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 "services/cloud/PortfolioCloudAdapter.h"
#include "network/cloud/CloudClient.h"
#include "storage/repositories/PortfolioRepository.h"
#include "storage/sync/SyncMap.h"
#include "storage/sync/SyncOutbox.h"
#include <QHash>
#include <functional>
#include <memory>
namespace fincept::services::cloud {
using fincept::cloud::CloudClient;
using fincept::cloud::CloudResponse;
namespace {
QString pf_entity() {
return QStringLiteral("portfolio");
}
QString pf_txn_entity() {
return QStringLiteral("portfolio_txn");
}
QString pf_path(const QString& pfl) {
return QStringLiteral("/portfolios/") + pfl;
}
AdapterResult pf_ok() {
AdapterResult r;
r.ok = true;
return r;
}
AdapterResult pf_retry(const QString& why) {
AdapterResult r;
r.retry = true;
r.error = why;
return r;
}
AdapterResult pf_credits() {
AdapterResult r;
r.credits_exhausted = true;
r.error = QStringLiteral("insufficient_credits");
return r;
}
// portfolio fields only — broker_account_id is device-local and never sent.
QJsonObject portfolio_body(const portfolio::Portfolio& p) {
QJsonObject b;
b["name"] = p.name;
b["owner"] = p.owner;
b["currency"] = p.currency.isEmpty() ? QStringLiteral("USD") : p.currency;
b["description"] = p.description;
return b;
}
QJsonObject txn_body(const portfolio::Transaction& t) {
QJsonObject b;
b["symbol"] = t.symbol;
b["transaction_type"] = t.transaction_type;
b["quantity"] = t.quantity;
b["price"] = t.price;
b["transaction_date"] = t.transaction_date;
b["notes"] = t.notes;
return b;
}
QJsonObject snap_body(const portfolio::PortfolioSnapshot& s) {
QJsonObject b;
b["total_value"] = s.total_value;
b["total_cost_basis"] = s.total_cost_basis;
b["total_pnl"] = s.total_pnl;
b["total_pnl_percent"] = s.total_pnl_percent;
b["snapshot_date"] = s.snapshot_date;
return b;
}
// An async operation that reports (credits_exhausted, failed) on completion.
using Op = std::function<void(std::function<void(bool, bool)>)>;
// Fire all ops concurrently; aggregate into one push outcome.
void pf_run_ops(const QVector<Op>& ops, PushDone done) {
if (ops.isEmpty()) {
done(pf_ok());
return;
}
auto pending = std::make_shared<int>(ops.size());
auto credits = std::make_shared<bool>(false);
auto failed = std::make_shared<bool>(false);
std::function<void(bool, bool)> rep = [pending, credits, failed, done](bool c, bool f) {
if (c)
*credits = true;
if (f)
*failed = true;
if (--*pending == 0) {
if (*credits)
done(pf_credits());
else if (*failed)
done(pf_retry(QStringLiteral("reconcile_partial")));
else
done(pf_ok());
}
};
for (const Op& op : ops)
op(rep);
}
} // namespace
PortfolioCloudAdapter& PortfolioCloudAdapter::instance() {
static PortfolioCloudAdapter s;
return s;
}
void PortfolioCloudAdapter::push(const OutboxRow& row, PushDone done) {
if (row.op == QLatin1String("delete"))
push_delete(row, std::move(done));
else
push_sync(row, std::move(done)); // "sync" (and any default)
}
void PortfolioCloudAdapter::push_delete(const OutboxRow& row, PushDone done) {
auto remote = SyncMap::remote_id(pf_entity(), row.local_id);
if (!remote) {
done(pf_ok()); // never pushed
return;
}
const QString local_id = row.local_id;
CloudClient::instance().del(
pf_path(*remote),
[local_id, done](CloudResponse resp) {
if (resp.ok || resp.status == 404) {
SyncMap::remove_by_local(pf_entity(), local_id);
done(pf_ok());
} else if (resp.is_insufficient_credits()) {
done(pf_credits());
} else {
done(pf_retry(QStringLiteral("delete_failed")));
}
},
this);
}
void PortfolioCloudAdapter::push_sync(const OutboxRow& row, PushDone done) {
const QString local_pid = row.local_id;
auto p = PortfolioRepository::instance().get_portfolio(local_pid);
if (p.is_err()) {
done(pf_ok()); // portfolio gone locally — nothing to sync
return;
}
const QJsonObject body = portfolio_body(p.value());
auto remote = SyncMap::remote_id(pf_entity(), local_pid);
if (remote) {
const QString pfl = *remote;
CloudClient::instance().put(
pf_path(pfl), body,
[this, local_pid, pfl, done](CloudResponse r) {
if (r.is_insufficient_credits()) {
done(pf_credits());
return;
}
if (!r.ok && r.status != 404) {
done(pf_retry(QStringLiteral("portfolio_put_failed")));
return;
}
reconcile_up(local_pid, pfl, done);
},
this);
} else {
CloudClient::instance().post(
QStringLiteral("/portfolios"), body,
[this, local_pid, done](CloudResponse r) {
if (r.is_insufficient_credits()) {
done(pf_credits());
return;
}
if (!r.ok || !r.data.isObject()) {
done(pf_retry(QStringLiteral("portfolio_post_failed")));
return;
}
const QJsonObject o = r.data.toObject();
const QString pfl = o.value("id").toString();
SyncMap::put(pf_entity(), local_pid, pfl, o.value("created_at").toString());
reconcile_up(local_pid, pfl, done);
},
this);
}
}
void PortfolioCloudAdapter::reconcile_up(const QString& local_pid, const QString& pfl, PushDone done) {
// Chain the (free) GETs: detail (assets) → transactions → snapshots, then
// compute and fire all child mutations under one barrier.
CloudClient::instance().get(
pf_path(pfl),
[this, local_pid, pfl, done](CloudResponse dr) {
if (!dr.ok || !dr.data.isObject()) {
done(pf_retry(QStringLiteral("detail_failed")));
return;
}
const QJsonArray cloud_assets = dr.data.toObject().value("assets").toArray();
CloudClient::instance().get(
pf_path(pfl) + QStringLiteral("/transactions?page_size=500"),
[this, local_pid, pfl, cloud_assets, done](CloudResponse tr) {
const QJsonArray cloud_txns = (tr.ok && tr.data.isObject())
? tr.data.toObject().value("transactions").toArray()
: QJsonArray();
CloudClient::instance().get(
pf_path(pfl) + QStringLiteral("/snapshots?days=3650"),
[this, local_pid, pfl, cloud_assets, cloud_txns, done](CloudResponse sr) {
const QJsonArray cloud_snaps =
(sr.ok && sr.data.isArray()) ? sr.data.toArray() : QJsonArray();
auto& repo = PortfolioRepository::instance();
QVector<Op> ops;
auto post_op = [this](const QString& ep, const QJsonObject& b) -> Op {
return [this, ep, b](std::function<void(bool, bool)> rep) {
CloudClient::instance().post(
ep, b,
[rep](CloudResponse r) {
rep(r.is_insufficient_credits(), !r.ok && r.status != 404);
},
this);
};
};
auto put_op = [this](const QString& ep, const QJsonObject& b) -> Op {
return [this, ep, b](std::function<void(bool, bool)> rep) {
CloudClient::instance().put(
ep, b,
[rep](CloudResponse r) {
rep(r.is_insufficient_credits(), !r.ok && r.status != 404);
},
this);
};
};
auto del_op = [this](const QString& ep) -> Op {
return [this, ep](std::function<void(bool, bool)> rep) {
CloudClient::instance().del(
ep,
[rep](CloudResponse r) {
rep(r.is_insufficient_credits(), !r.ok && r.status != 404);
},
this);
};
};
// ── assets (by symbol): PUT existing / POST new / DELETE gone ──
QHash<QString, QJsonObject> cloud_by_sym;
for (const QJsonValue& v : cloud_assets)
cloud_by_sym.insert(v.toObject().value("symbol").toString().toUpper(), v.toObject());
QSet<QString> local_syms;
auto la = repo.get_assets(local_pid);
if (la.is_ok()) {
for (const portfolio::PortfolioAsset& a : la.value()) {
const QString sym = a.symbol.toUpper();
local_syms.insert(sym);
if (cloud_by_sym.contains(sym)) {
const QString pfa = cloud_by_sym.value(sym).value("id").toString();
QJsonObject b;
b["quantity"] = a.quantity;
b["avg_buy_price"] = a.avg_buy_price;
b["sector"] = a.sector;
b["broker_symbol"] = a.broker_symbol;
b["exchange"] = a.exchange;
ops.append(put_op(pf_path(pfl) + "/assets/" + pfa, b));
} else {
QJsonObject b;
b["symbol"] = a.symbol;
b["quantity"] = a.quantity;
b["avg_buy_price"] = a.avg_buy_price;
b["purchase_date"] = a.first_purchase_date;
b["sector"] = a.sector;
b["broker_symbol"] = a.broker_symbol;
b["exchange"] = a.exchange;
ops.append(post_op(pf_path(pfl) + "/assets", b));
}
}
}
for (auto it = cloud_by_sym.constBegin(); it != cloud_by_sym.constEnd(); ++it)
if (!local_syms.contains(it.key()))
ops.append(del_op(pf_path(pfl) + "/assets/" + it.value().value("id").toString()));
// ── transactions: POST unmapped locals / DELETE orphaned cloud ──
QSet<QString> local_txn_ids;
auto lt = repo.get_transactions(local_pid, 1000000);
if (lt.is_ok()) {
for (const portfolio::Transaction& t : lt.value()) {
local_txn_ids.insert(t.id);
if (!SyncMap::remote_id(pf_txn_entity(), t.id)) {
const QString uuid = t.id;
const QString ep = pf_path(pfl) + "/transactions";
const QJsonObject b = txn_body(t);
ops.append([this, ep, b, uuid](std::function<void(bool, bool)> rep) {
CloudClient::instance().post(
ep, b,
[rep, uuid](CloudResponse r) {
if (r.ok && r.data.isObject())
SyncMap::put(pf_txn_entity(), uuid,
r.data.toObject().value("id").toString(), {});
rep(r.is_insufficient_credits(), !r.ok);
},
this);
});
}
}
}
for (const QJsonValue& v : cloud_txns) {
const QString ptx = v.toObject().value("id").toString();
auto loc = SyncMap::local_id(pf_txn_entity(), ptx);
if (loc && !local_txn_ids.contains(*loc)) {
const QString uuid = *loc;
const QString ep = pf_path(pfl) + "/transactions/" + ptx;
ops.append([this, ep, uuid](std::function<void(bool, bool)> rep) {
CloudClient::instance().del(
ep,
[rep, uuid](CloudResponse r) {
if (r.ok || r.status == 404)
SyncMap::remove_by_local(pf_txn_entity(), uuid);
rep(r.is_insufficient_credits(), !r.ok && r.status != 404);
},
this);
});
}
}
// ── snapshots (by date): POST dates missing in cloud ──
QSet<QString> cloud_dates;
for (const QJsonValue& v : cloud_snaps)
cloud_dates.insert(v.toObject().value("snapshot_date").toString());
auto ls = repo.get_snapshots(local_pid, 3650);
if (ls.is_ok())
for (const portfolio::PortfolioSnapshot& s : ls.value())
if (!cloud_dates.contains(s.snapshot_date))
ops.append(post_op(pf_path(pfl) + "/snapshots", snap_body(s)));
pf_run_ops(ops, done);
},
this);
},
this);
},
this);
}
// ── counts / first-enable ────────────────────────────────────────────────────
int PortfolioCloudAdapter::local_count() const {
auto r = PortfolioRepository::instance().list_portfolios();
return r.is_ok() ? static_cast<int>(r.value().size()) : 0;
}
void PortfolioCloudAdapter::remote_count(CountDone done) {
CloudClient::instance().get(
QStringLiteral("/portfolios"),
[done](CloudResponse resp) {
if (!resp.ok) {
done(false, 0);
return;
}
done(true, resp.data.isArray() ? static_cast<int>(resp.data.toArray().size()) : 0);
},
this);
}
void PortfolioCloudAdapter::enqueue_all_local() {
auto ps = PortfolioRepository::instance().list_portfolios();
if (ps.is_err())
return;
for (const portfolio::Portfolio& p : ps.value())
SyncOutbox::record_unique(pf_entity(), p.id, QStringLiteral("sync"));
}
// ── pull ─────────────────────────────────────────────────────────────────────
void PortfolioCloudAdapter::pull(PullDone done) {
CloudClient::instance().get(
QStringLiteral("/portfolios"),
[this, done](CloudResponse resp) {
if (!resp.ok) {
done(false, resp.error);
return;
}
const QJsonArray arr = resp.data.toArray();
auto remote_ids = std::make_shared<QSet<QString>>();
for (const QJsonValue& v : arr)
remote_ids->insert(v.toObject().value("id").toString());
if (arr.isEmpty()) {
reconcile_portfolio_deletes(*remote_ids);
done(true, QString());
return;
}
auto pending = std::make_shared<int>(static_cast<int>(arr.size()));
auto had_error = std::make_shared<bool>(false);
auto finish_one = [this, pending, had_error, remote_ids, done]() {
if (--*pending == 0) {
reconcile_portfolio_deletes(*remote_ids);
done(!*had_error, *had_error ? QStringLiteral("pull_partial") : QString());
}
};
for (const QJsonValue& v : arr) {
const QString pfl = v.toObject().value("id").toString();
CloudClient::instance().get(
pf_path(pfl),
[this, pfl, had_error, finish_one](CloudResponse dr) {
if (!dr.ok || !dr.data.isObject()) {
*had_error = true;
finish_one();
return;
}
const QJsonObject detail = dr.data.toObject();
CloudClient::instance().get(
pf_path(pfl) + QStringLiteral("/transactions?page_size=500"),
[this, pfl, detail, had_error, finish_one](CloudResponse tr) {
const QJsonArray txns = (tr.ok && tr.data.isObject())
? tr.data.toObject().value("transactions").toArray()
: QJsonArray();
CloudClient::instance().get(
pf_path(pfl) + QStringLiteral("/snapshots?days=3650"),
[this, detail, txns, finish_one](CloudResponse sr) {
const QJsonArray snaps =
(sr.ok && sr.data.isArray()) ? sr.data.toArray() : QJsonArray();
apply_remote_portfolio(detail, txns, snaps);
finish_one();
},
this);
},
this);
},
this);
}
},
this);
}
void PortfolioCloudAdapter::apply_remote_portfolio(const QJsonObject& detail, const QJsonArray& txns,
const QJsonArray& snaps) {
SyncOutbox::ApplyGuard guard; // suppress outbox for the whole apply pass
auto& repo = PortfolioRepository::instance();
const QString pfl = detail.value("id").toString();
const QString updated = detail.value("updated_at").toString();
auto existing = SyncMap::local_id(pf_entity(), pfl);
QString local_pid;
if (existing) {
local_pid = *existing;
repo.update_portfolio(local_pid, detail.value("name").toString(), detail.value("owner").toString(),
detail.value("currency").toString(), detail.value("description").toString());
} else {
// broker_account_id is device-local — never imported from cloud.
auto cr = repo.create_portfolio(detail.value("name").toString(), detail.value("owner").toString(),
detail.value("currency").toString(), detail.value("description").toString());
if (cr.is_err())
return;
local_pid = cr.value();
}
SyncMap::put(pf_entity(), local_pid, pfl, updated);
// ── assets (cloud → local) ──
const QJsonArray cassets = detail.value("assets").toArray();
QSet<QString> cloud_syms;
QSet<QString> local_syms;
auto la = repo.get_assets(local_pid);
if (la.is_ok())
for (const portfolio::PortfolioAsset& a : la.value())
local_syms.insert(a.symbol.toUpper());
for (const QJsonValue& v : cassets) {
const QJsonObject a = v.toObject();
const QString sym = a.value("symbol").toString();
cloud_syms.insert(sym.toUpper());
const double qty = a.value("quantity").toDouble();
const double avg = a.value("avg_buy_price").toDouble();
const QString sector = a.value("sector").toString();
if (local_syms.contains(sym.toUpper())) {
repo.update_asset(local_pid, sym, qty, avg);
if (!sector.isEmpty())
repo.set_asset_sector(local_pid, sym, sector);
} else {
repo.add_asset(local_pid, sym, qty, avg, a.value("purchase_date").toString(), sector,
a.value("broker_symbol").toString(), a.value("exchange").toString());
}
}
if (la.is_ok())
for (const portfolio::PortfolioAsset& a : la.value())
if (!cloud_syms.contains(a.symbol.toUpper()))
repo.remove_asset(local_pid, a.symbol);
// ── transactions (cloud → local) ──
QSet<QString> cloud_ptx;
QSet<QString> local_txn_ids;
auto lt = repo.get_transactions(local_pid, 1000000);
if (lt.is_ok())
for (const portfolio::Transaction& t : lt.value())
local_txn_ids.insert(t.id);
for (const QJsonValue& v : txns) {
const QJsonObject t = v.toObject();
const QString ptx = t.value("id").toString();
cloud_ptx.insert(ptx);
if (!SyncMap::local_id(pf_txn_entity(), ptx)) {
auto cr =
repo.add_transaction(local_pid, t.value("symbol").toString(), t.value("transaction_type").toString(),
t.value("quantity").toDouble(), t.value("price").toDouble(),
t.value("transaction_date").toString(), t.value("notes").toString());
if (cr.is_ok())
SyncMap::put(pf_txn_entity(), cr.value(), ptx, {});
}
}
if (lt.is_ok())
for (const portfolio::Transaction& t : lt.value()) {
auto rm = SyncMap::remote_id(pf_txn_entity(), t.id);
if (rm && !cloud_ptx.contains(*rm)) {
repo.delete_transaction(t.id);
SyncMap::remove_by_local(pf_txn_entity(), t.id);
}
}
// ── snapshots (cloud → local): upsert by date ──
for (const QJsonValue& v : snaps) {
const QJsonObject s = v.toObject();
repo.save_snapshot(local_pid, s.value("total_value").toDouble(), s.value("total_cost_basis").toDouble(),
s.value("total_pnl").toDouble(), s.value("total_pnl_percent").toDouble(),
s.value("snapshot_date").toString());
}
}
void PortfolioCloudAdapter::reconcile_portfolio_deletes(const QSet<QString>& remote_ids) {
SyncOutbox::ApplyGuard guard;
auto maps = SyncMap::all(pf_entity());
if (maps.is_err())
return;
auto& repo = PortfolioRepository::instance();
for (const SyncMapping& m : maps.value()) {
if (!remote_ids.contains(m.remote_id)) {
repo.delete_portfolio(m.local_id);
SyncMap::remove_by_local(pf_entity(), m.local_id);
}
}
}
} // namespace fincept::services::cloud