PasswordVaultView.cpp

Go to the documentation of this file.

/*
 * BastionGuard™
 * Copyright (C) 2025–2026 Calogero Scarnà
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 *
 * BastionGuard™ is a trademark of Calogero Scarnà.
 * The BastionGuard™ name and branding are not licensed under the GPL.
 */
 
#include "PasswordVaultView.hpp"
#include <glibmm/i18n.h>
#include <algorithm>
#include <fstream>
 
 
PasswordVaultView::PasswordVaultView(Gtk::Window& parent, PasswordVault& vault)
: parent_(parent),
  vault_(vault),
  toolBar_(Gtk::Orientation::HORIZONTAL, 8),
  exportBtn_(_("💾  Esporta CSV"))
{
    dialog_ = new Gtk::Dialog(_("Vault — credenziali salvate"), parent, true);
    dialog_->set_default_size(820, 580);
    buildUi();
}
 
PasswordVaultView::~PasswordVaultView() {
    delete dialog_;
}
 
void PasswordVaultView::present() {
    entries_ = vault_.loadIndex();
    populate();
    dialog_->present();
}
 
 
void PasswordVaultView::buildUi() {
    auto* content = dialog_->get_content_area();
    content->set_margin(0);
    content->set_spacing(0);
 
    auto* mainBox = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 8);
    mainBox->set_margin(16);
 
    toolBar_.set_margin_bottom(4);
 
    searchEntry_.set_placeholder_text(_("Filtra per nome, username, URL…"));
    searchEntry_.set_hexpand(true);
    searchEntry_.signal_search_changed().connect(
        sigc::mem_fun(*this, &PasswordVaultView::onSearchChanged));
 
    countLabel_.set_xalign(0.0f);
    countLabel_.get_style_context()->add_class("dim-label");
 
    styleExportButton();
 
    toolBar_.append(searchEntry_);
    toolBar_.append(countLabel_);
    toolBar_.append(exportBtn_);
    mainBox->append(toolBar_);
 
    mainBox->append(*Gtk::make_managed<Gtk::Separator>(Gtk::Orientation::HORIZONTAL));
 
    {
        auto* hdr = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 0);
        hdr->set_margin_start(8);
        hdr->set_margin_end(8);
        hdr->set_margin_top(4);
        hdr->set_margin_bottom(4);
 
        auto makeHdr = [](const std::string& t, int chars) {
            auto* l = Gtk::make_managed<Gtk::Label>();
            l->set_markup("<b>" + Glib::Markup::escape_text(t) + "</b>");
            l->set_xalign(0.0f);
            l->set_width_chars(chars);
            l->set_max_width_chars(chars);
            l->set_ellipsize(Pango::EllipsizeMode::END);
            return l;
        };
        hdr->append(*makeHdr(_("Nome / Sito"),   24));
        hdr->append(*makeHdr(_("Username"),       20));
        hdr->append(*makeHdr(_("URL"),            26));
        hdr->append(*makeHdr(_("Aggiornato"),     16));
        mainBox->append(*hdr);
    }
 
    mainBox->append(*Gtk::make_managed<Gtk::Separator>(Gtk::Orientation::HORIZONTAL));
 
    // ── Lista ──
    list_.set_selection_mode(Gtk::SelectionMode::SINGLE);
    scrolled_.set_child(list_);
    scrolled_.set_vexpand(true);
    mainBox->append(scrolled_);
 
    content->append(*mainBox);
    dialog_->add_button(_("Chiudi"), Gtk::ResponseType::CANCEL);
 
    dialog_->signal_response().connect([this](int) { dialog_->hide(); });
 
    exportBtn_.signal_clicked().connect(
        sigc::mem_fun(*this, &PasswordVaultView::onExportClicked));
}
 
void PasswordVaultView::styleExportButton() {
    exportBtn_.get_style_context()->add_class("suggested-action");
    auto provider = Gtk::CssProvider::create();
    provider->load_from_data(
        "button.suggested-action {"
        "  background: linear-gradient(to bottom, #3584e4, #1c71d8);"
        "  color: white;"
        "  font-weight: bold;"
        "  padding: 6px 18px;"
        "  border-radius: 6px;"
        "  border: 1px solid #1558b0;"
        "}");
    exportBtn_.get_style_context()->add_provider(
        provider, GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
}
 
 
void PasswordVaultView::populate(const std::string& filter) {
    while (auto* child = list_.get_first_child())
        list_.remove(*child);
 
    std::string needle = filter;
    std::transform(needle.begin(), needle.end(), needle.begin(), ::tolower);
 
    int shown = 0;
    for (const auto& entry : entries_) {
        std::string hay = entry.name + " " + entry.username + " " + entry.url;
        std::transform(hay.begin(), hay.end(), hay.begin(), ::tolower);
        if (!needle.empty() && hay.find(needle) == std::string::npos) continue;
 
        auto* row = Gtk::make_managed<Gtk::ListBoxRow>();
        auto* box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 0);
        box->set_margin_top(6);
        box->set_margin_bottom(6);
        box->set_margin_start(8);
        box->set_margin_end(8);
 
        auto makeCell = [](const std::string& t, int chars) {
            auto* l = Gtk::make_managed<Gtk::Label>(t);
            l->set_xalign(0.0f);
            l->set_width_chars(chars);
            l->set_max_width_chars(chars);
            l->set_ellipsize(Pango::EllipsizeMode::END);
            return l;
        };
 
        box->append(*makeCell(entry.name,       24));
        box->append(*makeCell(entry.username,   20));
        box->append(*makeCell(entry.url,        26));
        box->append(*makeCell(entry.updated_at, 16));
        auto* pwdBtn = Gtk::make_managed<Gtk::Button>(_("👁"));
        pwdBtn->set_tooltip_text(_("Mostra password"));
        pwdBtn->get_style_context()->add_class("flat");
        pwdBtn->signal_clicked().connect([this, entry]() {
            showEntryDetail(entry);
        });
        box->append(*pwdBtn);
 
        row->set_child(*box);
        list_.append(*row);
        ++shown;
    }
 
    countLabel_.set_text(std::to_string(shown) + " / " +
                         std::to_string(entries_.size()) +
                         std::string(_(" credenziali")));
}
 
 
void PasswordVaultView::onSearchChanged() {
    populate(searchEntry_.get_text());
}
 
 
void PasswordVaultView::showEntryDetail(const PasswordEntry& entry) {
    vault_.getSecretAsync(entry.id, [this, entry](std::string secret) {
        auto* dlg = new Gtk::Dialog(_("Dettaglio credenziale"), *dialog_, true);
        dlg->set_default_size(420, 320);
 
        auto* box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 10);
        box->set_margin(16);
 
        auto addRow = [&](const std::string& label, const std::string& value, bool selectable = true) {
            auto* row = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 8);
            auto* lbl = Gtk::make_managed<Gtk::Label>();
            lbl->set_markup("<b>" + Glib::Markup::escape_text(label) + "</b>");
            lbl->set_xalign(0.0f);
            lbl->set_size_request(100, -1);
 
            auto* val = Gtk::make_managed<Gtk::Label>(value);
            val->set_xalign(0.0f);
            val->set_hexpand(true);
            val->set_selectable(selectable);
            val->set_ellipsize(Pango::EllipsizeMode::END);
 
            row->append(*lbl);
            row->append(*val);
            box->append(*row);
        };
 
        addRow(_("Nome:"),     entry.name);
        addRow(_("Username:"), entry.username);
        addRow(_("URL:"),      entry.url);
        addRow(_("Password:"), secret, true);
        if (!entry.notes.empty())
            addRow(_("Note:"), entry.notes);
        addRow(_("Creato:"),   entry.created_at, false);
        addRow(_("Modificato:"), entry.updated_at, false);
 
        dlg->get_content_area()->set_margin(0);
        dlg->get_content_area()->append(*box);
        dlg->add_button(_("Chiudi"), Gtk::ResponseType::CANCEL);
 
        dlg->signal_response().connect([dlg](int) {
            dlg->hide();
            delete dlg;
        });
        dlg->present();
    });
}
 
 
void PasswordVaultView::onExportClicked() {
    auto* fc = new Gtk::FileChooserDialog(
        _("Salva CSV"), Gtk::FileChooser::Action::SAVE);
    fc->set_transient_for(*dialog_);
    fc->set_modal(true);
    fc->set_current_name("passwords_export.csv");
 
    auto filter = Gtk::FileFilter::create();
    filter->set_name(_("File CSV (*.csv)"));
    filter->add_pattern("*.csv");
    fc->add_filter(filter);
 
    fc->add_button(_("Annulla"), Gtk::ResponseType::CANCEL);
    fc->add_button(_("Salva"),   Gtk::ResponseType::OK);
 
    fc->signal_response().connect([this, fc](int r) {
        if (r == Gtk::ResponseType::OK) {
            const auto file = fc->get_file();
            if (file) {
                const std::string path = file->get_path();
                exportBtn_.set_sensitive(false);
                exportBtn_.set_label(_("⏳  Esportazione…"));
 
                vault_.exportToCSV([this, path](std::string csv, std::string err) {
                    exportBtn_.set_sensitive(true);
                    exportBtn_.set_label(_("💾  Esporta CSV"));
 
                    if (!err.empty()) {
                        auto* msg = new Gtk::MessageDialog(
                            *dialog_, _("Errore export"),
                            false, Gtk::MessageType::ERROR,
                            Gtk::ButtonsType::CLOSE, true);
                        msg->set_secondary_text(err);
                        msg->signal_response().connect([msg](int) { msg->hide(); delete msg; });
                        msg->present();
                        return;
                    }
 
                    std::ofstream out(path, std::ios::trunc);
                    if (!out.good()) return;
                    out << csv;
 
                    auto* msg = new Gtk::MessageDialog(
                        *dialog_, _("Export completato"),
                        false, Gtk::MessageType::INFO,
                        Gtk::ButtonsType::CLOSE, true);
                    msg->set_secondary_text(
                        std::to_string(entries_.size()) +
                        std::string(_(" credenziali salvate in:\n")) + path);
                    msg->signal_response().connect([msg](int) { msg->hide(); delete msg; });
                    msg->present();
                });
            }
        }
        fc->hide();
        delete fc;
    });
    fc->present();
}