common/cal-svc.c

   1 /*
   2   *
   3   *  Copyright 2012  Samsung Electronics Co., Ltd
   4   *
   5   *  Licensed under the Flora License, Version 1.0 (the "License");
   6   *  you may not use this file except in compliance with the License.
   7   *  You may obtain a copy of the License at
   8   *
   9   *       http://www.tizenopensource.org/license
  10   *
  11   *  Unless required by applicable law or agreed to in writing, software
  12   *  distributed under the License is distributed on an "AS IS" BASIS,
  13   *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14   *  See the License for the specific language governing permissions and
  15   *  limitations under the License.
  16   */
  17
  18 #include "cld.h"
  19
  20 static Calendar_color def_color[] = {
  21         {90, 167, 48, 255,},
  22         {221, 129, 0, 255,},
  23         {0, 182, 252, 255,},
  24         {122, 52, 122, 255,},
  25         {22, 139, 121, 255,},
  26         {40, 81, 163, 255,},
  27 };
  28
  29 int * _calendar_svc_get_simple_cs(int acct_id, struct tm *start, struct tm *end)
  30 {
  31         CAL_FN_START;
  32
  33         int *month = calloc(31, sizeof(int));
  34         c_retv_if(!month, NULL);
  35
  36         int i = 0;
  37
  38         struct tm tm_start, tm_end;
  39         long long int lli_start, lli_end;
  40
  41         cal_util_convert_tm_to_lli(NULL, start, &lli_start);
  42         cal_util_convert_tm_to_lli(NULL, end, &lli_end);
  43
  44         cal_struct *cs = NULL;
  45         cal_iter *iter = NULL;
  46
  47         int r = calendar_svc_event_get_normal_list_by_period(-1, CALS_LIST_PERIOD_NORMAL_OSP, lli_start, lli_end, &iter);
  48         c_warn_if(r != CAL_SUCCESS, "calendar_svc_event_get_normal_list_by_period() is failed(%d)", r);
  49         c_warn_if(!iter, "iter is NULL");
  50
  51         while ((r = CALENDAR_SVC_ITER_NEXT(iter)) == CAL_SUCCESS) {
  52                 cs = NULL;
  53                 r = CALENDAR_SVC_ITER_GET_INFO(iter, &cs);
  54                 if (r != CAL_SUCCESS)
  55                         break;
  56
  57                 lli_start = CALENDAR_SVC_STRUCT_GET_LLI(cs, CALS_VALUE_LLI_DTSTART_UTIME);
  58                 lli_end = CALENDAR_SVC_STRUCT_GET_LLI(cs, CALS_VALUE_LLI_DTEND_UTIME);
  59
  60                 cal_util_convert_lli_to_tm(NULL, lli_start, &tm_start);
  61                 cal_util_convert_lli_to_tm(NULL, lli_end, &tm_end);
  62
  63                 for (i = tm_start.tm_mday; i <= tm_end.tm_mday; i++)
  64                         month[i - 1] += 1;
  65         }
  66
  67         r = calendar_svc_event_get_allday_list_by_period(-1, CALS_LIST_PERIOD_ALLDAY_OSP,
  68                 start->tm_year + 1900, start->tm_mon + 1, start->tm_mday,
  69                 end->tm_year + 1900, end->tm_mon + 1, end->tm_mday,
  70                 &iter);
  71         c_warn_if(r != CAL_SUCCESS, "calendar_svc_event_get_allday_list_by_period() is failed(%d)", r);
  72         c_warn_if(!iter, "iter is NULL");
  73
  74         while ((r = CALENDAR_SVC_ITER_NEXT(iter)) == CAL_SUCCESS) {
  75                 cs = NULL;
  76                 r = CALENDAR_SVC_ITER_GET_INFO(iter, &cs);
  77                 if (r != CAL_SUCCESS)
  78                         break;
  79
  80                 tm_start.tm_mday = CALENDAR_SVC_STRUCT_GET_INT(cs, CALS_VALUE_INT_DTSTART_MDAY);
  81                 tm_end.tm_mday = CALENDAR_SVC_STRUCT_GET_INT(cs, CALS_VALUE_INT_DTEND_MDAY);
  82
  83                 for (i = tm_start.tm_mday; i <= tm_end.tm_mday; i++)
  84                         month[i - 1] += 1;
  85         }
  86
  87         CAL_FN_END;
  88
  89         return month;
  90 }
  91
  92 void _calendar_svc_free_cslist(Eina_List **h)
  93 {
  94         c_ret_if(!h);
  95         c_ret_if(!*h);
  96
  97         cal_struct *cs = NULL;
  98         Eina_List *l = NULL;
  99
 100         EINA_LIST_FOREACH(*h, l, cs) {
 101                 if (cs)
 102                         CALENDAR_SVC_STRUCT_FREE(&cs);
 103         }
 104
 105         *h = eina_list_free(*h);
 106         *h = NULL;
 107 }
 108
 109 int _calendar_svc_get_account_visibility(int account_id)
 110 {
 111         cal_struct* cs = NULL;
 112         Eina_List* list = NULL;
 113         Eina_List* l = NULL;
 114         int r = 0;
 115
 116         list = CALENDAR_SVC_GET_ALL(account_id, ALL_CALENDAR_ID, CAL_STRUCT_CALENDAR);
 117         EINA_LIST_FOREACH(list,l,cs)
 118         {
 119                 r = CALENDAR_SVC_STRUCT_GET_INT(cs, CAL_TABLE_INT_VISIBILITY);
 120                 if(r == 1)
 121                         break;
 122         }
 123         if(r != 0 && r!=1)
 124         {
 125                 //DBG("CALENDAR_SVC_GET_ACCOUNT_VISIBILITY fail : %d\n", r);
 126                 return -1;
 127         }
 128         return r;
 129 }
 130
 131 void _calendar_svc_set_account_visibility(int account_id, int value)
 132 {
 133         cal_struct* cs = NULL;
 134         Eina_List* list = NULL;
 135         Eina_List* l = NULL;
 136         int r = 0;
 137
 138         list = CALENDAR_SVC_GET_ALL(account_id, ALL_CALENDAR_ID, CAL_STRUCT_CALENDAR);
 139         EINA_LIST_FOREACH(list,l,cs)
 140         {
 141                 r = CALENDAR_SVC_STRUCT_SET_INT(cs, CAL_TABLE_INT_VISIBILITY, value);
 142                 if(r != 0)
 143                 {
 144                         //DBG("\n calendar_svc_struct_set_int fail : %d \n", r);
 145                         return;
 146                 }
 147
 148                 r = CALENDAR_SVC_UPDATE(cs);
 149                 if(r != 0)
 150                 {
 151                         //DBG("\n CALENDAR_SVC_UPDATE fail : %d \n", r);
 152                         return;
 153                 }
 154         }
 155 }
 156
 157 void _calendar_svc_set_calendar_visibility(cal_struct* cs, int value)
 158 {
 159         int r = 0;
 160         int account_id = 0;
 161         int cal_id = 0;
 162
 163         r = CALENDAR_SVC_STRUCT_SET_INT(cs, CAL_TABLE_INT_VISIBILITY, value);
 164         if(r)
 165         {
 166                 DBG("\n CALENDAR_SVC_STRUCT_SET_INT fail : %d \n", r);
 167                 return;
 168         }
 169         account_id = CALENDAR_SVC_STRUCT_GET_INT(cs,CAL_TABLE_INT_ACCOUNT_ID);
 170         cal_id = CALENDAR_SVC_STRUCT_GET_INT(cs,CAL_TABLE_INT_INDEX);
 171 }
 172
 173 int _calendar_svc_get_calendar_visibility(cal_struct* cs)
 174 {
 175         int r = 0;
 176         int account_id = 0;
 177         int cal_id = 0;
 178
 179         r = CALENDAR_SVC_STRUCT_GET_INT(cs, CAL_TABLE_INT_VISIBILITY);
 180         account_id = CALENDAR_SVC_STRUCT_GET_INT(cs,CAL_TABLE_INT_ACCOUNT_ID);
 181         cal_id = CALENDAR_SVC_STRUCT_GET_INT(cs,CAL_TABLE_INT_INDEX);
 182         return r;
 183 }
 184
 185 //cal_calendar_svc_find_event is used only in alarm call back
 186 Eina_List* _calendar_svc_find_event(int acct_id, const char *field, const void *val)
 187 {
 188         Eina_List *csl;
 189         int r;
 190         cal_struct *cs;
 191         cal_iter *it;
 192         time_t t = time(NULL);
 193
 194         struct tm tm;
 195         struct tm* tmp;
 196
 197         tmp = localtime_r((const time_t*)&t, &tm);
 198         if(!tmp)
 199         {
 200                 ERR("localtime_r return null");
 201                 return NULL;
 202         }
 203
 204         it = NULL;
 205         r = CALENDAR_SVC_FIND_EVENT_LIST(acct_id, field, val, &it);
 206         if (r != CAL_SUCCESS)
 207                 return NULL;
 208
 209         csl = NULL;
 210         while (CALENDAR_SVC_ITER_NEXT(it) == CAL_SUCCESS) {
 211                 cs = NULL;
 212                 r = CALENDAR_SVC_ITER_GET_INFO(it, &cs);
 213                 if (r != CAL_SUCCESS)
 214                         break;
 215
 216                 csl = eina_list_append(csl, cs);
 217         }
 218
 219         CALENDAR_SVC_ITER_REMOVE(&it);
 220
 221         return csl;
 222 }
 223
 224 Eina_List* _calendar_svc_get_calendars_with_account(int account_id, void* at)
 225 {
 226         Eina_List *csl = NULL;
 227         cal_struct *cal = NULL;
 228
 229         Eina_List *list = CALENDAR_SVC_GET_ALL(account_id, ALL_CALENDAR_ID, CAL_STRUCT_CALENDAR);
 230         c_retv_if(!list, NULL);
 231
 232         Eina_List *l = NULL;
 233
 234         EINA_LIST_FOREACH(list, l, cal) {
 235                 struct _cs *cs = calloc(1, sizeof(struct _cs));
 236                 c_retv_if(!cs, NULL);
 237
 238                 cs->cs = cal;
 239                 cs->at = at;
 240                 csl = eina_list_append(csl, cs);
 241         }
 242
 243         eina_list_free(list);
 244
 245         return csl;
 246 }
 247
 248 void _calendar_svc_set_calendar_color(cal_struct* cal, Calendar_color* color )
 249 {
 250         char buf[16] = {0,};
 251         int r;
 252         snprintf(buf, sizeof(buf), "%d.%d.%d.%d", color->red, color->green, color->blue, color->alpha);
 253
 254         r = CALENDAR_SVC_STRUCT_SET_STR(cal, CAL_TABLE_TXT_COLOR, buf);
 255         if (r != CAL_SUCCESS)
 256         {
 257                 ERR("CALENDAR_SVC_STRUCT_SET_STR return %d", r);
 258                 return;
 259         }
 260 }
 261
 262 void _calendar_svc_get_calendar_color(cal_struct* cal, Calendar_color* calendar_color )
 263 {
 264         if(!cal || !calendar_color)
 265         {
 266                 ERR("parameter is NULL");
 267                 return;
 268         }
 269
 270         char* calendar = NULL;
 271         char* color = NULL;
 272         char* token = NULL;
 273         char* temp = NULL;
 274         int index = 0;
 275
 276         calendar = CALENDAR_SVC_STRUCT_GET_STR(cal, CAL_TABLE_TXT_COLOR);
 277
 278         color = CAL_STRDUP(calendar);
 279
 280         if (8 < CAL_STRLEN(color)) {
 281
 282                 token = strtok_r(color, ".", &temp);
 283                 if (token)
 284                         calendar_color->red = atoi(token);
 285                 else {
 286                         calendar_color->red = 0;
 287                         ERR("color : %s, token is NULL", calendar);
 288                 }
 289
 290                 token = strtok_r(NULL, ".", &temp);
 291                 if (token)
 292                         calendar_color->green = atoi(token);
 293                 else {
 294                         calendar_color->green = 0;
 295                         ERR("color : %s, token is NULL", calendar);
 296                 }
 297
 298                 token = strtok_r(NULL, ".", &temp);
 299                 if (token)
 300                         calendar_color->blue = atoi(token);
 301                 else {
 302                         calendar_color->blue = 0;
 303                         ERR("color : %s, token is NULL", calendar);
 304                 }
 305
 306                 token = strtok_r(NULL, ".", &temp);
 307                 if (token)
 308                         calendar_color->alpha = atoi(token);
 309                 else {
 310                         calendar_color->alpha = 255;
 311                         ERR("color : %s, token is NULL", calendar);
 312                 }
 313         } else{
 314
 315                 index = CALENDAR_SVC_STRUCT_GET_INT(cal, CAL_TABLE_INT_INDEX)%6;
 316
 317                 *calendar_color = def_color[index];
 318         }
 319
 320         free(color);
 321 }
 322
 323 void _calendar_svc_add_event_changed_callback(void(*callback)(void *), void *user_data)
 324 {
 325         c_retm_if(!callback, "callback is null");
 326         c_retm_if(!user_data, "user_data is null");
 327
 328         int ret = calendar_svc_subscribe_change(callback, user_data);
 329         c_retm_if(ret!= CAL_SUCCESS, "calendar_svc_subscribe_change() is failed");
 330 }
 331
 332 void _calendar_svc_del_event_changed_callback(void(*callback)(void *))
 333 {
 334         c_retm_if(!callback, "callback is null");
 335
 336         int ret = calendar_svc_unsubscribe_change(callback);
 337         c_retm_if(ret!= CAL_SUCCESS, "calendar_svc_unsubscribe_change() is failed");
 338 }
 339
 340 void _calendar_svc_add_calendar_changed_callback(const char *type, void(*callback)(void *), void *user_data)
 341 {
 342         c_retm_if(!callback, "callback is null");
 343         c_retm_if(!user_data, "user_data is null");
 344
 345         int ret = calendar_svc_subscribe_db_change(type, callback, user_data);
 346         c_retm_if(ret!= CAL_SUCCESS, "calendar_svc_subscribe_db_change() is failed");
 347 }
 348
 349 void _calendar_svc_del_calendar_changed_callback(const char *type, void(*callback)(void *))
 350 {
 351         c_retm_if(!callback, "callback is null");
 352
 353         int ret = calendar_svc_unsubscribe_db_change(type, callback);
 354         c_retm_if(ret!= CAL_SUCCESS, "calendar_svc_unsubscribe_db_change() is failed");
 355 }
 356
 357 Eina_Bool _calendar_svc_is_allday_event(cal_struct *schedule)
 358 {
 359         c_retv_if(!schedule, EINA_FALSE);
 360
 361         return CALENDAR_SVC_STRUCT_GET_INT(schedule, CALS_VALUE_INT_DTSTART_TYPE) == CALS_TIME_LOCALTIME;
 362 }
 363
 364 static void __calendar_svc_append_list_with_iter(Eina_List **list, cal_iter *iter)
 365 {
 366         c_ret_if(!list);
 367         c_ret_if(!iter);
 368
 369         cal_struct *cs = NULL;
 370
 371         while (CALENDAR_SVC_ITER_NEXT(iter) == CAL_SUCCESS) {
 372
 373                 cs = NULL;
 374                 cal_error error = CALENDAR_SVC_ITER_GET_INFO(iter, &cs);
 375                 if (error != CAL_SUCCESS) {
 376                         ERR("CALENDAR_SVC_ITER_GET_INFO() is failed(%d)", error);
 377                         break;
 378                 }
 379
 380                 *list = eina_list_append(*list, cs);
 381         }
 382 }
 383
 384 static int __calendar_svc_compare_list_item(const void *data1, const void *data2)
 385 {
 386         c_retv_if(!data1, 1);
 387         c_retv_if(!data2, -1);
 388
 389         cal_struct *normal_event = (cal_struct *)data1;
 390         cal_struct *allday_event = (cal_struct *)data2;
 391
 392         long long int lli_normal = CALENDAR_SVC_STRUCT_GET_LLI(normal_event, CALS_VALUE_LLI_DTSTART_UTIME);
 393
 394         struct tm tm_allday = {0};
 395         tm_allday.tm_year = CALENDAR_SVC_STRUCT_GET_INT(allday_event, CALS_VALUE_INT_DTSTART_YEAR) - 1900;
 396         tm_allday.tm_mon = CALENDAR_SVC_STRUCT_GET_INT(allday_event, CALS_VALUE_INT_DTSTART_MONTH) - 1;
 397         tm_allday.tm_mday = CALENDAR_SVC_STRUCT_GET_INT(allday_event, CALS_VALUE_INT_DTSTART_MDAY);
 398
 399         long long int lli_allday;
 400         cal_util_convert_tm_to_lli(NULL, &tm_allday, &lli_allday);
 401
 402         return (lli_allday < lli_normal) ? 1 : -1;
 403 }
 404
 405
 406 Eina_List * _calendar_svc_get_normal_list(struct tm *tm_start, struct tm *tm_end)
 407 {
 408         c_retv_if(!tm_start, NULL);
 409         c_retv_if(!tm_end, NULL);
 410
 411         long long int lli_start, lli_end;
 412
 413         cal_util_convert_tm_to_lli(NULL, tm_start, &lli_start);
 414         cal_util_convert_tm_to_lli(NULL, tm_end, &lli_end);
 415
 416         cal_iter *iter = NULL;
 417
 418 // TODO: Change calendar_id to defined constants
 419
 420         int r = calendar_svc_event_get_normal_list_by_period(-1, CALS_LIST_PERIOD_NORMAL_OSP, lli_start, lli_end, &iter);
 421         c_retvm_if(r != CAL_SUCCESS, NULL, "calendar_svc_event_get_normal_list_by_period() is failed(%d)", r);
 422
 423         Eina_List *normal_list = NULL;
 424
 425         __calendar_svc_append_list_with_iter(&normal_list, iter);
 426
 427         CALENDAR_SVC_ITER_REMOVE(&iter);
 428
 429         return normal_list;
 430 }
 431
 432 Eina_List * _calendar_svc_get_allday_list(struct tm *tm_start, struct tm *tm_end)
 433 {
 434         c_retv_if(!tm_start, NULL);
 435         c_retv_if(!tm_end, NULL);
 436
 437         cal_iter *iter = NULL;
 438
 439 // TODO: Change calendar_id to defined constants
 440
 441         int r = calendar_svc_event_get_allday_list_by_period(-1, CALS_LIST_PERIOD_ALLDAY_OSP,
 442                 tm_start->tm_year + 1900, tm_start->tm_mon + 1, tm_start->tm_mday,
 443                 tm_end->tm_year + 1900, tm_end->tm_mon + 1, tm_end->tm_mday,
 444                 &iter);
 445         c_retvm_if(r != CAL_SUCCESS, NULL, "calendar_svc_event_get_allday_list_by_period() is failed(%d)", r);
 446
 447         Eina_List *allday_list = NULL;
 448
 449         __calendar_svc_append_list_with_iter(&allday_list, iter);
 450
 451         CALENDAR_SVC_ITER_REMOVE(&iter);
 452
 453         return allday_list;
 454 }
 455
 456 Eina_List *_calendar_svc_get_event_list(struct tm *tm_start, struct tm *tm_end)
 457 {
 458         c_retv_if(!tm_start, NULL);
 459         c_retv_if(!tm_end, NULL);
 460
 461         Eina_List *normal_list = _calendar_svc_get_normal_list(tm_start, tm_end);
 462         Eina_List *allday_list = _calendar_svc_get_allday_list(tm_start, tm_end);
 463
 464         return eina_list_sorted_merge(normal_list, allday_list, __calendar_svc_compare_list_item);
 465 }
 466
 467 Eina_List * _calendar_svc_get_task_list(struct tm *tm_start, struct tm *tm_end, int priority, cals_status_t status, cals_todo_list_order_t order)
 468 {
 469         c_retv_if(!tm_start, NULL);
 470         c_retv_if(!tm_end, NULL);
 471
 472         cal_iter *it = NULL;
 473
 474         long long int lli_start, lli_end;
 475
 476         cal_util_convert_tm_to_lli(NULL, tm_start, &lli_start);
 477         cal_util_convert_tm_to_lli(NULL, tm_end, &lli_end);
 478
 479         cal_error error = calendar_svc_todo_get_list(-1, lli_start, lli_end, priority, status, order, &it);
 480         c_retvm_if(error != CAL_SUCCESS, NULL, "calendar_svc_todo_get_list(%d) is failed(%d)", -1, error);
 481
 482         Eina_List *task_list = NULL;
 483
 484         __calendar_svc_append_list_with_iter(&task_list, it);
 485
 486         CALENDAR_SVC_ITER_REMOVE(&it);
 487
 488         return task_list;
 489 }
 490
 491 Eina_List *_calendar_svc_event_search(int search_fields, const char *keyword)
 492 {
 493         c_retv_if(!keyword, NULL);
 494
 495         cal_iter *iter = NULL;
 496
 497         int r = calendar_svc_event_search(search_fields, keyword, &iter);
 498         c_retvm_if(r != CAL_SUCCESS, NULL, "calendar_svc_event_search(%d,%s) is failed(%d)", search_fields, keyword, r);
 499
 500         Eina_List *search_result = NULL;
 501
 502         __calendar_svc_append_list_with_iter(&search_result, iter);
 503
 504         CALENDAR_SVC_ITER_REMOVE(&iter);
 505
 506         return search_result;
 507 }
 508
 509 Eina_List *_calendar_svc_todo_search(int search_fields, const char *keyword)
 510 {
 511         c_retv_if(!keyword, NULL);
 512
 513         cal_iter *iter = NULL;
 514
 515         int r = calendar_svc_todo_search(search_fields, keyword, &iter);
 516         c_retvm_if(r != CAL_SUCCESS, NULL, "calendar_svc_event_search(%d,%s) is failed(%d)", search_fields, keyword, r);
 517
 518         Eina_List *search_result = NULL;
 519
 520         __calendar_svc_append_list_with_iter(&search_result, iter);
 521
 522         CALENDAR_SVC_ITER_REMOVE(&iter);
 523
 524         return search_result;
 525 }
 526
 527 Eina_List * _calendar_svc_get_all(int account_id, int calendar_id, const char *type)
 528 {
 529         c_retv_if(!type, NULL);
 530
 531         cal_iter *iter = NULL;
 532
 533         int r = calendar_svc_get_all(account_id, calendar_id, type, &iter);
 534         c_retvm_if(r != CAL_SUCCESS, NULL, "calendar_svc_get_all(%s) is failed(%d)", type, r);
 535
 536         Eina_List *list = NULL;
 537
 538         __calendar_svc_append_list_with_iter(&list, iter);
 539
 540         CALENDAR_SVC_ITER_REMOVE(&iter);
 541
 542         return list;
 543 }
 544