component_state_manager.hpp

// SPDX-License-Identifier: Apache-2.0
// Copyright 2020 - 2023 Pionix GmbH and Contributors to EVerest
 
#pragma once
 
#include "database_handler.hpp"
#include <ocpp/v2/ocpp_enums.hpp>
 
namespace ocpp::v2 {
 
class EvseOutOfRangeException : public std::exception {
public:
    explicit EvseOutOfRangeException(int32_t id) : msg{"Evse with id " + std::to_string(id) + " does not exist"} {
    }
 
    ~EvseOutOfRangeException() noexcept override = default;
 
    const char* what() const noexcept override {
        return msg.c_str();
    }
 
private:
    std::string msg;
};
 
class ConnectorOutOfRangeException : public std::exception {
public:
    explicit ConnectorOutOfRangeException(int32_t connector_id, int32_t evse_id) :
        msg{"Connector with id " + std::to_string(connector_id) + " does not exist for evse with id " +
            std::to_string(evse_id)} {
    }
 
    ~ConnectorOutOfRangeException() noexcept override = default;
 
    const char* what() const noexcept override {
        return msg.c_str();
    }
 
private:
    std::string msg;
};
 
struct FullConnectorStatus {
    OperationalStatusEnum individual_operational_status;
    bool faulted;
    bool reserved;
    bool occupied;
    bool unavailable;
 
    ConnectorStatusEnum to_connector_status();
};
 
class ComponentStateManagerInterface {
public:
    virtual ~ComponentStateManagerInterface();
 
    virtual void set_cs_effective_availability_changed_callback(
        const std::function<void(const OperationalStatusEnum new_status)>& callback) = 0;
 
    virtual void set_evse_effective_availability_changed_callback(
        const std::function<void(const int32_t evse_id, const OperationalStatusEnum new_status)>& callback) = 0;
 
    virtual void set_connector_effective_availability_changed_callback(
        const std::function<void(const int32_t evse_id, const int32_t connector_id,
                                 const OperationalStatusEnum new_status)>& callback) = 0;
 
    virtual OperationalStatusEnum get_cs_individual_operational_status() = 0;
 
    virtual OperationalStatusEnum get_evse_individual_operational_status(int32_t evse_id) = 0;
 
    virtual OperationalStatusEnum get_connector_individual_operational_status(int32_t evse_id,
                                                                              int32_t connector_id) = 0;
 
    virtual OperationalStatusEnum get_cs_persisted_operational_status() = 0;
 
    virtual OperationalStatusEnum get_evse_persisted_operational_status(int32_t evse_id) = 0;
 
    virtual OperationalStatusEnum get_connector_persisted_operational_status(int32_t evse_id, int32_t connector_id) = 0;
 
    virtual void set_cs_individual_operational_status(OperationalStatusEnum new_status, bool persist) = 0;
 
    virtual void set_evse_individual_operational_status(int32_t evse_id, OperationalStatusEnum new_status,
                                                        bool persist) = 0;
 
    virtual void set_connector_individual_operational_status(int32_t evse_id, int32_t connector_id,
                                                             OperationalStatusEnum new_status, bool persist) = 0;
 
    virtual OperationalStatusEnum get_evse_effective_operational_status(int32_t evse_id) = 0;
 
    virtual OperationalStatusEnum get_connector_effective_operational_status(int32_t evse_id, int32_t connector_id) = 0;
 
    virtual ConnectorStatusEnum get_connector_effective_status(int32_t evse_id, int32_t connector_id) = 0;
 
    virtual void set_connector_occupied(int32_t evse_id, int32_t connector_id, bool is_occupied) = 0;
 
    virtual void set_connector_reserved(int32_t evse_id, int32_t connector_id, bool is_reserved) = 0;
 
    virtual void set_connector_faulted(int32_t evse_id, int32_t connector_id, bool is_faulted) = 0;
 
    virtual void set_connector_unavailable(int32_t evse_id, int32_t connector_id, bool is_unavailable) = 0;
 
    virtual void trigger_all_effective_availability_changed_callbacks() = 0;
 
    virtual void send_status_notification_all_connectors() = 0;
 
    virtual void send_status_notification_changed_connectors() = 0;
 
    virtual void send_status_notification_single_connector(int32_t evse_id, int32_t connector_id) = 0;
};
 
class ComponentStateManager : public ComponentStateManagerInterface {
private:
    std::shared_ptr<DatabaseHandler> database;
 
    OperationalStatusEnum cs_individual_status;
    std::vector<std::pair<OperationalStatusEnum, std::vector<FullConnectorStatus>>>
        evse_and_connector_individual_statuses;
 
    OperationalStatusEnum last_cs_effective_operational_status;
    std::vector<std::pair<OperationalStatusEnum, std::vector<OperationalStatusEnum>>>
        last_evse_and_connector_effective_operational_statuses;
 
    // We need to track this separately because the send_connector_status_notification_callback can fail
    std::vector<std::vector<ConnectorStatusEnum>> last_connector_reported_statuses;
 
    std::optional<std::function<void(const OperationalStatusEnum new_status)>>
        cs_effective_availability_changed_callback = std::nullopt;
 
    std::optional<std::function<void(const int32_t evse_id, const OperationalStatusEnum new_status)>>
        evse_effective_availability_changed_callback = std::nullopt;
 
    std::optional<
        std::function<void(const int32_t evse_id, const int32_t connector_id, const OperationalStatusEnum new_status)>>
        connector_effective_availability_changed_callback = std::nullopt;
 
    std::function<bool(const int32_t evse_id, const int32_t connector_id, const ConnectorStatusEnum new_status,
                       bool initiated_by_trigger_message)>
        send_connector_status_notification_callback;
 
    int32_t num_evses();
    int32_t num_connectors(int32_t evse_id);
 
    void check_evse_id(int32_t evse_id);
    void check_evse_and_connector_id(int32_t evse_id, int32_t connector_id);
 
    OperationalStatusEnum& individual_evse_status(int32_t evse_id);
    FullConnectorStatus& individual_connector_status(int32_t evse_id, int32_t connector_id);
 
    OperationalStatusEnum& last_evse_effective_status(int32_t evse_id);
    OperationalStatusEnum& last_connector_effective_status(int32_t evse_id, int32_t connector_id);
    ConnectorStatusEnum& last_connector_reported_status(int32_t evse_id, int32_t connector_id);
 
    void trigger_callbacks_cs(bool only_if_state_changed);
    void trigger_callbacks_evse(int32_t evse_id, bool only_if_state_changed);
    void trigger_callbacks_connector(int32_t evse_id, int32_t connector_id, bool only_if_state_changed);
 
    void send_status_notification_single_connector_internal(int32_t evse_id, int32_t connector_id, bool only_if_changed,
                                                            bool intiated_by_trigger_message = false);
 
    void read_all_states_from_database_or_set_defaults(const std::map<int32_t, int32_t>& evse_connector_structure);
 
    void initialize_reported_state_cache();
 
public:
    explicit ComponentStateManager(
        const std::map<int32_t, int32_t>& evse_connector_structure, std::shared_ptr<DatabaseHandler> db_handler,
        std::function<bool(const int32_t evse_id, const int32_t connector_id, const ConnectorStatusEnum new_status,
                           const bool initiated_by_trigger_message)>
            send_connector_status_notification_callback);
 
    void set_cs_effective_availability_changed_callback(
        const std::function<void(const OperationalStatusEnum new_status)>& callback);
 
    void set_evse_effective_availability_changed_callback(
        const std::function<void(const int32_t evse_id, const OperationalStatusEnum new_status)>& callback);
 
    void set_connector_effective_availability_changed_callback(
        const std::function<void(const int32_t evse_id, const int32_t connector_id,
                                 const OperationalStatusEnum new_status)>& callback);
 
    OperationalStatusEnum get_cs_individual_operational_status();
    OperationalStatusEnum get_evse_individual_operational_status(int32_t evse_id);
    OperationalStatusEnum get_connector_individual_operational_status(int32_t evse_id, int32_t connector_id);
 
    OperationalStatusEnum get_cs_persisted_operational_status();
    OperationalStatusEnum get_evse_persisted_operational_status(int32_t evse_id);
    OperationalStatusEnum get_connector_persisted_operational_status(int32_t evse_id, int32_t connector_id);
 
    void set_cs_individual_operational_status(OperationalStatusEnum new_status, bool persist);
    void set_evse_individual_operational_status(int32_t evse_id, OperationalStatusEnum new_status, bool persist);
    void set_connector_individual_operational_status(int32_t evse_id, int32_t connector_id,
                                                     OperationalStatusEnum new_status, bool persist);
 
    OperationalStatusEnum get_evse_effective_operational_status(int32_t evse_id);
    OperationalStatusEnum get_connector_effective_operational_status(int32_t evse_id, int32_t connector_id);
    ConnectorStatusEnum get_connector_effective_status(int32_t evse_id, int32_t connector_id);
 
    void set_connector_occupied(int32_t evse_id, int32_t connector_id, bool is_occupied);
    void set_connector_reserved(int32_t evse_id, int32_t connector_id, bool is_reserved);
    void set_connector_faulted(int32_t evse_id, int32_t connector_id, bool is_faulted);
    void set_connector_unavailable(int32_t evse_id, int32_t connector_id, bool is_unavailable);
 
    void trigger_all_effective_availability_changed_callbacks();
 
    void send_status_notification_all_connectors();
    void send_status_notification_changed_connectors();
    void send_status_notification_single_connector(int32_t evse_id, int32_t connector_id);
};
 
} // namespace ocpp::v2