1 files changed, 434 insertions, 11 deletions

diff --git a/src/components/policy/policy_external/src/sql_pt_representation.cc b/src/components/policy/policy_external/src/sql_pt_representation.cc
index f69a64a6a0..8abe37b9ea 100644
--- a/src/components/policy/policy_external/src/sql_pt_representation.cc
+++ b/src/components/policy/policy_external/src/sql_pt_representation.cc
@@ -515,6 +515,11 @@ std::shared_ptr<policy_table::Table> SQLPTRepresentation::GenerateSnapshot()
   GatherConsumerFriendlyMessages(
       &*table->policy_table.consumer_friendly_messages);
   GatherApplicationPoliciesSection(&table->policy_table.app_policies_section);
+  GatherVehicleData(&*table->policy_table.vehicle_data);
+  if (!table->policy_table.vehicle_data.is_initialized()) {
+    rpc::Optional<rpc::String<0, 100> > null_version;
+    table->policy_table.vehicle_data->schema_version = null_version;
+  }
   return table;
 }
 
@@ -559,6 +564,18 @@ void SQLPTRepresentation::GatherModuleConfig(
     }
   }
 
+  utils::dbms::SQLQuery endpoint_properties(db());
+  if (!endpoint_properties.Prepare(sql_pt::kSelectEndpointProperties)) {
+    LOG4CXX_ERROR(logger_, "Incorrect statement for Endpoint properties");
+  } else {
+    while (endpoint_properties.Next()) {
+      const std::string& service = endpoint_properties.GetString(0);
+      const std::string& version = endpoint_properties.GetString(1);
+      auto& ep_properties = (*config->endpoint_properties);
+      *ep_properties[service].version = version;
+    }
+  }
+
   utils::dbms::SQLQuery notifications(db());
   if (!notifications.Prepare(sql_pt::kSelectNotificationsPerMin)) {
     LOG4CXX_WARN(logger_, "Incorrect select statement for notifications");
@@ -650,16 +667,15 @@ bool SQLPTRepresentation::GatherFunctionalGroupings(
         }
       }
       if (!rpcs.IsNull(2)) {
-        policy_table::Parameter param;
-        if (policy_table::EnumFromJsonString(rpcs.GetString(2), &param)) {
-          // EMPTY is a special mark to specify that 'parameters' section is
-          // present, but has no parameters. It is not valid parameter value.
-          if (policy_table::P_EMPTY == param) {
-            (*rpcs_tbl.rpcs[rpcs.GetString(0)].parameters).mark_initialized();
-            continue;
-          }
-          InsertUnique(param, &(*rpcs_tbl.rpcs[rpcs.GetString(0)].parameters));
+        std::string param = rpcs.GetString(2);
+        // EMPTY is a special mark to specify that 'parameters' section is
+        // present, but has no parameters. It is not valid parameter value.
+        if ("EMPTY" == param) {
+          (*rpcs_tbl.rpcs[rpcs.GetString(0)].parameters).mark_initialized();
+          continue;
         }
+        InsertUnique(rpcs.GetString(2),
+                     &(*rpcs_tbl.rpcs[rpcs.GetString(0)].parameters));
       }
     }
 
@@ -814,6 +830,43 @@ bool SQLPTRepresentation::GatherApplicationPoliciesSection(
   return true;
 }
 
+bool SQLPTRepresentation::GatherVehicleData(
+    policy_table::VehicleData* vehicle_data) const {
+  utils::dbms::SQLQuery query(db());
+  if (!query.Prepare(sql_pt::kSelectVehicleDataSchemaVersion) ||
+      !query.Next()) {
+    LOG4CXX_ERROR(logger_,
+                  "Incorrect statement for vehicle data schema version");
+    return false;
+  }
+  *vehicle_data->schema_version = query.GetString(0);
+
+  vehicle_data->mark_initialized();
+  return GatherVehicleDataItems(&*vehicle_data->schema_items);
+}
+
+bool SQLPTRepresentation::GatherVehicleDataItems(
+    policy_table::VehicleDataItems* vehicle_data_items) const {
+  auto parameterized_vdi = SelectParameterizedVehicleDataItems();
+  if (!parameterized_vdi.is_initialized()) {
+    return false;
+  }
+
+  auto non_parameterized_vdi = SelectNonParameterizedVehicleDataItems();
+  if (!non_parameterized_vdi.is_initialized()) {
+    return false;
+  }
+
+  vehicle_data_items->insert(vehicle_data_items->end(),
+                             parameterized_vdi.begin(),
+                             parameterized_vdi.end());
+  vehicle_data_items->insert(vehicle_data_items->end(),
+                             non_parameterized_vdi.begin(),
+                             non_parameterized_vdi.end());
+
+  return true;
+}
+
 bool SQLPTRepresentation::Save(const policy_table::Table& table) {
   LOG4CXX_AUTO_TRACE(logger_);
   db_->BeginTransaction();
@@ -848,6 +901,10 @@ bool SQLPTRepresentation::Save(const policy_table::Table& table) {
     db_->RollbackTransaction();
     return false;
   }
+  if (!SaveVehicleData(*table.policy_table.vehicle_data)) {
+    db_->RollbackTransaction();
+    return false;
+  }
   db_->CommitTransaction();
   return true;
 }
@@ -946,8 +1003,7 @@ bool SQLPTRepresentation::SaveRpcs(int64_t group_id,
           query_parameter.Bind(0, it->first);
           query_parameter.Bind(
               1, std::string(policy_table::EnumToJsonString(*hmi_it)));
-          query_parameter.Bind(
-              2, std::string(policy_table::EnumToJsonString(*ps_it)));
+          query_parameter.Bind(2, std::string(*ps_it));
           query_parameter.Bind(3, group_id);
           if (!query_parameter.Exec() || !query_parameter.Reset()) {
             LOG4CXX_WARN(logger_, "Incorrect insert into rpc with parameter");
@@ -1161,6 +1217,43 @@ bool policy::SQLPTRepresentation::SaveDevicePolicy(
   return true;
 }
 
+bool SQLPTRepresentation::SaveVehicleDataItems(
+    const policy_table::VehicleDataItems& vehicle_data_items) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  DeleteVehicleDataItems();
+  for (const auto& item : vehicle_data_items) {
+    if (!InsertVehicleDataItem(item)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool SQLPTRepresentation::SaveVehicleData(
+    const policy_table::VehicleData& vehicle_data) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  if (!vehicle_data.is_initialized() ||
+      !vehicle_data.schema_items.is_initialized() ||
+      !vehicle_data.schema_version.is_initialized()) {
+    LOG4CXX_DEBUG(logger_, "Vehicle data is absent in policy table.");
+    return true;
+  }
+
+  utils::dbms::SQLQuery query(db());
+  if (!query.Prepare(sql_pt::kInsertVehicleDataSchemaVersion)) {
+    LOG4CXX_WARN(logger_,
+                 "Incorrect insert of schema_version to vehicle_data.");
+    return false;
+  }
+  query.Bind(0, *vehicle_data.schema_version);
+  if (!query.Exec() || !query.Reset()) {
+    LOG4CXX_WARN(logger_, "Failed to insert schema_version to vehicle_data.");
+    return false;
+  }
+
+  return SaveVehicleDataItems(*vehicle_data.schema_items);
+}
+
 bool SQLPTRepresentation::SaveAppGroup(
     const std::string& app_id, const policy_table::Strings& app_groups) {
   utils::dbms::SQLQuery query(db());
@@ -1427,6 +1520,10 @@ bool SQLPTRepresentation::SaveModuleConfig(
     return false;
   }
 
+  if (!SaveServiceEndpointProperties(*config.endpoint_properties)) {
+    return false;
+  }
+
   return true;
 }
 
@@ -1465,6 +1562,31 @@ bool SQLPTRepresentation::SaveServiceEndpoints(
   return true;
 }
 
+bool SQLPTRepresentation::SaveServiceEndpointProperties(
+    const policy_table::ServiceEndpointProperties& endpoint_properties) {
+  utils::dbms::SQLQuery query(db());
+  if (!query.Prepare(sql_pt::kInsertEndpointVersion)) {
+    LOG4CXX_WARN(
+        logger_,
+        "Incorrect insert of endpoint property to endpoint_properties.");
+    return false;
+  }
+
+  for (auto& endpoint_property : endpoint_properties) {
+    query.Bind(0, endpoint_property.first);
+    query.Bind(1, endpoint_property.second.version);
+
+    if (!query.Exec() || !query.Reset()) {
+      LOG4CXX_WARN(
+          logger_,
+          "Failed to insert endpoint property into endpoint_properties.");
+      return false;
+    }
+  }
+
+  return true;
+}
+
 bool SQLPTRepresentation::SaveConsumerFriendlyMessages(
     const policy_table::ConsumerFriendlyMessages& messages) {
   LOG4CXX_AUTO_TRACE(logger_);
@@ -1551,6 +1673,123 @@ bool SQLPTRepresentation::SaveLanguage(const std::string& code) {
   return true;
 }
 
+policy_table::VehicleDataItem SQLPTRepresentation::PopulateVDIFromQuery(
+    const utils::dbms::SQLQuery& query) const {
+  policy_table::VehicleDataItem result;
+
+  result.name = query.GetString(0);
+  result.type = query.GetString(1);
+  result.key = query.GetString(2);
+  result.mandatory = query.GetBoolean(3);
+
+  if (!query.IsNull(4)) {
+    *result.array = query.GetBoolean(4);
+  }
+  if (!query.IsNull(5)) {
+    *result.since = query.GetString(5);
+  }
+  if (!query.IsNull(6)) {
+    *result.until = query.GetString(6);
+  }
+  if (!query.IsNull(7)) {
+    *result.removed = query.GetBoolean(7);
+  }
+  if (!query.IsNull(8)) {
+    *result.deprecated = query.GetBoolean(8);
+  }
+  if (!query.IsNull(9)) {
+    *result.minvalue = query.GetInteger(9);
+  }
+  if (!query.IsNull(10)) {
+    *result.maxvalue = query.GetInteger(10);
+  }
+  if (!query.IsNull(11)) {
+    *result.minsize = query.GetUInteger(11);
+  }
+  if (!query.IsNull(12)) {
+    *result.maxsize = query.GetUInteger(12);
+  }
+  if (!query.IsNull(13)) {
+    *result.minlength = query.GetUInteger(13);
+  }
+  if (!query.IsNull(14)) {
+    *result.maxlength = query.GetUInteger(14);
+  }
+  result.params->mark_initialized();
+
+  result.mark_initialized();
+  return result;
+}
+
+policy_table::VehicleDataItems
+SQLPTRepresentation::SelectParameterizedVehicleDataItems() const {
+  utils::dbms::SQLQuery query(db());
+  if (!query.Prepare(sql_pt::kSelectParametrizedVehicleDataItemsKey)) {
+    LOG4CXX_ERROR(logger_,
+                  "Incorrect statement for parameterized vehicle data items");
+    return policy_table::VehicleDataItems();
+  }
+
+  policy_table::VehicleDataItems result;
+  result.mark_initialized();
+
+  while (query.Next()) {
+    const auto vdi = GetVehicleDataItem(query.GetString(0), query.GetString(1));
+    if (!vdi.is_initialized()) {
+      return policy_table::VehicleDataItems();
+    }
+    for (const auto& item : vdi) {
+      result.push_back(item);
+    }
+  }
+
+  return result;
+}
+
+policy_table::VehicleDataItems
+SQLPTRepresentation::SelectNonParameterizedVehicleDataItems() const {
+  utils::dbms::SQLQuery query(db());
+  if (!query.Prepare(sql_pt::kSelectNonParametrizedVehicleDataItems)) {
+    LOG4CXX_ERROR(
+        logger_,
+        "Incorrect statement for non parameterized vehicle data items");
+    return policy_table::VehicleDataItems();
+  }
+
+  auto result = policy_table::VehicleDataItems();
+  result.mark_initialized();
+
+  while (query.Next()) {
+    const auto vdi = PopulateVDIFromQuery(query);
+    if (!vdi.is_initialized()) {
+      return policy_table::VehicleDataItems();
+    }
+    result.push_back(vdi);
+  }
+  return result;
+}
+
+bool SQLPTRepresentation::DeleteVehicleDataItems() const {
+  utils::dbms::SQLQuery query(db());
+  db_->BeginTransaction();
+  if (!query.Exec(sql_pt::kDeleteVehicleDataItems)) {
+    LOG4CXX_ERROR(logger_,
+                  "Failed clearing database: " << query.LastError().text());
+    db_->RollbackTransaction();
+    return false;
+  }
+
+  if (!query.Exec(sql_pt::kDeleteVehicleDataItemParams)) {
+    LOG4CXX_ERROR(logger_,
+                  "Failed clearing database: " << query.LastError().text());
+    db_->RollbackTransaction();
+    return false;
+  }
+  db_->CommitTransaction();
+
+  return true;
+}
+
 bool SQLPTRepresentation::SaveMessageString(
     const std::string& type,
     const std::string& lang,
@@ -2282,6 +2521,190 @@ bool SQLPTRepresentation::UpdateDBVersion() const {
   return true;
 }
 
+policy_table::VehicleDataItems SQLPTRepresentation::GetVehicleDataItem(
+    const std::string& name, const std::string& key) const {
+  policy_table::VehicleDataItems result;
+  utils::dbms::SQLQuery query(db());
+
+  if (!query.Prepare(sql_pt::kSelectVehicleDataItem)) {
+    LOG4CXX_ERROR(logger_,
+                  "Incorrent select statement of vehicle data item. "
+                      << query.LastError().text());
+    return result;
+  }
+
+  query.Bind(0, key);
+  query.Bind(1, name);
+
+  while (query.Next()) {
+    auto vdi = PopulateVDIFromQuery(query);
+    if (!vdi.is_initialized()) {
+      return policy_table::VehicleDataItems();
+    }
+
+    utils::dbms::SQLQuery param_query(db());
+    if (policy_table::VehicleDataItem::kStruct ==
+        static_cast<std::string>(vdi.type)) {
+      if (!param_query.Prepare(sql_pt::kSelectVehicleDataItemParams)) {
+        LOG4CXX_ERROR(logger_,
+                      "Incorrent select statement of vehicle data item. "
+                          << param_query.LastError().text());
+        return policy_table::VehicleDataItems();
+      }
+
+      param_query.Bind(0, name);
+      param_query.Bind(1, key);
+
+      while (param_query.Next()) {
+        const auto param_with_diff_versions = GetVehicleDataItem(
+            param_query.GetString(2), param_query.GetString(3));
+        if (!param_with_diff_versions.is_initialized()) {
+          return policy_table::VehicleDataItems();
+        }
+        for (const auto& param : param_with_diff_versions) {
+          vdi.params->push_back(param);
+        }
+      }
+    }
+    result.push_back(vdi);
+  }
+  if (!result.empty()) {
+    result.mark_initialized();
+  }
+
+  return result;
+}
+
+bool SQLPTRepresentation::InsertVehicleDataItem(
+    const policy_table::VehicleDataItem& vehicle_data_item) {
+  utils::dbms::SQLQuery query(db());
+
+  if (!vehicle_data_item.is_initialized() || !vehicle_data_item.is_valid()) {
+    LOG4CXX_ERROR(logger_, "Vehicle data item is not initialized.");
+    return false;
+  }
+
+  if (VehicleDataItemExists(vehicle_data_item)) {
+    LOG4CXX_INFO(logger_,
+                 static_cast<std::string>(vehicle_data_item.key)
+                     << " is already stored.");
+    return true;
+  }
+
+  if (!query.Prepare(sql_pt::kInsertVehicleDataItem)) {
+    LOG4CXX_ERROR(logger_,
+                  "Incorrent select statement of vehicle data item. "
+                      << query.LastError().text());
+    return false;
+  }
+
+  query.Bind(0, vehicle_data_item.name);
+  query.Bind(1, vehicle_data_item.type);
+  query.Bind(2, vehicle_data_item.key);
+  query.Bind(3, vehicle_data_item.mandatory);
+  vehicle_data_item.array.is_initialized()
+      ? query.Bind(4, *vehicle_data_item.array)
+      : query.Bind(4);
+  vehicle_data_item.since.is_initialized()
+      ? query.Bind(5, *vehicle_data_item.since)
+      : query.Bind(5);
+  vehicle_data_item.until.is_initialized()
+      ? query.Bind(6, *vehicle_data_item.until)
+      : query.Bind(6);
+  vehicle_data_item.removed.is_initialized()
+      ? query.Bind(7, *vehicle_data_item.removed)
+      : query.Bind(7);
+  vehicle_data_item.deprecated.is_initialized()
+      ? query.Bind(8, *vehicle_data_item.deprecated)
+      : query.Bind(8);
+  vehicle_data_item.minvalue.is_initialized()
+      ? query.Bind(9, *vehicle_data_item.minvalue)
+      : query.Bind(9);
+  vehicle_data_item.maxvalue.is_initialized()
+      ? query.Bind(10, *vehicle_data_item.maxvalue)
+      : query.Bind(10);
+  vehicle_data_item.minsize.is_initialized()
+      ? query.Bind(11, static_cast<int64_t>(*vehicle_data_item.minsize))
+      : query.Bind(11);
+  vehicle_data_item.maxsize.is_initialized()
+      ? query.Bind(12, static_cast<int64_t>(*vehicle_data_item.maxsize))
+      : query.Bind(12);
+  vehicle_data_item.minlength.is_initialized()
+      ? query.Bind(13, static_cast<int64_t>(*vehicle_data_item.minlength))
+      : query.Bind(13);
+  vehicle_data_item.maxlength.is_initialized()
+      ? query.Bind(14, static_cast<int64_t>(*vehicle_data_item.maxlength))
+      : query.Bind(14);
+
+  if (!query.Exec() || !query.Reset()) {
+    LOG4CXX_ERROR(logger_,
+                  "Failed to insert vehicle data item: "
+                      << static_cast<std::string>(vehicle_data_item.key)
+                      << ". Error: " << query.LastError().text());
+    return false;
+  }
+
+  if (vehicle_data_item.params->is_initialized()) {
+    for (const auto& param : *(vehicle_data_item.params)) {
+      if (!InsertVehicleDataItem(param)) {
+        return false;
+      }
+
+      if (!query.Prepare(sql_pt::kInsertVehicleDataItemParams)) {
+        LOG4CXX_ERROR(logger_,
+                      "Incorrent select statement of vehicle data item. "
+                          << query.LastError().text());
+        return false;
+      }
+
+      query.Bind(0, vehicle_data_item.name);
+      query.Bind(1, vehicle_data_item.key);
+      query.Bind(2, param.name);
+      query.Bind(3, param.key);
+
+      if (!query.Exec() || !query.Reset()) {
+        LOG4CXX_ERROR(
+            logger_,
+            "Failed to insert to vehicle data item relations helper table: "
+                << static_cast<std::string>(param.key)
+                << ". Error: " << query.LastError().text());
+        return false;
+      }
+    }
+  }
+
+  return true;
+}
+
+bool SQLPTRepresentation::VehicleDataItemExists(
+    const policy_table::VehicleDataItem& vehicle_data_item) const {
+  utils::dbms::SQLQuery query(db());
+  if (!query.Prepare(sql_pt::kSelectVehicleDataItemWithVersion)) {
+    LOG4CXX_ERROR(logger_,
+                  "Incorrent select statement for vehicle data item. "
+                      << query.LastError().text());
+    return false;
+  }
+
+  query.Bind(0, vehicle_data_item.name);
+  query.Bind(1, vehicle_data_item.key);
+  vehicle_data_item.since.is_initialized()
+      ? query.Bind(2, std::string(*vehicle_data_item.since))
+      : query.Bind(2);
+  vehicle_data_item.until.is_initialized()
+      ? query.Bind(3, std::string(*vehicle_data_item.until))
+      : query.Bind(3);
+
+  if (!query.Exec()) {
+    LOG4CXX_ERROR(logger_,
+                  "Failed to retrieve vehicle data item: "
+                      << std::string(vehicle_data_item.key)
+                      << ". Error: " << query.LastError().text());
+    return false;
+  }
+  return !query.IsNull(0);
+}
+
 const int32_t SQLPTRepresentation::GetDBVersion() const {
   return utils::Djb2HashFromString(sql_pt::kCreateSchema);
 }