structs.hpp

Go to the documentation of this file.

#ifndef IV_SRC_MODEL_STRUCTS_HPP_
#define IV_SRC_MODEL_STRUCTS_HPP_
 
#include "core/Timestamp.hpp"
#include "filehandlers/xmlFile.hpp"
#include "model/enums.hpp"
 
#include <map>
#include <optional>
 
namespace iv::model
{
 
struct EntryRegister
{
    EntryRegister();
    EntryRegister(const EntryRegister &other);
    EntryRegister(EntryRegister &&other) noexcept;
    ~EntryRegister();
 
    EntryRegister &operator=(const EntryRegister &other);
    EntryRegister &operator=(EntryRegister &&other) noexcept;
 
    std::string name;
    iv::time::Timestamp timestamp;
};
 
struct LocalizedText
{
    LocalizedText();
    LocalizedText(const LocalizedText &other);
    LocalizedText(LocalizedText &&other) noexcept;
    ~LocalizedText();
 
    LocalizedText &operator=(const LocalizedText &other);
    LocalizedText &operator=(LocalizedText &&other) noexcept;
 
    bool load(const iv::file::xml::node &nodeLocalizedTexts);
    bool save(iv::file::xml::node &nodeLocalizedText, std::string_view localizedTextNodeName) const;
 
    [[nodiscard]] std::string_view getText(iv::eLanguage language = iv::eLanguage::English) const;
    [[nodiscard]] std::string &getRefString(iv::eLanguage language = iv::eLanguage::English);
    bool empty() const;
    void clear();
 
    std::map<iv::eLanguage, std::string> localizedText;
 
private:
    struct Keys
    {
        static constexpr std::string_view language {"Language"};
        static constexpr std::string_view text {"Text"};
    };
 
    struct DefaultValues
    {
        static constexpr std::string string {};
    };
};
 
struct PasswordRequirements
{
    PasswordRequirements();
    PasswordRequirements(uint64_t minLength, bool requiresUpperCase, bool requiresLowerCase, bool requiresNumbers);
    PasswordRequirements(const PasswordRequirements &other);
    PasswordRequirements(PasswordRequirements &&other) noexcept;
    ~PasswordRequirements();
 
    PasswordRequirements &operator=(const PasswordRequirements &other);
    PasswordRequirements &operator=(PasswordRequirements &&other) noexcept;
 
    bool load(const iv::file::xml::node &nodePasswordRequirements);
    bool save(iv::file::xml::node &nodePasswordRequirements) const;
 
    uint64_t _minLength;
    bool _requiresUpperCase;
    bool _requiresLowerCase;
    bool _requiresNumbers;
 
private:
    struct Keys
    {
        static constexpr std::string_view minLength {"MinLength"};
        static constexpr std::string_view requiresUpperCase {"RequiresUpperCase"};
        static constexpr std::string_view requiresLowerCase {"RequiresLowerCase"};
        static constexpr std::string_view requiresNumbers {"RequiresNumbers"};
    };
 
    struct DefaultValues
    {
        static constexpr int32_t minLength {4};
        static constexpr bool requiresUpperCase {false};
        static constexpr bool requiresLowerCase {false};
        static constexpr bool requiresNumbers {true};
    };
};
 
struct PasswordLifecycle
{
    PasswordLifecycle();
    PasswordLifecycle(iv::types::milliseconds expirationTime, iv::types::milliseconds minTimeBetweenChanges,
                      iv::types::milliseconds notificationTimeBeforeExpiration);
    PasswordLifecycle(const PasswordLifecycle &other);
    PasswordLifecycle(PasswordLifecycle &&other) noexcept;
    ~PasswordLifecycle();
 
    PasswordLifecycle &operator=(const PasswordLifecycle &other);
    PasswordLifecycle &operator=(PasswordLifecycle &&other) noexcept;
 
    bool load(const iv::file::xml::node &nodePasswordLifecycle);
    bool save(iv::file::xml::node &nodePasswordLifecycle) const;
 
    iv::types::milliseconds _expirationTime;                  // Time after which password expires and needs renewal
    iv::types::milliseconds _minTimeBetweenChanges;           // Minimum time required between password changes
    iv::types::milliseconds _notificationTimeBeforeExpiration;// Time before expiration to notify
 
private:
    struct Keys
    {
        static constexpr std::string_view expirationTime {"ExpirationTime"};
        static constexpr std::string_view minTimeBetweenChanges {"MinTimeBetweenChanges"};
        static constexpr std::string_view notificationTimeBeforeExpiration {"NotificationTimeBeforeExpiration"};
    };
 
    struct DefaultValues
    {
        static constexpr iv::types::milliseconds expirationTime {1ULL * 365 * 24 * 60 * 60 * 1000};         // 1 year
        static constexpr iv::types::milliseconds minTimeBetweenChanges {1 * 24 * 60 * 60 * 1000};           // 1 day
        static constexpr iv::types::milliseconds notificationTimeBeforeExpiration {1 * 24 * 60 * 60 * 1000};// 1 day
    };
};
 
struct LoginLockout
{
    LoginLockout();
    LoginLockout(uint8_t maxFailedAttempts, iv::types::milliseconds lockoutDuration, bool automaticUnlock);
    LoginLockout(const LoginLockout &other);
    LoginLockout(LoginLockout &&other) noexcept;
    ~LoginLockout();
 
    LoginLockout &operator=(const LoginLockout &other);
    LoginLockout &operator=(LoginLockout &&other) noexcept;
 
    bool load(const iv::file::xml::node &nodeLoginLockout);
    bool save(iv::file::xml::node &nodeLoginLockout) const;
 
    uint8_t _maxFailedAttempts;              // Maximum number of failed login attempts before lockout
    iv::types::milliseconds _lockoutDuration;// Duration of lockout (5 minutes)
    bool _automaticUnlock;                   // Flag indicating whether automatic unlock is enabled
 
private:
    struct Keys
    {
        static constexpr std::string_view maxFailedAttempts {"MaxFailedAttempts"};
        static constexpr std::string_view lockoutDuration {"LockoutDuration"};
        static constexpr std::string_view automaticUnlock {"AutomaticUnlock"};
    };
 
    struct DefaultValues
    {
        static constexpr uint8_t maxFailedAttempts {5};
        static constexpr iv::types::milliseconds lockoutDuration {5 * 60 * 1000};
        static constexpr bool automaticUnlock {true};
    };
};
 
struct CloudSettings
{
    CloudSettings();
    CloudSettings(const CloudSettings &other);
    CloudSettings(CloudSettings &&other) noexcept;
    ~CloudSettings();
 
    CloudSettings &operator=(const CloudSettings &other);
    CloudSettings &operator=(CloudSettings &&other) noexcept;
 
    bool load(const iv::file::xml::node &nodeCloudSettings);
    bool save(iv::file::xml::node &nodeCloudSettings) const;
 
    bool enabled {DefaultValues::enabled};
    bool isSedniServer {DefaultValues::isSedniServer};
    iv::types::networkId networkId {DefaultValues::networkId};
    std::string username {DefaultValues::username};
    std::string password {DefaultValues::password};
    std::string databaseHost {DefaultValues::databaseHost};
    iv::types::ipPort databasePort {DefaultValues::databasePort};
    std::string databaseName {DefaultValues::databaseName};
 
private:
    struct Keys
    {
        static constexpr std::string_view enabled {"Enabled"};
        static constexpr std::string_view isSedniServer {"IsSedniServer"};
        static constexpr std::string_view networkId {"NetworkId"};
        static constexpr std::string_view username {"Username"};
        static constexpr std::string_view password {"Password"};
        static constexpr std::string_view databaseHost {"DatabaseHost"};
        static constexpr std::string_view databasePort {"DatabasePort"};
        static constexpr std::string_view databaseName {"DatabaseName"};
    };
 
    struct DefaultValues
    {
        static constexpr bool enabled {false};
        static constexpr bool isSedniServer {true};
        static constexpr iv::types::networkId networkId {};
        static constexpr std::string username {"admin"};
        static constexpr std::string password {"admin"};
        static constexpr std::string databaseHost {"localhost"};
        static constexpr iv::types::ipPort databasePort {27017};
        static constexpr std::string databaseName {};
    };
};
 
struct PosixTimeFormat
{
    PosixTimeFormat() = default;
    PosixTimeFormat(const PosixTimeFormat &other) = default;
    PosixTimeFormat(PosixTimeFormat &&other) noexcept = default;
    ~PosixTimeFormat() = default;
 
    PosixTimeFormat &operator=(const PosixTimeFormat &other) = default;
    PosixTimeFormat &operator=(PosixTimeFormat &&other) noexcept = default;
 
    bool load(const iv::file::xml::node &nodePosixTimeFormat);
    bool save(iv::file::xml::node &nodePosixTimeFormat) const;
 
    std::optional<iv::types::timestamp> getTimestamp() const;
    iv::types::channelId channelId {};
 
private:
    struct Keys
    {
        static constexpr std::string_view channelId {"ChannelId"};
    };
    struct DefaultValues
    {
        static constexpr std::string string {};
    };
};
 
struct RMCLikeFormat
{
    RMCLikeFormat() = default;
    RMCLikeFormat(const RMCLikeFormat &other) = default;
    RMCLikeFormat(RMCLikeFormat &&other) noexcept = default;
    ~RMCLikeFormat() = default;
 
    RMCLikeFormat &operator=(const RMCLikeFormat &other) = default;
    RMCLikeFormat &operator=(RMCLikeFormat &&other) noexcept = default;
 
    bool load(const iv::file::xml::node &nodeRMCLikeFormat);
    bool save(iv::file::xml::node &nodeRMCLikeFormat) const;
 
    std::optional<iv::types::timestamp> getTimestamp() const;
    iv::types::channelId utcTimeChannelId;//hhmmss.sss
    iv::types::channelId dateChannelId;   //ddmmyy
private:
    struct Keys
    {
        static constexpr std::string_view utcTimeChannelId {"UtcTimeChannelId"};
        static constexpr std::string_view dateChannelId {"DateChannelId"};
    };
    struct DefaultValues
    {
        static constexpr std::string string {};
    };
};
 
struct ZDALikeFormat
{
    ZDALikeFormat() = default;
    ZDALikeFormat(const ZDALikeFormat &other) = default;
    ZDALikeFormat(ZDALikeFormat &&other) noexcept = default;
    ~ZDALikeFormat() = default;
 
    ZDALikeFormat &operator=(const ZDALikeFormat &other) = default;
    ZDALikeFormat &operator=(ZDALikeFormat &&other) noexcept = default;
 
    bool load(const iv::file::xml::node &nodeZDALikeFormat);
    bool save(iv::file::xml::node &nodeZDALikeFormat) const;
 
    std::optional<iv::types::timestamp> getTimestamp() const;
 
    iv::types::channelId utcTimeChannelId;//hhmmss
    iv::types::channelId yearChannelId;
    iv::types::channelId monthChannelId;
    iv::types::channelId dayChannelId;
 
private:
    struct Keys
    {
        static constexpr std::string_view utcTimeChannelId {"UtcTimeChannelId"};
        static constexpr std::string_view monthChannelId {"MonthChannelId"};
        static constexpr std::string_view dayChannelId {"DayChannelId"};
        static constexpr std::string_view yearChannelId {"YearChannelId"};
    };
    struct DefaultValues
    {
        static constexpr std::string string {};
    };
};
 
struct TimeSyncSettings
{
    TimeSyncSettings();
    TimeSyncSettings(const TimeSyncSettings &other) = default;
    TimeSyncSettings(TimeSyncSettings &&other) noexcept = default;
    ~TimeSyncSettings() = default;
 
    TimeSyncSettings &operator=(const TimeSyncSettings &other) = default;
    TimeSyncSettings &operator=(TimeSyncSettings &&other) noexcept = default;
 
    std::optional<iv::types::timestamp> getTimestamp() const;
    std::optional<int32_t> getTimeZoneOffset() const;
 
    bool load(const iv::file::xml::node &nodeTimeSyncSettings);
    bool save(iv::file::xml::node &nodeTimeSyncSettings) const;
 
    bool hasTimeZoneSync;
    iv::types::channelId timeZoneChannelId {};
 
    bool hasTimeSync;
    iv::types::milliseconds maxTimeDifference {DefaultValues::maxTimeDifference};
 
    iv::model::eTimeSyncFormat timeSyncFormat;
 
    PosixTimeFormat posixTimeFormat;
    RMCLikeFormat rmcLikeFormat;
    ZDALikeFormat zdaLikeFormat;
 
private:
    struct Keys
    {
        static constexpr std::string_view hasTimeSync {"HasTimeSync"};
        static constexpr std::string_view hasTimeZoneSync {"HasTimeZoneSync"};
        static constexpr std::string_view timeZoneChannelId {"TimeZoneChannelId"};
        static constexpr std::string_view maxTimeDifference {"MaxTimeDifference"};
        static constexpr std::string_view timeSyncFormat {"TimeSyncFormat"};
    };
    struct Sections
    {
        static constexpr std::string_view posixTimeFormat {"PosixTimeFormat"};
        static constexpr std::string_view rmcLikeFormat {"RMCLikeFormat"};
        static constexpr std::string_view zdaLikeFormat {"ZDALikeFormat"};
    };
    struct DefaultValues
    {
        static constexpr std::string string {};
        static constexpr bool hasTimeSync {false};
        static constexpr bool hasTimeZoneSync {false};
        static constexpr iv::types::timestamp maxTimeDifference {5000};
        static constexpr auto timeSyncFormat {iv::model::eTimeSyncFormat::posixTime};
    };
};
 
struct DeadManSettings
{
    DeadManSettings() = default;
    DeadManSettings(const DeadManSettings &other) = default;
    DeadManSettings(DeadManSettings &&other) noexcept = default;
    ~DeadManSettings() = default;
 
    DeadManSettings &operator=(const DeadManSettings &other) = default;
    DeadManSettings &operator=(DeadManSettings &&other) noexcept = default;
 
    bool load(const iv::file::xml::node &nodeDeadManSettings);
    bool save(iv::file::xml::node &nodeDeadManSettings) const;
 
    std::optional<iv::types::channelId> deadManOn;
    std::optional<iv::types::channelId> deadManWarning;
    std::optional<iv::types::channelId> deadManAlarm;
    std::optional<iv::types::channelId> deadManCommandOn;
    std::optional<iv::types::channelId> deadManCommandOff;
    std::optional<iv::types::channelId> deadManCommandReset;
    std::optional<iv::types::channelId> deadManTime;
 
    // Redundant information
    bool isDeadManEnabled {false};
 
    struct Keys
    {
        static constexpr std::string_view deadManOn {"DeadManOn"};
        static constexpr std::string_view deadManWarning {"DeadManWarning"};
        static constexpr std::string_view deadManAlarm {"DeadManAlarm"};
        static constexpr std::string_view deadManCommandOn {"DeadManCommandOn"};
        static constexpr std::string_view deadManCommandOff {"DeadManCommandOff"};
        static constexpr std::string_view deadManCommandReset {"DeadManCommandReset"};
        static constexpr std::string_view deadManTime {"DeadManTime"};
    };
 
    struct DefaultValues
    {
        static constexpr std::string string {};
    };
};
}// namespace iv::model
 
#endif//IV_SRC_MODEL_STRUCTS_HPP_