[Messaging] Refactor MessageConversation related code

Refactoring was requested to get rid of duplicated and unnecessary
code.

[Verification] TCT pass rate: 100%

Change-Id: Iee2eacf50ca89ea60e89b283d3aac24111cfd5e5
Signed-off-by: Pawel Wasowski <p.wasowski2@partner.samsung.com>

diff --git a/src/messaging/message.cc b/src/messaging/message.cc
index 5fdbbc6..15935d0 100644 (file)
--- a/src/messaging/message.cc
+++ b/src/messaging/message.cc
@@ -1517,6 +1517,11 @@ std::vector<std::string> Message::split(const std::string& input, char delimiter
 
 std::vector<std::string> Message::getEmailRecipientsFromStruct(const char* recipients) {
   ScopeLogger();
+
+  if (!recipients) {
+    return {};
+  }
+
   std::vector<std::string> tmp = Message::split(recipients, ';');
   for (std::vector<std::string>::iterator it = tmp.begin(); it != tmp.end(); ++it) {
     *it = MessagingUtil::ltrim(*it);

diff --git a/src/messaging/message_conversation.cc b/src/messaging/message_conversation.cc
index d320a3a..4644b29 100644 (file)
--- a/src/messaging/message_conversation.cc
+++ b/src/messaging/message_conversation.cc
@@ -43,77 +43,19 @@ MessageConversation::MessageConversation()
   ScopeLogger("Message Conversation constructor.");
 }
 
-namespace {
-
-std::string SanitizeUtf8String(const std::string& input) {
-  ScopeLogger();
-
-  std::string result = input;
-  const gchar* end = nullptr;
-
-  while (FALSE == g_utf8_validate(result.c_str(), -1, &end)) {
-    result = result.substr(0, end - result.c_str());
-  }
-
-  return result;
-}
-
-std::vector<std::string> SanitizeUtf8StringVector(const std::vector<std::string>& string_vector) {
-  ScopeLogger();
-
-  std::vector<std::string> sanitized_strings;
-  for (const auto& string : string_vector) {
-    sanitized_strings.push_back(SanitizeUtf8String(string));
-  }
-
-  return sanitized_strings;
-}
-
-std::vector<std::string> GetSanitizedEmailRecipientsFromCString(const char* recipients_c_string) {
-  ScopeLogger();
-
-  if (!recipients_c_string) {
-    return {};
-  }
-
-  return SanitizeUtf8StringVector(Message::getEmailRecipientsFromStruct(recipients_c_string));
-}
-
-std::string GetSanitizedStringFromCString(const char* c_string) {
-  ScopeLogger();
-
-  if (!c_string) {
-    return "";
-  }
-
-  return SanitizeUtf8String(c_string);
-}
-
-std::string GetSingleSanitizedEmailAddressFromCString(const char* address_c_string) {
-  ScopeLogger();
-
-  if (!address_c_string) {
-    return "";
-  }
-
-  return SanitizeUtf8String(MessagingUtil::extractSingleEmailAddress(address_c_string));
-}
-
-}  // namespace
-
 MessageConversation::MessageConversation(const email_mail_data_t& mail_data)
     : m_conversation_id(mail_data.thread_id),
       m_conversation_type(MessageType::EMAIL),
       m_timestamp(mail_data.date_time),
       m_count(mail_data.thread_item_count),
       m_unread_messages(0),
-      m_preview(GetSanitizedStringFromCString(mail_data.preview_text)),
-      m_conversation_subject(GetSanitizedStringFromCString(mail_data.subject)),
+      m_preview(MessagingUtil::SanitizeUtf8String(mail_data.preview_text)),
+      m_conversation_subject(MessagingUtil::SanitizeUtf8String(mail_data.subject)),
       m_is_read(mail_data.flags_seen_field),
-      m_from(GetSingleSanitizedEmailAddressFromCString(mail_data.full_address_from)),
-      m_to(GetSanitizedEmailRecipientsFromCString(mail_data.full_address_to)),
-      m_cc(GetSanitizedEmailRecipientsFromCString(mail_data.full_address_cc)),
-      m_bcc(GetSanitizedEmailRecipientsFromCString(mail_data.full_address_bcc)),
+      m_from(MessagingUtil::extractSingleEmailAddress(mail_data.full_address_from)),
+      m_to(Message::getEmailRecipientsFromStruct(mail_data.full_address_to)),
+      m_cc(Message::getEmailRecipientsFromStruct(mail_data.full_address_cc)),
+      m_bcc(Message::getEmailRecipientsFromStruct(mail_data.full_address_bcc)),
       m_last_message_id(mail_data.mail_id) {
   ScopeLogger();
   auto result = initializeUnreadMessagesCount();
@@ -406,20 +348,12 @@ PlatformResult MessageConversation::convertEmailConversationToObject(
 
     if (resultMail->full_address_from[0] != '\0') {
       conversation->m_from =
-          GetSingleSanitizedEmailAddressFromCString(resultMail->full_address_from);
+          MessagingUtil::extractSingleEmailAddress(resultMail->full_address_from);
     }
 
-    if (mailData->full_address_to != NULL) {
-      conversation->m_to = GetSanitizedEmailRecipientsFromCString(mailData->full_address_to);
-    }
-
-    if (mailData->full_address_cc != NULL) {
-      conversation->m_cc = GetSanitizedEmailRecipientsFromCString(mailData->full_address_cc);
-    }
-
-    if (mailData->full_address_bcc != NULL) {
-      conversation->m_bcc = GetSanitizedEmailRecipientsFromCString(mailData->full_address_bcc);
-    }
+    conversation->m_to = Message::getEmailRecipientsFromStruct(mailData->full_address_to);
+    conversation->m_cc = Message::getEmailRecipientsFromStruct(mailData->full_address_cc);
+    conversation->m_bcc = Message::getEmailRecipientsFromStruct(mailData->full_address_bcc);
 
     conversation->m_last_message_id = resultMail->mail_id;
 
@@ -457,11 +391,11 @@ void MessageConversation::setUnreadMessages(int unread_messages) {
 }
 
 void MessageConversation::setPreview(std::string preview) {
-  m_preview = SanitizeUtf8String(preview);
+  m_preview = MessagingUtil::SanitizeUtf8String(preview);
 }
 
 void MessageConversation::setSubject(std::string conversation_subject) {
-  m_conversation_subject = SanitizeUtf8String(conversation_subject);
+  m_conversation_subject = MessagingUtil::SanitizeUtf8String(conversation_subject);
 }
 
 void MessageConversation::setIsRead(bool is_read) {
@@ -589,6 +523,15 @@ common::PlatformResult MessageConversation::initializeUnreadMessagesCount() {
   return PlatformResult{ErrorCode::NO_ERROR};
 }
 
+namespace {
+
+bool defaultConversationComparator(const ConversationPtr&, const ConversationPtr&) {
+  return false;
+}
+
+}  // namespace
+
+// clang-format off
 const MessageConversation::MessageConversationComparatorMap
   MessageConversation::m_message_conversation_comparators = {
     {
@@ -653,24 +596,19 @@ const MessageConversation::MessageConversationComparatorMap
     },
     {
       /* Every record has EMAIL type - no element is "greater than" any other. */
-      "type", [] (const ConversationPtr& a, const ConversationPtr& b) {
-        return false;
-      }
+      "type", defaultConversationComparator
     }
 };
+// clang-format on
 
 MessageConversation::MessageConversationComparator MessageConversation::getComparator(
-  const std::string& attribute) {
+    const std::string& attribute) {
   auto comparator_it = m_message_conversation_comparators.find(attribute);
   if (std::end(m_message_conversation_comparators) != comparator_it) {
     return comparator_it->second;
   }
 
-  auto default_comparator = [](const ConversationPtr& a, const ConversationPtr& b) {
-    return false;
-  };
-
-  return default_comparator;
+  return defaultConversationComparator;
 }
 
 }  // messaging

diff --git a/src/messaging/messaging_database_manager.cc b/src/messaging/messaging_database_manager.cc
index 03d190d..6d87bd2 100644 (file)
--- a/src/messaging/messaging_database_manager.cc
+++ b/src/messaging/messaging_database_manager.cc
@@ -933,6 +933,7 @@ PlatformResult MessagingDatabaseManager::retrieveEmailThreadsFromDatabase(
     return result;
   }
 
+  // clang-format off
   const std::string isLastMessageInThread =
     "(MAIL_ID IN "
     "(SELECT MAIL_ID "
@@ -940,6 +941,7 @@ PlatformResult MessagingDatabaseManager::retrieveEmailThreadsFromDatabase(
      "(SELECT MAIL_ID, MAX(DATE_TIME) "
       "FROM MAIL_TBL "
       "GROUP BY THREAD_ID)))";
+  // clang-format on
 
   const std::string isServiceAccountId =
       "account_id = " + std::to_string(findEmailConversationsData.getAccountId());

diff --git a/src/messaging/messaging_util.cc b/src/messaging/messaging_util.cc
index d919911..875844b 100644 (file)
--- a/src/messaging/messaging_util.cc
+++ b/src/messaging/messaging_util.cc
@@ -239,13 +239,23 @@ std::string MessagingUtil::extractSingleEmailAddress(const std::string& address)
   // then extract email address from the inside
   if (found_begin != std::string::npos && found_end != std::string::npos &&
       found_begin < found_end) {
-    return address.substr(found_begin + 1, found_end - found_begin - 1);
+    return SanitizeUtf8String(address.substr(found_begin + 1, found_end - found_begin - 1));
   } else {
     // return unmodified source string
-    return address;
+    return SanitizeUtf8String(address);
   }
 }
 
+std::string MessagingUtil::extractSingleEmailAddress(const char* address) {
+  ScopeLogger();
+
+  if (!address) {
+    return {};
+  }
+
+  return extractSingleEmailAddress(std::string{address});
+}
+
 std::vector<std::string> MessagingUtil::extractEmailAddresses(
     const std::vector<std::string>& addresses) {
   ScopeLogger();
@@ -1138,6 +1148,29 @@ PlatformResult MessagingUtil::jsonToMessageConversation(
   return PlatformResult(ErrorCode::NO_ERROR);
 }
 
+std::string MessagingUtil::SanitizeUtf8String(const std::string& input) {
+  ScopeLogger();
+
+  std::string result = input;
+  const gchar* end = nullptr;
+
+  while (FALSE == g_utf8_validate(result.c_str(), -1, &end)) {
+    result = result.substr(0, end - result.c_str());
+  }
+
+  return result;
+}
+
+std::string MessagingUtil::SanitizeUtf8String(const char* input) {
+  ScopeLogger();
+
+  if (!input) {
+    return {};
+  }
+
+  return SanitizeUtf8String(std::string{input});
+}
+
 PostQueue::PostQueue(MessagingInstance& instance) : instance_(instance) {
   ScopeLogger("this: [%p]", this);
 }

diff --git a/src/messaging/messaging_util.h b/src/messaging/messaging_util.h
index 7ccd031..6af1d6c 100644 (file)
--- a/src/messaging/messaging_util.h
+++ b/src/messaging/messaging_util.h
@@ -120,6 +120,7 @@ class MessagingUtil {
   static std::string messageTypeToString(MessageType type);
   static std::string ltrim(const std::string& input);
   static std::string extractSingleEmailAddress(const std::string& address);
+  static std::string extractSingleEmailAddress(const char* address);
   static std::vector<std::string> extractEmailAddresses(const std::vector<std::string>& addresses);
 
   static picojson::value messageBodyToJson(std::shared_ptr<MessageBody> body);
@@ -164,6 +165,8 @@ class MessagingUtil {
   static common::PlatformResult loadFileContentToString(const std::string& file_path,
                                                         std::string* result);
   static std::string messageStatusToString(MessageStatus status);
+  static std::string SanitizeUtf8String(const std::string& input);
+  static std::string SanitizeUtf8String(const char* input);
 
  private:
   static common::PlatformResult jsonFilterToAbstractFilter(const picojson::object& json,