#include <DashboardPage.hpp>

Inheritance diagram for DashboardPage:

Public Member Functions
	DashboardPage ()
	~DashboardPage () override
void	update_from_logs (const std::string &log_path, const Glib::ustring &db_version, bool on_access_enabled)
bool	update_from_logs ()

Private Member Functions
void	check_updates_async ()
bool	on_update_check_timer ()
void	set_update_status (const std::string &state)
Gtk::Frame *	make_card (const std::string &icon_path, Gtk::Widget &content, const Glib::ustring &title)

Private Attributes
Gtk::Label	lbl_title_
Gtk::Grid	grid_cards_
Gtk::Frame *	card_status_ = nullptr
Gtk::Frame *	card_db_version_ = nullptr
Gtk::Frame *	card_db_date_ = nullptr
Gtk::Frame *	card_logs_ = nullptr
Gtk::Label	lbl_status_
Gtk::Label	lbl_db_version_
Gtk::Label	lbl_db_date_
Gtk::Label	lbl_ransomware_status_
Gtk::Label	lbl_phishing_status_
Gtk::TextView	txt_onaccess_report_
Glib::RefPtr< Gtk::TextBuffer >	buf_onaccess_report_
Gtk::Box *	footer_box_ = nullptr
Gtk::Label	lbl_update_status_
Gtk::Button *	btn_theme_light_ = nullptr
Gtk::Button *	btn_theme_dark_ = nullptr
sigc::connection	update_check_timer_
bool	update_check_in_progress_ = false
sigc::connection	refresh_timer_
BastionGuard::AliveFlag	alive_ = BastionGuard::make_alive_flag()

Detailed Description

Definition at line 27 of file DashboardPage.hpp.

Constructor & Destructor Documentation

◆ DashboardPage()

DashboardPage::DashboardPage ( )

Definition at line 91 of file DashboardPage.cpp.

: Gtk::Box(Gtk::Orientation::VERTICAL, 16),
  lbl_title_("<b>Dashboard BastionGuard Endpoint</b>", Gtk::Align::START),
  grid_cards_(),
  lbl_status_(_("Inizializzazione...")),
  lbl_db_version_(_("Versione firme: sconosciuta")),
  lbl_db_date_(_("Data aggiornamento: sconosciuta")),
  lbl_ransomware_status_(_("Anti-Ransomware: stato sconosciuto")),
  lbl_phishing_status_(_("Anti-Phishing: stato sconosciuto"))
{
    set_margin(20);
    set_hexpand(true);
    set_halign(Gtk::Align::FILL);
 
 
    lbl_title_.set_use_markup(true);
    lbl_title_.set_margin_bottom(12);
    lbl_title_.get_style_context()->add_class("title");
    append(lbl_title_);
 
 
    grid_cards_.set_row_spacing(20);
    grid_cards_.set_column_spacing(20);
    grid_cards_.set_column_homogeneous(true);
    grid_cards_.set_hexpand(true);
    grid_cards_.set_halign(Gtk::Align::FILL);
 
 
    auto vbox_status = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 6);
    vbox_status->append(lbl_status_);
    vbox_status->append(lbl_ransomware_status_);
    vbox_status->append(lbl_phishing_status_);
 
 
    card_status_     = make_card(resource("icons/status.svg"),      *vbox_status,    _("Stato"));
    card_db_version_ = make_card(resource("icons/version.svg"),     lbl_db_version_, _("Versione Firme"));
    card_db_date_    = make_card(resource("icons/update-date.svg"), lbl_db_date_,    _("Ultimo aggiornamento"));
 
 
    grid_cards_.attach(*card_status_,     0, 0, 1, 1);
    grid_cards_.attach(*card_db_version_, 1, 0, 1, 1);
    grid_cards_.attach(*card_db_date_,    2, 0, 1, 1);
    append(grid_cards_);
 
 
    buf_onaccess_report_ = Gtk::TextBuffer::create();
    txt_onaccess_report_.set_buffer(buf_onaccess_report_);
    txt_onaccess_report_.set_editable(false);
    txt_onaccess_report_.set_wrap_mode(Gtk::WrapMode::WORD_CHAR);
    txt_onaccess_report_.set_vexpand(true);
 
    card_logs_ = make_card(resource("icons/log-dash.svg"), txt_onaccess_report_, _("Ultimi file scansionati"));
    append(*card_logs_);
 
    auto spacer = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL);
    spacer->set_vexpand(false); // <-- IMPORTANTE
    append(*spacer);
 
    footer_box_ = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL);
    footer_box_->set_hexpand(true);
    footer_box_->set_halign(Gtk::Align::FILL);
    footer_box_->set_margin_top(12);
    footer_box_->set_spacing(4);
 
    {
        auto applyTheme = [this](const std::string& themeId) {
            std::string cssFile;
            if (themeId == "dark")
                cssFile = Glib::build_filename(DATA_DIR, "BastionGuard-dark.css");
            else
                cssFile = Glib::build_filename(DATA_DIR, "BastionGuard.css");
            if (!std::filesystem::exists(cssFile)) {
                char self_path[1024] = {};
                ssize_t n = readlink("/proc/self/exe", self_path, sizeof(self_path) - 1);
                if (n > 0) {
                    std::string exeDir =
                        std::filesystem::path(self_path).parent_path().string();
                    std::string candidate = exeDir + "/" +
                        (themeId == "dark" ? "BastionGuard-dark.css" : "BastionGuard.css");
                    if (std::filesystem::exists(candidate))
                        cssFile = candidate;
                }
            }
 
            if (!std::filesystem::exists(cssFile)) {
                std::cerr << "[BastionGuard] CSS non trovato: " << cssFile << "\n";
                return;
            }
 
            try {
                auto provider = Gtk::CssProvider::create();
                provider->load_from_path(cssFile);
                Gtk::StyleContext::add_provider_for_display(
                    Gdk::Display::get_default(),
                    provider,
                    GTK_STYLE_PROVIDER_PRIORITY_USER);
            } catch (const Glib::Error& e) {
                std::cerr << "[BastionGuard] Errore CSS: " << e.what() << "\n";
                return;
            }
 
            std::string cfgDir = Glib::get_home_dir() + "/.config/BastionGuard";
            std::filesystem::create_directories(cfgDir);
            std::ofstream tf(cfgDir + "/theme.conf", std::ios::trunc);
            tf << themeId;
 
            btn_theme_light_->get_style_context()->remove_class("theme-btn-active");
            btn_theme_dark_->get_style_context()->remove_class("theme-btn-active");
            if (themeId == "dark")
                btn_theme_dark_->get_style_context()->add_class("theme-btn-active");
            else
                btn_theme_light_->get_style_context()->add_class("theme-btn-active");
        };
 
        btn_theme_light_ = Gtk::make_managed<Gtk::Button>("☀");
        btn_theme_light_->set_tooltip_text(_("Tema Chiaro"));
        btn_theme_light_->get_style_context()->add_class("flat");
        btn_theme_light_->get_style_context()->add_class("theme-btn");
        btn_theme_light_->signal_clicked().connect([applyTheme]() { applyTheme("light"); });
 
        btn_theme_dark_ = Gtk::make_managed<Gtk::Button>("🌙");
        btn_theme_dark_->set_tooltip_text(_("Tema Scuro"));
        btn_theme_dark_->get_style_context()->add_class("flat");
        btn_theme_dark_->get_style_context()->add_class("theme-btn");
        btn_theme_dark_->signal_clicked().connect([applyTheme]() { applyTheme("dark"); });
 
        {
            std::string saved;
            std::ifstream tf(Glib::get_home_dir() + "/.config/BastionGuard/theme.conf");
            tf >> saved;
            if (saved == "dark")
                btn_theme_dark_->get_style_context()->add_class("theme-btn-active");
            else
                btn_theme_light_->get_style_context()->add_class("theme-btn-active");
        }
 
        footer_box_->append(*btn_theme_light_);
        footer_box_->append(*btn_theme_dark_);
    }
 
    lbl_update_status_.set_text(_("Verifica aggiornamenti..."));
    lbl_update_status_.set_halign(Gtk::Align::END);
    lbl_update_status_.set_hexpand(true);
    lbl_update_status_.set_xalign(1.0f);
 
    auto ctx = lbl_update_status_.get_style_context();
    ctx->add_class("update-badge");
    ctx->add_class("update-checking");
 
    footer_box_->append(lbl_update_status_);
    append(*footer_box_);
 
 
    refresh_timer_ = Glib::signal_timeout().connect(
        sigc::mem_fun(*this,
            static_cast<bool(DashboardPage::*)()>(&DashboardPage::update_from_logs)),
        5000
    );
    check_updates_async();
    update_check_timer_ = Glib::signal_timeout().connect(
    sigc::mem_fun(*this, &DashboardPage::on_update_check_timer),
    6 * 60 * 60 * 1000
    );
}

References _, btn_theme_dark_, btn_theme_light_, buf_onaccess_report_, card_db_date_, card_db_version_, card_logs_, card_status_, check_updates_async(), DashboardPage(), DATA_DIR, footer_box_, grid_cards_, lbl_db_date_, lbl_db_version_, lbl_phishing_status_, lbl_ransomware_status_, lbl_status_, lbl_title_, lbl_update_status_, make_card(), on_update_check_timer(), refresh_timer_, resource(), txt_onaccess_report_, update_check_timer_, and update_from_logs().

Referenced by check_updates_async(), and DashboardPage().

◆ ~DashboardPage()

DashboardPage::~DashboardPage ( )

override

Definition at line 83 of file DashboardPage.cpp.

{
    if (alive_) alive_->store(false, std::memory_order_release);
    if (refresh_timer_.connected())       refresh_timer_.disconnect();
    if (update_check_timer_.connected())  update_check_timer_.disconnect();
}

References alive_, refresh_timer_, and update_check_timer_.

Member Function Documentation

◆ check_updates_async()

void DashboardPage::check_updates_async ( )

private

Definition at line 262 of file DashboardPage.cpp.

{
    if (update_check_in_progress_)
        return;
    update_check_in_progress_ = true;
 
    const char* url = "https://bastionguard.eu/version.php";
 
    SoupSession* session = soup_session_new();
    g_object_set(session, "timeout", 10, NULL);
 
    SoupMessage* msg = soup_message_new("GET", url);
 
    // Passiamo via user_data una coppia (this, alive_flag) allocata sullo heap:
    // se la pagina viene distrutta prima del callback async, alive_flag->load()
    // è false e il callback fa early-return.
    struct CheckUpdateCtx {
        DashboardPage* self;
        BastionGuard::AliveFlag alive;
    };
    auto* ctx = new CheckUpdateCtx{this, alive_};
 
    soup_session_send_and_read_async(
        session,
        msg,
        G_PRIORITY_DEFAULT,
        nullptr,
        +[](GObject* source, GAsyncResult* res, gpointer user_data) {
 
            std::unique_ptr<CheckUpdateCtx> ctx(
                static_cast<CheckUpdateCtx*>(user_data));
            DashboardPage* self = ctx->self;
            auto alive = ctx->alive;
 
            SoupSession* session = SOUP_SESSION(source);
 
            GError* error = nullptr;
            GBytes* bytes = soup_session_send_and_read_finish(session, res, &error);
 
            if (!alive->load()) {
                if (bytes) g_bytes_unref(bytes);
                if (error) g_error_free(error);
                g_object_unref(session);
                return;
            }
 
            if (error || !bytes) {
                Glib::signal_idle().connect_once([self, alive]{
                    BastionGuard::if_alive(alive, [self]{
                        self->update_check_in_progress_ = false;
                        self->set_update_status("error");
                    });
                });
 
                if (error) g_error_free(error);
                g_object_unref(session);
                return;
            }
 
            gsize size = 0;
            const char* data = static_cast<const char*>(g_bytes_get_data(bytes, &size));
            std::string body(data, size);
            g_bytes_unref(bytes);
 
            std::istringstream iss(body);
            std::string line;
            std::string remote_version = "0.0";
            int remote_build = 0;
 
            try {
                while (std::getline(iss, line)) {
                    if (!line.empty() && line.back() == '\r')
                        line.pop_back();
 
                    if (line.rfind("version=", 0) == 0) {
                        remote_version = line.substr(8);
                    } else if (line.rfind("build=", 0) == 0) {
                        remote_build = std::stoi(line.substr(6));
                    }
                }
            } catch (...) {
                Glib::signal_idle().connect_once([self, alive]{
                    BastionGuard::if_alive(alive, [self]{
                        self->update_check_in_progress_ = false;
                        self->set_update_status("error");
                    });
                });
 
                g_object_unref(session);
                return;
            }
 
            const std::string local_version = Backend::getAppVersion();
            const int local_build = Backend::getAppBuild();
 
            bool update_available = false;
 
            int vcmp = compare_semver(local_version, remote_version);
            if (vcmp < 0) update_available = true;
            else if (vcmp == 0 && remote_build > local_build) update_available = true;
 
            Glib::signal_idle().connect_once([self, alive, update_available, remote_version, remote_build]{
                BastionGuard::if_alive(alive, [self, update_available, &remote_version, remote_build]{
                    self->update_check_in_progress_ = false;
 
                    self->set_update_status(update_available ? "update" : "ok");
                    self->lbl_update_status_.set_tooltip_text(
                        Glib::ustring::compose(
                            _("Remoto: %1 (%2)"),
                            remote_version,
                            std::to_string(remote_build)
                        )
                    );
                });
            });
 
            g_object_unref(session);
        },
        ctx
    );
 
    g_object_unref(msg);
}

References _, alive_, compare_semver(), DashboardPage(), Backend::getAppBuild(), Backend::getAppVersion(), BastionGuard::if_alive(), lbl_update_status_, set_update_status(), and update_check_in_progress_.

Referenced by DashboardPage(), and on_update_check_timer().

◆ make_card()

Gtk::Frame * DashboardPage::make_card	(	const std::string &	icon_path,
		Gtk::Widget &	content,
		const Glib::ustring &	title )

private

Definition at line 452 of file DashboardPage.cpp.

{
    auto frame = Gtk::make_managed<Gtk::Frame>();
    frame->get_style_context()->add_class("card");
    frame->set_margin_bottom(10);
    frame->set_hexpand(true);
    frame->set_halign(Gtk::Align::FILL);
 
    auto hbox = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 12);
    hbox->set_margin(12);
    hbox->set_hexpand(true);
    hbox->set_halign(Gtk::Align::FILL);
 
 
    auto icon_box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL);
    icon_box->set_size_request(64, 64);
    icon_box->set_halign(Gtk::Align::START);
    icon_box->set_valign(Gtk::Align::START);
 
    auto pic = Gtk::make_managed<Gtk::Picture>();
    try {
        auto pb     = Gdk::Pixbuf::create_from_file(icon_path);
        auto scaled = pb->scale_simple(64, 64, Gdk::InterpType::BILINEAR);
        auto tex    = Gdk::Texture::create_for_pixbuf(scaled);
        pic->set_paintable(tex);
        pic->set_content_fit(Gtk::ContentFit::FILL);
        pic->set_keep_aspect_ratio(true);
    } catch (...) {
        std::cerr << _("⚠ Impossibile caricare icona: ") << icon_path << "\n";
    }
 
    icon_box->append(*pic);
    hbox->append(*icon_box);
 
 
    auto vbox = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 6);
    vbox->set_hexpand(true);
    vbox->set_halign(Gtk::Align::FILL);
 
    auto lbl_title = Gtk::make_managed<Gtk::Label>();
    lbl_title->set_markup("<b>" + title + "</b>");
    lbl_title->set_halign(Gtk::Align::START);
 
    if (auto lbl = dynamic_cast<Gtk::Label*>(&content)) {
        lbl->set_wrap(true);
        lbl->set_wrap_mode(Pango::WrapMode::WORD_CHAR);
        lbl->set_ellipsize(Pango::EllipsizeMode::NONE);
        lbl->set_xalign(0.0);
        lbl->set_hexpand(true);
        lbl->set_halign(Gtk::Align::FILL);
    }
 
    vbox->append(*lbl_title);
    vbox->append(content);
 
    hbox->append(*vbox);
    frame->set_child(*hbox);
 
    return frame;
}

References _.

Referenced by DashboardPage().

◆ on_update_check_timer()

bool DashboardPage::on_update_check_timer ( )

private

Definition at line 257 of file DashboardPage.cpp.

                                          {
    check_updates_async();
    return true;
}

References check_updates_async().

Referenced by DashboardPage().

◆ set_update_status()

void DashboardPage::set_update_status ( const std::string & state )

private

Definition at line 388 of file DashboardPage.cpp.

{
    auto ctx = lbl_update_status_.get_style_context();
 
    ctx->add_class("update-badge");
 
    ctx->remove_class("update-ok");
    ctx->remove_class("update-warn");
    ctx->remove_class("update-unk");
    ctx->remove_class("update-checking");
 
    if (state == "ok") {
        ctx->add_class("update-ok");
        lbl_update_status_.set_text(_("Aggiornato"));
    }
    else if (state == "update") {
        ctx->add_class("update-warn");
        lbl_update_status_.set_text(_("Aggiornamento disponibile"));
    }
    else if (state == "checking") {
        ctx->add_class("update-checking");
        lbl_update_status_.set_text(_("Verifica aggiornamenti..."));
    }
    else {
        ctx->add_class("update-unk");
        lbl_update_status_.set_text(_("Impossibile verificare"));
    }
}

References _, and lbl_update_status_.

Referenced by check_updates_async().

◆ update_from_logs() [1/2]

bool DashboardPage::update_from_logs ( )

Definition at line 519 of file DashboardPage.cpp.

                                     {
    update_from_logs("", Backend::getDbVersion(), Backend::isClamonaccActive());
    return true;
}

References Backend::getDbVersion(), Backend::isClamonaccActive(), and update_from_logs().

◆ update_from_logs() [2/2]

void DashboardPage::update_from_logs	(	const std::string &	log_path,
		const Glib::ustring &	db_version,
		bool	on_access_enabled )

Definition at line 525 of file DashboardPage.cpp.

{
 
    lbl_status_.set_markup(_("<b>Antivirus engine:</b> <span foreground='green'><b>Attivo</b></span>"));
 
    if (!db_version.empty() && db_version != _("sconosciuta")) {
        lbl_db_version_.set_text(db_version);
    } else {
        lbl_db_version_.set_text(_("Versione firme: sconosciuta"));
    }
 
    auto update_date = Backend::getLastUpdateDate();
    if (!update_date.empty())
        lbl_db_date_.set_text(update_date);
    else
        lbl_db_date_.set_text(_("Data aggiornamento: sconosciuta"));
 
 
    auto events = Backend::getOnAccessEvents();
 
    if (!events.empty()) {
        std::ostringstream oss;
 
 
        int count = 0;
        for (auto it = events.rbegin(); it != events.rend() && count < 2; ++it, ++count) {
            oss << "• " << *it << "\n";
        }
 
        buf_onaccess_report_->set_text(oss.str());
    } else {
        buf_onaccess_report_->set_text(_("Nessun file scansionato di recente."));
    }
 
    // Stato Anti-Ransomware → servizio utente
    bool ransom_ok = check_service_active("BastionGuard-ransomware-realtime.service");
    if (ransom_ok) {
        lbl_ransomware_status_.set_markup(
            _("<b>Anti-Ransomware:</b> <span foreground='green'><b>Attivo</b></span>")
        );
    } else {
        lbl_ransomware_status_.set_markup(
            _("<b>Anti-Ransomware:</b> <span foreground='red'><b>Disattivato</b></span>")
        );
    }
 
 
    bool phish_ok = check_service_active("BastionGuard-phishing-scanner.service");
    if (phish_ok) {
        lbl_phishing_status_.set_markup(
            _("<b>Anti-Phishing:</b> <span foreground='green'><b>Attivo</b></span>")
        );
    } else {
        lbl_phishing_status_.set_markup(
            _("<b>Anti-Phishing:</b> <span foreground='red'><b>Disattivato</b></span>")
        );
    }
}