init_device_model_db.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
// Copyright Pionix GmbH and Contributors to EVerest
 
 
#pragma once
 
#include <filesystem>
 
#include <ocpp/common/database/database_handler_common.hpp>
#include <ocpp/v2/device_model_storage_interface.hpp>
 
namespace ocpp::v2 {
struct ComponentKey {
    std::optional<uint64_t> db_id;       
    std::string name;                    
    std::optional<std::string> instance; 
    std::optional<int32_t> evse_id;      
    std::optional<int32_t> connector_id; 
    std::vector<std::string> required;   
 
    friend bool operator<(const ComponentKey& l, const ComponentKey& r);
};
 
struct DbVariableAttribute {
    std::optional<uint64_t> db_id;           
    std::optional<std::string> value_source; 
    VariableAttribute variable_attribute;    
};
 
struct DeviceModelVariable {
    std::optional<uint64_t> db_id;
    std::optional<uint64_t> variable_characteristics_db_id;
    std::string name;
    VariableCharacteristics characteristics;
    std::vector<DbVariableAttribute> attributes;
    bool required;
    std::optional<std::string> instance;
    std::optional<std::string> default_actual_value;
    std::vector<VariableMonitoringMeta> monitors;
    std::optional<std::string> source;
};
 
void from_json(const json& j, ComponentKey& c);
 
void from_json(const json& j, DeviceModelVariable& c);
 
void from_json(const json& j, VariableMonitoringMeta& c);
 
class InitDeviceModelDbError : public std::exception {
public:
    [[nodiscard]] const char* what() const noexcept override {
        return this->reason.c_str();
    }
    explicit InitDeviceModelDbError(std::string msg) {
        this->reason = std::move(msg);
    }
    explicit InitDeviceModelDbError(const char* msg) {
        this->reason = std::string(msg);
    }
 
private:
    std::string reason;
};
 
class InitDeviceModelDb : public common::DatabaseHandlerCommon {
private: // Members
    const std::filesystem::path database_path;
    bool database_exists;
 
public:
    InitDeviceModelDb(const std::filesystem::path& database_path, const std::filesystem::path& migration_files_path);
 
    virtual ~InitDeviceModelDb();
 
    void initialize_database(const std::filesystem::path& config_path, const bool delete_db_if_exists);
 
private: // Functions
    void execute_init_sql(const bool delete_db_if_exists);
 
    std::vector<std::filesystem::path> get_component_config_from_directory(const std::filesystem::path& directory);
 
    std::map<ComponentKey, std::vector<DeviceModelVariable>>
    get_all_component_configs(const std::filesystem::path& directory);
 
    void insert_components(const std::map<ComponentKey, std::vector<DeviceModelVariable>>& components,
                           const std::map<ComponentKey, std::vector<DeviceModelVariable>>& existing_components);
 
    void insert_component(const ComponentKey& component_key,
                          const std::vector<DeviceModelVariable>& component_variables);
 
    std::map<ComponentKey, std::vector<DeviceModelVariable>>
    read_component_config(const std::vector<std::filesystem::path>& components_config_path);
 
    std::vector<DeviceModelVariable> get_all_component_properties(const json& component_properties,
                                                                  std::vector<std::string> required_properties);
 
    void insert_variable_characteristics(const VariableCharacteristics& characteristics, const int64_t& variable_id);
 
    void update_variable_characteristics(const VariableCharacteristics& characteristics,
                                         const int64_t& characteristics_id, const int64_t& variable_id);
 
    void insert_variable(const DeviceModelVariable& variable, const uint64_t& component_id);
 
    void update_variable(const DeviceModelVariable& variable, const DeviceModelVariable& db_variable,
                         const uint64_t component_id);
 
    void delete_variable(const DeviceModelVariable& variable);
 
    void insert_attribute(const VariableAttribute& attribute, const uint64_t& variable_id,
                          const std::optional<std::string>& default_actual_value);
 
    void insert_attributes(const std::vector<DbVariableAttribute>& attributes, const uint64_t& variable_id,
                           const std::optional<std::string>& default_actual_value);
 
    void update_attributes(const std::vector<DbVariableAttribute>& new_attributes,
                           const std::vector<DbVariableAttribute>& db_attributes, const uint64_t& variable_id,
                           const std::optional<std::string>& default_actual_value);
 
    void update_attribute(const VariableAttribute& attribute, const DbVariableAttribute& db_attribute,
                          const std::optional<std::string>& default_actual_value);
 
    void delete_attribute(const DbVariableAttribute& attribute);
 
    bool insert_variable_attribute_value(const int64_t& variable_attribute_id,
                                         const std::string& variable_attribute_value,
                                         const bool warn_source_not_default);
 
    void insert_variable_monitor(const VariableMonitoringMeta& monitor, const int64_t& variable_id);
 
    void insert_variable_monitors(const std::vector<VariableMonitoringMeta>& monitors, const int64_t& variable_id);
 
    void update_variable_monitor(const VariableMonitoringMeta& new_monitor, const VariableMonitoringMeta& db_monitor,
                                 const int64_t& variable_id);
 
    void update_variable_monitors(const std::vector<VariableMonitoringMeta>& new_monitors,
                                  const std::vector<VariableMonitoringMeta>& db_monitors, const int64_t& variable_id);
 
    void delete_variable_monitor(const VariableMonitoringMeta& monitor, const int64_t& variable_id);
 
    std::map<ComponentKey, std::vector<DeviceModelVariable>> get_all_components_from_db();
 
    std::optional<std::pair<ComponentKey, std::vector<DeviceModelVariable>>>
    component_exists_in_db(const std::map<ComponentKey, std::vector<DeviceModelVariable>>& db_components,
                           const ComponentKey& component);
 
    bool component_exists_in_config(const std::map<ComponentKey, std::vector<DeviceModelVariable>>& component_config,
                                    const ComponentKey& component);
 
    void remove_not_existing_components_from_db(
        const std::map<ComponentKey, std::vector<DeviceModelVariable>>& component_config,
        const std::map<ComponentKey, std::vector<DeviceModelVariable>>& db_components);
 
    bool remove_component_from_db(const ComponentKey& component);
 
    void
    update_component_variables(const std::pair<ComponentKey, std::vector<DeviceModelVariable>>& db_component_variables,
                               const std::vector<DeviceModelVariable>& variables);
 
    std::vector<DbVariableAttribute> get_variable_attributes_from_db(const uint64_t& variable_id);
 
    std::vector<VariableMonitoringMeta> get_variable_monitors_from_db(const uint64_t& variable_id);
 
protected: // Functions
    // DatabaseHandlerCommon interface
    virtual void init_sql() override;
};
} // namespace ocpp::v2