structs.hpp

Go to the documentation of this file.

#ifndef IV_SRC_SERVICES_STRUCTS_HPP_
#define IV_SRC_SERVICES_STRUCTS_HPP_
 
#include "alarms/enums.hpp"
#include "core/types.hpp"
#include "filehandlers/xmlFile.hpp"
#include "model/diamar/AuditableEvents.hpp"
 
#include <memory>
#include <optional>
#include <string>
#include <utility>
#include <vector>
 
namespace iv::comms::api
{
 
struct ApiPaginationInfo
{
    uint32_t count {0};
    uint32_t limit {0};
    uint32_t offset {0};
    uint64_t total {0};
};
 
struct ApiCommunicationInfo
{
    iv::types::ipAddress ip;
    iv::types::ipPort port {0};
    std::weak_ptr<bool> isEnabled {};
};
 
struct HttpSettings
{
    std::vector<ApiCommunicationInfo> apiURLs;
 
    bool load(const iv::file::xml::node &node);
    bool save(iv::file::xml::node &node) const;
 
private:
    struct Keys
    {
        static constexpr std::string_view httpSettingIp {"Ip"};
        static constexpr std::string_view httpSettingPort {"Port"};
    };
 
    struct Sections
    {
        static constexpr std::string_view httpSetting {"HttpSetting"};
    };
};
 
struct ILoggerMessage
{
    iv::types::timestamp timestamp {0};
 
    ILoggerMessage() = default;
    explicit ILoggerMessage(const iv::types::timestamp _timestamp) : timestamp(_timestamp) {};
    virtual ~ILoggerMessage() = default;
};
 
struct ApiResponse
{
    ApiPaginationInfo paginationInfo;
    std::optional<std::vector<std::shared_ptr<iv::comms::api::ILoggerMessage>>> messages {std::nullopt};
};
 
struct ApiDeleteResponse
{
    bool acknowledged {false};
    uint32_t count {0};
    std::optional<std::string> extraInfo {std::nullopt};
 
    struct Fields
    {
        static constexpr std::string_view acknowledged {"acknowledged"};
        static constexpr std::string_view count {"deletedCount"};
    };
};
 
struct ApiPingResponse
{
    bool isActive {false};
 
    std::string status;
    std::string version;
    std::string name;
    std::string description;
};
 
namespace dataLogger
{
 
struct DataLoggerMessage final : ILoggerMessage
{
    iv::types::channelId channelId;
    iv::types::channelValue value {0};
 
    iv::alarms::eAlarmPriority alarmPriority {alarms::eAlarmPriority::Warning};
    iv::alarms::eAlarmState alarmState {alarms::eAlarmState::Undefined};
    iv::alarms::eAlarmType alarmType {alarms::eAlarmType::AlarmUnk};
 
    DataLoggerMessage() = default;
 
    DataLoggerMessage(const iv::types::timestamp _timestamp, iv::types::channelId _channelId,
                      const iv::types::channelValue _value, const iv::alarms::eAlarmPriority _alarmPriority,
                      const iv::alarms::eAlarmState _alarmState, const iv::alarms::eAlarmType _alarmType)
        : ILoggerMessage(_timestamp), channelId(std::move(_channelId)), value(_value), alarmPriority(_alarmPriority),
          alarmState(_alarmState), alarmType(_alarmType)
    {
    }
};
 
}// namespace dataLogger
 
namespace eventLogger
{
 
struct EventLoggerMessage final : ILoggerMessage
{
    //Common data
    std::string id;
    std::string description;
    std::string source;
    std::string type;
    iv::model::diamar::EventCategory category;//Kept as an enum to make it easier to filter
 
    //Access control event
    std::string userProfileIn;
    std::string userProfileOut;
 
    //Request errors event or  potential attack activity event
    std::string ipAddress;
    std::string ipPort;
 
    //Control system event
    std::string unitId;
    std::string channelId;
    std::string groupId;
 
    //Backup and restore event
    std::string backupName;
};
 
}// namespace eventLogger
 
namespace historyLogger
{
 
struct HistoryLoggerMessage final : ILoggerMessage
{
    iv::types::channelId tag;
    std::string message;
 
    iv::alarms::eAlarmPriority alarmPriority {iv::alarms::eAlarmPriority::Warning};
    iv::alarms::eAlarmState alarmState {iv::alarms::eAlarmState::Undefined};
    iv::alarms::eAlarmState originalAlarmState {iv::alarms::eAlarmState::Undefined};
    iv::alarms::eAlarmType alarmType {iv::alarms::eAlarmType::AlarmUnk};
    iv::types::channelValue value {0};
 
    bool isPrinted {false};
 
    HistoryLoggerMessage() = default;
    HistoryLoggerMessage(const iv::types::timestamp _timestamp, iv::types::channelId _channelId, std::string _message,
                         const iv::alarms::eAlarmPriority _alarmPriority, const iv::alarms::eAlarmState _alarmState,
                         const iv::alarms::eAlarmType _alarmType, const iv::types::channelValue _value,
                         const bool _isPrinted)
        : ILoggerMessage(_timestamp), tag(std::move(_channelId)), message(std::move(_message)),
          alarmPriority(_alarmPriority), alarmState(_alarmState), originalAlarmState(_alarmState),
          alarmType(_alarmType), value(_value), isPrinted(_isPrinted) {};
};
 
}// namespace historyLogger
 
}// namespace iv::comms::api
 
#endif//IV_SRC_SERVICES_STRUCTS_HPP_