transaction.hpp

// SPDX-License-Identifier: Apache-2.0
// Copyright 2020 - 2023 Pionix GmbH and Contributors to EVerest
#ifndef OCPP_V16_TRANSACTION_HPP
#define OCPP_V16_TRANSACTION_HPP
 
#include <memory>
#include <random>
 
#include <everest/timer.hpp>
#include <ocpp/v16/ocpp_types.hpp>
#include <ocpp/v16/types.hpp>
 
namespace ocpp {
namespace v16 {
 
struct StampedEnergyWh {
    ocpp::DateTime timestamp; 
    double energy_Wh;         
    StampedEnergyWh(ocpp::DateTime timestamp, double energy_Wh) {
        this->timestamp = timestamp;
        this->energy_Wh = energy_Wh;
    }
};
 
class Transaction {
private:
    std::optional<int32_t> transaction_id;
    int32_t internal_transaction_id;
    int32_t connector;
    std::string session_id;
    CiString<20> id_token;
    std::shared_ptr<StampedEnergyWh> start_energy_wh;
    std::optional<int32_t> reservation_id;
    bool active;
    bool finished;
    bool has_signed_meter_values;
    std::unique_ptr<Everest::SteadyTimer> meter_values_sample_timer;
    std::string start_transaction_message_id;
    std::string stop_transaction_message_id;
    std::shared_ptr<StampedEnergyWh> stop_energy_wh;
    std::mutex meter_values_mutex;
    std::vector<MeterValue> meter_values;
 
public:
    Transaction(const int32_t transaction_id, const int32_t& connector, const std::string& session_id,
                const CiString<20>& id_token, const double meter_start, std::optional<int32_t> reservation_id,
                const ocpp::DateTime& timestamp, std::unique_ptr<Everest::SteadyTimer> meter_values_sample_timer);
 
    std::shared_ptr<StampedEnergyWh> get_start_energy_wh();
 
    void add_stop_energy_wh(std::shared_ptr<StampedEnergyWh> stop_energy_wh);
 
    std::shared_ptr<StampedEnergyWh> get_stop_energy_wh();
 
    std::optional<int32_t> get_reservation_id();
 
    int32_t get_connector();
 
    CiString<20> get_id_tag();
 
    void add_meter_value(MeterValue meter_value);
 
    std::vector<MeterValue> get_meter_values();
 
    bool change_meter_values_sample_interval(int32_t interval);
 
    void add_clock_aligned_meter_value(MeterValue meter_value);
 
    std::optional<int32_t> get_transaction_id();
 
    int32_t get_internal_transaction_id();
 
    std::string get_session_id();
 
    void set_start_transaction_message_id(const std::string& message_id);
 
    std::string get_start_transaction_message_id();
 
    void set_stop_transaction_message_id(const std::string& message_id);
 
    std::string get_stop_transaction_message_id();
 
    void set_transaction_id(int32_t transaction_id);
 
    std::vector<TransactionData> get_transaction_data();
 
    void stop();
 
    bool is_active();
 
    bool is_finished();
 
    void set_finished();
 
    void set_has_signed_meter_values();
 
    bool get_has_signed_meter_values();
};
 
class TransactionHandler {
private:
    std::mutex active_transactions_mutex;
    // size is equal to the number of connectors
    int32_t number_of_connectors;
 
    std::vector<std::shared_ptr<Transaction>> active_transactions;
    // size does not depend on the number of connectors
    std::vector<std::shared_ptr<Transaction>> stopped_transactions;
 
    std::mt19937 gen;
    std::uniform_int_distribution<int32_t> distr;
 
public:
    explicit TransactionHandler(int32_t number_of_connectors);
 
    int32_t get_negative_random_transaction_id();
 
    void add_transaction(std::shared_ptr<Transaction> transaction);
 
    void add_stopped_transaction(int32_t connector);
 
    bool remove_active_transaction(int32_t connector);
 
    void erase_stopped_transaction(std::string stop_transaction_message_id);
 
    std::shared_ptr<Transaction> get_transaction(int32_t connector);
 
    std::shared_ptr<Transaction> get_transaction(const std::string& start_transaction_message_id);
 
    std::shared_ptr<Transaction> get_transaction_from_id_tag(const std::string& id_tag);
 
    int32_t get_connector_from_transaction_id(int32_t transaction_id);
 
    void add_meter_value(int32_t connector, const MeterValue& meter_value);
 
    void change_meter_values_sample_intervals(int32_t interval);
 
    // \brief Provides the IdTag that was associated with the transaction with the provided
    std::optional<CiString<20>> get_authorized_id_tag(const std::string& stop_transaction_message_id);
 
    bool transaction_active(int32_t connector);
};
 
} // namespace v16
} // namespace ocpp
 
#endif // OCPP_V16_TRANSACTION_HPP