diff options
Diffstat (limited to 'src/components/policy/policy_external/src/sql_pt_representation.cc')
-rw-r--r-- | src/components/policy/policy_external/src/sql_pt_representation.cc | 460 |
1 files changed, 437 insertions, 23 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 f2a2d34145..7874abc4ee 100644 --- a/src/components/policy/policy_external/src/sql_pt_representation.cc +++ b/src/components/policy/policy_external/src/sql_pt_representation.cc @@ -451,16 +451,6 @@ bool SQLPTRepresentation::Close() { return db_->LastError().number() == utils::dbms::OK; } -const VehicleInfo SQLPTRepresentation::GetVehicleInfo() const { - policy_table::ModuleConfig module_config; - GatherModuleConfig(&module_config); - VehicleInfo vehicle_info; - vehicle_info.vehicle_make = *module_config.vehicle_make; - vehicle_info.vehicle_model = *module_config.vehicle_model; - vehicle_info.vehicle_year = *module_config.vehicle_year; - return vehicle_info; -} - bool SQLPTRepresentation::Drop() { utils::dbms::SQLQuery query(db()); if (!query.Exec(sql_pt::kDropSchema)) { @@ -525,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; } @@ -569,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"); @@ -664,16 +671,15 @@ bool SQLPTRepresentation::GatherFunctionalGroupings( } } if (!rpcs.IsNull(2)) { - policy_table::Parameter param; - if (policy_table::EnumFromJsonString(rpcs.GetString(2), ¶m)) { - // 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 (policy_table::EnumToJsonString(policy_table::P_EMPTY) == param) { + (*rpcs_tbl.rpcs[rpcs.GetString(0)].parameters).mark_initialized(); + continue; } + InsertUnique(rpcs.GetString(2), + &(*rpcs_tbl.rpcs[rpcs.GetString(0)].parameters)); } } @@ -832,6 +838,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 = SelectCompositeVehicleDataItems(); + if (!parameterized_vdi.is_initialized()) { + return false; + } + + auto non_parameterized_vdi = SelectPrimitiveVehicleDataItems(); + 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(); @@ -866,6 +909,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; } @@ -966,8 +1013,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"); @@ -1185,6 +1231,44 @@ 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_version.is_initialized()) { + 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; + } + } + + auto vehicle_data_items = vehicle_data.is_initialized() && + vehicle_data.schema_items.is_initialized() + ? *(vehicle_data.schema_items) + : policy_table::VehicleDataItems(); + + return SaveVehicleDataItems(vehicle_data_items); +} + bool SQLPTRepresentation::SaveAppGroup( const std::string& app_id, const policy_table::Strings& app_groups) { utils::dbms::SQLQuery query(db()); @@ -1308,7 +1392,9 @@ bool SQLPTRepresentation::SaveRequestSubType( } else if (request_subtypes.is_initialized()) { LOG4CXX_WARN(logger_, "Request subtypes empty."); query.Bind(0, app_id); - query.Bind(1, std::string("EMPTY")); + query.Bind(1, + std::string(policy_table::EnumToJsonString( + policy_table::RequestType::RT_EMPTY))); if (!query.Exec() || !query.Reset()) { LOG4CXX_WARN(logger_, "Incorrect insert into request subtypes."); return false; @@ -1451,6 +1537,10 @@ bool SQLPTRepresentation::SaveModuleConfig( return false; } + if (!SaveServiceEndpointProperties(*config.endpoint_properties)) { + return false; + } + return true; } @@ -1489,6 +1579,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_); @@ -1575,6 +1690,120 @@ 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::SelectCompositeVehicleDataItems() const { + utils::dbms::SQLQuery query(db()); + if (!query.Prepare(sql_pt::kSelectCompositeVehicleDataItemsKey)) { + 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::SelectPrimitiveVehicleDataItems() const { + utils::dbms::SQLQuery query(db()); + if (!query.Prepare(sql_pt::kSelectPrimitiveVehicleDataItems)) { + 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()); + LOG4CXX_AUTO_TRACE(logger_); + + if (!query.Exec(sql_pt::kDeleteVehicleDataItems)) { + LOG4CXX_ERROR(logger_, + "Failed clearing database: " << query.LastError().text()); + return false; + } + + if (!query.Exec(sql_pt::kDeleteVehicleDataItemParams)) { + LOG4CXX_ERROR(logger_, + "Failed clearing database: " << query.LastError().text()); + return false; + } + return true; +} + bool SQLPTRepresentation::SaveMessageString( const std::string& type, const std::string& lang, @@ -1817,7 +2046,8 @@ bool SQLPTRepresentation::GatherRequestSubType( query.Bind(0, app_id); while (query.Next()) { const std::string request_subtype = query.GetString(0); - if ("EMPTY" == request_subtype) { + if (policy_table::EnumToJsonString(policy_table::RequestType::RT_EMPTY) == + request_subtype) { request_subtypes->mark_initialized(); continue; } @@ -2306,6 +2536,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); } |