src/DataControl/JSSQLDataControlConsumer.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
  19 #include <CommonsJavaScript/Converter.h>
  20 #include <CommonsJavaScript/Validator.h>
  21 #include <CommonsJavaScript/JSUtils.h>
  22 #include <CommonsJavaScript/JSCallbackManager.h>
  23 #include <CommonsJavaScript/Utils.h>
  24 #include <JSWebAPIErrorFactory.h>
  25 #include <SecurityExceptions.h>
  26 #include <Commons/Exception.h>
  27 #include <TimeTracer.h>
  28 #include <ArgumentValidator.h>
  29 #include <JSUtil.h>
  30 #include "DataType.h"
  31 #include "DataControlFactory.h"
  32 #include "JSSQLDataControlConsumer.h"
  33 #include "DataControlAsyncCallbackManager.h"
  34 #include "DataControlListener.h"
  35 #include "DataControlConverter.h"
  36 #include "plugin_config.h"
  37
  38 using namespace WrtDeviceApis;
  39 using namespace WrtDeviceApis::Commons;
  40
  41 using namespace WrtDeviceApis::CommonsJavaScript;
  42
  43 using namespace DeviceAPI::Common;
  44
  45
  46 namespace DeviceAPI {
  47 namespace DataControl {
  48
  49 JSClassRef JSSQLDataControlConsumer::m_jsClassRef = NULL;
  50
  51 JSClassDefinition JSSQLDataControlConsumer::m_classInfo =
  52 {
  53         0,
  54         kJSClassAttributeNone,
  55         "DataControlConsumer",
  56         NULL,
  57         m_property,
  58         m_function,
  59         initialize,
  60         finalize,
  61         NULL,
  62         NULL,
  63         NULL,
  64         NULL,
  65         NULL,
  66         NULL,
  67         NULL,
  68         hasInstance,
  69         NULL
  70 };
  71
  72 JSStaticValue JSSQLDataControlConsumer::m_property[] = {
  73         { "type", getProperty, NULL, kJSPropertyAttributeReadOnly },
  74         { "providerId", getProperty, NULL, kJSPropertyAttributeReadOnly },
  75         { "dataId", getProperty, NULL, kJSPropertyAttributeReadOnly },
  76         { 0, 0, 0, 0 }
  77 };
  78
  79 JSStaticFunction JSSQLDataControlConsumer::m_function[] =
  80 {
  81         { "insert", JSSQLDataControlConsumer::insert, kJSPropertyAttributeNone },
  82         { "update", JSSQLDataControlConsumer::update, kJSPropertyAttributeNone },
  83         { "remove", JSSQLDataControlConsumer::remove, kJSPropertyAttributeNone },
  84         { "select", JSSQLDataControlConsumer::select, kJSPropertyAttributeNone },
  85         { 0, 0, 0 }
  86 };
  87
  88 const JSClassRef JSSQLDataControlConsumer::getClassRef()
  89 {
  90         if (!m_jsClassRef) {
  91                 m_jsClassRef = JSClassCreate(&m_classInfo);
  92         }
  93         return m_jsClassRef;
  94 }
  95
  96 const JSClassDefinition* JSSQLDataControlConsumer::getClassInfo()
  97 {
  98         return &m_classInfo;
  99 }
 100
 101 void JSSQLDataControlConsumer::initialize(JSContextRef context, JSObjectRef object)
 102 {
 103 }
 104 void JSSQLDataControlConsumer::finalize(JSObjectRef object)
 105 {
 106     JSSQLDataControlConsumerPriv *priv = static_cast<JSSQLDataControlConsumerPriv*>(JSObjectGetPrivate(object));
 107     LoggerD("finalize");
 108
 109     if (!priv) {
 110         LoggerE("Private object is null");
 111     }
 112     delete priv;
 113     priv = NULL;
 114 }
 115
 116 bool JSSQLDataControlConsumer::hasInstance(JSContextRef context, JSObjectRef constructor, JSValueRef possibleInstance, JSValueRef* exception)
 117 {
 118     return JSValueIsObjectOfClass(context, possibleInstance, getClassRef());
 119 }
 120
 121
 122 JSObjectRef JSSQLDataControlConsumer::createJSObject(JSContextRef context, std::string provId, std::string dataId, std::string type)
 123 {
 124         ISQLDataControlConsumerPtr SqlDataControlConsumer(DataControlFactory::getInstance().getSQLDataControlConsumer(provId, dataId, type));
 125         JSSQLDataControlConsumerPriv* priv = new JSSQLDataControlConsumerPriv( context, SqlDataControlConsumer);
 126         return JSObjectMake(context, getClassRef(), priv);
 127 }
 128
 129 JSValueRef JSSQLDataControlConsumer::getProperty(JSContextRef context,
 130                 JSObjectRef object,
 131                 JSStringRef propertyName,
 132                 JSValueRef* exception)
 133 {
 134         Try
 135         {
 136                 DataControlConverter converter(context);
 137                 JSSQLDataControlConsumerPriv *priv = static_cast<JSSQLDataControlConsumerPriv*>(JSObjectGetPrivate(object));
 138                 ISQLDataControlConsumerPtr dataControlConsumer(priv->getObject());
 139
 140                 std::string propertyNameStr = converter.toString(propertyName);
 141                 if(propertyNameStr == "type")
 142                 {
 143                         return converter.toJSValueRef(dataControlConsumer->getType());
 144                 }
 145                 else if(propertyNameStr == "providerId")
 146                 {
 147                         return converter.toJSValueRef(dataControlConsumer->getProviderId());
 148                 }
 149                 else if(propertyNameStr == "dataId")
 150                 {
 151                         return converter.toJSValueRef(dataControlConsumer->getDataId());
 152                 }
 153         }
 154         Catch(WrtDeviceApis::Commons::Exception)
 155         {
 156                 LoggerW("trying to get incorrect value");
 157         }
 158
 159         return JSValueMakeUndefined(context);
 160 }
 161
 162 JSValueRef JSSQLDataControlConsumer::insert(
 163         JSContextRef context, JSObjectRef object,
 164         JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[],
 165         JSValueRef* exception)
 166 {
 167         LoggerD("Enter");
 168         TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
 169
 170         AceSecurityStatus status = DATACONTROL_CHECK_ACCESS(DATACONTROL_FUNC_CONSUMER);
 171         TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 172
 173
 174         // argument validation with new validator
 175         try
 176         {
 177                 ArgumentValidator validator(context, argumentCount, arguments);
 178                 validator.toULong(0, false);
 179                 validator.toObject(1, false);
 180                 validator.toFunction(2, true);
 181                 validator.toFunction(3, true);
 182         }
 183         catch (const BasePlatformException &err)
 184         {
 185                 return JSWebAPIErrorFactory::postException(context, exception, err);
 186         }
 187         catch (...)
 188         {
 189                 DeviceAPI::Common::UnknownException err("");
 190                 return JSWebAPIErrorFactory::postException(context, exception, err);
 191         }
 192
 193
 194         DataControlConverter converter(context);
 195         JSSQLDataControlConsumerPriv *priv = static_cast<JSSQLDataControlConsumerPriv*>(JSObjectGetPrivate(thisObject));
 196         JSValueRef successCallback = NULL;
 197         JSValueRef errorCallBack = NULL;
 198         size_t index = 0;
 199         JSValueRef reserveArguments[5];
 200
 201         if (priv == NULL)
 202         {
 203                 return JSWebAPIErrorFactory::postException(context, exception,
 204                                         JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "type mismatch error");
 205         }
 206
 207         JSCallbackManagerPtr cbm = JSCallbackManager::createObject(priv->getContext(), NULL, NULL);
 208
 209
 210         Try
 211         {
 212                 for (index = 0; index < 4; index++)
 213                 {
 214                         if (index < argumentCount)
 215                                 reserveArguments[index] = arguments[index];
 216                         else
 217                                 reserveArguments[index] = JSValueMakeUndefined(context);
 218                 }
 219
 220                 ISQLDataControlConsumerPtr dataControlConsumer(priv->getObject());
 221                 EventInsertPtr event(new EventInsert);
 222
 223                 unsigned int reqId = converter.toULong(reserveArguments[0]);
 224                 RowData* rowData = converter.toRowDataPtr(reserveArguments[1]);
 225                 std::string dummyWhere = "";
 226
 227                 try
 228                 {
 229                         converter.checkRowDataSize(rowData, dummyWhere);
 230                 }
 231                 catch (const WrtDeviceApis::Commons::Exception& ex)
 232                 {
 233                         return JSWebAPIErrorFactory::postException(context, exception,
 234                                 JSWebAPIErrorFactory::INVALID_VALUES_ERROR, ex.GetMessage());
 235                 }
 236
 237                 unsigned int colSize = rowData->m_Data.size();
 238                 successCallback = converter.toFunctionOrNull(reserveArguments[2]);
 239                 errorCallBack = converter.toFunctionOrNull(reserveArguments[3]);
 240
 241                 cbm->setOnSuccess(successCallback);
 242                 cbm->setOnError(errorCallBack);
 243
 244                 event->setPrivateData(DPL::StaticPointerCast<WrtDeviceApis::Commons::IEventPrivateData> (cbm));
 245                 DataControlListener& listener = DataControlListener::getInstance();
 246
 247                 event->setReqId(reqId);
 248                 event->setRowData(rowData);
 249                 event->setColumnSize(colSize);
 250                 event->setForAsynchronousCall(&listener);
 251
 252                 dataControlConsumer->insertData(event);
 253                 DataControlAsyncCallbackManagerSingleton::Instance().registerCallbackManager(cbm, priv->getContext());
 254
 255         }
 256         Catch (WrtDeviceApis::Commons::ConversionException)
 257         {
 258                 LoggerE("ConversionException");
 259                 return JSWebAPIErrorFactory::postException(context, exception,
 260                                         JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "type mismatch error");
 261
 262         }
 263         Catch (WrtDeviceApis::Commons::InvalidArgumentException)
 264         {
 265                 LoggerE("InvalidArgumentException");
 266                 return JSWebAPIErrorFactory::postException(context, exception,
 267                                 JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "type mismatch error");
 268         }
 269         Catch(WrtDeviceApis::Commons::UnsupportedException)
 270         {
 271                 LoggerE("UnsupportException");
 272                 return JSWebAPIErrorFactory::postException(context, exception,
 273                                 JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, "Unsupport Exception");
 274         }
 275         Catch(WrtDeviceApis::Commons::Exception)
 276         {
 277                 LoggerE("UnkownException");
 278                 return JSWebAPIErrorFactory::postException(context, exception,
 279                                 JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unkown error");
 280         }
 281         TIME_TRACER_ITEM_END(__FUNCTION__, 0);
 282         return JSValueMakeUndefined(context);
 283 }
 284
 285
 286 JSValueRef JSSQLDataControlConsumer::update(
 287         JSContextRef context, JSObjectRef object,
 288         JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[],
 289         JSValueRef* exception)
 290 {
 291         LoggerD("Enter");
 292         TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
 293
 294         AceSecurityStatus status = DATACONTROL_CHECK_ACCESS(DATACONTROL_FUNC_CONSUMER);
 295         TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 296
 297         // argument validation with new validator
 298         try
 299         {
 300                 ArgumentValidator validator(context, argumentCount, arguments);
 301                 validator.toULong(0, false);
 302                 validator.toObject(1, false);
 303                 validator.toString(2, false);
 304                 validator.toFunction(3, true);
 305                 validator.toFunction(4, true);
 306         }
 307         catch (const BasePlatformException &err)
 308         {
 309                 return JSWebAPIErrorFactory::postException(context, exception, err);
 310         }
 311         catch (...)
 312         {
 313                 DeviceAPI::Common::UnknownException err("");
 314                 return JSWebAPIErrorFactory::postException(context, exception, err);
 315         }
 316
 317         DataControlConverter converter(context);
 318         JSSQLDataControlConsumerPriv *priv = static_cast<JSSQLDataControlConsumerPriv*>(JSObjectGetPrivate(thisObject));
 319         JSValueRef successCallback = NULL;
 320         JSValueRef errorCallBack = NULL;
 321         size_t index = 0;
 322         JSValueRef reserveArguments[6];
 323
 324         if (priv == NULL)
 325         {
 326                 return JSWebAPIErrorFactory::postException(context, exception,
 327                                         JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "type mismatch error");
 328         }
 329
 330
 331         JSCallbackManagerPtr cbm = JSCallbackManager::createObject(priv->getContext(), NULL, NULL);
 332
 333
 334         Try
 335         {
 336                 for (index = 0; index < 6; index++)
 337                 {
 338                         if (index < argumentCount)
 339                                 reserveArguments[index] = arguments[index];
 340                         else
 341                                 reserveArguments[index] = JSValueMakeUndefined(context);
 342                 }
 343
 344                 ISQLDataControlConsumerPtr dataControlConsumer(priv->getObject());
 345                 EventUpdatePtr event(new EventUpdate);
 346
 347                 unsigned int reqId = converter.toULong(reserveArguments[0]);
 348                 RowData* rowData = converter.toRowDataPtr(reserveArguments[1]);
 349                 unsigned int colSize = rowData->m_Data.size();
 350                 std::string where = converter.toString(reserveArguments[2]);
 351
 352                 try
 353                 {
 354                         converter.checkRowDataSize(rowData, where);
 355                 }
 356                 catch (const WrtDeviceApis::Commons::Exception& ex)
 357                 {
 358                         return JSWebAPIErrorFactory::postException(context, exception,
 359                                 JSWebAPIErrorFactory::INVALID_VALUES_ERROR, ex.GetMessage());
 360                 }
 361
 362                 successCallback = converter.toFunctionOrNull(reserveArguments[3]);
 363                 errorCallBack = converter.toFunctionOrNull(reserveArguments[4]);
 364
 365                 cbm->setOnSuccess(successCallback);
 366                 cbm->setOnError(errorCallBack);
 367
 368                 event->setPrivateData(DPL::StaticPointerCast<WrtDeviceApis::Commons::IEventPrivateData > (cbm));
 369                 DataControlListener& listener = DataControlListener::getInstance();
 370
 371
 372                 event->setReqId(reqId);
 373                 event->setWhere(where);
 374                 event->setRowData(rowData);
 375                 event->setColumnSize(colSize);
 376                 event->setForAsynchronousCall(&listener);
 377
 378                 dataControlConsumer->updateData(event);
 379                 DataControlAsyncCallbackManagerSingleton::Instance().registerCallbackManager(cbm, priv->getContext());
 380         }
 381         Catch (WrtDeviceApis::Commons::ConversionException)
 382         {
 383                 LoggerE("ConversionException");
 384                 return JSWebAPIErrorFactory::postException(context, exception,
 385                                         JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "type mismatch error");
 386
 387         }
 388         Catch (WrtDeviceApis::Commons::InvalidArgumentException)
 389         {
 390                 LoggerE("InvalidArgumentException");
 391                 return JSWebAPIErrorFactory::postException(context, exception,
 392                                 JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "type mismatch error");
 393         }
 394         Catch(WrtDeviceApis::Commons::UnsupportedException)
 395         {
 396                 LoggerE("UnsupportException");
 397                 return JSWebAPIErrorFactory::postException(context, exception,
 398                                 JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, "Unsupport Exception");
 399         }
 400         Catch(WrtDeviceApis::Commons::Exception)
 401         {
 402                 LoggerE("UnkownException");
 403                 return JSWebAPIErrorFactory::postException(context, exception,
 404                                 JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unkown error");
 405         }
 406         TIME_TRACER_ITEM_END(__FUNCTION__, 0);
 407         return JSValueMakeUndefined(context);
 408 }
 409
 410
 411 JSValueRef JSSQLDataControlConsumer::select(
 412         JSContextRef context, JSObjectRef object,
 413         JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[],
 414         JSValueRef* exception)
 415
 416 {
 417         LoggerD("Enter");
 418         TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
 419
 420         AceSecurityStatus status = DATACONTROL_CHECK_ACCESS(DATACONTROL_FUNC_CONSUMER);
 421         TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 422
 423         // argument validation with new validator
 424         try
 425         {
 426                 ArgumentValidator validator(context, argumentCount, arguments);
 427                 validator.toULong(0, false);
 428                 validator.toArrayObject(1, false);
 429                 validator.toString(2, false);
 430                 validator.toFunction(3, false);
 431                 validator.toFunction(4, true);
 432                 validator.toULong(5, true);
 433                 validator.toULong(6, true);
 434         }
 435         catch (const BasePlatformException &err)
 436         {
 437                 return JSWebAPIErrorFactory::postException(context, exception, err);
 438         }
 439         catch (...)
 440         {
 441                 DeviceAPI::Common::UnknownException err("");
 442                 return JSWebAPIErrorFactory::postException(context, exception, err);
 443         }
 444
 445
 446         JSSQLDataControlConsumerPriv *priv = static_cast<JSSQLDataControlConsumerPriv*>(JSObjectGetPrivate(thisObject));
 447         JSValueRef successCallback = NULL;
 448         JSValueRef errorCallBack = NULL;
 449         size_t index = 0;
 450         JSValueRef reserveArguments[7];
 451
 452         if (priv == NULL)
 453         {
 454                 return JSWebAPIErrorFactory::postException(context, exception,
 455                                         JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "type mismatch error");
 456         }
 457
 458         JSContextRef globalContext = priv->getContext();
 459         DataControlConverter converter(globalContext);
 460         JSCallbackManagerPtr cbm = JSCallbackManager::createObject(priv->getContext(), NULL, NULL);
 461
 462
 463         Try
 464         {
 465                 for (index = 0; index < 7; index++)
 466                 {
 467                         if (index < argumentCount)
 468                                 reserveArguments[index] = arguments[index];
 469                         else
 470                                 reserveArguments[index] = JSValueMakeUndefined(globalContext);
 471                 }
 472
 473                 ISQLDataControlConsumerPtr dataControlConsumer(priv->getObject());
 474                 EventSelectPtr event(new EventSelect);
 475
 476                 unsigned int reqId = converter.toULong(reserveArguments[0]);
 477                 unsigned long dataSize = 0;
 478
 479                 LoggerD(reqId);
 480
 481                 std::vector<std::string> columns = converter.toVectorOfStrings(reserveArguments[1]);
 482
 483                 if (columns.size() == 0)
 484                         Throw(WrtDeviceApis::Commons::ConversionException);
 485
 486                 for (size_t index = 0; index < columns.size(); index++)
 487                 {
 488                         dataSize += columns[index].size();
 489                 }
 490
 491                 std::string where = converter.toString(reserveArguments[2]);
 492                 dataSize += where.size();
 493
 494                 if (dataSize > PROTOCOL_DATA_MAX)
 495                 {
 496                         return JSWebAPIErrorFactory::postException(context, exception,
 497                                 JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Data is too big");
 498                 }
 499
 500                 successCallback = converter.toFunctionOrNull(reserveArguments[3]);
 501                 errorCallBack = converter.toFunctionOrNull(reserveArguments[4]);
 502
 503                 cbm->setOnSuccess(successCallback);
 504                 cbm->setOnError(errorCallBack);
 505
 506                 event->setPrivateData(DPL::StaticPointerCast<WrtDeviceApis::Commons::IEventPrivateData > (cbm));
 507                 DataControlListener& listener = DataControlListener::getInstance();
 508
 509                 if (JSValueIsUndefined(globalContext, reserveArguments[5]) == false)
 510                 {
 511                         std::string page = converter.toString(reserveArguments[5]);
 512                         event->setPage(page);
 513                 }
 514
 515                 if (JSValueIsUndefined(globalContext,reserveArguments[6]) == false)
 516                 {
 517                         std::string number = converter.toString(reserveArguments[6]);
 518                         event->setNumberPerPage(number);
 519                 }
 520
 521                 event->setReqId(reqId);
 522                 event->setWhere(where);
 523                 event->setForAsynchronousCall(&listener);
 524                 event->setColumns(columns);
 525                 dataControlConsumer->selectData(event);
 526                 DataControlAsyncCallbackManagerSingleton::Instance().registerCallbackManager(cbm, priv->getContext());
 527
 528         }
 529         Catch (WrtDeviceApis::Commons::ConversionException)
 530         {
 531                 LoggerE("ConversionException");
 532                 return JSWebAPIErrorFactory::postException(context, exception,
 533                                         JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "type mismatch error");
 534
 535         }
 536         Catch (WrtDeviceApis::Commons::InvalidArgumentException)
 537         {
 538                 LoggerE("InvalidArgumentException");
 539                 return JSWebAPIErrorFactory::postException(context, exception,
 540                                 JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "type mismatch error");
 541         }
 542         Catch(WrtDeviceApis::Commons::UnsupportedException)
 543         {
 544                 LoggerE("UnsupportException");
 545                 return JSWebAPIErrorFactory::postException(context, exception,
 546                                 JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, "Unsupport Exception");
 547         }
 548         Catch(WrtDeviceApis::Commons::Exception)
 549         {
 550                 LoggerE("UnkownException");
 551                 return JSWebAPIErrorFactory::postException(context, exception,
 552                                 JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unkown error");
 553         }
 554         TIME_TRACER_ITEM_END(__FUNCTION__, 0);
 555         return JSValueMakeUndefined(context);
 556 }
 557
 558 JSValueRef JSSQLDataControlConsumer::remove(
 559         JSContextRef context, JSObjectRef object,
 560         JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[],
 561         JSValueRef* exception)
 562 {
 563         LoggerD("Enter");
 564         TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
 565
 566         AceSecurityStatus status = DATACONTROL_CHECK_ACCESS(DATACONTROL_FUNC_CONSUMER);
 567         TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 568
 569         // argument validation with new validator
 570         try
 571         {
 572                 ArgumentValidator validator(context, argumentCount, arguments);
 573                 validator.toULong(0, false);
 574                 validator.toString(1, false);
 575                 validator.toFunction(2, true);
 576                 validator.toFunction(3, true);
 577         }
 578         catch (const BasePlatformException &err)
 579         {
 580                 return JSWebAPIErrorFactory::postException(context, exception, err);
 581         }
 582         catch (...)
 583         {
 584                 DeviceAPI::Common::UnknownException err("");
 585                 return JSWebAPIErrorFactory::postException(context, exception, err);
 586         }
 587
 588         DataControlConverter converter(context);
 589         JSSQLDataControlConsumerPriv *priv = static_cast<JSSQLDataControlConsumerPriv*>(JSObjectGetPrivate(thisObject));
 590         JSValueRef successCallback = NULL;
 591         JSValueRef errorCallBack = NULL;
 592         size_t index = 0;
 593         JSValueRef reserveArguments[4];
 594
 595         if (priv == NULL)
 596         {
 597                 return JSWebAPIErrorFactory::postException(context, exception,
 598                                         JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "type mismatch error");
 599         }
 600
 601         JSCallbackManagerPtr cbm = JSCallbackManager::createObject(priv->getContext(), NULL, NULL);
 602
 603
 604         Try
 605         {
 606
 607
 608                 for (index = 0; index < 4; index++)
 609                 {
 610                         if (index < argumentCount)
 611                                 reserveArguments[index] = arguments[index];
 612                         else
 613                                 reserveArguments[index] = JSValueMakeUndefined(context);
 614                 }
 615
 616                 ISQLDataControlConsumerPtr dataControlConsumer(priv->getObject());
 617                 EventDeletePtr event(new EventDelete);
 618
 619                 unsigned int reqId = converter.toULong(reserveArguments[0]);
 620                 std::string where = converter.toString(reserveArguments[1]);
 621                 successCallback = converter.toFunctionOrNull(reserveArguments[2]);
 622                 errorCallBack = converter.toFunctionOrNull(reserveArguments[3]);
 623
 624                 unsigned long dataSize = where.size();
 625
 626                 if (dataSize > PROTOCOL_DATA_MAX)
 627                 {
 628                         return JSWebAPIErrorFactory::postException(context, exception,
 629                                 JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Data is too big");
 630                 }
 631
 632
 633                 cbm->setOnSuccess(successCallback);
 634                 cbm->setOnError(errorCallBack);
 635
 636                 event->setPrivateData(DPL::StaticPointerCast<WrtDeviceApis::Commons::IEventPrivateData > (cbm));
 637                 DataControlListener& listener = DataControlListener::getInstance();
 638
 639
 640                 event->setReqId(reqId);
 641                 event->setWhere(where);
 642                 event->setForAsynchronousCall(&listener);
 643
 644                 dataControlConsumer->deleteData(event);
 645                 DataControlAsyncCallbackManagerSingleton::Instance().registerCallbackManager(cbm, priv->getContext());
 646
 647         }
 648
 649         Catch (WrtDeviceApis::Commons::ConversionException)
 650         {
 651                 LoggerE("ConversionException");
 652                 return JSWebAPIErrorFactory::postException(context, exception,
 653                                         JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "type mismatch error");
 654
 655         }
 656         Catch (WrtDeviceApis::Commons::InvalidArgumentException)
 657         {
 658                 LoggerE("InvalidArgumentException");
 659                 return JSWebAPIErrorFactory::postException(context, exception,
 660                                 JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "type mismatch error");
 661         }
 662         Catch(WrtDeviceApis::Commons::UnsupportedException)
 663         {
 664                 LoggerE("UnsupportException");
 665                 return JSWebAPIErrorFactory::postException(context, exception,
 666                                 JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, "Unsupport Exception");
 667         }
 668         Catch(WrtDeviceApis::Commons::Exception)
 669         {
 670                 LoggerE("UnkownException");
 671                 return JSWebAPIErrorFactory::postException(context, exception,
 672                                 JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unkown error");
 673         }
 674         TIME_TRACER_ITEM_END(__FUNCTION__, 0);
 675         return JSValueMakeUndefined(context);
 676 }
 677
 678
 679 }
 680 }
 681