CDataAppDiamar.hpp

Go to the documentation of this file.

#ifndef LIBS_DIAMAR_CDATAAPPDIAMAR_HPP_
#define LIBS_DIAMAR_CDATAAPPDIAMAR_HPP_
 
#include "comms/DataLoggerManager.hpp"
#include "core/SoundManager.hpp"
#include "diamar/DiamarModel.hpp"
#include "diamar/IApplicationController.hpp"
#include "logs/EventLogs.hpp"
#include "logs/StartingLog.hpp"
#include "threads/RunReconnect.hpp"
#include "threads/Thread.hpp"
#include "ui/panels/CLoggerInformError.hpp"
 
#include <bits/stdint-uintn.h>
#include <memory>
#include <string>
 
class CDataAppDiamar : public iv::appdiamar::IApplicationController
{
public:
    static constexpr uint64_t kPrvTimerUpdateConnectionFail = 1000;
    static constexpr int32_t kPrvPasswordMaxNumChars = 15;
    static constexpr int32_t kPrvPasswordMinNumChars = 4;
 
    CDataAppDiamar() = delete;
    CDataAppDiamar(std::string projectFolder, const std::shared_ptr<iv::model::IModel> &modelApplication);
    CDataAppDiamar(const CDataAppDiamar &other) = delete;
    CDataAppDiamar(CDataAppDiamar &&other) = delete;
    ~CDataAppDiamar() override;
 
    CDataAppDiamar &operator=(const CDataAppDiamar &other) = delete;
    CDataAppDiamar &operator=(CDataAppDiamar &&other) = delete;
 
    const std::shared_ptr<iv::model::diamar::DiamarModel> &model();
 
    virtual bool configure(const std::shared_ptr<iv::logs::StartingLog> &logger);
    bool read();
    void save() const;
 
    void closeSystem(const std::shared_ptr<AbstractProgress> &progress, AbstractLog *logger);
 
    void setModelApplicationRef(iv::model::IModel *modelApplication);
 
    [[nodiscard]] virtual iv::model::eShipArea getCurrentShipArea() const;
 
    virtual void startSystem(const std::shared_ptr<AbstractProgress> &progress,
                             const std::shared_ptr<AbstractLog> &logger);
 
    void setGMT(iv::eGmtArea gmt);
 
    void setActiveLanguage(iv::eLanguage eLanguage);
    void setShowAlarms();
 
    static bool canEnd(CDialog *dlgFather);
    [[nodiscard]] virtual bool isHideWatchCallPanel() const;
    [[nodiscard]] const bool &isShowAlarms() const;
    [[nodiscard]] bool hasLicense() const;
    [[nodiscard]] bool hasRepeaters() const;
    [[nodiscard]] std::string getHostName();
 
    [[nodiscard]] bool isStarted() const;
 
    static bool isRemoteOn();
 
    void updateChannels() override;
 
    // GETTERS
    [[nodiscard]] const iv::time::Timestamp &lastUpdate() const override
    {
        return m_model->m_lastUpdate;
    }
 
    [[nodiscard]] const iv::diamar::Preferences &preferences() const override
    {
        return m_preferences;
    }
 
    [[nodiscard]] const std::shared_ptr<iv::model::ShipInfo> &shipInfo() const override
    {
        return m_model->m_shipInfo;
    }
 
    [[nodiscard]] const std::shared_ptr<iv::model::ProjectInfo> &projectInfo() const override
    {
        return m_model->m_projectInfo;
    }
 
    [[nodiscard]] const std::shared_ptr<iv::diamar::Settings> &settings() const override
    {
        return m_model->m_settings;
    }
 
    [[nodiscard]] std::map<iv::eLanguage, bool> &languages() const override
    {
        return m_model->m_languages;
    }
 
    [[nodiscard]] const std::shared_ptr<iv::diamar::Stations> &stations() const override
    {
        return m_model->m_stations;
    }
 
    [[nodiscard]] const std::shared_ptr<iv::model::diamar::Cabinets> &cabinets() const override
    {
        return m_model->m_cabinets;
    }
 
    [[nodiscard]] const std::shared_ptr<iv::units::Units> &units() const override
    {
        return m_model->m_units;
    }
 
    [[nodiscard]] const std::shared_ptr<iv::model::pms::PmsManager> &pmsManager() const override
    {
        return m_model->m_pmsManager;
    }
 
    [[nodiscard]] const std::shared_ptr<iv::model::control::ControlManager> &controlManager() const override
    {
        return m_model->m_controlManager;
    }
 
    [[nodiscard]] const std::shared_ptr<iv::diamar::Mimics> &mimics() const override
    {
        return m_model->m_mimics;
    }
 
    [[nodiscard]] iv::model::GroupMenuModel<std::weak_ptr<iv::diamar::Mimic>> &mimicsGroups() const override
    {
        return m_model->m_mimicsGroups;
    }
 
    [[nodiscard]] const std::shared_ptr<iv::model::diamar::Groups> &groups() const override
    {
        return m_model->m_groups;
    }
 
    [[nodiscard]] const std::shared_ptr<iv::config::UserProfileManager> &userProfileManager() const override
    {
        return m_userProfileManager;
    }
 
    [[nodiscard]] const std::shared_ptr<iv::comms::CommunicationCenter> &commCenter() const override
    {
        return m_commCenter;
    }
 
    [[nodiscard]] const std::shared_ptr<iv::tanks::Tanks> &tanks() const override
    {
        return m_model->m_tanks;
    }
 
    [[nodiscard]] const std::shared_ptr<iv::logic::ParametersOnline> &parametersOnline() const override
    {
        return m_model->m_parametersOnline;
    }
 
    [[nodiscard]] std::string title() const override
    {
        return fmt::format("{} ({})", m_model->m_projectInfo->m_reference,
                           not m_model->m_shipInfo->hull.empty() ? m_model->m_shipInfo->hull : "N/A");
    }
 
    [[nodiscard]] std::string projectFolder() const override
    {
        return m_model->projectFolder;
    }
 
    [[nodiscard]] const std::shared_ptr<iv::alarms::AlarmsManager> &alarmsManager() const override
    {
        return m_alarmsManager;
    }
 
    [[nodiscard]] iv::eProgramCaller programCaller() const override
    {
        return m_model->programCaller;
    }
 
    [[nodiscard]] const std::shared_ptr<iv::alarms::WatchcallManager> &watchcallManager() const override
    {
        return m_model->m_watchcallManager;
    }
 
    void setModelApplication(const std::shared_ptr<iv::model::IModel> &modelApplication) override {};
 
    [[nodiscard]] const std::shared_ptr<iv::sound::SoundManager> &soundManager() const
    {
        return m_soundManager;
    }
 
    [[nodiscard]] const std::shared_ptr<iv::diamar::AppFailuresLoggerManager> &appFailuresLogger() const override
    {
        return m_appFailuresLoggerManager;
    }
 
    [[nodiscard]] const std::shared_ptr<iv::model::Changes> &changes() const override
    {
        return m_model->m_changes;
    }
 
    std::shared_ptr<std::mutex> m_commsMutex;
 
protected:
    void deleteApplicationData() override
    {
    }
 
    [[nodiscard]] virtual bool prvReviewSystemIntegrity(const std::shared_ptr<AbstractProgress> &progress,
                                                        const std::shared_ptr<AbstractLog> &logger) const;
 
    std::string m_dataAppFolder;
    bool m_hasLicense;
 
    std::string m_hostname;
    bool m_hasFilteredAlarmChannels;
 
    std::shared_ptr<iv::comms::CommunicationCenter> m_commCenter;
    std::shared_ptr<iv::config::UserProfileManager> m_userProfileManager;
 
    iv::eProcessingState m_stateProcessing;
 
    std::shared_ptr<iv::model::diamar::DiamarModel> m_model;
    iv::diamar::Preferences m_preferences;
 
    std::shared_ptr<iv::alarms::AlarmsManager> m_alarmsManager;
    std::shared_ptr<iv::sound::SoundManager> m_soundManager;
    std::shared_ptr<iv::diamar::AppFailuresLoggerManager> m_appFailuresLoggerManager;
};
 
#endif /* LIBS_DIAMAR_CDATAAPPDIAMAR_HPP_ */