SettingsStore Class Reference

#include <SettingsStore.hpp>

Static Public Member Functions
static void	init ()
static void	reload ()
static bool	flush ()
static bool	reset_to_defaults ()
static bool	get_secure_payments_enabled ()
static void	set_secure_payments_enabled (bool enabled)
static std::string	get_language ()
static void	set_language (const std::string &lang)
static void	apply_language ()
static std::string	get_string (const std::string &dotted_key, const std::string &fallback_default)
static void	set_string (const std::string &dotted_key, const std::string &value)
static void	ensure_payments_json_exists ()
static std::vector< std::string >	get_payment_domains ()
static bool	save_payment_domains_user (const std::vector< std::string > &domains)
static bool	reset_payment_domains_from_system ()

Static Private Member Functions
static std::string	settings_file_path ()
static nlohmann::json	defaults ()
static void	ensure_loaded_locked ()
static bool	load_from_disk_locked ()
static bool	write_to_disk_locked (const nlohmann::json &j)
static nlohmann::json *	get_or_create_node_locked (nlohmann::json &root, const std::string &dotted_key)
static const nlohmann::json *	get_node_locked (const nlohmann::json &root, const std::string &dotted_key)
static bool	get_bool (const std::string &dotted_key, bool fallback_default)
static void	set_bool (const std::string &dotted_key, bool value)
static int	get_int (const std::string &dotted_key, int fallback_default)
static void	set_int (const std::string &dotted_key, int value)
static std::string	user_payments_path ()
static std::string	system_payments_path ()
static nlohmann::json	default_payments_seed ()
static bool	read_json_file (const std::string &path, nlohmann::json &out)
static bool	write_json_atomic (const std::string &path, const nlohmann::json &j)

Static Private Attributes
static std::mutex	mtx_
static bool	loaded_ = false
static nlohmann::json	cache_ = nlohmann::json::object()

Detailed Description

Definition at line 27 of file SettingsStore.hpp.

Member Function Documentation

apply_language()

void SettingsStore::apply_language ( )

static

Definition at line 293 of file SettingsStore.cpp.

                                   {
    // ── Fonte 1: settings.json ui.language ───────────────────────────────────
    const std::string from_settings = get_language();
 
    // ── Fonte 2: lang.conf ────────────────────────────────────────────────────
    const std::string lang_conf =
        Glib::get_home_dir() + "/.config/BastionGuard/lang.conf";
 
    // Leggi la lingua da lang.conf (es. "it_IT" da LANG=it_IT.UTF-8)
    std::string from_lang_conf;
    {
        std::ifstream f(lang_conf);
        std::string line;
        while (std::getline(f, line)) {
            // Cerca LANG= o LANGUAGE= per estrarre il codice lingua
            if (line.rfind("LANGUAGE=", 0) == 0) {
                from_lang_conf = line.substr(9);
                // Prendi solo la prima voce (es. "it_IT:it" → "it_IT")
                const auto colon = from_lang_conf.find(':');
                if (colon != std::string::npos)
                    from_lang_conf = from_lang_conf.substr(0, colon);
                break;
            }
        }
    }
 
    // Determina la lingua effettiva da usare:
    // Se settings.json è vuoto o è ancora il default "en_US" E lang.conf
    // ha qualcosa di diverso → lang.conf vince (migrazione automatica).
    std::string lang;
    const bool settings_is_default =
        from_settings.empty() || from_settings == "en_US";
 
    if (settings_is_default && !from_lang_conf.empty()
                             && from_lang_conf != "en_US") {
        lang = from_lang_conf;
        // Scrivi in settings.json così i prossimi avvii usano direttamente quello
        set_language(lang);
        std::cerr << "[i18n] migrated language from lang.conf to settings.json: "
                  << lang << "\n";
    } else if (!from_settings.empty()) {
        lang = from_settings;
        std::cerr << "[i18n] language from settings.json: " << lang << "\n";
    } else if (!from_lang_conf.empty()) {
        lang = from_lang_conf;
        std::cerr << "[i18n] language from lang.conf: " << lang << "\n";
    } else {
        std::cerr << "[i18n] no language configured, using system locale\n";
        setlocale(LC_ALL, "");
        return;
    }
 
    setenv("LANGUAGE", lang.c_str(), 1);
    setenv("LANG",    (lang + ".UTF-8").c_str(), 1);
    setenv("LC_ALL",  (lang + ".UTF-8").c_str(), 1);
    if (!setlocale(LC_ALL, (lang + ".UTF-8").c_str()))
        if (!setlocale(LC_ALL, lang.c_str()))
            setlocale(LC_ALL, "");
}

References get_language(), and set_language().

Referenced by main().

default_payments_seed()

nlohmann::json SettingsStore::default_payments_seed ( )

staticprivate

Definition at line 374 of file SettingsStore.cpp.

                                                  {
    nlohmann::json j;
    j["version"] = 1;
    j["updated_at"] = "2026-01-13";
    j["list"] = nlohmann::json::array({
        "paypal.com",
        "stripe.com",
        "adyen.com",
        "klarna.com",
        "checkout.com",
        "worldpay.com",
        "braintreepayments.com",
        "braintreegateway.com",
        "amazonpay.com",
        "pay.google.com",
        "pay.apple.com",
        "sisalpay.it",
        "nexi.it",
        "payments.amazon.com"
    });
    return j;
}

Referenced by ensure_payments_json_exists().

defaults()

nlohmann::json SettingsStore::defaults ( )

staticprivate

Definition at line 45 of file SettingsStore.cpp.

                                     {
    nlohmann::json j;
    j["security"] = nlohmann::json::object();
    j["security"]["secure_payments_enabled"] = false;
 
    j["ui"] = nlohmann::json::object();
    j["ui"]["language"] = "";  // vuoto = leggi da lang.conf
 
    return j;
}

Referenced by ensure_loaded_locked(), and reset_to_defaults().

ensure_loaded_locked()

void SettingsStore::ensure_loaded_locked ( )

staticprivate

Definition at line 75 of file SettingsStore.cpp.

                                         {
    if (loaded_) return;
 
    cache_ = defaults();
 
    load_from_disk_locked();
 
    loaded_ = true;
}

References cache_, defaults(), load_from_disk_locked(), and loaded_.

Referenced by flush(), get_bool(), get_int(), get_string(), init(), reload(), set_bool(), set_int(), and set_string().

ensure_payments_json_exists()

void SettingsStore::ensure_payments_json_exists ( )

static

Definition at line 439 of file SettingsStore.cpp.

                                                {
    std::lock_guard<std::mutex> lk(mtx_);
 
    const auto up = user_payments_path();
    const auto sp = system_payments_path();
 
    if (fs::exists(up)) return;
    if (fs::exists(sp)) {
        try {
            fs::create_directories(fs::path(up).parent_path());
            std::ifstream in(sp, std::ios::binary);
            std::ofstream out(up, std::ios::binary | std::ios::trunc);
            if (in.good() && out.good()) {
                out << in.rdbuf();
                return;
            }
        } catch (...) {
        }
    }
 
    write_json_atomic(up, default_payments_seed());
}

References default_payments_seed(), mtx_, system_payments_path(), user_payments_path(), and write_json_atomic().

Referenced by get_payment_domains().

flush()

bool SettingsStore::flush ( )

static

Definition at line 139 of file SettingsStore.cpp.

                          {
    std::lock_guard<std::mutex> lk(mtx_);
    ensure_loaded_locked();
    return write_to_disk_locked(cache_);
}

References cache_, ensure_loaded_locked(), mtx_, and write_to_disk_locked().

get_bool()

bool SettingsStore::get_bool ( const std::string & dotted_key, bool fallback_default )

staticprivate

Definition at line 187 of file SettingsStore.cpp.

                                                                               {
    std::lock_guard<std::mutex> lk(mtx_);
    ensure_loaded_locked();
 
    const auto* n = get_node_locked(cache_, dotted_key);
    if (!n) return fallback_default;
    if (n->is_boolean()) return n->get<bool>();
    return fallback_default;
}

References cache_, ensure_loaded_locked(), get_node_locked(), and mtx_.

Referenced by get_secure_payments_enabled().

get_int()

int SettingsStore::get_int ( const std::string & dotted_key, int fallback_default )

staticprivate

Definition at line 211 of file SettingsStore.cpp.

                                                                            {
    std::lock_guard<std::mutex> lk(mtx_);
    ensure_loaded_locked();
 
    const auto* n = get_node_locked(cache_, dotted_key);
    if (!n) return fallback_default;
    if (n->is_number_integer()) return n->get<int>();
    if (n->is_number()) return static_cast<int>(n->get<double>());
    return fallback_default;
}

References cache_, ensure_loaded_locked(), get_node_locked(), and mtx_.

get_language()

std::string SettingsStore::get_language ( )

static

Definition at line 270 of file SettingsStore.cpp.

                                      {
    return get_string("ui.language", "");
}

References get_string().

Referenced by apply_language().

get_node_locked()

const nlohmann::json * SettingsStore::get_node_locked ( const nlohmann::json & root, const std::string & dotted_key )

staticprivate

Definition at line 175 of file SettingsStore.cpp.

                                                                                                        {
    auto parts = split_dotted(dotted_key);
    if (parts.empty()) return nullptr;
 
    const nlohmann::json* node = &root;
    for (const auto& k : parts) {
        if (!node->is_object() || !node->contains(k)) return nullptr;
        node = &(*node)[k];
    }
    return node;
}

References split_dotted().

Referenced by get_bool(), get_int(), and get_string().

get_or_create_node_locked()

nlohmann::json * SettingsStore::get_or_create_node_locked ( nlohmann::json & root, const std::string & dotted_key )

staticprivate

Definition at line 160 of file SettingsStore.cpp.

                                                                                                      {
    auto parts = split_dotted(dotted_key);
    if (parts.empty()) return nullptr;
 
    nlohmann::json* node = &root;
    for (size_t i = 0; i + 1 < parts.size(); ++i) {
        const auto& k = parts[i];
        if (!node->contains(k) || !(*node)[k].is_object()) {
            (*node)[k] = nlohmann::json::object();
        }
        node = &(*node)[k];
    }
    return node;
}

References split_dotted().

Referenced by set_bool(), set_int(), and set_string().

get_payment_domains()

std::vector< std::string > SettingsStore::get_payment_domains ( )

static

Definition at line 480 of file SettingsStore.cpp.

                                                        {
    ensure_payments_json_exists();
 
    std::lock_guard<std::mutex> lk(mtx_);
 
    std::vector<std::string> tmp;
    nlohmann::json jsys, jusr;
    if (read_json_file(system_payments_path(), jsys)) extract_domains_from_payments_json(jsys, tmp);
    if (read_json_file(user_payments_path(), jusr))  extract_domains_from_payments_json(jusr, tmp);
 
    // dedup + sort
    std::unordered_set<std::string> uniq;
    std::vector<std::string> out;
    out.reserve(tmp.size());
 
    for (auto& d : tmp) {
        d = normalize_domain(d);
        if (d.empty()) continue;
        if (uniq.insert(d).second) out.push_back(d);
    }
 
    std::sort(out.begin(), out.end());
    return out;
}

References ensure_payments_json_exists(), extract_domains_from_payments_json(), mtx_, normalize_domain(), read_json_file(), system_payments_path(), and user_payments_path().

get_secure_payments_enabled()

bool SettingsStore::get_secure_payments_enabled ( )

static

Definition at line 261 of file SettingsStore.cpp.

                                                {
    // usa default ufficiale (false)
    return get_bool("security.secure_payments_enabled", false);
}

References get_bool().

Referenced by SettingsPage::build_secure_payments_tab(), BankOpener::is_payment_domain(), is_payment_domain(), and SecureList::is_payment_domain().

get_string()

std::string SettingsStore::get_string ( const std::string & dotted_key, const std::string & fallback_default )

static

Definition at line 236 of file SettingsStore.cpp.

                                                                                                  {
    std::lock_guard<std::mutex> lk(mtx_);
    ensure_loaded_locked();
 
    const auto* n = get_node_locked(cache_, dotted_key);
    if (!n) return fallback_default;
    if (n->is_string()) return n->get<std::string>();
    return fallback_default;
}

References cache_, ensure_loaded_locked(), get_node_locked(), and mtx_.

Referenced by get_language().

init()

void SettingsStore::init ( )

static

Definition at line 56 of file SettingsStore.cpp.

                         {
    std::lock_guard<std::mutex> lk(mtx_);
    ensure_loaded_locked();
}

References ensure_loaded_locked(), and mtx_.

load_from_disk_locked()

bool SettingsStore::load_from_disk_locked ( )

staticprivate

Definition at line 85 of file SettingsStore.cpp.

                                          {
    const auto path = settings_file_path();
 
    if (!fs::exists(path)) {
        return true;
    }
 
    try {
        std::ifstream in(path, std::ios::binary);
        if (!in.good()) return false;
 
        nlohmann::json disk;
        in >> disk;
        cache_.merge_patch(disk);
 
        return true;
    } catch (...) {
        return false;
    }
}

References cache_, and settings_file_path().

Referenced by ensure_loaded_locked().

read_json_file()

bool SettingsStore::read_json_file ( const std::string & path, nlohmann::json & out )

staticprivate

Definition at line 397 of file SettingsStore.cpp.

                                                                           {
    try {
        if (!fs::exists(path)) return false;
        std::ifstream in(path, std::ios::binary);
        if (!in.good()) return false;
        in >> out;
        return true;
    } catch (...) {
        return false;
    }
}

Referenced by get_payment_domains().

reload()

void SettingsStore::reload ( )

static

Definition at line 61 of file SettingsStore.cpp.

                           {
    std::lock_guard<std::mutex> lk(mtx_);
    loaded_ = false;
    cache_.clear();
    ensure_loaded_locked();
}

References cache_, ensure_loaded_locked(), loaded_, and mtx_.

reset_payment_domains_from_system()

bool SettingsStore::reset_payment_domains_from_system ( )

static

Definition at line 523 of file SettingsStore.cpp.

                                                      {
    std::lock_guard<std::mutex> lk(mtx_);
 
    const auto sp = system_payments_path();
    const auto up = user_payments_path();
 
    if (!fs::exists(sp)) return false;
 
    try {
        fs::create_directories(fs::path(up).parent_path());
        std::ifstream in(sp, std::ios::binary);
        std::ofstream out(up, std::ios::binary | std::ios::trunc);
        if (!in.good() || !out.good()) return false;
        out << in.rdbuf();
        return true;
    } catch (...) {
        return false;
    }
}

References mtx_, system_payments_path(), and user_payments_path().

reset_to_defaults()

bool SettingsStore::reset_to_defaults ( )

static

Definition at line 68 of file SettingsStore.cpp.

                                      {
    std::lock_guard<std::mutex> lk(mtx_);
    cache_ = defaults();
    loaded_ = true;
    return write_to_disk_locked(cache_);
}

References cache_, defaults(), loaded_, mtx_, and write_to_disk_locked().

save_payment_domains_user()

bool SettingsStore::save_payment_domains_user ( const std::vector< std::string > & domains )

static

Definition at line 505 of file SettingsStore.cpp.

                                                                                 {
    std::lock_guard<std::mutex> lk(mtx_);
 
    nlohmann::json j;
    j["version"] = 1;
    j["updated_at"] = "2026-01-13";
    j["list"] = nlohmann::json::array();
 
    std::unordered_set<std::string> uniq;
    for (auto d : domains) {
        d = normalize_domain(d);
        if (d.empty()) continue;
        if (uniq.insert(d).second) j["list"].push_back(d);
    }
 
    return write_json_atomic(user_payments_path(), j);
}

References mtx_, normalize_domain(), user_payments_path(), and write_json_atomic().

set_bool()

void SettingsStore::set_bool ( const std::string & dotted_key, bool value )

staticprivate

Definition at line 197 of file SettingsStore.cpp.

                                                                    {
    std::lock_guard<std::mutex> lk(mtx_);
    ensure_loaded_locked();
 
    auto parts = split_dotted(dotted_key);
    if (parts.empty()) return;
 
    nlohmann::json* parent = get_or_create_node_locked(cache_, dotted_key);
    if (!parent) return;
 
    (*parent)[parts.back()] = value;
    write_to_disk_locked(cache_);
}

References cache_, ensure_loaded_locked(), get_or_create_node_locked(), mtx_, split_dotted(), and write_to_disk_locked().

Referenced by set_secure_payments_enabled().

set_int()

void SettingsStore::set_int ( const std::string & dotted_key, int value )

staticprivate

Definition at line 222 of file SettingsStore.cpp.

                                                                  {
    std::lock_guard<std::mutex> lk(mtx_);
    ensure_loaded_locked();
 
    auto parts = split_dotted(dotted_key);
    if (parts.empty()) return;
 
    nlohmann::json* parent = get_or_create_node_locked(cache_, dotted_key);
    if (!parent) return;
 
    (*parent)[parts.back()] = value;
    write_to_disk_locked(cache_);
}

References cache_, ensure_loaded_locked(), get_or_create_node_locked(), mtx_, split_dotted(), and write_to_disk_locked().

set_language()

void SettingsStore::set_language ( const std::string & lang )

static

Definition at line 274 of file SettingsStore.cpp.

                                                      {
    set_string("ui.language", lang);
 
    // Mantieni lang.conf sincronizzato — usato dai binari che girano
    // prima che SettingsStore sia inizializzato (es. script di sistema).
    const std::string lang_conf =
        Glib::get_home_dir() + "/.config/BastionGuard/lang.conf";
    try {
        std::filesystem::create_directories(
            std::filesystem::path(lang_conf).parent_path());
        std::ofstream f(lang_conf, std::ios::trunc);
        if (f.is_open()) {
            f << "LANG="     << lang << ".UTF-8\n"
              << "LC_ALL="   << lang << ".UTF-8\n"
              << "LANGUAGE=" << lang << ":" << lang.substr(0, 2) << "\n";
        }
    } catch (...) {}
}

References set_string().

Referenced by apply_language().

set_secure_payments_enabled()

void SettingsStore::set_secure_payments_enabled ( bool enabled )

static

Definition at line 266 of file SettingsStore.cpp.

                                                            {
    set_bool("security.secure_payments_enabled", enabled);
}

References set_bool().

Referenced by SettingsPage::build_secure_payments_tab().

set_string()

void SettingsStore::set_string ( const std::string & dotted_key, const std::string & value )

static

Definition at line 246 of file SettingsStore.cpp.

                                                                                  {
    std::lock_guard<std::mutex> lk(mtx_);
    ensure_loaded_locked();
 
    auto parts = split_dotted(dotted_key);
    if (parts.empty()) return;
 
    nlohmann::json* parent = get_or_create_node_locked(cache_, dotted_key);
    if (!parent) return;
 
    (*parent)[parts.back()] = value;
    write_to_disk_locked(cache_);
}

References cache_, ensure_loaded_locked(), get_or_create_node_locked(), mtx_, split_dotted(), and write_to_disk_locked().

Referenced by set_language().

settings_file_path()

std::string SettingsStore::settings_file_path ( )

staticprivate

Definition at line 41 of file SettingsStore.cpp.

                                            {
    return config_dir_path() + "/settings.json";
}

References config_dir_path().

Referenced by load_from_disk_locked(), and write_to_disk_locked().

system_payments_path()

std::string SettingsStore::system_payments_path ( )

staticprivate

Definition at line 357 of file SettingsStore.cpp.

                                              {
    return "/usr/share/BastionGuard/data/payments/payments.json";
}

Referenced by ensure_payments_json_exists(), get_payment_domains(), and reset_payment_domains_from_system().

user_payments_path()

std::string SettingsStore::user_payments_path ( )

staticprivate

Definition at line 353 of file SettingsStore.cpp.

                                            {
    return Glib::get_home_dir() + "/.config/BastionGuard/payments.json";
}

Referenced by ensure_payments_json_exists(), get_payment_domains(), reset_payment_domains_from_system(), and save_payment_domains_user().

write_json_atomic()

bool SettingsStore::write_json_atomic ( const std::string & path, const nlohmann::json & j )

staticprivate

Definition at line 409 of file SettingsStore.cpp.

                                                                                  {
    try {
        fs::create_directories(fs::path(path).parent_path());
        const auto tmp = path + ".tmp";
 
        {
            std::ofstream out(tmp, std::ios::binary | std::ios::trunc);
            if (!out.good()) return false;
            out << j.dump(2);
            out.flush();
            if (!out.good()) return false;
        }
 
        std::error_code ec;
        fs::rename(tmp, path, ec);
        if (ec) {
            fs::remove(path, ec);
            ec.clear();
            fs::rename(tmp, path, ec);
            if (ec) {
                fs::remove(tmp, ec);
                return false;
            }
        }
        return true;
    } catch (...) {
        return false;
    }
}

Referenced by ensure_payments_json_exists(), and save_payment_domains_user().

write_to_disk_locked()

bool SettingsStore::write_to_disk_locked ( const nlohmann::json & j )

staticprivate

Definition at line 106 of file SettingsStore.cpp.

                                                              {
    const auto dir  = config_dir_path();
    const auto path = settings_file_path();
    const auto tmp  = path + ".tmp";
 
    try {
        fs::create_directories(dir);
        {
            std::ofstream out(tmp, std::ios::binary | std::ios::trunc);
            if (!out.good()) return false;
            out << j.dump(2);
            out.flush();
            if (!out.good()) return false;
        }
 
        std::error_code ec;
        fs::rename(tmp, path, ec);
        if (ec) {
            fs::remove(path, ec);
            ec.clear();
            fs::rename(tmp, path, ec);
            if (ec) {
                fs::remove(tmp, ec);
                return false;
            }
        }
 
        return true;
    } catch (...) {
        return false;
    }
}

References config_dir_path(), and settings_file_path().

Referenced by flush(), reset_to_defaults(), set_bool(), set_int(), and set_string().

Member Data Documentation

cache_

nlohmann::json SettingsStore::cache_ = nlohmann::json::object()

staticprivate

Definition at line 76 of file SettingsStore.hpp.

Referenced by ensure_loaded_locked(), flush(), get_bool(), get_int(), get_string(), load_from_disk_locked(), reload(), reset_to_defaults(), set_bool(), set_int(), and set_string().

loaded_

bool SettingsStore::loaded_ = false

staticprivate

Definition at line 75 of file SettingsStore.hpp.

Referenced by ensure_loaded_locked(), reload(), and reset_to_defaults().

mtx_

std::mutex SettingsStore::mtx_

staticprivate

Definition at line 74 of file SettingsStore.hpp.

Referenced by ensure_payments_json_exists(), flush(), get_bool(), get_int(), get_payment_domains(), get_string(), init(), reload(), reset_payment_domains_from_system(), reset_to_defaults(), save_payment_domains_user(), set_bool(), set_int(), and set_string().

---

The documentation for this class was generated from the following files:

• BastionGuard/src/SettingsStore.hpp
• BastionGuard/src/SettingsStore.cpp