FinceptTerminal is a modern finance application offering advanced market analytics, investment research, and economic data tools, designed for interactive exploration and data-driven decision-making in a user-friendly environment.
C++ ai-agentsalgorithmic-tradingbloomberg-terminalcppfinancefinancial-marketsfintechgood-first-issueinvestmentinvestment-researchmachine-learningopensourcepythonqtquantitative-financestock-markettrading
#include "core/layout/LayoutCatalog.h"
#include "core/layout/WorkspaceShell.h"
#include "core/logging/Logger.h"
#include "core/profile/ProfilePaths.h"
#include <QDateTime>
#include <QDir>
#include <QFile>
#include <QFileInfo>
#include <QJsonDocument>
#include <QJsonObject>
#include <QSaveFile>
#include <QSqlDatabase>
#include <QSqlError>
#include <QSqlQuery>
namespace fincept {
namespace {
constexpr const char* kCatalogTag = "LayoutCatalog";
constexpr const char* kConnectionName = "fincept_layouts_index";
QSqlDatabase& open_index_db_(const QString& path, bool& opened) {
static QSqlDatabase db;
if (opened)
return db;
db = QSqlDatabase::addDatabase("QSQLITE", kConnectionName);
db.setDatabaseName(path);
if (!db.open()) {
LOG_ERROR(kCatalogTag, QString("Failed to open layouts index db: %1").arg(db.lastError().text()));
opened = false;
} else {
opened = true;
}
return db;
}
} // namespace
LayoutCatalog& LayoutCatalog::instance() {
static LayoutCatalog s;
return s;
}
Result<void> LayoutCatalog::open() {
if (opened_)
return Result<void>::ok();
// Ensure layouts dir + index file path exist before SQLite opens.
QDir().mkpath(ProfilePaths::layouts_dir());
auto& db = open_index_db_(ProfilePaths::layouts_index_db(), opened_);
if (!opened_)
return Result<void>::err("layouts_index.db open failed");
QSqlQuery pragma(db);
pragma.exec("PRAGMA journal_mode = WAL");
pragma.exec("PRAGMA synchronous = NORMAL");
auto r = ensure_index_schema();
if (r.is_err()) {
opened_ = false;
return r;
}
LOG_INFO(kCatalogTag, "Layouts catalogue opened: " + ProfilePaths::layouts_index_db());
return Result<void>::ok();
}
Result<void> LayoutCatalog::ensure_index_schema() {
QSqlDatabase db = QSqlDatabase::database(kConnectionName);
if (!db.isOpen())
return Result<void>::err("index db not open");
QSqlQuery q(db);
if (!q.exec("CREATE TABLE IF NOT EXISTS layouts ("
" uuid TEXT PRIMARY KEY,"
" name TEXT NOT NULL,"
" kind TEXT NOT NULL,"
" created_at_unix INTEGER NOT NULL,"
" updated_at_unix INTEGER NOT NULL,"
" description TEXT,"
" thumbnail_path TEXT"
")")) {
return Result<void>::err(q.lastError().text().toStdString());
}
if (!q.exec("CREATE INDEX IF NOT EXISTS idx_layouts_kind_updated "
"ON layouts(kind, updated_at_unix DESC)")) {
LOG_WARN(kCatalogTag, QString("idx create failed: %1").arg(q.lastError().text()));
}
// `_meta` is a generic key/value store. Used today by:
// last_loaded_uuid — Phase 3 cold-boot restore pointer.
// fwsp_import_done — Phase 7 one-shot legacy import flag.
if (!q.exec("CREATE TABLE IF NOT EXISTS _meta ("
" key TEXT PRIMARY KEY,"
" value TEXT NOT NULL"
")")) {
return Result<void>::err(q.lastError().text().toStdString());
}
return Result<void>::ok();
}
QString LayoutCatalog::file_path_for_(const LayoutId& id) const {
return ProfilePaths::layouts_dir() + "/" + id.to_string() + ".json";
}
Result<void> LayoutCatalog::upsert_index_row(const layout::Workspace& w) {
QSqlDatabase db = QSqlDatabase::database(kConnectionName);
if (!db.isOpen())
return Result<void>::err("index db not open");
QSqlQuery q(db);
q.prepare("INSERT INTO layouts(uuid, name, kind, created_at_unix, updated_at_unix, "
" description, thumbnail_path) "
"VALUES (?, ?, ?, ?, ?, ?, ?) "
"ON CONFLICT(uuid) DO UPDATE SET "
" name=excluded.name, kind=excluded.kind, "
" updated_at_unix=excluded.updated_at_unix, "
" description=excluded.description, "
" thumbnail_path=excluded.thumbnail_path");
q.addBindValue(w.id.to_string());
q.addBindValue(w.name);
q.addBindValue(w.kind);
q.addBindValue(w.created_at_unix);
q.addBindValue(w.updated_at_unix);
q.addBindValue(w.description);
q.addBindValue(w.thumbnail_path);
if (!q.exec())
return Result<void>::err(q.lastError().text().toStdString());
return Result<void>::ok();
}
Result<LayoutId> LayoutCatalog::save_workspace(const layout::Workspace& w_in) {
if (!opened_) {
auto r = open();
if (r.is_err())
return Result<LayoutId>::err(r.error());
}
layout::Workspace w = w_in;
if (w.id.is_null())
w.id = LayoutId::generate();
const qint64 now = QDateTime::currentSecsSinceEpoch();
if (w.created_at_unix == 0)
w.created_at_unix = now;
w.updated_at_unix = now;
// Write the JSON file first; if that fails, we don't want a stale
// index row pointing at nothing.
// QSaveFile writes to a temp file and renames on commit(), so a crash or a
// full disk can no longer leave a truncated layout under the real name (the
// old Truncate-then-write also ignored a short write and reported success).
const QString path = file_path_for_(w.id);
QSaveFile f(path);
if (!f.open(QIODevice::WriteOnly))
return Result<LayoutId>::err(("Failed to open " + path + ": " + f.errorString()).toStdString());
f.write(QJsonDocument(w.to_json()).toJson(QJsonDocument::Indented));
if (!f.commit())
return Result<LayoutId>::err(("Failed to write " + path + ": " + f.errorString()).toStdString());
auto idx = upsert_index_row(w);
if (idx.is_err()) {
LOG_WARN(kCatalogTag, QString("File written but index update failed for %1: %2")
.arg(w.id.to_string(), QString::fromStdString(idx.error())));
return Result<LayoutId>::err(idx.error());
}
LOG_INFO(kCatalogTag, QString("Saved layout '%1' (uuid=%2)").arg(w.name, w.id.to_string()));
emit layout_saved(w.id);
return Result<LayoutId>::ok(w.id);
}
Result<layout::Workspace> LayoutCatalog::load_workspace(const LayoutId& id) {
if (!opened_) {
auto r = open();
if (r.is_err())
return Result<layout::Workspace>::err(r.error());
}
const QString path = file_path_for_(id);
QFile f(path);
if (!f.open(QIODevice::ReadOnly))
return Result<layout::Workspace>::err(("Failed to open " + path + ": " + f.errorString()).toStdString());
const QByteArray bytes = f.readAll();
f.close();
QJsonParseError err;
const QJsonDocument doc = QJsonDocument::fromJson(bytes, &err);
if (err.error != QJsonParseError::NoError)
return Result<layout::Workspace>::err(("Parse error in " + path + ": " + err.errorString()).toStdString());
if (!doc.isObject())
return Result<layout::Workspace>::err(("Layout file is not a JSON object: " + path).toStdString());
return Result<layout::Workspace>::ok(layout::Workspace::from_json(doc.object()));
}
Result<void> LayoutCatalog::remove_layout(const LayoutId& id) {
if (!opened_) {
auto r = open();
if (r.is_err())
return r;
}
QFile::remove(file_path_for_(id));
// Best-effort thumbnail cleanup; not fatal if it's missing.
QFile::remove(ProfilePaths::layouts_dir() + "/thumbs/" + id.to_string() + ".png");
QSqlDatabase db = QSqlDatabase::database(kConnectionName);
if (db.isOpen()) {
QSqlQuery q(db);
q.prepare("DELETE FROM layouts WHERE uuid = ?");
q.addBindValue(id.to_string());
q.exec();
}
// If the removed layout was pinned as last_loaded, clear the pointer so
// cold-boot doesn't try to restore a dead UUID.
auto last = meta(QStringLiteral("last_loaded_uuid"));
if (last.is_ok() && last.value() == id.to_string())
set_meta(QStringLiteral("last_loaded_uuid"), QString());
// If the removed layout is also the one this session has loaded, drop
// the in-memory current-name/id pointer so the title bar suffix and
// the toolbar's Save-vs-Save-As decision stop pointing at a dead UUID.
if (layout::WorkspaceShell::current_id() == id)
layout::WorkspaceShell::clear_current();
emit layout_removed(id);
return Result<void>::ok();
}
Result<QList<LayoutCatalog::Entry>> LayoutCatalog::list_layouts() {
if (!opened_) {
auto r = open();
if (r.is_err())
return Result<QList<Entry>>::err(r.error());
}
QSqlDatabase db = QSqlDatabase::database(kConnectionName);
if (!db.isOpen())
return Result<QList<Entry>>::err("index db not open");
QSqlQuery q(db);
if (!q.exec("SELECT uuid, name, kind, created_at_unix, updated_at_unix, "
" description, thumbnail_path "
"FROM layouts ORDER BY updated_at_unix DESC"))
return Result<QList<Entry>>::err(q.lastError().text().toStdString());
QList<Entry> out;
while (q.next()) {
Entry e;
e.id = LayoutId::from_string(q.value(0).toString());
e.name = q.value(1).toString();
e.kind = q.value(2).toString();
e.created_at_unix = q.value(3).toLongLong();
e.updated_at_unix = q.value(4).toLongLong();
e.description = q.value(5).toString();
e.thumbnail_path = q.value(6).toString();
out.append(e);
}
return Result<QList<Entry>>::ok(out);
}
Result<QList<LayoutCatalog::Entry>> LayoutCatalog::recent_layouts(int limit, bool include_auto) {
auto r = list_layouts();
if (r.is_err())
return r;
QList<Entry> filtered;
for (const auto& e : r.value()) {
if (!include_auto && e.kind == QStringLiteral("auto"))
continue;
filtered.append(e);
if (filtered.size() >= limit)
break;
}
return Result<QList<Entry>>::ok(filtered);
}
LayoutId LayoutCatalog::find_by_name(const QString& name) {
auto r = list_layouts();
if (r.is_err())
return LayoutId();
for (const auto& e : r.value()) {
if (e.name.compare(name, Qt::CaseInsensitive) == 0)
return e.id;
}
return LayoutId();
}
Result<void> LayoutCatalog::export_to(const LayoutId& id, const QString& path) {
auto wr = load_workspace(id);
if (wr.is_err())
return Result<void>::err(wr.error());
QSaveFile f(path);
if (!f.open(QIODevice::WriteOnly))
return Result<void>::err(("Export open failed: " + f.errorString()).toStdString());
f.write(QJsonDocument(wr.value().to_json()).toJson(QJsonDocument::Indented));
if (!f.commit())
return Result<void>::err(("Export write failed: " + f.errorString()).toStdString());
return Result<void>::ok();
}
Result<QString> LayoutCatalog::meta(const QString& key) const {
QSqlDatabase db = QSqlDatabase::database(kConnectionName);
if (!db.isOpen())
return Result<QString>::err("index db not open");
QSqlQuery q(db);
q.prepare("SELECT value FROM _meta WHERE key = ?");
q.addBindValue(key);
if (!q.exec())
return Result<QString>::err(q.lastError().text().toStdString());
if (q.next())
return Result<QString>::ok(q.value(0).toString());
return Result<QString>::ok(QString());
}
Result<void> LayoutCatalog::set_meta(const QString& key, const QString& value) {
QSqlDatabase db = QSqlDatabase::database(kConnectionName);
if (!db.isOpen())
return Result<void>::err("index db not open");
QSqlQuery q(db);
q.prepare("INSERT INTO _meta(key, value) VALUES(?, ?) "
"ON CONFLICT(key) DO UPDATE SET value = excluded.value");
q.addBindValue(key);
q.addBindValue(value);
if (!q.exec())
return Result<void>::err(q.lastError().text().toStdString());
return Result<void>::ok();
}
Result<LayoutId> LayoutCatalog::last_loaded_id() const {
auto m = meta(QStringLiteral("last_loaded_uuid"));
if (m.is_err())
return Result<LayoutId>::err(m.error());
if (m.value().isEmpty())
return Result<LayoutId>::ok(LayoutId());
return Result<LayoutId>::ok(LayoutId::from_string(m.value()));
}
Result<void> LayoutCatalog::set_last_loaded_id(const LayoutId& id) {
return set_meta(QStringLiteral("last_loaded_uuid"), id.is_null() ? QString() : id.to_string());
}
Result<LayoutId> LayoutCatalog::import_from(const QString& path) {
QFile f(path);
if (!f.open(QIODevice::ReadOnly))
return Result<LayoutId>::err(("Import open failed: " + f.errorString()).toStdString());
const QByteArray bytes = f.readAll();
f.close();
QJsonParseError err;
const QJsonDocument doc = QJsonDocument::fromJson(bytes, &err);
if (err.error != QJsonParseError::NoError)
return Result<LayoutId>::err(("Parse error: " + err.errorString()).toStdString());
if (!doc.isObject())
return Result<LayoutId>::err("Import failed: file is not a layout (JSON root is not an object)");
layout::Workspace w = layout::Workspace::from_json(doc.object());
// Mint a fresh id so two users importing the same shared file don't
// collide on the same UUID. Caller can override via save_workspace
// path-based copy if they really want to preserve cross-user identity.
w.id = LayoutId::generate();
return save_workspace(w);
}
} // namespace fincept