types.hpp

// SPDX-License-Identifier: Apache-2.0
// Copyright Pionix GmbH and Contributors to EVerest
 
#ifndef OCPP_COMMON_TYPES_HPP
#define OCPP_COMMON_TYPES_HPP
 
#include <chrono>
#include <cstddef>
#include <iostream>
#include <optional>
#include <sstream>
#include <stdexcept>
#include <string>
 
#include <nlohmann/json_fwd.hpp>
 
#include <date/date.h>
#include <date/tz.h>
 
#include <ocpp/common/cistring.hpp>
#include <ocpp/common/support_older_cpp_versions.hpp>
#include <ocpp/v16/ocpp_enums.hpp>
#include <ocpp/v2/ocpp_enums.hpp>
 
using json = nlohmann::json;
 
namespace ocpp {
 
struct Message {
    virtual std::string get_type() const = 0;
};
 
class TimePointParseException : public std::exception {
public:
    explicit TimePointParseException(const std::string& timepoint_str) :
        msg{"Timepoint string parsing failed. Could not convert: \"" + timepoint_str + "\" into DateTime."} {
    }
 
    const char* what() const noexcept override {
        return msg.c_str();
    }
 
private:
    std::string msg;
};
 
class DateTimeImpl {
private:
    std::chrono::time_point<date::utc_clock> timepoint;
 
public:
    DateTimeImpl();
 
    ~DateTimeImpl() = default;
 
    explicit DateTimeImpl(std::chrono::time_point<date::utc_clock> timepoint);
 
    explicit DateTimeImpl(const std::string& timepoint_str);
 
    std::string to_rfc3339() const;
 
    void from_rfc3339(const std::string& timepoint_str);
 
    std::chrono::time_point<date::utc_clock> to_time_point() const;
 
    DateTimeImpl& operator=(const DateTimeImpl& dt);
 
    operator std::string() {
        return this->to_rfc3339();
    }
 
    friend std::ostream& operator<<(std::ostream& os, const DateTimeImpl& dt);
 
    friend bool operator>(const DateTimeImpl& lhs, const DateTimeImpl& rhs);
 
    friend bool operator>=(const DateTimeImpl& lhs, const DateTimeImpl& rhs);
 
    friend bool operator<(const DateTimeImpl& lhs, const DateTimeImpl& rhs);
 
    friend bool operator<=(const DateTimeImpl& lhs, const DateTimeImpl& rhs);
 
    friend bool operator==(const DateTimeImpl& lhs, const DateTimeImpl& rhs);
};
 
class DateTime : public DateTimeImpl {
public:
    DateTime();
 
    ~DateTime() = default;
 
    explicit DateTime(std::chrono::time_point<date::utc_clock> timepoint);
 
    explicit DateTime(const std::string& timepoint_str);
};
 
class EnumConversionException : public std::out_of_range {
public:
    using std::out_of_range::out_of_range;
};
 
class EnumToStringException : public EnumConversionException {
public:
    template <typename T>
    explicit EnumToStringException(T enumValue, std::string_view type) :
        EnumConversionException{std::string{"No known conversion from value '"} +
                                std::to_string(static_cast<int>(enumValue)) + "' to " + type.data()} {
    }
};
 
class StringToEnumException : public EnumConversionException {
public:
    StringToEnumException(std::string_view str, std::string_view type) :
        EnumConversionException{std::string{"Provided string '"} + str.data() + "' could not be converted to " +
                                type.data()} {
    }
};
 
enum SessionStartedReason {
    EVConnected,
    Authorized
};
namespace conversions {
std::string session_started_reason_to_string(SessionStartedReason e);
 
SessionStartedReason string_to_session_started_reason(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const SessionStartedReason& session_started_reason);
 
struct Current {
    std::optional<float> DC; 
    std::optional<float> L1; 
    std::optional<float> L2; 
    std::optional<float> L3; 
    std::optional<float> N;  
 
    friend void to_json(json& j, const Current& k);
 
    friend void from_json(const json& j, Current& k);
 
    // \brief Writes the string representation of the given Current \p k to the given output stream \p os
    friend std::ostream& operator<<(std::ostream& os, const Current& k);
};
struct Voltage {
    std::optional<float> DC; 
    std::optional<float> L1; 
    std::optional<float> L2; 
    std::optional<float> L3; 
 
    friend void to_json(json& j, const Voltage& k);
 
    friend void from_json(const json& j, Voltage& k);
 
    // \brief Writes the string representation of the given Voltage \p k to the given output stream \p os
    friend std::ostream& operator<<(std::ostream& os, const Voltage& k);
};
struct Frequency {
    float L1;                
    std::optional<float> L2; 
    std::optional<float> L3; 
 
    friend void to_json(json& j, const Frequency& k);
 
    friend void from_json(const json& j, Frequency& k);
 
    // \brief Writes the string representation of the given Frequency \p k to the given output stream \p os
    friend std::ostream& operator<<(std::ostream& os, const Frequency& k);
};
struct Power {
    float total;             
    std::optional<float> L1; 
    std::optional<float> L2; 
    std::optional<float> L3; 
 
    friend void to_json(json& j, const Power& k);
 
    friend void from_json(const json& j, Power& k);
 
    // \brief Writes the string representation of the given Power \p k to the given output stream \p os
    friend std::ostream& operator<<(std::ostream& os, const Power& k);
};
struct Energy {
    float total;             
    std::optional<float> L1; 
    std::optional<float> L2; 
    std::optional<float> L3; 
 
    friend void to_json(json& j, const Energy& k);
 
    friend void from_json(const json& j, Energy& k);
 
    // \brief Writes the string representation of the given Energy \p k to the given output stream \p os
    friend std::ostream& operator<<(std::ostream& os, const Energy& k);
};
struct ReactivePower {
    float total;                 
    std::optional<float> VARphA; 
    std::optional<float> VARphB; 
    std::optional<float> VARphC; 
 
    friend void to_json(json& j, const ReactivePower& k);
 
    friend void from_json(const json& j, ReactivePower& k);
 
    // \brief Writes the string representation of the given ReactivePower \p k to the given output stream \p os
    friend std::ostream& operator<<(std::ostream& os, const ReactivePower& k);
};
 
struct Powermeter {
    std::string timestamp;                  
    Energy energy_Wh_import;                
    std::optional<std::string> meter_id;    
    std::optional<bool> phase_seq_error;    
    std::optional<Energy> energy_Wh_export; 
    std::optional<Power>
        power_W; 
    std::optional<Voltage> voltage_V;      
    std::optional<ReactivePower> VAR;      
    std::optional<Current> current_A;      
    std::optional<Frequency> frequency_Hz; 
 
    friend void to_json(json& j, const Powermeter& k);
 
    friend void from_json(const json& j, Powermeter& k);
 
    // \brief Writes the string representation of the given Powermeter \p k to the given output stream \p os
    friend std::ostream& operator<<(std::ostream& os, const Powermeter& k);
};
 
struct StateOfCharge {
    float value;                         
    std::optional<std::string> location; 
 
    friend void to_json(json& j, const StateOfCharge& k);
 
    friend void from_json(const json& j, StateOfCharge& k);
 
    // \brief Writes the string representation of the given StateOfCharge \p k to the given output stream \p os
    friend std::ostream& operator<<(std::ostream& os, const StateOfCharge& k);
};
 
struct Temperature {
    float value;                         
    std::optional<std::string> location; 
 
    friend void to_json(json& j, const Temperature& k);
 
    friend void from_json(const json& j, Temperature& k);
 
    // \brief Writes the string representation of the given Temperature \p k to the given output stream \p os
    friend std::ostream& operator<<(std::ostream& os, const Temperature& k);
};
 
struct RPM {
    float value;                         
    std::optional<std::string> location; 
 
    friend void to_json(json& j, const RPM& k);
 
    friend void from_json(const json& j, RPM& k);
 
    // \brief Writes the string representation of the given RPM \p k to the given output stream \p os
    friend std::ostream& operator<<(std::ostream& os, const RPM& k);
};
 
struct Measurement {
    Powermeter power_meter;                   
    std::optional<StateOfCharge> soc_Percent; 
    std::vector<Temperature> temperature_C;   
    std::optional<RPM> rpm;                   
 
    friend void to_json(json& j, const Measurement& k);
 
    friend void from_json(const json& j, Measurement& k);
 
    // \brief Writes the string representation of the given Measurement \p k to the given output stream \p os
    friend std::ostream& operator<<(std::ostream& os, const Measurement& k);
};
 
struct DisplayMessageContent {
    std::string message;
    std::optional<std::string> language;
    std::optional<v2::MessageFormatEnum> message_format;
 
    friend void from_json(const json& j, DisplayMessageContent& m);
    friend void to_json(json& j, const DisplayMessageContent& m);
};
 
enum class IdentifierType {
    SessionId,    
    IdToken,      
    TransactionId 
};
 
struct DisplayMessage {
    std::optional<int32_t> id;
    std::optional<v2::MessagePriorityEnum> priority;
    std::optional<v2::MessageStateEnum> state;
    std::optional<DateTime> timestamp_from;
    std::optional<DateTime> timestamp_to;
    std::optional<std::string> identifier_id;
    std::optional<IdentifierType> identifier_type;
    DisplayMessageContent message;
    std::optional<std::string> qr_code;
};
 
struct RunningCostChargingPrice {
    std::optional<double> kWh_price;
    std::optional<double> hour_price;
    std::optional<double> flat_fee;
 
    friend void from_json(const json& j, RunningCostChargingPrice& c);
    friend void to_json(json& j, const RunningCostChargingPrice& c);
};
 
struct RunningCostIdlePrice {
    std::optional<uint32_t> idle_grace_minutes;
    std::optional<double> idle_hour_price;
 
    friend void from_json(const json& j, RunningCostIdlePrice& c);
    friend void to_json(json& j, const RunningCostIdlePrice& c);
};
 
enum class RunningCostState {
    Charging,
    Idle,
    Finished
};
 
namespace conversions {
RunningCostState string_to_running_cost_state(const std::string& state);
std::string running_cost_state_to_string(const RunningCostState& state);
} // namespace conversions
 
struct RunningCost {
    std::string transaction_id;
    std::optional<DateTime> timestamp;
    std::optional<uint32_t> meter_value;
    double cost;
    // Running cost state: "Charging" or "Idle". When this is the final price, state will be "Finished".
    RunningCostState state;
    std::optional<RunningCostChargingPrice> charging_price;
    std::optional<RunningCostIdlePrice> idle_price;
    std::optional<DateTime> next_period_at_time;
    std::optional<RunningCostChargingPrice> next_period_charging_price;
    std::optional<RunningCostIdlePrice> next_period_idle_price;
    std::optional<std::vector<DisplayMessageContent>> cost_messages;
    std::optional<std::string> qr_code_text;
 
    friend void from_json(const json& j, RunningCost& c);
};
 
struct TriggerMeterValue {
    std::optional<DateTime> at_time;
    std::optional<int> at_energy_kwh;
    std::optional<int> at_power_kw;
    std::vector<v16::ChargePointStatus> at_chargepoint_status;
 
    friend void from_json(const json& j, TriggerMeterValue& t);
};
 
enum class CaCertificateType {
    V2G,
    MO,
    CSMS,
    MF
};
 
namespace conversions {
std::string ca_certificate_type_to_string(CaCertificateType e);
 
CaCertificateType string_to_ca_certificate_type(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const CaCertificateType& ca_certificate_type);
 
enum class CertificateValidationResult {
    Valid,
    Expired,
    InvalidSignature,
    IssuerNotFound,
    InvalidLeafSignature,
    InvalidChain,
    Unknown,
};
 
namespace conversions {
std::string certificate_validation_result_to_string(CertificateValidationResult e);
 
CertificateValidationResult string_to_certificate_validation_result(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const CertificateValidationResult& certificate_validation_result);
 
enum class InstallCertificateResult {
    InvalidSignature,
    InvalidCertificateChain,
    InvalidFormat,
    InvalidCommonName,
    NoRootCertificateInstalled,
    Expired,
    CertificateStoreMaxLengthExceeded,
    WriteError,
    Accepted
};
 
namespace conversions {
std::string install_certificate_result_to_string(InstallCertificateResult e);
 
InstallCertificateResult string_to_install_certificate_result(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const InstallCertificateResult& install_certificate_result);
 
enum class DeleteCertificateResult {
    Accepted,
    Failed,
    NotFound,
};
 
namespace conversions {
std::string delete_certificate_result_to_string(DeleteCertificateResult e);
 
DeleteCertificateResult string_to_delete_certificate_result(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const DeleteCertificateResult& delete_certificate_result);
 
// from: GetInstalledCertificateIdsResponse
enum class HashAlgorithmEnumType {
    SHA256,
    SHA384,
    SHA512,
};
 
namespace conversions {
std::string hash_algorithm_enum_type_to_string(HashAlgorithmEnumType e);
 
HashAlgorithmEnumType string_to_hash_algorithm_enum_type(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const HashAlgorithmEnumType& hash_algorithm_enum_type);
 
struct CertificateHashDataType {
    HashAlgorithmEnumType hashAlgorithm;
    CiString<128> issuerNameHash;
    CiString<128> issuerKeyHash;
    CiString<40> serialNumber;
};
void to_json(json& j, const CertificateHashDataType& k);
 
void from_json(const json& j, CertificateHashDataType& k);
 
// \brief Writes the string representation of the given CertificateHashDataType \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const CertificateHashDataType& k);
 
enum class CertificateType {
    V2GRootCertificate,
    MORootCertificate,
    CSMSRootCertificate,
    V2GCertificateChain,
    MFRootCertificate,
};
 
namespace conversions {
std::string certificate_type_to_string(CertificateType e);
 
CertificateType string_to_certificate_type(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const CertificateType& ceritficate_type);
 
struct CertificateHashDataChain {
    CertificateHashDataType certificateHashData;
    CertificateType certificateType;
    std::optional<std::vector<CertificateHashDataType>> childCertificateHashData;
};
void to_json(json& j, const CertificateHashDataChain& k);
 
void from_json(const json& j, CertificateHashDataChain& k);
 
// \brief Writes the string representation of the given CertificateHashDataChain \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const CertificateHashDataChain& k);
 
enum class OcppProtocolVersion {
    v16,
    v201,
    v21,
    Unknown,
};
 
namespace conversions {
std::string ocpp_protocol_version_to_string(OcppProtocolVersion e);
 
OcppProtocolVersion string_to_ocpp_protocol_version(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const OcppProtocolVersion& ocpp_protocol_version);
 
enum class CertificateSigningUseEnum {
    ChargingStationCertificate,
    V2GCertificate,
    ManufacturerCertificate
};
 
namespace conversions {
std::string certificate_signing_use_enum_to_string(CertificateSigningUseEnum e);
 
CertificateSigningUseEnum string_to_certificate_signing_use_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const CertificateSigningUseEnum& certificate_signing_use_enum);
 
struct OCSPRequestData {
    HashAlgorithmEnumType hashAlgorithm;
    std::string issuerNameHash;
    std::string issuerKeyHash;
    std::string serialNumber;
    std::string responderUrl;
};
 
enum class GetCertificateSignRequestStatus {
    Accepted,
    InvalidRequestedType, 
    KeyGenError,          
    GenerationError,      
};
 
enum class GetCertificateInfoStatus {
    Accepted,
    Rejected,
    NotFound,
    NotFoundValid,
    PrivateKeyNotFound,
};
 
struct GetCertificateSignRequestResult {
    GetCertificateSignRequestStatus status;
    std::optional<std::string> csr;
};
 
struct CertificateOCSP {
    CertificateHashDataType hash;
    std::optional<fs::path> ocsp_path;
};
 
struct CertificateInfo {
    std::optional<fs::path> certificate_path;        // path to the full certificate chain
    std::optional<fs::path> certificate_single_path; // path to the single leaf certificate
    int certificate_count;                           // count of certs in the chain
    fs::path key_path;                               // path to private key of the leaf certificate
    std::optional<std::string> password;             // optional password for the private key
    std::vector<CertificateOCSP> ocsp;               // OCSP data if requested
};
 
struct GetCertificateInfoResult {
    GetCertificateInfoStatus status;
    std::optional<CertificateInfo> info;
};
 
enum class LeafCertificateType {
    CSMS, // Charging Station Management System
    V2G,  // Vehicle to grid
    MF,   // Manufacturer
    MO    // Mobility Operator
};
 
namespace conversions {
std::string bool_to_string(bool b);
 
bool string_to_bool(const std::string& s);
 
std::string double_to_string(double d, int precision);
 
std::string double_to_string(double d);
} // namespace conversions
 
enum class FirmwareStatusNotification {
    Downloaded,
    DownloadFailed,
    Downloading,
    DownloadScheduled,
    DownloadPaused,
    Idle,
    InstallationFailed,
    Installing,
    Installed,
    InstallRebooting,
    InstallScheduled,
    InstallVerificationFailed,
    InvalidSignature,
    SignatureVerified
};
 
namespace conversions {
std::string generate_certificate_signing_request_status_to_string(const GetCertificateSignRequestStatus status);
} // namespace conversions
 
namespace conversions {
 
v16::FirmwareStatus firmware_status_notification_to_firmware_status(const FirmwareStatusNotification status);
 
v16::FirmwareStatusEnumType
firmware_status_notification_to_firmware_status_enum_type(const FirmwareStatusNotification status);
 
} // namespace conversions
 
namespace security {
// The security profiles defined in OCPP 2.0.1 resp. in the OCPP 1.6 security-whitepaper.
enum SecurityProfile { // no "enum class" because values are used in implicit `switch`-comparisons to `int
                       // security_profile`
    OCPP_1_6_ONLY_UNSECURED_TRANSPORT_WITHOUT_BASIC_AUTHENTICATION = 0,
    UNSECURED_TRANSPORT_WITH_BASIC_AUTHENTICATION = 1,
    TLS_WITH_BASIC_AUTHENTICATION = 2,
    TLS_WITH_CLIENT_SIDE_CERTIFICATES = 3,
};
} // namespace security
 
namespace security_events {
 
// This is the list of security events defined in OCPP 2.0.1 (and the 1.6 security whitepper).
// Security events that are marked critical should be pushed to the CSMS.
// This is a non-exhaustive list of security events, when a security event matches the description in the OCPP
// specification of one of the Security Events in this list, for interoperability reasons, the Security Event from this
// list shall be used, instead of adding a new (proprietary) Security Event.
 
inline const std::string FIRMWARE_UPDATED = "FirmwareUpdated"; // CRITICAL
inline const std::string FAILEDTOAUTHENTICATEATCSMS = "FailedToAuthenticateAtCsms";
inline const std::string CSMSFAILEDTOAUTHENTICATE = "CsmsFailedToAuthenticate";
inline const std::string CSRGENERATIONFAILED = "CSRGenerationFailed";
inline const std::string SETTINGSYSTEMTIME = "SettingSystemTime";         // CRITICAL
inline const std::string RESET_OR_REBOOT = "ResetOrReboot";               // CRITICAL
inline const std::string STARTUP_OF_THE_DEVICE = "StartupOfTheDevice";    // CRITICAL
inline const std::string SECURITYLOGWASCLEARED = "SecurityLogWasCleared"; // CRITICAL
inline const std::string RECONFIGURATIONOFSECURITYPARAMETERS = "ReconfigurationOfSecurityParameters";
inline const std::string MEMORYEXHAUSTION = "MemoryExhaustion"; // CRITICAL
inline const std::string INVALIDMESSAGES = "InvalidMessages";
inline const std::string ATTEMPTEDREPLAYATTACKS = "AttemptedReplayAttacks";
inline const std::string TAMPERDETECTIONACTIVATED = "TamperDetectionActivated"; // CRITICAL
inline const std::string INVALIDFIRMWARESIGNATURE = "InvalidFirmwareSignature";
inline const std::string INVALIDFIRMWARESIGNINGCERTIFICATE = "InvalidFirmwareSigningCertificate";
inline const std::string INVALIDCSMSCERTIFICATE = "InvalidCsmsCertificate";
inline const std::string INVALIDCENTRALSYSTEMCERTIFICATE = "InvalidCentralSystemCertificate";
inline const std::string INVALIDCHARGINGSTATIONCERTIFICATE = "InvalidChargingStationCertificate";
inline const std::string INVALIDCHARGEPOINTCERTIFICATE = "InvalidChargePointCertificate"; // for OCPP1.6
inline const std::string INVALIDTLSVERSION = "InvalidTLSVersion";
inline const std::string INVALIDTLSCIPHERSUITE = "InvalidTLSCipherSuite";
inline const std::string MAINTENANCELOGINACCEPTED = "MaintenanceLoginAccepted";
inline const std::string MAINTENANCELOGINFAILED = "MaintenanceLoginFailed";
} // namespace security_events
 
enum class MessageDirection {
    CSMSToChargingStation,
    ChargingStationToCSMS
};
 
enum class ConnectionFailedReason {
    InvalidCSMSCertificate = 0,
    FailedToAuthenticateAtCsms
};
 
enum class WebsocketCloseReason : uint8_t {
    Normal = 1,
    ForceTcpDrop,
    GoingAway,
    AbnormalClose,
    ServiceRestart
};
 
enum class QueueType {
    Normal,
    Transaction,
    None,
};
 
struct CompositeScheduleDefaultLimits {
    int32_t amps;
    int32_t watts;
    int32_t number_phases;
};
 
enum class ReservationCheckStatus {
    NotReserved,           
    ReservedForToken,      
    ReservedForOtherToken, 
    ReservedForOtherTokenAndHasParentToken, 
};
 
} // namespace ocpp
 
#endif