charge_point.hpp

// SPDX-License-Identifier: Apache-2.0
// Copyright Pionix GmbH and Contributors to EVerest
 
#pragma once
 
#include <future>
#include <memory>
#include <set>
 
#include <ocpp/common/message_dispatcher.hpp>
 
#include <ocpp/common/charging_station_base.hpp>
 
#include <ocpp/v2/average_meter_values.hpp>
#include <ocpp/v2/charge_point_callbacks.hpp>
#include <ocpp/v2/ocpp_enums.hpp>
#include <ocpp/v2/ocpp_types.hpp>
#include <ocpp/v2/ocsp_updater.hpp>
#include <ocpp/v2/types.hpp>
#include <ocpp/v2/utils.hpp>
 
#include <ocpp/v2/messages/Authorize.hpp>
#include <ocpp/v2/messages/DataTransfer.hpp>
#include <ocpp/v2/messages/Get15118EVCertificate.hpp>
#include <ocpp/v2/messages/GetCompositeSchedule.hpp>
 
#include "component_state_manager.hpp"
 
namespace ocpp {
namespace v2 {
 
class AuthorizationInterface;
class AvailabilityInterface;
class DataTransferInterface;
class DiagnosticsInterface;
class DisplayMessageInterface;
class FirmwareUpdateInterface;
class MeterValuesInterface;
class ProvisioningInterface;
class RemoteTransactionControlInterface;
class ReservationInterface;
class SecurityInterface;
class SmartChargingInterface;
class TariffAndCostInterface;
class TransactionInterface;
 
class DatabaseHandler;
class DeviceModel;
class DeviceModelStorageInterface;
class EvseManager;
 
struct FunctionalBlockContext;
 
class UnexpectedMessageTypeFromCSMS : public std::runtime_error {
    using std::runtime_error::runtime_error;
};
 
class ChargePointInterface {
public:
    virtual ~ChargePointInterface() = default;
 
    virtual void start(BootReasonEnum bootreason = BootReasonEnum::PowerUp, bool start_connecting = true) = 0;
 
    virtual void stop() = 0;
 
    virtual void connect_websocket(std::optional<int32_t> network_profile_slot = std::nullopt) = 0;
 
    virtual void disconnect_websocket() = 0;
 
 
 
    virtual void on_network_disconnected(OCPPInterfaceEnum ocpp_interface) = 0;
 
    virtual void on_firmware_update_status_notification(int32_t request_id,
                                                        const FirmwareStatusEnum& firmware_update_status) = 0;
 
    virtual void on_session_started(const int32_t evse_id, const int32_t connector_id) = 0;
 
    virtual Get15118EVCertificateResponse
    on_get_15118_ev_certificate_request(const Get15118EVCertificateRequest& request) = 0;
 
    virtual void
    on_transaction_started(const int32_t evse_id, const int32_t connector_id, const std::string& session_id,
                           const DateTime& timestamp, const TriggerReasonEnum trigger_reason,
                           const MeterValue& meter_start, const std::optional<IdToken>& id_token,
                           const std::optional<IdToken>& group_id_token, const std::optional<int32_t>& reservation_id,
                           const std::optional<int32_t>& remote_start_id, const ChargingStateEnum charging_state) = 0;
 
    virtual void on_transaction_finished(const int32_t evse_id, const DateTime& timestamp, const MeterValue& meter_stop,
                                         const ReasonEnum reason, const TriggerReasonEnum trigger_reason,
                                         const std::optional<IdToken>& id_token,
                                         const std::optional<std::string>& signed_meter_value,
                                         const ChargingStateEnum charging_state) = 0;
 
    virtual void on_session_finished(const int32_t evse_id, const int32_t connector_id) = 0;
 
    virtual void on_authorized(const int32_t evse_id, const int32_t connector_id, const IdToken& id_token) = 0;
 
    virtual void on_meter_value(const int32_t evse_id, const MeterValue& meter_value) = 0;
 
    virtual void on_unavailable(const int32_t evse_id, const int32_t connector_id) = 0;
 
    virtual void on_enabled(const int32_t evse_id, const int32_t connector_id) = 0;
 
    virtual void on_faulted(const int32_t evse_id, const int32_t connector_id) = 0;
 
    virtual void on_fault_cleared(const int32_t evse_id, const int32_t connector_id) = 0;
 
    virtual void on_reserved(const int32_t evse_id, const int32_t connector_id) = 0;
 
    virtual void on_reservation_cleared(const int32_t evse_id, const int32_t connector_id) = 0;
 
    virtual bool
    on_charging_state_changed(const uint32_t evse_id, const ChargingStateEnum charging_state,
                              const TriggerReasonEnum trigger_reason = TriggerReasonEnum::ChargingStateChanged) = 0;
 
    virtual std::optional<std::string> get_evse_transaction_id(int32_t evse_id) = 0;
 
    virtual void on_event(const std::vector<EventData>& events) = 0;
 
    virtual void on_log_status_notification(UploadLogStatusEnum status, int32_t requestId) = 0;
 
    // \brief Notifies chargepoint that a SecurityEvent has occured. This will send a SecurityEventNotification.req to
    // the
    virtual void on_security_event(const CiString<50>& event_type, const std::optional<CiString<255>>& tech_info,
                                   const std::optional<bool>& critical = std::nullopt,
                                   const std::optional<DateTime>& timestamp = std::nullopt) = 0;
 
    virtual void on_variable_changed(const SetVariableData& set_variable_data) = 0;
 
    virtual void on_reservation_status(const int32_t reservation_id, const ReservationUpdateStatusEnum status) = 0;
 
 
 
    virtual AuthorizeResponse validate_token(const IdToken id_token, const std::optional<CiString<5500>>& certificate,
                                             const std::optional<std::vector<OCSPRequestData>>& ocsp_request_data) = 0;
 
    virtual std::optional<DataTransferResponse> data_transfer_req(const CiString<255>& vendorId,
                                                                  const std::optional<CiString<50>>& messageId,
                                                                  const std::optional<json>& data) = 0;
 
    virtual std::optional<DataTransferResponse> data_transfer_req(const DataTransferRequest& request) = 0;
 
    virtual void set_message_queue_resume_delay(std::chrono::seconds delay) = 0;
 
    virtual std::vector<GetVariableResult>
    get_variables(const std::vector<GetVariableData>& get_variable_data_vector) = 0;
 
    virtual std::map<SetVariableData, SetVariableResult>
    set_variables(const std::vector<SetVariableData>& set_variable_data_vector, const std::string& source) = 0;
 
    virtual GetCompositeScheduleResponse get_composite_schedule(const GetCompositeScheduleRequest& request) = 0;
 
    virtual std::optional<CompositeSchedule> get_composite_schedule(int32_t evse_id, std::chrono::seconds duration,
                                                                    ChargingRateUnitEnum unit) = 0;
 
    virtual std::vector<CompositeSchedule> get_all_composite_schedules(const int32_t duration,
                                                                       const ChargingRateUnitEnum& unit) = 0;
 
    virtual std::optional<NetworkConnectionProfile>
    get_network_connection_profile(const int32_t configuration_slot) const = 0;
 
    virtual std::optional<int> get_priority_from_configuration_slot(const int configuration_slot) const = 0;
 
    virtual const std::vector<int>& get_network_connection_slots() const = 0;
};
 
class ChargePoint : public ChargePointInterface, private ocpp::ChargingStationBase {
 
private:
    std::shared_ptr<DeviceModel> device_model;
    std::unique_ptr<EvseManager> evse_manager;
    std::unique_ptr<ConnectivityManager> connectivity_manager;
 
    std::unique_ptr<MessageDispatcherInterface<MessageType>> message_dispatcher;
 
    // Functional blocks
    std::unique_ptr<FunctionalBlockContext> functional_block_context;
    std::unique_ptr<DataTransferInterface> data_transfer;
    std::unique_ptr<ReservationInterface> reservation;
    std::unique_ptr<AvailabilityInterface> availability;
    std::unique_ptr<AuthorizationInterface> authorization;
    std::unique_ptr<DiagnosticsInterface> diagnostics;
    std::unique_ptr<SecurityInterface> security;
    std::unique_ptr<DisplayMessageInterface> display_message;
    std::unique_ptr<FirmwareUpdateInterface> firmware_update;
    std::unique_ptr<MeterValuesInterface> meter_values;
    std::unique_ptr<SmartChargingInterface> smart_charging;
    std::unique_ptr<TariffAndCostInterface> tariff_and_cost;
    std::unique_ptr<TransactionInterface> transaction;
    std::unique_ptr<ProvisioningInterface> provisioning;
    std::unique_ptr<RemoteTransactionControlInterface> remote_transaction_control;
 
    // utility
    std::shared_ptr<MessageQueue<v2::MessageType>> message_queue;
    std::shared_ptr<DatabaseHandler> database_handler;
 
    // states
    std::atomic<RegistrationStatusEnum> registration_status;
    std::atomic<UploadLogStatusEnum> upload_log_status;
    std::atomic<int32_t> upload_log_status_id;
    BootReasonEnum bootreason;
    bool skip_invalid_csms_certificate_notifications;
 
    std::shared_ptr<ComponentStateManagerInterface> component_state_manager;
 
    // store the connector status
    struct EvseConnectorPair {
        int32_t evse_id;
        int32_t connector_id;
 
        // Define a comparison operator for the struct
        bool operator<(const EvseConnectorPair& other) const {
            // Compare based on name, then age
            if (evse_id != other.evse_id) {
                return evse_id < other.evse_id;
            }
            return connector_id < other.connector_id;
        }
    };
 
    std::chrono::time_point<std::chrono::steady_clock> time_disconnected;
 
    // callback struct
    Callbacks callbacks;
 
    OcspUpdater ocsp_updater;
 
    std::chrono::seconds message_queue_resume_delay = std::chrono::seconds(0);
 
    // internal helper functions
    void initialize(const std::map<int32_t, int32_t>& evse_connector_structure, const std::string& message_log_path);
    void websocket_connected_callback(const int configuration_slot,
                                      const NetworkConnectionProfile& network_connection_profile);
    void websocket_disconnected_callback(const int configuration_slot,
                                         const NetworkConnectionProfile& network_connection_profile);
    void websocket_connection_failed(ConnectionFailedReason reason);
    void update_dm_availability_state(const int32_t evse_id, const int32_t connector_id,
                                      const ConnectorStatusEnum status);
 
    void message_callback(const std::string& message);
 
    bool is_offline();
 
    void configure_message_logging_format(const std::string& message_log_path);
 
    /* OCPP message requests */
 
    /* OCPP message handlers */
 
    // Generates async sending callbacks
    template <class RequestType, class ResponseType>
    std::function<ResponseType(RequestType)> send_callback(MessageType expected_response_message_type) {
        return [this, expected_response_message_type](auto request) {
            const auto enhanced_response =
                this->message_dispatcher->dispatch_call_async(ocpp::Call<RequestType>(request)).get();
            if (enhanced_response.messageType != expected_response_message_type) {
                throw UnexpectedMessageTypeFromCSMS(
                    std::string("Got unexpected message type from CSMS, expected: ") +
                    conversions::messagetype_to_string(expected_response_message_type) +
                    ", got: " + conversions::messagetype_to_string(enhanced_response.messageType));
            }
            ocpp::CallResult<ResponseType> call_result = enhanced_response.message;
            return call_result.msg;
        };
    }
 
protected:
    void handle_message(const EnhancedMessage<v2::MessageType>& message);
    void clear_invalid_charging_profiles();
 
public:
 
 
    ChargePoint(const std::map<int32_t, int32_t>& evse_connector_structure, std::shared_ptr<DeviceModel> device_model,
                std::shared_ptr<DatabaseHandler> database_handler,
                std::shared_ptr<MessageQueue<v2::MessageType>> message_queue, const std::string& message_log_path,
                const std::shared_ptr<EvseSecurity> evse_security, const Callbacks& callbacks);
 
    ChargePoint(const std::map<int32_t, int32_t>& evse_connector_structure,
                std::unique_ptr<DeviceModelStorageInterface> device_model_storage_interface,
                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);
 
    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_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);
 
 
 
    ~ChargePoint();
 
    void start(BootReasonEnum bootreason = BootReasonEnum::PowerUp, bool start_connecting = true) override;
 
    void stop() override;
 
    void connect_websocket(std::optional<int32_t> network_profile_slot = std::nullopt) override;
    virtual void disconnect_websocket() override;
 
    void on_network_disconnected(OCPPInterfaceEnum ocpp_interface) override;
 
    void on_firmware_update_status_notification(int32_t request_id,
                                                const FirmwareStatusEnum& firmware_update_status) override;
 
    void on_session_started(const int32_t evse_id, const int32_t connector_id) override;
 
    Get15118EVCertificateResponse
    on_get_15118_ev_certificate_request(const Get15118EVCertificateRequest& request) override;
 
    void on_transaction_started(const int32_t evse_id, const int32_t connector_id, const std::string& session_id,
                                const DateTime& timestamp, const TriggerReasonEnum trigger_reason,
                                const MeterValue& meter_start, const std::optional<IdToken>& id_token,
                                const std::optional<IdToken>& group_id_token,
                                const std::optional<int32_t>& reservation_id,
                                const std::optional<int32_t>& remote_start_id,
                                const ChargingStateEnum charging_state) override;
 
    void on_transaction_finished(const int32_t evse_id, const DateTime& timestamp, const MeterValue& meter_stop,
                                 const ReasonEnum reason, const TriggerReasonEnum trigger_reason,
                                 const std::optional<IdToken>& id_token,
                                 const std::optional<std::string>& signed_meter_value,
                                 const ChargingStateEnum charging_state) override;
 
    void on_session_finished(const int32_t evse_id, const int32_t connector_id) override;
 
    void on_authorized(const int32_t evse_id, const int32_t connector_id, const IdToken& id_token) override;
 
    void on_meter_value(const int32_t evse_id, const MeterValue& meter_value) override;
 
    void on_unavailable(const int32_t evse_id, const int32_t connector_id) override;
 
    void on_enabled(const int32_t evse_id, const int32_t connector_id) override;
 
    void on_faulted(const int32_t evse_id, const int32_t connector_id) override;
 
    void on_fault_cleared(const int32_t evse_id, const int32_t connector_id) override;
 
    void on_reserved(const int32_t evse_id, const int32_t connector_id) override;
 
    void on_reservation_cleared(const int32_t evse_id, const int32_t connector_id) override;
 
    bool on_charging_state_changed(
        const uint32_t evse_id, const ChargingStateEnum charging_state,
        const TriggerReasonEnum trigger_reason = TriggerReasonEnum::ChargingStateChanged) override;
 
    std::optional<std::string> get_evse_transaction_id(int32_t evse_id) override;
 
    AuthorizeResponse validate_token(const IdToken id_token, const std::optional<CiString<5500>>& certificate,
                                     const std::optional<std::vector<OCSPRequestData>>& ocsp_request_data) override;
 
    void on_event(const std::vector<EventData>& events) override;
 
    void on_log_status_notification(UploadLogStatusEnum status, int32_t requestId) override;
 
    void on_security_event(const CiString<50>& event_type, const std::optional<CiString<255>>& tech_info,
                           const std::optional<bool>& critical = std::nullopt,
                           const std::optional<DateTime>& timestamp = std::nullopt) override;
 
    void on_variable_changed(const SetVariableData& set_variable_data) override;
 
    void on_reservation_status(const int32_t reservation_id, const ReservationUpdateStatusEnum status) override;
 
    std::optional<DataTransferResponse> data_transfer_req(const CiString<255>& vendorId,
                                                          const std::optional<CiString<50>>& messageId,
                                                          const std::optional<json>& data) override;
 
    std::optional<DataTransferResponse> data_transfer_req(const DataTransferRequest& request) override;
 
    void set_message_queue_resume_delay(std::chrono::seconds delay) override {
        this->message_queue_resume_delay = delay;
    }
 
    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, const std::string& source) override;
    GetCompositeScheduleResponse get_composite_schedule(const GetCompositeScheduleRequest& request) override;
    std::optional<CompositeSchedule> get_composite_schedule(int32_t evse_id, std::chrono::seconds duration,
                                                            ChargingRateUnitEnum unit) override;
    std::vector<CompositeSchedule> get_all_composite_schedules(const int32_t duration,
                                                               const ChargingRateUnitEnum& unit) override;
 
    std::optional<NetworkConnectionProfile>
    get_network_connection_profile(const int32_t configuration_slot) const override;
 
    std::optional<int> get_priority_from_configuration_slot(const int configuration_slot) const override;
 
    const std::vector<int>& get_network_connection_slots() const override;
 
    void send_not_implemented_error(const MessageId unique_message_id, const MessageTypeId message_type_id);
 
    template <typename T>
    RequestDeviceModelResponse<T> request_value(const Component& component_id, const Variable& variable_id,
                                                const AttributeEnum& attribute_enum) {
        return this->device_model->request_value<T>(component_id, variable_id, attribute_enum);
    }
};
 
} // namespace v2
} // namespace ocpp