database_handler.hpp

// SPDX-License-Identifier: Apache-2.0
// Copyright 2020 - 2023 Pionix GmbH and Contributors to EVerest
#ifndef OCPP_V16_DATABASE_HANDLER_HPP
#define OCPP_V16_DATABASE_HANDLER_HPP
 
#include "sqlite3.h"
#include <fstream>
#include <iostream>
 
#include <ocpp/common/database/database_handler_common.hpp>
#include <ocpp/common/schemas.hpp>
#include <ocpp/common/support_older_cpp_versions.hpp>
#include <ocpp/common/types.hpp>
#include <ocpp/v16/ocpp_types.hpp>
#include <ocpp/v16/types.hpp>
 
namespace ocpp {
namespace v16 {
 
struct TransactionEntry {
    std::string session_id;
    int32_t connector;
    std::string id_tag_start;
    std::string time_start;
    int32_t meter_start;
    int32_t transaction_id;
    bool csms_ack;
    int32_t meter_last;
    std::string meter_last_time;
    std::string last_update;
    std::string start_transaction_message_id;
    std::optional<std::string> stop_transaction_message_id;
    std::optional<int32_t> reservation_id = std::nullopt;
    std::optional<std::string> parent_id_tag = std::nullopt;
    std::optional<int32_t> meter_stop = std::nullopt;
    std::optional<std::string> time_end = std::nullopt;
    std::optional<std::string> id_tag_end = std::nullopt;
    std::optional<std::string> stop_reason = std::nullopt;
};
 
class DatabaseHandler : public ocpp::common::DatabaseHandlerCommon {
private:
    const int32_t number_of_connectors;
 
    // Runs initialization script and initializes the CONNECTORS and AUTH_LIST_VERSION table.
    void init_sql() override;
    void init_connector_table();
 
public:
    DatabaseHandler(std::unique_ptr<common::DatabaseConnectionInterface> database,
                    const fs::path& sql_migration_files_path, int32_t number_of_connectors);
 
    // transactions
    void insert_transaction(const std::string& session_id, const int32_t transaction_id, const int32_t connector,
                            const std::string& id_tag_start, const std::string& time_start, const int32_t meter_start,
                            const bool csms_ack, const std::optional<int32_t> reservation_id,
                            const std::string& start_transaction_message_id);
 
    void update_transaction(const std::string& session_id, int32_t transaction_id,
                            std::optional<CiString<20>> parent_id_tag = std::nullopt);
 
    void update_transaction(const std::string& session_id, int32_t meter_stop, const std::string& time_end,
                            std::optional<CiString<20>> id_tag_end, std::optional<v16::Reason> stop_reason,
                            const std::string& stop_transaction_message_id);
 
    void update_transaction_csms_ack(const int32_t transaction_id);
 
    void update_start_transaction_message_id(const std::string& session_id,
                                             const std::string& start_transaction_message_id);
 
    void update_transaction_meter_value(const std::string& session_id, const int32_t value,
                                        const std::string& timestamp);
 
    std::vector<TransactionEntry> get_transactions(bool filter_incomplete = false);
 
    // authorization cache
    void insert_or_update_authorization_cache_entry(const CiString<20>& id_tag, const v16::IdTagInfo& id_tag_info);
 
    std::optional<v16::IdTagInfo> get_authorization_cache_entry(const CiString<20>& id_tag);
 
    void clear_authorization_cache();
 
    // connector availability
    void insert_or_update_connector_availability(int32_t connector, const v16::AvailabilityType& availability_type);
 
    void insert_or_update_connector_availability(const std::vector<int32_t>& connectors,
                                                 const v16::AvailabilityType& availability_type);
 
    v16::AvailabilityType get_connector_availability(int32_t connector);
 
    std::map<int32_t, v16::AvailabilityType> get_connector_availability();
 
    // local auth list management
 
    void insert_or_ignore_local_list_version(int32_t version);
 
    void insert_or_update_local_list_version(int32_t version);
 
    int32_t get_local_list_version();
 
    void insert_or_update_local_authorization_list_entry(const CiString<20>& id_tag, const v16::IdTagInfo& id_tag_info);
 
    void insert_or_update_local_authorization_list(std::vector<v16::LocalAuthorizationList> local_authorization_list);
 
    void delete_local_authorization_list_entry(const std::string& id_tag);
 
    std::optional<v16::IdTagInfo> get_local_authorization_list_entry(const CiString<20>& id_tag);
 
    void clear_local_authorization_list();
 
    int32_t get_local_authorization_list_number_of_entries();
 
    virtual void insert_or_update_charging_profile(const int connector_id, const v16::ChargingProfile& profile);
 
    virtual void delete_charging_profile(const int profile_id);
 
    void delete_charging_profiles();
 
    std::vector<v16::ChargingProfile> get_charging_profiles();
 
    int get_connector_id(const int profile_id);
 
    void insert_ocsp_update();
 
    std::optional<DateTime> get_last_ocsp_update();
};
 
} // namespace v16
} // namespace ocpp
 
#endif // OCPP_COMMON_DATABASE_HANDLER_HPP