charge_point_callbacks.hpp

#pragma once
 
#include <cstdint>
#include <memory>
 
#include <ocpp/v2/connectivity_manager.hpp>
#include <ocpp/v2/device_model.hpp>
 
#include <ocpp/v2/messages/BootNotification.hpp>
#include <ocpp/v2/messages/ClearDisplayMessage.hpp>
#include <ocpp/v2/messages/DataTransfer.hpp>
#include <ocpp/v2/messages/GetDisplayMessages.hpp>
#include <ocpp/v2/messages/GetLog.hpp>
#include <ocpp/v2/messages/RequestStartTransaction.hpp>
#include <ocpp/v2/messages/ReserveNow.hpp>
#include <ocpp/v2/messages/SetDisplayMessage.hpp>
#include <ocpp/v2/messages/TransactionEvent.hpp>
#include <ocpp/v2/messages/UnlockConnector.hpp>
#include <ocpp/v2/messages/UpdateFirmware.hpp>
 
namespace ocpp::v2 {
struct Callbacks {
 
 
    bool all_callbacks_valid(std::shared_ptr<DeviceModel> device_model) const;
 
    std::function<bool(const std::optional<const int32_t> evse_id, const ResetEnum& reset_type)>
        is_reset_allowed_callback;
    std::function<void(const std::optional<const int32_t> evse_id, const ResetEnum& reset_type)> reset_callback;
    std::function<RequestStartStopStatusEnum(const int32_t evse_id, const ReasonEnum& stop_reason)>
        stop_transaction_callback;
    std::function<void(const int32_t evse_id)> pause_charging_callback;
 
    std::optional<std::function<void(const OperationalStatusEnum new_status)>>
        cs_effective_operative_status_changed_callback;
 
    std::optional<std::function<void(const int32_t evse_id, const OperationalStatusEnum new_status)>>
        evse_effective_operative_status_changed_callback;
 
    std::function<void(const int32_t evse_id, const int32_t connector_id, const OperationalStatusEnum new_status)>
        connector_effective_operative_status_changed_callback;
 
    std::function<GetLogResponse(const GetLogRequest& request)> get_log_request_callback;
    std::function<UnlockConnectorResponse(const int32_t evse_id, const int32_t connecor_id)> unlock_connector_callback;
    // callback to be called when the request can be accepted. authorize_remote_start indicates if Authorize.req needs
    // to follow or not
    std::function<RequestStartStopStatusEnum(const RequestStartTransactionRequest& request,
                                             const bool authorize_remote_start)>
        remote_start_transaction_callback;
 
    std::function<ocpp::ReservationCheckStatus(const int32_t evse_id, const CiString<36> idToken,
                                               const std::optional<CiString<36>> groupIdToken)>
        is_reservation_for_token_callback;
    std::function<UpdateFirmwareResponse(const UpdateFirmwareRequest& request)> update_firmware_request_callback;
    // callback to be called when a variable has been changed by the CSMS
    std::optional<std::function<void(const SetVariableData& set_variable_data)>> variable_changed_callback;
    // callback is called when receiving a SetNetworkProfile.req from the CSMS
    std::optional<std::function<SetNetworkProfileStatusEnum(
        const int32_t configuration_slot, const NetworkConnectionProfile& network_connection_profile)>>
        validate_network_profile_callback;
    std::optional<ConfigureNetworkConnectionProfileCallback> configure_network_connection_profile_callback;
    std::optional<std::function<void(const ocpp::DateTime& currentTime)>> time_sync_callback;
 
    std::optional<std::function<void(const std::string& message, MessageDirection direction)>> ocpp_messages_callback;
 
    std::function<void(const CiString<50>& event_type, const std::optional<CiString<255>>& tech_info)>
        security_event_callback;
 
    std::function<void()> set_charging_profiles_callback;
 
    std::optional<std::function<void(const ocpp::v2::BootNotificationResponse& boot_notification_response)>>
        boot_notification_callback;
 
    std::optional<std::function<std::string(const std::optional<CertificateHashDataType> customer_certificate,
                                            const std::optional<IdToken> id_token,
                                            const std::optional<CiString<64>> customer_identifier)>>
        get_customer_information_callback;
 
    std::optional<std::function<void(const std::optional<CertificateHashDataType> customer_certificate,
                                     const std::optional<IdToken> id_token,
                                     const std::optional<CiString<64>> customer_identifier)>>
        clear_customer_information_callback;
 
    std::optional<std::function<void()>> all_connectors_unavailable_callback;
 
    std::optional<std::function<DataTransferResponse(const DataTransferRequest& request)>> data_transfer_callback;
 
    std::optional<std::function<void(const TransactionEventRequest& transaction_event)>> transaction_event_callback;
 
    std::optional<std::function<void(const TransactionEventRequest& transaction_event,
                                     const TransactionEventResponse& transaction_event_response)>>
        transaction_event_response_callback;
 
    std::optional<std::function<void(const bool is_connected, const int configuration_slot,
                                     const NetworkConnectionProfile& network_connection_profile)>>
        connection_state_changed_callback;
 
    std::optional<std::function<std::vector<DisplayMessage>(const GetDisplayMessagesRequest& request)>>
        get_display_message_callback;
    std::optional<std::function<SetDisplayMessageResponse(const std::vector<DisplayMessage>& display_messages)>>
        set_display_message_callback;
    std::optional<std::function<ClearDisplayMessageResponse(const ClearDisplayMessageRequest& request)>>
        clear_display_message_callback;
 
    std::optional<std::function<void(const RunningCost& running_cost, const uint32_t number_of_decimals,
                                     std::optional<std::string> currency_code)>>
        set_running_cost_callback;
 
    std::optional<std::function<ReserveNowStatusEnum(const ReserveNowRequest& request)>> reserve_now_callback;
    std::optional<std::function<bool(const int32_t reservationId)>> cancel_reservation_callback;
 
 
};
} // namespace ocpp::v2