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