Station.hpp

Go to the documentation of this file.

#ifndef IV_SRC_MODEL_DIAMAR_STATION_HPP_
#define IV_SRC_MODEL_DIAMAR_STATION_HPP_
 
#include "comms/apis/structs.hpp"
#include "core/defines.hpp"
#include "core/enums.hpp"
#include "core/structs.hpp"
#include "core/system.hpp"
#include "model/comms/NetworkData.hpp"
#include "model/enums.hpp"
#include "model/structs.hpp"
 
#include <memory>
#include <set>
#include <vector>
 
namespace iv::diamar
{
 
struct StationNetworksLoadData
{
    std::vector<std::shared_ptr<iv::model::comms::NetworkData>> readNetworkDatas;
    bool requiresGenerateLoggersDefaultNetwork {false};
    bool hasRetrofitNetwork {false};
};
 
class Station
{
    struct Settings
    {
        bool canBlockAck {false};
        bool localSoundOff {false};
 
        bool canConfigureVolume {true};
        bool canConfigureBrightness {false};
 
        iv::PrinterDevice alarmPrinter;
        iv::PrinterDevice printer;
 
        bool load(const iv::file::xml::node &nodeSettings);
        bool save(iv::file::xml::node &nodeSetings) const;
    };
 
public:
    bool load(const iv::file::xml::node &nodeStation, iv::diamar::StationNetworksLoadData &readNetworksInfo);
    bool save(iv::file::xml::node &nodeStation,
              const std::vector<std::shared_ptr<iv::model::comms::NetworkData>> &stationNetworks) const;
    [[nodiscard]] std::shared_ptr<Station> clone() const;
    void update(const Station &other);
 
    iv::types::stationId &stationId();
 
    iv::types::unitId &stationUnitId();
    iv::model::eShipArea &shipArea();
    iv::diamar::Station::Settings &stationSettings();
 
    [[nodiscard]] std::set<iv::types::ipAddress> getIps() const;
    std::set<iv::types::ipAddress> &getIpsRef();
    void setIps(std::set<iv::types::ipAddress> ipAddresses);
 
    [[nodiscard]] std::weak_ptr<iv::channels::AbstractChannel> getStationHeartbeatChannel() const;
    [[nodiscard]] std::weak_ptr<iv::channels::AbstractChannel> getStationFailureChannel() const;
 
    void setStationHeartbeatChannel(const std::shared_ptr<iv::channels::AbstractChannel> &channel);
    void setStationFailureChannel(const std::shared_ptr<iv::channels::AbstractChannel> &channel);
 
    [[nodiscard]] bool isOn() const;
 
    iv::types::timestamp lastHeartbeat; 
    // Getter and setter for the unit's last heartbeat
    void setUnitLastHeartbeats(
            const std::map<iv::types::unitId, std::map<iv::comms::eLomLine, iv::types::timestamp>> &lastHeartbeats);
    [[nodiscard]] std::map<iv::types::unitId, std::map<iv::comms::eLomLine, iv::types::timestamp>>
    getUnitsLastHeartbeats();
 
private:
    bool loadIp(const iv::file::xml::node &nodeStation);
    bool saveIp(iv::file::xml::node &nodeStation) const;
 
    bool loadNetworks(const iv::file::xml::node &nodeStation,
                      iv::diamar::StationNetworksLoadData &readNetworksInfo) const;
    bool saveNetworks(iv::file::xml::node &nodeStation,
                      const std::vector<std::shared_ptr<iv::model::comms::NetworkData>> &stationNetworks) const;
 
    std::weak_ptr<iv::channels::AbstractChannel> m_stationHeartbeatChannel; 
    std::weak_ptr<iv::channels::AbstractChannel>
            m_stationCommFailureChannel; 
    iv::types::stationId m_idStation;
    iv::types::unitId m_stationUnitId {0};
    std::set<iv::types::ipAddress> m_ip;
 
    iv::model::eShipArea m_shipArea {iv::model::eShipArea::Ecr};
    iv::diamar::Station::Settings m_stationSettings;
 
    std::map<iv::types::unitId, std::map<iv::comms::eLomLine, iv::types::timestamp>>
            unitsLastHeartbeats; 
    std::mutex m_unitsLastHeartbeatsMutex;
 
    struct Keys
    {
        static constexpr std::string_view stationId {"Id"};
        static constexpr std::string_view shipArea {"ShipArea"};
 
        static constexpr std::string_view canBlockACK {"CanBlockACK"};
        static constexpr std::string_view localSoundOFF {"LocalSoundOFF"};
        static constexpr std::string_view hideWatchCallPanel {"HideWatchCallPanel"};
        static constexpr std::string_view canConfigureVolume {"CanConfigureVolume"};
        static constexpr std::string_view canConfigureBrightness {"CanConfigureBrightness"};
 
        static constexpr std::string_view heartbeatChannel {"HeartbeatChannel"};
        static constexpr std::string_view failureChannel {"FailureChannel"};
 
        static constexpr std::string_view ip {"Ip"};
    };
 
    struct Sections
    {
        static constexpr std::string_view settings {"Settings"};
        static constexpr std::string_view ipAddresses {"IpAddresses"};
        static constexpr std::string_view ipAddress {"IpAddress"};
        static constexpr std::string_view networks {"Networks"};
        static constexpr std::string_view network {"Network"};
        static constexpr std::string_view networkCommInterfaceSettings {"Interface"};
        static constexpr std::string_view networkCommProtocolSettings {"Protocol"};
        static constexpr std::string_view alarmPrinter {"AlarmPrinter"};
        static constexpr std::string_view printer {"Printer"};
 
        struct Network
        {
            static constexpr std::string_view httpSetting {"HttpSetting"};
        };
    };
 
    struct DefaultValues
    {
        static constexpr std::string string {};
        static constexpr bool isEnabled {};
        static constexpr std::string shipArea {"Ecr"};
    };
};
 
class Stations
{
public:
    bool load(const iv::file::xml::File &xml);
    [[nodiscard]] bool save(const std::shared_ptr<iv::file::xml::File> &xml) const;
    void update(const iv::diamar::Stations &other);
 
    bool insertNetworkData(const iv::types::stationId &stationId,
                           const std::shared_ptr<iv::model::comms::NetworkData> &networkData);
    void changeNetworkId(const iv::types::networkId &previousNetworkID, const iv::types::networkId &newNetworkID);
    void updateNetworkHeartbeatAndFailureChannelsTagsAndDescriptions(const types::networkId &networkId);
    bool removeNetworkData(const iv::types::networkId &networkId);
 
    void changeStationId(const iv::types::stationId &previousStationID, const iv::types::stationId &newStationID);
    bool addDefaultStation(iv::types::stationId stationId);
    void addStationDefaultNetworks(iv::types::stationId stationId, bool addLoggers = true, bool addRedundancy = true);
 
    [[nodiscard]] std::shared_ptr<Station>
    getStation(const iv::types::stationId &stationId = iv::system::retrieveHostName()) const;
    [[nodiscard]] const std::map<iv::types::stationId, std::shared_ptr<iv::diamar::Station>> &getAll() const;
    [[nodiscard]] const std::map<iv::types::stationId, std::set<iv::types::networkId>> &getStationWithNetworks() const;
 
    void addStation(const std::shared_ptr<Station> &station);
    void clearStations();
    void eraseStation(const iv::types::stationId &stationId);
 
    void deleteNetwork(const iv::types::networkId &networkId);
 
    [[nodiscard]] std::vector<std::shared_ptr<iv::model::comms::NetworkData>>
    getStationNetworksData(const iv::types::stationId &stationId = iv::system::retrieveHostName()) const;
 
    std::weak_ptr<iv::model::comms::NetworkData> getNetworkData(const iv::types::networkId &networkId);
 
    [[nodiscard]] const std::map<iv::types::networkId, std::shared_ptr<iv::model::comms::NetworkData>> &
    getNetworksData() const;
 
    [[nodiscard]] std::shared_ptr<Stations> clone() const;
    void updateNetworks(const std::shared_ptr<Stations> &newStations);
 
    // Processed gets
    [[nodiscard]] std::weak_ptr<Station> getStationAt(uint32_t index) const;
 
    [[nodiscard]] std::weak_ptr<iv::model::comms::NetworkData> getNetworkDataAt(uint32_t index);
 
    [[nodiscard]] std::vector<iv::comms::api::ApiCommunicationInfo>
    getAPICommInfoOfType(iv::comms::eNetworkType networkType, bool onlyEnabled,
                         const iv::types::stationId &stationId = iv::system::retrieveHostName()) const;
 
    [[nodiscard]] bool isMaster(const iv::types::stationId &stationId = iv::system::retrieveHostName()) const;
    [[nodiscard]] bool isWatchcallMaster(const iv::types::stationId &stationId = iv::system::retrieveHostName()) const;
 
    [[nodiscard]] std::shared_ptr<Station> getMaster() const;
 
private:
    std::map<iv::types::networkId, std::shared_ptr<iv::model::comms::NetworkData>> m_networksData;
 
    std::map<iv::types::stationId, std::set<iv::types::networkId>> m_stationsNetworks;
    std::map<iv::types::stationId, std::shared_ptr<iv::diamar::Station>> m_stations;
 
    [[nodiscard]] std::vector<std::weak_ptr<iv::model::comms::NetworkData>>
    getNetworksRefOfType(iv::comms::eNetworkType networkType, bool onlyEnabled,
                         const iv::types::stationId &stationId) const;
 
public:
    struct Sections
    {
        static constexpr std::string_view stations {"Stations"};
        static constexpr std::string_view station {"Station"};
    };
};
 
}// namespace iv::diamar
 
#endif//IV_SRC_MODEL_DIAMAR_STATION_HPP_