[Contact] AddresBook_batchFunc implementation.

[Verification] Following TCT should pass:
- AddressBook_removeBatch
- AddressBook_updateBatch
- AddressBook_updateBatch_with_successCallback
- AddressBook_updateBatch_with_errorCallback
- AddressBook_removeBatch_with_errorCallback
- AddressBook_removeBatch_with_successCallback
- ContactManager_updateBatch_with_errorCallback
- ContactManager_updateBatch_with_successCallback
- ContactManager_removeBatch_with_errorCallback
- ContactManager_removeBatch_with_successCallback

Change-Id: Iecdc3ae503f5b474458cd7f7cf320a7d2b3c3b97
Signed-off-by: Adam Banasiak <a.banasiak@samsung.com>

diff --git a/src/contact/addressbook.cc b/src/contact/addressbook.cc
index 10a9b081df9be57912a93cf6030481f6fc4a7579..4bbb950e722f58b24a15e6da45efc719869afcc0 100644 (file)
--- a/src/contact/addressbook.cc
+++ b/src/contact/addressbook.cc
@@ -164,21 +164,19 @@ void AddressBook_update(const JsonObject& args, JsonObject& out) {
 }
 
 void AddressBook_remove(const JsonObject& args, JsonObject&) {
+  LoggerE("entered");
   ContactUtil::CheckDBConnection();
 
-  long contact_id = common::stol(FromJson<JsonString>(args, "id"));
+  int contact_id = common::stol(FromJson<JsonString>(args, "id"));
 
   if (contact_id < 0) {
     throw common::InvalidValuesException("Nagative contact id");
   }
 
-  int err = CONTACTS_ERROR_NONE;
-  err = contacts_db_delete_record(_contacts_contact._uri, contact_id);
+  int err = contacts_db_delete_record(_contacts_contact._uri, contact_id);
   if (CONTACTS_ERROR_NO_DATA == err) {
-    LoggerW("Remove failed: contact not found, error code: %d", err);
     throw common::NotFoundException("Remove failed: contact not found");
   } else if (CONTACTS_ERROR_NONE != err) {
-    LoggerW("Contacts record delete error, error code: %d", err);
     throw common::UnknownException("Contacts record delete error");
   }
 }
@@ -188,21 +186,18 @@ void AddressBook_addBatch(const JsonObject& args, JsonArray& out) {
 
   ContactUtil::CheckDBConnection();
 
-  long addressBookId = -1;
   const JsonArray& batch_args = FromJson<JsonArray>(args, "batchArgs");
-  addressBookId = common::stol(FromJson<JsonString>(args, "addressBookId"));
+  long addressBookId = common::stol(FromJson<JsonString>(args, "addressBookId"));
   addressBookId = addressBookId == -1 ? 0 : addressBookId;
 
   unsigned length = batch_args.size();
-  int error_code = 0;
   contacts_list_h contacts_list = NULL;
-  error_code = contacts_list_create(&contacts_list);
+  int error_code = contacts_list_create(&contacts_list);
   if (CONTACTS_ERROR_NONE != error_code) {
     LoggerE("list creation failed, code: %d", error_code);
     throw new common::UnknownException("list creation failed");
   }
-  ContactUtil::ContactsListHPtr contacts_list_ptr(
-      &contacts_list, ContactUtil::ContactsListDeleter);
+  ContactUtil::ContactsListHPtr contacts_list_ptr(&contacts_list, ContactUtil::ContactsListDeleter);
 
   for (auto& item : batch_args) {
     contacts_record_h contacts_record = nullptr;
@@ -212,12 +207,9 @@ void AddressBook_addBatch(const JsonObject& args, JsonArray& out) {
       LoggerW("Contacts record create error, error code: %d", err);
       throw common::UnknownException("Contacts record create error");
     }
-    ContactUtil::ContactsRecordHPtr x(&contacts_record,
-                                      ContactUtil::ContactsDeleter);
-    ContactUtil::ExportContactToContactsRecord(contacts_record,
-                                               JsonCast<JsonObject>(item));
-    ContactUtil::SetIntInRecord(
-        contacts_record, _contacts_contact.address_book_id, addressBookId);
+    ContactUtil::ContactsRecordHPtr x(&contacts_record, ContactUtil::ContactsDeleter);
+    ContactUtil::ExportContactToContactsRecord(contacts_record, JsonCast<JsonObject>(item));
+    ContactUtil::SetIntInRecord(contacts_record, _contacts_contact.address_book_id, addressBookId);
     error_code = contacts_list_add(*contacts_list_ptr, *(x.release()));
     if (CONTACTS_ERROR_NONE != error_code) {
       LoggerE("error during add record to list, code: %d", error_code);
@@ -243,8 +235,7 @@ void AddressBook_addBatch(const JsonObject& args, JsonArray& out) {
   for (unsigned int i = 0; i < count; i++) {
     JsonObject out_object;
     contacts_record_h contact_record = nullptr;
-    error_code =
-        contacts_db_get_record(_contacts_contact._uri, ids[i], &contact_record);
+    error_code = contacts_db_get_record(_contacts_contact._uri, ids[i], &contact_record);
     if (CONTACTS_ERROR_NONE != error_code) {
       if (ids) {
         free(ids);
@@ -262,10 +253,26 @@ void AddressBook_addBatch(const JsonObject& args, JsonArray& out) {
   }
 }
 
-void AddressBook_batchFunc(/*NativeFunction impl, */const char* single_arg_name,
-                           const JsonObject& args/*, JsonObject& out*/) {
-  // @todo implement
-  throw common::NotFoundException("Not implemented");
+// TODO all batch operations should be implemented using CAPI batch functions
+void AddressBook_batchFunc(NativeFunction impl, const char *single_arg_name,
+                           const JsonObject &args, JsonArray &out) {
+  const JsonArray &batch_args = FromJson<JsonArray>(args, "batchArgs");
+  const JsonObject &address_book = FromJson<JsonObject>(args, "addressBook");
+
+  int i = 0;
+  for (auto &item : batch_args) {
+    ++i;
+    JsonObject single_args{};
+
+    single_args.insert(std::make_pair("addressBook", address_book));
+    single_args.insert(std::make_pair(single_arg_name, item));
+
+    JsonObject single_out;
+    impl(single_args, single_out);
+    if (!single_out.empty()) {
+      out.push_back(JsonValue{single_out});
+    }
+  }
 }
 
 void AddressBook_find(const JsonObject& args, JsonArray& array) {

diff --git a/src/contact/addressbook.h b/src/contact/addressbook.h
index 7b01ce18bce056691abb1d2229c1afd2e79a58f8..dd301dd278a926f4b034991c283b83910d44bf8f 100644 (file)
--- a/src/contact/addressbook.h
+++ b/src/contact/addressbook.h
@@ -19,11 +19,14 @@
 
 #include "common/picojson.h"
 #include "contact/contact_util.h"
+#include "functional"
 
 namespace extension {
 namespace contact {
 namespace AddressBook {
 
+typedef std::function<void(const JsonObject&, JsonObject&)> NativeFunction;
+
 void AddressBook_get(const JsonObject& args, JsonObject& out);
 void AddressBook_add(const JsonObject& args, JsonObject& out);
 void AddressBook_update(const JsonObject& args, JsonObject& out);
@@ -37,10 +40,10 @@ void AddressBook_getGroups(const JsonObject& args, JsonArray& out);
 void AddressBook_startListening(const JsonObject& args, JsonObject& out);
 void AddressBook_stopListening(const JsonObject& args, JsonObject& out);
 
-void AddressBook_batchFunc(/*common::NativeFunction impl,*/
-                           const char* single_arg_name, const JsonObject& args/*,
-                           JsonObject& out*/);
+void AddressBook_batchFunc(NativeFunction impl, const char *single_arg_name,
+                           const JsonObject &args, JsonArray &out);
 
+// TODO all batch operations should be implemented using CAPI batch functions
 void AddressBook_addBatch(const JsonObject& args, JsonArray& out);
 
 }  // AddressBook

diff --git a/src/contact/contact_instance.cc b/src/contact/contact_instance.cc
index a383c40cd76b9c129869a488e247c1af0f4df941..20bca6a8b323959e8ab2b0e2c5934b021ead399f 100644 (file)
--- a/src/contact/contact_instance.cc
+++ b/src/contact/contact_instance.cc
@@ -38,9 +38,9 @@ ContactInstance::ContactInstance() {
   REGISTER_SYNC("ContactManager_getAddressBook", ContactManager_getAddressBook);
   REGISTER_SYNC("ContactManager_get", ContactManager_get);
   REGISTER_SYNC("ContactManager_update", ContactManager_update);
-  REGISTER_SYNC("ContactManager_updateBatch", ContactManager_updateBatch);
+  REGISTER_ASYNC("ContactManager_updateBatch", ContactManager_updateBatch);
   REGISTER_SYNC("ContactManager_remove", ContactManager_remove);
-  REGISTER_SYNC("ContactManager_removeBatch", ContactManager_removeBatch);
+  REGISTER_ASYNC("ContactManager_removeBatch", ContactManager_removeBatch);
   REGISTER_ASYNC("ContactManager_find", ContactManager_find);
   REGISTER_SYNC("ContactManager_importFromVCard", ContactManager_importFromVCard);
   REGISTER_SYNC("ContactManager_startListening", ContactManager_startListening);
@@ -48,6 +48,8 @@ ContactInstance::ContactInstance() {
 
   // AddressBook
   REGISTER_ASYNC("AddressBook_addBatch", AddressBook_addBatch);
+  REGISTER_ASYNC("AddressBook_updateBatch", AddressBook_updateBatch);
+  REGISTER_ASYNC("AddressBook_removeBatch", AddressBook_removeBatch);
   REGISTER_SYNC("AddressBook_get", AddressBook_get);
   REGISTER_SYNC("AddressBook_add", AddressBook_add);
   REGISTER_SYNC("AddressBook_update", AddressBook_update);
@@ -91,21 +93,83 @@ void ContactInstance::AddressBook_addBatch(const JsonValue &args, JsonObject &ou
 
   const double callback_id = args.get("callbackId").get<double>();
 
-  auto get = [=](const std::shared_ptr<JsonValue>& response)->void {
-      try {
-        JsonValue result = JsonValue(JsonArray());
-        AddressBook::AddressBook_addBatch(common::JsonCast<JsonObject>(args),
-            result.get<JsonArray>());
-        ReportSuccess(result, response->get<JsonObject>());
-      } catch (const PlatformException& e) {
-        ReportError(e, response->get<JsonObject>());
-      }
+  auto get = [=](const std::shared_ptr <JsonValue> &response) -> void {
+    try {
+      JsonValue result = JsonValue(JsonArray());
+      AddressBook::AddressBook_addBatch(common::JsonCast<JsonObject>(args),
+          result.get<JsonArray>());
+      ReportSuccess(result, response->get<JsonObject>());
+    } catch (const PlatformException &e) {
+      ReportError(e, response->get<JsonObject>());
+    }
   };
 
-  auto get_response = [this, callback_id](const std::shared_ptr<JsonValue>& response) {
-      JsonObject& obj = response->get<JsonObject>();
-      obj.insert(std::make_pair("callbackId", callback_id));
-      PostMessage(response->serialize().c_str());
+  auto get_response = [this, callback_id](const std::shared_ptr <JsonValue> &response) {
+    JsonObject &obj = response->get<JsonObject>();
+    obj.insert(std::make_pair("callbackId", callback_id));
+    PostMessage(response->serialize().c_str());
+  };
+
+  TaskQueue::GetInstance().Queue<JsonValue>(get, get_response,
+      std::shared_ptr<JsonValue>(new JsonValue(JsonObject())));
+}
+
+void ContactInstance::AddressBook_removeBatch(const JsonValue &args, JsonObject &out) {
+  LoggerD("entered");
+  // TODO check privileges
+
+  const double callback_id = args.get("callbackId").get<double>();
+
+  auto get = [=](const std::shared_ptr<JsonValue> &response) -> void {
+    try {
+      JsonValue result = JsonValue(JsonArray());
+      // TODO all batch operations should be implemented using CAPI batch functions
+      AddressBook::AddressBook_batchFunc(AddressBook::AddressBook_remove, "id",
+          common::JsonCast<JsonObject>(args),
+          result.get<JsonArray>());
+
+      ReportSuccess(result, response->get<JsonObject>());
+    }
+    catch (const PlatformException &e) {
+      ReportError(e, response->get<JsonObject>());
+    }
+  };
+
+  auto get_response = [this, callback_id](const std::shared_ptr<JsonValue> &response) {
+    JsonObject &obj = response->get<JsonObject>();
+    obj.insert(std::make_pair("callbackId", callback_id));
+    PostMessage(response->serialize().c_str());
+  };
+
+  TaskQueue::GetInstance().Queue<JsonValue>(get, get_response,
+      std::shared_ptr<JsonValue>(new JsonValue(JsonObject())));
+}
+
+void ContactInstance::AddressBook_updateBatch(const JsonValue& args, JsonObject& out) {
+  LoggerD("entered");
+  // TODO check privileges
+
+  const double callback_id = args.get("callbackId").get<double>();
+
+  auto get = [=](const std::shared_ptr<JsonValue> &response) -> void {
+    try {
+      JsonValue result = JsonValue(JsonArray());
+      // TODO all batch operations should be implemented using CAPI batch functions
+      AddressBook::AddressBook_batchFunc(AddressBook::AddressBook_update, "contact",
+          common::JsonCast<JsonObject>(args),
+          result.get<JsonArray>());
+
+      ReportSuccess(result, response->get<JsonObject>());
+    }
+    catch (const PlatformException &e) {
+      ReportError(e, response->get<JsonObject>());
+    }
+  };
+
+  auto get_response = [this, callback_id](const std::shared_ptr<JsonValue> &response) {
+    JsonObject &obj = response->get<JsonObject>();
+    obj.insert(std::make_pair("callbackId", callback_id));
+    PostMessage(response->serialize().c_str());
   };
 
   TaskQueue::GetInstance().Queue<JsonValue>(get, get_response,
@@ -132,22 +196,20 @@ void ContactInstance::AddressBook_find(const JsonValue& args, JsonObject& out) {
   LoggerD("entered");
   const double callback_id = args.get("callbackId").get<double>();
 
-  auto get = [=](const std::shared_ptr <JsonValue>& response) -> void {
+  auto get = [=](const std::shared_ptr<JsonValue> &response) -> void {
     try {
       JsonValue result = JsonValue(JsonArray());
-      AddressBook::AddressBook_find(common::JsonCast<JsonObject>(args),
-          result.get<JsonArray>());
-      ReportSuccess(result, response->get<picojson::object>());
-    } catch (const PlatformException& e) {
-      ReportError(e, response->get<picojson::object>());
+      AddressBook::AddressBook_find(JsonCast<JsonObject>(args), result.get<JsonArray>());
+      ReportSuccess(result, response->get<JsonObject>());
+    } catch (const PlatformException &e) {
+      ReportError(e, response->get<JsonObject>());
     }
   };
 
-  auto get_response = [this, callback_id](const std::shared_ptr <JsonValue>& response) {
-    picojson::object& obj = response->get<picojson::object>();
+  auto get_response = [this, callback_id](const std::shared_ptr<JsonValue> &response) {
+    JsonObject &obj = response->get<JsonObject>();
     obj.insert(std::make_pair("callbackId", callback_id));
     PostMessage(response->serialize().c_str());
-
   };
 
   TaskQueue::GetInstance().Queue<JsonValue>(get, get_response,
@@ -205,14 +267,14 @@ void ContactInstance::ContactManager_getAddressBooks(const JsonValue& args, Json
       JsonValue result = JsonValue(JsonArray());
       ContactManager::ContactManager_getAddressBooks(common::JsonCast<JsonObject>(args),
           result.get<JsonArray>());
-      ReportSuccess(result, response->get<picojson::object>());
+      ReportSuccess(result, response->get<JsonObject>());
     } catch (const PlatformException &e) {
-      ReportError(e, response->get<picojson::object>());
+      ReportError(e, response->get<JsonObject>());
     }
   };
 
   auto get_response = [this, callback_id](const std::shared_ptr<JsonValue> &response) {
-    picojson::object &obj = response->get<picojson::object>();
+    JsonObject &obj = response->get<JsonObject>();
     obj.insert(std::make_pair("callbackId", callback_id));
     PostMessage(response->serialize().c_str());
   };
@@ -257,8 +319,35 @@ void ContactInstance::ContactManager_update(const JsonValue& args, JsonObject& o
   ReportSuccess(out);
 }
 
-void ContactInstance::ContactManager_updateBatch(const JsonValue& args, JsonObject& out) {
-  // @todo implement
+void ContactInstance::ContactManager_updateBatch(const JsonValue &args, JsonObject &out) {
+  LoggerD("entered");
+  // TODO check privileges
+
+  const double callback_id = args.get("callbackId").get<double>();
+
+  auto get = [=](const std::shared_ptr<JsonValue> &response) -> void {
+    try {
+      JsonValue result = JsonValue(JsonArray());
+      // TODO all batch operations should be implemented using CAPI batch functions
+      AddressBook::AddressBook_batchFunc(ContactManager::ContactManager_update, "person",
+          common::JsonCast<JsonObject>(args),
+          result.get<JsonArray>());
+
+      ReportSuccess(result, response->get<JsonObject>());
+    }
+    catch (const PlatformException &e) {
+      ReportError(e, response->get<JsonObject>());
+    }
+  };
+
+  auto get_response = [this, callback_id](const std::shared_ptr<JsonValue> &response) {
+    JsonObject &obj = response->get<JsonObject>();
+    obj.insert(std::make_pair("callbackId", callback_id));
+    PostMessage(response->serialize().c_str());
+  };
+
+  TaskQueue::GetInstance().Queue<JsonValue>(get, get_response,
+      std::shared_ptr<JsonValue>(new JsonValue(JsonObject())));
 }
 
 void ContactInstance::ContactManager_remove(const JsonValue& args, JsonObject& out) {
@@ -267,8 +356,35 @@ void ContactInstance::ContactManager_remove(const JsonValue& args, JsonObject& o
   ReportSuccess(out);
 }
 
-void ContactInstance::ContactManager_removeBatch(const JsonValue& args, JsonObject& out) {
-  // @todo implement
+void ContactInstance::ContactManager_removeBatch(const JsonValue &args, JsonObject &out) {
+  LoggerD("entered");
+  // TODO check privileges
+
+  const double callback_id = args.get("callbackId").get<double>();
+
+  auto get = [=](const std::shared_ptr<JsonValue> &response) -> void {
+    try {
+      JsonValue result = JsonValue(JsonArray());
+      // TODO all batch operations should be implemented using CAPI batch functions
+      AddressBook::AddressBook_batchFunc(ContactManager::ContactManager_remove, "personId",
+          common::JsonCast<JsonObject>(args),
+          result.get<JsonArray>());
+
+      ReportSuccess(result, response->get<JsonObject>());
+    }
+    catch (const PlatformException &e) {
+      ReportError(e, response->get<JsonObject>());
+    }
+  };
+
+  auto get_response = [this, callback_id](const std::shared_ptr<JsonValue> &response) {
+    JsonObject &obj = response->get<JsonObject>();
+    obj.insert(std::make_pair("callbackId", callback_id));
+    PostMessage(response->serialize().c_str());
+  };
+
+  TaskQueue::GetInstance().Queue<JsonValue>(get, get_response,
+      std::shared_ptr<JsonValue>(new JsonValue(JsonObject())));
 }
 
 void ContactInstance::ContactManager_find(const JsonValue &args, JsonObject &out) {
@@ -281,14 +397,14 @@ void ContactInstance::ContactManager_find(const JsonValue &args, JsonObject &out
       JsonValue result = JsonValue(JsonArray());
       ContactManager::ContactManager_find(common::JsonCast<JsonObject>(args),
           result.get<JsonArray>());
-      ReportSuccess(result, response->get<picojson::object>());
+      ReportSuccess(result, response->get<JsonObject>());
     } catch (const PlatformException &e) {
-      ReportError(e, response->get<picojson::object>());
+      ReportError(e, response->get<JsonObject>());
     }
   };
 
   auto get_response = [this, callback_id](const std::shared_ptr <JsonValue> &response) {
-    picojson::object &obj = response->get<picojson::object>();
+    JsonObject &obj = response->get<JsonObject>();
     obj.insert(std::make_pair("callbackId", callback_id));
     PostMessage(response->serialize().c_str());
   };

diff --git a/src/contact/contact_instance.h b/src/contact/contact_instance.h
index ea1378757854e10675c932a3719b26163437ff97..3e4df598d2fcc7b817c416265b8f9951a22f50ff 100644 (file)
--- a/src/contact/contact_instance.h
+++ b/src/contact/contact_instance.h
@@ -25,13 +25,17 @@ class ContactInstance : public common::ParsedInstance {
   void AddressBook_add(const JsonValue& args, JsonObject& out);
   void AddressBook_addBatch(const JsonValue& args, JsonObject& out);
   void AddressBook_update(const JsonValue& args, JsonObject& out);
+  void AddressBook_updateBatch(const JsonValue& args, JsonObject& out);
   void AddressBook_remove(const JsonValue& args, JsonObject& out);
+  void AddressBook_removeBatch(const JsonValue& args, JsonObject& out);
   void AddressBook_find(const JsonValue& args, JsonObject& out);
-  void AddressBook_addGroup(const JsonValue& args, JsonObject& out);
+
   void AddressBook_getGroup(const JsonValue& args, JsonObject& out);
+  void AddressBook_getGroups(const JsonValue& args, JsonObject& out);
+  void AddressBook_addGroup(const JsonValue& args, JsonObject& out);
   void AddressBook_updateGroup(const JsonValue& args, JsonObject& out);
   void AddressBook_removeGroup(const JsonValue& args, JsonObject& out);
-  void AddressBook_getGroups(const JsonValue& args, JsonObject& out);
+
   void AddressBook_startListening(const JsonValue& args, JsonObject& out);
   void AddressBook_stopListening(const JsonValue& args,JsonObject& out);
 
@@ -110,7 +114,7 @@ class ContactInstance : public common::ParsedInstance {
    * {status: 'success', result: {persons}}
    * @endcode
    */
-  void ContactManager_updateBatch(const JsonValue& args, JsonObject& out);
+  void ContactManager_updateBatch(const JsonValue &args, JsonObject &out);
 
   /**
    * Signature: @code void remove(personId); @endcode
@@ -142,7 +146,7 @@ class ContactInstance : public common::ParsedInstance {
    * {status: 'success'}
    * @endcode
    */
-  void ContactManager_removeBatch(const JsonValue& args, JsonObject& out);
+  void ContactManager_removeBatch(const JsonValue &args, JsonObject &out);
 
   /**
    * Signature: @code void find(successCallback, errorCallback, filter, sortMode);