src/platform/API/Messaging/ReqReceiverMessage.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 /**
  18  * @file       ReqReceiverMessage.cpp
  19  * @author     Pawel Misiak (p.misiak@samsung.com)
  20  * @version    0.1
  21  * @brief
  22  */
  23 #include <vector>
  24 #include <Commons/Exception.h>
  25 #include "ReqReceiverMessage.h"
  26 #include "IMessaging.h"
  27 #include "IMessage.h"
  28
  29 #include "MessageFilterValidatorFactory.h"
  30 #include "ConversationFilterValidatorFactory.h"
  31 #include "FolderFilterValidatorFactory.h"
  32
  33
  34 using namespace std;
  35 using namespace TizenApis::Api::Tizen;
  36 using namespace TizenApis::Platform::Messaging;
  37 using namespace WrtDeviceApis::Commons;
  38
  39 namespace TizenApis {
  40 namespace Api {
  41 namespace Messaging {
  42
  43 ReqReceiverMessage::ReqReceiverMessage() :
  44     EventAddDraftMessageReqReceiver(ThreadEnum::MESSAGING_THREAD),
  45     EventSendMessageReqReceiver(ThreadEnum::MESSAGING_THREAD),
  46     EventUpdateMessageReqReceiver(ThreadEnum::MESSAGING_THREAD),
  47     EventDeleteMessageReqReceiver(ThreadEnum::MESSAGING_THREAD),
  48     EventDeleteMessagesReqReceiver(ThreadEnum::MESSAGING_THREAD),
  49     EventUpdateMessagesReqReceiver(ThreadEnum::MESSAGING_THREAD),
  50     EventQueryMessagesReqReceiver(ThreadEnum::MESSAGING_THREAD),
  51     EventGetConversationIdReqReceiver(ThreadEnum::MESSAGING_THREAD),
  52     EventQueryConversationsReqReceiver(ThreadEnum::MESSAGING_THREAD),
  53     EventDeleteConversationsReqReceiver(ThreadEnum::MESSAGING_THREAD),
  54     EventQueryFoldersReqReceiver(ThreadEnum::MESSAGING_THREAD),
  55     EventMessagingServiceReqReceiver(ThreadEnum::MESSAGING_THREAD)
  56 {
  57     LogDebug("create receiver for messaging");
  58 }
  59
  60 ReqReceiverMessage::~ReqReceiverMessage()
  61 {
  62 }
  63
  64 void ReqReceiverMessage::addDraftMessage(const EventAddDraftMessagePtr& event)
  65 {
  66     LogDebug("enter");
  67     EventAddDraftMessageReqReceiver::PostRequest(event);
  68 }
  69
  70 void ReqReceiverMessage::sendMessage(const EventSendMessagePtr& event)
  71 {
  72     LogDebug("enter");
  73     EventSendMessageReqReceiver::PostRequest(event);
  74 }
  75
  76 void ReqReceiverMessage::updateMessage(const EventUpdateMessagePtr& event)
  77 {
  78     LogDebug("enter");
  79     EventUpdateMessageReqReceiver::PostRequest(event);
  80 }
  81
  82 void ReqReceiverMessage::deleteMessage(const EventDeleteMessagePtr& event)
  83 {
  84     LogDebug("enter");
  85     EventDeleteMessageReqReceiver::PostRequest(event);
  86 }
  87
  88 void ReqReceiverMessage::deleteMessages(const EventDeleteMessagesPtr& event)
  89 {
  90     LogDebug("enter");
  91     EventDeleteMessagesReqReceiver::PostRequest(event);
  92 }
  93
  94 void ReqReceiverMessage::updateMessages(const EventUpdateMessagesPtr& event)
  95 {
  96     LogDebug("enter");
  97     EventUpdateMessagesReqReceiver::PostRequest(event);
  98 }
  99
 100 void ReqReceiverMessage::queryMessages(const EventQueryMessagesPtr& event)
 101 {
 102     LogDebug("enter");
 103     EventQueryMessagesReqReceiver::PostRequest(event);
 104 }
 105
 106
 107 void ReqReceiverMessage::getConversationId(const EventGetConversationIdPtr& event)
 108 {
 109         LogDebug("enter");
 110         EventGetConversationIdReqReceiver::PostRequest(event);
 111 }
 112
 113 void ReqReceiverMessage::queryConversations(const EventQueryConversationsPtr& event)
 114 {
 115         LogDebug("enter");
 116         EventQueryConversationsReqReceiver::PostRequest(event);
 117 }
 118
 119 void ReqReceiverMessage::deleteConversations(const EventDeleteConversationsPtr& event)
 120 {
 121         LogDebug("enter");
 122         EventDeleteConversationsReqReceiver::PostRequest(event);
 123 }
 124
 125 void ReqReceiverMessage::queryFolders(const EventQueryFoldersPtr& event)
 126 {
 127         LogDebug("enter");
 128         EventQueryFoldersReqReceiver::PostRequest(event);
 129 }
 130
 131 void ReqReceiverMessage::loadMessageBody(const EventMessagingServicePtr& event)
 132 {
 133         LogDebug("enter");
 134         EventMessagingServiceReqReceiver::PostRequest(event);
 135 }
 136
 137 void ReqReceiverMessage::loadMessageAttachment(const EventMessagingServicePtr& event)
 138 {
 139         LogDebug("enter");
 140         EventMessagingServiceReqReceiver::PostRequest(event);
 141 }
 142
 143 void ReqReceiverMessage::sync(const EventMessagingServicePtr& event)
 144 {
 145         LogDebug("enter");
 146         EventMessagingServiceReqReceiver::PostRequest(event);
 147 }
 148
 149 void ReqReceiverMessage::syncFolder(const EventMessagingServicePtr& event)
 150 {
 151         LogDebug("enter");
 152         EventMessagingServiceReqReceiver::PostRequest(event);
 153 }
 154
 155 void ReqReceiverMessage::OnRequestReceived(const EventAddDraftMessagePtr& event)
 156 {
 157     LogDebug("enter");
 158
 159     Try {
 160         IMessagePtr msg = event->msg;
 161         if (!event->checkCancelled()) {
 162             event->setCancelAllowed(false);
 163             msg->addMessageToDraft();
 164         } else {
 165             event->setCancelAllowed(true);
 166         }
 167     }
 168     Catch(WrtDeviceApis::Commons::PlatformException) {
 169         MsgLogError("platform exception");
 170         event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::UnknownException);
 171     }
 172
 173 }
 174
 175 void ReqReceiverMessage::OnRequestReceived(const EventSendMessagePtr& event)
 176 {
 177     LogDebug("enter");
 178
 179     Try {
 180                 IMessagePtr msg = event->msg;
 181                 //this prevents calling BONDI, Tizen callback immidiately after leaving this function
 182                 //callback will be called after receving platform callback.
 183                 msg->setRequestReceiver(this);
 184                 msg->setSendMessageEvent(event);
 185                 if (!event->checkCancelled()) {
 186                         event->setCancelAllowed(false);
 187                         event->switchToManualAnswer();
 188                         int handle = msg->send();
 189                         LogDebug("handle : " << handle);
 190                         if (event->opId && event->m_messagingService)
 191                         {
 192                                 event->m_messagingService->setHandleToOpId(event->opId, handle);
 193                         }
 194                 } else {
 195                         event->setCancelAllowed(true);
 196                 }
 197     }
 198     Catch(WrtDeviceApis::Commons::PlatformException) {
 199         event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::UnknownException);
 200         WrtDeviceApis::Commons::EventRequestReceiver<EventSendMessage>::ManualAnswer(event);
 201     }
 202 }
 203
 204 void ReqReceiverMessage::OnRequestReceived(const EventUpdateMessagePtr& event)
 205 {
 206     LogDebug("enter");
 207
 208     Try {
 209         IMessagePtr msg = event->msg;
 210         if (!event->checkCancelled()) {
 211             event->setCancelAllowed(false);
 212             msg->update(true);
 213         } else {
 214             event->setCancelAllowed(true);
 215         }
 216     }
 217     Catch(WrtDeviceApis::Commons::PlatformException) {
 218         MsgLogError("platform exception");
 219         event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::UnknownException);
 220     }
 221 }
 222
 223 void ReqReceiverMessage::OnRequestReceived(const EventDeleteMessagePtr& event)
 224 {
 225     LogDebug("enter");
 226
 227     Try {
 228         IMessagePtr msg = event->msg;
 229         msg->remove();
 230     }
 231     Catch(WrtDeviceApis::Commons::PlatformException) {
 232         MsgLogError("platform exception");
 233         event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::UnknownException);
 234     }
 235 }
 236
 237 bool ReqReceiverMessage::validateFilter(const Tizen::FilterPtr& filter){
 238         LogDebug("<<<");
 239
 240         bool retBool = false;
 241
 242         if(filter != NULL){
 243                 MessageFilterValidatorPtr validator =
 244                                 MessageFilterValidatorFactory::getMessageFilterValidator();
 245
 246                 FilterValidatorPtr filterValidator = DPL::StaticPointerCast<FilterValidator>(validator);
 247                 retBool = filter->validate(filterValidator);
 248                 LogDebug("retBool:" << retBool);
 249                 if(retBool == false){
 250                         MsgLogError(">>> Validate FAIL InvalidArgumentException");
 251                         Throw(WrtDeviceApis::Commons::InvalidArgumentException);
 252                 }
 253         }else{
 254                 LogDebug("filter is NULL");
 255                 retBool = false;
 256         }
 257
 258         LogDebug(">>> retBool:" << retBool);
 259         return retBool;
 260
 261 }
 262
 263 void ReqReceiverMessage::OnRequestReceived(const EventDeleteMessagesPtr& event)
 264 {
 265         LogDebug("enter");
 266
 267         Try {
 268                 Tizen::FilterPtr filter = event->getFilter();
 269                 if(filter != NULL){
 270                         bool isValidFilter = validateFilter(filter);
 271                         if(isValidFilter == false){
 272                                 Throw(WrtDeviceApis::Commons::InvalidArgumentException);
 273                         }
 274
 275                         event->msgArray = IMessaging::getInstance().findMessages(event->getFilter());
 276                 }
 277
 278                 std::vector<Api::Messaging::IMessagePtr> msg = event->msgArray;
 279                 LogDebug("msg.size()" << msg.size());
 280
 281                 int vecSize = msg.size();
 282                 for(int i=0; i < vecSize; i++){
 283                         int type = msg[i]->getMessageType();
 284                         std::string id = msg[i]->getId();
 285                         MsgLogError("type :"<<type);
 286                         MsgLogError("id :"<<id);
 287                         MsgLogError("body" << msg[i]->getBody());
 288                         msg[i]->remove();
 289                 }//for
 290         }Catch(WrtDeviceApis::Commons::PlatformException) {
 291                 MsgLogError("platform exception");
 292                 event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::UnknownException);
 293         }
 294 }
 295
 296 void ReqReceiverMessage::OnRequestReceived(const EventUpdateMessagesPtr& event)
 297 {
 298     LogDebug("enter");
 299
 300     Try {
 301         std::vector<Api::Messaging::IMessagePtr> msg = event->msgArray;
 302         LogDebug("msg.size()" << msg.size());
 303         int vecSize = msg.size();
 304         for(int i=0; i < vecSize; i++)
 305         {
 306 //            int type = msg[i]->getMessageType();
 307             std::string id = msg[i]->getId();
 308             msg[i]->updateIsRead();
 309         }
 310     }
 311     Catch(WrtDeviceApis::Commons::PlatformException) {
 312         MsgLogError("platform exception");
 313         event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::UnknownException);
 314     }
 315 }
 316
 317 void ReqReceiverMessage::OnRequestReceived(const EventQueryMessagesPtr& event)
 318 {
 319     LogDebug("<<<");
 320
 321         Try {
 322
 323                 vector<IMessagePtr> msgs;
 324
 325                 //check filter validation
 326                 Tizen::FilterPtr filter = event->getFilter();
 327                 bool isValidFilter = validateFilter(filter);
 328                 if(isValidFilter == false){
 329                         MsgLogError("[ERROR]this filter is invalid");
 330                         Throw(WrtDeviceApis::Commons::InvalidArgumentException);
 331                 }
 332
 333                 // using filter
 334                 vector<IMessagePtr> tmp = IMessaging::getInstance().findMessages(event->getFilter(), event->getSortMode(), event->getLimit(), event->getOffset());
 335                 msgs.insert(msgs.end(), tmp.begin(), tmp.end());
 336                 event->msgs = msgs;
 337
 338         }Catch(WrtDeviceApis::Commons::PlatformException) {
 339                 MsgLogError("platform exception");
 340                 event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::UnknownException);
 341         }Catch(WrtDeviceApis::Commons::InvalidArgumentException){
 342                 MsgLogError("InvalidArgumentException");
 343                 event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::InvalidArgumentException);
 344         }
 345 }
 346
 347 void ReqReceiverMessage::OnRequestReceived(const EventGetConversationIdPtr& event)
 348 {
 349         LogDebug("enter");
 350
 351         Try {
 352                 Api::Messaging::IMessagePtr msg = event->getConversationMsgPtr();
 353                 Api::Messaging::MessageType msgType = msg->getMessageType();
 354                 unsigned int msgId = 0;
 355
 356                 if (msgType == EMAIL)
 357                 {
 358                         Api::Messaging::IEmailPtr email = Api::Messaging::MessageFactory::convertToEmail(msg);
 359                         msgId = email->getUID();
 360
 361                 }
 362                 else
 363                 {
 364                         msgId = msg->convertId(msg->getId());
 365                 }
 366
 367                 int conversationId = IMessaging::getInstance().getConversationId(msgId, msgType);
 368                 LogDebug("Cond Id:" << conversationId);
 369                 event->setConversationId(conversationId);
 370         }
 371         Catch(WrtDeviceApis::Commons::PlatformException) {
 372                 MsgLogError("platform exception");
 373                 event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::UnknownException);
 374         }
 375 }
 376
 377 void ReqReceiverMessage::OnRequestReceived(const EventQueryConversationsPtr& event)
 378 {
 379         LogDebug("<<<");
 380
 381         Try
 382         {
 383                 //check filter validation
 384                 Tizen::FilterPtr filter = event->getFilter();
 385                 if(filter != NULL){
 386                         ConversationFilterValidatorPtr validator =
 387                                         ConversationFilterValidatorFactory::getConversationFilterValidator();
 388
 389                         FilterValidatorPtr filterValidator = DPL::StaticPointerCast<FilterValidator>(validator);
 390                         bool isValidFilter = filter->validate(filterValidator);
 391                         if(isValidFilter == false){
 392                                 MsgLogError("[ERROR]Filter is Invalid");
 393                                 Throw(WrtDeviceApis::Commons::InvalidArgumentException);
 394                         }
 395                 }
 396
 397                 vector<IConversationPtr> tmp = IMessaging::getInstance().queryConversations(event->getSortMode(), event->getFilter(), event->getLimit(), event->getOffset());
 398                 event->addConversations(tmp);
 399
 400         }
 401         Catch(WrtDeviceApis::Commons::PlatformException)
 402         {
 403                 MsgLogError("platform exception");
 404                 event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::UnknownException);
 405         }
 406         Catch(WrtDeviceApis::Commons::InvalidArgumentException)
 407         {
 408                 MsgLogError("InvalidArgumentException");
 409                 event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::InvalidArgumentException);
 410         }
 411 }
 412
 413 void ReqReceiverMessage::OnRequestReceived(const EventMessagingServicePtr& event)
 414 {
 415     LogDebug("enter : EventMessagingServicePtr");
 416
 417     Try {
 418                 LogDebug("event type :" << event->getEventType() );
 419                 int MessagingServiceEventType = event->getEventType();
 420
 421                 if (MessagingServiceEventType == EventMessagingService::MESSAGING_SERVICE_EVENT_TYPE_LOAD_MESSAGE_BODY)
 422                 {
 423                         if (!event->checkCancelled()) {
 424                                 IMessagePtr msg = event->m_message;
 425                                 if(msg)
 426                                 {
 427                                         msg->setRequestReceiver(this);
 428                                 msg->setMessagingServiceEvent(event);
 429
 430                                         int type = msg->getMessageType();
 431                                         LogDebug("message type :" << type);
 432                                         if ( msg->getMessageType() == Api::Messaging::EMAIL )
 433                                         {
 434                                                 IEmailPtr email = MessageFactory::convertToEmail(msg);
 435                                                 event->switchToManualAnswer();          //switch to manual answer;
 436                                                 int handle = email->downloadBody();
 437                                                 LogDebug("Load Message Body handle : " << handle);
 438                                                 if (event->opId && event->m_messagingService)
 439                                                 {
 440                                                         event->m_messagingService->setHandleToOpId(event->opId, handle);
 441                                                 }
 442                                         }
 443                                 }
 444                                 else {
 445                                 LogDebug(" invaild message. ");
 446                                         event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::InvalidArgumentException);
 447                                 }
 448
 449                         }
 450                         else
 451                         {
 452                                 LogDebug(" Cancel ");
 453                                 event->setCancelAllowed(true);
 454                         }
 455                 }
 456
 457                 else if (MessagingServiceEventType == EventMessagingService::MESSAGING_SERVICE_EVENT_TYPE_LOAD_MESSAGE_ATTACHMENT)
 458                 {
 459                         if (!event->checkCancelled()) {
 460                                 IMessagePtr msg = event->m_message;
 461                                 if(msg)
 462                                 {
 463                                         msg->setRequestReceiver(this);
 464                                 msg->setMessagingServiceEvent(event);
 465
 466                                         int type = msg->getMessageType();
 467                                         LogDebug("message type :" << type);
 468                                         if ( msg->getMessageType() == Api::Messaging::EMAIL )
 469                                         {
 470                                                 IEmailPtr email = MessageFactory::convertToEmail(msg);
 471                                                 event->switchToManualAnswer();          //switch to manual answer;
 472                                                 int handle = email->downloadAttachment(event->m_attachment);
 473                                                 LogDebug("Load Message Attachment handle : " << handle);
 474                                                 if (event->opId && event->m_messagingService)
 475                                                 {
 476                                                         event->m_messagingService->setHandleToOpId(event->opId, handle);
 477                                                 }
 478                                         }
 479                                         else
 480                                         {
 481                                                 LogDebug(" invaild message. ");
 482                                                 event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::InvalidArgumentException);
 483                                         }
 484                                 }
 485                         }
 486                         else
 487                         {
 488                                 LogDebug(" cancel. ");
 489                                 event->setCancelAllowed(true);
 490                         }
 491
 492                 }
 493
 494                 else if (MessagingServiceEventType == EventMessagingService::MESSAGING_SERVICE_EVENT_TYPE_SYNC)
 495                 {
 496                         if (event->m_messagingService)
 497                         {
 498                                 if (!event->checkCancelled()) {
 499                                         int type = event->m_messagingService->getType();
 500                                         LogDebug("messaging service type :" << type);
 501
 502                                         event->m_messagingService->setRequestReceiver(this);
 503                                         event->m_messagingService->setMessagingServiceEvent(event);     //
 504
 505                                         if (type == Api::Messaging::EMAIL)
 506                                         {
 507                                                 event->switchToManualAnswer(); //switch to manual answer;
 508                                                 LogDebug("privateData->getAccountId() :" << event->m_messagingService->getAccountID());
 509
 510                                                 if ( event->m_messagingService->getAccountID() > 0)
 511                                                 {
 512                                                         int handle = event->m_messagingService->sync( event->m_messagingService, event->m_sync_limit );
 513                                                         LogDebug("Sync handle : " << handle);
 514                                                         if (event->opId && event->m_messagingService)
 515                                                         {
 516                                                                 event->m_messagingService->setHandleToOpId(event->opId, handle);
 517                                                         }
 518                                                 }
 519                                                 else
 520                                                         event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::InvalidArgumentException);
 521                                         }
 522                                         else
 523                                         {
 524                                                 event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::InvalidArgumentException);
 525                                         }
 526                                 }
 527                                 else
 528                                 {
 529                                         LogDebug(" cancel. ");
 530                                         event->setCancelAllowed(true);
 531                                 }
 532                         }
 533
 534                 }
 535                 else if (MessagingServiceEventType == EventMessagingService::MESSAGING_SERVICE_EVENT_TYPE_SYNC_FOLDER)
 536                 {
 537                         if (event->m_messagingService)
 538                         {
 539                                 if (!event->checkCancelled()) {
 540                                         int type = event->m_messagingService->getType();
 541                                         LogDebug("messaging service type :" << type);
 542
 543                                         event->m_messagingService->setRequestReceiver(this);
 544                                         event->m_messagingService->setMessagingServiceEvent(event);     //
 545
 546                                         if (type == Api::Messaging::EMAIL)
 547                                         {
 548                                                 event->switchToManualAnswer(); //switch to manual answer;
 549                                                 LogDebug("privateData->getAccountId() :" << event->m_messagingService->getAccountID());
 550
 551                                                 if ( event->m_messagingService->getAccountID() > 0)
 552                                                 {
 553                                                         int handle = event->m_messagingService->syncFolder( event->m_messagingService, event->m_folder_name, event->m_sync_limit);
 554                                                         LogDebug("Sync Folder handle : " << handle);
 555                                                         if (event->opId && event->m_messagingService)
 556                                                         {
 557                                                                 event->m_messagingService->setHandleToOpId(event->opId, handle);
 558                                                         }
 559                                                 }
 560                                                 else
 561                                                         event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::InvalidArgumentException);
 562                                         }
 563                                         else
 564                                         {
 565                                                 event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::InvalidArgumentException);
 566                                         }
 567                                 }
 568                                 else
 569                                 {
 570                                         LogDebug(" cancel. ");
 571                                         event->setCancelAllowed(true);
 572                                 }
 573                         }
 574                 }
 575                 else
 576                 {
 577                         LogDebug(" Cancel ");
 578                         event->setCancelAllowed(true);
 579                 }
 580
 581     }
 582     Catch (WrtDeviceApis::Commons::PlatformException) {
 583           MsgLogError("platform exception");
 584         event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::UnknownException);
 585     }
 586
 587 }
 588
 589 void ReqReceiverMessage::OnRequestReceived(const EventDeleteConversationsPtr& event)
 590 {
 591         LogDebug("enter");
 592
 593         Try
 594         {
 595                         if (event->isFilterUsing())
 596                         {
 597                                 LogDebug("filter use");
 598
 599                                 //check filter validation
 600                                 FilterPtr filter = event->getFilter();
 601                                 if(filter != NULL)
 602                                 {
 603                                         ConversationFilterValidatorPtr validator =
 604                                                 ConversationFilterValidatorFactory::getConversationFilterValidator();
 605
 606
 607                                         FilterValidatorPtr filterValidator = DPL::StaticPointerCast<FilterValidator>(validator);
 608                                         bool isValidFilter = filter->validate(filterValidator);
 609
 610                                         if(isValidFilter == false)
 611                                         {
 612                                                 Throw(WrtDeviceApis::Commons::InvalidArgumentException);
 613                                         }
 614                                 }
 615
 616                                 if (IMessaging::getInstance().deleteConversations(event->getSortMode(), event->getFilter()) == false)
 617                                 {
 618                                         Throw(WrtDeviceApis::Commons::PlatformException);
 619                                 }
 620                                         //.queryConversations(event->getSortMode(), event->getFilter());
 621                         }
 622                         else
 623                         {
 624                                 LogDebug("no filter");
 625
 626                                 if (IMessaging::getInstance().deleteConversations(event->getConversations()) == false)
 627                                 {
 628                                         Throw(WrtDeviceApis::Commons::PlatformException);
 629                                 }
 630                         }
 631         }
 632         Catch(WrtDeviceApis::Commons::PlatformException)
 633         {
 634                 MsgLogError("platform exception");
 635                 event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::UnknownException);
 636         }
 637         Catch(WrtDeviceApis::Commons::InvalidArgumentException)
 638         {
 639                 MsgLogError("InvalidArgumentException");
 640                 event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::InvalidArgumentException);
 641         }
 642 }
 643
 644 void ReqReceiverMessage::OnRequestReceived(const EventQueryFoldersPtr& event)
 645 {
 646         LogDebug("enter");
 647
 648         Try
 649         {
 650
 651                 //check filter validation
 652                 Tizen::FilterPtr filter = event->getFilter();
 653                 if(filter != NULL){
 654                         FolderFilterValidatorPtr validator =
 655                                         FolderFilterValidatorFactory::getFolderFilterValidator();
 656
 657                         FilterValidatorPtr filterValidator = DPL::StaticPointerCast<FilterValidator>(validator);
 658
 659                         bool isValidFilter = filter->validate(filterValidator);
 660                         if(isValidFilter == false){
 661                                 MsgLogError("[ERROR]Filter is Invalid");
 662                                 Throw(WrtDeviceApis::Commons::InvalidArgumentException);
 663                         }
 664
 665                 }
 666
 667                 vector<IMessageFolderPtr> tmp = IMessaging::getInstance().queryFolders(event->getFilter());
 668                 event->addFolders(tmp);
 669         }
 670         Catch(WrtDeviceApis::Commons::PlatformException)
 671         {
 672                 MsgLogError("platform exception");
 673                 event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::UnknownException);
 674         }
 675         Catch(WrtDeviceApis::Commons::InvalidArgumentException)
 676         {
 677                 MsgLogError("InvalidArgumentException");
 678                 event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::InvalidArgumentException);
 679         }
 680 }
 681
 682 }
 683 }
 684 }