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