Feature/656 device model initialization in cpp

config/v201/CMakeLists.txt

@@ -1,5 +1,6 @@
 # find all migration files, store only the filenames by showing relative to the folder
 set(MIGRATION_FILES_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}/core_migrations")
+set(MIGRATION_FILES_DEVICE_MODEL_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}/device_model_migrations")
 
 include(../CollectMigrationFiles.cmake)
 
@@ -9,7 +10,15 @@ collect_migration_files(
      )
 
 set(MIGRATION_FILE_VERSION_V201 ${TARGET_MIGRATION_FILE_VERSION} PARENT_SCOPE)
+
+collect_migration_files(
+     LOCATION ${MIGRATION_FILES_DEVICE_MODEL_LOCATION}
+     INSTALL_DESTINATION ${CMAKE_INSTALL_DATADIR}/everest/modules/OCPP201/device_model_migrations
+     )
+
+set(MIGRATION_DEVICE_MODEL_FILE_VERSION_V201 ${TARGET_MIGRATION_FILE_VERSION} PARENT_SCOPE)
 set(MIGRATION_FILES_SOURCE_DIR_V201 ${MIGRATION_FILES_LOCATION} PARENT_SCOPE)
+set(MIGRATION_FILES_DEVICE_MODEL_SOURCE_DIR_V201 ${MIGRATION_FILES_DEVICE_MODEL_LOCATION} PARENT_SCOPE)
 
 option(LIBOCPP_INSTALL_DEVICE_MODEL_DATABASE "Install device model database for OCPP201" ON)
 
@@ -26,14 +35,15 @@ install(
 if (LIBOCPP_INSTALL_DEVICE_MODEL_DATABASE)
      set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/config.json)
 
-     find_program(
-          PYTHON_EXECUTABLE
-          python3
-          REQUIRED
-     )
+     # find_program(
+     #      PYTHON_EXECUTABLE
+     #      python3
+     #      REQUIRED
+     # )
 
-     set(INIT_DEVICE_MODULE_DB_SCRIPT "${CMAKE_CURRENT_SOURCE_DIR}/init_device_model_db.py")
-     set(DEVICE_MODEL_DATABASE_FILE "device_model_storage.db")
+     # set(INIT_DEVICE_MODULE_DB_SCRIPT "${CMAKE_CURRENT_SOURCE_DIR}/init_device_model_db.py")
+     # TODO set correct paths and copy files to data dir!!
+     set(DEVICE_MODEL_DATABASE_FILE "${CMAKE_INSTALL_DATADIR}/everest/modules/OCPP201/device_model_storage.db")
 
      if(NOT LIBOCPP_V201_CONFIG_FILE)
           set(LIBOCPP_V201_CONFIG_FILE "${CMAKE_CURRENT_SOURCE_DIR}/config.json")
@@ -46,19 +56,21 @@ if (LIBOCPP_INSTALL_DEVICE_MODEL_DATABASE)
 
      message(STATUS "Using ocpp v201 config file path: ${LIBOCPP_V201_CONFIG_FILE}")
 
-     execute_process(
-             COMMAND
-             ${PYTHON_EXECUTABLE} ${INIT_DEVICE_MODULE_DB_SCRIPT} init --db ${CMAKE_CURRENT_BINARY_DIR}/${DEVICE_MODEL_DATABASE_FILE} --schemas ${LIBOCPP_COMPONENT_SCHEMAS_PATH}
-          WORKING_DIRECTORY 
-               ${CMAKE_CURRENT_SOURCE_DIR}
-     )
+     # execute_process(
+     #         COMMAND
+     #         ${PYTHON_EXECUTABLE} ${INIT_DEVICE_MODULE_DB_SCRIPT} init --db ${CMAKE_CURRENT_BINARY_DIR}/${DEVICE_MODEL_DATABASE_FILE} --schemas ${LIBOCPP_COMPONENT_SCHEMAS_PATH}
+     #      WORKING_DIRECTORY
+     #           ${CMAKE_CURRENT_SOURCE_DIR}
+     # )
 
-     execute_process(
-             COMMAND
-             ${PYTHON_EXECUTABLE} ${INIT_DEVICE_MODULE_DB_SCRIPT} insert --db ${CMAKE_CURRENT_BINARY_DIR}/${DEVICE_MODEL_DATABASE_FILE} --schemas ${LIBOCPP_COMPONENT_SCHEMAS_PATH} --config ${LIBOCPP_V201_CONFIG_FILE}
-          WORKING_DIRECTORY 
-               ${CMAKE_CURRENT_SOURCE_DIR}
-     )
+     # execute_process(
+     #         COMMAND
+     #         ${PYTHON_EXECUTABLE} ${INIT_DEVICE_MODULE_DB_SCRIPT} insert --db ${CMAKE_CURRENT_BINARY_DIR}/${DEVICE_MODEL_DATABASE_FILE} --schemas ${LIBOCPP_COMPONENT_SCHEMAS_PATH} --config ${LIBOCPP_V201_CONFIG_FILE}
+     #      WORKING_DIRECTORY
+     #           ${CMAKE_CURRENT_SOURCE_DIR}
+     # )
 
-     install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${DEVICE_MODEL_DATABASE_FILE} DESTINATION ${CMAKE_INSTALL_DATADIR}/everest/modules/OCPP201)
+     # install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${DEVICE_MODEL_DATABASE_FILE} DESTINATION ${CMAKE_INSTALL_DATADIR}/everest/modules/OCPP201)
+     install(FILES ${LIBOCPP_V201_CONFIG_FILE} DESTINATION ${CMAKE_INSTALL_DATADIR}/everest/modules/OCPP201)
+     install(DIRECTORY ${LIBOCPP_COMPONENT_SCHEMAS_PATH} DESTINATION ${CMAKE_INSTALL_DATADIR}/everest/modules/OCPP201)
 endif()

config/v201/init_device_model.sql → config/v201/device_model_migrations/1_up-initial.sql

@@ -17,50 +17,50 @@ CREATE TABLE IF NOT EXISTS COMPONENT (
 );
 CREATE TABLE IF NOT EXISTS VARIABLE_ATTRIBUTE (
   ID INTEGER PRIMARY KEY AUTOINCREMENT,
-  VARIABLE_ID INTEGER,
+  VARIABLE_ID INTEGER NOT NULL,
   MUTABILITY_ID INTEGER,
   PERSISTENT INTEGER,
   CONSTANT INTEGER,
   TYPE_ID INTEGER,
+  VALUE_SOURCE TEXT DEFAULT "default",
   "VALUE" TEXT,
-  FOREIGN KEY (VARIABLE_ID) REFERENCES VARIABLE (ID),
-  FOREIGN KEY (TYPE_ID) REFERENCES VARIABLE_ATTRIBUTE_TYPE (ID),
-  FOREIGN KEY (MUTABILITY_ID) REFERENCES MUTABILITY (ID)
+  FOREIGN KEY (VARIABLE_ID) REFERENCES VARIABLE (ID) ON DELETE CASCADE,
+  FOREIGN KEY (TYPE_ID) REFERENCES VARIABLE_ATTRIBUTE_TYPE (ID) ON DELETE RESTRICT,
+  FOREIGN KEY (MUTABILITY_ID) REFERENCES MUTABILITY (ID) ON DELETE RESTRICT
 );
 CREATE TABLE IF NOT EXISTS VARIABLE_CHARACTERISTICS (
   ID INTEGER PRIMARY KEY AUTOINCREMENT,
-  DATATYPE_ID INTEGER,
+  DATATYPE_ID INTEGER NOT NULL,
+  VARIABLE_ID INTEGER NOT NULL,
   MAX_LIMIT REAL,
   MIN_LIMIT REAL,
   SUPPORTS_MONITORING INTEGER,
   UNIT TEXT,
   VALUES_LIST TEXT,
-  FOREIGN KEY (DATATYPE_ID) REFERENCES DATATYPE (ID)
+  FOREIGN KEY (DATATYPE_ID) REFERENCES DATATYPE (ID) ON DELETE RESTRICT
+  FOREIGN KEY (VARIABLE_ID) REFERENCES VARIABLE (ID) ON DELETE CASCADE
 );
 CREATE TABLE IF NOT EXISTS VARIABLE_MONITORING (
   ID INTEGER PRIMARY KEY AUTOINCREMENT,
-  VARIABLE_ID INTEGER,
+  VARIABLE_ID INTEGER NOT NULL,
   SEVERITY INTEGER,
   "TRANSACTION" INTEGER,
-  TYPE_ID INTEGER,
+  TYPE_ID INTEGER NOT NULL,
   CONFIG_TYPE_ID INTEGER,
   "VALUE" DECIMAL,
   REFERENCE_VALUE TEXT,
-  FOREIGN KEY (VARIABLE_ID) REFERENCES VARIABLE (ID),
-  FOREIGN KEY (TYPE_ID) REFERENCES MONITOR (ID),
-  FOREIGN KEY (CONFIG_TYPE_ID) REFERENCES MONITOR_CONFIG_TYPE(ID)
+  FOREIGN KEY (VARIABLE_ID) REFERENCES VARIABLE (ID) ON DELETE CASCADE,
+  FOREIGN KEY (TYPE_ID) REFERENCES MONITOR (ID) ON DELETE RESTRICT,
+  FOREIGN KEY (CONFIG_TYPE_ID) REFERENCES MONITOR_CONFIG_TYPE(ID) ON DELETE RESTRICT
 );
 CREATE TABLE IF NOT EXISTS VARIABLE (
   ID INTEGER PRIMARY KEY AUTOINCREMENT,
   NAME TEXT,
   INSTANCE TEXT,
-  COMPONENT_ID INTEGER,
-  VARIABLE_CHARACTERISTICS_ID INTEGER,
+  COMPONENT_ID INTEGER NOT NULL,
   REQUIRED INTEGER DEFAULT FALSE,
-  FOREIGN KEY (COMPONENT_ID) REFERENCES COMPONENT (ID),
-  FOREIGN KEY (VARIABLE_CHARACTERISTICS_ID) REFERENCES VARIABLE_CHARACTERISTICS (ID)
+  FOREIGN KEY (COMPONENT_ID) REFERENCES COMPONENT (ID) ON DELETE CASCADE
 );
-BEGIN TRANSACTION;
 INSERT
   OR REPLACE INTO MUTABILITY
 VALUES (0, "ReadOnly");
@@ -160,4 +160,3 @@ VALUES (2, "MinSet");
 INSERT
   OR REPLACE INTO VARIABLE_ATTRIBUTE_TYPE
 VALUES (3, "MaxSet");
-COMMIT;

doc/device_model_initialization.md

@@ -0,0 +1,51 @@
+# Device model initialization and inserting of config values
+
+If there is no custom database used for the device model, and 'initialize_device_model' is set to true in the 
+constructor of ChargePoint, the device model will be created or updated when ChargePoint is created. This document will
+give more information about the files you need and what will be updated when the 'initialize_device_model' is set
+to true.
+
+
+## Database, component schemas and config file paths
+
+Along with the 'initialize_device_model' flag, a few paths must be given to the constructor:
+- The path of the device model migration files (normally `resources/v201/device_model_migration_files`).
+- The path of the device model database.
+- The path of the directory with the device model schemas. There should be two directories in it: 'standardized' and 
+  'custom', both containing device model schemas.
+- The path of the config file.
+
+
+## Component schemas and config file
+
+When the database is created for the first time, it will insert all components, variables, characteristics and 
+attributes from the component schemas. 
+
+It will then set all the values read from the config file. 
+
+If anything does not match, no values will be set. So if for example there is a variable set in the config that is 
+not in the component schema, the config values will not be set. 
+
+
+## Update config values
+
+Each time the software starts, the config file is read and the values will be set to the database accordingly. Only 
+the initial values will be set to the values in the config file. So if for example the csms changed a value, it will 
+not be updated to the value from the config file.
+
+
+## Update component schemas
+
+It is only possible to update the component schemas for `EVSE`'s and `Connector`s. All other components can not be updated.
+
+To update an `EVSE` or `Connector` component, just place the correct `EVSE` / `Connector` json schema in the 
+`component_schemas/custom` folder. When restarting the software, it will:
+- Check if there are `EVSE`'s or `Connector`s in the database that are not in the component schema's. Those will be 
+  removed.
+- Check if there are `EVSE`'s er `Connectors` in the component schema's that are not in the database. Those will be 
+  added.
+- Check if anything has changed inside the `EVSE`'s or `Connectors` (`Variable`, `Characteristics` or `Attributes` 
+  removed, changed or added. Those will be removed, changed or added to the database as well. 
+
+Note: When the id of an `EVSE` Component is changed, this is seen as the removal of an `EVSE` and addition of a new 
+`EVSE`. The same applies to the `evse_id` or `connector_id` of a `Connector` component.

include/ocpp/common/database/sqlite_statement.hpp

@@ -39,6 +39,7 @@ class SQLiteStatementInterface {
     virtual int bind_null(const int idx) = 0;
     virtual int bind_null(const std::string& param) = 0;
 
+    virtual int get_number_of_rows() = 0;
     virtual int column_type(const int idx) = 0;
     virtual std::string column_text(const int idx) = 0;
     virtual std::optional<std::string> column_text_nullable(const int idx) = 0;
@@ -73,6 +74,7 @@ class SQLiteStatement : public SQLiteStatementInterface {
     int bind_null(const int idx) override;
     int bind_null(const std::string& param) override;
 
+    int get_number_of_rows() override;
     int column_type(const int idx) override;
     std::string column_text(const int idx) override;
     std::optional<std::string> column_text_nullable(const int idx) override;

include/ocpp/v201/charge_point.hpp

@@ -388,7 +388,7 @@ class ChargePointInterface {
     /// \return Map containing the SetVariableData as a key and the  SetVariableResult as a value for each requested
     /// change
     virtual std::map<SetVariableData, SetVariableResult>
-    set_variables(const std::vector<SetVariableData>& set_variable_data_vector) = 0;
+    set_variables(const std::vector<SetVariableData>& set_variable_data_vector, const std::string& source) = 0;
 };
 
 /// \brief Class implements OCPP2.0.1 Charging Station
@@ -524,11 +524,13 @@ class ChargePoint : public ChargePointInterface, private ocpp::ChargingStationBa
 
     /// \brief Sets variables specified within \p set_variable_data_vector in the device model and returns the result.
     /// \param set_variable_data_vector contains data of the variables to set
+    /// \param source   value source (who sets the value, for example 'csms' or 'libocpp')
     /// \param allow_read_only if true, setting VariableAttribute values with mutability ReadOnly is allowed
     /// \return Map containing the SetVariableData as a key and the  SetVariableResult as a value for each requested
     /// change
     std::map<SetVariableData, SetVariableResult>
-    set_variables_internal(const std::vector<SetVariableData>& set_variable_data_vector, const bool allow_read_only);
+    set_variables_internal(const std::vector<SetVariableData>& set_variable_data_vector, const std::string& source,
+                           const bool allow_read_only);
 
     MeterValue get_latest_meter_value_filtered(const MeterValue& meter_value, ReadingContextEnum context,
                                                const RequiredComponentVariable& component_variable);
@@ -743,7 +745,7 @@ class ChargePoint : public ChargePointInterface, private ocpp::ChargingStationBa
             ocpp::CallResult<ResponseType> call_result = enhanced_response.message;
             return call_result.msg;
         };
-    };
+    }
 
     /// \brief Checks if all connectors are effectively inoperative.
     /// If this is the case, calls the all_connectors_unavailable_callback
@@ -761,6 +763,31 @@ class ChargePoint : public ChargePointInterface, private ocpp::ChargingStationBa
     void execute_change_availability_request(ChangeAvailabilityRequest request, bool persist);
 
 public:
+    /// \brief Construct a new ChargePoint object
+    /// \param evse_connector_structure Map that defines the structure of EVSE and connectors of the chargepoint. The
+    /// key represents the id of the EVSE and the value represents the number of connectors for this EVSE. The ids of
+    /// the EVSEs have to increment starting with 1.
+    /// \param device_model_storage_address address to device model storage (e.g. location of SQLite database)
+    /// \param initialize_device_model  Set to true to initialize the device model database
+    /// \param device_model_migration_path  Path to the device model database migration files
+    /// \param device_model_schemas_path    Path to the device model schemas
+    /// \param config_path                  Path to the chargepoint configuration
+    /// \param ocpp_main_path Path where utility files for OCPP are read and written to
+    /// \param core_database_path Path to directory where core database is located
+    /// \param message_log_path Path to where logfiles are written to
+    /// \param evse_security Pointer to evse_security that manages security related operations; if nullptr
+    /// security_configuration must be set
+    /// \param callbacks Callbacks that will be registered for ChargePoint
+    /// \param security_configuration specifies the file paths that are required to set up the internal evse_security
+    /// implementation
+    ChargePoint(const std::map<int32_t, int32_t>& evse_connector_structure,
+                const std::string& device_model_storage_address, const bool initialize_device_model,
+                const std::string& device_model_migration_path, const std::string& device_model_schemas_path,
+                const std::string& config_path, const std::string& ocpp_main_path,
+                const std::string& core_database_path, const std::string& sql_init_path,
+                const std::string& message_log_path, const std::shared_ptr<EvseSecurity> evse_security,
+                const Callbacks& callbacks);
+
     /// \brief Construct a new ChargePoint object
     /// \param evse_connector_structure Map that defines the structure of EVSE and connectors of the chargepoint. The
     /// key represents the id of the EVSE and the value represents the number of connectors for this EVSE. The ids of
@@ -875,7 +902,7 @@ class ChargePoint : public ChargePointInterface, private ocpp::ChargingStationBa
     std::vector<GetVariableResult> get_variables(const std::vector<GetVariableData>& get_variable_data_vector) override;
 
     std::map<SetVariableData, SetVariableResult>
-    set_variables(const std::vector<SetVariableData>& set_variable_data_vector) override;
+    set_variables(const std::vector<SetVariableData>& set_variable_data_vector, const std::string& source) override;
 
     /// \brief Requests a value of a VariableAttribute specified by combination of \p component_id and \p variable_id
     /// from the device model

include/ocpp/v201/device_model.hpp

@@ -165,21 +165,24 @@ class DeviceModel {
     /// \param variable_id
     /// \param attribute_enum
     /// \param value
+    /// \param source           The source of the value (for example 'csms' or 'default').
     /// \param allow_read_only If this is true, read-only variables can be changed,
     ///                        otherwise only non read-only variables can be changed. Defaults to false
     /// \return Result of the requested operation
     SetVariableStatusEnum set_value(const Component& component_id, const Variable& variable_id,
                                     const AttributeEnum& attribute_enum, const std::string& value,
-                                    const bool allow_read_only = false);
+                                    const std::string& source, const bool allow_read_only = false);
     /// \brief Sets the variable_id attribute \p value specified by \p component_id , \p variable_id and \p
     /// attribute_enum for read only variables only. Only works on certain allowed components.
     /// \param component_id
     /// \param variable_id
     /// \param attribute_enum
     /// \param value
+    /// \param source           The source of the value (for example 'csms' or 'default').
     /// \return Result of the requested operation
     SetVariableStatusEnum set_read_only_value(const Component& component_id, const Variable& variable_id,
-                                              const AttributeEnum& attribute_enum, const std::string& value);
+                                              const AttributeEnum& attribute_enum, const std::string& value,
+                                              const std::string& source);
 
     /// \brief Gets the VariableMetaData for the given \p component_id and \p variable_id
     /// \param component_id

include/ocpp/v201/device_model_storage.hpp

@@ -84,9 +84,11 @@ class DeviceModelStorage {
     /// \param variable_id
     /// \param attribute_enum
     /// \param value
+    /// \param source           The source of the value.
     /// \return true if the value could be set in the storage, else false
     virtual bool set_variable_attribute_value(const Component& component_id, const Variable& variable_id,
-                                              const AttributeEnum& attribute_enum, const std::string& value) = 0;
+                                              const AttributeEnum& attribute_enum, const std::string& value,
+                                              const std::string& source) = 0;
 
     /// \brief Inserts or replaces a variable monitor in the database
     /// \param data Monitor data to set

include/ocpp/v201/device_model_storage_sqlite.hpp

@@ -25,7 +25,26 @@ class DeviceModelStorageSqlite : public DeviceModelStorage {
 
 public:
     /// \brief Opens SQLite connection at given \p db_path
-    /// \param db_path  path to database
+    ///
+    /// With this constructor, you can initialize the database as well.
+    ///
+    /// \param db_path              Path to database
+    /// \param migration_files_path Path to the migration files to initialize the database (only needs to be set if
+    ///                             `init_db` is true)
+    /// \param schemas_path         Path to the device model schemas (only needs to be set if `init_db` is true)
+    /// \param config_path          Path to the configuration file (only needs to be set if `init_db` is true)
+    /// \param init_db              True to initialize the database
+    ///
+    explicit DeviceModelStorageSqlite(const fs::path& db_path, const std::filesystem::path& migration_files_path,
+                                      const std::filesystem::path& schemas_path,
+                                      const std::filesystem::path& config_path, const bool init_db);
+
+    /// \brief Opens SQLite connection at given \p db_path
+    ///
+    /// Will not initialize the database.
+    ///
+    /// \param db_path              Path to database
+    ///
     explicit DeviceModelStorageSqlite(const fs::path& db_path);
     ~DeviceModelStorageSqlite() = default;
 
@@ -38,7 +57,8 @@ class DeviceModelStorageSqlite : public DeviceModelStorage {
                                                            const std::optional<AttributeEnum>& attribute_enum) final;
 
     bool set_variable_attribute_value(const Component& component_id, const Variable& variable_id,
-                                      const AttributeEnum& attribute_enum, const std::string& value) final;
+                                      const AttributeEnum& attribute_enum, const std::string& value,
+                                      const std::string& source) final;
 
     std::optional<VariableMonitoringMeta> set_monitoring_data(const SetMonitoringData& data,
                                                               const VariableMonitorType type) final;