[Calendar] - refactoring logs

Change-Id: I60672d9b298d4a634c22b24435022a00a11a512c
Signed-off-by: Andrzej Popowski <a.popowski@samsung.com>

diff --git a/src/calendar/calendar.cc b/src/calendar/calendar.cc
index bb1b9be7b5611242436cf623a8762bba395dccd5..0084c0aeeb8dfc7b98265cf9cd820ba104443b59 100755 (executable)
--- a/src/calendar/calendar.cc
+++ b/src/calendar/calendar.cc
@@ -67,7 +67,7 @@ Calendar::~Calendar() {
 
 PlatformResult Calendar::Get(const picojson::object& args, picojson::object& out) {
   if (!CalendarManager::GetInstance().IsConnected()) {
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "DB Connection failed.");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "DB Connection failed.");
   }
 
   int calendar_id = common::stol(FromJson<std::string>(args, "calendarId"));
@@ -112,7 +112,7 @@ PlatformResult Calendar::Get(const picojson::object& args, picojson::object& out
 PlatformResult Calendar::Add(const picojson::object& args,
                              picojson::object& out) {
   if (!CalendarManager::GetInstance().IsConnected()) {
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "DB Connection failed.");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "DB Connection failed.");
   }
 
   const auto& item = FromJson<picojson::object>(args, "item");
@@ -153,12 +153,12 @@ PlatformResult Calendar::Add(const picojson::object& args,
 PlatformResult Calendar::AddBatch(const picojson::object& args,
                                   picojson::array& array) {
   if (!CalendarManager::GetInstance().IsConnected()) {
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "DB Connection failed.");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "DB Connection failed.");
   }
 
   auto& items = FromJson<picojson::array>(args, "items");
   if (items.empty()) {
-    return PlatformResult(ErrorCode::INVALID_VALUES_ERR, "No items");
+    return LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR, "No items");
   }
 
   int type = CalendarRecord::TypeToInt(FromJson<std::string>(args, "type"));
@@ -167,31 +167,32 @@ PlatformResult Calendar::AddBatch(const picojson::object& args,
   if (status.IsError()) return status;
 
   calendar_list_h list = NULL;
-  if (CALENDAR_ERROR_NONE != calendar_list_create(&list)) {
-    LoggerE("Could not create list for batch operation");
-    return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                          "Could not create list for batch operation");
+  int ret = calendar_list_create(&list);
+  if (CALENDAR_ERROR_NONE != ret) {
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, "Could not create list for batch operation",
+              ("calendar_list_create error: %d (%s)", ret, get_error_message(ret)));
   }
   CalendarListPtr list_ptr = CalendarListPtr(list, CalendarRecord::ListDeleter);
 
-  int ret;
   calendar_record_h record;
 
   for (auto& item : items) {
     ret = calendar_record_create(view_uri.c_str(), &record);
     if (CALENDAR_ERROR_NONE != ret) {
-      LoggerW("Can't create platform record %d", ret);
-      return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                            "Can't create platform record");
+      return LogAndCreateResult(
+                ErrorCode::UNKNOWN_ERR, "Can't create platform record",
+                ("calendar_record_create error: %d (%s)", ret, get_error_message(ret)));
     }
     PlatformResult status =
         CalendarItem::FromJson(type, record, item.get<picojson::object>());
     if (status.IsError()) return status;
 
-    if (CALENDAR_ERROR_NONE != calendar_list_add(list_ptr.get(), record)) {
-      LoggerE("Could not add record to list events");
-      return PlatformResult(ErrorCode::INVALID_VALUES_ERR,
-                            "Could not add record to list");
+    ret = calendar_list_add(list_ptr.get(), record);
+    if (CALENDAR_ERROR_NONE != ret) {
+      return LogAndCreateResult(
+                ErrorCode::INVALID_VALUES_ERR, "Could not add record to list",
+                ("calendar_list_add error: %d (%s)", ret, get_error_message(ret)));
     }
   }
 
@@ -199,15 +200,14 @@ PlatformResult Calendar::AddBatch(const picojson::object& args,
   int count;
   ret = calendar_db_insert_records(list_ptr.get(), &ids, &count);
   if (CALENDAR_ERROR_NONE != ret) {
-    LoggerE("calendar_db_insert_records failed.");
     if (CALENDAR_ERROR_INVALID_PARAMETER == ret) {
-      LoggerE("CALENDAR_ERROR_INVALID_PARAMETER.");
-      return PlatformResult(ErrorCode::INVALID_VALUES_ERR,
-                            "Parameter is invalid");
+      return LogAndCreateResult(
+                  ErrorCode::INVALID_VALUES_ERR, "Parameter is invalid",
+                  ("calendar_db_insert_records error: %d (%s)", ret, get_error_message(ret)));
     } else {
-      LoggerE("CALENDAR_ERROR_DB_FAILED");
-      return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                            "CALENDAR_ERROR_DB_FAILED occurred");
+      return LogAndCreateResult(
+                  ErrorCode::UNKNOWN_ERR, "CALENDAR_ERROR_DB_FAILED occurred",
+                  ("calendar_db_insert_records error: %d (%s)", ret, get_error_message(ret)));
     }
   }
 
@@ -231,7 +231,7 @@ PlatformResult Calendar::AddBatch(const picojson::object& args,
 PlatformResult Calendar::Update(const picojson::object& args,
                                 picojson::object& /*out*/) {
   if (!CalendarManager::GetInstance().IsConnected()) {
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "DB Connection failed.");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "DB Connection failed.");
   }
 
   const auto& item = FromJson<picojson::object>(args, "item");
@@ -263,12 +263,15 @@ PlatformResult Calendar::Update(const picojson::object& args,
   status = CalendarItem::FromJson(type, record_ptr.get(), item);
   if (status.IsError()) return status;
 
+  int ret;
+
   if (type == CALENDAR_BOOK_TYPE_TODO || update_all ||
       common::IsNull(item, "recurrenceRule")) {
-    if (CALENDAR_ERROR_NONE != calendar_db_update_record(record_ptr.get())) {
-      LoggerE("Can't update calendar item");
-      return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                            "Can't update calendar item");
+    ret = calendar_db_update_record(record_ptr.get());
+    if (CALENDAR_ERROR_NONE != ret) {
+      return LogAndCreateResult(
+                  ErrorCode::UNKNOWN_ERR, "Can't update calendar item",
+                  ("calendar_db_update_record error: %d (%s)", ret, get_error_message(ret)));
     }
   } else {
     // first update the parent event
@@ -288,10 +291,11 @@ PlatformResult Calendar::Update(const picojson::object& args,
                                        _calendar_event.recurrence_id, "");
     if (status.IsError()) return status;
 
-    if (CALENDAR_ERROR_NONE != calendar_db_update_record(record_ptr.get())) {
-      LoggerE("Can't update calendar item");
-      return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                            "Can't update calendar item");
+    ret = calendar_db_update_record(record_ptr.get());
+    if (CALENDAR_ERROR_NONE != ret) {
+      return LogAndCreateResult(
+                  ErrorCode::UNKNOWN_ERR, "Can't update calendar item",
+                  ("calendar_db_update_record error: %d (%s)", ret, get_error_message(ret)));
     }
 
     // now add the detached child event
@@ -316,12 +320,12 @@ PlatformResult Calendar::Update(const picojson::object& args,
 PlatformResult Calendar::UpdateBatch(const picojson::object& args,
                                      picojson::array& array) {
   if (!CalendarManager::GetInstance().IsConnected()) {
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "DB Connection failed.");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "DB Connection failed.");
   }
 
   auto& items = FromJson<picojson::array>(args, "items");
   if (items.empty()) {
-    return PlatformResult(ErrorCode::INVALID_VALUES_ERR, "No items");
+    return LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR, "No items");
   }
 
   bool update_all = true;
@@ -335,10 +339,11 @@ PlatformResult Calendar::UpdateBatch(const picojson::object& args,
   if (status.IsError()) return status;
 
   calendar_list_h list = NULL;
-  if (CALENDAR_ERROR_NONE != calendar_list_create(&list)) {
-    LoggerE("Could not create list for batch operation");
-    return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                          "Could not create list for batch operation");
+  int ret = calendar_list_create(&list);
+  if (CALENDAR_ERROR_NONE != ret) {
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, "Could not create list for batch operation",
+              ("calendar_list_create error: %d (%s)", ret, get_error_message(ret)));
   }
   CalendarListPtr list_ptr = CalendarListPtr(list, CalendarRecord::ListDeleter);
 
@@ -353,28 +358,30 @@ PlatformResult Calendar::UpdateBatch(const picojson::object& args,
       id = common::stol(FromJson<std::string>(item_obj, "id"));
     }
 
-    int ret = calendar_db_get_record(view_uri.c_str(), id, &record);
+    ret = calendar_db_get_record(view_uri.c_str(), id, &record);
     if (CALENDAR_ERROR_NONE != ret) {
-      LoggerW("Can't get platform record %d", ret);
-      return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                            "Can't get platform record");
+      return LogAndCreateResult(
+                ErrorCode::UNKNOWN_ERR, "Can't get platform record",
+                ("calendar_db_get_record error: %d (%s)", ret, get_error_message(ret)));
     }
     PlatformResult status =
         CalendarItem::FromJson(type, record, item.get<picojson::object>());
     if (status.IsError()) return status;
 
-    if (CALENDAR_ERROR_NONE != calendar_list_add(list_ptr.get(), record)) {
-      LoggerE("Could not add record to list events");
-      return PlatformResult(ErrorCode::INVALID_VALUES_ERR,
-                            "Could not add record to list");
+    ret = calendar_list_add(list_ptr.get(), record);
+    if (CALENDAR_ERROR_NONE != ret) {
+      return LogAndCreateResult(
+                  ErrorCode::INVALID_VALUES_ERR, "Could not add record to list",
+                  ("calendar_list_add error: %d (%s)", ret, get_error_message(ret)));
     }
   }
 
   if (type == CALENDAR_BOOK_TYPE_TODO || update_all) {
-    if (CALENDAR_ERROR_NONE != calendar_db_update_records(list_ptr.get())) {
-      LoggerE("Can't update calendar items");
-      return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                            "Can't update calendar items");
+    ret = calendar_db_update_records(list_ptr.get());
+    if (CALENDAR_ERROR_NONE != ret) {
+      return LogAndCreateResult(
+                  ErrorCode::UNKNOWN_ERR, "Can't update calendar items",
+                  ("calendar_db_update_records error: %d (%s)", ret, get_error_message(ret)));
     }
   } else {
     // @todo update the exdate for a recurring parent event and add a new
@@ -387,7 +394,7 @@ PlatformResult Calendar::UpdateBatch(const picojson::object& args,
 PlatformResult Calendar::Remove(const picojson::object& args,
                                 picojson::object& out) {
   if (!CalendarManager::GetInstance().IsConnected()) {
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "DB Connection failed.");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "DB Connection failed.");
   }
 
   int type = CalendarRecord::TypeToInt(FromJson<std::string>(args, "type"));
@@ -443,7 +450,7 @@ PlatformResult Calendar::SetDefaultFilter(calendar_query_h* calendar_query, int
 
 PlatformResult Calendar::Find(const picojson::object& args, picojson::array& array) {
   if (!CalendarManager::GetInstance().IsConnected()) {
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "DB Connection failed.");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "DB Connection failed.");
   }
   int calendar_id = common::stol(FromJson<std::string>(args, "calendarId"));
   int error_code = 0;
@@ -503,8 +510,8 @@ PlatformResult Calendar::Find(const picojson::object& args, picojson::array& arr
           value = common::stol(JsonCast<std::string>(match_value));
         }
         if (value < 0) {
-          return PlatformResult(ErrorCode::INVALID_VALUES_ERR,
-                                "Match value cannot be less than 0");
+          return LogAndCreateResult(
+                      ErrorCode::INVALID_VALUES_ERR, "Match value cannot be less than 0");
         }
         calendar_match_int_flag_e flag;
         if (AttributeMatchFlag::kExists == match_flag) {
@@ -591,8 +598,8 @@ PlatformResult Calendar::Find(const picojson::object& args, picojson::array& arr
 
     visitor.SetOnCompositeFilterEnd([&](CompositeFilterType calType) {
       if (intermediate_filters.size() == 0) {
-        return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                              "Reached stack size equal to 0!");
+        return LogAndCreateResult(
+                  ErrorCode::UNKNOWN_ERR, "Reached stack size equal to 0!");
       }
       calendar_filter_h merged_filter = nullptr;
 
@@ -613,8 +620,9 @@ PlatformResult Calendar::Find(const picojson::object& args, picojson::array& arr
               merged_filter, CALENDAR_FILTER_OPERATOR_OR);
           if ((status = ErrorChecker(error_code)).IsError()) return status;
         } else {
-          return PlatformResult(ErrorCode::INVALID_VALUES_ERR,
-                                "Invalid union type!");
+          return LogAndCreateResult(
+                      ErrorCode::INVALID_VALUES_ERR, "Invalid union type!",
+                      ("Invalid union type: %d", calType));
         }
       }
       intermediate_filters.pop_back();
@@ -806,8 +814,7 @@ PlatformResult Calendar::Find(const picojson::object& args, picojson::array& arr
     visitor.Visit(FromJson<JsonObject>(args, "filter"));
     if ((intermediate_filters.size() != 1) ||
         (intermediate_filters[0].size() != 1)) {
-      LoggerE("Bad filter evaluation!");
-      return PlatformResult(ErrorCode::UNKNOWN_ERR, "Bad filter evaluation!");
+      return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Bad filter evaluation!");
     }
     error_code = calendar_query_set_filter(calendar_query,
                                            intermediate_filters[0][0].get());
@@ -849,20 +856,27 @@ PlatformResult Calendar::Find(const picojson::object& args, picojson::array& arr
   error_code =
       calendar_db_get_records_with_query(calendar_query, 0, 0, &record_list);
   if (CALENDAR_ERROR_NONE != error_code) {
-    return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                          "calendar_db_get_records_with_query failed");
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, "calendar_db_get_records_with_query failed",
+              ("calendar_db_get_records_with_query error: %d (%s)",
+                  error_code, get_error_message(error_code)));
   }
   CalendarListPtr record_list_ptr(record_list, CalendarRecord::ListDeleter);
 
   int record_count = 0;
   error_code = calendar_list_get_count(record_list, &record_count);
   if (CALENDAR_ERROR_NONE != error_code) {
-    return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                          "calendar_list_get_count failed");
+    return LogAndCreateResult(
+                ErrorCode::UNKNOWN_ERR, "calendar_list_get_count failed",
+                ("calendar_list_get_count error: %d (%s)",
+                      error_code, get_error_message(error_code)));
   }
   error_code = calendar_list_first(record_list);
   if (CALENDAR_ERROR_NONE != error_code) {
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "calendar_list_first failed");
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, "calendar_list_first failed",
+              ("calendar_list_first error: %d (%s)",
+                  error_code, get_error_message(error_code)));
   }
 
   array.reserve(record_count);
@@ -872,8 +886,10 @@ PlatformResult Calendar::Find(const picojson::object& args, picojson::array& arr
     error_code =
         calendar_list_get_current_record_p(record_list, &current_record);
     if (CALENDAR_ERROR_NONE != error_code) {
-      return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                            "calendar_list_get_current_record_p failed");
+      return LogAndCreateResult(
+                ErrorCode::UNKNOWN_ERR, "calendar_list_get_current_record_p failed",
+                ("calendar_list_get_current_record_p error: %d (%s)",
+                    error_code, get_error_message(error_code)));
     }
     picojson::value record_obj = picojson::value(picojson::object());
     PlatformResult status = CalendarItem::ToJson(
@@ -895,12 +911,12 @@ PlatformResult Calendar::Find(const picojson::object& args, picojson::array& arr
 PlatformResult Calendar::RemoveBatch(const picojson::object& args,
                                      picojson::array& array) {
   if (!CalendarManager::GetInstance().IsConnected()) {
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "DB Connection failed.");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "DB Connection failed.");
   }
 
   auto& ids = FromJson<picojson::array>(args, "ids");
   if (ids.empty()) {
-    return PlatformResult(ErrorCode::INVALID_VALUES_ERR, "No items");
+    return LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR, "No items");
   }
 
   int type = CalendarRecord::TypeToInt(FromJson<std::string>(args, "type"));
@@ -949,12 +965,13 @@ PlatformResult Calendar::RemoveBatch(const picojson::object& args,
     if (CALENDAR_ERROR_NONE != ret) {
       LoggerE("calendar_db_delete_records failed.");
       if (CALENDAR_ERROR_INVALID_PARAMETER == ret) {
-        LoggerE("CALENDAR_ERROR_INVALID_PARAMETER");
-        return PlatformResult(ErrorCode::INVALID_VALUES_ERR,
-                              "Parameter is invalid");
+        return LogAndCreateResult(
+                  ErrorCode::INVALID_VALUES_ERR, "Parameter is invalid",
+                  ("calendar_db_delete_records error: %d (%s)", ret, get_error_message(ret)));
       } else {
-        LoggerE("CALENDAR_ERROR_DB_FAILED");
-        return PlatformResult(ErrorCode::UNKNOWN_ERR, "UnknownError");
+        return LogAndCreateResult(
+                  ErrorCode::UNKNOWN_ERR, "UnknownError",
+                  ("calendar_db_delete_records error: %d (%s)", ret, get_error_message(ret)));
       }
     }
   }
@@ -965,7 +982,7 @@ PlatformResult Calendar::RemoveBatch(const picojson::object& args,
 PlatformResult Calendar::AddChangeListener(const picojson::object& args,
                                            picojson::object& out) {
   if (!CalendarManager::GetInstance().IsConnected()) {
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "DB Connection failed.");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "DB Connection failed.");
   }
 
   const std::string& type = FromJson<std::string>(args, "type");
@@ -979,16 +996,17 @@ PlatformResult Calendar::AddChangeListener(const picojson::object& args,
     int ret = calendar_db_add_changed_cb(view_uri.c_str(), ChangeCallback, this);
     if (CALENDAR_ERROR_NONE != ret) {
       LoggerE("Add calendar change callback error for type %s", type.c_str());
-      return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                            "Add calendar change callback error");
+      return LogAndCreateResult(
+                  ErrorCode::UNKNOWN_ERR, "Add calendar change callback error",
+                  ("calendar_db_add_changed_cb error %d (%s)", ret, get_error_message(ret)));
     }
 
     ret = calendar_db_get_current_version(&current_db_version_);
     if (CALENDAR_ERROR_NONE != ret) {
       current_db_version_ = 0;
-      LoggerE("Can't get calendar db version");
-      return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                            "Can't get calendar db version");
+      return LogAndCreateResult(
+                ErrorCode::UNKNOWN_ERR, "Can't get calendar db version",
+                ("calendar_db_get_current_version error: %d (%s)", ret, get_error_message(ret)));
     }
 
     listeners_registered_[type] = listener_id;
@@ -1000,7 +1018,7 @@ PlatformResult Calendar::AddChangeListener(const picojson::object& args,
 PlatformResult Calendar::RemoveChangeListener(const picojson::object& args,
                                               picojson::object& out) {
   if (!CalendarManager::GetInstance().IsConnected()) {
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "DB Connection failed.");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "DB Connection failed.");
   }
 
   const std::string& type = FromJson<std::string>(args, "type");
@@ -1012,10 +1030,10 @@ PlatformResult Calendar::RemoveChangeListener(const picojson::object& args,
 
     int ret = calendar_db_remove_changed_cb(view_uri.c_str(), ChangeCallback, this);
     if (CALENDAR_ERROR_NONE != ret) {
-      LoggerE("Remove calendar change callback error for type %s",
-              type.c_str());
-      return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                            "Remove calendar change callback error");
+      return LogAndCreateResult(
+                ErrorCode::UNKNOWN_ERR, "Remove calendar change callback error",
+                ("Remove calendar change callback error for type %s - %d (%s)",
+                  type.c_str(), ret, get_error_message(ret)));
     }
     listeners_registered_.erase(type);
   }
@@ -1153,7 +1171,9 @@ void Calendar::ChangeCallback(const char* view_uri, void* user_data) {
 
 PlatformResult Calendar::ErrorChecker(int errorCode) {
   if (errorCode != CALENDAR_ERROR_NONE)
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "exception occured");
+    return LogAndCreateResult(
+                ErrorCode::UNKNOWN_ERR, "exception occured",
+                ("Error %d in ErrorChecker (%s)", errorCode, get_error_message(errorCode)));
 
   return PlatformResult(ErrorCode::NO_ERROR);
 }

diff --git a/src/calendar/calendar_instance.cc b/src/calendar/calendar_instance.cc
index ac5f48e123da11b29d784673e2accee62e921b0d..ff220e518f754573f53d7120035d3cbfe5a49a93 100755 (executable)
--- a/src/calendar/calendar_instance.cc
+++ b/src/calendar/calendar_instance.cc
@@ -84,8 +84,7 @@ void CalendarInstance::CalendarGet(const JsonValue& args, JsonObject& out) {
     ReportSuccess(val, out);
   else
   {
-    LoggerE("Failed");
-    ReportError(status, &out);
+    LogAndReportError(status, &out);
   }
 }
 
@@ -99,8 +98,7 @@ void CalendarInstance::CalendarAdd(const JsonValue& args, JsonObject& out) {
   if (status.IsSuccess()) {
     ReportSuccess(val, out);
   } else{
-    LoggerE("Failed");
-    ReportError(status, &out);
+    LogAndReportError(status, &out);
   }
 }
 
@@ -119,8 +117,7 @@ void CalendarInstance::CalendarAddBatch(const JsonValue& args,
       ReportSuccess(result, response->get<picojson::object>());
     else
     {
-      LoggerE("Failed");
-      ReportError(status, &response->get<picojson::object>());
+      LogAndReportError(status, &response->get<picojson::object>());
     }
   };
 
@@ -150,8 +147,7 @@ void CalendarInstance::CalendarUpdate(const JsonValue& args, JsonObject& out) {
     ReportSuccess(val, out);
   else
   {
-    LoggerE("Failed");
-    ReportError(status, &out);
+    LogAndReportError(status, &out);
   }
 }
 
@@ -170,8 +166,7 @@ void CalendarInstance::CalendarUpdateBatch(const JsonValue& args,
       ReportSuccess(result, response->get<picojson::object>());
     else
     {
-      LoggerE("Failed");
-      ReportError(status, &response->get<picojson::object>());
+      LogAndReportError(status, &response->get<picojson::object>());
     }
   };
 
@@ -201,8 +196,7 @@ void CalendarInstance::CalendarRemove(const JsonValue& args, JsonObject& out) {
     ReportSuccess(out);
   else
   {
-    LoggerE("Failed");
-    ReportError(status, &val.get<JsonObject>());
+    LogAndReportError(status, &val.get<JsonObject>());
   }
 }
 
@@ -221,8 +215,7 @@ void CalendarInstance::CalendarRemoveBatch(const JsonValue& args,
       ReportSuccess(result, response->get<picojson::object>());
     else
     {
-      LoggerE("Failed");
-      ReportError(status, &response->get<picojson::object>());
+      LogAndReportError(status, &response->get<picojson::object>());
     }
   };
 
@@ -255,8 +248,7 @@ void CalendarInstance::CalendarFind(const JsonValue& args, JsonObject& out) {
       ReportSuccess(result, response->get<picojson::object>());
     else
     {
-      LoggerE("Failed");
-      ReportError(status, &response->get<picojson::object>());
+      LogAndReportError(status, &response->get<picojson::object>());
     }
   };
 
@@ -287,8 +279,7 @@ void CalendarInstance::CalendarAddChangeListener(const JsonValue& args,
     ReportSuccess(out);
   else
   {
-    LoggerE("Failed");
-    ReportError(status, &val.get<JsonObject>());
+    LogAndReportError(status, &val.get<JsonObject>());
   }
 }
 
@@ -304,8 +295,7 @@ void CalendarInstance::CalendarRemoveChangeListener(const JsonValue& args,
     ReportSuccess(out);
   else
   {
-    LoggerE("Failed");
-    ReportError(status, &val.get<JsonObject>());
+    LogAndReportError(status, &val.get<JsonObject>());
   }
 }
 
@@ -321,8 +311,7 @@ void CalendarInstance::CalendarManagerAddCalendar(const JsonValue& args,
     ReportSuccess(val, out);
   else
   {
-    LoggerE("Failed");
-    ReportError(status, &out);
+    LogAndReportError(status, &out);
   }
 }
 
@@ -337,8 +326,7 @@ void CalendarInstance::CalendarManagerGetCalendar(const JsonValue& args,
     ReportSuccess(val, out);
   else
   {
-    LoggerE("Failed");
-    ReportError(status, &out);
+    LogAndReportError(status, &out);
   }
 }
 
@@ -358,8 +346,7 @@ void CalendarInstance::CalendarManagerGetCalendars(const JsonValue& args,
       ReportSuccess(result, response->get<picojson::object>());
     else
     {
-      LoggerE("Failed");
-      ReportError(status, &response->get<JsonObject>());
+      LogAndReportError(status, &response->get<JsonObject>());
     }
   };
 
@@ -389,8 +376,7 @@ void CalendarInstance::CalendarManagerRemoveCalendar(const JsonValue& args,
     ReportSuccess(val, out);
   else
   {
-    LoggerE("Failed");
-    ReportError(status, &out);
+    LogAndReportError(status, &out);
   }
 }
 

diff --git a/src/calendar/calendar_item.cc b/src/calendar/calendar_item.cc
index d221776421430e98127d829545c18e95f6cc792a..cb95c0b3d22c52eccb315bab50e4fe751a1a2860 100755 (executable)
--- a/src/calendar/calendar_item.cc
+++ b/src/calendar/calendar_item.cc
@@ -195,7 +195,6 @@ PlatformResult CalendarItem::Create(int type, calendar_record_h* handle) {
   std::string value_str;
   PlatformResult status = CalendarRecord::TypeToUri(type, &value_str);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
@@ -207,14 +206,12 @@ PlatformResult CalendarItem::Remove(int type, int id) {
   std::string view_uri;
   PlatformResult status = CalendarRecord::TypeToUri(type, &view_uri);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
   calendar_record_h handle = nullptr;
   status = GetById(id, view_uri.c_str(), &handle);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
@@ -225,21 +222,22 @@ PlatformResult CalendarItem::Remove(int type, int id) {
     PlatformResult status =
         GetString(type, record.get(), "recurrence_id", &rid);
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
 
     if (rid.length() > 0) {
       // @todo remove all occurrences
-      LoggerE("Error: TODO: remove all occurrences");
-      return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                            "TODO: remove all occurrences");
+      return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                                "TODO: remove all occurrences");
     }
   }
 
-  if (CALENDAR_ERROR_NONE != calendar_db_delete_record(view_uri.c_str(), id)) {
+  int ret = calendar_db_delete_record(view_uri.c_str(), id);
+  if (CALENDAR_ERROR_NONE != ret) {
     LOGE("Calendar record delete error");
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Record deletion error");
+    return LogAndCreateResult(
+                ErrorCode::UNKNOWN_ERR, "Record deletion error",
+                ("calendar_db_delete_record error: %d (%s)", ret, get_error_message(ret)));
   }
 
   return PlatformResult(ErrorCode::NO_ERROR);
@@ -251,17 +249,15 @@ PlatformResult CalendarItem::GetPlatformProperty(int type,
   LoggerD("Enter");
   if (platform_property_map_.find(property) == platform_property_map_.end()) {
     std::string message = std::string("Undefined property ") + property;
-    LoggerE("Error: %s", message.c_str());
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, message);
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, message);
   }
 
   auto prop = platform_property_map_.at(property);
   if (prop.find(type) == prop.end()) {
-    LoggerE("Property %s not defined for type %d", property.c_str(), type);
-    return PlatformResult(
-        ErrorCode::INVALID_VALUES_ERR,
-        std::string("Property %s not defined for type ", property.c_str()) +
-        std::to_string(type));
+    return LogAndCreateResult(
+              ErrorCode::INVALID_VALUES_ERR,
+              std::string("Property %s not defined for type ", property.c_str()) +
+              std::to_string(type));
   }
 
   *value = prop.at(type);
@@ -276,8 +272,7 @@ PlatformResult CalendarItem::StringToPlatformEnum(const std::string& field,
   auto iter = platform_enum_map_.find(field);
   if (iter == platform_enum_map_.end()) {
     std::string message = std::string("Undefined platform enum type ") + field;
-    LoggerE("Error: %s", message.c_str());
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, message);
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, message);
   }
 
   auto def = platform_enum_map_.at(field);
@@ -296,8 +291,7 @@ PlatformResult CalendarItem::StringToPlatformEnum(const std::string& field,
 
   std::string message =
       "Platform enum value " + value + " not found for " + field;
-  LoggerE("Error: %s", message.c_str());
-  return PlatformResult(ErrorCode::INVALID_VALUES_ERR, message);
+  return LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR, message);
 }
 
 PlatformResult CalendarItem::PlatformEnumToString(const std::string& field,
@@ -320,8 +314,7 @@ PlatformResult CalendarItem::PlatformEnumToString(const std::string& field,
   auto iter = platform_enum_reverse_map_.find(field);
   if (iter == platform_enum_reverse_map_.end()) {
     std::string message = std::string("Undefined platform enum type ") + field;
-    LoggerE("Error: %s", message.c_str());
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, message);
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, message);
   }
 
   auto def = platform_enum_reverse_map_.at(field);
@@ -333,8 +326,7 @@ PlatformResult CalendarItem::PlatformEnumToString(const std::string& field,
 
   std::string message = "Platform enum value " + std::to_string(value) +
       " not found for " + field;
-  LoggerE("Error: %s", message.c_str());
-  return PlatformResult(ErrorCode::INVALID_VALUES_ERR, message);
+  return LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR, message);
 }
 
 PlatformResult CalendarItem::SetString(int type, calendar_record_h rec,
@@ -361,14 +353,12 @@ PlatformResult CalendarItem::SetString(int type, calendar_record_h rec,
   unsigned int prop;
   PlatformResult status = GetPlatformProperty(type, property, &prop);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
   if (prop != -1u) {
     PlatformResult status = CalendarRecord::SetString(rec, prop, value);
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
   }
@@ -384,7 +374,6 @@ PlatformResult CalendarItem::GetString(int type, calendar_record_h rec,
   unsigned int prop;
   PlatformResult status = GetPlatformProperty(type, property, &prop);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
@@ -412,7 +401,6 @@ PlatformResult CalendarItem::SetInt(int type, calendar_record_h rec,
   unsigned int prop;
   PlatformResult status = GetPlatformProperty(type, property, &prop);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
@@ -426,7 +414,6 @@ PlatformResult CalendarItem::GetInt(int type, calendar_record_h rec,
   unsigned int prop;
   PlatformResult status = GetPlatformProperty(type, property, &prop);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
@@ -443,13 +430,11 @@ PlatformResult CalendarItem::SetEnum(int type, calendar_record_h rec,
   int value_int;
   PlatformResult status = StringToPlatformEnum(enum_name, value, &value_int);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
   status = SetInt(type, rec, property, value_int);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
@@ -464,13 +449,11 @@ PlatformResult CalendarItem::SetEnum(calendar_record_h rec,
   int value_int;
   PlatformResult status = StringToPlatformEnum(enum_name, value, &value_int);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
   status = CalendarRecord::SetInt(rec, property, value_int);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
@@ -484,7 +467,6 @@ PlatformResult CalendarItem::GetEnum(int type, calendar_record_h rec,
   int value;
   PlatformResult status = GetInt(type, rec, property, &value);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
@@ -499,7 +481,6 @@ PlatformResult CalendarItem::GetEnum(calendar_record_h rec,
   int value;
   PlatformResult status = CalendarRecord::GetInt(rec, property, &value);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
@@ -513,15 +494,14 @@ PlatformResult CalendarItem::SetDouble(int type, calendar_record_h rec,
   unsigned int prop;
   PlatformResult status = GetPlatformProperty(type, property, &prop);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
   int ret = calendar_record_set_double(rec, prop, value);
-
   if (CALENDAR_ERROR_NONE != ret) {
-    LoggerW("Can't set double value to record: %d", ret);
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Set double to record failed.");
+    return LogAndCreateResult(
+                ErrorCode::UNKNOWN_ERR, "Set double to record failed.",
+                ("calendar_record_set_double error: %d (%s)", ret, get_error_message(ret)));
   }
 
   return PlatformResult(ErrorCode::NO_ERROR);
@@ -535,15 +515,14 @@ PlatformResult CalendarItem::GetDouble(int type, calendar_record_h rec,
   unsigned int prop;
   PlatformResult status = GetPlatformProperty(type, property, &prop);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
   int ret = calendar_record_get_double(rec, prop, value);
   if (CALENDAR_ERROR_NONE != ret) {
-    LoggerW("Can't get double value form record: %d", ret);
-    return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                          "Get int from record failed.");
+    return LogAndCreateResult(
+                ErrorCode::UNKNOWN_ERR, "Get int from record failed.",
+                ("calendar_record_get_double error: %d (%s)", ret, get_error_message(ret)));
   }
 
   return PlatformResult(ErrorCode::NO_ERROR);
@@ -557,7 +536,6 @@ PlatformResult CalendarItem::SetCaltime(int type, calendar_record_h rec,
   unsigned int prop;
   PlatformResult status = GetPlatformProperty(type, property, &prop);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
@@ -572,12 +550,11 @@ PlatformResult CalendarItem::SetCaltime(calendar_record_h rec,
   int ret = calendar_record_set_caltime(rec, property, value);
 
   if (CALENDAR_ERROR_NONE != ret) {
-    LoggerW("Can't set caltime value to record: %d", ret);
+    LoggerW("Can't set caltime value to record: %d (%s)", ret, get_error_message(ret));
 
     if (throw_on_error) {
       std::string message = "Set caltime to record failed.";
-      LoggerE("Error: %s", message.c_str());
-      return PlatformResult(ErrorCode::UNKNOWN_ERR, message);
+      return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, message);
     }
   }
 
@@ -593,7 +570,6 @@ PlatformResult CalendarItem::GetCaltime(int type, calendar_record_h rec,
   unsigned int prop;
   PlatformResult status = GetPlatformProperty(type, property, &prop);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
@@ -611,8 +587,7 @@ PlatformResult CalendarItem::GetCaltime(calendar_record_h rec,
       LoggerW("Can't get calendar_time value form record: %d", ret);
       if (throw_on_error) {
         std::string message = "Can't get calendar_time value form record";
-        LoggerE("Error: %s", message.c_str());
-        return PlatformResult(ErrorCode::UNKNOWN_ERR, message);
+        return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, message);
       }
     }
   }
@@ -631,8 +606,7 @@ PlatformResult CalendarItem::SetLli(calendar_record_h rec,
 
     if (throw_on_error) {
       std::string message = "Set long long int to record failed.";
-      LoggerE("Error: %s", message.c_str());
-      return PlatformResult(ErrorCode::UNKNOWN_ERR, message);
+      return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, message);
     }
   }
 
@@ -647,7 +621,6 @@ PlatformResult CalendarItem::GetLli(int type, calendar_record_h rec,
   unsigned int prop;
   PlatformResult status = GetPlatformProperty(type, property, &prop);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
@@ -663,8 +636,7 @@ PlatformResult CalendarItem::GetLli(calendar_record_h rec,
     LoggerW("Can't get lli value form record: %d", ret);
     if (throw_on_error) {
       std::string message = "Get lli from record failed.";
-      LoggerE("Error: %s", message.c_str());
-      return PlatformResult(ErrorCode::UNKNOWN_ERR, message);
+      return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, message);
     }
   }
 
@@ -718,7 +690,6 @@ PlatformResult CalendarItem::CategoriesFromJson(int type, calendar_record_h rec,
 
   PlatformResult status = SetString(type, rec, "categories", categories);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
@@ -731,7 +702,6 @@ PlatformResult CalendarItem::CategoriesToJson(int type, calendar_record_h rec,
   std::string categories;
   PlatformResult status = GetString(type, rec, "categories", &categories);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
@@ -758,15 +728,16 @@ PlatformResult CalendarItem::AttendeesFromJson(int type, calendar_record_h rec,
 
     int ret = calendar_record_create(_calendar_attendee._uri, &attendee);
     if (CALENDAR_ERROR_NONE != ret) {
-      LoggerE("Fail to create attendee record, error code: %d", ret);
-      return PlatformResult(ErrorCode::UNKNOWN_ERR, "Fail to create attendee record");
+      return LogAndCreateResult(
+                  ErrorCode::UNKNOWN_ERR, "Fail to create attendee record",
+                  ("Fail to create attendee record, error code: %d (%s)",
+                      ret, get_error_message(ret)));
     }
 
     PlatformResult status =
         CalendarRecord::SetString(attendee, _calendar_attendee.email,
                                   common::FromJson<std::string>(obj, "uri"));
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
 
@@ -775,7 +746,6 @@ PlatformResult CalendarItem::AttendeesFromJson(int type, calendar_record_h rec,
           CalendarRecord::SetString(attendee, _calendar_attendee.name,
                                     common::FromJson<std::string>(obj, "name"));
       if (status.IsError()) {
-        LoggerE("Error: %s", status.message().c_str());
         return status;
       }
     }
@@ -783,28 +753,24 @@ PlatformResult CalendarItem::AttendeesFromJson(int type, calendar_record_h rec,
     status = SetEnum(attendee, _calendar_attendee.role, kAttendeeRole,
                      common::FromJson<std::string>(obj, "role"));
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
 
     status = SetEnum(attendee, _calendar_attendee.status, kAttendeeStatus,
                      common::FromJson<std::string>(obj, "status"));
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
 
     status = CalendarRecord::SetInt(attendee, _calendar_attendee.rsvp,
                                     common::FromJson<bool>(obj, "RSVP"));
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
 
     status = SetEnum(attendee, _calendar_attendee.cutype, kAttendeeType,
                      common::FromJson<std::string>(obj, "type"));
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
 
@@ -812,7 +778,6 @@ PlatformResult CalendarItem::AttendeesFromJson(int type, calendar_record_h rec,
       status = CalendarRecord::SetString(attendee, _calendar_attendee.group,
                                          common::FromJson<std::string>(obj, "group"));
       if (status.IsError()) {
-        LoggerE("Error: %s", status.message().c_str());
         return status;
       }
     }
@@ -821,7 +786,6 @@ PlatformResult CalendarItem::AttendeesFromJson(int type, calendar_record_h rec,
           attendee, _calendar_attendee.delegator_uri,
           common::FromJson<std::string>(obj, "delegatorURI"));
       if (status.IsError()) {
-        LoggerE("Error: %s", status.message().c_str());
         return status;
       }
     }
@@ -830,7 +794,6 @@ PlatformResult CalendarItem::AttendeesFromJson(int type, calendar_record_h rec,
           attendee, _calendar_attendee.delegatee_uri,
           common::FromJson<std::string>(obj, "delegateURI"));
       if (status.IsError()) {
-        LoggerE("Error: %s", status.message().c_str());
         return status;
       }
     }
@@ -840,7 +803,6 @@ PlatformResult CalendarItem::AttendeesFromJson(int type, calendar_record_h rec,
           attendee, _calendar_attendee.uid,
           common::FromJson<std::string>(obj, "contactRef", "contactId"));
       if (status.IsError()) {
-        LoggerE("Error: %s", status.message().c_str());
         return status;
       }
 
@@ -850,7 +812,6 @@ PlatformResult CalendarItem::AttendeesFromJson(int type, calendar_record_h rec,
       status = CalendarRecord::SetInt(attendee, _calendar_attendee.person_id,
                                       common::stol(address_book));
       if (status.IsError()) {
-        LoggerE("Error: %s", status.message().c_str());
         return status;
       }
     } else {
@@ -859,7 +820,6 @@ PlatformResult CalendarItem::AttendeesFromJson(int type, calendar_record_h rec,
 
     status = AddChildRecord(rec, property, attendee);
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
   }
@@ -880,7 +840,6 @@ PlatformResult CalendarItem::AttendeesToJson(int type, calendar_record_h rec,
   unsigned int count = 0;
   PlatformResult status = GetChildRecordCount(rec, property, true, &count);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
   if (!count) {
@@ -889,10 +848,12 @@ PlatformResult CalendarItem::AttendeesToJson(int type, calendar_record_h rec,
   }
 
   calendar_list_h list;
-  if (CALENDAR_ERROR_NONE !=
-      calendar_record_clone_child_record_list(rec, property, &list)) {
-    LoggerE("Can't get attendee list");
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Can't get attendee list");
+  int ret = calendar_record_clone_child_record_list(rec, property, &list);
+  if (CALENDAR_ERROR_NONE != ret) {
+    return LogAndCreateResult(
+                ErrorCode::UNKNOWN_ERR, "Can't get attendee list",
+                ("calendar_record_clone_child_record_list error: %d (%s)",
+                    ret, get_error_message(ret)));
   }
   CalendarListPtr(list, CalendarRecord::ListDeleter);
 
@@ -912,7 +873,6 @@ PlatformResult CalendarItem::AttendeesToJson(int type, calendar_record_h rec,
     PlatformResult status = CalendarRecord::GetString(
         attendee, _calendar_attendee.email, &value_str);
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
     attendee_obj["uri"] = picojson::value(value_str);
@@ -920,7 +880,6 @@ PlatformResult CalendarItem::AttendeesToJson(int type, calendar_record_h rec,
     status = CalendarRecord::GetString(attendee, _calendar_attendee.name,
                                        &value_str);
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
     attendee_obj["name"] = picojson::value(value_str);
@@ -929,7 +888,6 @@ PlatformResult CalendarItem::AttendeesToJson(int type, calendar_record_h rec,
     status =
         GetEnum(attendee, _calendar_attendee.role, kAttendeeRole, &enum_str);
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
     attendee_obj["role"] = picojson::value(enum_str);
@@ -937,7 +895,6 @@ PlatformResult CalendarItem::AttendeesToJson(int type, calendar_record_h rec,
     status = GetEnum(attendee, _calendar_attendee.status, kAttendeeStatus,
                      &enum_str);
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
     attendee_obj["status"] = picojson::value(enum_str);
@@ -946,7 +903,6 @@ PlatformResult CalendarItem::AttendeesToJson(int type, calendar_record_h rec,
     status =
         CalendarRecord::GetInt(attendee, _calendar_attendee.rsvp, &value_int);
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
     attendee_obj["RSVP"] = picojson::value(static_cast<bool>(value_int));
@@ -954,7 +910,6 @@ PlatformResult CalendarItem::AttendeesToJson(int type, calendar_record_h rec,
     status =
         GetEnum(attendee, _calendar_attendee.cutype, kAttendeeType, &enum_str);
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
     attendee_obj["type"] = picojson::value(enum_str);
@@ -962,7 +917,6 @@ PlatformResult CalendarItem::AttendeesToJson(int type, calendar_record_h rec,
     status = CalendarRecord::GetString(attendee, _calendar_attendee.group,
                                        &value_str);
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
     attendee_obj["group"] = picojson::value(value_str);
@@ -970,7 +924,6 @@ PlatformResult CalendarItem::AttendeesToJson(int type, calendar_record_h rec,
     status = CalendarRecord::GetString(
         attendee, _calendar_attendee.delegator_uri, &value_str);
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
     attendee_obj["delegatorURI"] = picojson::value(value_str);
@@ -978,7 +931,6 @@ PlatformResult CalendarItem::AttendeesToJson(int type, calendar_record_h rec,
     status = CalendarRecord::GetString(
         attendee, _calendar_attendee.delegatee_uri, &value_str);
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
     attendee_obj["delegateURI"] = picojson::value(value_str);
@@ -988,7 +940,6 @@ PlatformResult CalendarItem::AttendeesToJson(int type, calendar_record_h rec,
     status = CalendarRecord::GetString(attendee, _calendar_attendee.uid,
                                        &contact_id);
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
 
@@ -996,7 +947,6 @@ PlatformResult CalendarItem::AttendeesToJson(int type, calendar_record_h rec,
     status = CalendarRecord::GetInt(attendee, _calendar_attendee.person_id,
                                     &book_id);
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
 
@@ -1028,9 +978,10 @@ PlatformResult CalendarItem::AlarmsFromJson(int type, calendar_record_h rec,
 
     int ret = calendar_record_create(_calendar_alarm._uri, &alarm);
     if (CALENDAR_ERROR_NONE != ret) {
-      LoggerE("Fail to create attendee record, error code: %d", ret);
-      return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                            "Fail to create attendee record");
+      return LogAndCreateResult(
+                  ErrorCode::UNKNOWN_ERR, "Fail to create attendee record",
+                  ("Fail to create attendee record, error: %d (%s)",
+                      ret, get_error_message(ret)));
     }
 
     int tick_unit = CALENDAR_ALARM_TIME_UNIT_SPECIFIC;
@@ -1040,14 +991,12 @@ PlatformResult CalendarItem::AlarmsFromJson(int type, calendar_record_h rec,
       PlatformResult status =
           SetCaltime(alarm, _calendar_alarm.alarm_time, absolute_date);
       if (status.IsError()) {
-        LoggerE("Error: %s", status.message().c_str());
         return status;
       }
 
       status =
           CalendarRecord::SetInt(alarm, _calendar_alarm.tick_unit, tick_unit);
       if (status.IsError()) {
-        LoggerE("Error: %s", status.message().c_str());
         return status;
       }
     }
@@ -1080,14 +1029,12 @@ PlatformResult CalendarItem::AlarmsFromJson(int type, calendar_record_h rec,
       PlatformResult status =
           CalendarRecord::SetInt(alarm, _calendar_alarm.tick, tick);
       if (status.IsError()) {
-        LoggerE("Error: %s", status.message().c_str());
         return status;
       }
 
       status =
           CalendarRecord::SetInt(alarm, _calendar_alarm.tick_unit, tick_unit);
       if (status.IsError()) {
-        LoggerE("Error: %s", status.message().c_str());
         return status;
       }
     }
@@ -1102,7 +1049,6 @@ PlatformResult CalendarItem::AlarmsFromJson(int type, calendar_record_h rec,
     PlatformResult status =
         SetEnum(alarm, _calendar_alarm.action, kAlarmMethod, method);
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
 
@@ -1110,13 +1056,11 @@ PlatformResult CalendarItem::AlarmsFromJson(int type, calendar_record_h rec,
         alarm, _calendar_alarm.description,
         common::FromJson<std::string>(obj, "description"));
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
 
     status = AddChildRecord(rec, property, alarm);
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
   }
@@ -1137,7 +1081,6 @@ PlatformResult CalendarItem::AlarmsToJson(int type, calendar_record_h rec,
   unsigned int count = 0;
   PlatformResult status = GetChildRecordCount(rec, property, true, &count);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
   if (!count) {
@@ -1146,10 +1089,11 @@ PlatformResult CalendarItem::AlarmsToJson(int type, calendar_record_h rec,
   }
 
   calendar_list_h list;
-  if (CALENDAR_ERROR_NONE !=
-      calendar_record_clone_child_record_list(rec, property, &list)) {
-    LoggerW("Can't get alarms list");
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Can't get alarms list");
+  int ret = calendar_record_clone_child_record_list(rec, property, &list);
+  if (CALENDAR_ERROR_NONE != ret) {
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, "Can't get alarms list",
+              ("Can't get alarms list %d (%s)", ret, get_error_message(ret)));
   }
   CalendarListPtr(list, CalendarRecord::ListDeleter);
 
@@ -1169,7 +1113,6 @@ PlatformResult CalendarItem::AlarmsToJson(int type, calendar_record_h rec,
     PlatformResult status =
         CalendarRecord::GetInt(alarm, _calendar_alarm.tick_unit, &tick_unit);
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
 
@@ -1177,7 +1120,6 @@ PlatformResult CalendarItem::AlarmsToJson(int type, calendar_record_h rec,
       calendar_time_s result;
       status = GetCaltime(alarm, _calendar_alarm.alarm_time, &result);
       if (status.IsError()) {
-        LoggerE("Error: %s", status.message().c_str());
         return status;
       }
 
@@ -1185,7 +1127,6 @@ PlatformResult CalendarItem::AlarmsToJson(int type, calendar_record_h rec,
     } else {
       status = CalendarRecord::GetInt(alarm, _calendar_alarm.tick, &tick);
       if (status.IsError()) {
-        LoggerE("Error: %s", status.message().c_str());
         return status;
       }
 
@@ -1215,7 +1156,6 @@ PlatformResult CalendarItem::AlarmsToJson(int type, calendar_record_h rec,
     std::string enum_str;
     status = GetEnum(alarm, _calendar_alarm.action, kAlarmMethod, &enum_str);
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
     alarm_obj["method"] = picojson::value(enum_str);
@@ -1225,7 +1165,6 @@ PlatformResult CalendarItem::AlarmsToJson(int type, calendar_record_h rec,
                                        &value_str);
     alarm_obj["description"] = picojson::value(value_str);
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
 
@@ -1244,14 +1183,12 @@ PlatformResult CalendarItem::RecurrenceRuleFromJson(
   PlatformResult status =
       SetEnum(rec, _calendar_event.freq, kRecurrenceRuleFrequency, frequency);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
   const unsigned short interval = common::FromJson<double>(rrule, "interval");
   status = CalendarRecord::SetInt(rec, _calendar_event.interval, interval);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
@@ -1261,14 +1198,12 @@ PlatformResult CalendarItem::RecurrenceRuleFromJson(
     status =
         CalendarRecord::SetInt(rec, _calendar_event.count, occurrence_count);
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
 
     status = CalendarRecord::SetInt(rec, _calendar_event.range_type,
                                     CALENDAR_RANGE_COUNT);
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
   }
@@ -1278,14 +1213,12 @@ PlatformResult CalendarItem::RecurrenceRuleFromJson(
     status = SetCaltime(rec, _calendar_event.until_time,
                         DateToPlatform(until, false));
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
 
     status = CalendarRecord::SetInt(rec, _calendar_event.range_type,
                                     CALENDAR_RANGE_UNTIL);
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
   }
@@ -1302,7 +1235,6 @@ PlatformResult CalendarItem::RecurrenceRuleFromJson(
   }
   status = CalendarRecord::SetString(rec, _calendar_event.byday, byday);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
@@ -1319,7 +1251,6 @@ PlatformResult CalendarItem::RecurrenceRuleFromJson(
   }
   status = CalendarRecord::SetString(rec, _calendar_event.bysetpos, bysetpos);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
@@ -1328,7 +1259,6 @@ PlatformResult CalendarItem::RecurrenceRuleFromJson(
       ExceptionsFromJson(
           common::FromJson<picojson::array>(rrule, "exceptions")));
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
@@ -1365,7 +1295,6 @@ PlatformResult CalendarItem::RecurrenceRuleToJson(calendar_record_h rec,
   PlatformResult status =
       GetEnum(rec, _calendar_event.freq, kRecurrenceRuleFrequency, &enum_str);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
   out["frequency"] = picojson::value(enum_str);
@@ -1374,7 +1303,6 @@ PlatformResult CalendarItem::RecurrenceRuleToJson(calendar_record_h rec,
   status =
       CalendarRecord::GetInt(rec, _calendar_event.interval, &interval);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
   out["interval"] = picojson::value(static_cast<double>(interval));
@@ -1391,21 +1319,18 @@ PlatformResult CalendarItem::RecurrenceRuleToJson(calendar_record_h rec,
   std::string value_str;
   status = CalendarRecord::GetString(rec, _calendar_event.byday, &value_str);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
   out["daysOfTheWeek"] = picojson::value(StringToArray(value_str));
 
   status = CalendarRecord::GetString(rec, _calendar_event.bysetpos, &value_str);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
   out["setPositions"] = picojson::value(StringToArray(value_str));
 
   status = CalendarRecord::GetString(rec, _calendar_event.exdate, &value_str);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
   const picojson::array& exceptions = StringToArray(value_str);
@@ -1442,14 +1367,12 @@ PlatformResult CalendarItem::DateFromPlatform(int type, calendar_record_h rec,
   calendar_time_s cal;
   PlatformResult status = GetCaltime(type, rec, property + "_time", &cal);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
   std::string tzid;
   status = GetString(type, rec, property + "_tzid", &tzid);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
@@ -1469,7 +1392,6 @@ PlatformResult CalendarItem::DateFromPlatform(calendar_record_h rec,
   calendar_time_s cal;
   PlatformResult status = GetCaltime(rec, property, &cal);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
@@ -1486,32 +1408,27 @@ PlatformResult CalendarItem::FromJson(int type, calendar_record_h rec,
                                       const picojson::object& in) {
   LoggerD("Enter");
   if (in.empty()) {
-    LoggerE("Empty CalendarItem object.");
-    return PlatformResult(ErrorCode::INVALID_VALUES_ERR,
-                          "Empty Calendar object.");
+    return LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR,
+                              "Empty Calendar object.");
   }
 
   PlatformResult status = SetString(type, rec, "description", in, true);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
   status = SetString(type, rec, "summary", in, true);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
   status = SetString(type, rec, "location", in, true);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
   status = SetString(type, rec, "organizer", in, true);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
@@ -1533,13 +1450,11 @@ PlatformResult CalendarItem::FromJson(int type, calendar_record_h rec,
     status = SetCaltime(type, rec, "startDate_time",
                         DateToPlatform(start, is_all_day));
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
 
     status = SetString(type, rec, "startDate_tzid", start.time_zone_);
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
   }
@@ -1557,20 +1472,17 @@ PlatformResult CalendarItem::FromJson(int type, calendar_record_h rec,
     status = SetCaltime(type, rec, end_property + "_time",
                         DateToPlatform(end, is_all_day));
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
 
     status = SetString(type, rec, end_property + "_tzid", end.time_zone_);
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
   }
 
   status = SetEnum(type, rec, "visibility", in, kItemVisibility);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
@@ -1579,7 +1491,6 @@ PlatformResult CalendarItem::FromJson(int type, calendar_record_h rec,
         SetDouble(type, rec, "latitude",
                   common::FromJson<double>(in, "geolocation", "latitude"));
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
 
@@ -1587,7 +1498,6 @@ PlatformResult CalendarItem::FromJson(int type, calendar_record_h rec,
         SetDouble(type, rec, "longitude",
                   common::FromJson<double>(in, "geolocation", "longitude"));
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
   }
@@ -1595,40 +1505,34 @@ PlatformResult CalendarItem::FromJson(int type, calendar_record_h rec,
   status = CategoriesFromJson(
       type, rec, common::FromJson<picojson::array>(in, "categories"));
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
   status = AttendeesFromJson(
       type, rec, common::FromJson<picojson::array>(in, "attendees"));
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
   status = AlarmsFromJson(type, rec,
                           common::FromJson<picojson::array>(in, "alarms"));
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
   if (type == CALENDAR_BOOK_TYPE_EVENT) {
     status = SetEnum(type, rec, "priority", in, kEventPriority);
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
 
     status = SetEnum(type, rec, "status", in, kEventStatus);
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
 
     status = SetEnum(type, rec, "availability", in, kEventAvailability);
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
 
@@ -1636,7 +1540,6 @@ PlatformResult CalendarItem::FromJson(int type, calendar_record_h rec,
       status = RecurrenceRuleFromJson(
           rec, common::FromJson<picojson::object>(in, "recurrenceRule"));
       if (status.IsError()) {
-        LoggerE("Error: %s", status.message().c_str());
         return status;
       }
     }
@@ -1644,13 +1547,11 @@ PlatformResult CalendarItem::FromJson(int type, calendar_record_h rec,
   } else {
     status = SetEnum(type, rec, "priority", in, kTaskPriority);
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
 
     status = SetEnum(type, rec, "status", in, kTaskStatus);
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
 
@@ -1659,14 +1560,12 @@ PlatformResult CalendarItem::FromJson(int type, calendar_record_h rec,
           SetLli(rec, _calendar_todo.completed_time,
                  DateFromJson(in, "completedDate").utc_timestamp_);
       if (status.IsError()) {
-        LoggerE("Error: %s", status.message().c_str());
         return status;
       }
     }
 
     PlatformResult status = SetInt(type, rec, "progress", in);
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
   }
@@ -1678,8 +1577,7 @@ PlatformResult CalendarItem::ToJson(int type, calendar_record_h rec,
                                     picojson::object* out_ptr) {
   LoggerD("Enter");
   if (NULL == rec) {
-    LoggerE("Calendar record is null");
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Calendar record is null");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Calendar record is null");
   }
 
   picojson::object& out = *out_ptr;
@@ -1687,7 +1585,6 @@ PlatformResult CalendarItem::ToJson(int type, calendar_record_h rec,
   int id;
   PlatformResult status = GetInt(type, rec, "id", &id);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
@@ -1700,7 +1597,6 @@ PlatformResult CalendarItem::ToJson(int type, calendar_record_h rec,
     std::string rid;
     status = GetString(type, rec, "recurrence_id", &rid);
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
 
@@ -1718,7 +1614,6 @@ PlatformResult CalendarItem::ToJson(int type, calendar_record_h rec,
   int calendar_id;
   status = GetInt(type, rec, "calendar_id", &calendar_id);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
   out["calendarId"] = picojson::value(std::to_string(calendar_id));
@@ -1726,28 +1621,24 @@ PlatformResult CalendarItem::ToJson(int type, calendar_record_h rec,
   std::string value_str;
   status = GetString(type, rec, "description", &value_str);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
   out["description"] = picojson::value(value_str);
 
   status = GetString(type, rec, "summary", &value_str);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
   out["summary"] = picojson::value(value_str);
 
   status = GetString(type, rec, "location", &value_str);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
   out["location"] = picojson::value(value_str);
 
   status = GetString(type, rec, "organizer", &value_str);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
   out["organizer"] = picojson::value(value_str);
@@ -1755,7 +1646,6 @@ PlatformResult CalendarItem::ToJson(int type, calendar_record_h rec,
   int value_int;
   status = GetInt(type, rec, "isAllDay", &value_int);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
   out["isAllDay"] = picojson::value(static_cast<bool>(value_int));
@@ -1771,7 +1661,6 @@ PlatformResult CalendarItem::ToJson(int type, calendar_record_h rec,
       (type == CALENDAR_BOOK_TYPE_EVENT) ? "endDate" : "dueDate";
   status = DateFromPlatform(type, rec, endProperty, &date_from_platform);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
   out[endProperty] = DateToJson(&date_from_platform);
@@ -1779,7 +1668,6 @@ PlatformResult CalendarItem::ToJson(int type, calendar_record_h rec,
   long long int lli;
   status = GetLli(type, rec, "lastModificationDate", &lli);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
   out["lastModificationDate"] = picojson::value(static_cast<double>(lli));
@@ -1787,14 +1675,12 @@ PlatformResult CalendarItem::ToJson(int type, calendar_record_h rec,
   double latitude;
   status = GetDouble(type, rec, "latitude", &latitude);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
   double longitude;
   status = GetDouble(type, rec, "longitude", &longitude);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
@@ -1805,7 +1691,6 @@ PlatformResult CalendarItem::ToJson(int type, calendar_record_h rec,
   std::string enum_str;
   status = GetEnum(type, rec, "visibility", kItemVisibility, &enum_str);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
   out["visibility"] = picojson::value(enum_str);
@@ -1813,7 +1698,6 @@ PlatformResult CalendarItem::ToJson(int type, calendar_record_h rec,
   picojson::array attendees = picojson::array();
   status = AttendeesToJson(type, rec, &attendees);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
   out["attendees"] = picojson::value(attendees);
@@ -1821,7 +1705,6 @@ PlatformResult CalendarItem::ToJson(int type, calendar_record_h rec,
   picojson::array categories = picojson::array();
   status = CategoriesToJson(type, rec, &categories);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
   out["categories"] = picojson::value(categories);
@@ -1829,7 +1712,6 @@ PlatformResult CalendarItem::ToJson(int type, calendar_record_h rec,
   picojson::array alarms = picojson::array();
   status = AlarmsToJson(type, rec, &alarms);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
   out["alarms"] = picojson::value(alarms);
@@ -1837,21 +1719,18 @@ PlatformResult CalendarItem::ToJson(int type, calendar_record_h rec,
   if (type == CALENDAR_BOOK_TYPE_EVENT) {
     status = GetEnum(type, rec, "status", kEventStatus, &enum_str);
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
     out["status"] = picojson::value(enum_str);
 
     status = GetEnum(type, rec, "priority", kEventPriority, &enum_str);
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
     out["priority"] = picojson::value(enum_str);
 
     status = GetEnum(type, rec, "availability", kEventAvailability, &enum_str);
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
     out["availability"] = picojson::value(enum_str);
@@ -1860,7 +1739,6 @@ PlatformResult CalendarItem::ToJson(int type, calendar_record_h rec,
     int occurrence_count;
     status = CalendarRecord::GetInt(rec, _calendar_event.count, &occurrence_count);
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
 
@@ -1870,7 +1748,6 @@ PlatformResult CalendarItem::ToJson(int type, calendar_record_h rec,
 
       status = RecurrenceRuleToJson(rec, &rec_rule);
       if (status.IsError()) {
-        LoggerE("Error: %s", status.message().c_str());
         return status;
       }
       out["recurrenceRule"] = picojson::value(rec_rule);
@@ -1878,14 +1755,12 @@ PlatformResult CalendarItem::ToJson(int type, calendar_record_h rec,
   } else {
     status = GetEnum(type, rec, "status", kTaskStatus, &enum_str);
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
     out["status"] = picojson::value(enum_str);
 
     status = GetEnum(type, rec, "priority", kTaskPriority, &enum_str);
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
     out["priority"] =  picojson::value(enum_str);
@@ -1893,14 +1768,12 @@ PlatformResult CalendarItem::ToJson(int type, calendar_record_h rec,
     long long int lli;
     status = GetLli(rec, _calendar_todo.completed_time, &lli);
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
     out["completedDate"] = picojson::value(static_cast<double>(lli));
 
     status = GetInt(type, rec, "progress", &value_int);
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
     out["progress"] = picojson::value(static_cast<double>(value_int));

diff --git a/src/calendar/calendar_manager.cc b/src/calendar/calendar_manager.cc
index ba34b8ab07bc10688ff0cd748639e7a7cc727362..3a7ed27d7ba781b32d94759808f71d979326cb79 100755 (executable)
--- a/src/calendar/calendar_manager.cc
+++ b/src/calendar/calendar_manager.cc
@@ -69,8 +69,7 @@ PlatformResult CalendarManager::GetCalendars(const JsonObject& args,
                                              JsonArray& array) {
   LoggerD("Enter");
   if (!is_connected_) {
-    LoggerE("DB Connection failed.");
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "DB Connection failed.");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "DB Connection failed.");
   }
 
   const std::string& type = FromJson<std::string>(args, "type");
@@ -83,7 +82,6 @@ PlatformResult CalendarManager::GetCalendars(const JsonObject& args,
   PlatformResult status =
       CalendarRecord::CheckReturn(ret, "Failed to get list");
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
@@ -91,7 +89,6 @@ PlatformResult CalendarManager::GetCalendars(const JsonObject& args,
   ret = calendar_list_get_count(list, &count);
   status = CalendarRecord::CheckReturn(ret, "Failed to get list size");
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
@@ -101,7 +98,6 @@ PlatformResult CalendarManager::GetCalendars(const JsonObject& args,
   status = CalendarRecord::CheckReturn(
       ret, "Failed to move list to the first position");
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
@@ -113,14 +109,12 @@ PlatformResult CalendarManager::GetCalendars(const JsonObject& args,
     ret = calendar_list_get_current_record_p(list, &calendar);
     status = CalendarRecord::CheckReturn(ret, "Failed to get current record");
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
 
     PlatformResult status = CalendarRecord::GetInt(
         calendar, _calendar_book.store_type, &store_type);
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
 
@@ -136,7 +130,6 @@ PlatformResult CalendarManager::GetCalendars(const JsonObject& args,
     status = CalendarRecord::CalendarToJson(calendar,
                                             &array.back().get<JsonObject>());
     if (status.IsError()) {
-      LoggerE("Error: %s", status.message().c_str());
       return status;
     }
 
@@ -150,7 +143,7 @@ PlatformResult CalendarManager::GetCalendar(const JsonObject& args,
                                             JsonObject& out) {
   LoggerD("Enter");
   if (!is_connected_) {
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "DB Connection failed.");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "DB Connection failed.");
   }
 
   int id = common::stol(FromJson<std::string>(args, "id"));
@@ -159,7 +152,6 @@ PlatformResult CalendarManager::GetCalendar(const JsonObject& args,
   PlatformResult status =
       CalendarRecord::GetById(id, _calendar_book._uri, &handle);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
@@ -171,18 +163,17 @@ PlatformResult CalendarManager::GetCalendar(const JsonObject& args,
   status = CalendarRecord::GetInt(record_ptr.get(), _calendar_book.store_type,
                                   &calendar_type);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
   if (type != calendar_type) {
-    LoggerD("Calendar type doesn't match requested type");
-    return PlatformResult(ErrorCode::NOT_FOUND_ERR, "Calendar not found");
+    return LogAndCreateResult(
+              ErrorCode::NOT_FOUND_ERR, "Calendar not found",
+              ("Calendar type doesn't match requested type %s", type));
   }
 
   status = CalendarRecord::CalendarToJson(record_ptr.get(), &out);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
@@ -193,7 +184,7 @@ PlatformResult CalendarManager::AddCalendar(const JsonObject& args,
                                             JsonObject& out) {
   LoggerD("Enter");
   if (!is_connected_) {
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "DB Connection failed.");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "DB Connection failed.");
   }
 
   const JsonObject& calendar = FromJson<JsonObject>(args, "calendar");
@@ -201,7 +192,6 @@ PlatformResult CalendarManager::AddCalendar(const JsonObject& args,
   calendar_record_h handle = nullptr;
   PlatformResult status = CalendarRecord::CreateCalendar(&handle);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
@@ -210,7 +200,6 @@ PlatformResult CalendarManager::AddCalendar(const JsonObject& args,
 
   status = CalendarRecord::CalendarFromJson(record_ptr.get(), calendar);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
@@ -219,7 +208,6 @@ PlatformResult CalendarManager::AddCalendar(const JsonObject& args,
   status = CalendarRecord::CheckReturn(
       ret, "Failed to insert calendar record into db");
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
 }
 
@@ -230,30 +218,26 @@ PlatformResult CalendarManager::RemoveCalendar(const JsonObject& args,
                                                JsonObject& out) {
   LoggerD("Enter");
   if (!is_connected_) {
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "DB Connection failed.");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "DB Connection failed.");
   }
 
   int id = common::stol(FromJson<std::string>(args, "id"));
 
   if (id == kUnifiedCalendardId) {
-    LoggerE("Unified calendar can not be deleted");
-    return PlatformResult(ErrorCode::INVALID_VALUES_ERR,
-                          "Unified calendar can not be deleted");
+    return LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR,
+                              "Unified calendar can not be deleted");
   } else if (id == DEFAULT_EVENT_CALENDAR_BOOK_ID) {
-    LoggerE("Default event calendar can not be deleted");
-    return PlatformResult(ErrorCode::INVALID_VALUES_ERR,
-                          "Default event calendar can not be deleted");
+    return LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR,
+                              "Default event calendar can not be deleted");
   } else if (id == DEFAULT_TODO_CALENDAR_BOOK_ID) {
-    LoggerE("Default todo calendar can not be deleted");
-    return PlatformResult(ErrorCode::INVALID_VALUES_ERR,
-                          "Default todo calendar can not be deleted");
+    return LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR,
+                              "Default todo calendar can not be deleted");
   }
 
   int ret = calendar_db_delete_record(_calendar_book._uri, id);
   PlatformResult status =
       CalendarRecord::CheckReturn(ret, "Failed to delete record from db");
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 

diff --git a/src/calendar/calendar_record.cc b/src/calendar/calendar_record.cc
index 81c17953e516642a62f26e008809b4bd23fd317c..60a76d28c49197337ed6892045f567450becb5e8 100755 (executable)
--- a/src/calendar/calendar_record.cc
+++ b/src/calendar/calendar_record.cc
@@ -35,8 +35,9 @@ PlatformResult CalendarRecord::CheckReturn(int ret,
                                            const std::string& error_name) {
   LoggerD("Enter");
   if (CALENDAR_ERROR_NONE != ret) {
-    LoggerE("%s : %d", error_name.c_str(), ret);
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, error_name);
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, error_name,
+              ("%s : %d (%s)", error_name.c_str(), ret, get_error_message(ret)));
   }
 
   return PlatformResult(ErrorCode::NO_ERROR);
@@ -77,10 +78,10 @@ PlatformResult CalendarRecord::GetString(calendar_record_h rec,
   char* value = NULL;
   int ret = calendar_record_get_str(rec, property, &value);
   if (CALENDAR_ERROR_NONE != ret) {
-    LoggerE("Can't get string value form record: %d", ret);
+    LoggerE("Can't get string value form record: %d (%s)",
+            ret, get_error_message(ret));
     if (throw_on_error) {
-      return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                            "Get string from record failed.");
+      return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Get string from record failed.");
     }
   }
 
@@ -102,10 +103,11 @@ PlatformResult CalendarRecord::SetString(calendar_record_h record,
                                     value.empty() ? NULL : value.c_str());
 
   if (CALENDAR_ERROR_NONE != ret) {
-    LoggerE("Can't set string value to record: %d", ret);
+    LoggerE("Can't set string value to record: %d (%s)",
+            ret, get_error_message(ret));
     if (throw_on_error) {
-      return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                            "Set string to record failed.");
+      return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                                "Set string to record failed.");
     }
   }
 
@@ -118,10 +120,11 @@ PlatformResult CalendarRecord::GetInt(calendar_record_h rec,
   LoggerD("Enter");
   int ret = calendar_record_get_int(rec, property, value);
   if (CALENDAR_ERROR_NONE != ret) {
-    LoggerE("Can't get int value form record: %d", ret);
+    LoggerE("Can't get int value form record: %d (%s)",
+            ret, get_error_message(ret));
     if (throw_on_error) {
-      return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                            "Get int from record failed.");
+      return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                                "Get int from record failed.");
     }
   }
 
@@ -135,10 +138,11 @@ PlatformResult CalendarRecord::SetInt(calendar_record_h record,
   int ret = calendar_record_set_int(record, property, value);
 
   if (CALENDAR_ERROR_NONE != ret) {
-    LoggerE("Can't set int value to record: %d", ret);
+    LoggerE("Can't set int value to record: %d (%s)",
+            ret, get_error_message(ret));
     if (throw_on_error) {
-      return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                            "Set int to record failed.");
+      return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                                "Set int to record failed.");
     }
   }
 
@@ -202,8 +206,9 @@ PlatformResult CalendarRecord::TypeToUri(const std::string& type,
   } else if (kCalendarTypeTask == type) {
     *uri = _calendar_todo._uri;
   } else {
-    LoggerE("Undefined record type: %s", type.c_str());
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Undefined record type");
+    return LogAndCreateResult(
+                ErrorCode::UNKNOWN_ERR, "Undefined record type",
+                ("Undefined record type: %s", type.c_str()));
   }
 
   return PlatformResult(ErrorCode::NO_ERROR);
@@ -216,8 +221,9 @@ PlatformResult CalendarRecord::TypeToUri(int type, std::string* uri) {
   } else if (CALENDAR_BOOK_TYPE_TODO == type) {
     *uri = _calendar_todo._uri;
   } else {
-    LoggerE("Undefined record type: %d", type);
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Undefined record type");
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, "Undefined record type",
+              ("Undefined record type: %d", type));
   }
 
   return PlatformResult(ErrorCode::NO_ERROR);
@@ -228,9 +234,10 @@ PlatformResult CalendarRecord::Create(const char* view_uri,
   LoggerD("Enter");
   int ret = calendar_record_create(view_uri, handle);
   if (CALENDAR_ERROR_NONE != ret || nullptr == handle) {
-    LoggerE("Fail to create calendar record, error code: %d", ret);
-    return PlatformResult(ErrorCode::NOT_FOUND_ERR,
-                          "Fail to create calendar record");
+    return LogAndCreateResult(
+              ErrorCode::NOT_FOUND_ERR, "Fail to create calendar record",
+              ("Fail to create calendar record, error code: %d (%s)",
+                  ret, get_error_message(ret)));
   }
 
   return PlatformResult(ErrorCode::NO_ERROR);
@@ -246,10 +253,10 @@ PlatformResult CalendarRecord::GetById(int id, const char* view_uri,
   LoggerD("Enter");
   int ret = calendar_db_get_record(view_uri, id, handle);
   if (CALENDAR_ERROR_NONE != ret || nullptr == handle) {
-    LoggerE("Fail to get calendar record %d for view %s, error code: %d", id,
-            view_uri, ret);
-    return PlatformResult(ErrorCode::NOT_FOUND_ERR,
-                          "Fail to get record with given id");
+    return LogAndCreateResult(
+              ErrorCode::NOT_FOUND_ERR, "Fail to get record with given id",
+              ("Fail to get calendar record %d for view %s, error code: %d (%s)",
+                id, view_uri, ret, get_error_message(ret)));
   }
 
   return PlatformResult(ErrorCode::NO_ERROR);
@@ -260,8 +267,10 @@ PlatformResult CalendarRecord::Insert(calendar_record_h rec, int* record_id) {
   int ret = calendar_db_insert_record(rec, record_id);
 
   if (CALENDAR_ERROR_NONE != ret) {
-    LoggerE("Cannot insert record, error code: %d", ret);
-    return PlatformResult(ErrorCode::NOT_FOUND_ERR, "Cannot insert record");
+    return LogAndCreateResult(
+              ErrorCode::NOT_FOUND_ERR, "Cannot insert record",
+              ("Cannot insert record, error code: %d (%s)",
+                ret, get_error_message(ret)));
   }
 
   return PlatformResult(ErrorCode::NO_ERROR);
@@ -276,8 +285,10 @@ PlatformResult CalendarRecord::AddChildRecord(calendar_record_h rec,
     if (child) {
       calendar_record_destroy(child, true);
     }
-    LoggerE("Cannot add child record, error code: %d", ret);
-    return PlatformResult(ErrorCode::NOT_FOUND_ERR, "Cannot add child record");
+    return LogAndCreateResult(
+              ErrorCode::NOT_FOUND_ERR, "Cannot add child record",
+              ("Cannot add child record, error code: %d (%s)",
+                  ret, get_error_message(ret)));
   }
 
   return PlatformResult(ErrorCode::NO_ERROR);
@@ -320,10 +331,10 @@ PlatformResult CalendarRecord::GetChildRecordCount(calendar_record_h rec,
   LoggerD("Enter");
   int ret = calendar_record_get_child_record_count(rec, property, value);
   if (CALENDAR_ERROR_NONE != ret) {
-    LoggerE("Can't get child record count: %d", ret);
+    LoggerE("Can't get child record count: %d (%s)", ret, get_error_message(ret));
     if (throw_on_error) {
-      return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                            "Get child record count failed.");
+      return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                                "Get child record count failed.");
     }
   }
 
@@ -337,9 +348,9 @@ PlatformResult CalendarRecord::GetChildRecordAt(calendar_record_h rec,
   LoggerD("Enter");
   int ret = calendar_record_get_child_record_at_p(rec, property, index, result);
   if (CALENDAR_ERROR_NONE != ret) {
-    LoggerE("Can't get child record at: %d", ret);
-    return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                          "Get child record at failed.");
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, "Get child record at failed.",
+              ("Can't get child record at: %d (%s)", ret, get_error_message(ret)));
   }
 
   return PlatformResult(ErrorCode::NO_ERROR);
@@ -351,8 +362,7 @@ PlatformResult CalendarRecord::CalendarToJson(calendar_record_h rec,
   picojson::object& out = *out_ptr;
 
   if (NULL == rec) {
-    LoggerE("Calendar record is null");
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Calendar record is null");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Calendar record is null");
   }
 
   int id = 0;
@@ -363,7 +373,6 @@ PlatformResult CalendarRecord::CalendarToJson(calendar_record_h rec,
   std::string name;
   status = GetString(rec, _calendar_book.name, &name);
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
@@ -384,9 +393,8 @@ PlatformResult CalendarRecord::CalendarFromJson(calendar_record_h rec,
                                                 const picojson::object& in) {
   LoggerD("Enter");
   if (in.empty()) {
-    LoggerE("Empty Calendar object.");
-    return PlatformResult(ErrorCode::INVALID_VALUES_ERR,
-                          "Empty Calendar object.");
+    return LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR,
+                              "Empty Calendar object.");
   }
 
   const std::string& name = FromJson<std::string>(in, "name");
@@ -403,21 +411,18 @@ PlatformResult CalendarRecord::CalendarFromJson(calendar_record_h rec,
   int ret = calendar_record_set_str(rec, _calendar_book.name, name.c_str());
   PlatformResult status = CheckReturn(ret, "Failed to set name");
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
   ret = calendar_record_set_int(rec, _calendar_book.account_id, account_id);
   status = CheckReturn(ret, "Failed to set account_id");
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }
 
   ret = calendar_record_set_int(rec, _calendar_book.store_type, store_type);
   status = CheckReturn(ret, "Failed to set store_type");
   if (status.IsError()) {
-    LoggerE("Error: %s", status.message().c_str());
     return status;
   }