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