src/messaging/messaging_instance.cc

   1 /*
   2  * Copyright (c) 2015 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 #include "messaging_instance.h"
  18
  19 #include <system_info.h>
  20 #include <sstream>
  21 #include <stdexcept>
  22
  23 #include "common/filesystem/filesystem_provider.h"
  24 #include "common/logger.h"
  25 #include "common/tools.h"
  26
  27 #include "MsgCommon/AbstractFilter.h"
  28 #include "conversations_change_callback.h"
  29 #include "email_manager.h"
  30 #include "find_msg_callback_user_data.h"
  31 #include "folders_change_callback.h"
  32 #include "message.h"
  33 #include "message_storage.h"
  34 #include "messages_callback_user_data.h"
  35 #include "messages_change_callback.h"
  36 #include "messaging_manager.h"
  37 #include "messaging_util.h"
  38 #include "short_message_manager.h"
  39
  40 using common::ErrorCode;
  41 using common::TypeMismatchException;
  42 using common::PlatformResult;
  43 using common::tools::ReportError;
  44
  45 namespace extension {
  46 namespace messaging {
  47
  48 namespace {
  49 const char* GET_MESSAGE_SERVICES_ARGS_MESSAGE_SERVICE_TYPE = "messageServiceType";
  50 const char* SEND_MESSAGE_ARGS_MESSAGE = "message";
  51 const char* SEND_MESSAGE_ARGS_SIMINDEX = "simIndex";
  52 const char* LOAD_MESSAGE_ATTACHMENT_ARGS_ATTACHMENT = "attachment";
  53 const char* SYNC_ARGS_ID = "id";
  54 const char* SYNC_ARGS_LIMIT = "limit";
  55 const char* SYNC_FOLDER_ARGS_ID = "id";
  56 const char* SYNC_FOLDER_ARGS_FOLDER = "folder";
  57 const char* SYNC_FOLDER_ARGS_LIMIT = "limit";
  58 const char* STOP_SYNC_ARGS_ID = "id";
  59 const char* STOP_SYNC_ARGS_OPID = "opId";
  60 const char* ADD_DRAFT_MESSAGE_ARGS_MESSAGE = "message";
  61 const char* REMOVE_MESSAGES_ARGS_MESSAGES = "messages";
  62 const char* UPDATE_MESSAGES_ARGS_MESSAGES = "messages";
  63 const char* FIND_CONVERSATIONS_ARGS_LIMIT = "limit";
  64 const char* FIND_CONVERSATIONS_ARGS_OFFSET = "offset";
  65 const char* REMOVE_CONVERSATIONS_ARGS_CONVERSATIONS = "conversations";
  66 const char* FIND_FOLDERS_ARGS_LIMIT = "limit";
  67 const char* FIND_FOLDERS_ARGS_OFFSET = "offset";
  68 const char* REMOVE_CHANGE_LISTENER_ARGS_WATCHID = "watchId";
  69 const char* FUNCTIONS_HIDDEN_ARGS_SERVICE_ID = "serviceId";
  70 const char* FUN_MESSAGE_MESSAGING_EMAIL = "messaging.email";
  71
  72 int getServiceIdFromJSON(const picojson::object& data) {
  73   try {
  74     return std::stoi(
  75         MessagingUtil::getValueFromJSONObject<std::string>(data, FUNCTIONS_HIDDEN_ARGS_SERVICE_ID));
  76   } catch (...) {
  77     return -1;
  78   }
  79 };
  80
  81 const std::string kPrivilegeMessagingRead = "http://tizen.org/privilege/messaging.read";
  82 const std::string kPrivilegeMessagingWrite = "http://tizen.org/privilege/messaging.write";
  83
  84 const long kDumbCallbackId = -1;
  85 }
  86
  87 MessagingInstance::MessagingInstance() : manager_(*this), queue_(*this) {
  88   ScopeLogger();
  89   using std::placeholders::_1;
  90   using std::placeholders::_2;
  91
  92 #define REGISTER_METHOD(M) RegisterSyncHandler(#M, std::bind(&MessagingInstance::M, this, _1, _2))
  93   REGISTER_METHOD(GetMessageServices);
  94   REGISTER_METHOD(MessageServiceSendMessage);
  95   REGISTER_METHOD(MessageServiceLoadMessageBody);
  96   REGISTER_METHOD(MessageServiceLoadMessageAttachment);
  97   REGISTER_METHOD(MessageStorageAddDraftMessage);
  98   REGISTER_METHOD(MessageStorageFindMessages);
  99   REGISTER_METHOD(MessageStorageRemoveMessages);
 100   REGISTER_METHOD(MessageStorageUpdateMessages);
 101   REGISTER_METHOD(MessageStorageFindConversations);
 102   REGISTER_METHOD(MessageStorageRemoveConversations);
 103   REGISTER_METHOD(MessageStorageFindFolders);
 104
 105   REGISTER_METHOD(MessageServiceSync);
 106   REGISTER_METHOD(MessageServiceStopSync);
 107   REGISTER_METHOD(MessageServiceSyncFolder);
 108   REGISTER_METHOD(MessageStorageAddMessagesChangeListener);
 109   REGISTER_METHOD(MessageStorageAddConversationsChangeListener);
 110   REGISTER_METHOD(MessageStorageAddFolderChangeListener);
 111   REGISTER_METHOD(MessageStorageRemoveChangeListener);
 112   REGISTER_METHOD(MessageGetMessageStatus);
 113 #undef REGISTER_METHOD
 114 }
 115
 116 MessagingInstance::~MessagingInstance() {
 117   ScopeLogger();
 118 }
 119
 120 #define POST_AND_RETURN(ret, json, obj)                                            \
 121   LogAndReportError(ret, &obj);                                                    \
 122   queue_.addAndResolve(obj.at(JSON_CALLBACK_ID).get<double>(), PostPriority::HIGH, \
 123                        json->serialize());                                         \
 124   return;
 125
 126 #define CHECK_EXIST(args, name, out)                                                \
 127   if (!args.contains(name)) {                                                       \
 128     std::string message = std::string(name) + " is required argument";              \
 129     LogAndReportError(PlatformResult(ErrorCode::TYPE_MISMATCH_ERR, message), &out); \
 130     return;                                                                         \
 131   }
 132
 133 EmailManager& MessagingInstance::getEmailManager() {
 134   return email_manager_;
 135 }
 136
 137 ShortMsgManager& MessagingInstance::getShortMsgManager() {
 138   return short_msg_manager_;
 139 }
 140
 141 void MessagingInstance::GetMessageServices(const picojson::value& args, picojson::object& out) {
 142   ScopeLogger();
 143   DEPRECATION_WARN(
 144       "GetMessageServices() is deprecated and will be removed from next "
 145       "release without any alternatives.",
 146       "8.0");
 147
 148   CHECK_EXIST(args, JSON_CALLBACK_ID, out);
 149
 150   picojson::value serviceTag =
 151       args.get<picojson::object>().at(GET_MESSAGE_SERVICES_ARGS_MESSAGE_SERVICE_TYPE);
 152   const double callbackId = args.get(JSON_CALLBACK_ID).get<double>();
 153   // above values should be validated in js
 154   manager_.getMessageServices(serviceTag.to_str(), callbackId);
 155 }
 156
 157 void MessagingInstance::MessageServiceSendMessage(const picojson::value& args,
 158                                                   picojson::object& out) {
 159   ScopeLogger();
 160   DEPRECATION_WARN(
 161       "MessageServiceSendMessage() is deprecated and will be removed from next "
 162       "release without any alternatives.",
 163       "8.0");
 164
 165   CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingWrite, &out);
 166   CHECK_EXIST(args, JSON_CALLBACK_ID, out);
 167
 168   picojson::object data = args.get<picojson::object>();
 169   picojson::value v_message = data.at(SEND_MESSAGE_ARGS_MESSAGE);
 170
 171   bool has_attachments = v_message.get("hasAttachment").get<bool>();
 172   if (has_attachments) {
 173     const auto& attachments = v_message.get("attachments").get<std::vector<picojson::value>>();
 174     for (const auto& att : attachments) {
 175       const auto& attachment_path = att.get("filePath").get<std::string>();
 176       const auto& attachment_real_path =
 177           common::FilesystemProvider::Create().GetRealPath(attachment_path);
 178       CHECK_STORAGE_ACCESS(attachment_real_path, &out);
 179     }
 180   }
 181
 182   const double callbackId = args.get(JSON_CALLBACK_ID).get<double>();
 183
 184   auto json = std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
 185   picojson::object& obj = json->get<picojson::object>();
 186   obj[JSON_CALLBACK_ID] = picojson::value(callbackId);
 187
 188   std::shared_ptr<Message> message;
 189   PlatformResult ret = MessagingUtil::jsonToMessage(v_message, &message, *this);
 190   if (ret.IsError()) {
 191     POST_AND_RETURN(ret, json, obj)
 192   }
 193
 194   MessageRecipientsCallbackData* callback =
 195       new MessageRecipientsCallbackData(queue_, callbackId, *this);
 196   long simIndex = 0;
 197   int serviceId = 0;
 198
 199   callback->setMessage(message);
 200   serviceId = getServiceIdFromJSON(data);
 201   callback->setAccountId(serviceId);
 202   simIndex = static_cast<long>(
 203       MessagingUtil::getValueFromJSONObject<double>(data, SEND_MESSAGE_ARGS_SIMINDEX));
 204
 205   bool cell_support = false;
 206   system_info_get_platform_bool("http://tizen.org/feature/network.telephony", &cell_support);
 207   if (cell_support) {
 208     LoggerD("cell_support is true");
 209     if (!callback->setSimIndex(simIndex)) {
 210       delete callback;
 211       callback = nullptr;
 212       POST_AND_RETURN(PlatformResult(ErrorCode::UNKNOWN_ERR, "set sim index failed"), json, obj)
 213     }
 214   } else {
 215     LoggerD("cell_support is false");
 216   }
 217
 218   callback->AddToQueue();
 219   auto service = manager_.getMessageService(serviceId);
 220
 221   ret = service->sendMessage(callback);
 222   if (!ret) {
 223     POST_AND_RETURN(ret, json, obj)
 224   }
 225 }
 226
 227 void MessagingInstance::MessageServiceLoadMessageBody(const picojson::value& args,
 228                                                       picojson::object& out) {
 229   ScopeLogger();
 230   DEPRECATION_WARN(
 231       "MessageServiceLoadMessageBody() is deprecated and will be removed from "
 232       "next release without any alternatives.",
 233       "8.0");
 234
 235   CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingWrite, &out);
 236   CHECK_EXIST(args, JSON_CALLBACK_ID, out);
 237
 238   picojson::object data = args.get<picojson::object>();
 239
 240   picojson::value json_message = data.at(ADD_DRAFT_MESSAGE_ARGS_MESSAGE);
 241   const double callbackId = args.get(JSON_CALLBACK_ID).get<double>();
 242
 243   auto json = std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
 244   picojson::object& obj = json->get<picojson::object>();
 245   obj[JSON_CALLBACK_ID] = picojson::value(callbackId);
 246
 247   std::shared_ptr<Message> message;
 248   PlatformResult ret = MessagingUtil::jsonToMessage(json_message, &message, *this);
 249   if (ret.IsError()) {
 250     POST_AND_RETURN(ret, json, obj)
 251   }
 252
 253   MessageBodyCallbackData* callback = new MessageBodyCallbackData(queue_, callbackId, *this);
 254
 255   callback->setMessage(message);
 256
 257   callback->AddToQueue();
 258   auto service = manager_.getMessageService(getServiceIdFromJSON(data));
 259   ret = service->loadMessageBody(callback);
 260   if (ret.IsError()) {
 261     POST_AND_RETURN(ret, json, obj)
 262   }
 263 }
 264
 265 void MessagingInstance::MessageServiceLoadMessageAttachment(const picojson::value& args,
 266                                                             picojson::object& out) {
 267   ScopeLogger();
 268   DEPRECATION_WARN(
 269       "MessageServiceLoadMessageAttachment() is deprecated and will be removed "
 270       "from next release without any alternatives.",
 271       "8.0");
 272
 273   CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingWrite, &out);
 274   CHECK_EXIST(args, JSON_CALLBACK_ID, out);
 275
 276   picojson::object data = args.get<picojson::object>();
 277   picojson::value attachment = data.at(LOAD_MESSAGE_ATTACHMENT_ARGS_ATTACHMENT);
 278   const double callbackId = args.get(JSON_CALLBACK_ID).get<double>();
 279
 280   MessageAttachmentCallbackData* callback =
 281       new MessageAttachmentCallbackData(queue_, callbackId, *this);
 282   callback->setMessageAttachment(MessagingUtil::jsonToMessageAttachment(attachment));
 283
 284   callback->AddToQueue();
 285   auto service = manager_.getMessageService(getServiceIdFromJSON(data));
 286   const auto result = service->loadMessageAttachment(callback);
 287   if (result.IsError()) {
 288     auto json = std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
 289     picojson::object& obj = json->get<picojson::object>();
 290     obj[JSON_CALLBACK_ID] = picojson::value(callbackId);
 291     POST_AND_RETURN(result, json, obj)
 292   }
 293 }
 294
 295 void MessagingInstance::MessageServiceSync(const picojson::value& args, picojson::object& out) {
 296   ScopeLogger();
 297   DEPRECATION_WARN(
 298       "MessageServiceSync() is deprecated and will be removed from next "
 299       "release without any alternatives.",
 300       "8.0");
 301
 302   CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingWrite, &out);
 303   CHECK_EXIST(args, JSON_CALLBACK_ID, out);
 304
 305   picojson::object data = args.get<picojson::object>();
 306   picojson::value v_id = data.at(SYNC_ARGS_ID);
 307   picojson::value v_limit = data.at(SYNC_ARGS_LIMIT);
 308   const double callbackId = args.get(JSON_CALLBACK_ID).get<double>();
 309
 310   int id = -1;
 311   try {
 312     id = std::stoi(v_id.get<std::string>());
 313   } catch (...) {
 314     LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR), &out,
 315                       ("Problem with MessageService"));
 316     return;
 317   }
 318   long limit = 0;
 319   if (v_limit.is<double>()) {
 320     limit = static_cast<long>(v_limit.get<double>());
 321   }
 322
 323   SyncCallbackData* callback = new SyncCallbackData(queue_, callbackId, *this);
 324   callback->setAccountId(id);
 325   callback->setLimit(limit);
 326
 327   callback->AddToQueue();
 328   long op_id = -1;
 329
 330   const auto result = manager_.getMessageService(id)->sync(callback, &op_id);
 331
 332   if (result) {
 333     ReportSuccess(picojson::value(static_cast<double>(op_id)), out);
 334   } else {
 335     LogAndReportError(result, &out);
 336   }
 337 }
 338
 339 void MessagingInstance::MessageServiceSyncFolder(const picojson::value& args,
 340                                                  picojson::object& out) {
 341   ScopeLogger();
 342   DEPRECATION_WARN(
 343       "MessageServiceSyncFolder() is deprecated and will be removed from next "
 344       "release without any alternatives.",
 345       "8.0");
 346
 347   CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingWrite, &out);
 348   CHECK_EXIST(args, JSON_CALLBACK_ID, out);
 349
 350   picojson::object data = args.get<picojson::object>();
 351   picojson::value v_id = data.at(SYNC_FOLDER_ARGS_ID);
 352   picojson::value v_folder = data.at(SYNC_FOLDER_ARGS_FOLDER);
 353   picojson::value v_limit = data.at(SYNC_FOLDER_ARGS_LIMIT);
 354   const double callbackId = args.get(JSON_CALLBACK_ID).get<double>();
 355
 356   int id = -1;
 357   try {
 358     id = std::stoi(v_id.get<std::string>());
 359   } catch (...) {
 360     LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR), &out,
 361                       ("Problem with MessageService"));
 362     return;
 363   }
 364
 365   long limit = 0;
 366   if (v_limit.is<double>()) {
 367     limit = static_cast<long>(v_limit.get<double>());
 368   }
 369
 370   SyncFolderCallbackData* callback = new SyncFolderCallbackData(queue_, callbackId, *this);
 371   callback->setAccountId(id);
 372   auto folder_ptr = std::make_shared<picojson::value>(v_folder);
 373   callback->setMessageFolder(folder_ptr);
 374   callback->setLimit(limit);
 375
 376   callback->AddToQueue();
 377   long op_id = -1;
 378
 379   const auto result = manager_.getMessageService(id)->syncFolder(callback, &op_id);
 380   if (result) {
 381     ReportSuccess(picojson::value(static_cast<double>(op_id)), out);
 382   } else {
 383     LogAndReportError(result, &out);
 384   }
 385 }
 386
 387 void MessagingInstance::MessageServiceStopSync(const picojson::value& args, picojson::object& out) {
 388   ScopeLogger();
 389   DEPRECATION_WARN(
 390       "MessageServiceStopSync() is deprecated and will be removed from next "
 391       "release without any alternatives.",
 392       "8.0");
 393   CHECK_EXIST(args, STOP_SYNC_ARGS_OPID, out);
 394
 395   picojson::object data = args.get<picojson::object>();
 396
 397   if (data.find(STOP_SYNC_ARGS_ID) != data.end()) {
 398     picojson::value v_id = data.at(STOP_SYNC_ARGS_ID);
 399     picojson::value v_op_id = data.at(STOP_SYNC_ARGS_OPID);
 400
 401     int id = -1;
 402     try {
 403       id = std::stoi(v_id.get<std::string>());
 404     } catch (...) {
 405       LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR), &out,
 406                         ("Problem with MessageService"));
 407       return;
 408     }
 409
 410     long op_id = 0;
 411     if (v_op_id.is<double>()) {
 412       op_id = static_cast<long>(v_op_id.get<double>());
 413     }
 414
 415     const auto result = manager_.getMessageService(id)->stopSync(op_id);
 416
 417     if (result) {
 418       ReportSuccess(out);
 419     } else {
 420       LogAndReportError(result, &out);
 421     }
 422   } else {
 423     LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR), &out, ("Unknown error"));
 424   }
 425 }
 426
 427 void MessagingInstance::MessageStorageAddDraftMessage(const picojson::value& args,
 428                                                       picojson::object& out) {
 429   ScopeLogger();
 430   DEPRECATION_WARN(
 431       "MessageStorageAddDraftMessage() is deprecated and will be removed from "
 432       "next release without any alternatives.",
 433       "8.0");
 434
 435   CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingWrite, &out);
 436   CHECK_EXIST(args, JSON_CALLBACK_ID, out);
 437
 438   picojson::object data = args.get<picojson::object>();
 439   picojson::value v_message = data.at(ADD_DRAFT_MESSAGE_ARGS_MESSAGE);
 440   const double callbackId = args.get(JSON_CALLBACK_ID).get<double>();
 441
 442   auto json = std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
 443   picojson::object& obj = json->get<picojson::object>();
 444   obj[JSON_CALLBACK_ID] = picojson::value(callbackId);
 445
 446   std::shared_ptr<Message> message;
 447   PlatformResult ret = MessagingUtil::jsonToMessage(v_message, &message, *this);
 448   if (ret.IsError()) {
 449     POST_AND_RETURN(ret, json, obj)
 450   }
 451
 452   MessageCallbackUserData* callback = new MessageCallbackUserData(queue_, callbackId, *this);
 453   callback->setMessage(message);
 454
 455   int serviceId = getServiceIdFromJSON(data);
 456   callback->setAccountId(serviceId);
 457
 458   callback->AddToQueue();
 459   auto service = manager_.getMessageService(serviceId);
 460   service->getMsgStorage()->addDraftMessage(callback);
 461 }
 462
 463 void MessagingInstance::MessageStorageFindMessages(const picojson::value& args,
 464                                                    picojson::object& out) {
 465   ScopeLogger();
 466   DEPRECATION_WARN(
 467       "MessageStorageFindMessages() is deprecated and will be removed from "
 468       "next release without any alternatives.",
 469       "8.0");
 470
 471   CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingRead, &out);
 472   CHECK_EXIST(args, JSON_CALLBACK_ID, out);
 473
 474   picojson::object data = args.get<picojson::object>();
 475   const double callbackId = args.get(JSON_CALLBACK_ID).get<double>();
 476
 477   auto json = std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
 478   picojson::object& obj = json->get<picojson::object>();
 479   obj[JSON_CALLBACK_ID] = picojson::value(callbackId);
 480
 481   AbstractFilterPtr filter;
 482   PlatformResult ret = MessagingUtil::jsonToAbstractFilter(data, &filter);
 483   if (ret.IsError()) {
 484     POST_AND_RETURN(ret, json, obj)
 485   }
 486   auto sortMode = MessagingUtil::jsonToSortMode(data);
 487
 488   long limit = static_cast<long>(
 489       MessagingUtil::getValueFromJSONObject<double>(data, FIND_FOLDERS_ARGS_LIMIT));
 490
 491   long offset = static_cast<long>(
 492       MessagingUtil::getValueFromJSONObject<double>(data, FIND_FOLDERS_ARGS_OFFSET));
 493
 494   int serviceId = getServiceIdFromJSON(data);
 495   auto storage = manager_.getMessageService(serviceId)->getMsgStorage();
 496
 497   FindMsgCallbackUserData* callback = new FindMsgCallbackUserData(queue_, callbackId, *this);
 498   callback->setFilter(filter);
 499   callback->setLimit(limit);
 500   callback->setOffset(offset);
 501   callback->setAccountId(serviceId);
 502   callback->setSortMode(sortMode);
 503
 504   callback->AddToQueue();
 505   storage->findMessages(callback);
 506 }
 507
 508 void MessagingInstance::MessageStorageRemoveMessages(const picojson::value& args,
 509                                                      picojson::object& out) {
 510   ScopeLogger();
 511   DEPRECATION_WARN(
 512       "MessageStorageRemoveMessages() is deprecated and will be removed from "
 513       "next release without any alternatives.",
 514       "8.0");
 515
 516   CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingWrite, &out);
 517   CHECK_EXIST(args, JSON_CALLBACK_ID, out);
 518
 519   picojson::object data = args.get<picojson::object>();
 520   picojson::array messages = data.at(REMOVE_MESSAGES_ARGS_MESSAGES).get<picojson::array>();
 521   const double callbackId = args.get(JSON_CALLBACK_ID).get<double>();
 522
 523   MessagesCallbackUserData* callback = new MessagesCallbackUserData(queue_, callbackId, *this);
 524
 525   auto each = [callback, this](picojson::value& v) -> void {
 526     std::shared_ptr<Message> message;
 527     PlatformResult ret = MessagingUtil::jsonToMessage(v, &message, *this);
 528     if (ret.IsSuccess()) {
 529       callback->addMessage(message);
 530     }
 531   };
 532
 533   for_each(messages.begin(), messages.end(), each);
 534
 535   auto service = manager_.getMessageService(getServiceIdFromJSON(data));
 536
 537   callback->AddToQueue();
 538   service->getMsgStorage()->removeMessages(callback);
 539 }
 540
 541 void MessagingInstance::MessageStorageUpdateMessages(const picojson::value& args,
 542                                                      picojson::object& out) {
 543   ScopeLogger();
 544   DEPRECATION_WARN(
 545       "MessageStorageUpdateMessages() is deprecated and will be removed from "
 546       "next release without any alternatives.",
 547       "8.0");
 548
 549   CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingWrite, &out);
 550   CHECK_EXIST(args, JSON_CALLBACK_ID, out);
 551
 552   picojson::object data = args.get<picojson::object>();
 553   picojson::value pico_messages = data.at(UPDATE_MESSAGES_ARGS_MESSAGES);
 554   auto pico_array = pico_messages.get<picojson::array>();
 555   const double callbackId = args.get(JSON_CALLBACK_ID).get<double>();
 556
 557   auto callback = new MessagesCallbackUserData(queue_, callbackId, *this);
 558
 559   std::for_each(pico_array.begin(), pico_array.end(),
 560                 [&callback, this](picojson::value& v) -> void {
 561                   std::shared_ptr<Message> message;
 562                   PlatformResult ret = MessagingUtil::jsonToMessage(v, &message, *this);
 563                   if (ret.IsSuccess()) {
 564                     callback->addMessage(message);
 565                   }
 566                 });
 567
 568   auto service = manager_.getMessageService(getServiceIdFromJSON(data));
 569
 570   callback->AddToQueue();
 571   service->getMsgStorage()->updateMessages(callback);
 572 }
 573
 574 void MessagingInstance::MessageStorageFindConversations(const picojson::value& args,
 575                                                         picojson::object& out) {
 576   ScopeLogger();
 577   DEPRECATION_WARN(
 578       "MessageStorageFindConversations() is deprecated and will be removed "
 579       "from next release without any alternatives.",
 580       "8.0");
 581
 582   CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingRead, &out);
 583   CHECK_EXIST(args, JSON_CALLBACK_ID, out);
 584
 585   picojson::object data = args.get<picojson::object>();
 586   const double callbackId = args.get(JSON_CALLBACK_ID).get<double>();
 587
 588   auto json = std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
 589   picojson::object& obj = json->get<picojson::object>();
 590   obj[JSON_CALLBACK_ID] = picojson::value(callbackId);
 591
 592   AbstractFilterPtr filter;
 593   PlatformResult ret = MessagingUtil::jsonToAbstractFilter(data, &filter);
 594   if (ret.IsError()) {
 595     POST_AND_RETURN(ret, json, obj)
 596   }
 597   auto sortMode = MessagingUtil::jsonToSortMode(data);
 598   long limit = static_cast<long>(
 599       MessagingUtil::getValueFromJSONObject<double>(data, FIND_CONVERSATIONS_ARGS_LIMIT));
 600   long offset = static_cast<long>(
 601       MessagingUtil::getValueFromJSONObject<double>(data, FIND_CONVERSATIONS_ARGS_OFFSET));
 602
 603   int serviceId = getServiceIdFromJSON(data);
 604
 605   ConversationCallbackData* callback = new ConversationCallbackData(queue_, callbackId, *this);
 606   callback->setFilter(filter);
 607   callback->setLimit(limit);
 608   callback->setOffset(offset);
 609   callback->setAccountId(serviceId);
 610   callback->setSortMode(sortMode);
 611
 612   callback->AddToQueue();
 613   auto storage = manager_.getMessageService(serviceId)->getMsgStorage();
 614   storage->findConversations(callback);
 615 }
 616
 617 void MessagingInstance::MessageStorageRemoveConversations(const picojson::value& args,
 618                                                           picojson::object& out) {
 619   ScopeLogger();
 620   DEPRECATION_WARN(
 621       "MessageStorageRemoveConversations() is deprecated and will be removed "
 622       "from next release without any alternatives.",
 623       "8.0");
 624
 625   CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingWrite, &out);
 626   CHECK_EXIST(args, JSON_CALLBACK_ID, out);
 627
 628   picojson::object data = args.get<picojson::object>();
 629   picojson::array conversations =
 630       data.at(REMOVE_CONVERSATIONS_ARGS_CONVERSATIONS).get<picojson::array>();
 631   const double callbackId = args.get(JSON_CALLBACK_ID).get<double>();
 632
 633   auto json = std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
 634   picojson::object& obj = json->get<picojson::object>();
 635   obj[JSON_CALLBACK_ID] = picojson::value(callbackId);
 636
 637   ConversationCallbackData* callback = new ConversationCallbackData(queue_, callbackId, *this);
 638
 639   PlatformResult ret(ErrorCode::NO_ERROR);
 640   for (auto it = conversations.begin(); it != conversations.end(); ++it) {
 641     std::shared_ptr<MessageConversation> conversation;
 642     ret = MessagingUtil::jsonToMessageConversation(*it, &conversation);
 643     if (ret.IsError()) {
 644       delete callback;
 645       POST_AND_RETURN(ret, json, obj)
 646     }
 647     callback->addConversation(conversation);
 648   }
 649
 650   auto service = manager_.getMessageService(getServiceIdFromJSON(data));
 651
 652   callback->AddToQueue();
 653   service->getMsgStorage()->removeConversations(callback);
 654 }
 655
 656 void MessagingInstance::MessageStorageFindFolders(const picojson::value& args,
 657                                                   picojson::object& out) {
 658   ScopeLogger();
 659   DEPRECATION_WARN(
 660       "MessageStorageFindFolders() is deprecated and will be removed from next "
 661       "release without any alternatives.",
 662       "8.0");
 663
 664   CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingRead, &out);
 665   CHECK_EXIST(args, JSON_CALLBACK_ID, out);
 666
 667   const auto& data = args.get<picojson::object>();
 668   auto service = manager_.getMessageService(getServiceIdFromJSON(data));
 669
 670   auto task_params = new FindFoldersTaskParams();
 671   task_params->instance = this;
 672   task_params->callback_id = args.get(JSON_CALLBACK_ID).get<double>();
 673   task_params->account_id = service->getMsgServiceId();
 674   task_params->message_type = service->getMsgServiceTypeString();
 675
 676   PlatformResult ret = MessagingUtil::jsonToAbstractFilter(data, &(task_params->filter));
 677   if (ret.IsError()) {
 678     LoggerE("Cannot convert json to AbstractFilter: %s", args.serialize().c_str());
 679     ReportError(ret, &out);
 680     delete task_params;
 681     return;
 682   }
 683
 684   service->getMsgStorage()->findFolders(task_params);
 685 }
 686
 687 void MessagingInstance::MessageStorageAddMessagesChangeListener(const picojson::value& args,
 688                                                                 picojson::object& out) {
 689   ScopeLogger();
 690   DEPRECATION_WARN(
 691       "MessageStorageAddMessagesChangeListener() is deprecated and will be "
 692       "removed from next release without any alternatives.",
 693       "8.0");
 694
 695   CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingRead, &out);
 696
 697   picojson::object data = args.get<picojson::object>();
 698
 699   AbstractFilterPtr filter;
 700   PlatformResult ret = MessagingUtil::jsonToAbstractFilter(data, &filter);
 701   if (ret.IsError()) {
 702     ReportError(ret, &out);
 703     return;
 704   }
 705
 706   int serviceId = getServiceIdFromJSON(data);
 707
 708   auto service = manager_.getMessageService(serviceId);
 709
 710   std::shared_ptr<MessagesChangeCallback> callback(new MessagesChangeCallback(
 711       kDumbCallbackId, serviceId, service->getMsgServiceType(), queue_, *this));
 712
 713   callback->setFilter(filter);
 714
 715   long op_id = service->getMsgStorage()->addMessagesChangeListener(callback);
 716
 717   picojson::value v(static_cast<double>(op_id));
 718   ReportSuccess(v, out);
 719 }
 720
 721 void MessagingInstance::MessageStorageAddConversationsChangeListener(const picojson::value& args,
 722                                                                      picojson::object& out) {
 723   ScopeLogger();
 724   DEPRECATION_WARN(
 725       "MessageStorageAddConversationsChangeListener() is deprecated and will "
 726       "be removed from next release without any alternatives.",
 727       "8.0");
 728
 729   CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingRead, &out);
 730
 731   picojson::object data = args.get<picojson::object>();
 732
 733   AbstractFilterPtr filter;
 734   PlatformResult ret = MessagingUtil::jsonToAbstractFilter(data, &filter);
 735   if (ret.IsError()) {
 736     ReportError(ret, &out);
 737     return;
 738   }
 739
 740   int serviceId = getServiceIdFromJSON(data);
 741
 742   auto service = manager_.getMessageService(serviceId);
 743
 744   std::shared_ptr<ConversationsChangeCallback> callback(new ConversationsChangeCallback(
 745       static_cast<long>(-1), serviceId, service->getMsgServiceType(), queue_, *this));
 746
 747   callback->setFilter(filter);
 748
 749   long op_id = service->getMsgStorage()->addConversationsChangeListener(callback);
 750
 751   picojson::value v(static_cast<double>(op_id));
 752   ReportSuccess(v, out);
 753 }
 754
 755 void MessagingInstance::MessageStorageAddFolderChangeListener(const picojson::value& args,
 756                                                               picojson::object& out) {
 757   ScopeLogger();
 758   DEPRECATION_WARN(
 759       "MessageStorageAddFolderChangeListener() is deprecated and will be "
 760       "removed from next release without any alternatives.",
 761       "8.0");
 762
 763   CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingRead, &out);
 764
 765   picojson::object data = args.get<picojson::object>();
 766
 767   AbstractFilterPtr filter;
 768   PlatformResult ret = MessagingUtil::jsonToAbstractFilter(data, &filter);
 769   if (ret.IsError()) {
 770     ReportError(ret, &out);
 771     return;
 772   }
 773
 774   int serviceId = getServiceIdFromJSON(data);
 775
 776   auto service = manager_.getMessageService(serviceId);
 777
 778   std::shared_ptr<FoldersChangeCallback> callback(
 779       new FoldersChangeCallback(serviceId, service->getMsgServiceType(), *this));
 780
 781   callback->setFilter(filter);
 782
 783   long op_id = service->getMsgStorage()->addFoldersChangeListener(callback);
 784
 785   picojson::value v(static_cast<double>(op_id));
 786   ReportSuccess(v, out);
 787 }
 788
 789 void MessagingInstance::MessageStorageRemoveChangeListener(const picojson::value& args,
 790                                                            picojson::object& out) {
 791   ScopeLogger();
 792   DEPRECATION_WARN(
 793       "MessageStorageRemoveChangeListener() is deprecated and will be removed "
 794       "from next release without any alternatives.",
 795       "8.0");
 796
 797   CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingRead, &out);
 798
 799   picojson::object data = args.get<picojson::object>();
 800   const long watchId =
 801       static_cast<long>(data.at(REMOVE_CHANGE_LISTENER_ARGS_WATCHID).get<double>());
 802
 803   auto service = manager_.getMessageService(getServiceIdFromJSON(data));
 804
 805   service->getMsgStorage()->removeChangeListener(watchId);
 806   ReportSuccess(out);
 807 }
 808
 809 void MessagingInstance::MessageGetMessageStatus(const picojson::value& args,
 810                                                 picojson::object& out) {
 811   ScopeLogger();
 812   DEPRECATION_WARN(
 813       "MessageGetMessageStatus() is deprecated and will be removed from next "
 814       "release without any alternatives.",
 815       "8.0");
 816
 817   picojson::object data = args.get<picojson::object>();
 818   const int id = stoi(data.at("id").get<std::string>());
 819   const std::string& type = data.at("type").get<std::string>();
 820
 821   std::string status;
 822   if (FUN_MESSAGE_MESSAGING_EMAIL == type) {
 823     status = email_manager_.getMessageStatus(id);
 824   } else {
 825     status = short_msg_manager_.getMessageStatus(id);
 826   }
 827
 828   ReportSuccess(picojson::value(status), out);
 829 }
 830
 831 }  // namespace messaging
 832 }  // namespace extension