database_handler.hpp

// SPDX-License-Identifier: Apache-2.0
// Copyright 2020 - 2023 Pionix GmbH and Contributors to EVerest
#ifndef OCPP_V2_DATABASE_HANDLER_HPP
#define OCPP_V2_DATABASE_HANDLER_HPP
 
#include "ocpp/v2/types.hpp"
#include "sqlite3.h"
#include <memory>
#include <ocpp/common/support_older_cpp_versions.hpp>
 
#include <ocpp/common/database/database_connection.hpp>
#include <ocpp/common/database/database_handler_common.hpp>
#include <ocpp/v2/ocpp_types.hpp>
#include <ocpp/v2/transaction.hpp>
 
#include <everest/logging.hpp>
 
namespace ocpp {
namespace v2 {
 
struct AuthorizationCacheEntry {
    IdTokenInfo id_token_info;
    DateTime last_used;
};
 
class DatabaseHandlerInterface {
public:
    virtual ~DatabaseHandlerInterface() = default;
 
    // Authorization cache management
 
    virtual void authorization_cache_insert_entry(const std::string& id_token_hash,
                                                  const IdTokenInfo& id_token_info) = 0;
 
    virtual void authorization_cache_update_last_used(const std::string& id_token_hash) = 0;
 
    virtual std::optional<AuthorizationCacheEntry> authorization_cache_get_entry(const std::string& id_token_hash) = 0;
 
    virtual void authorization_cache_delete_entry(const std::string& id_token_hash) = 0;
 
    virtual void authorization_cache_delete_nr_of_oldest_entries(size_t nr_to_remove) = 0;
 
    virtual void
    authorization_cache_delete_expired_entries(std::optional<std::chrono::seconds> auth_cache_lifetime) = 0;
 
    virtual void authorization_cache_clear() = 0;
 
    virtual size_t authorization_cache_get_binary_size() = 0;
 
    // Availability
 
    virtual void insert_cs_availability(OperationalStatusEnum operational_status, bool replace) = 0;
    virtual OperationalStatusEnum get_cs_availability() = 0;
 
    virtual void insert_evse_availability(int32_t evse_id, OperationalStatusEnum operational_status, bool replace) = 0;
    virtual OperationalStatusEnum get_evse_availability(int32_t evse_id) = 0;
 
    virtual void insert_connector_availability(int32_t evse_id, int32_t connector_id,
                                               OperationalStatusEnum operational_status, bool replace) = 0;
    virtual OperationalStatusEnum get_connector_availability(int32_t evse_id, int32_t connector_id) = 0;
 
    // Local authorization list management
 
    virtual void insert_or_update_local_authorization_list_version(int32_t version) = 0;
 
    virtual int32_t get_local_authorization_list_version() = 0;
 
    virtual void insert_or_update_local_authorization_list_entry(const IdToken& id_token,
                                                                 const IdTokenInfo& id_token_info) = 0;
 
    virtual void
    insert_or_update_local_authorization_list(const std::vector<v2::AuthorizationData>& local_authorization_list) = 0;
 
    virtual void delete_local_authorization_list_entry(const IdToken& id_token) = 0;
 
    virtual std::optional<v2::IdTokenInfo> get_local_authorization_list_entry(const IdToken& id_token) = 0;
 
    virtual void clear_local_authorization_list() = 0;
 
    virtual int32_t get_local_authorization_list_number_of_entries() = 0;
 
    // Transaction metervalues
 
    virtual void transaction_metervalues_insert(const std::string& transaction_id, const MeterValue& meter_value) = 0;
 
    virtual std::vector<MeterValue> transaction_metervalues_get_all(const std::string& transaction_id) = 0;
 
    virtual void transaction_metervalues_clear(const std::string& transaction_id) = 0;
 
    // transactions
 
    virtual void transaction_insert(const EnhancedTransaction& transaction, int32_t evse_id) = 0;
 
    virtual std::unique_ptr<EnhancedTransaction> transaction_get(const int32_t evse_id) = 0;
 
    virtual void transaction_update_seq_no(const std::string& transaction_id, int32_t seq_no) = 0;
 
    virtual void transaction_update_charging_state(const std::string& transaction_id,
                                                   const ChargingStateEnum charging_state) = 0;
 
    virtual void transaction_update_id_token_sent(const std::string& transaction_id, bool id_token_sent) = 0;
 
    virtual void transaction_delete(const std::string& transaction_id) = 0;
 
 
    virtual void insert_or_update_charging_profile(
        const int evse_id, const v2::ChargingProfile& profile,
        const ChargingLimitSourceEnum charging_limit_source = ChargingLimitSourceEnum::CSO) = 0;
 
    virtual bool delete_charging_profile(const int profile_id) = 0;
 
    virtual void delete_charging_profile_by_transaction_id(const std::string& transaction_id) = 0;
 
    virtual bool clear_charging_profiles() = 0;
 
    virtual bool clear_charging_profiles_matching_criteria(const std::optional<int32_t> profile_id,
                                                           const std::optional<ClearChargingProfile>& criteria) = 0;
 
    virtual std::vector<ReportedChargingProfile>
    get_charging_profiles_matching_criteria(const std::optional<int32_t> evse_id,
                                            const ChargingProfileCriterion& criteria) = 0;
 
    virtual std::vector<v2::ChargingProfile> get_charging_profiles_for_evse(const int evse_id) = 0;
 
    virtual std::vector<v2::ChargingProfile> get_all_charging_profiles() = 0;
 
    virtual std::map<int32_t, std::vector<v2::ChargingProfile>> get_all_charging_profiles_group_by_evse() = 0;
 
    virtual ChargingLimitSourceEnum get_charging_limit_source_for_profile(const int profile_id) = 0;
 
    virtual std::unique_ptr<common::SQLiteStatementInterface> new_statement(const std::string& sql) = 0;
};
 
class DatabaseHandler : public DatabaseHandlerInterface, public common::DatabaseHandlerCommon {
private:
    void init_sql() override;
 
    void inintialize_enum_tables();
    void init_enum_table_inner(const std::string& table_name, const int begin, const int end,
                               std::function<std::string(int)> conversion);
    template <typename T>
    void init_enum_table(const std::string& table_name, T begin, T end, std::function<std::string(T)> conversion);
 
    // Availability management (internal helpers)
    // Setting evse_id to 0 addresses the whole CS, setting evse_id > 0 and connector_id=0 addresses a whole EVSE
    void insert_availability(int32_t evse_id, int32_t connector_id, OperationalStatusEnum operational_status,
                             bool replace);
    OperationalStatusEnum get_availability(int32_t evse_id, int32_t connector_id);
 
public:
    DatabaseHandler(std::unique_ptr<common::DatabaseConnectionInterface> database,
                    const fs::path& sql_migration_files_path);
 
    // Authorization cache management
    void authorization_cache_insert_entry(const std::string& id_token_hash, const IdTokenInfo& id_token_info) override;
    void authorization_cache_update_last_used(const std::string& id_token_hash) override;
    std::optional<AuthorizationCacheEntry> authorization_cache_get_entry(const std::string& id_token_hash) override;
    void authorization_cache_delete_entry(const std::string& id_token_hash) override;
    void authorization_cache_delete_nr_of_oldest_entries(size_t nr_to_remove) override;
    void authorization_cache_delete_expired_entries(std::optional<std::chrono::seconds> auth_cache_lifetime) override;
    void authorization_cache_clear() override;
    size_t authorization_cache_get_binary_size() override;
 
    // Availability
    virtual void insert_cs_availability(OperationalStatusEnum operational_status, bool replace) override;
    virtual OperationalStatusEnum get_cs_availability() override;
    virtual void insert_evse_availability(int32_t evse_id, OperationalStatusEnum operational_status,
                                          bool replace) override;
    virtual OperationalStatusEnum get_evse_availability(int32_t evse_id) override;
    virtual void insert_connector_availability(int32_t evse_id, int32_t connector_id,
                                               OperationalStatusEnum operational_status, bool replace) override;
    virtual OperationalStatusEnum get_connector_availability(int32_t evse_id, int32_t connector_id) override;
 
    // Local authorization list management
    void insert_or_update_local_authorization_list_version(int32_t version) override;
    int32_t get_local_authorization_list_version() override;
    void insert_or_update_local_authorization_list_entry(const IdToken& id_token,
                                                         const IdTokenInfo& id_token_info) override;
    void insert_or_update_local_authorization_list(
        const std::vector<v2::AuthorizationData>& local_authorization_list) override;
    void delete_local_authorization_list_entry(const IdToken& id_token) override;
    std::optional<v2::IdTokenInfo> get_local_authorization_list_entry(const IdToken& id_token) override;
    void clear_local_authorization_list() override;
    int32_t get_local_authorization_list_number_of_entries() override;
 
    // Transaction metervalues
    void transaction_metervalues_insert(const std::string& transaction_id, const MeterValue& meter_value) override;
    std::vector<MeterValue> transaction_metervalues_get_all(const std::string& transaction_id) override;
    void transaction_metervalues_clear(const std::string& transaction_id) override;
 
    // transactions
    void transaction_insert(const EnhancedTransaction& transaction, int32_t evse_id) override;
    std::unique_ptr<EnhancedTransaction> transaction_get(const int32_t evse_id) override;
    void transaction_update_seq_no(const std::string& transaction_id, int32_t seq_no) override;
    void transaction_update_charging_state(const std::string& transaction_id,
                                           const ChargingStateEnum charging_state) override;
    void transaction_update_id_token_sent(const std::string& transaction_id, bool id_token_sent) override;
    void transaction_delete(const std::string& transaction_id) override;
 
    void insert_or_update_charging_profile(
        const int evse_id, const v2::ChargingProfile& profile,
        const ChargingLimitSourceEnum charging_limit_source = ChargingLimitSourceEnum::CSO) override;
    bool delete_charging_profile(const int profile_id) override;
    void delete_charging_profile_by_transaction_id(const std::string& transaction_id) override;
    bool clear_charging_profiles() override;
    bool clear_charging_profiles_matching_criteria(const std::optional<int32_t> profile_id,
                                                   const std::optional<ClearChargingProfile>& criteria) override;
    std::vector<ReportedChargingProfile>
    get_charging_profiles_matching_criteria(const std::optional<int32_t> evse_id,
                                            const ChargingProfileCriterion& criteria) override;
    std::vector<v2::ChargingProfile> get_charging_profiles_for_evse(const int evse_id) override;
    std::vector<v2::ChargingProfile> get_all_charging_profiles() override;
    virtual std::map<int32_t, std::vector<v2::ChargingProfile>> get_all_charging_profiles_group_by_evse() override;
    ChargingLimitSourceEnum get_charging_limit_source_for_profile(const int profile_id) override;
 
    std::unique_ptr<common::SQLiteStatementInterface> new_statement(const std::string& sql) override;
};
 
} // namespace v2
} // namespace ocpp
 
#endif