src/modules/tizen/Calendar/EventWrapper.cpp

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *    Licensed under the Apache License, Version 2.0 (the "License");
   5  *    you may not use this file except in compliance with the License.
   6  *    You may obtain a copy of the License at
   7  *
   8  *        http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *    Unless required by applicable law or agreed to in writing, software
  11  *    distributed under the License is distributed on an "AS IS" BASIS,
  12  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *    See the License for the specific language governing permissions and
  14  *    limitations under the License.
  15  */
  16 /**
  17  * @file        EventWrapper.cpp
  18  * @author      Lukasz Marek (l.marek@samsung.com)
  19  * @version     0.1
  20  */
  21
  22 #include <string.h>
  23 #include <algorithm>
  24 #include <pcrecpp.h>
  25 #include <dpl/log/log.h>
  26 #include <Commons/Exception.h>
  27 #include "EventWrapper.h"
  28 #include "Calendar.h"
  29
  30 namespace {
  31 const char weekDays[] = "0111110";
  32 const int NEW_EVENT_ID = -1;
  33 }
  34
  35 namespace WrtDeviceApis {
  36 namespace Calendar {
  37
  38 using namespace Api;
  39
  40 EventWrapper::EventWrapper() :
  41     m_platformEvent(NULL),
  42     m_abstractEvent(NULL)
  43 {
  44     LogDebug("entered");
  45     m_abstractEvent = CalendarEventPtr(new CalendarEvent());
  46     if (!m_abstractEvent) {
  47         ThrowMsg(Commons::UnknownException, "abstract object is not created");
  48     }
  49 }
  50
  51 EventWrapper::EventWrapper(const CalendarEventPtr &event) :
  52     m_platformEvent(NULL),
  53     m_abstractEvent(event)
  54 {
  55     LogDebug("entered");
  56 }
  57
  58 EventWrapper::~EventWrapper()
  59 {
  60     LogDebug("entered");
  61     freePlatformEvent();
  62 }
  63
  64 int EventWrapper::getIDFromPlatformEvent() const
  65 {
  66     LogDebug("Entered");
  67     if (m_platformEvent == NULL) {
  68         ThrowMsg(Commons::NullPointerException, "m_platformEvent is not set");
  69     }
  70
  71     return calendar_svc_struct_get_int(m_platformEvent, CAL_VALUE_INT_INDEX);
  72 }
  73
  74 void EventWrapper::saveEvent()
  75 {
  76     LogDebug("entered");
  77     //Check if platform struct is set.
  78     //It could be set here, but forcing user to do it manually can help to avoid problems.
  79     if (m_platformEvent == NULL) {
  80         ThrowMsg(Commons::NullPointerException, "m_platformEvent is not set");
  81     }
  82
  83     int eventID = getIDFromPlatformEvent();
  84     LogDebug("eventID: " << eventID);
  85
  86     displayPlatformEvent();
  87
  88     //insert new record or update existing one
  89     if (eventID < 0) { //insert new event
  90         int returnValue = calendar_svc_insert(m_platformEvent);
  91         if (CAL_SUCCESS > returnValue) {
  92             LogError("Can't insert new event, error code: " << returnValue);
  93             ThrowMsg(Commons::PlatformException, "Can't insert new event.");
  94         }
  95         m_abstractEvent->setId(returnValue);
  96         LogInfo("New calendar event inserted");
  97     } else { //update
  98         if (CAL_SUCCESS != calendar_svc_update(m_platformEvent)) {
  99             ThrowMsg(Commons::PlatformException, "Can't update new event.");
 100         }
 101         LogDebug("Calendar event updated");
 102     }
 103 }
 104
 105 void EventWrapper::loadEvent(int id)
 106 {
 107     LogDebug("Entered. ID of event to load: " << id);
 108     freePlatformEvent();
 109     int errorCode = calendar_svc_get(CAL_STRUCT_SCHEDULE,
 110                                      id,
 111                                      NULL,
 112                                      &m_platformEvent);
 113     if (CAL_SUCCESS > errorCode) {
 114         LogError(
 115             "Can't get event with ID = " << id << ", error code: " <<
 116             errorCode);
 117         ThrowMsg(
 118             Commons::PlatformException,
 119             "Can't get event with ID = " << id << ", error code: " <<
 120             errorCode);
 121     }
 122     convertPlatformEventToAbstractEvent();
 123     displayAbstractEvent();
 124 }
 125
 126 bool EventWrapper::matchFilters(EventFilterPtr filter)
 127 {
 128     LogDebug("Entered");
 129     if (!filter) {
 130         return true;
 131     }
 132     if (!m_abstractEvent) {
 133         ThrowMsg(Commons::NullPointerException,
 134                  "abstractEvent object is not set");
 135     }
 136
 137     LogDebug("---new event to match---");
 138     m_abstractEvent->display();
 139
 140     if (filter->getIdIsSet() && m_abstractEvent->getIdIsSet()) {
 141         std::stringstream ss;
 142         if (!(ss << m_abstractEvent->getId())) {
 143             LogDebug("rejected by id");
 144             return false;
 145         }
 146         if (!pcrecpp::RE(filter->getIdFilter()).FullMatch(ss.str())) {
 147             LogDebug("rejected by id " << filter->getIdFilter());
 148             return false;
 149         }
 150     }
 151     if (filter->getCalendarIdIsSet()) {
 152         if (m_abstractEvent->getCalendarId() !=
 153             filter->getCalendarIdFilter()) {
 154             LogDebug("rejected by calendar id " << filter->getCalendarIdFilter());
 155             return false;
 156         }
 157     }
 158     if (filter->getDescriptionIsSet()) {
 159         if (!pcrecpp::RE(filter->getDescriptionFilter()).FullMatch(
 160                 m_abstractEvent->getDescription())) {
 161             LogDebug("rejected by description " << filter->getDescriptionFilter());
 162             return false;
 163         }
 164     }
 165     if (filter->getSubjectIsSet()) {
 166         if (!pcrecpp::RE(filter->getSubjectFilter()).FullMatch(m_abstractEvent
 167                                                                    ->getSubject()))
 168         {
 169             LogDebug("rejected by subject " << filter->getSubjectFilter());
 170             return false;
 171         }
 172     }
 173     if (filter->getStartTimeMinIsSet() && m_abstractEvent->getStartTime() <
 174         filter->getStartTimeMinFilter()) {
 175         LogDebug("rejected by start time min " << filter->getStartTimeMinFilter());
 176         return false;
 177     }
 178     if (filter->getStartTimeMaxIsSet() && m_abstractEvent->getStartTime() >
 179         filter->getStartTimeMaxFilter()) {
 180         LogDebug("rejected by start time max " << filter->getStartTimeMaxFilter());
 181         return false;
 182     }
 183     if (filter->getEndTimeMinIsSet() && m_abstractEvent->getEndTime() <
 184         filter->getEndTimeMinFilter()) {
 185         LogDebug("rejected by end time min " << filter->getEndTimeMinFilter());
 186         return false;
 187     }
 188     if (filter->getEndTimeMaxIsSet() && m_abstractEvent->getEndTime() >
 189         filter->getEndTimeMaxFilter()) {
 190         LogDebug("rejected by end time max " << filter->getEndTimeMaxFilter());
 191         return false;
 192     }
 193     if (filter->getLocationIsSet()) {
 194         if (!pcrecpp::RE(filter->getLocationFilter()).FullMatch(m_abstractEvent
 195                                                                     ->
 196                                                                     getLocation()))
 197         {
 198             LogDebug("rejected by location " << filter->getLocationFilter());
 199             return false;
 200         }
 201     }
 202     if (filter->getRecurrenceIsSet()) {
 203         const std::vector<CalendarEvent::EventRecurrence> &filterVal =
 204             filter->getRecurrenceFilter();
 205         if (std::find(filterVal.begin(), filterVal.end(),
 206                       m_abstractEvent->getRecurrence()) == filterVal.end()) {
 207             LogDebug("rejected by recurrence");
 208             return false;
 209         }
 210     }
 211     if (filter->getStatusIsSet()) {
 212         const std::vector<CalendarEvent::EventStatus> &filterVal =
 213             filter->getStatusFilter();
 214         if (std::find(filterVal.begin(), filterVal.end(),
 215                       m_abstractEvent->getStatus()) == filterVal.end()) {
 216             LogDebug("rejected by status");
 217             return false;
 218         }
 219     }
 220     if (filter->getAlarmTimeMinIsSet() && m_abstractEvent->getAlarmTime() <
 221         filter->getAlarmTimeMinFilter()) {
 222         LogDebug("rejected by alarm time min " << filter->getAlarmTimeMinFilter());
 223         return false;
 224     }
 225     if (filter->getAlarmTimeMinIsSet() && m_abstractEvent->getAlarmTime() >
 226         filter->getAlarmTimeMaxFilter()) {
 227         LogDebug("rejected by alarm time max " << filter->getAlarmTimeMaxFilter());
 228         return false;
 229     }
 230     if (filter->getAlarmTypeIsSet()) {
 231         const std::vector<CalendarEvent::EventAlarmType> &filterVal =
 232             filter->getAlarmTypeFilter();
 233         if (std::find(filterVal.begin(), filterVal.end(),
 234                       m_abstractEvent->getAlarmType()) == filterVal.end()) {
 235             LogDebug("rejected by alarm type");
 236             return false;
 237         }
 238     }
 239     if (filter->getCategoryIsSet()) {
 240         CategoryListPtr categories = m_abstractEvent->getCategories();
 241         bool found = false;
 242         for (std::size_t i = 0; i < categories->size(); ++i) {
 243             if (pcrecpp::RE(filter->getCategoryFilter()).FullMatch(categories->
 244                                                                        at(i)))
 245             {
 246                 found = true;
 247                 break;
 248             }
 249         }
 250         if (!found) {
 251             LogDebug("rejectedy by category");
 252             return false;
 253         }
 254     }
 255     return true;
 256 }
 257
 258 void EventWrapper::deleteEvent()
 259 {
 260     LogDebug("entered");
 261     if (m_platformEvent == NULL) {
 262         ThrowMsg(Commons::NullPointerException,
 263                  "Failed to delete event in calendar (m_platformEvent==NULL)");
 264     }
 265     int eventID = getIDFromPlatformEvent();
 266     LogDebug("eventID: " << eventID);
 267     if (eventID < 0) {
 268         ThrowMsg(
 269             Commons::InvalidArgumentException,
 270             "Failed to delete event in calendar (event is not saved in calendar)");
 271     }
 272     cal_struct *event = NULL;
 273     int error = calendar_svc_get(CAL_STRUCT_SCHEDULE, eventID, NULL, &event);
 274     if (event) {
 275         calendar_svc_struct_free(&event);
 276     }
 277     if (CAL_SUCCESS != error) {
 278         ThrowMsg(
 279             Commons::NotFoundException,
 280             "Can't delete calendar event, event doesn't exist. Error code "
 281             << error);
 282     }
 283     error = calendar_svc_delete(CAL_STRUCT_SCHEDULE, eventID);
 284     if (CAL_SUCCESS != error) {
 285         ThrowMsg(Commons::PlatformException,
 286                  "Can't delete calendar event. Error code " << error);
 287     }
 288     LogDebug("event deleted");
 289     m_abstractEvent->resetId();
 290     setIDToPlatformEvent();
 291 }
 292
 293 cal_struct *EventWrapper::getPlatformEvent() const
 294 {
 295     return m_platformEvent;
 296 }
 297
 298 CalendarEventPtr EventWrapper::getAbstractEvent() const
 299 {
 300     return m_abstractEvent;
 301 }
 302
 303 void EventWrapper::freePlatformEvent()
 304 {
 305     LogDebug("entered");
 306     if (m_platformEvent != NULL) {
 307         if (CAL_SUCCESS != calendar_svc_struct_free(&m_platformEvent)) {
 308             LogError("Can't free calendar event struct.");
 309         }
 310         m_platformEvent = NULL;
 311     }
 312 }
 313
 314 cal_struct *EventWrapper::convertAbstractEventToPlatformEvent()
 315 {
 316     LogDebug("entered");
 317     freePlatformEvent();
 318     m_platformEvent = calendar_svc_struct_new(CAL_STRUCT_SCHEDULE);
 319     if (!m_platformEvent) {
 320         ThrowMsg(Commons::UnknownException, "cannot create platform event");
 321     }
 322     setDescriptionToPlatformEvent();
 323     setSubjectToPlatformEvent();
 324     setStartTimeToPlatformEvent();
 325     setEndTimeToPlatformEvent();
 326     setLocationToPlatformEvent();
 327     setAlarmToPlatformEvent();
 328     setRecurrenceToPlatformEvent();
 329     setStatusToPlatformEvent();
 330     setCategoriesToPlatformEvent();
 331     setIDToPlatformEvent();
 332     setExpiresToPlatformEvent();
 333     setIntervalToPlatformEvent();
 334     return getPlatformEvent();
 335 }
 336
 337 void EventWrapper::setDescriptionToPlatformEvent()
 338 {
 339     if (!m_platformEvent) {
 340         ThrowMsg(Commons::UnknownException, "Null platform pointer.");
 341     }
 342     if (CAL_SUCCESS != calendar_svc_struct_set_str(m_platformEvent,
 343                                                    CAL_VALUE_TXT_DESCRIPTION,
 344                                                    m_abstractEvent->
 345                                                        getDescription().c_str()))
 346     {
 347         ThrowMsg(Commons::PlatformException, "Can't set event description.");
 348     }
 349 }
 350
 351 void EventWrapper::setSubjectToPlatformEvent()
 352 {
 353     if (!m_platformEvent) {
 354         ThrowMsg(Commons::UnknownException, "Null platform pointer.");
 355     }
 356     if (CAL_SUCCESS != calendar_svc_struct_set_str(m_platformEvent,
 357                                                    CAL_VALUE_TXT_SUMMARY,
 358                                                    m_abstractEvent->getSubject()
 359                                                        .c_str())) {
 360         ThrowMsg(Commons::PlatformException, "Can't set event subject.");
 361     }
 362 }
 363
 364 void EventWrapper::setStartTimeToPlatformEvent()
 365 {
 366     if (!m_platformEvent) {
 367         ThrowMsg(Commons::UnknownException, "Null platform pointer.");
 368     }
 369
 370     time_t time = m_abstractEvent->getStartTime();
 371     if (time == 0) {
 372         time = m_abstractEvent->getEndTime();
 373     }
 374     if (CAL_SUCCESS != calendar_svc_struct_set_time(m_platformEvent,
 375                                                     CAL_VALUE_GMT_START_DATE_TIME,
 376                                                     CAL_TZ_FLAG_GMT, time)) {
 377         ThrowMsg(Commons::PlatformException, "Can't set event start time.");
 378     }
 379 }
 380
 381 void EventWrapper::setEndTimeToPlatformEvent()
 382 {
 383     if (!m_platformEvent) {
 384         ThrowMsg(Commons::UnknownException, "Null platform pointer.");
 385     }
 386
 387     time_t time = m_abstractEvent->getEndTime();
 388     if (time == 0) {
 389         time = m_abstractEvent->getStartTime();
 390     }
 391     if (CAL_SUCCESS != calendar_svc_struct_set_time(m_platformEvent,
 392                                                     CAL_VALUE_GMT_END_DATE_TIME,
 393                                                     CAL_TZ_FLAG_GMT, time)) {
 394         ThrowMsg(Commons::PlatformException, "Can't set event end time.");
 395     }
 396 }
 397
 398 void EventWrapper::setLocationToPlatformEvent()
 399 {
 400     if (!m_platformEvent) {
 401         ThrowMsg(Commons::UnknownException, "Null platform pointer.");
 402     }
 403     if (CAL_SUCCESS != calendar_svc_struct_set_str(m_platformEvent,
 404                                                    CAL_VALUE_TXT_LOCATION,
 405                                                    m_abstractEvent->getLocation()
 406                                                        .c_str())) {
 407         ThrowMsg(Commons::PlatformException, "Can't set event location.");
 408     }
 409 }
 410
 411 void EventWrapper::setRecurrenceToPlatformEvent()
 412 {
 413     if (!m_platformEvent) {
 414         ThrowMsg(Commons::UnknownException, "Null platform pointer.");
 415     }
 416     bool ret = false;
 417     switch (m_abstractEvent->getRecurrence()) {
 418     case CalendarEvent::NO_RECURRENCE:
 419         ret = (CAL_SUCCESS == calendar_svc_struct_set_int(m_platformEvent,
 420                                                           CAL_VALUE_INT_REPEAT_TERM,
 421                                                           CAL_REPEAT_NONE));
 422         break;
 423     case CalendarEvent::DAILY_RECURRENCE:
 424         ret = (CAL_SUCCESS == calendar_svc_struct_set_int(m_platformEvent,
 425                                                           CAL_VALUE_INT_REPEAT_TERM,
 426                                                           CAL_REPEAT_EVERY_DAY))
 427             &&
 428             (CAL_SUCCESS == calendar_svc_struct_set_int(m_platformEvent,
 429                                                         CAL_VALUE_INT_REPEAT_OCCURRENCES,
 430                                                         0));
 431         break;
 432     case CalendarEvent::WEEKLY_RECURRENCE:
 433     {
 434         char weekDay[] = "0000000";
 435         time_t date = m_abstractEvent->getStartTime();
 436         tm* time = localtime(&date);
 437         if (!time) {
 438             LogError("localtime failed");
 439             ret = -1;
 440             break;
 441         }
 442
 443         int days = time->tm_wday;
 444         if (days < 0 || days > 6) {
 445             LogError("invalid week day");
 446             ret = -1;
 447         } else {
 448             weekDay[days] = '1';
 449             ret = (CAL_SUCCESS == calendar_svc_struct_set_int(m_platformEvent,
 450                                                               CAL_VALUE_INT_REPEAT_TERM,
 451                                                               CAL_REPEAT_EVERY_WEEK))
 452                 &&
 453                 (CAL_SUCCESS == calendar_svc_struct_set_int(m_platformEvent,
 454                                                             CAL_VALUE_INT_REPEAT_OCCURRENCES,
 455                                                             0)) &&
 456                 (CAL_SUCCESS == calendar_svc_struct_set_str(m_platformEvent,
 457                                                             CAL_VALUE_TXT_WEEK_FLAG,
 458                                                             weekDay));
 459         }
 460     }
 461     break;
 462     case CalendarEvent::MONTHLY_ON_DAY_RECURRENCE:
 463     {
 464         char weekDay[] = "0000000";
 465         time_t date = m_abstractEvent->getStartTime();
 466         int days = localtime(&date)->tm_wday;
 467         if (days < 0 || days > 6) {
 468             LogError("invalid week day");
 469             ret = -1;
 470         } else {
 471             weekDay[days] = '1';
 472             ret = (CAL_SUCCESS == calendar_svc_struct_set_int(
 473                       m_platformEvent,
 474                       CAL_VALUE_INT_REPEAT_OCCURRENCES,
 475                       0)) &&
 476                   (CAL_SUCCESS == calendar_svc_struct_set_str(
 477                       m_platformEvent,
 478                       CAL_VALUE_TXT_WEEK_FLAG,
 479                       weekDay));
 480         }
 481     }
 482     break;
 483     case CalendarEvent::MONTHLY_RECURRENCE:
 484         ret = (CAL_SUCCESS == calendar_svc_struct_set_int(
 485                   m_platformEvent,
 486                   CAL_VALUE_INT_REPEAT_TERM,
 487                   CAL_REPEAT_EVERY_MONTH)) &&
 488               (CAL_SUCCESS == calendar_svc_struct_set_int(
 489                   m_platformEvent,
 490                   CAL_VALUE_INT_REPEAT_OCCURRENCES,
 491                   0));
 492         break;
 493     case CalendarEvent::WEEKDAY_RECURRENCE:
 494         ret = (CAL_SUCCESS == calendar_svc_struct_set_int(
 495                    m_platformEvent,
 496                    CAL_VALUE_INT_REPEAT_TERM,
 497                    CAL_REPEAT_EVERY_WEEK)) &&
 498             (CAL_SUCCESS == calendar_svc_struct_set_int(
 499                    m_platformEvent,
 500                    CAL_VALUE_INT_REPEAT_OCCURRENCES,
 501                    0)) &&
 502             (CAL_SUCCESS == calendar_svc_struct_set_str(
 503                    m_platformEvent,
 504                    CAL_VALUE_TXT_WEEK_FLAG,
 505                    weekDays));
 506         break;
 507     case CalendarEvent::YEARLY_RECURRENCE:
 508         ret = (CAL_SUCCESS == calendar_svc_struct_set_int(
 509                    m_platformEvent,
 510                    CAL_VALUE_INT_REPEAT_TERM,
 511                    CAL_REPEAT_EVERY_YEAR)) &&
 512               (CAL_SUCCESS == calendar_svc_struct_set_int(
 513                    m_platformEvent,
 514                    CAL_VALUE_INT_REPEAT_OCCURRENCES,
 515                    0));
 516         break;
 517     case CalendarEvent::INVALID_RECURRENCE:
 518     case CalendarEvent::UNDEFINED_RECURRENCE:
 519     default:
 520         LogError("invalid reccurence " << m_abstractEvent->getRecurrence());
 521         ret = 0;
 522         break;
 523     }
 524     if (!ret) {
 525         ThrowMsg(Commons::PlatformException, "Can't set event recurrence.");
 526     }
 527 }
 528
 529 void EventWrapper::setAlarmToPlatformEvent()
 530 {
 531     if (!m_platformEvent) {
 532         ThrowMsg(Commons::UnknownException, "Null platform pointer.");
 533     }
 534
 535     GList* list = NULL;
 536
 537     if (m_abstractEvent->getAlarmTimeIsSet()) {
 538
 539         //set alarm's type
 540         cal_alert_type_t alarmType = CAL_ALERT_MELODY;
 541         switch (m_abstractEvent->getAlarmType()) {
 542         case CalendarEvent::NO_ALARM:
 543             alarmType = CAL_ALERT_MUTE;
 544             break;
 545         case CalendarEvent::SOUND_ALARM:
 546             alarmType = CAL_ALERT_MELODY;
 547             break;
 548         case CalendarEvent::SILENT_ALARM:
 549             alarmType = CAL_ALERT_VIBRATION;
 550             break;
 551         default:
 552             ThrowMsg(Commons::UnknownException, "wrong alarm type");
 553             break;
 554         }
 555
 556         //create new alarm
 557         cal_value* alarm = calendar_svc_value_new(CAL_VALUE_LST_ALARM);
 558         if (NULL == alarm) {
 559             ThrowMsg(Commons::PlatformException, "Can't set alarm.");
 560         }
 561
 562         if (CAL_SUCCESS != calendar_svc_value_set_time(
 563                 alarm,
 564                 CAL_VALUE_GMT_ALARMS_TIME,
 565                 CAL_TZ_FLAG_GMT,
 566                 m_abstractEvent->getAlarmTime()) ||
 567             CAL_SUCCESS != calendar_svc_value_set_int(
 568                 alarm,
 569                 CAL_VALUE_INT_ALARMS_TICK,
 570                 0) ||
 571             CAL_SUCCESS != calendar_svc_value_set_int(
 572                 alarm,
 573                 CAL_VALUE_INT_ALARMS_TICK_UNIT,
 574                 CAL_SCH_TIME_UNIT_SPECIFIC) ||
 575             CAL_SUCCESS != calendar_svc_value_set_int(
 576                 alarm,
 577                 CAL_VALUE_INT_ALARMS_TYPE,
 578                 alarmType))
 579         {
 580             calendar_svc_value_free(&alarm);
 581             ThrowMsg(Commons::PlatformException, "Can't set alarm.");
 582         }
 583
 584         //add alarm to list
 585         list = g_list_prepend(list, alarm);
 586     }
 587
 588     //store alarms list
 589     if (CAL_SUCCESS != calendar_svc_struct_store_list(
 590             m_platformEvent,
 591             CAL_VALUE_LST_ALARM,
 592             list))
 593     {
 594         ThrowMsg(Commons::PlatformException, "cannot save the alarms");
 595     }
 596
 597 }
 598
 599 void EventWrapper::setStatusToPlatformEvent()
 600 {
 601     if (!m_platformEvent) {
 602         ThrowMsg(Commons::UnknownException, "Null platform pointer.");
 603     }
 604     int status = 0;
 605     switch (m_abstractEvent->getStatus()) {
 606     case CalendarEvent::TENTATIVE_STATUS:
 607         status = 1;
 608         break;
 609     case CalendarEvent::CANCELLED_STATUS:
 610         status = 2;
 611         break;
 612     case CalendarEvent::CONFIRMED_STATUS:
 613     default:
 614         status = 0;
 615         break;
 616     }
 617     if (CAL_SUCCESS != calendar_svc_struct_set_int(m_platformEvent,
 618                                                    CAL_VALUE_INT_MEETING_STATUS,
 619                                                    status)) {
 620         ThrowMsg(Commons::PlatformException, "Can't set event ID.");
 621     }
 622 }
 623
 624 void EventWrapper::setCategoriesToPlatformEvent()
 625 {
 626     if (!m_platformEvent) {
 627         ThrowMsg(Commons::UnknownException, "Null platform pointer.");
 628     }
 629     GList *categoryList = NULL;
 630     cal_value* category = NULL;
 631     Try
 632     {
 633         for (size_t i = 0; i < m_abstractEvent->getCategories()->size(); ++i) {
 634             LogDebug("adding category " <<
 635                      m_abstractEvent->getCategories()->at(i));
 636             category = calendar_svc_value_new(CAL_VALUE_LST_MEETING_CATEGORY);
 637             if (NULL == category) {
 638                 LogError("error during creating category");
 639                 ThrowMsg(Commons::PlatformException,
 640                          "Cannot create category object");
 641             }
 642             if (CAL_SUCCESS !=
 643                 calendar_svc_value_set_str(category, "category_name",
 644                                            m_abstractEvent->getCategories()->at(
 645                                                i).c_str())) {
 646                 LogError("error during setting category name");
 647                 calendar_svc_value_free(&category);
 648                 ThrowMsg(Commons::PlatformException, "Cannot set category name");
 649             }
 650             //Order of categories is lost during saving, so we don't need to reverse this list.
 651             categoryList = g_list_prepend(categoryList, category);
 652         }
 653
 654         calendar_svc_struct_store_list(m_platformEvent,
 655                                        CAL_VALUE_LST_MEETING_CATEGORY,
 656                                        categoryList);
 657     }
 658     Catch(Commons::PlatformException)
 659     {
 660         LogError("error during setting categories");
 661         calendar_svc_struct_store_list(m_platformEvent,
 662                                        CAL_VALUE_LST_MEETING_CATEGORY,
 663                                        NULL);
 664         for (; categoryList; categoryList = g_list_next(categoryList)) {
 665             category = static_cast<cal_value*>(categoryList->data);
 666             calendar_svc_value_free(&category);
 667         }
 668         g_list_free(categoryList);
 669         ReThrow(Commons::PlatformException);
 670     }
 671 }
 672
 673 void EventWrapper::setIDToPlatformEvent()
 674 {
 675     if (!m_platformEvent) {
 676         ThrowMsg(Commons::UnknownException, "Null platform pointer.");
 677     }
 678     if (m_abstractEvent->getIdIsSet()) {
 679         if (CAL_SUCCESS != calendar_svc_struct_set_int(
 680                 m_platformEvent,
 681                 CAL_VALUE_INT_INDEX,
 682                 m_abstractEvent->getId()))
 683         {
 684             ThrowMsg(Commons::PlatformException, "Can't set event ID.");
 685         }
 686     } else {
 687         if (CAL_SUCCESS != calendar_svc_struct_set_int(
 688                 m_platformEvent,
 689                 CAL_VALUE_INT_INDEX,
 690                 NEW_EVENT_ID))
 691         {
 692             ThrowMsg(Commons::PlatformException, "Can't set event ID.");
 693         }
 694     }
 695 }
 696
 697 void EventWrapper::setExpiresToPlatformEvent()
 698 {
 699     if (!m_platformEvent) {
 700         ThrowMsg(Commons::UnknownException, "Null platform pointer.");
 701     }
 702     if (m_abstractEvent->getExpiresIsSet()) {
 703         int errorCode = calendar_svc_struct_set_time(
 704                 m_platformEvent,
 705                 CAL_VALUE_GMT_REPEAT_END_DATE,
 706                 CAL_TZ_FLAG_GMT,
 707                 m_abstractEvent->getExpires());
 708         if (CAL_SUCCESS != errorCode) {
 709             LogError(
 710                 "Can't set CAL_VALUE_GMT_REPEAT_END_DATE, error: " <<
 711                 errorCode);
 712             ThrowMsg(Commons::PlatformException, "Can't set expires.");
 713         }
 714     }
 715 }
 716
 717 void EventWrapper::setIntervalToPlatformEvent()
 718 {
 719     if (CAL_SUCCESS != calendar_svc_struct_set_int(m_platformEvent,
 720                                                    CAL_VALUE_INT_REPEAT_INTERVAL,
 721                                                    m_abstractEvent->getInterval()))
 722     {
 723         ThrowMsg(Commons::PlatformException, "Can't set interval.");
 724     }
 725 }
 726
 727 CalendarEventPtr EventWrapper::convertPlatformEventToAbstractEvent()
 728 {
 729     LogDebug("entered");
 730     setDescriptionFromPlatformEvent();
 731     setSubjectFromPlatformEvent();
 732     setStartTimeFromPlatformEvent();
 733     setEndTimeFromPlatformEvent();
 734     setLocationFromPlatformEvent();
 735     setRecurrenceFromPlatformEvent();
 736     setAlarmFromPlatformEvent();
 737     setStatusFromPlatformEvent();
 738     setCategoriesFromPlatformEvent();
 739     setIDFromPlatformEvent();
 740     setExpiresFromPlatformEvent();
 741     setIntervalFromPlatformEvent();
 742     return getAbstractEvent();
 743 }
 744
 745 void EventWrapper::setDescriptionFromPlatformEvent()
 746 {
 747     if (!m_platformEvent) {
 748         ThrowMsg(Commons::UnknownException, "Null platform pointer.");
 749     }
 750     const char *description = calendar_svc_struct_get_str(
 751             m_platformEvent,
 752             CAL_VALUE_TXT_DESCRIPTION);
 753     if (description) {
 754         m_abstractEvent->setDescription(description);
 755     }
 756 }
 757
 758 void EventWrapper::setSubjectFromPlatformEvent()
 759 {
 760     if (!m_platformEvent) {
 761         ThrowMsg(Commons::UnknownException, "Null platform pointer.");
 762     }
 763     const char *summary = calendar_svc_struct_get_str(m_platformEvent,
 764                                                       CAL_VALUE_TXT_SUMMARY);
 765     if (summary) {
 766         m_abstractEvent->setSubject(summary);
 767     }
 768 }
 769
 770 void EventWrapper::setStartTimeFromPlatformEvent()
 771 {
 772     if (!m_platformEvent) {
 773         ThrowMsg(Commons::UnknownException, "Null platform pointer.");
 774     }
 775     time_t startTime = calendar_svc_struct_get_time(
 776             m_platformEvent,
 777             CAL_VALUE_GMT_START_DATE_TIME,
 778             CAL_TZ_FLAG_GMT);
 779     m_abstractEvent->setStartTime(startTime);
 780 }
 781
 782 void EventWrapper::setEndTimeFromPlatformEvent()
 783 {
 784     if (!m_platformEvent) {
 785         ThrowMsg(Commons::UnknownException, "Null platform pointer.");
 786     }
 787     time_t endTime = calendar_svc_struct_get_time(m_platformEvent,
 788                                                   CAL_VALUE_GMT_END_DATE_TIME,
 789                                                   CAL_TZ_FLAG_GMT);
 790     m_abstractEvent->setEndTime(endTime);
 791 }
 792
 793 void EventWrapper::setLocationFromPlatformEvent()
 794 {
 795     if (!m_platformEvent) {
 796         ThrowMsg(Commons::UnknownException, "Null platform pointer.");
 797     }
 798     const char* location = calendar_svc_struct_get_str(m_platformEvent,
 799                                                        CAL_VALUE_TXT_LOCATION);
 800     if (location) {
 801         m_abstractEvent->setLocation(location);
 802     }
 803 }
 804
 805 void EventWrapper::setRecurrenceFromPlatformEvent()
 806 {
 807     if (!m_platformEvent) {
 808         ThrowMsg(Commons::UnknownException, "Null platform pointer.");
 809     }
 810     int recurrence = calendar_svc_struct_get_int(m_platformEvent,
 811                                                  CAL_VALUE_INT_REPEAT_TERM);
 812     switch (recurrence) {
 813     case CAL_REPEAT_NONE:
 814         m_abstractEvent->setRecurrence(CalendarEvent::NO_RECURRENCE);
 815         break;
 816     case CAL_REPEAT_EVERY_DAY:
 817         m_abstractEvent->setRecurrence(CalendarEvent::DAILY_RECURRENCE);
 818         break;
 819     case CAL_REPEAT_EVERY_WEEK:
 820     {
 821         const char *daysFlag = calendar_svc_struct_get_str(
 822                 m_platformEvent,
 823                 CAL_VALUE_TXT_WEEK_FLAG);
 824         if (daysFlag && strncmp(daysFlag, weekDays, 7) == 0) {
 825             m_abstractEvent->setRecurrence(CalendarEvent::WEEKDAY_RECURRENCE);
 826         } else {
 827             m_abstractEvent->setRecurrence(CalendarEvent::WEEKLY_RECURRENCE);
 828         }
 829     }
 830     break;
 831     case CAL_REPEAT_EVERY_MONTH:
 832     {
 833         const char *daysFlag = calendar_svc_struct_get_str(
 834                 m_platformEvent,
 835                 CAL_VALUE_TXT_WEEK_FLAG);
 836         if (!daysFlag || strnlen(daysFlag, 7) == 0) {
 837             m_abstractEvent->setRecurrence(CalendarEvent::MONTHLY_RECURRENCE);
 838         } else {
 839             m_abstractEvent->setRecurrence(
 840                 CalendarEvent::MONTHLY_ON_DAY_RECURRENCE);
 841         }
 842     }
 843     break;
 844     case CAL_REPEAT_EVERY_YEAR:
 845         m_abstractEvent->setRecurrence(CalendarEvent::YEARLY_RECURRENCE);
 846         break;
 847     default:
 848         LogWarning("unknown recurrence");
 849         m_abstractEvent->setRecurrence(CalendarEvent::NO_RECURRENCE);
 850         break;
 851     }
 852 }
 853
 854 void EventWrapper::setAlarmFromPlatformEvent()
 855 {
 856     if (!m_platformEvent) {
 857         ThrowMsg(Commons::UnknownException, "Null platform pointer.");
 858     }
 859
 860     GList* list = NULL;
 861     calendar_svc_struct_get_list(m_platformEvent, CAL_VALUE_LST_ALARM, &list);
 862     if (NULL == list) {
 863         //no alarms
 864         m_abstractEvent->resetAlarmTime();
 865         return;
 866     }
 867
 868     cal_value* alarm =  static_cast<cal_value*>(list->data);
 869     if (NULL == alarm) {
 870         //no alarms
 871         m_abstractEvent->resetAlarmTime();
 872         return;
 873     }
 874
 875     cal_sch_remind_tick_unit_t tickUnit =
 876         static_cast<cal_sch_remind_tick_unit_t>(calendar_svc_value_get_int(
 877             alarm,
 878             CAL_VALUE_INT_ALARMS_TICK_UNIT));
 879
 880     if (CAL_SCH_TIME_UNIT_OFF == tickUnit) {
 881         //no alarm
 882         m_abstractEvent->resetAlarmTime();
 883         return;
 884     }
 885     else if (CAL_SCH_TIME_UNIT_SPECIFIC == tickUnit) {
 886         m_abstractEvent->setAlarmTime(calendar_svc_value_get_time(
 887             alarm, CAL_VALUE_GMT_ALARMS_TIME, CAL_TZ_FLAG_GMT));
 888     }
 889     else {
 890         int tick = calendar_svc_value_get_int(alarm,
 891                                               CAL_VALUE_INT_ALARMS_TICK);
 892         time_t startTime = m_abstractEvent->getStartTime();
 893         switch(tickUnit) {
 894         case CAL_SCH_TIME_UNIT_MIN:
 895             /* tick contains number of minutes to substract */
 896             startTime -= tick * 60;
 897             break;
 898         case CAL_SCH_TIME_UNIT_HOUR:
 899             /* tick contains number of hours to substract */
 900             startTime -= tick * 60 * 60;
 901             break;
 902         case CAL_SCH_TIME_UNIT_DAY:
 903             /* tick contains number of days to substract */
 904             startTime -= tick * 60 * 60 * 24;
 905             break;
 906         case CAL_SCH_TIME_UNIT_WEEK:
 907             /* tick contains number of weeks to substract */
 908             startTime -= tick * 60 * 60 * 24 * 7;
 909             break;
 910         case CAL_SCH_TIME_UNIT_MONTH: {
 911             /* tick contains number of months to substract */
 912             struct tm *t = localtime(&startTime);
 913             t->tm_mon -= tick;
 914             int tmpDay = t->tm_mday;
 915             startTime = mktime(t);
 916             if (tmpDay != t->tm_mday) {
 917                 //previous month is shorter than current
 918                 //corrent day and month
 919                 t->tm_mday = tmpDay - t->tm_mday;
 920                 --t->tm_mon;
 921                 startTime = mktime(t);
 922             }
 923             }
 924             break;
 925         default:
 926             break;
 927         }
 928         m_abstractEvent->setAlarmTime(startTime);
 929     }
 930
 931     cal_alert_type_t alarmType = static_cast<cal_alert_type_t>(
 932             calendar_svc_value_get_int(alarm, CAL_VALUE_INT_ALARMS_TYPE));
 933     switch (alarmType) {
 934     case CAL_ALERT_VIBRATION:
 935         m_abstractEvent->setAlarmType(CalendarEvent::SILENT_ALARM);
 936         break;
 937     case CAL_ALERT_MELODY:
 938     case CAL_ALERT_INCREASING_MELODY:
 939     case CAL_ALERT_VIBRATION_THEN_MELODY:
 940     case CAL_ALERT_VIBMELODY:
 941     case CAL_ALERT_VIB_INCREASING_MELODY:
 942         m_abstractEvent->setAlarmType(CalendarEvent::SOUND_ALARM);
 943         break;
 944     case CAL_ALERT_MUTE:
 945     default:
 946         m_abstractEvent->setAlarmType(CalendarEvent::NO_ALARM);
 947         break;
 948     }
 949 }
 950
 951 void EventWrapper::setStatusFromPlatformEvent()
 952 {
 953     if (!m_platformEvent) {
 954         ThrowMsg(Commons::UnknownException, "Null platform pointer.");
 955     }
 956     int status = calendar_svc_struct_get_int(m_platformEvent,
 957                                              CAL_VALUE_INT_MEETING_STATUS);
 958     switch (status) {
 959     case 1:
 960         m_abstractEvent->setStatus(CalendarEvent::TENTATIVE_STATUS);
 961         break;
 962     case 2:
 963         m_abstractEvent->setStatus(CalendarEvent::CANCELLED_STATUS);
 964         break;
 965     case 0:
 966     default:
 967         m_abstractEvent->setStatus(CalendarEvent::CONFIRMED_STATUS);
 968         break;
 969     }
 970 }
 971 void EventWrapper::setCategoriesFromPlatformEvent()
 972 {
 973     if (!m_platformEvent) {
 974         ThrowMsg(Commons::UnknownException, "Null platform pointer.");
 975     }
 976     m_abstractEvent->getCategories()->clear();
 977     GList *categoryList = NULL;
 978     if (CAL_SUCCESS !=
 979         calendar_svc_struct_get_list(m_platformEvent,
 980                                      CAL_VALUE_LST_MEETING_CATEGORY,
 981                                      &categoryList)) {
 982         LogError("cannot read category list");
 983         return;
 984     }
 985     cal_value* category = NULL;
 986     for (; categoryList; categoryList = g_list_next(categoryList)) {
 987         category = static_cast<cal_value*>(categoryList->data);
 988         char* categoryName = calendar_svc_value_get_str(category,
 989                                                         "category_name");
 990         if (NULL == categoryName) {
 991             LogError("cannot read category name");
 992             return;
 993         }
 994         m_abstractEvent->getCategories()->push_back(categoryName);
 995     }
 996 }
 997
 998 void EventWrapper::setIDFromPlatformEvent()
 999 {
1000     if (!m_platformEvent) {
1001         ThrowMsg(Commons::UnknownException, "Null platform pointer.");
1002     }
1003     m_abstractEvent->setId(getIDFromPlatformEvent());
1004 }
1005
1006 void EventWrapper::setExpiresFromPlatformEvent()
1007 {
1008     if (!m_platformEvent) {
1009         ThrowMsg(Commons::UnknownException, "Null platform pointer.");
1010     }
1011     time_t expires = calendar_svc_struct_get_time(m_platformEvent,
1012                                                   CAL_VALUE_GMT_REPEAT_END_DATE,
1013                                                   CAL_TZ_FLAG_GMT);
1014     m_abstractEvent->setExpires(expires);
1015 }
1016
1017 void EventWrapper::setIntervalFromPlatformEvent()
1018 {
1019     int interval = calendar_svc_struct_get_int(m_platformEvent,
1020                                                CAL_VALUE_INT_REPEAT_INTERVAL);
1021     m_abstractEvent->setInterval(interval);
1022 }
1023
1024 void EventWrapper::displayAbstractEvent()
1025 {
1026     m_abstractEvent->display();
1027 }
1028
1029 void EventWrapper::displayPlatformEvent()
1030 {
1031     LogDebug("event id: " << calendar_svc_struct_get_int(m_platformEvent,
1032                                                          CAL_VALUE_INT_INDEX));
1033     LogDebug("event start time: " << calendar_svc_struct_get_time(
1034                  m_platformEvent, CAL_VALUE_GMT_START_DATE_TIME,
1035                  CAL_TZ_FLAG_GMT));
1036     LogDebug("event end time: " << calendar_svc_struct_get_time(m_platformEvent,
1037                                                                 CAL_VALUE_GMT_END_DATE_TIME,
1038                                                                 CAL_TZ_FLAG_GMT));
1039     LogDebug("event location: " << calendar_svc_struct_get_str(m_platformEvent,
1040                                                                CAL_VALUE_TXT_LOCATION));
1041     LogDebug("event summary: " << calendar_svc_struct_get_str(m_platformEvent,
1042                                                               CAL_VALUE_TXT_SUMMARY));
1043     LogDebug("event description: " << calendar_svc_struct_get_str(
1044                  m_platformEvent, CAL_VALUE_TXT_DESCRIPTION));
1045 }
1046 }
1047 }