src/Calendar/JSCalendarEventId.cpp

   1 //
   2 // Tizen Web Device API
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
  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 "JSCalendarEventId.h"
  19 #include "CalendarConverter.h"
  20 #include <JSTizenExceptionFactory.h>
  21 #include <JSTizenException.h>
  22 #include <CommonsJavaScript/Converter.h>
  23 #include <TimeUtilConverter.h>
  24 #include <JSTZDate.h>
  25 #include <sstream>
  26 #include <Logger.h>
  27
  28 using namespace WrtDeviceApis::Commons;
  29 using namespace WrtDeviceApis::CommonsJavaScript;
  30 using namespace DeviceAPI::Common;
  31
  32 namespace DeviceAPI {
  33 namespace Calendar {
  34
  35 JSClassDefinition JSCalendarEventId::m_classInfo = {
  36     0,
  37     kJSClassAttributeNone,
  38     TIZEN_INTERFACE_CALENDAR_EVENT_ID,
  39     0,
  40     m_property,
  41     NULL, //m_function,
  42     initialize,
  43     finalize,
  44     NULL, //hasProperty,
  45     NULL, //getProperty,
  46     NULL, //setProperty,
  47     NULL, //deleteProperty,
  48     NULL, //getPropertyNames,
  49     NULL, //callAsFunction,
  50     constructor,
  51     NULL, //hasInstance,
  52     NULL, //convertToType,
  53 };
  54
  55 JSStaticValue JSCalendarEventId::m_property[] = {
  56     { TIZEN_CALENDAR_EVENT_ID_UID, getProperty, setProperty, kJSPropertyAttributeNone },
  57     { TIZEN_CALENDAR_EVENT_ID_RECURRENCEID, getProperty, setProperty, kJSPropertyAttributeNone },
  58     { 0, 0, 0, 0 }
  59 };
  60
  61 JSClassRef JSCalendarEventId::m_jsClassRef = JSClassCreate(
  62         JSCalendarEventId::getClassInfo());
  63
  64 const JSClassDefinition* JSCalendarEventId::getClassInfo()
  65 {
  66     return &(m_classInfo);
  67 }
  68
  69 JSClassRef JSCalendarEventId::getClassRef()
  70 {
  71     if (!m_jsClassRef) {
  72         m_jsClassRef = JSClassCreate(&m_classInfo);
  73     }
  74     return m_jsClassRef;
  75 }
  76
  77 EventIdPtr JSCalendarEventId::getPrivateObject(JSObjectRef object)
  78 {
  79     EventIdPrivateObject *priv =
  80         static_cast<EventIdPrivateObject*>(JSObjectGetPrivate(object));
  81     if (!priv) {
  82         ThrowMsg(NullPointerException, "Private object is null");
  83     }
  84     EventIdPtr result = priv->getObject();
  85     if (!result) {
  86         ThrowMsg(NullPointerException, "Private object is null");
  87     }
  88     return result;
  89 }
  90
  91 void JSCalendarEventId::setPrivateObject(const EventIdPtr &eventId,
  92         JSContextRef ctx,
  93         const JSObjectRef object)
  94 {
  95     Try
  96     {
  97         EventIdPrivateObject *priv =
  98             static_cast<EventIdPrivateObject*>(JSObjectGetPrivate(object));
  99         delete priv;
 100         priv = new EventIdPrivateObject(ctx, eventId);
 101         if (!JSObjectSetPrivate(object, static_cast<void*>(priv))) {
 102             delete priv;
 103         }
 104     }
 105     Catch(Exception)
 106     {
 107         LoggerE("Error during replacing event id object.");
 108     }
 109 }
 110
 111 JSObjectRef JSCalendarEventId::createJSCalendarEventId(JSContextRef context, EventIdPtr eventId)
 112 {
 113     EventIdPrivateObject *priv = new EventIdPrivateObject(context, eventId);
 114     return JSObjectMake(context, getClassRef(), priv);
 115 }
 116
 117 void JSCalendarEventId::initialize(JSContextRef context,
 118         JSObjectRef object)
 119 {
 120     if (!JSObjectGetPrivate(object)) {
 121         LoggerD("Create calendar event id private object.");
 122         EventIdPtr eventId( new EventId() );
 123         EventIdPrivateObject *priv = new EventIdPrivateObject(context, eventId);
 124         if (!JSObjectSetPrivate(object, static_cast<void*>(priv))) {
 125             delete priv;
 126         }
 127     } else {
 128         LoggerD("Private object already set.");
 129     }
 130 }
 131
 132 void JSCalendarEventId::finalize(JSObjectRef object)
 133 {
 134     EventIdPrivateObject* priv = static_cast<EventIdPrivateObject*>(JSObjectGetPrivate(object));
 135     if (priv) {
 136         delete priv;
 137         JSObjectSetPrivate(object, NULL);
 138     }
 139 }
 140
 141 JSObjectRef JSCalendarEventId::constructor(JSContextRef context,
 142     JSObjectRef constructor,
 143     size_t argumentCount,
 144     const JSValueRef arguments[],
 145     JSValueRef* exception)
 146 {
 147     Try
 148     {
 149         CalendarConverter converter(context);
 150         EventIdPtr eventId;
 151
 152         if (argumentCount==0) {
 153             EventIdPtr result( new EventId());
 154             eventId = result;
 155         } else if (argumentCount==1) {
 156             EventIdPtr result( new EventId());
 157             eventId = result;
 158             eventId->setUId(converter.toString(arguments[0]));
 159         } else if (argumentCount>=2) {
 160             EventIdPtr result( new EventId());
 161             eventId = result;
 162             eventId->setUId(converter.toString(arguments[0]));
 163             eventId->setRecurrenceId(converter.toString(arguments[1]));
 164         }
 165
 166         return createJSCalendarEventId(context, eventId);
 167     }
 168     Catch(UnsupportedException)
 169     {
 170         LoggerW("Exception: "<<_rethrown_exception.GetMessage());
 171         *exception = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
 172     }
 173     Catch(InvalidArgumentException)
 174     {
 175         LoggerW("Exception: "<<_rethrown_exception.GetMessage());
 176         *exception = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
 177     }
 178     Catch(ConversionException)
 179     {
 180         LoggerW("Exception: "<<_rethrown_exception.GetMessage());
 181         *exception = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
 182     }
 183     Catch(Exception)
 184     {
 185         LoggerW("Exception: "<<_rethrown_exception.GetMessage());
 186         *exception = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
 187     }
 188
 189     return NULL;
 190 }
 191
 192 JSValueRef JSCalendarEventId::getProperty(JSContextRef context,
 193         JSObjectRef object,
 194         JSStringRef propertyName,
 195         JSValueRef* exception)
 196 {
 197     Try
 198     {
 199         EventIdPrivateObject* priv = static_cast<EventIdPrivateObject*>(JSObjectGetPrivate(object));
 200         if (!priv) {
 201             ThrowMsg(NullPointerException, "Private object is NULL.");
 202         }
 203
 204         EventIdPtr eventId = priv->getObject();
 205         if (!eventId) {
 206             ThrowMsg(NullPointerException, "EventId is NULL.");
 207         }
 208
 209         Converter converter(context);
 210         if (JSStringIsEqualToUTF8CString(propertyName, TIZEN_CALENDAR_EVENT_ID_UID)) {
 211             if (eventId->getUId()==UNDEFINED_ID) {
 212                 return JSValueMakeNull(context);
 213             } else {
 214                 return converter.toJSValueRef(eventId->getUId());
 215             }
 216         } else if (JSStringIsEqualToUTF8CString(propertyName, TIZEN_CALENDAR_EVENT_ID_RECURRENCEID)) {
 217             if (eventId->getRecurrenceId()==UNDEFINED_ID) {
 218                 return JSValueMakeNull(context);
 219             } else {
 220                 return converter.toJSValueRef(eventId->getRecurrenceId());
 221             }
 222         }
 223     }
 224     Catch(Exception)
 225     {
 226                 LoggerW("Exception: "<<_rethrown_exception.GetMessage());
 227     }
 228     return JSValueMakeUndefined(context);
 229 }
 230
 231 bool JSCalendarEventId::setProperty(JSContextRef context,
 232         JSObjectRef object,
 233         JSStringRef propertyName,
 234         JSValueRef value,
 235         JSValueRef* exception)
 236 {
 237     Try
 238     {
 239         EventIdPrivateObject* priv = static_cast<EventIdPrivateObject*>(JSObjectGetPrivate(object));
 240         if (!priv) {
 241             ThrowMsg(NullPointerException, "Private object is NULL.");
 242         }
 243
 244         EventIdPtr eventId = priv->getObject();
 245         Converter converter(context);
 246         if (JSStringIsEqualToUTF8CString(propertyName, TIZEN_CALENDAR_EVENT_ID_UID)) {
 247             std::string uid = converter.toString(value);
 248             eventId->setUId(uid);
 249             return true;
 250         } else if (JSStringIsEqualToUTF8CString(propertyName, TIZEN_CALENDAR_EVENT_ID_RECURRENCEID)) {
 251             std::string recurrenceId = converter.toString(value);
 252             eventId->setRecurrenceId(recurrenceId);
 253             return true;
 254         }
 255     }
 256     Catch(Exception)
 257     {
 258                 LoggerW("Exception: "<<_rethrown_exception.GetMessage());
 259     }
 260
 261     return true;
 262 }
 263
 264 }
 265 }