Add processing new light capabilities to set_interior_vehicle_datafeature/rc_lights_more_names_and_status_values

3 files changed, 313 insertions, 120 deletions

diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/mobile/set_interior_vehicle_data_request.h b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/mobile/set_interior_vehicle_data_request.h
index d5de4981c6..128c668ee9 100644
--- a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/mobile/set_interior_vehicle_data_request.h
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/mobile/set_interior_vehicle_data_request.h
@@ -39,6 +39,11 @@ namespace rc_rpc_plugin {
 namespace app_mngr = application_manager;
 
 namespace commands {
+
+enum capabilitiesStatus { success, missedLightName, missedParam, readOnly };
+
+typedef std::pair<std::string, capabilitiesStatus> ModuleCapability;
+
 class SetInteriorVehicleDataRequest : public RCCommandRequest {
  public:
   SetInteriorVehicleDataRequest(
@@ -81,10 +86,12 @@ class SetInteriorVehicleDataRequest : public RCCommandRequest {
 
   /**
    * @brief Method that check if READ_ONLY parameters present
-   * @param request_params params from received message
+   * @param request_params params from received message,
+   * @param module_data_capabilities info for notification to mobile
    * @return true if present , false - otherwise
    */
-  bool AreReadOnlyParamsPresent(const smart_objects::SmartObject& module_data);
+  bool AreReadOnlyParamsPresent(const smart_objects::SmartObject& module_data,
+                                ModuleCapability& module_data_capabilities);
 
   /**
    * @brief Method that check if all request parameters are READ_ONLY
@@ -95,7 +102,7 @@ class SetInteriorVehicleDataRequest : public RCCommandRequest {
 
   /**
    * @brief Method that cuts-off READ_ONLY parameters
-   * @param request_params params to handle
+   * @param module_data params to handle
    */
   void CutOffReadOnlyParams(smart_objects::SmartObject& module_data);
 
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/rc_module_constants.h b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/rc_module_constants.h
index 195cec0ced..1951af1a24 100644
--- a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/rc_module_constants.h
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/rc_module_constants.h
@@ -179,9 +179,9 @@ const char kHeatedMirrorsEnable[] = "heatedMirrorsEnable";
 
 // LightControlData
 const char kLightState[] = "lightState";
-const char kStatus[] = "status";
-const char kDensity[] = "density";
-const char kColor[] = "color";
+const char kLightStatus[] = "status";
+const char kLightDensity[] = "density";
+const char kLightColor[] = "color";
 
 // AudioControlData
 const char kSource[] = "source";
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/mobile/set_interior_vehicle_data_request.cc b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/mobile/set_interior_vehicle_data_request.cc
index 17a492b5aa..e6f19a889c 100644
--- a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/mobile/set_interior_vehicle_data_request.cc
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/mobile/set_interior_vehicle_data_request.cc
@@ -59,10 +59,22 @@ std::vector<std::string> GetModuleReadOnlyParams(
     module_ro_params.push_back(kSignalChangeThreshold);
     module_ro_params.push_back(kState);
     module_ro_params.push_back(kSisData);
+  } else if (enums_value::kLight == module_type) {
+    module_ro_params.push_back(kLightStatus);
   }
+
   return module_ro_params;
 }
 
+const std::map<std::string, std::string> GetLightCapabilitiesMapping() {
+  std::map<std::string, std::string> mapping = {
+      {message_params::kId, strings::kName},
+      {message_params::kLightStatus, strings::kStatusAvailable},
+      {message_params::kLightDensity, strings::kDensityAvailable},
+      {message_params::kLightColor, strings::kRGBColorSpaceAvailable}};
+  return mapping;
+}
+
 const std::map<std::string, std::string> GetModuleDataToCapabilitiesMapping() {
   std::map<std::string, std::string> mapping;
   // climate
@@ -113,6 +125,7 @@ const std::map<std::string, std::string> GetModuleDataToCapabilitiesMapping() {
   mapping["massageMode"] = "massageModeAvailable";
   mapping["massageCushionFirmness"] = "massageCushionFirmnessAvailable";
   mapping["memory"] = "memoryAvailable";
+
   // audio
   mapping["source"] = "sourceAvailable";
   mapping["keepContext"] = "keepContextAvailable";
@@ -146,45 +159,98 @@ const std::string LightName(const smart_objects::SmartObject& light_name) {
   return ok ? name : "unknown";
 }
 
-bool CheckLightDataByCapabilities(
+/**
+ * @brief Check whether the parameter exist in capabilities
+ * @param smart object of capabilities
+ * @param mapping - map of module data and capabilities
+ * @param request_parameter - string
+ * @param switched_off_result - ref of mobile_apis::Result
+ * @return success if parameter exist in capabilities missedParam otherwise
+ */
+capabilitiesStatus GetItemCapability(
     const smart_objects::SmartObject& capabilities,
-    const smart_objects::SmartObject& light_data) {
+    const std::map<std::string, std::string>& mapping,
+    const std::string& request_parameter,
+    const mobile_apis::Result::eType& switched_off_result) {
+  const auto it = mapping.find(request_parameter);
+
+  if (it == mapping.end()) {
+    LOG4CXX_DEBUG(logger_,
+                  "Parameter " << request_parameter
+                               << " doesn't exist in capabilities.");
+    return capabilitiesStatus::missedParam;
+  }
+
+  const std::string& caps_key = it->second;
+
+  LOG4CXX_DEBUG(logger_,
+                "Checking request parameter "
+                    << request_parameter
+                    << " with capabilities. Appropriate key is " << caps_key);
+
+  if (!capabilities.keyExists(caps_key)) {
+    LOG4CXX_DEBUG(logger_,
+                  "Capability " << caps_key
+                                << " is missed in RemoteControl capabilities");
+    return capabilitiesStatus::missedParam;
+  }
+
+  if (!capabilities[caps_key].asBool()) {
+    LOG4CXX_DEBUG(logger_,
+                  "Capability "
+                      << caps_key
+                      << " is switched off in RemoteControl capabilities");
+    capabilitiesStatus status = capabilitiesStatus::missedParam;
+    if (mobile_apis::Result::READ_ONLY == switched_off_result) {
+      status = capabilitiesStatus::readOnly;
+    }
+    return status;
+  }
+
+  return capabilitiesStatus::success;
+}
+
+/**
+ * @brief Check whether the cpabilities for light allowed
+ * @param smart object of capabilities
+ * @param smart object of control_data
+ * @return pair of state and capability status - ModuleCapability
+ */
+ModuleCapability GetLightDataCapabilities(
+    const smart_objects::SmartObject& capabilities,
+    const smart_objects::SmartObject& control_data) {
   LOG4CXX_AUTO_TRACE(logger_);
-  std::map<std::string, std::string> lightCapsMapping = {
-      {message_params::kId, strings::kName},
-      {message_params::kDensity, strings::kDensityAvailable},
-      {message_params::kColor, strings::kRGBColorSpaceAvailable}};
-  auto it = light_data.map_begin();
-  for (; it != light_data.map_end(); ++it) {
-    if (message_params::kStatus == it->first ||
-        message_params::kId == it->first) {
+  std::map<std::string, std::string> mapping = GetLightCapabilitiesMapping();
+
+  for (auto it = control_data.map_begin(); it != control_data.map_end(); ++it) {
+    const std::string& request_parameter = it->first;
+
+    if (message_params::kId == request_parameter) {
       continue;
     }
-    const std::string& caps_key = lightCapsMapping[it->first];
-    LOG4CXX_DEBUG(logger_,
-                  "Checking request parameter "
-                      << it->first << " with capabilities. Appropriate key is "
-                      << caps_key);
-
-    if (!capabilities.keyExists(caps_key)) {
-      LOG4CXX_DEBUG(logger_,
-                    "Capability "
-                        << caps_key
-                        << " is missed in RemoteControl capabilities");
-      return false;
-    }
-    if (!capabilities[caps_key].asBool()) {
-      LOG4CXX_DEBUG(logger_,
-                    "Capability "
-                        << caps_key
-                        << " is switched off in RemoteControl capabilities");
-      return false;
+
+    const capabilitiesStatus status_item_capability =
+        GetItemCapability(capabilities,
+                          mapping,
+                          request_parameter,
+                          mobile_apis::Result::READ_ONLY);
+
+    if (capabilitiesStatus::success != status_item_capability) {
+      return std::make_pair(message_params::kLightState,
+                            status_item_capability);
     }
   }
-  return true;
+
+  return std::make_pair("", capabilitiesStatus::success);
 }
 
-bool CheckLightNameByCapabilities(
+/**
+ * @brief Check whether the light name exists in capabilities
+ * @param smart object of capabilities_status
+ * @param smart object of light_data
+ * @return pair of state and capability status - ModuleCapability
+ */
+ModuleCapability GetLightNameCapabilities(
     const smart_objects::SmartObject& capabilities_status,
     const smart_objects::SmartObject& light_data) {
   LOG4CXX_AUTO_TRACE(logger_);
@@ -193,90 +259,101 @@ bool CheckLightNameByCapabilities(
     const smart_objects::SmartObject& so = *it;
     const int64_t current_id = so[message_params::kName].asInt();
     if (current_id == light_data[message_params::kId].asInt()) {
-      return CheckLightDataByCapabilities(so, light_data);
+      return GetLightDataCapabilities(so, light_data);
     }
   }
   LOG4CXX_DEBUG(logger_, "There is no such light name in capabilities");
-  return false;
-}
-
-bool CheckRadioBandByCapabilities(
-    const smart_objects::SmartObject& capabilities_status,
-    const smart_objects::SmartObject& request_parameter) {
-  mobile_apis::RadioBand::eType radio_band =
-      static_cast<mobile_apis::RadioBand::eType>(request_parameter.asUInt());
-  if (mobile_apis::RadioBand::XM == radio_band) {
-    if (!capabilities_status.keyExists(strings::kSiriusxmRadioAvailable)) {
-      LOG4CXX_DEBUG(logger_,
-                    "Capability "
-                        << strings::kSiriusxmRadioAvailable
-                        << " is missed in RemoteControl capabilities");
-      return false;
-    }
-    if (!capabilities_status[strings::kSiriusxmRadioAvailable].asBool()) {
-      LOG4CXX_DEBUG(logger_,
-                    "Capability "
-                        << strings::kSiriusxmRadioAvailable
-                        << " is switched off in RemoteControl capabilities");
-      return false;
-    }
-  }
-  return true;
+  return std::make_pair(message_params::kLightState,
+                        capabilitiesStatus::missedLightName);
 }
 
-bool CheckControlDataByCapabilities(
-    const smart_objects::SmartObject& capabilities_status,
+/**
+ * @brief Check whether the exists light data related to correspondent
+ * capabilities
+ * @param smart object of capabilities
+ * @param smart object of control_data
+ * @return pair of state and capability status - ModuleCapability
+ */
+ModuleCapability GetControlDataCapabilities(
+    const smart_objects::SmartObject& capabilities,
     const smart_objects::SmartObject& control_data) {
   LOG4CXX_AUTO_TRACE(logger_);
   std::map<std::string, std::string> mapping =
       GetModuleDataToCapabilitiesMapping();
-  auto it = control_data.map_begin();
-  for (; it != control_data.map_end(); ++it) {
+
+  for (auto it = control_data.map_begin(); it != control_data.map_end(); ++it) {
     const std::string& request_parameter = it->first;
     if (message_params::kId == request_parameter) {
       continue;
     }
     if (message_params::kLightState == request_parameter) {
       auto light_data = control_data[request_parameter].asArray()->begin();
+      ModuleCapability light_capability =
+          std::make_pair("", capabilitiesStatus::success);
+
       for (; light_data != control_data[request_parameter].asArray()->end();
            ++light_data) {
-        if (!CheckLightNameByCapabilities(
-                capabilities_status[strings::kSupportedLights], *light_data)) {
-          return false;
+        light_capability = GetLightNameCapabilities(
+            capabilities[strings::kSupportedLights], *light_data);
+
+        if (capabilitiesStatus::success != light_capability.second) {
+          return light_capability;
         }
       }
-      return true;
-    }
-    const std::string& caps_key = mapping[request_parameter];
-    LOG4CXX_DEBUG(logger_,
-                  "Checking request parameter "
-                      << request_parameter
-                      << " with capabilities. Appropriate key is " << caps_key);
-
-    if (!capabilities_status.keyExists(caps_key)) {
-      LOG4CXX_DEBUG(logger_,
-                    "Capability "
-                        << caps_key
-                        << " is missed in RemoteControl capabilities");
-      return false;
+
+      return light_capability;
     }
-    if (!capabilities_status[caps_key].asBool()) {
-      LOG4CXX_DEBUG(logger_,
-                    "Capability "
-                        << caps_key
-                        << " is switched off in RemoteControl capabilities");
-      return false;
+
+    const capabilitiesStatus status_item_capability =
+        GetItemCapability(capabilities[0],
+                          mapping,
+                          request_parameter,
+                          mobile_apis::Result::UNSUPPORTED_RESOURCE);
+
+    if (capabilitiesStatus::success != status_item_capability) {
+      return std::make_pair("", status_item_capability);
     }
-    if (message_params::kBand == request_parameter &&
-        !CheckRadioBandByCapabilities(capabilities_status,
-                                      control_data[request_parameter])) {
-      return false;
+  }
+
+  return std::make_pair("", capabilitiesStatus::success);
+}
+
+/**
+ * @brief Check whether the exists hmi data related to correspondent
+ * capabilities
+ * @param smart object of capabilities
+ * @param smart object of control_data
+ * @return pair of state and capability status - ModuleCapability
+ */
+ModuleCapability GetHmiControlDataCapabilities(
+    const smart_objects::SmartObject& capabilities,
+    const smart_objects::SmartObject& control_data) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  std::map<std::string, std::string> mapping =
+      GetModuleDataToCapabilitiesMapping();
+
+  for (auto it = control_data.map_begin(); it != control_data.map_end(); ++it) {
+    const capabilitiesStatus status_item_capability =
+        GetItemCapability(capabilities,
+                          mapping,
+                          it->first,
+                          mobile_apis::Result::UNSUPPORTED_RESOURCE);
+
+    if (capabilitiesStatus::success != status_item_capability) {
+      return std::make_pair("", status_item_capability);
     }
   }
-  return true;
+
+  return std::make_pair("", capabilitiesStatus::success);
 }
 
-bool CheckIfModuleDataExistInCapabilities(
+/**
+ * @brief Check whether rc module data capabilities are presented
+ * @param smart object of rc_capabilities
+ * @param smart object of module_data
+ * @return pair of state and capability status - ModuleCapability
+ */
+ModuleCapability GetModuleDataCapabilities(
     const smart_objects::SmartObject& rc_capabilities,
     const smart_objects::SmartObject& module_data) {
   LOG4CXX_AUTO_TRACE(logger_);
@@ -285,29 +362,31 @@ bool CheckIfModuleDataExistInCapabilities(
   const auto& get_module_data_key = RCHelpers::GetModuleTypeToDataMapping();
   const auto& get_capabilities_key =
       RCHelpers::GetModuleTypeToCapabilitiesMapping();
+  ModuleCapability module_data_capabilities =
+      std::make_pair("", capabilitiesStatus::missedParam);
 
-  bool is_module_data_valid = false;
   for (const auto& module_type : all_module_types) {
     const auto module_data_key = get_module_data_key(module_type);
     const auto capabilities_key = get_capabilities_key(module_type);
     if (module_data.keyExists(module_data_key)) {
       if (!rc_capabilities.keyExists(capabilities_key)) {
         LOG4CXX_DEBUG(logger_, module_data_key << " capabilities not present");
-        return false;
+        return module_data_capabilities;
       }
       const smart_objects::SmartObject& caps =
           rc_capabilities[capabilities_key];
-      if (message_params::kHmiSettingsControlData == module_data_key ||
-          message_params::kLightControlData == module_data_key) {
-        is_module_data_valid =
-            CheckControlDataByCapabilities(caps, module_data[module_data_key]);
+
+      if (message_params::kHmiSettingsControlData == module_data_key) {
+        module_data_capabilities =
+            GetHmiControlDataCapabilities(caps, module_data[module_data_key]);
       } else {
-        is_module_data_valid = CheckControlDataByCapabilities(
-            caps[0], module_data[module_data_key]);
+        module_data_capabilities =
+            GetControlDataCapabilities(caps, module_data[module_data_key]);
       }
     }
   }
-  return is_module_data_valid;
+
+  return module_data_capabilities;
 }
 
 bool isModuleTypeAndDataMatch(const std::string& module_type,
@@ -325,6 +404,35 @@ bool isModuleTypeAndDataMatch(const std::string& module_type,
   return module_type_and_data_match;
 }
 
+mobile_apis::Result::eType PrepareResultCodeAndInfo(
+    const ModuleCapability module_data_capabilities, std::string& info) {
+  mobile_apis::Result::eType result_code =
+      mobile_apis::Result::UNSUPPORTED_RESOURCE;
+  if (message_params::kLightState == module_data_capabilities.first) {
+    switch (module_data_capabilities.second) {
+      case capabilitiesStatus::missedLightName:
+        info = "The requested LightName is not supported by the vehicle.";
+        break;
+      case capabilitiesStatus::missedParam:
+        info =
+            "The requested parameter of the given LightName is not supported "
+            "by the vehicle.";
+        break;
+      case capabilitiesStatus::readOnly:
+        info = "The requested parameter is read-only.";
+        result_code = mobile_apis::Result::READ_ONLY;
+        break;
+      default:
+        break;
+    }
+
+  } else {
+    info = "Accessing not supported module data.";
+  }
+  return result_code;
+  LOG4CXX_WARN(logger_, info);
+}
+
 void SetInteriorVehicleDataRequest::Execute() {
   LOG4CXX_AUTO_TRACE(logger_);
 
@@ -335,15 +443,22 @@ void SetInteriorVehicleDataRequest::Execute() {
   if (isModuleTypeAndDataMatch(module_type, module_data)) {
     const smart_objects::SmartObject* rc_capabilities =
         hmi_capabilities_.rc_capability();
-    if (rc_capabilities &&
-        !CheckIfModuleDataExistInCapabilities(*rc_capabilities, module_data)) {
-      LOG4CXX_WARN(logger_, "Accessing not supported module data");
-      SetResourceState(ModuleType(), ResourceState::FREE);
-      SendResponse(false,
-                   mobile_apis::Result::UNSUPPORTED_RESOURCE,
-                   "Accessing not supported module data");
-      return;
+    ModuleCapability module_data_capabilities;
+
+    if (rc_capabilities) {
+      module_data_capabilities =
+          GetModuleDataCapabilities(*rc_capabilities, module_data);
+
+      if (capabilitiesStatus::success != module_data_capabilities.second) {
+        SetResourceState(ModuleType(), ResourceState::FREE);
+        std::string info;
+        mobile_apis::Result::eType result =
+            PrepareResultCodeAndInfo(module_data_capabilities, info);
+        SendResponse(false, result, info.c_str());
+        return;
+      }
     }
+
     if (AreAllParamsReadOnly(module_data)) {
       LOG4CXX_WARN(logger_, "All request params in module type are READ ONLY!");
       SetResourceState(ModuleType(), ResourceState::FREE);
@@ -352,11 +467,27 @@ void SetInteriorVehicleDataRequest::Execute() {
                    "All request params in module type are READ ONLY!");
       return;
     }
-    if (AreReadOnlyParamsPresent(module_data)) {
+
+    module_data_capabilities = std::make_pair("", capabilitiesStatus::success);
+
+    if (AreReadOnlyParamsPresent(module_data, module_data_capabilities)) {
       LOG4CXX_DEBUG(logger_, "Request module type has READ ONLY parameters");
+
+      if (enums_value::kLight == module_data_capabilities.first &&
+          capabilitiesStatus::success != module_data_capabilities.second) {
+        SetResourceState(ModuleType(), ResourceState::FREE);
+        SendResponse(
+            false,
+            mobile_apis::Result::READ_ONLY,
+            "The LightStatus enum passed is READ ONLY and cannot be written.");
+        return;
+      }
+
       LOG4CXX_DEBUG(logger_, "Cutting-off READ ONLY parameters... ");
+
       CutOffReadOnlyParams(module_data);
     }
+
     application_manager_.RemoveHMIFakeParameters(message_);
 
     app_mngr::ApplicationSharedPtr app =
@@ -478,6 +609,8 @@ bool SetInteriorVehicleDataRequest::AreAllParamsReadOnly(
       return false;
     }
   }
+
+  LOG4CXX_DEBUG(logger_, "All params are ReadOnly");
   return true;
 }
 
@@ -487,33 +620,84 @@ bool CheckReadOnlyParamsForAudio(
     const auto& equalizer_settings =
         module_type_params[message_params::kEqualizerSettings];
     auto it = equalizer_settings.asArray()->begin();
+
     for (; it != equalizer_settings.asArray()->end(); ++it) {
       if (it->keyExists(message_params::kChannelName)) {
         LOG4CXX_DEBUG(logger_,
-                      " READ ONLY parameter: " << message_params::kChannelName);
+                      "READ ONLY parameter. ChannelName = "
+                          << (*it)[message_params::kChannelName].asString());
         return true;
       }
     }
   }
+
+  return false;
+}
+
+bool CheckReadOnlyParamsForLight(
+    const smart_objects::SmartObject& module_type_params) {
+  if (module_type_params.keyExists(message_params::kLightState)) {
+    const auto& light_state = module_type_params[message_params::kLightState];
+    auto it = light_state.asArray()->begin();
+
+    for (; it != light_state.asArray()->end(); ++it) {
+      if (it->keyExists(message_params::kLightStatus)) {
+        const mobile_apis::LightStatus::eType light_status =
+            static_cast<mobile_apis::LightStatus::eType>(
+                (*it)[message_params::kLightStatus].asUInt());
+
+        if (helpers::Compare<mobile_apis::LightStatus::eType,
+                             helpers::EQ,
+                             helpers::ONE>(light_status,
+                                           mobile_apis::LightStatus::RAMP_UP,
+                                           mobile_apis::LightStatus::RAMP_DOWN,
+                                           mobile_apis::LightStatus::UNKNOWN,
+                                           mobile_apis::LightStatus::INVALID)) {
+          LOG4CXX_DEBUG(logger_,
+                        "READ ONLY parameter. Status = "
+                            << (*it)[message_params::kLightStatus].asInt());
+          return true;
+        }
+      }
+    }
+  }
+
   return false;
 }
 
 bool SetInteriorVehicleDataRequest::AreReadOnlyParamsPresent(
-    const smart_objects::SmartObject& module_data) {
+    const smart_objects::SmartObject& module_data,
+    ModuleCapability& module_data_capabilities) {
   LOG4CXX_AUTO_TRACE(logger_);
   const smart_objects::SmartObject& module_type_params =
       ControlData(module_data);
-  auto it = module_type_params.map_begin();
   const std::string module_type = ModuleType();
-  std::vector<std::string> ro_params = GetModuleReadOnlyParams(module_type);
+
   if (enums_value::kAudio == module_type) {
     return CheckReadOnlyParamsForAudio(module_type_params);
   }
+
+  if (enums_value::kLight == module_type) {
+    const bool result = CheckReadOnlyParamsForLight(module_type_params);
+
+    if (result) {
+      module_data_capabilities =
+          std::make_pair(module_type, capabilitiesStatus::readOnly);
+    }
+
+    return result;
+  }
+
+  const std::vector<std::string> ro_params =
+      GetModuleReadOnlyParams(module_type);
+  auto it = module_type_params.map_begin();
+
   for (; it != module_type_params.map_end(); ++it) {
     if (helpers::in_range(ro_params, it->first)) {
       return true;
     }
   }
+
   return false;
 }
 
@@ -529,11 +713,13 @@ void SetInteriorVehicleDataRequest::CutOffReadOnlyParams(
     if (module_type_params.keyExists(it)) {
       if (enums_value::kClimate == module_type) {
         module_data[message_params::kClimateControlData].erase(it);
-        LOG4CXX_DEBUG(logger_, "Cutting-off READ ONLY parameter: " << it);
       } else if (enums_value::kRadio == module_type) {
         module_data[message_params::kRadioControlData].erase(it);
-        LOG4CXX_DEBUG(logger_, "Cutting-off READ ONLY parameter: " << it);
+      } else {
+        continue;
       }
+
+      LOG4CXX_DEBUG(logger_, "Cutting-off READ ONLY parameter: " << it);
     }
   }