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].incoming_server_user_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 EventDeleteMessagePtr& event)
 302 {
 303     LoggerD("enter");
 304
 305     Try {
 306         IMessagePtr msg = event->msg;
 307         msg->remove();
 308     }
 309     Catch(WrtDeviceApis::Commons::PlatformException) {
 310         MsgLoggerE("platform exception");
 311         event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::UnknownException);
 312     }
 313 }
 314 */
 315
 316
 317 void ReqReceiverMessage::OnRequestReceived(const EventDeleteMessagesPtr& event)
 318 {
 319         LoggerD("enter");
 320
 321         Try {
 322 /*
 323                 DeviceAPI::Tizen::FilterPtr filter = event->getFilter();
 324                 if(filter != NULL){
 325                         bool isValidFilter = validateFilter(filter);
 326                         if(isValidFilter == false){
 327                                 Throw(WrtDeviceApis::Commons::InvalidArgumentException);
 328                         }
 329
 330                         event->msgArray = IMessaging::getInstance().findMessages(event->getFilter());
 331                 }
 332 */
 333                 std::vector<IMessagePtr> msg = event->msgArray;
 334                 LoggerD("msg.size()" << msg.size());
 335
 336                 int vecSize = msg.size();
 337                 for(int i=0; i < vecSize; i++){
 338                         int type = msg[i]->getMessageType();
 339                         std::string id = msg[i]->getId();
 340                         MsgLoggerE("type :"<<type);
 341                         MsgLoggerE("id :"<<id);
 342                         MsgLoggerE("body" << msg[i]->getBody());
 343                         msg[i]->remove();
 344                 }//for
 345         }Catch(WrtDeviceApis::Commons::PlatformException) {
 346                 MsgLoggerE("platform exception");
 347                 event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::UnknownException);
 348         }
 349 }
 350
 351 void ReqReceiverMessage::OnRequestReceived(const EventUpdateMessagesPtr& event)
 352 {
 353     LoggerD("enter");
 354
 355     Try {
 356         std::vector<IMessagePtr> msg = event->msgArray;
 357         LoggerD("msg.size()" << msg.size());
 358         int vecSize = msg.size();
 359         for(int i=0; i < vecSize; i++)
 360         {
 361 //            int type = msg[i]->getMessageType();
 362             std::string id = msg[i]->getId();
 363             msg[i]->updateMessage();
 364 //            msg[i]->updateIsRead();
 365         }
 366     }
 367     Catch(WrtDeviceApis::Commons::PlatformException) {
 368         MsgLoggerE("platform exception");
 369         event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::UnknownException);
 370     }
 371 }
 372
 373 void ReqReceiverMessage::OnRequestReceived(const EventQueryMessagesPtr& event)
 374 {
 375     LoggerD("<<<");
 376
 377         Try {
 378
 379                 vector<IMessagePtr> msgs;
 380                 vector<IMessagePtr> tmp;
 381
 382                 //check filter validation
 383                 DeviceAPI::Tizen::FilterPtr filter = event->getFilter();
 384                 bool isValidFilter = validateFilter(filter);
 385                 if(isValidFilter == false){
 386                         MsgLoggerE("[ERROR]this filter is invalid");
 387                         Throw(WrtDeviceApis::Commons::InvalidArgumentException);
 388                 }
 389
 390                 // using filter
 391                 LoggerD("event->getType() = " << event->getType());
 392                 if(event->getType() > UNKNOWN)
 393                 {
 394                         tmp = IMessaging::getInstance().findMessages(event->getFilter(), event->getSortMode(), event->getLimit(), event->getOffset(), event->getType());
 395                 }
 396                 else
 397                 {
 398                         Throw(WrtDeviceApis::Commons::InvalidArgumentException);
 399                 }
 400
 401                 msgs.insert(msgs.end(), tmp.begin(), tmp.end());
 402                 event->msgs = msgs;
 403
 404         }Catch(WrtDeviceApis::Commons::PlatformException) {
 405                 MsgLoggerE("platform exception");
 406                 event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::UnknownException);
 407         }Catch(WrtDeviceApis::Commons::InvalidArgumentException){
 408                 MsgLoggerE("InvalidArgumentException");
 409                 event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::InvalidArgumentException);
 410         }
 411         Catch (exception) {
 412                 MsgLoggerE("platform exception");
 413                 event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::UnknownException);
 414         }
 415 }
 416
 417 void ReqReceiverMessage::OnRequestReceived(const EventGetConversationIdPtr& event)
 418 {
 419         LoggerD("enter");
 420
 421         Try {
 422                 IMessagePtr msg = event->getConversationMsgPtr();
 423                 MessageType msgType = msg->getMessageType();
 424                 unsigned int msgId = 0;
 425
 426                 if (msgType == EMAIL)
 427                 {
 428                         IEmailPtr email = MessageFactory::convertToEmail(msg);
 429                         msgId = email->getUID();
 430
 431                 }
 432                 else
 433                 {
 434                         msgId = msg->convertId(msg->getId());
 435                 }
 436
 437                 int conversationId = IMessaging::getInstance().getConversationId(msgId, msgType);
 438                 LoggerD("Cond Id:" << conversationId);
 439                 event->setConversationId(conversationId);
 440         }
 441         Catch(WrtDeviceApis::Commons::PlatformException) {
 442                 MsgLoggerE("platform exception");
 443                 event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::UnknownException);
 444         }
 445 }
 446
 447 void ReqReceiverMessage::OnRequestReceived(const EventQueryConversationsPtr& event)
 448 {
 449         LoggerD("<<<");
 450
 451         Try
 452         {
 453                 //check filter validation
 454                 DeviceAPI::Tizen::FilterPtr filter = event->getFilter();
 455                 vector<IConversationPtr> tmp;
 456                 if(filter != NULL){
 457                         ConversationFilterValidatorPtr validator =
 458                                         ConversationFilterValidatorFactory::getConversationFilterValidator();
 459
 460                         FilterValidatorPtr filterValidator = DPL::StaticPointerCast<FilterValidator>(validator);
 461                         bool isValidFilter = filter->validate(filterValidator);
 462                         if(isValidFilter == false){
 463                                 MsgLoggerE("[ERROR]Filter is Invalid");
 464                                 Throw(WrtDeviceApis::Commons::InvalidArgumentException);
 465                         }
 466                 }
 467                 LoggerD("event->getType() = "<<event->getType());
 468                 if(event->getType() > UNKNOWN)
 469                 {
 470                         tmp = IMessaging::getInstance().queryConversations(event->getFilter(), event->getSortMode(), event->getType(), event->getLimit(), event->getOffset());
 471                 }
 472                 else
 473                 {
 474 //                      LoggerD("enter");
 475 //                      tmp = IMessaging::getInstance().queryConversations(event->getSortMode(), event->getFilter(), event->getLimit(), event->getOffset());
 476                         Throw(WrtDeviceApis::Commons::InvalidArgumentException);
 477                 }
 478
 479                 event->addConversations(tmp);
 480
 481         }
 482         Catch(WrtDeviceApis::Commons::PlatformException)
 483         {
 484                 MsgLoggerE("platform exception");
 485                 event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::UnknownException);
 486         }
 487         Catch(WrtDeviceApis::Commons::InvalidArgumentException)
 488         {
 489                 MsgLoggerE("InvalidArgumentException");
 490                 event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::InvalidArgumentException);
 491         }
 492 }
 493
 494 void ReqReceiverMessage::OnRequestReceived(const EventMessagingServicePtr& event)
 495 {
 496     LoggerD("enter : EventMessagingServicePtr");
 497
 498     Try {
 499                 LoggerD("event type :" << event->getEventType() );
 500                 int MessagingServiceEventType = event->getEventType();
 501
 502                 if (MessagingServiceEventType == MESSAGING_SERVICE_EVENT_TYPE_LOAD_MESSAGE_BODY)
 503                 {
 504                         if (!event->checkCancelled()) {
 505                                 IMessagePtr msg = event->m_message;
 506                                 if(msg)
 507                                 {
 508
 509                                         msg->setRequestReceiver(this);
 510                                         msg->setMessagingServiceEvent(event);
 511
 512                                         int type = msg->getMessageType();
 513                                         LoggerD("message type :" << type);
 514                                         if ( msg->getMessageType() == EMAIL )
 515                                         {
 516                                                 IEmailPtr email = MessageFactory::convertToEmail(msg);
 517                                                 event->switchToManualAnswer();          //switch to manual answer;
 518                                                 int handle = email->downloadBody();
 519                                                 LoggerD("Load Message Body handle : " << handle);
 520                                                 if (event->opId && event->m_messagingService)
 521                                                 {
 522                                                         event->m_messagingService->setHandleToOpId(event->opId, handle);
 523                                                 }
 524                                                 if (handle > 0)
 525                                                 {
 526                                                         event->setHandle(handle);       //set handle
 527                                                 }
 528                                         }
 529                                 }
 530                                 else {
 531                                 LoggerD(" invaild message. ");
 532                                         event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::InvalidArgumentException);
 533                                 }
 534
 535                         }
 536                         else
 537                         {
 538                                 LoggerD(" Cancel ");
 539                                 event->setCancelAllowed(true);
 540                         }
 541                 }
 542
 543                 else if (MessagingServiceEventType == MESSAGING_SERVICE_EVENT_TYPE_LOAD_MESSAGE_ATTACHMENT)
 544                 {
 545                         if (!event->checkCancelled()) {
 546                                 IMessagePtr msg = event->m_message;
 547                                 if(msg)
 548                                 {
 549                                         msg->setRequestReceiver(this);
 550                                 msg->setMessagingServiceEvent(event);
 551
 552                                         int type = msg->getMessageType();
 553                                         LoggerD("message type :" << type);
 554                                         if ( msg->getMessageType() == EMAIL )
 555                                         {
 556                                                 IEmailPtr email = MessageFactory::convertToEmail(msg);
 557                                                 event->switchToManualAnswer();          //switch to manual answer;
 558                                                 int handle = email->downloadAttachment(event->m_attachment);
 559                                                 LoggerD("Load Message Attachment handle : " << handle);
 560                                                 if (event->opId && event->m_messagingService)
 561                                                 {
 562                                                         event->m_messagingService->setHandleToOpId(event->opId, handle);
 563                                                 }
 564                                                 if (handle > 0)
 565                                                 {
 566                                                         event->setHandle(handle);       //set handle
 567                                                 }
 568                                         }
 569                                         else
 570                                         {
 571                                                 LoggerD(" invaild message. ");
 572                                                 event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::InvalidArgumentException);
 573                                         }
 574                                 }
 575                         }
 576                         else
 577                         {
 578                                 LoggerD(" cancel. ");
 579                                 event->setCancelAllowed(true);
 580                         }
 581
 582                 }
 583
 584                 else if (MessagingServiceEventType == MESSAGING_SERVICE_EVENT_TYPE_SYNC)
 585                 {
 586                         if (event->m_messagingService)
 587                         {
 588                                 if (!event->checkCancelled()) {
 589                                         int type = event->m_messagingService->getType();
 590                                         LoggerD("messaging service type :" << type);
 591
 592                                         event->m_messagingService->setRequestReceiver(this);
 593                                         event->m_messagingService->setMessagingServiceEvent(event);     //
 594
 595                                         if (type == EMAIL)
 596                                         {
 597                                                 event->switchToManualAnswer(); //switch to manual answer;
 598                                                 LoggerD("privateData->getAccountId() :" << event->m_messagingService->getAccountID());
 599
 600                                                 if ( event->m_messagingService->getAccountID() > 0)
 601                                                 {
 602                                                         int handle = event->m_messagingService->sync( event->m_messagingService, event->m_sync_limit );
 603                                                         LoggerD("Sync handle : " << handle);
 604                                                         if (event->opId && event->m_messagingService)
 605                                                         {
 606                                                                 event->m_messagingService->setHandleToOpId(event->opId, handle);
 607                                                         }
 608                                                         if (handle > 0)
 609                                                         {
 610                                                                 event->setHandle(handle);       //set handle
 611                                                         }
 612
 613                                                 }
 614                                                 else
 615                                                         event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::InvalidArgumentException);
 616                                         }
 617                                         else
 618                                         {
 619                                                 event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::InvalidArgumentException);
 620                                         }
 621                                 }
 622                                 else
 623                                 {
 624                                         LoggerD(" cancel. ");
 625                                         event->setCancelAllowed(true);
 626                                 }
 627                         }
 628
 629                 }
 630                 else if (MessagingServiceEventType == MESSAGING_SERVICE_EVENT_TYPE_SYNC_FOLDER)
 631                 {
 632                         if (event->m_messagingService)
 633                         {
 634                                 if (!event->checkCancelled()) {
 635                                         int type = event->m_messagingService->getType();
 636                                         LoggerD("messaging service type :" << type);
 637
 638                                         event->m_messagingService->setRequestReceiver(this);
 639                                         event->m_messagingService->setMessagingServiceEvent(event);
 640                                         if (type == EMAIL)
 641                                         {
 642                                                 event->switchToManualAnswer(); //switch to manual answer;
 643                                                 LoggerD("privateData->getAccountId() :" << event->m_messagingService->getAccountID());
 644
 645                                                 if ( event->m_messagingService->getAccountID() > 0)
 646                                                 {
 647                                                         int handle = event->m_messagingService->syncFolder( event->m_messagingService, event->m_sync_folder_id, event->m_sync_limit);
 648                                                         LoggerD("Sync Folder handle : " << handle);
 649                                                         if (event->opId && event->m_messagingService)
 650                                                         {
 651                                                                 event->m_messagingService->setHandleToOpId(event->opId, handle);
 652                                                         }
 653                                                         if (handle > 0)
 654                                                         {
 655                                                                 event->setHandle(handle);       //set handle
 656                                                         }
 657                                                 }
 658                                                 else
 659                                                         event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::InvalidArgumentException);
 660                                         }
 661                                         else
 662                                         {
 663                                                 event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::InvalidArgumentException);
 664                                         }
 665                                 }
 666                                 else
 667                                 {
 668                                         LoggerD(" cancel. ");
 669                                         event->setCancelAllowed(true);
 670                                 }
 671                         }
 672                 }
 673                 else if (MessagingServiceEventType == MESSAGING_SERVICE_EVENT_TYPE_SEND_MESSAGE)
 674                 {
 675                         IMessagePtr msg = event->m_message;
 676                         msg->setRequestReceiver(this);
 677                         msg->setMessagingServiceEvent(event);
 678                         if (!event->checkCancelled())
 679                         {
 680
 681                                 if (msg->getMessageStatus() == MESSAGE_STATUS_CREATED ) //create message.
 682                                 {
 683                                         //if draft Message.
 684                                         if (msg->getMessageType() == EMAIL )
 685                                         {
 686                                                 IEmailPtr email = MessageFactory::convertToEmail(msg);
 687                                                 email->setEmailAccount(event->m_messagingService->getCurrentEmailAccount());
 688                                         }
 689
 690                                         msg->createSendMessage();
 691                                         LoggerD("Message Status = " << msg->getMessageStatus());
 692                                         LoggerD("Message ID = " << msg->getId());
 693                                 }
 694                                 event->switchToManualAnswer();
 695
 696                                 int handle = msg->send();
 697                                 LoggerD("handle : " << handle);
 698                                 if (event->opId && event->m_messagingService)
 699                                 {
 700                                         event->m_messagingService->setHandleToOpId(event->opId, handle);
 701                                 }
 702
 703                                 if (handle > 0)
 704                                 {
 705                                         event->setHandle(handle);       //set handle
 706                                 }
 707
 708                         }
 709
 710                 }
 711                 else
 712                 {
 713                         LoggerD(" Cancel ");
 714                         event->setCancelAllowed(true);
 715                 }
 716
 717     }
 718     Catch (WrtDeviceApis::Commons::PlatformException) {
 719           MsgLoggerE("platform exception");
 720         event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::UnknownException);
 721     }
 722     Catch (WrtDeviceApis::Commons::ConversionException) {
 723           MsgLoggerE("conversion exception");
 724         event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::ConversionException);
 725     }
 726
 727 }
 728
 729 void ReqReceiverMessage::OnRequestReceived(const EventDeleteConversationsPtr& event)
 730 {
 731         LoggerD("enter");
 732
 733         Try
 734         {/*
 735                         if (event->isFilterUsing())
 736                         {
 737                                 LoggerD("filter use");
 738
 739                                 //check filter validation
 740                                 FilterPtr filter = event->getFilter();
 741                                 if(filter != NULL)
 742                                 {
 743                                         ConversationFilterValidatorPtr validator =
 744                                                 ConversationFilterValidatorFactory::getConversationFilterValidator();
 745
 746
 747                                         FilterValidatorPtr filterValidator = DPL::StaticPointerCast<FilterValidator>(validator);
 748                                         bool isValidFilter = filter->validate(filterValidator);
 749
 750                                         if(isValidFilter == false)
 751                                         {
 752                                                 Throw(WrtDeviceApis::Commons::InvalidArgumentException);
 753                                         }
 754                                 }
 755
 756                                 if (IMessaging::getInstance().deleteConversations(event->getSortMode(), event->getFilter()) == false)
 757                                 {
 758                                         Throw(WrtDeviceApis::Commons::PlatformException);
 759                                 }
 760                                         //.queryConversations(event->getSortMode(), event->getFilter());
 761                         }
 762                         else*/
 763                         {
 764                                 LoggerD("no filter");
 765
 766                                 if (IMessaging::getInstance().deleteConversations(event->getConversations()) == false)
 767                                 {
 768                                         Throw(WrtDeviceApis::Commons::PlatformException);
 769                                 }
 770                         }
 771         }
 772         Catch(WrtDeviceApis::Commons::PlatformException)
 773         {
 774                 MsgLoggerE("platform exception");
 775                 event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::UnknownException);
 776         }
 777         Catch(WrtDeviceApis::Commons::InvalidArgumentException)
 778         {
 779                 MsgLoggerE("InvalidArgumentException");
 780                 event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::InvalidArgumentException);
 781         }
 782 }
 783
 784 void ReqReceiverMessage::OnRequestReceived(const EventQueryFoldersPtr& event)
 785 {
 786         LoggerD("enter");
 787
 788         Try
 789         {
 790
 791                 //check filter validation
 792                 DeviceAPI::Tizen::FilterPtr filter = event->getFilter();
 793                 if(filter != NULL){
 794                         FolderFilterValidatorPtr validator =
 795                                         FolderFilterValidatorFactory::getFolderFilterValidator();
 796
 797                         FilterValidatorPtr filterValidator = DPL::StaticPointerCast<FilterValidator>(validator);
 798
 799                         bool isValidFilter = filter->validate(filterValidator);
 800                         if(isValidFilter == false){
 801                                 MsgLoggerE("[ERROR]Filter is Invalid");
 802                                 Throw(WrtDeviceApis::Commons::InvalidArgumentException);
 803                         }
 804
 805                 }
 806
 807                 vector<IMessageFolderPtr> tmp = IMessaging::getInstance().queryFolders(event->getFilter());
 808                 event->addFolders(tmp);
 809         }
 810         Catch(WrtDeviceApis::Commons::PlatformException)
 811         {
 812                 MsgLoggerE("platform exception");
 813                 event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::UnknownException);
 814         }
 815         Catch(WrtDeviceApis::Commons::InvalidArgumentException)
 816         {
 817                 MsgLoggerE("InvalidArgumentException");
 818                 event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::InvalidArgumentException);
 819         }
 820
 821 }
 822 }
 823 }