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