common/cal_record_instance_normal.c

   1 /*
   2  * Calendar Service
   3  *
   4  * Copyright (c) 2012 - 2015 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20 #include <stdlib.h>
  21 #include <stdbool.h>
  22 #include <string.h>
  23
  24 #include "cal_internal.h"
  25 #include "cal_typedef.h"
  26 #include "cal_view.h"
  27 #include "cal_record.h"
  28 #include "cal_utils.h"
  29
  30 static int _cal_record_instance_normal_create(calendar_record_h* out_record);
  31 static int _cal_record_instance_normal_destroy(calendar_record_h record, bool delete_child);
  32 static int _cal_record_instance_normal_clone(calendar_record_h record, calendar_record_h* out_record);
  33 static int _cal_record_instance_normal_get_str(calendar_record_h record, unsigned int property_id, char** out_str);
  34 static int _cal_record_instance_normal_get_str_p(calendar_record_h record, unsigned int property_id, char** out_str);
  35 static int _cal_record_instance_normal_get_int(calendar_record_h record, unsigned int property_id, int* out_value);
  36 static int _cal_record_instance_normal_get_double(calendar_record_h record, unsigned int property_id, double* out_value);
  37 static int _cal_record_instance_normal_get_lli(calendar_record_h record, unsigned int property_id, long long int* out_value);
  38 static int _cal_record_instance_normal_get_caltime(calendar_record_h record, unsigned int property_id, calendar_time_s* out_value);
  39 static int _cal_record_instance_normal_set_str(calendar_record_h record, unsigned int property_id, const char* value);
  40 static int _cal_record_instance_normal_set_int(calendar_record_h record, unsigned int property_id, int value);
  41 static int _cal_record_instance_normal_set_double(calendar_record_h record, unsigned int property_id, double value);
  42 static int _cal_record_instance_normal_set_caltime(calendar_record_h record, unsigned int property_id, calendar_time_s value);
  43
  44 cal_record_plugin_cb_s cal_record_instance_normal_plugin_cb = {
  45         .create = _cal_record_instance_normal_create,
  46         .destroy = _cal_record_instance_normal_destroy,
  47         .clone = _cal_record_instance_normal_clone,
  48         .get_str = _cal_record_instance_normal_get_str,
  49         .get_str_p = _cal_record_instance_normal_get_str_p,
  50         .get_int = _cal_record_instance_normal_get_int,
  51         .get_double = _cal_record_instance_normal_get_double,
  52         .get_lli = _cal_record_instance_normal_get_lli,
  53         .get_caltime = _cal_record_instance_normal_get_caltime,
  54         .set_str = _cal_record_instance_normal_set_str,
  55         .set_int = _cal_record_instance_normal_set_int,
  56         .set_double = _cal_record_instance_normal_set_double,
  57         .set_lli = NULL,
  58         .set_caltime = _cal_record_instance_normal_set_caltime,
  59         .add_child_record = NULL,
  60         .remove_child_record = NULL,
  61         .get_child_record_count = NULL,
  62         .get_child_record_at_p = NULL,
  63         .clone_child_record_list = NULL
  64 };
  65
  66 static void _cal_record_instance_normal_struct_init(cal_instance_normal_s* record)
  67 {
  68         memset(record, 0, sizeof(cal_instance_normal_s));
  69
  70         record->event_status = CALENDAR_EVENT_STATUS_NONE;
  71         record->calendar_id = DEFAULT_EVENT_CALENDAR_BOOK_ID;
  72         record->event_id = CAL_INVALID_ID;
  73
  74         record->busy_status = 2;
  75         record->summary = NULL;
  76         record->description = NULL;
  77         record->location = NULL;
  78
  79         record->latitude = 1000; /* set default 1000 out of range(-180 ~ 180) */
  80         record->longitude = 1000; /* set default 1000 out of range(-180 ~ 180) */
  81
  82         return ;
  83 }
  84
  85 static int _cal_record_instance_normal_create(calendar_record_h* out_record)
  86 {
  87         cal_instance_normal_s *temp = NULL;
  88         int ret = CALENDAR_ERROR_NONE;
  89
  90         temp = calloc(1, sizeof(cal_instance_normal_s));
  91         RETVM_IF(NULL == temp, CALENDAR_ERROR_OUT_OF_MEMORY, "calloc() Fail");
  92
  93         _cal_record_instance_normal_struct_init(temp);
  94
  95         *out_record = (calendar_record_h)temp;
  96
  97         return ret;
  98 }
  99
 100 static void _cal_record_instance_normal_struct_free(cal_instance_normal_s *record)
 101 {
 102         CAL_FREE(record->summary);
 103         CAL_FREE(record->description);
 104         CAL_FREE(record->location);
 105         CAL_FREE(record->sync_data1);
 106
 107         CAL_FREE(record);
 108 }
 109
 110 static int _cal_record_instance_normal_destroy(calendar_record_h record, bool delete_child)
 111 {
 112         cal_instance_normal_s *temp = (cal_instance_normal_s*)(record);
 113
 114         _cal_record_instance_normal_struct_free(temp);
 115
 116         return CALENDAR_ERROR_NONE;
 117 }
 118
 119 static int _cal_record_instance_normal_clone(calendar_record_h record, calendar_record_h* out_record)
 120 {
 121         cal_instance_normal_s *out_data = NULL;
 122         cal_instance_normal_s *src_data = NULL;
 123
 124         src_data = (cal_instance_normal_s*)(record);
 125
 126         out_data = calloc(1, sizeof(cal_instance_normal_s));
 127         RETVM_IF(NULL == out_data, CALENDAR_ERROR_OUT_OF_MEMORY, "calloc() Fail");
 128
 129         CAL_RECORD_COPY_COMMON(&(out_data->common), &(src_data->common));
 130
 131         out_data->event_id = src_data->event_id;
 132         out_data->calendar_id = src_data->calendar_id;
 133         out_data->start = src_data->start;
 134         out_data->end = src_data->end;
 135         out_data->summary = cal_strdup(src_data->summary);
 136         out_data->description = cal_strdup(src_data->description);
 137         out_data->location = cal_strdup(src_data->location);
 138         out_data->busy_status = src_data->busy_status;
 139         out_data->event_status = src_data->event_status;
 140         out_data->priority = src_data->priority;
 141         out_data->sensitivity = src_data->sensitivity;
 142         out_data->has_rrule = src_data->has_rrule;
 143         out_data->latitude = src_data->latitude;
 144         out_data->longitude = src_data->longitude;
 145         out_data->has_alarm = src_data->has_alarm;
 146         out_data->original_event_id = src_data->original_event_id;
 147         out_data->last_mod = src_data->last_mod;
 148         out_data->sync_data1 = cal_strdup(src_data->sync_data1);
 149
 150         *out_record = (calendar_record_h)out_data;
 151
 152         return CALENDAR_ERROR_NONE;
 153 }
 154
 155 static int _cal_record_instance_normal_get_str(calendar_record_h record, unsigned int property_id, char** out_str)
 156 {
 157         cal_instance_normal_s *rec = (cal_instance_normal_s*)(record);
 158         switch (property_id) {
 159         case CAL_PROPERTY_INSTANCE_NORMAL_SUMMARY:
 160                 *out_str = cal_strdup(rec->summary);
 161                 break;
 162         case CAL_PROPERTY_INSTANCE_NORMAL_DESCRIPTION:
 163                 *out_str = cal_strdup(rec->description);
 164                 break;
 165         case CAL_PROPERTY_INSTANCE_NORMAL_LOCATION:
 166                 *out_str = cal_strdup(rec->location);
 167                 break;
 168         case CAL_PROPERTY_INSTANCE_NORMAL_SYNC_DATA1:
 169                 *out_str = cal_strdup(rec->sync_data1);
 170                 break;
 171         default:
 172                 ERR("invalid parameter (property:0x%x)", property_id);
 173                 return CALENDAR_ERROR_INVALID_PARAMETER;
 174         }
 175
 176         return CALENDAR_ERROR_NONE;
 177 }
 178
 179 static int _cal_record_instance_normal_get_str_p(calendar_record_h record, unsigned int property_id, char** out_str)
 180 {
 181         cal_instance_normal_s *rec = (cal_instance_normal_s*)(record);
 182         switch (property_id) {
 183         case CAL_PROPERTY_INSTANCE_NORMAL_SUMMARY:
 184                 *out_str = (rec->summary);
 185                 break;
 186         case CAL_PROPERTY_INSTANCE_NORMAL_DESCRIPTION:
 187                 *out_str = (rec->description);
 188                 break;
 189         case CAL_PROPERTY_INSTANCE_NORMAL_LOCATION:
 190                 *out_str = (rec->location);
 191                 break;
 192         case CAL_PROPERTY_INSTANCE_NORMAL_SYNC_DATA1:
 193                 *out_str = (rec->sync_data1);
 194                 break;
 195         default:
 196                 ERR("invalid parameter (property:0x%x)", property_id);
 197                 return CALENDAR_ERROR_INVALID_PARAMETER;
 198         }
 199
 200         return CALENDAR_ERROR_NONE;
 201 }
 202
 203 static int _cal_record_instance_normal_get_int(calendar_record_h record, unsigned int property_id, int* out_value)
 204 {
 205         cal_instance_normal_s *rec = (cal_instance_normal_s*)(record);
 206         switch (property_id) {
 207         case CAL_PROPERTY_INSTANCE_NORMAL_EVENT_ID:
 208                 *out_value = (rec->event_id);
 209                 break;
 210         case CAL_PROPERTY_INSTANCE_NORMAL_CALENDAR_ID:
 211                 *out_value = (rec->calendar_id);
 212                 break;
 213         case CAL_PROPERTY_INSTANCE_NORMAL_BUSY_STATUS:
 214                 *out_value = (rec->busy_status);
 215                 break;
 216         case CAL_PROPERTY_INSTANCE_NORMAL_EVENT_STATUS:
 217                 *out_value = (rec->event_status);
 218                 break;
 219         case CAL_PROPERTY_INSTANCE_NORMAL_PRIORITY:
 220                 *out_value = (rec->priority);
 221                 break;
 222         case CAL_PROPERTY_INSTANCE_NORMAL_SENSITIVITY:
 223                 *out_value = (rec->sensitivity);
 224                 break;
 225         case CAL_PROPERTY_INSTANCE_NORMAL_HAS_RRULE:
 226                 *out_value = (rec->has_rrule);
 227                 break;
 228         case CAL_PROPERTY_INSTANCE_NORMAL_HAS_ALARM:
 229                 *out_value = (rec->has_alarm);
 230                 break;
 231         case CAL_PROPERTY_INSTANCE_NORMAL_ORIGINAL_EVENT_ID:
 232                 *out_value = (rec->original_event_id);
 233                 break;
 234         default:
 235                 ERR("invalid parameter (property:0x%x)", property_id);
 236                 return CALENDAR_ERROR_INVALID_PARAMETER;
 237         }
 238
 239         return CALENDAR_ERROR_NONE;
 240 }
 241
 242 static int _cal_record_instance_normal_get_double(calendar_record_h record, unsigned int property_id, double* out_value)
 243 {
 244         cal_instance_normal_s *rec = (cal_instance_normal_s*)(record);
 245         switch (property_id) {
 246         case CAL_PROPERTY_INSTANCE_NORMAL_LATITUDE:
 247                 *out_value = (rec->latitude);
 248                 break;
 249         case CAL_PROPERTY_INSTANCE_NORMAL_LONGITUDE:
 250                 *out_value = (rec->longitude);
 251                 break;
 252
 253         default:
 254                 ERR("invalid parameter (property:0x%x)", property_id);
 255                 return CALENDAR_ERROR_INVALID_PARAMETER;
 256         }
 257
 258         return CALENDAR_ERROR_NONE;
 259 }
 260
 261 static int _cal_record_instance_normal_get_lli(calendar_record_h record, unsigned int property_id, long long int* out_value)
 262 {
 263         cal_instance_normal_s *rec = (cal_instance_normal_s*)(record);
 264         switch (property_id) {
 265         case CAL_PROPERTY_INSTANCE_NORMAL_LAST_MODIFIED_TIME:
 266                 *out_value = (rec->last_mod);
 267                 break;
 268         default:
 269                 return CALENDAR_ERROR_INVALID_PARAMETER;
 270         }
 271
 272         return CALENDAR_ERROR_NONE;
 273 }
 274
 275 static int _cal_record_instance_normal_get_caltime(calendar_record_h record, unsigned int property_id, calendar_time_s* out_value)
 276 {
 277         cal_instance_normal_s *rec = (cal_instance_normal_s*)(record);
 278         switch (property_id) {
 279         case CAL_PROPERTY_INSTANCE_NORMAL_START:
 280                 *out_value = rec->start;
 281                 break;
 282         case CAL_PROPERTY_INSTANCE_NORMAL_END:
 283                 *out_value = rec->end;
 284                 break;
 285         default:
 286                 ERR("invalid parameter (property:0x%x)", property_id);
 287                 return CALENDAR_ERROR_INVALID_PARAMETER;
 288         }
 289
 290         return CALENDAR_ERROR_NONE;
 291 }
 292
 293 static int _cal_record_instance_normal_set_str(calendar_record_h record, unsigned int property_id, const char* value)
 294 {
 295         cal_instance_normal_s *rec = (cal_instance_normal_s*)(record);
 296         switch (property_id) {
 297         case CAL_PROPERTY_INSTANCE_NORMAL_SUMMARY:
 298                 CAL_FREE(rec->summary);
 299                 rec->summary = cal_strdup(value);
 300                 break;
 301         case CAL_PROPERTY_INSTANCE_NORMAL_DESCRIPTION:
 302                 CAL_FREE(rec->description);
 303                 rec->description = cal_strdup(value);
 304                 break;
 305         case CAL_PROPERTY_INSTANCE_NORMAL_LOCATION:
 306                 CAL_FREE(rec->location);
 307                 rec->location = cal_strdup(value);
 308                 break;
 309         case CAL_PROPERTY_INSTANCE_NORMAL_SYNC_DATA1:
 310                 CAL_FREE(rec->sync_data1);
 311                 rec->sync_data1 = cal_strdup(value);
 312                 break;
 313         default:
 314                 ERR("invalid parameter (property:0x%x)", property_id);
 315                 return CALENDAR_ERROR_INVALID_PARAMETER;
 316         }
 317
 318         return CALENDAR_ERROR_NONE;
 319 }
 320
 321 static int _cal_record_instance_normal_set_int(calendar_record_h record, unsigned int property_id, int value)
 322 {
 323         cal_instance_normal_s *rec = (cal_instance_normal_s*)(record);
 324         switch (property_id) {
 325         case CAL_PROPERTY_INSTANCE_NORMAL_EVENT_ID:
 326                 (rec->event_id) = value;
 327                 break;
 328         case CAL_PROPERTY_INSTANCE_NORMAL_CALENDAR_ID:
 329                 (rec->calendar_id) = value;
 330                 break;
 331         case CAL_PROPERTY_INSTANCE_NORMAL_BUSY_STATUS:
 332                 (rec->busy_status) = value;
 333                 break;
 334         case CAL_PROPERTY_INSTANCE_NORMAL_EVENT_STATUS:
 335                 (rec->event_status) = value;
 336                 break;
 337         case CAL_PROPERTY_INSTANCE_NORMAL_PRIORITY:
 338                 (rec->priority) = value;
 339                 break;
 340         case CAL_PROPERTY_INSTANCE_NORMAL_SENSITIVITY:
 341                 (rec->sensitivity) = value;
 342                 break;
 343         case CAL_PROPERTY_INSTANCE_NORMAL_HAS_RRULE:
 344                 (rec->has_rrule) = value;
 345                 break;
 346         case CAL_PROPERTY_INSTANCE_NORMAL_HAS_ALARM:
 347                 (rec->has_alarm) = value;
 348                 break;
 349         case CAL_PROPERTY_INSTANCE_NORMAL_ORIGINAL_EVENT_ID:
 350                 (rec->original_event_id) = value;
 351                 break;
 352         default:
 353                 ERR("invalid parameter (property:0x%x)", property_id);
 354                 return CALENDAR_ERROR_INVALID_PARAMETER;
 355         }
 356
 357         return CALENDAR_ERROR_NONE;
 358 }
 359
 360 static int _cal_record_instance_normal_set_double(calendar_record_h record, unsigned int property_id, double value)
 361 {
 362         cal_instance_normal_s *rec = (cal_instance_normal_s*)(record);
 363         switch (property_id) {
 364         case CAL_PROPERTY_INSTANCE_NORMAL_LATITUDE:
 365                 (rec->latitude) = value;
 366                 break;
 367         case CAL_PROPERTY_INSTANCE_NORMAL_LONGITUDE:
 368                 (rec->longitude) = value;
 369                 break;
 370
 371         default:
 372                 ERR("invalid parameter (property:0x%x)", property_id);
 373                 return CALENDAR_ERROR_INVALID_PARAMETER;
 374         }
 375
 376         return CALENDAR_ERROR_NONE;
 377 }
 378
 379 static int _cal_record_instance_normal_set_caltime(calendar_record_h record, unsigned int property_id, calendar_time_s value)
 380 {
 381         cal_instance_normal_s *rec = (cal_instance_normal_s*)(record);
 382         switch (property_id) {
 383         case CAL_PROPERTY_INSTANCE_NORMAL_START:
 384                 rec->start = value;
 385                 break;
 386         case CAL_PROPERTY_INSTANCE_NORMAL_END:
 387                 rec->end = value;
 388                 break;
 389         default:
 390                 ERR("invalid parameter (property:0x%x)", property_id);
 391                 return CALENDAR_ERROR_INVALID_PARAMETER;
 392         }
 393
 394         return CALENDAR_ERROR_NONE;
 395 }