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                 /* LCOV_EXCL_START */
 173                 ERR("invalid parameter (property:0x%x)", property_id);
 174                 return CALENDAR_ERROR_INVALID_PARAMETER;
 175                 /* LCOV_EXCL_STOP */
 176         }
 177
 178         return CALENDAR_ERROR_NONE;
 179 }
 180
 181 static int _cal_record_instance_normal_get_str_p(calendar_record_h record, unsigned int property_id, char** out_str)
 182 {
 183         cal_instance_normal_s *rec = (cal_instance_normal_s*)(record);
 184         switch (property_id) {
 185         case CAL_PROPERTY_INSTANCE_NORMAL_SUMMARY:
 186                 *out_str = (rec->summary);
 187                 break;
 188         case CAL_PROPERTY_INSTANCE_NORMAL_DESCRIPTION:
 189                 *out_str = (rec->description);
 190                 break;
 191         case CAL_PROPERTY_INSTANCE_NORMAL_LOCATION:
 192                 *out_str = (rec->location);
 193                 break;
 194         case CAL_PROPERTY_INSTANCE_NORMAL_SYNC_DATA1:
 195                 *out_str = (rec->sync_data1);
 196                 break;
 197         default:
 198                 /* LCOV_EXCL_START */
 199                 ERR("invalid parameter (property:0x%x)", property_id);
 200                 return CALENDAR_ERROR_INVALID_PARAMETER;
 201                 /* LCOV_EXCL_STOP */
 202         }
 203
 204         return CALENDAR_ERROR_NONE;
 205 }
 206
 207 static int _cal_record_instance_normal_get_int(calendar_record_h record, unsigned int property_id, int* out_value)
 208 {
 209         cal_instance_normal_s *rec = (cal_instance_normal_s*)(record);
 210         switch (property_id) {
 211         case CAL_PROPERTY_INSTANCE_NORMAL_EVENT_ID:
 212                 *out_value = (rec->event_id);
 213                 break;
 214         case CAL_PROPERTY_INSTANCE_NORMAL_CALENDAR_ID:
 215                 *out_value = (rec->calendar_id);
 216                 break;
 217         case CAL_PROPERTY_INSTANCE_NORMAL_BUSY_STATUS:
 218                 *out_value = (rec->busy_status);
 219                 break;
 220         case CAL_PROPERTY_INSTANCE_NORMAL_EVENT_STATUS:
 221                 *out_value = (rec->event_status);
 222                 break;
 223         case CAL_PROPERTY_INSTANCE_NORMAL_PRIORITY:
 224                 *out_value = (rec->priority);
 225                 break;
 226         case CAL_PROPERTY_INSTANCE_NORMAL_SENSITIVITY:
 227                 *out_value = (rec->sensitivity);
 228                 break;
 229         case CAL_PROPERTY_INSTANCE_NORMAL_HAS_RRULE:
 230                 *out_value = (rec->has_rrule);
 231                 break;
 232         case CAL_PROPERTY_INSTANCE_NORMAL_HAS_ALARM:
 233                 *out_value = (rec->has_alarm);
 234                 break;
 235         case CAL_PROPERTY_INSTANCE_NORMAL_ORIGINAL_EVENT_ID:
 236                 *out_value = (rec->original_event_id);
 237                 break;
 238         default:
 239                 /* LCOV_EXCL_START */
 240                 ERR("invalid parameter (property:0x%x)", property_id);
 241                 return CALENDAR_ERROR_INVALID_PARAMETER;
 242                 /* LCOV_EXCL_STOP */
 243         }
 244
 245         return CALENDAR_ERROR_NONE;
 246 }
 247
 248 static int _cal_record_instance_normal_get_double(calendar_record_h record, unsigned int property_id, double* out_value)
 249 {
 250         cal_instance_normal_s *rec = (cal_instance_normal_s*)(record);
 251         switch (property_id) {
 252         case CAL_PROPERTY_INSTANCE_NORMAL_LATITUDE:
 253                 *out_value = (rec->latitude);
 254                 break;
 255         case CAL_PROPERTY_INSTANCE_NORMAL_LONGITUDE:
 256                 *out_value = (rec->longitude);
 257                 break;
 258
 259         default:
 260                 /* LCOV_EXCL_START */
 261                 ERR("invalid parameter (property:0x%x)", property_id);
 262                 return CALENDAR_ERROR_INVALID_PARAMETER;
 263                 /* LCOV_EXCL_STOP */
 264         }
 265
 266         return CALENDAR_ERROR_NONE;
 267 }
 268
 269 static int _cal_record_instance_normal_get_lli(calendar_record_h record, unsigned int property_id, long long int* out_value)
 270 {
 271         cal_instance_normal_s *rec = (cal_instance_normal_s*)(record);
 272         switch (property_id) {
 273         case CAL_PROPERTY_INSTANCE_NORMAL_LAST_MODIFIED_TIME:
 274                 *out_value = (rec->last_mod);
 275                 break;
 276         default:
 277                 return CALENDAR_ERROR_INVALID_PARAMETER;
 278                 /* LCOV_EXCL_STOP */
 279         }
 280
 281         return CALENDAR_ERROR_NONE;
 282 }
 283
 284 static int _cal_record_instance_normal_get_caltime(calendar_record_h record, unsigned int property_id, calendar_time_s* out_value)
 285 {
 286         cal_instance_normal_s *rec = (cal_instance_normal_s*)(record);
 287         switch (property_id) {
 288         case CAL_PROPERTY_INSTANCE_NORMAL_START:
 289                 *out_value = rec->start;
 290                 break;
 291         case CAL_PROPERTY_INSTANCE_NORMAL_END:
 292                 *out_value = rec->end;
 293                 break;
 294         default:
 295                 /* LCOV_EXCL_START */
 296                 ERR("invalid parameter (property:0x%x)", property_id);
 297                 return CALENDAR_ERROR_INVALID_PARAMETER;
 298                 /* LCOV_EXCL_STOP */
 299         }
 300
 301         return CALENDAR_ERROR_NONE;
 302 }
 303
 304 static int _cal_record_instance_normal_set_str(calendar_record_h record, unsigned int property_id, const char* value)
 305 {
 306         cal_instance_normal_s *rec = (cal_instance_normal_s*)(record);
 307         switch (property_id) {
 308         case CAL_PROPERTY_INSTANCE_NORMAL_SUMMARY:
 309                 CAL_FREE(rec->summary);
 310                 rec->summary = cal_strdup(value);
 311                 break;
 312         case CAL_PROPERTY_INSTANCE_NORMAL_DESCRIPTION:
 313                 CAL_FREE(rec->description);
 314                 rec->description = cal_strdup(value);
 315                 break;
 316         case CAL_PROPERTY_INSTANCE_NORMAL_LOCATION:
 317                 CAL_FREE(rec->location);
 318                 rec->location = cal_strdup(value);
 319                 break;
 320         case CAL_PROPERTY_INSTANCE_NORMAL_SYNC_DATA1:
 321                 CAL_FREE(rec->sync_data1);
 322                 rec->sync_data1 = cal_strdup(value);
 323                 break;
 324         default:
 325                 /* LCOV_EXCL_START */
 326                 ERR("invalid parameter (property:0x%x)", property_id);
 327                 return CALENDAR_ERROR_INVALID_PARAMETER;
 328                 /* LCOV_EXCL_STOP */
 329         }
 330
 331         return CALENDAR_ERROR_NONE;
 332 }
 333
 334 static int _cal_record_instance_normal_set_int(calendar_record_h record, unsigned int property_id, int value)
 335 {
 336         cal_instance_normal_s *rec = (cal_instance_normal_s*)(record);
 337         switch (property_id) {
 338         case CAL_PROPERTY_INSTANCE_NORMAL_EVENT_ID:
 339                 (rec->event_id) = value;
 340                 break;
 341         case CAL_PROPERTY_INSTANCE_NORMAL_CALENDAR_ID:
 342                 (rec->calendar_id) = value;
 343                 break;
 344         case CAL_PROPERTY_INSTANCE_NORMAL_BUSY_STATUS:
 345                 (rec->busy_status) = value;
 346                 break;
 347         case CAL_PROPERTY_INSTANCE_NORMAL_EVENT_STATUS:
 348                 (rec->event_status) = value;
 349                 break;
 350         case CAL_PROPERTY_INSTANCE_NORMAL_PRIORITY:
 351                 (rec->priority) = value;
 352                 break;
 353         case CAL_PROPERTY_INSTANCE_NORMAL_SENSITIVITY:
 354                 (rec->sensitivity) = value;
 355                 break;
 356         case CAL_PROPERTY_INSTANCE_NORMAL_HAS_RRULE:
 357                 (rec->has_rrule) = value;
 358                 break;
 359         case CAL_PROPERTY_INSTANCE_NORMAL_HAS_ALARM:
 360                 (rec->has_alarm) = value;
 361                 break;
 362         case CAL_PROPERTY_INSTANCE_NORMAL_ORIGINAL_EVENT_ID:
 363                 (rec->original_event_id) = value;
 364                 break;
 365         default:
 366                 /* LCOV_EXCL_START */
 367                 ERR("invalid parameter (property:0x%x)", property_id);
 368                 return CALENDAR_ERROR_INVALID_PARAMETER;
 369                 /* LCOV_EXCL_STOP */
 370         }
 371
 372         return CALENDAR_ERROR_NONE;
 373 }
 374
 375 static int _cal_record_instance_normal_set_double(calendar_record_h record, unsigned int property_id, double value)
 376 {
 377         cal_instance_normal_s *rec = (cal_instance_normal_s*)(record);
 378         switch (property_id) {
 379         case CAL_PROPERTY_INSTANCE_NORMAL_LATITUDE:
 380                 (rec->latitude) = value;
 381                 break;
 382         case CAL_PROPERTY_INSTANCE_NORMAL_LONGITUDE:
 383                 (rec->longitude) = value;
 384                 break;
 385
 386         default:
 387                 /* LCOV_EXCL_START */
 388                 ERR("invalid parameter (property:0x%x)", property_id);
 389                 return CALENDAR_ERROR_INVALID_PARAMETER;
 390                 /* LCOV_EXCL_STOP */
 391         }
 392
 393         return CALENDAR_ERROR_NONE;
 394 }
 395
 396 static int _cal_record_instance_normal_set_caltime(calendar_record_h record, unsigned int property_id, calendar_time_s value)
 397 {
 398         cal_instance_normal_s *rec = (cal_instance_normal_s*)(record);
 399         switch (property_id) {
 400         case CAL_PROPERTY_INSTANCE_NORMAL_START:
 401                 rec->start = value;
 402                 break;
 403         case CAL_PROPERTY_INSTANCE_NORMAL_END:
 404                 rec->end = value;
 405                 break;
 406         default:
 407                 /* LCOV_EXCL_START */
 408                 ERR("invalid parameter (property:0x%x)", property_id);
 409                 return CALENDAR_ERROR_INVALID_PARAMETER;
 410                 /* LCOV_EXCL_STOP */
 411         }
 412
 413         return CALENDAR_ERROR_NONE;
 414 }