1 files changed, 130 insertions, 84 deletions

diff --git a/src/components/application_manager/src/commands/mobile/send_location_request.cc b/src/components/application_manager/src/commands/mobile/send_location_request.cc
index b1c96ebb98..975f7e43c3 100644
--- a/src/components/application_manager/src/commands/mobile/send_location_request.cc
+++ b/src/components/application_manager/src/commands/mobile/send_location_request.cc
@@ -30,39 +30,51 @@
  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  POSSIBILITY OF SUCH DAMAGE.
  */
+#include <algorithm>
+
 #include "application_manager/commands/mobile/send_location_request.h"
-#include "application_manager/application_manager_impl.h"
+
 #include "application_manager/message_helper.h"
+#include "utils/helpers.h"
+#include "utils/custom_string.h"
 
 namespace application_manager {
 
 namespace commands {
 
-SendLocationRequest::SendLocationRequest(const MessageSharedPtr& message)
- : CommandRequestImpl(message) {
-}
+SendLocationRequest::SendLocationRequest(
+    const MessageSharedPtr& message, ApplicationManager& application_manager)
+    : CommandRequestImpl(message, application_manager) {}
 
-SendLocationRequest::~SendLocationRequest() {
-}
+SendLocationRequest::~SendLocationRequest() {}
 
 void SendLocationRequest::Run() {
   using namespace hmi_apis;
+  using smart_objects::SmartObject;
   LOG4CXX_AUTO_TRACE(logger_);
 
-  ApplicationSharedPtr app = application_manager::ApplicationManagerImpl::instance()
-      ->application(connection_key());
+  ApplicationSharedPtr app = application_manager_.application(connection_key());
 
   if (!app) {
-    LOG4CXX_ERROR_EXT(logger_,
-                      "An application with connection key " << connection_key()
-                      << " is not registered.");
+    LOG4CXX_ERROR(logger_,
+                  "An application with connection key "
+                      << connection_key() << " is not registered.");
     SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED);
     return;
   }
 
-  const smart_objects::SmartObject& msg_params = (*message_)[strings::msg_params];
-  std::list<Common_TextFieldName::eType> fields_to_check;
+  smart_objects::SmartObject& msg_params = (*message_)[strings::msg_params];
+  if (msg_params.keyExists(strings::delivery_mode)) {
+    const std::vector<std::string>& allowed_params =
+        parameters_permissions().allowed_params;
+    if (allowed_params.end() == std::find(allowed_params.begin(),
+                                          allowed_params.end(),
+                                          strings::delivery_mode)) {
+      msg_params.erase(strings::delivery_mode);
+    }
+  }
 
+  std::vector<Common_TextFieldName::eType> fields_to_check;
   if (msg_params.keyExists(strings::location_name)) {
     fields_to_check.push_back(Common_TextFieldName::locationName);
   }
@@ -87,11 +99,27 @@ void SendLocationRequest::Run() {
     return;
   }
 
-  if ((*message_)[strings::msg_params].keyExists(strings::location_image)) {
+  if (msg_params.keyExists(strings::address)) {
+    const utils::custom_string::CustomString& address =
+        msg_params[strings::address].asCustomString();
+    if (address.empty()) {
+      msg_params.erase(strings::address);
+    }
+  }
+
+  if (!CheckFieldsCompatibility()) {
+    LOG4CXX_ERROR(logger_, "CheckFieldsCompatibility failed");
+    SendResponse(false, mobile_apis::Result::INVALID_DATA);
+    return;
+  }
+
+  if (msg_params.keyExists(strings::location_image)) {
     mobile_apis::Result::eType verification_result =
         mobile_apis::Result::SUCCESS;
     verification_result = MessageHelper::VerifyImage(
-        (*message_)[strings::msg_params][strings::location_image], app);
+        (*message_)[strings::msg_params][strings::location_image],
+        app,
+        application_manager_);
     if (mobile_apis::Result::SUCCESS != verification_result) {
       LOG4CXX_ERROR(logger_, "VerifyImage INVALID_DATA!");
       SendResponse(false, verification_result);
@@ -99,61 +127,76 @@ void SendLocationRequest::Run() {
     }
   }
 
-  smart_objects::SmartObject request_msg_params = smart_objects::SmartObject(
-      smart_objects::SmartType_Map);
-  request_msg_params = (*message_)[strings::msg_params];
+  SmartObject request_msg_params = SmartObject(smart_objects::SmartType_Map);
+  request_msg_params = msg_params;
   request_msg_params[strings::app_id] = app->hmi_app_id();
-
-  SendHMIRequest(hmi_apis::FunctionID::Navigation_SendLocation,
-                 &request_msg_params, true);
+  SendHMIRequest(
+      hmi_apis::FunctionID::Navigation_SendLocation, &request_msg_params, true);
 }
 
 void SendLocationRequest::on_event(const event_engine::Event& event) {
-  LOG4CXX_INFO(logger_, "SendLocationRquest::on_event");
+  LOG4CXX_AUTO_TRACE(logger_);
+  namespace Result = mobile_apis::Result;
+  using namespace helpers;
   const smart_objects::SmartObject& message = event.smart_object();
-  switch (event.id()) {
-    case hmi_apis::FunctionID::Navigation_SendLocation: {
-      LOG4CXX_INFO(logger_, "Received Navigation_SendLocation event");
-      mobile_apis::Result::eType result_code = GetMobileResultCode(
-          static_cast<hmi_apis::Common_Result::eType>(
-              message[strings::params][hmi_response::code].asUInt()));
-      bool result =
-          mobile_apis::Result::SUCCESS == result_code ||
-          mobile_apis::Result::WARNINGS == result_code ||
-          mobile_apis::Result::UNSUPPORTED_RESOURCE == result_code ;
-      SendResponse(result, result_code, NULL, &(message[strings::msg_params]));
-      break;
-    }
-    default: {
-      LOG4CXX_ERROR(logger_,"Received unknown event" << event.id());
-      break;
-    }
+  if (hmi_apis::FunctionID::Navigation_SendLocation == event.id()) {
+    LOG4CXX_INFO(logger_, "Received Navigation_SendLocation event");
+    mobile_apis::Result::eType result_code =
+        GetMobileResultCode(static_cast<hmi_apis::Common_Result::eType>(
+            message[strings::params][hmi_response::code].asUInt()));
+    const bool result =
+        Compare<Result::eType, EQ, ONE>(result_code,
+                                        Result::SAVED,
+                                        Result::SUCCESS,
+                                        Result::WARNINGS,
+                                        Result::UNSUPPORTED_RESOURCE);
+    SendResponse(result, result_code, NULL, &(message[strings::params]));
+    return;
   }
+  LOG4CXX_ERROR(logger_, "Received unknown event" << event.id());
 }
 
-bool SendLocationRequest::IsWhiteSpaceExist() {
-  LOG4CXX_INFO(logger_, "SendLocationRquest::IsWhiteSpaceExist");
-  const char* str;
+bool SendLocationRequest::CheckFieldsCompatibility() {
   const smart_objects::SmartObject& msg_params =
       (*message_)[strings::msg_params];
-
-  if (msg_params.keyExists(strings::location_name)) {
-    str = msg_params[strings::location_name].asCharArray();
-    if (!CheckSyntax(str)) {
-      LOG4CXX_ERROR(logger_,
-                    "parameter locationName contains invalid character");
-      return true;
-    }
+  MessageHelper::PrintSmartObject(msg_params);
+  const bool longitude_degrees_exist =
+      msg_params.keyExists(strings::longitude_degrees);
+  const bool latitude_degrees_exist =
+      msg_params.keyExists(strings::latitude_degrees);
+  const bool address_exist = msg_params.keyExists(strings::address);
+
+  if (latitude_degrees_exist ^ longitude_degrees_exist) {
+    LOG4CXX_DEBUG(logger_,
+                  "latitude and longitude should be provided only in pair");
+    return false;
   }
 
-  if (msg_params.keyExists(strings::location_description)) {
-    str = msg_params[strings::location_description].asCharArray();
-    if (!CheckSyntax(str)) {
-      LOG4CXX_ERROR(logger_,
-                    "parameter locationDescription contains invalid character");
-      return true;
-    }
+  if (!address_exist && !longitude_degrees_exist && !latitude_degrees_exist) {
+    LOG4CXX_DEBUG(logger_,
+                  "address or latitude/longtitude should should be provided");
+    return false;
+  }
+  return true;
+}
+void insert_if_contains(
+    const smart_objects::SmartObject& msg_params,
+    const std::string& param_key,
+    std::vector<utils::custom_string::CustomString>& output_vector) {
+  if (msg_params.keyExists(param_key)) {
+    output_vector.push_back(msg_params[param_key].asCustomString());
   }
+}
+
+bool SendLocationRequest::IsWhiteSpaceExist() {
+  LOG4CXX_AUTO_TRACE(logger_);
+  std::vector<utils::custom_string::CustomString> fields_to_check;
+  const smart_objects::SmartObject& msg_params =
+      (*message_)[strings::msg_params];
+  insert_if_contains(msg_params, strings::location_name, fields_to_check);
+  insert_if_contains(
+      msg_params, strings::location_description, fields_to_check);
+  insert_if_contains(msg_params, strings::phone_number, fields_to_check);
 
   if (msg_params.keyExists(strings::address_lines)) {
     const smart_objects::SmartArray* al_array =
@@ -161,60 +204,63 @@ bool SendLocationRequest::IsWhiteSpaceExist() {
     smart_objects::SmartArray::const_iterator it_al = al_array->begin();
     smart_objects::SmartArray::const_iterator it_al_end = al_array->end();
     for (; it_al != it_al_end; ++it_al) {
-      str = (*it_al).asCharArray();
-      if(!CheckSyntax(str)) {
-        LOG4CXX_ERROR(logger_,
-                      "parameter address_lines contains invalid character");
-        return true;
-      }
+      const utils::custom_string::CustomString& val = (*it_al).asCustomString();
+      fields_to_check.push_back(val);
     }
   }
 
-  if (msg_params.keyExists(strings::phone_number)) {
-    str = msg_params[strings::phone_number].asCharArray();
-    if (!CheckSyntax(str)) {
-      LOG4CXX_ERROR(logger_,
-                    "parameter phoneNumber contains invalid character");
-      return true;
-    }
+  if (msg_params.keyExists(strings::address)) {
+    const smart_objects::SmartObject& address_so = msg_params[strings::address];
+    insert_if_contains(address_so, strings::country_name, fields_to_check);
+    insert_if_contains(address_so, strings::country_code, fields_to_check);
+    insert_if_contains(address_so, strings::postal_code, fields_to_check);
+    insert_if_contains(
+        address_so, strings::administrative_area, fields_to_check);
+    insert_if_contains(address_so, strings::locality, fields_to_check);
+    insert_if_contains(address_so, strings::sub_locality, fields_to_check);
+    insert_if_contains(address_so, strings::thoroughfare, fields_to_check);
+    insert_if_contains(address_so, strings::sub_thoroughfare, fields_to_check);
   }
 
-  if (msg_params.keyExists(strings::location_image)) {
-    str = msg_params[strings::location_image][strings::value].asCharArray();
-    if (!CheckSyntax(str)) {
+  std::vector<utils::custom_string::CustomString>::iterator it =
+      fields_to_check.begin();
+  for (; it != fields_to_check.end(); ++it) {
+    const std::string& str = it->AsMBString();
+    if (!CheckSyntax(str, false)) {
       LOG4CXX_ERROR(logger_,
-                          "parameter value in locationImage contains invalid character");
+                    "string '" << str << "'' contains invalid characters");
       return true;
     }
   }
-
   return false;
 }
 
-bool SendLocationRequest::CheckHMICapabilities(std::list<hmi_apis::Common_TextFieldName::eType>& fields_names) {
+bool SendLocationRequest::CheckHMICapabilities(
+    std::vector<hmi_apis::Common_TextFieldName::eType>& fields_names) {
   using namespace smart_objects;
   using namespace hmi_apis;
-
   if (fields_names.empty()) {
     return true;
   }
 
-  ApplicationManagerImpl* instance = ApplicationManagerImpl::instance();
-  const HMICapabilities& hmi_capabilities = instance->hmi_capabilities();
+  const HMICapabilities& hmi_capabilities =
+      application_manager_.hmi_capabilities();
   if (!hmi_capabilities.is_ui_cooperating()) {
-    LOG4CXX_ERROR_EXT(logger_, "UI is not supported.");
+    LOG4CXX_ERROR(logger_, "UI is not supported.");
     return false;
   }
 
   if (hmi_capabilities.display_capabilities()) {
     const SmartObject disp_cap = (*hmi_capabilities.display_capabilities());
-    const SmartObject& text_fields = disp_cap.getElement(hmi_response::text_fields);
+    const SmartObject& text_fields =
+        disp_cap.getElement(hmi_response::text_fields);
     const size_t len = text_fields.length();
     for (size_t i = 0; i < len; ++i) {
       const SmartObject& text_field = text_fields[i];
       const Common_TextFieldName::eType filed_name =
-          static_cast<Common_TextFieldName::eType>(text_field.getElement(strings::name).asInt());
-      const std::list<Common_TextFieldName::eType>::iterator it =
+          static_cast<Common_TextFieldName::eType>(
+              text_field.getElement(strings::name).asInt());
+      const std::vector<Common_TextFieldName::eType>::iterator it =
           std::find(fields_names.begin(), fields_names.end(), filed_name);
       if (it != fields_names.end()) {
         fields_names.erase(it);
@@ -223,7 +269,7 @@ bool SendLocationRequest::CheckHMICapabilities(std::list<hmi_apis::Common_TextFi
   }
 
   if (!fields_names.empty()) {
-    LOG4CXX_ERROR_EXT(logger_, "Some fields are not supported by capabilities");
+    LOG4CXX_ERROR(logger_, "Some fields are not supported by capabilities");
     return false;
   }
   return true;