Settings.hpp

Go to the documentation of this file.

#ifndef IV_SRC_DIAMAR_SETTINGS_HPP_
#define IV_SRC_DIAMAR_SETTINGS_HPP_
 
#include "diamar/Station.hpp"
#include "diamar/UserProfile.hpp"
#include "model/enums.hpp"
#include "model/structs.hpp"
#include "third_party/magic_enum/magic_enum.hpp"
 
#include <map>
#include <string>
 
namespace iv::diamar
{
 
struct Settings
{
    Settings();
    static bool validatePassword(const std::string_view &password, std::string *errorMsg);
    std::vector<std::shared_ptr<iv::diamar::UserProfile>> getUsersWithPermissions();
 
    std::map<iv::diamar::eUserProfileType, std::shared_ptr<iv::diamar::UserProfile>> profiles;
    bool enablePasswordConstraints {DefaultValues::enablePasswordConstraints};
    iv::model::PasswordRequirements passwordRequirements;
    iv::model::PasswordLifecycle passwordLifecycle;
    iv::model::LoginLockout loginLockout;
    iv::model::CloudSettings cloudSettings;
    iv::model::TimeSyncSettings timeSyncSettings;
    iv::model::DeadManSettings deadManSettings;
 
    std::string printerDevice;
 
    bool allowRemoteConnection {DefaultValues::allowRemoteConnection};
    bool enableTrendCurves {DefaultValues::enableTrendCurves};
    bool enableChannelLogs {DefaultValues::enableChannelLogs};
    bool isDemoMode {DefaultValues::isDemoMode};
    bool showShipyardTag {DefaultValues::showShipyardTag};
    uint64_t maxLogs;
    bool includeDiamar1Functionalities {DefaultValues::includeDiamar1Functionalities};
 
    static void actionPasswordRequirementsChanged();
    static void actionPasswordLifecycleChanged();
    static void actionUnsuccessfulLoginSettingsChanged();
    static void actionUserPasswordChanged();
 
    bool load(const iv::file::xml::node &nodeConfigDiamar)
    {
        bool result {true};
        iv::file::xml::node nodeGeneral = nodeConfigDiamar.getChild(Sections::general);
        if (nodeGeneral.emptyNode())
        {
            return false;
        }
        printerDevice = nodeGeneral.getAttribute(Keys::printerDevice, DefaultValues::defaultPrinter);
        allowRemoteConnection =
                nodeGeneral.getAttribute(Keys::allowRemoteConnection, DefaultValues::allowRemoteConnection);
        enableTrendCurves = nodeGeneral.getAttribute(Keys::enableTrendCurves, DefaultValues::enableTrendCurves);
        enableChannelLogs = nodeGeneral.getAttribute(Keys::enableChannelLogs, DefaultValues::enableChannelLogs);
        isDemoMode = nodeGeneral.getAttribute(Keys::isDemoMode, DefaultValues::isDemoMode);
        showShipyardTag = nodeGeneral.getAttribute(Keys::showShipyardTag, DefaultValues::showShipyardTag);
        includeDiamar1Functionalities = nodeGeneral.getAttribute(Keys::includeDiamar1Functionalities,
                                                                 DefaultValues::includeDiamar1Functionalities);
 
        enablePasswordConstraints = nodeConfigDiamar.getAttribute(Keys::enablePasswordConstraints,
                                                                  DefaultValues::enablePasswordConstraints);
        result &= passwordRequirements.load(nodeConfigDiamar.getChild(Sections::passwordRequirements));
        result &= passwordLifecycle.load(nodeConfigDiamar.getChild(Sections::passwordLifecycle));
        result &= loginLockout.load(nodeConfigDiamar.getChild(Sections::loginLockout));
        result &= cloudSettings.load(nodeConfigDiamar.getChild(Sections::cloudSettings));
        timeSyncSettings.load(nodeConfigDiamar.getChild(Sections::timeSyncSettings));
        deadManSettings.load(nodeConfigDiamar.getChild(Sections::deadManSettings));
        maxLogs = nodeGeneral.getAttribute(Keys::maxLogs, DefaultValues::maxLogs);
 
        for (const iv::file::xml::node nodeProfile: nodeConfigDiamar.getChild(Sections::profiles))
        {
            std::shared_ptr<iv::diamar::UserProfile> userProfile = std::make_shared<iv::diamar::UserProfile>();
            result &= userProfile->load(nodeProfile);
            profiles.insert_or_assign(userProfile->getType(), userProfile);
        }
 
        for (const auto &profileType: magic_enum::enum_values<iv::diamar::eUserProfileType>())
        {
            if (not profiles.contains(profileType))
            {
                return false;
            }
        }
 
        return result;
    }
 
    bool save(iv::file::xml::node &nodeConfigDiamar) const
    {
        bool result {true};
        iv::file::xml::node nodeGeneral = nodeConfigDiamar.appendChild(Sections::general);
        nodeGeneral.addAttribute(Keys::printerDevice, printerDevice);
        nodeGeneral.addAttribute(Keys::allowRemoteConnection, allowRemoteConnection);
        nodeGeneral.addAttribute(Keys::enableTrendCurves, enableTrendCurves);
        nodeGeneral.addAttribute(Keys::enableChannelLogs, enableChannelLogs);
        nodeGeneral.addAttribute(Keys::isDemoMode, isDemoMode);
        nodeGeneral.addAttribute(Keys::showShipyardTag, showShipyardTag);
        nodeGeneral.addAttribute(Keys::maxLogs, maxLogs);
        nodeGeneral.addAttribute(Keys::includeDiamar1Functionalities, includeDiamar1Functionalities);
 
        nodeConfigDiamar.addAttribute(Keys::enablePasswordConstraints, enablePasswordConstraints);
        iv::file::xml::node nodePasswordRequirements = nodeConfigDiamar.appendChild(Sections::passwordRequirements);
        result &= passwordRequirements.save(nodePasswordRequirements);
 
        iv::file::xml::node nodePasswordLifecycle = nodeConfigDiamar.appendChild(Sections::passwordLifecycle);
        result &= passwordLifecycle.save(nodePasswordLifecycle);
 
        iv::file::xml::node nodeLoginLockout = nodeConfigDiamar.appendChild(Sections::loginLockout);
        result &= loginLockout.save(nodeLoginLockout);
 
        iv::file::xml::node nodeCloudSettings = nodeConfigDiamar.appendChild(Sections::cloudSettings);
        result &= cloudSettings.save(nodeCloudSettings);
 
        iv::file::xml::node nodeTimeSyncSettings = nodeConfigDiamar.appendChild(Sections::timeSyncSettings);
        result &= timeSyncSettings.save(nodeTimeSyncSettings);
 
        iv::file::xml::node nodeDeadManSettings = nodeConfigDiamar.appendChild(Sections::deadManSettings);
        result &= deadManSettings.save(nodeDeadManSettings);
        iv::file::xml::node nodeProfiles = nodeConfigDiamar.appendChild(Sections::profiles);
        for (const auto &[profileType, userProfile]: profiles)
        {
            iv::file::xml::node nodeProfile = nodeProfiles.appendChild(Sections::profile);
            result &= userProfile->save(nodeProfile);
        }
 
        return result;
    }
 
    void update(const Settings &other)
    {
        printerDevice = other.printerDevice;
        allowRemoteConnection = other.allowRemoteConnection;
        enableTrendCurves = other.enableTrendCurves;
        enableChannelLogs = other.enableChannelLogs;
        isDemoMode = other.isDemoMode;
        maxLogs = other.maxLogs;
        enablePasswordConstraints = other.enablePasswordConstraints;
        passwordRequirements = other.passwordRequirements;
        passwordLifecycle = other.passwordLifecycle;
        loginLockout = other.loginLockout;
 
        profiles = other.profiles;
        for (const auto &[profileType, userProfile]: other.profiles)
        {
            if (not profiles.contains(profileType))
            {
                profiles.insert_or_assign(profileType, userProfile);
            }
            else
            {
                profiles.at(profileType)->update(*userProfile);
            }
        }
 
        std::erase_if(profiles, [&other](const auto &profile) { return not other.profiles.contains(profile.first); });
    }
 
    void innitDefaultProfiles()
    {
        profiles.clear();
 
        auto engMgt = std::make_shared<iv::diamar::UserProfile>(iv::diamar::eUserProfileType::EngineManagement, true);
        auto advEngMgt =
                std::make_shared<iv::diamar::UserProfile>(iv::diamar::eUserProfileType::EngineAdvancedManagement, true);
        auto root = std::make_shared<iv::diamar::UserProfile>(iv::diamar::eUserProfileType::Root, true);
        auto deckMgt = std::make_shared<iv::diamar::UserProfile>(iv::diamar::eUserProfileType::DeckManagement, false);
        auto advDeckMgt =
                std::make_shared<iv::diamar::UserProfile>(iv::diamar::eUserProfileType::DeckAdvancedManagement, false);
        auto monitor = std::make_shared<iv::diamar::UserProfile>(iv::diamar::eUserProfileType::Monitor, false);
 
        profiles.insert_or_assign(engMgt->getType(), engMgt);
        profiles.insert_or_assign(advEngMgt->getType(), advEngMgt);
        profiles.insert_or_assign(root->getType(), root);
        profiles.insert_or_assign(deckMgt->getType(), deckMgt);
        profiles.insert_or_assign(advDeckMgt->getType(), advDeckMgt);
        profiles.insert_or_assign(monitor->getType(), monitor);
    }
 
private:
    struct Sections
    {
        static constexpr std::string_view general {"General"};
        static constexpr std::string_view profiles {"Profiles"};
        static constexpr std::string_view profile {"Profile"};
        static constexpr std::string_view passwordRequirements {"PasswordRequirements"};
        static constexpr std::string_view passwordLifecycle {"PasswordLifecycle"};
        static constexpr std::string_view loginLockout {"LoginLockout"};
        static constexpr std::string_view cloudSettings {"Cloud"};
        static constexpr std::string_view timeSyncSettings {"TimeSync"};
        static constexpr std::string_view deadManSettings {"DeadMan"};
    };
    struct Keys
    {
        static constexpr std::string_view enablePasswordConstraints {"EnablePasswordConstraints"};
        static constexpr std::string_view printerDevice {"PrinterDevice"};
        static constexpr std::string_view allowRemoteConnection {"AllowRemoteConnection"};
        static constexpr std::string_view enableTrendCurves {"EnableTrendCurves"};
        static constexpr std::string_view enableChannelLogs {"EnableChannelLogs"};
        static constexpr std::string_view isDemoMode {"IsDemoMode"};
        static constexpr std::string_view showShipyardTag {"ShowShipyardTag"};
        static constexpr std::string_view maxLogs {"MaxNumberLogs"};
        static constexpr std::string_view includeDiamar1Functionalities {"IncludeDiamar1Functionalities"};
    };
    struct DefaultValues
    {
        static constexpr bool enablePasswordConstraints {false};
        static constexpr std::string defaultPrinter {};
        static constexpr bool allowRemoteConnection {true};
        static constexpr bool enableTrendCurves {true};
        static constexpr bool enableChannelLogs {false};
        static constexpr bool isDemoMode {false};
        static constexpr bool showShipyardTag {false};
        static constexpr uint64_t maxLogs {10};
        static constexpr bool includeDiamar1Functionalities {false};
    };
};
 
}// namespace iv::diamar
 
#endif//IV_SRC_DIAMAR_SETTINGS_HPP_