src/modules/tizen/Calendar/Calendar.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        Calendar.cpp
  18  * @author      Lukasz Marek (l.marek@samsung.com)
  19  * @version     0.1
  20  */
  21
  22 #include <calendar-svc-provider.h>
  23 #include <dpl/log/log.h>
  24 #include <dpl/scoped_ptr.h>
  25 #include "Calendar.h"
  26 #include "CalendarManager.h"
  27
  28 namespace WrtDeviceApis {
  29 namespace Calendar {
  30
  31 using namespace Api;
  32
  33 Calendar::Calendar()
  34 {
  35     LogDebug("entered");
  36 }
  37
  38 Calendar::~Calendar()
  39 {
  40     LogDebug("entered");
  41 }
  42
  43 void Calendar::OnRequestReceived(const EventAddEventPtr &event)
  44 {
  45     LogDebug("entered");
  46     Try
  47     {
  48         if (!event->getEvent()) {
  49             ThrowMsg(Commons::NullPointerException, "event parameter is NULL");
  50         }
  51         if (event->getEvent()->getIdIsSet()) {
  52             LogWarning("adding event that is already added");
  53             event->getEvent()->resetId();
  54         }
  55         DPL::ScopedPtr<EventWrapper> eventWrapper(
  56                 new EventWrapper(event->getEvent()));
  57         eventWrapper->convertAbstractEventToPlatformEvent();
  58         if (event->checkCancelled()) {
  59             event->setCancelAllowed(true);
  60             event->setResult(true);
  61             return;
  62         }
  63         eventWrapper->saveEvent();
  64         event->setResult(true);
  65     }
  66     catch (const Commons::Exception &ex)
  67     {
  68         LogError("Error during adding event" << ex.DumpToString());
  69         event->setResult(false);
  70     }
  71     event->setCancelAllowed(false);
  72 }
  73
  74 void Calendar::OnRequestReceived(const EventDeleteEventPtr &event)
  75 {
  76     LogDebug("entered");
  77     Try
  78     {
  79         if (!event->getEvent()) {
  80             ThrowMsg(Commons::NullPointerException, "event parameter is NULL");
  81         }
  82         if (!event->getEvent()->getIdIsSet()) {
  83             ThrowMsg(Commons::InvalidArgumentException,
  84                      "Cannot delete non-existing event.");
  85         }
  86         DPL::ScopedPtr<EventWrapper> eventWrapper(new EventWrapper(
  87                                                       event->getEvent()));
  88         eventWrapper->convertAbstractEventToPlatformEvent();
  89         if (event->checkCancelled()) {
  90             event->setCancelAllowed(true);
  91             event->setResult(true);
  92             return;
  93         }
  94         eventWrapper->deleteEvent();
  95         event->setResult(true);
  96     }
  97     catch (const Commons::NotFoundException &ex)
  98     {
  99         LogError("event doesn't exist");
 100         event->setResult(false);
 101         event->setExceptionCode(Commons::ExceptionCodes::NotFoundException);
 102     }
 103     catch (const Commons::Exception &ex)
 104     {
 105         LogError("Error during deleting event " << ex.DumpToString());
 106         event->setResult(false);
 107     }
 108     event->setCancelAllowed(false);
 109 }
 110
 111 void Calendar::OnRequestReceived(const EventUpdateEventPtr &event)
 112 {
 113     LogDebug("entered");
 114     Try
 115     {
 116         if (!event->getEvent()) {
 117             ThrowMsg(Commons::NullPointerException, "event parameter is NULL");
 118         }
 119         if (!event->getEvent()->getIdIsSet()) {
 120             ThrowMsg(
 121                 Commons::InvalidArgumentException,
 122                 "Cannot update non-existing event. Event needs adding or ID is wrong");
 123         }
 124         DPL::ScopedPtr<EventWrapper> eventWrapper(new EventWrapper(
 125                                                       event->getEvent()));
 126         eventWrapper->convertAbstractEventToPlatformEvent();
 127         if (event->checkCancelled()) {
 128             event->setCancelAllowed(true);
 129             event->setResult(true);
 130             return;
 131         }
 132         eventWrapper->saveEvent();
 133         event->setResult(true);
 134     }
 135     catch (const Commons::Exception &ex)
 136     {
 137         LogError("Error during updating event " << ex.DumpToString());
 138         event->setResult(false);
 139     }
 140     event->setCancelAllowed(false);
 141 }
 142
 143 void Calendar::OnRequestReceived(const EventFindEventsPtr &event)
 144 {
 145     LogDebug("entered");
 146     const EventFilterPtr &filter = event->getFilter();
 147     cal_struct *platformEvent = NULL;
 148     cal_iter *iter = NULL;
 149     int foundCnt = 0;
 150     event->setResult(true);
 151
 152     try {
 153         if (CAL_SUCCESS !=
 154             calendar_svc_get_all(0, 0, CAL_STRUCT_SCHEDULE, &iter)) {
 155             ThrowMsg(Commons::PlatformException, "Can't get all records");
 156         }
 157         //TODO: currently platform starts iteration with below function
 158         // It's possible that current approach will change to be familiar with std iterators
 159
 160         while (CAL_SUCCESS == calendar_svc_iter_next(iter)) {
 161             event->tryCancelled();
 162             if (CAL_SUCCESS !=
 163                 calendar_svc_iter_get_info(iter, &platformEvent)) {
 164                 ThrowMsg(Commons::PlatformException, "Can't get event info.");
 165             }
 166             //getting ID
 167             int eventId = calendar_svc_struct_get_int(platformEvent,
 168                                                       CAL_VALUE_INT_INDEX);
 169             if (CAL_SUCCESS != calendar_svc_struct_free(&platformEvent)) {
 170                 LogError("Can't free calendar event struct.");
 171             }
 172
 173             DPL::ScopedPtr<EventWrapper> eventWrapper(new EventWrapper());
 174             eventWrapper->loadEvent(eventId);
 175             if (!filter || eventWrapper->matchFilters(filter)) {
 176                 if (foundCnt >= event->getFirstEvent() &&
 177                     (event->getLastEvent() == -1 || foundCnt <=
 178                         event->getLastEvent())) {
 179                     event->addEvent(eventWrapper->getAbstractEvent());
 180                 }
 181                 foundCnt++;
 182             }
 183         }
 184     }
 185     catch (const Commons::Exception &ex)
 186     {
 187         LogError("Exception: " << ex.DumpToString());
 188         event->setResult(false);
 189     }
 190     //According to example in calendar-svc-provider.h it's not needed to pass here
 191     //iter set on first element
 192     calendar_svc_iter_remove(&iter);
 193     event->setCancelAllowed(true);
 194 }
 195
 196 void Calendar::OnRequestReceived(const EventCreateEventPtr &event)
 197 {
 198     LogDebug("entered");
 199     Try
 200     {
 201         event->setEvent(CalendarEventPtr(new CalendarEvent()));
 202         event->setResult(event->getEvent().Get() != NULL);
 203     }
 204     catch (const Commons::Exception &ex)
 205     {
 206         LogError("Error during creating an event " << ex.DumpToString());
 207         event->setResult(false);
 208     }
 209 }
 210
 211 }
 212 }