src/Messaging/ReqReceiverMessage.cpp

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