fix: rebase with main

fix: setting JSON configuration to include schema validation (#1782)

Moved validation function to base class and added checks to V2
device model storage (OCPP 1.6)

Additional tests to ensure that schema validation on set works
for both JSON and database implemantations.

Signed-off-by: James Chapman <james.chapman@pionix.de>

Author: james-ctc

lib/everest/ocpp/include/ocpp/v16/charge_point_configuration.hpp

@@ -24,7 +24,6 @@ class ChargePointConfiguration : private ChargePointConfigurationBase, public Ch
     json custom_schema;
     json internal_schema;
     bool core_schema_unlock_connector_on_ev_side_disconnect_ro_value;
-    fs::path ocpp_main_path;
     fs::path user_config_path;
 
     std::recursive_mutex configuration_mutex;
@@ -36,11 +35,10 @@ class ChargePointConfiguration : private ChargePointConfigurationBase, public Ch
     void setChargepointInformationProperty(json& user_config, const std::string& key,
                                            const std::optional<std::string>& value);
 
-    bool validate(const std::string_view& schema_file, const json& object);
-
 public:
     ChargePointConfiguration(const std::string& config, const fs::path& ocpp_main_path,
                              const fs::path& user_config_path);
+    virtual ~ChargePointConfiguration() = default;
     void setChargepointInformation(const std::string& chargePointVendor, const std::string& chargePointModel,
                                    const std::optional<std::string>& chargePointSerialNumber,
                                    const std::optional<std::string>& chargeBoxSerialNumber,

lib/everest/ocpp/include/ocpp/v16/charge_point_configuration_base.hpp

@@ -7,9 +7,11 @@
 #include <ocpp/v16/types.hpp>
 
 #include <cstddef>
+#include <filesystem>
 #include <map>
 #include <optional>
 #include <set>
+#include <string_view>
 
 namespace ocpp::v16 {
 
@@ -39,11 +41,20 @@ class ChargePointConfigurationBase {
     MessagesSet supported_message_types_sending;
     ProfilesSet supported_feature_profiles;
     MeasurandsMap supported_measurands;
+    std::filesystem::path ocpp_main_path;
 
     void initialise(const ProfilesSet& initial_set, const std::optional<std::string>& supported_profiles_csl,
                     const std::optional<std::string>& supported_measurands_csl);
 
 public:
+    ChargePointConfigurationBase(const std::string_view& ocpp_main_path) : ocpp_main_path(ocpp_main_path) {
+    }
+    ChargePointConfigurationBase(const std::filesystem::path& ocpp_main_path) : ocpp_main_path(ocpp_main_path) {
+    }
+    virtual ~ChargePointConfigurationBase() = default;
+
+    bool validate(const std::string_view& schema_file, const json& object) const;
+
     bool isValidSupportedMeasurands(const std::string& csl) const;
     std::optional<MeasurandWithPhaseList> csvToMeasurandWithPhaseVector(const std::string& csl) const;
 

lib/everest/ocpp/include/ocpp/v16/charge_point_configuration_devicemodel.hpp

@@ -95,7 +95,8 @@ class ChargePointConfigurationDeviceModel : private ChargePointConfigurationBase
     SetResult setInternalWaitForSetUserPriceTimeout(const std::string& value);
 
 public:
-    explicit ChargePointConfigurationDeviceModel(std::unique_ptr<v2::DeviceModelInterface> device_model_interface);
+    explicit ChargePointConfigurationDeviceModel(const std::string_view& ocpp_main_path,
+                                                 std::unique_ptr<v2::DeviceModelInterface> device_model_interface);
     virtual ~ChargePointConfigurationDeviceModel() = default;
 
     // UserConfig and Internal

lib/everest/ocpp/include/ocpp/v16/charge_point_configuration_interface.hpp

@@ -20,6 +20,7 @@ struct KeyValue;
 /// \brief contains the configuration of the charge point
 class ChargePointConfigurationInterface {
 public:
+    virtual ~ChargePointConfigurationInterface() = default;
     // UserConfig and Internal
     virtual std::string getChargeBoxSerialNumber() = 0;
     virtual std::optional<CiString<25>> getChargePointSerialNumber() = 0;

lib/everest/ocpp/lib/ocpp/v16/charge_point_configuration.cpp

@@ -19,7 +19,7 @@ namespace ocpp::v16 {
 
 ChargePointConfiguration::ChargePointConfiguration(const std::string& config, const fs::path& ocpp_main_path,
                                                    const fs::path& user_config_path) :
-    ocpp_main_path(ocpp_main_path), user_config_path(user_config_path) {
+    ChargePointConfigurationBase(ocpp_main_path), user_config_path(user_config_path) {
 
     if (!fs::exists(this->user_config_path)) {
         EVLOG_critical << "User config file does not exist";
@@ -160,24 +160,6 @@ void ChargePointConfiguration::setChargepointInformationProperty(json& user_conf
     }
 }
 
-bool ChargePointConfiguration::validate(const std::string_view& schema_file, const json& object) {
-    bool result{false};
-    try {
-        fs::path schema_path = ocpp_main_path / "profile_schemas" / schema_file;
-        std::ifstream ifs(schema_path);
-        auto schema_json = json::parse(ifs);
-        ocpp::Schemas schema(std::move(schema_json));
-        auto validator = schema.get_validator();
-        if (validator) {
-            validator->validate(object);
-            result = true;
-        }
-    } catch (const std::exception& e) {
-        EVLOG_error << "Error validating against schema " << schema_file << ": " << e.what();
-    }
-    return result;
-}
-
 void ChargePointConfiguration::setChargepointInformation(const std::string& chargePointVendor,
                                                          const std::string& chargePointModel,
                                                          const std::optional<std::string>& chargePointSerialNumber,

lib/everest/ocpp/lib/ocpp/v16/charge_point_configuration_base.cpp

@@ -2,10 +2,12 @@
 // Copyright 2020 - 2026 Pionix GmbH and Contributors to EVerest
 
 #include <cstddef>
+#include <ocpp/common/schemas.hpp>
 #include <ocpp/v16/charge_point_configuration_base.hpp>
 #include <ocpp/v16/utils.hpp>
 
 #include <exception>
+#include <fstream>
 #include <regex>
 #include <string>
 
@@ -157,6 +159,24 @@ void ChargePointConfigurationBase::initialise(const ProfilesSet& initial_set,
     }
 }
 
+bool ChargePointConfigurationBase::validate(const std::string_view& schema_file, const json& object) const {
+    bool result{false};
+    try {
+        fs::path schema_path = ocpp_main_path / "profile_schemas" / schema_file;
+        std::ifstream ifs(schema_path);
+        auto schema_json = json::parse(ifs);
+        ocpp::Schemas schema(std::move(schema_json));
+        auto validator = schema.get_validator();
+        if (validator) {
+            validator->validate(object);
+            result = true;
+        }
+    } catch (const std::exception& e) {
+        EVLOG_error << "Error validating against schema " << schema_file << ": " << e.what();
+    }
+    return result;
+}
+
 bool ChargePointConfigurationBase::isValidSupportedMeasurands(const std::string& csl) const {
     const auto elements = utils::from_csl(csl);
     bool result{true};

lib/everest/ocpp/lib/ocpp/v16/charge_point_configuration_devicemodel.cpp

@@ -758,7 +758,17 @@ ChargePointConfigurationDeviceModel::setInternalDefaultPrice(const std::string&
     try {
         json default_price = json::object();
         default_price = json::parse(value);
-        result = set_value(*storage, keys::valid_keys::DefaultPrice, value);
+
+        // perform schema validation on value
+        json test_value;
+        test_value["CustomDisplayCostAndPrice"] = true;
+        test_value["DefaultPrice"] = default_price;
+
+        if (validate("CostAndPrice.json", test_value)) {
+            result = set_value(*storage, keys::valid_keys::DefaultPrice, value);
+        } else {
+            EVLOG_error << "DefaultPrice is invalid: " << value;
+        }
     } catch (const std::exception& e) {
         EVLOG_error << "Default price json not correct, can not store default price : " << e.what();
     }
@@ -844,7 +854,17 @@ ChargePointConfigurationDeviceModel::setInternalDefaultPriceText(const std::stri
                         // add new info
                         default_price_json["priceTexts"].push_back(value_json);
                     }
-                    result = set_value(*storage, keys::valid_keys::DefaultPriceText, default_price_json.dump(2));
+
+                    // perform schema validation on default_price
+                    json test_value;
+                    test_value["CustomDisplayCostAndPrice"] = true;
+                    test_value["DefaultPriceText"] = default_price_json;
+
+                    if (validate("CostAndPrice.json", test_value)) {
+                        result = set_value(*storage, keys::valid_keys::DefaultPriceText, default_price_json.dump(2));
+                    } else {
+                        EVLOG_error << "DefaultPriceText value is invalid: " << value;
+                    }
                 } else {
                     EVLOG_error << "Error while setting default price: 'priceTexts' is not an array";
                 }
@@ -907,8 +927,8 @@ ChargePointConfigurationDeviceModel::setInternalWaitForSetUserPriceTimeout(const
 // Public methods
 
 ChargePointConfigurationDeviceModel::ChargePointConfigurationDeviceModel(
-    std::unique_ptr<v2::DeviceModelInterface> device_model_interface) :
-    ChargePointConfigurationBase(), storage(std::move(device_model_interface)) {
+    const std::string_view& ocpp_main_path, std::unique_ptr<v2::DeviceModelInterface> device_model_interface) :
+    ChargePointConfigurationBase(ocpp_main_path), storage(std::move(device_model_interface)) {
     const auto profiles = get_optional<std::string>(*storage, keys::valid_keys::SupportedFeatureProfiles);
     const auto measurands = get_optional<std::string>(*storage, keys::valid_keys::SupportedMeasurands);
     ProfilesSet initial;

lib/everest/ocpp/tests/lib/ocpp/v16/v2config/configuration_stub.hpp

@@ -5,32 +5,42 @@
 
 #include <gtest/gtest.h>
 
+#include <filesystem>
 #include <fstream>
 #include <memory>
 
 #include <ocpp/v16/charge_point_configuration.hpp>
 #include <ocpp/v16/charge_point_configuration_devicemodel.hpp>
 #include <ocpp/v16/utils.hpp>
+#include <string_view>
 
 #include "memory_storage.hpp"
 
 namespace ocpp::v16::stubs {
 
+namespace fs = std::filesystem;
+
 // create instances for v16 and v2 configuration
 class ConfigurationBase : public testing::Test {
 protected:
     std::unique_ptr<ocpp::v16::ChargePointConfigurationInterface> v16_config;
     std::unique_ptr<ocpp::v16::ChargePointConfigurationInterface> v2_config;
     std::unique_ptr<MemoryStorage> device_model;
 
-    void SetUp() override {
-        std::ifstream ifs(CONFIG_FILE_LOCATION_V16);
+    void loadConfig(const std::string_view& file) {
+        fs::path cfg{CONFIG_DIR_V16};
+        cfg /= file;
+        std::ifstream ifs(cfg);
         const std::string config_file((std::istreambuf_iterator<char>(ifs)), (std::istreambuf_iterator<char>()));
         v16_config = std::make_unique<ocpp::v16::ChargePointConfiguration>(config_file, CONFIG_DIR_V16,
                                                                            USER_CONFIG_FILE_LOCATION_V16);
         device_model = std::make_unique<MemoryStorage>();
         std::unique_ptr<ocpp::v2::DeviceModelInterface> proxy = std::make_unique<MemoryStorageProxy>(*device_model);
-        v2_config = std::make_unique<ocpp::v16::ChargePointConfigurationDeviceModel>(std::move(proxy));
+        v2_config = std::make_unique<ocpp::v16::ChargePointConfigurationDeviceModel>(CONFIG_DIR_V16, std::move(proxy));
+    }
+
+    void SetUp() override {
+        loadConfig("config.json");
     }
 
     // void TearDown() override {
@@ -53,4 +63,13 @@ class Configuration : public ConfigurationBase, public testing::WithParamInterfa
     }
 };
 
+// create instances for v16 and v2 configuration
+class ConfigurationFull : public Configuration {
+protected:
+    void SetUp() override {
+        loadConfig("config-full.json");
+        device_model->apply_full_config();
+    }
+};
+
 } // namespace ocpp::v16::stubs

lib/everest/ocpp/tests/lib/ocpp/v16/v2config/memory_storage.cpp

@@ -3,6 +3,7 @@
 
 #include "memory_storage.hpp"
 
+#include <iterator>
 #include <ocpp/v16/known_keys.hpp>
 #include <ocpp/v2/ocpp_enums.hpp>
 #include <ocpp/v2/ocpp_types.hpp>
@@ -52,7 +53,6 @@ const std::map<std::string, std::string> required_vars_internal = {
     {"LogRotationMaximumFileSize", "0"},
     {"SupportedChargingProfilePurposeTypes", "ChargePointMaxProfile,TxDefaultProfile,TxProfile"},
     {"LogMessagesFormat", ""},
-    {"AllowChargingProfileWithoutStartSchedule", "true"},
     {"CompositeScheduleDefaultLimitAmps", "48"},
     {"CompositeScheduleDefaultLimitWatts", "33120"},
     {"CompositeScheduleDefaultNumberPhases", "3"},
@@ -134,6 +134,13 @@ const std::map<std::string, std::string> required_vars_california_pricing = {
 // Do not add additional values
 const std::map<std::string, std::string> required_vars_custom = {};
 
+// additional values for full config
+const std::map<std::string, std::string> full_vars_california_pricing = {
+    {"SupportedLanguages", "en, nl, de, nb_NO"},
+    {"CustomMultiLanguageMessages", "true"},
+    {"Language", "en"},
+};
+
 std::map<std::string, std::string> vars_internal;
 std::map<std::string, std::string> vars_core;
 std::map<std::string, std::string> vars_firmware_management;
@@ -191,6 +198,10 @@ MemoryStorage::MemoryStorage() {
     read_only.clear();
 }
 
+void MemoryStorage::apply_full_config() {
+    vars_california_pricing.insert(full_vars_california_pricing.begin(), full_vars_california_pricing.end());
+}
+
 void MemoryStorage::set_readonly(const std::string& key) {
     read_only.insert(key);
 }

lib/everest/ocpp/tests/lib/ocpp/v16/v2config/memory_storage.hpp

@@ -45,6 +45,8 @@ class MemoryStorage : public ocpp::v2::DeviceModelInterface {
 
     MemoryStorage();
 
+    void apply_full_config();
+
     void set_readonly(const std::string& key);
     void set(const std::string_view& component, const std::string_view& variable, const std::string_view& value);
     std::string get(const std::string_view& component, const std::string_view& variable);