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
// src/services/equity/EquityResearchService.cpp
#include "services/equity/EquityResearchService.h"
#include "core/logging/Logger.h"
#include "python/PythonRunner.h"
#include "storage/cache/CacheManager.h"
#include "storage/repositories/DataSourceRepository.h"
#include "trading/AccountManager.h"
#include "trading/BrokerInterface.h"
#include "trading/BrokerRegistry.h"
#include "trading/HistoricalDataService.h"
#include <QDate>
#include <QDateTime>
#include <QJsonArray>
#include <QJsonDocument>
#include <QJsonObject>
#include <QNetworkAccessManager>
#include <QNetworkReply>
#include <QNetworkRequest>
#include <QPointer>
#include <QUrl>
#include <QUrlQuery>
#include <algorithm>
#include <cmath>
#include <memory>
#include <vector>
namespace fincept::services::equity {
namespace {
// yfinance symbol → broker region. ".NS"/".BO" are Indian (NSE/BSE); a bare
// ticker with no exchange suffix is a US listing (yfinance convention, e.g.
// AAPL/SPGI). Other suffixes (.L, .TO, .HK …) aren't routable via the wired
// brokers → empty region. Mirrors research_symbol_region() in the screen.
QString candle_symbol_region(const QString& sym) {
if (sym.endsWith(QStringLiteral(".NS"), Qt::CaseInsensitive) ||
sym.endsWith(QStringLiteral(".BO"), Qt::CaseInsensitive))
return QStringLiteral("IN");
if (!sym.contains(QLatin1Char('.')))
return QStringLiteral("US");
return {};
}
// yfinance form (RELIANCE.NS / TCS.BO) → bare broker symbol. US tickers are
// already bare.
QString candle_bare_symbol(const QString& sym) {
if (sym.endsWith(QStringLiteral(".NS"), Qt::CaseInsensitive) ||
sym.endsWith(QStringLiteral(".BO"), Qt::CaseInsensitive))
return sym.left(sym.length() - 3);
return sym;
}
// Pick the first *Connected* active account whose broker region matches the
// symbol's market, so RELIANCE.NS routes through a live Indian broker and a US
// ticker through a live US broker — never cross-region. Returns false when no
// usable broker exists (caller then uses yfinance).
bool resolve_connected_data_broker(const QString& symbol, QString& broker_id, QString& account_id) {
const QString region = candle_symbol_region(symbol);
if (region.isEmpty())
return false;
const auto accounts = fincept::trading::AccountManager::instance().active_accounts();
for (const auto& a : accounts) {
if (a.state != fincept::trading::ConnectionState::Connected)
continue;
auto* b = fincept::trading::BrokerRegistry::instance().get(a.broker_id);
if (b && b->profile().region == region) {
broker_id = a.broker_id;
account_id = a.account_id;
return true;
}
}
return false;
}
// yfinance period string ("2y"/"1y"/"6mo"/"3mo"/"1mo"/"5d"/"max") → lookback
// days for the broker history request. Defaults to ~2y (good indicator warm-up).
int candle_lookback_days(const QString& period) {
const QString p = period.trimmed().toLower();
if (p == QLatin1String("max"))
return 3650;
auto num = [&](int trim) { return p.left(p.size() - trim).toInt(); };
if (p.endsWith(QLatin1String("mo"))) {
int n = num(2);
if (n > 0)
return n * 31;
} else if (p.endsWith(QLatin1Char('y'))) {
int n = num(1);
if (n > 0)
return n * 365;
} else if (p.endsWith(QLatin1String("wk"))) {
int n = num(2);
if (n > 0)
return n * 7;
} else if (p.endsWith(QLatin1Char('d'))) {
int n = num(1);
if (n > 0)
return n;
}
return 730;
}
// trading-layer BrokerCandle[] → the yfinance-shaped JSON array the indicator
// scripts consume: [{timestamp(sec), open, high, low, close, volume}, …], ascending.
// Timestamps are normalised to epoch SECONDS (some brokers, e.g. Fyers, return
// milliseconds — the chart and the indicator engine assume seconds).
QString broker_candles_to_json(const QVector<fincept::trading::BrokerCandle>& candles) {
struct Row {
qint64 ts;
const fincept::trading::BrokerCandle* c;
};
std::vector<Row> rows;
rows.reserve(static_cast<size_t>(candles.size()));
for (const auto& c : candles) {
qint64 ts = c.timestamp;
if (ts > 1000000000000LL) // > ~Sep 2001 in ms → milliseconds, convert to seconds
ts /= 1000;
if (ts <= 0)
continue;
rows.push_back({ts, &c});
}
std::sort(rows.begin(), rows.end(), [](const Row& a, const Row& b) { return a.ts < b.ts; });
QJsonArray arr;
for (const auto& r : rows) {
QJsonObject o;
o["timestamp"] = static_cast<double>(r.ts);
o["open"] = r.c->open;
o["high"] = r.c->high;
o["low"] = r.c->low;
o["close"] = r.c->close;
o["volume"] = r.c->volume;
arr.append(o);
}
return QString::fromUtf8(QJsonDocument(arr).toJson(QJsonDocument::Compact));
}
// compute_technicals.py receives the candle series as ONE command-line argument (it is shared
// with the workflow nodes, so its interface is left alone). Windows caps a whole command line
// at ~32 K characters and QProcess backslash-escapes every embedded quote, so a candle costs
// ~112 characters on the wire: a 24/7 instrument (crypto: 365 bars/yr) or any 5y request blew
// the limit, the process failed to start, and the Technicals tab just showed an error.
// Re-serialise compactly and keep the most recent bars that fit — the indicators are read off
// the LAST row only, and ~260 bars is ample warm-up for every window the script uses.
QString equity_svc_fit_candles_for_argv(const QString& hist_json) {
constexpr qsizetype kBudgetChars = 30000; // leaves ~2 K for the interpreter + script paths
const QJsonArray arr = QJsonDocument::fromJson(hist_json.toUtf8()).array();
if (arr.isEmpty())
return hist_json; // not a candle array — pass through untouched
QVector<QByteArray> parts;
parts.reserve(arr.size());
for (const auto& v : arr)
parts.append(QJsonDocument(v.toObject()).toJson(QJsonDocument::Compact));
qsizetype used = 2; // the enclosing [ ]
qsizetype first = arr.size();
for (qsizetype i = arr.size() - 1; i >= 0; --i) {
const qsizetype cost = parts[i].size() + parts[i].count('"') + 1; // +1: separating comma
if (used + cost > kBudgetChars)
break;
used += cost;
first = i;
}
if (first >= arr.size())
return hist_json;
QByteArray out = "[";
for (qsizetype i = first; i < arr.size(); ++i) {
if (i > first)
out += ',';
out += parts[i];
}
out += ']';
return QString::fromUtf8(out);
}
// True when an identical request is already running and young enough to still be
// trusted (see EquityResearchService::kInflightMaxAgeMs).
bool equity_svc_inflight_busy(const QHash<QString, qint64>& inflight, const QString& key, qint64 max_age_ms) {
const auto it = inflight.constFind(key);
return it != inflight.constEnd() && (QDateTime::currentMSecsSinceEpoch() - it.value()) < max_age_ms;
}
} // namespace
// ── Singleton ─────────────────────────────────────────────────────────────────
EquityResearchService& EquityResearchService::instance() {
static EquityResearchService inst;
return inst;
}
EquityResearchService::EquityResearchService(QObject* parent) : QObject(parent) {
search_debounce_ = new QTimer(this);
search_debounce_->setSingleShot(true);
search_debounce_->setInterval(kDebounceMs);
connect(search_debounce_, &QTimer::timeout, this, [this]() { search_symbols(pending_query_); });
}
// ── Python helper ─────────────────────────────────────────────────────────────
void EquityResearchService::run_python(const QString& script, const QStringList& args,
std::function<void(bool, const QString&)> cb) {
QPointer<EquityResearchService> self = this;
python::PythonRunner::instance().run(script, args, [self, cb](python::PythonResult result) {
if (!self)
return;
cb(result.success, result.success ? result.output : result.error);
});
}
// ── Search ────────────────────────────────────────────────────────────────────
void EquityResearchService::schedule_search(const QString& query) {
pending_query_ = query;
search_debounce_->start();
}
void EquityResearchService::search_symbols(const QString& query) {
if (query.trimmed().isEmpty())
return;
run_python("yfinance_data.py", {"search", query, "20"}, [this, query](bool ok, const QString& out) {
// Report failures on error_occurred("Search", …) — every listener filters by
// context — so callers waiting on the result (the MCP search tool) fail fast
// instead of running into their timeout.
if (!ok) {
LOG_WARN("EquityResearch", "Symbol search failed");
emit error_occurred("Search", "Symbol search failed for '" + query + "'");
return;
}
auto doc = QJsonDocument::fromJson(python::extract_json(out).toUtf8());
const QString script_error = doc.object().value("error").toString();
if (!script_error.isEmpty()) {
LOG_WARN("EquityResearch", "Symbol search failed: " + script_error);
emit error_occurred("Search", script_error);
return;
}
auto arr = doc.object()["results"].toArray();
QVector<SearchResult> results;
results.reserve(arr.size());
for (const auto& v : arr) {
auto o = v.toObject();
SearchResult r;
r.symbol = o["symbol"].toString();
r.name = o["name"].toString();
r.exchange = o["exchange"].toString();
r.type = o["type"].toString();
r.currency = o["currency"].toString();
r.industry = o["industry"].toString();
if (!r.symbol.isEmpty())
results.append(r);
}
emit search_results_loaded(results);
});
}
// ── Load symbol (quote + info + historical in parallel) ───────────────────────
void EquityResearchService::load_quote_only(const QString& symbol) {
if (symbol.isEmpty())
return;
const QVariant qcv = fincept::CacheManager::instance().get("equity:quote:" + symbol);
if (!qcv.isNull()) {
emit quote_loaded(parse_quote(QJsonDocument::fromJson(qcv.toString().toUtf8()).object()));
return;
}
// The header bar and the Overview tab both ask when a symbol opens; the answer is
// broadcast to every listener, so a second request while one runs is redundant.
if (equity_svc_inflight_busy(quote_inflight_, symbol, kInflightMaxAgeMs))
return;
quote_inflight_.insert(symbol, QDateTime::currentMSecsSinceEpoch());
run_python("yfinance_data.py", {"quote", symbol}, [this, symbol](bool ok, const QString& out) {
quote_inflight_.remove(symbol);
if (!ok) {
emit error_occurred("Quote", "Failed to fetch quote for " + symbol);
return;
}
auto obj = QJsonDocument::fromJson(python::extract_json(out).toUtf8()).object();
if (obj.contains("error")) {
emit error_occurred("Quote", obj["error"].toString());
return;
}
fincept::CacheManager::instance().put(
"equity:quote:" + symbol, QVariant(QString::fromUtf8(QJsonDocument(obj).toJson(QJsonDocument::Compact))),
kQuoteTtlSec, "equity");
emit quote_loaded(parse_quote(obj));
});
}
void EquityResearchService::load_info_only(const QString& symbol) {
if (symbol.isEmpty())
return;
const QVariant icv = fincept::CacheManager::instance().get("equity:info:" + symbol);
if (!icv.isNull()) {
emit info_loaded(parse_info(QJsonDocument::fromJson(icv.toString().toUtf8()).object()));
return;
}
if (equity_svc_inflight_busy(info_inflight_, symbol, kInflightMaxAgeMs))
return; // header bar + Overview + Analysis all ask on open — one daemon call serves them
info_inflight_.insert(symbol, QDateTime::currentMSecsSinceEpoch());
run_python("yfinance_data.py", {"info", symbol}, [this, symbol](bool ok, const QString& out) {
info_inflight_.remove(symbol);
if (!ok) {
emit error_occurred("Info", "Failed to fetch info for " + symbol);
return;
}
auto obj = QJsonDocument::fromJson(python::extract_json(out).toUtf8()).object();
if (obj.contains("error")) {
emit error_occurred("Info", obj["error"].toString());
return;
}
fincept::CacheManager::instance().put(
"equity:info:" + symbol, QVariant(QString::fromUtf8(QJsonDocument(obj).toJson(QJsonDocument::Compact))),
kInfoTtlSec, "equity");
emit info_loaded(parse_info(obj));
});
}
void EquityResearchService::load_historical_only(const QString& symbol, const QString& period) {
if (symbol.isEmpty())
return;
const QString cache_key = "equity:candles:" + symbol + ":" + period;
const QVariant hcv = fincept::CacheManager::instance().get(cache_key);
if (!hcv.isNull()) {
auto arr = QJsonDocument::fromJson(hcv.toString().toUtf8()).array();
if (!arr.isEmpty()) {
emit historical_loaded(symbol, parse_candles(arr));
return;
}
}
if (equity_svc_inflight_busy(historical_inflight_, cache_key, kInflightMaxAgeMs))
return;
historical_inflight_.insert(cache_key, QDateTime::currentMSecsSinceEpoch());
run_python("yfinance_data.py", {"historical_period", symbol, period, "1d"},
[this, symbol, cache_key](bool ok, const QString& out) {
historical_inflight_.remove(cache_key);
if (!ok) {
emit error_occurred("Historical", "Failed to fetch historical for " + symbol);
return;
}
auto arr = QJsonDocument::fromJson(python::extract_json(out).toUtf8()).array();
if (!arr.isEmpty()) {
fincept::CacheManager::instance().put(
cache_key, QVariant(QString::fromUtf8(QJsonDocument(arr).toJson(QJsonDocument::Compact))),
kHistoricalTtlSec, "equity");
}
emit historical_loaded(symbol, parse_candles(arr));
});
}
void EquityResearchService::load_symbol(const QString& symbol, const QString& period) {
if (symbol.isEmpty())
return;
load_quote_only(symbol);
load_info_only(symbol);
load_historical_only(symbol, period);
}
// ── Financials ────────────────────────────────────────────────────────────────
void EquityResearchService::fetch_financials(const QString& symbol) {
// Statements change quarterly, yet every Financials/Valuation tab visit used to
// re-run the yfinance statements pull (and the two tabs each started their own).
// Serve a cached copy, and fold a request that arrives while one is in flight.
const QString cache_key = "equity:financials:" + symbol;
const QString lkg_key = "equity:lkg:financials:" + symbol;
auto& cache = fincept::CacheManager::instance();
const QVariant cached = cache.get(cache_key);
if (!cached.isNull()) {
const auto cached_obj = QJsonDocument::fromJson(cached.toString().toUtf8()).object();
if (!cached_obj.isEmpty()) {
emit financials_loaded(parse_financials(cached_obj));
return;
}
}
if (equity_svc_inflight_busy(financials_inflight_, symbol, kInflightMaxAgeMs))
return;
financials_inflight_.insert(symbol, QDateTime::currentMSecsSinceEpoch());
// Last-known-good statements: shown at once (flagged stale) while the refresh runs. A
// failed refresh then leaves them on screen, still flagged, instead of a blank tab.
if (const auto lkg = cache.try_get(lkg_key)) {
const auto lkg_obj = QJsonDocument::fromJson(lkg->toUtf8()).object();
if (!lkg_obj.isEmpty()) {
FinancialsData stale = parse_financials(lkg_obj);
stale.stale = true;
emit financials_loaded(stale);
}
}
run_python("yfinance_data.py", {"financials", symbol},
[this, symbol, cache_key, lkg_key](bool ok, const QString& out) {
financials_inflight_.remove(symbol);
if (!ok) {
emit error_occurred("Financials", "Failed to fetch financials for " + symbol);
return;
}
auto obj = QJsonDocument::fromJson(python::extract_json(out).toUtf8()).object();
if (obj.contains("error")) {
emit error_occurred("Financials", obj["error"].toString());
return;
}
const QVariant payload(QString::fromUtf8(QJsonDocument(obj).toJson(QJsonDocument::Compact)));
auto& c = fincept::CacheManager::instance();
c.put(cache_key, payload, kFinancialsTtlSec, "equity");
c.put(lkg_key, payload, kFinancialsLkgTtlSec, "equity");
emit financials_loaded(parse_financials(obj));
});
}
// ── Technicals ────────────────────────────────────────────────────────────────
void EquityResearchService::fetch_technicals(const QString& symbol, const QString& period) {
// Indicators off daily bars: serve a recent computation instead of spawning another
// compute_technicals.py process on every Technicals-tab visit / Sentiment blend.
const QString result_key = "equity:technicals:" + symbol + ":" + period;
if (const auto hit = fincept::CacheManager::instance().try_get(result_key)) {
const QJsonArray rows = QJsonDocument::fromJson(hit->toUtf8()).array();
if (!rows.isEmpty()) {
emit technicals_loaded(parse_technicals(symbol, rows));
return;
}
}
// The Technicals tab and the Sentiment blend both ask for the same symbol; the
// second request would only spawn a duplicate compute_technicals.py process.
const QString inflight_key = symbol + QLatin1Char(':') + period;
if (equity_svc_inflight_busy(technicals_inflight_, inflight_key, kInflightMaxAgeMs))
return;
technicals_inflight_.insert(inflight_key, QDateTime::currentMSecsSinceEpoch());
// Candles come from ensure_candles (cache → region-matched connected broker →
// yfinance fallback); compute_technicals.py then derives the rating + indicators.
auto run_compute = [this, symbol, inflight_key, result_key](const QString& hist_json) {
run_python("compute_technicals.py", {equity_svc_fit_candles_for_argv(hist_json)},
[this, symbol, inflight_key, result_key](bool ok2, const QString& out2) {
technicals_inflight_.remove(inflight_key);
if (!ok2) {
emit error_occurred("Technicals", "Indicator computation failed");
return;
}
auto doc = QJsonDocument::fromJson(python::extract_json(out2).toUtf8()).object();
if (!doc["success"].toBool()) {
emit error_occurred("Technicals", "compute_technicals returned failure");
return;
}
const QJsonArray rows = doc["data"].toArray();
// parse_technicals() reads the last row plus the last 50 closes (SMA 50);
// keep a 60-row tail rather than the whole indicator frame.
QJsonArray tail;
for (qsizetype i = std::max<qsizetype>(0, rows.size() - 60); i < rows.size(); ++i)
tail.append(rows.at(i));
if (!tail.isEmpty())
fincept::CacheManager::instance().put(
result_key, QVariant(QString::fromUtf8(QJsonDocument(tail).toJson(QJsonDocument::Compact))),
kTechnicalsTtlSec, "equity");
emit technicals_loaded(parse_technicals(symbol, rows));
});
};
QPointer<EquityResearchService> self = this;
ensure_candles(symbol, period, [self, run_compute, inflight_key](bool ok, const QString& hist_json) {
if (!self)
return;
if (!ok || hist_json.trimmed().isEmpty()) {
self->technicals_inflight_.remove(inflight_key);
emit self->error_occurred("Technicals", "Failed historical fetch");
return;
}
run_compute(hist_json);
});
}
// ── Peers ─────────────────────────────────────────────────────────────────────
void EquityResearchService::fetch_peers(const QString& symbol, const QStringList& peer_symbols) {
QStringList all;
all << symbol;
all.append(peer_symbols);
QString joined = all.join(",");
// `multiple_ratios` carries the valuation/return ratios only. Price, beta, market
// cap, name and sector live in the separate `multiple_profiles` pull — merge it in
// so those PeerData fields (and the PRICE / BETA columns that read them) are real
// instead of permanently zero. The two runs are independent, so start both and emit
// once both are back; a failed profile pull just leaves those fields empty.
struct PeersJoin {
QJsonArray ratios;
QJsonArray profiles;
bool ratios_done = false;
bool ratios_ok = false;
bool profiles_done = false;
};
auto join = std::make_shared<PeersJoin>();
auto try_emit = [this, join]() {
if (!join->ratios_done || !join->profiles_done)
return;
if (!join->ratios_ok) {
emit error_occurred("Peers", "Failed to fetch peer data");
return;
}
QVector<PeerData> peers = parse_peers(join->ratios);
for (const auto& pv : join->profiles) {
const auto po = pv.toObject();
const QString psym = po["symbol"].toString();
for (auto& peer : peers) {
if (peer.symbol.compare(psym, Qt::CaseInsensitive) != 0)
continue;
peer.name = po["companyName"].toString();
peer.sector = po["sector"].toString();
peer.market_cap = po["marketCap"].toDouble();
peer.beta = po["beta"].toDouble();
peer.price = po["price"].toDouble();
peer.change_pct = po["changes"].toDouble();
break;
}
}
emit peers_loaded(peers);
};
run_python("yfinance_data.py", {"multiple_ratios", joined}, [join, try_emit](bool ok, const QString& out) {
join->ratios_done = true;
join->ratios_ok = ok;
if (ok)
join->ratios = QJsonDocument::fromJson(python::extract_json(out).toUtf8()).array();
try_emit();
});
run_python("yfinance_data.py", {"multiple_profiles", joined}, [join, try_emit](bool ok, const QString& out) {
join->profiles_done = true;
if (ok)
join->profiles = QJsonDocument::fromJson(python::extract_json(out).toUtf8()).array();
try_emit();
});
}
// ── News ──────────────────────────────────────────────────────────────────────
// Turn a yfinance company_name into a Google-News-friendly query by dropping the
// trailing corporate suffix(es) and punctuation — "Reliance Industries Limited" →
// "Reliance Industries", "Tesla, Inc." → "Tesla". Materially improves GNews recall.
static QString gnews_query_from_company_name(const QString& company_name) {
static const QStringList kSuffixes = {"Limited", "Ltd", "Incorporated", "Inc", "Corporation", "Corp",
"Company", "Co", "PLC", "Holdings", "Holding", "Group",
"SA", "NV", "AG", "SE", "SpA", "AB"};
QString q = company_name.trimmed();
bool changed = true;
while (changed) {
changed = false;
q = q.trimmed();
while (q.endsWith(QLatin1Char(',')) || q.endsWith(QLatin1Char('.')))
q.chop(1);
for (const auto& suf : kSuffixes) {
if (q.endsWith(QLatin1Char(' ') + suf, Qt::CaseInsensitive)) {
q.chop(suf.size() + 1);
changed = true;
break;
}
}
}
return q.trimmed();
}
// Build the news search query for a symbol: the cleaned company name from cached
// info when available, else the bare ticker (.NS/.BO suffix stripped).
static QString news_query_for_symbol(const QString& symbol) {
const bool indian = symbol.endsWith(QStringLiteral(".NS"), Qt::CaseInsensitive) ||
symbol.endsWith(QStringLiteral(".BO"), Qt::CaseInsensitive);
QString query = indian ? symbol.left(symbol.length() - 3) : symbol;
const QVariant icv = fincept::CacheManager::instance().get("equity:info:" + symbol);
if (!icv.isNull()) {
const auto info = QJsonDocument::fromJson(icv.toString().toUtf8()).object();
const QString cleaned = gnews_query_from_company_name(info.value("company_name").toString());
if (!cleaned.isEmpty())
query = cleaned;
}
return query;
}
// NewsAPI /v2/everything query for a symbol. Builds an EXACT-PHRASE (quoted) match
// on the company name (ticker as fallback) so results are about THIS company.
// Paired with searchIn=title,description at the call site, this keeps the feed
// stock-specific — the default everything search also scans the full article body,
// so a bare word like "Apple"/"Reliance" otherwise pulled in unrelated general news.
static QString newsapi_query_for_symbol(const QString& symbol) {
const bool indian = symbol.endsWith(QStringLiteral(".NS"), Qt::CaseInsensitive) ||
symbol.endsWith(QStringLiteral(".BO"), Qt::CaseInsensitive);
const QString ticker = indian ? symbol.left(symbol.length() - 3) : symbol;
QString company;
const QVariant icv = fincept::CacheManager::instance().get("equity:info:" + symbol);
if (!icv.isNull()) {
const auto info = QJsonDocument::fromJson(icv.toString().toUtf8()).object();
company = gnews_query_from_company_name(info.value("company_name").toString());
}
QString phrase = company;
if (phrase.isEmpty())
phrase = ticker;
if (phrase.isEmpty())
phrase = symbol;
return QStringLiteral("\"%1\"").arg(phrase); // quotes → NewsAPI exact-phrase match
}
void EquityResearchService::fetch_news(const QString& symbol, int count, NewsProvider provider, bool force) {
// User-pressed REFRESH: the 3-minute cache would otherwise hand back the very
// same articles the tab is already showing.
if (force) {
fincept::CacheManager::instance().remove("equity:news:" + symbol);
fincept::CacheManager::instance().remove("equity:news:newsapi:" + symbol);
}
// NewsAPI.org provider (opt-in): use it only when a key is configured, and
// cache it under a separate key so switching providers doesn't surface the
// other provider's cached result.
if (provider == NewsProvider::NewsApi) {
const QString key = configured_newsapi_key();
if (!key.isEmpty()) {
const QVariant ncv = fincept::CacheManager::instance().get("equity:news:newsapi:" + symbol);
if (!ncv.isNull()) {
const QJsonArray arr = QJsonDocument::fromJson(ncv.toString().toUtf8()).array();
emit news_loaded(symbol, parse_news(arr));
return;
}
fetch_news_newsapi(symbol, count, key);
return;
}
// No key configured → fall through to the default Auto chain below.
}
{
const QVariant ncv = fincept::CacheManager::instance().get("equity:news:" + symbol);
if (!ncv.isNull()) {
const QJsonArray arr = QJsonDocument::fromJson(ncv.toString().toUtf8()).array();
emit news_loaded(symbol, parse_news(arr));
return;
}
}
// Primary source: Google News (fetch_company_news.py) — broader, more current
// company coverage than yfinance's Yahoo feed. Google News recall is far better
// for a clean company NAME than a bare ticker or the full legal name (e.g.
// "Reliance Industries" returns articles where "RELIANCE" and "Reliance
// Industries Limited" both return none), so query by the cleaned company_name
// from the cached info when available, falling back to the bare ticker.
const bool indian = symbol.endsWith(QStringLiteral(".NS"), Qt::CaseInsensitive) ||
symbol.endsWith(QStringLiteral(".BO"), Qt::CaseInsensitive);
const QString country = indian ? QStringLiteral("IN") : QStringLiteral("US");
const QString query = news_query_for_symbol(symbol);
run_python("fetch_company_news.py",
{"search", query, QString::number(count), QStringLiteral("1M"), QStringLiteral("en"), country},
[this, symbol, count](bool ok, const QString& out) {
if (ok) {
const auto obj = QJsonDocument::fromJson(python::extract_json(out).toUtf8()).object();
// GNews returns {"success":true,"data":[...]}. Only accept a
// non-empty result; anything else falls through to yfinance.
if (obj.value("success").toBool()) {
const auto arr = obj.value("data").toArray();
if (!arr.isEmpty()) {
fincept::CacheManager::instance().put(
"equity:news:" + symbol,
QVariant(QString::fromUtf8(QJsonDocument(arr).toJson(QJsonDocument::Compact))),
kNewsTtlSec, "equity");
emit news_loaded(symbol, parse_news(arr));
return;
}
}
}
// Google News unavailable (e.g. gnews missing / network) or empty →
// fall back to the Yahoo/yfinance feed.
fetch_news_yfinance(symbol, count);
});
}
void EquityResearchService::fetch_news_yfinance(const QString& symbol, int count) {
run_python(
"yfinance_data.py", {"news", symbol, QString::number(count)}, [this, symbol](bool ok, const QString& out) {
if (!ok) {
emit error_occurred("News", "Failed to fetch news for " + symbol);
return;
}
auto obj = QJsonDocument::fromJson(python::extract_json(out).toUtf8()).object();
auto arr = obj["articles"].toArray();
fincept::CacheManager::instance().put(
"equity:news:" + symbol, QVariant(QString::fromUtf8(QJsonDocument(arr).toJson(QJsonDocument::Compact))),
kNewsTtlSec, "equity");
emit news_loaded(symbol, parse_news(arr));
});
}
// ── NewsAPI.org ─────────────────────────────────────────────────────────────
// The configured & enabled NewsAPI key from the Data Sources tab (provider id
// "newsapi", set by ConnectionConfigDialog as ds.provider = connector id). Empty
// when no enabled NewsAPI connection has a non-empty apiKey.
QString EquityResearchService::configured_newsapi_key() const {
const auto res = fincept::DataSourceRepository::instance().list_all();
if (res.is_err())
return {};
for (const auto& ds : res.value()) {
if (!ds.enabled || ds.provider != QLatin1String("newsapi"))
continue;
const auto cfg = QJsonDocument::fromJson(ds.config.toUtf8()).object();
const QString key = cfg.value("apiKey").toString().trimmed();
if (!key.isEmpty())
return key;
}
return {};
}
// Fetch stock-specific news from newsapi.org/v2/everything. On any failure
// (network error, non-"ok" status such as 401/quota, or no usable articles) it
// falls back to the default Auto chain so the tab always shows news.
void EquityResearchService::fetch_news_newsapi(const QString& symbol, int count, const QString& api_key) {
if (!news_nam_)
news_nam_ = new QNetworkAccessManager(this);
QUrl url(QStringLiteral("https://newsapi.org/v2/everything"));
QUrlQuery params;
// Exact-phrase company query restricted to title+description (NOT the full
// article body) so results are about THIS company, not any article that
// merely mentions the word. This is what makes the feed stock-specific.
params.addQueryItem(QStringLiteral("q"), newsapi_query_for_symbol(symbol));
params.addQueryItem(QStringLiteral("searchIn"), QStringLiteral("title,description"));
params.addQueryItem(QStringLiteral("language"), QStringLiteral("en"));
params.addQueryItem(QStringLiteral("sortBy"), QStringLiteral("publishedAt"));
params.addQueryItem(QStringLiteral("pageSize"), QString::number(std::clamp(count, 1, 100)));
params.addQueryItem(QStringLiteral("from"), QDate::currentDate().addDays(-30).toString(Qt::ISODate));
url.setQuery(params);
QNetworkRequest req(url);
req.setRawHeader("X-Api-Key", api_key.toUtf8()); // key in header, not the URL
req.setHeader(QNetworkRequest::UserAgentHeader, QStringLiteral("FinceptTerminal"));
QNetworkReply* reply = news_nam_->get(req);
connect(reply, &QNetworkReply::finished, this, [this, reply, symbol, count]() {
reply->deleteLater();
const auto fall_back = [this, symbol, count]() { fetch_news(symbol, count, NewsProvider::Auto); };
if (reply->error() != QNetworkReply::NoError) {
LOG_WARN("EquityResearch", QString("NewsAPI request failed (%1) — falling back").arg(reply->errorString()));
fall_back();
return;
}
const auto obj = QJsonDocument::fromJson(reply->readAll()).object();
if (obj.value("status").toString() != QLatin1String("ok")) {
LOG_WARN("EquityResearch",
QString("NewsAPI error: %1 — falling back").arg(obj.value("message").toString("unknown")));
fall_back();
return;
}
// Reshape NewsAPI articles into the {title, description, url, publisher,
// published_date} shape parse_news() consumes.
QJsonArray reshaped;
for (const auto& v : obj.value("articles").toArray()) {
const auto a = v.toObject();
const QString title = a.value("title").toString();
if (title.isEmpty() || title == QLatin1String("[Removed]"))
continue;
reshaped.append(QJsonObject{
{"title", title},
{"description", a.value("description").toString()},
{"url", a.value("url").toString()},
{"publisher", a.value("source").toObject().value("name").toString()},
{"published_date", a.value("publishedAt").toString()},
});
}
if (reshaped.isEmpty()) {
fall_back(); // nothing usable from NewsAPI → Auto chain
return;
}
fincept::CacheManager::instance().put(
"equity:news:newsapi:" + symbol,
QVariant(QString::fromUtf8(QJsonDocument(reshaped).toJson(QJsonDocument::Compact))), kNewsTtlSec, "equity");
emit news_loaded(symbol, parse_news(reshaped));
});
}
// ── Candle source: connected broker first, yfinance fallback ─────────────────
// Shared by fetch_technicals (and any future indicator path). Order:
// 1. cache hit → return immediately
// 2. region-matched *connected* broker → broker get_history (live, reliable)
// 3. yfinance → fallback (no broker, or broker empty/failed)
// The result is cached under "equity:candles:<symbol>". done(ok, hist_json) is
// always invoked on the main thread.
void EquityResearchService::ensure_candles(const QString& symbol, const QString& period,
std::function<void(bool, const QString&)> done) {
const QString cache_key = "equity:candles:" + symbol;
const QVariant cached = fincept::CacheManager::instance().get(cache_key);
if (!cached.isNull()) {
// Reject a cached empty payload ("" or "[]") — a stale rate-limited
// result would otherwise wedge the tab on "No data returned".
const QString c = cached.toString().trimmed();
if (!c.isEmpty() && c != QLatin1String("[]")) {
done(true, cached.toString());
return;
}
}
QPointer<EquityResearchService> self = this;
auto run_yfinance = [self, symbol, period, cache_key, done]() {
if (!self) {
done(false, {});
return;
}
self->run_python("yfinance_data.py", {"historical_period", symbol, period, "1d"},
[cache_key, done](bool ok, const QString& out) {
if (!ok) {
done(false, {});
return;
}
const QString raw = python::extract_json(out);
const QString trimmed = raw.trimmed();
if (trimmed.isEmpty() || trimmed == QLatin1String("[]")) {
done(false, {}); // yfinance rate-limited / unknown symbol
return;
}
fincept::CacheManager::instance().put(cache_key, QVariant(raw), kHistoricalTtlSec,
"equity");
done(true, raw);
});
};
QString broker_id, account_id;
if (resolve_connected_data_broker(symbol, broker_id, account_id)) {
const QString bare = candle_bare_symbol(symbol);
const int lookback = candle_lookback_days(period);
LOG_INFO("EquityResearch", QString("Candles for %1 via broker %2").arg(symbol, broker_id));
fincept::trading::HistoricalDataService::instance().fetch(
bare, QStringLiteral("1d"), lookback, broker_id, account_id,
[cache_key, done, run_yfinance](bool ok, const QVector<fincept::trading::BrokerCandle>& candles,
const QString& /*err*/) {
if (ok && !candles.isEmpty()) {
const QString json = broker_candles_to_json(candles);
if (!json.isEmpty() && json != QLatin1String("[]")) {
fincept::CacheManager::instance().put(cache_key, QVariant(json), kHistoricalTtlSec, "equity");
done(true, json);
return;
}
}
run_yfinance(); // broker had no data — fall back
});
return;
}
run_yfinance(); // no connected region-matched broker
}
// ── Parsers ───────────────────────────────────────────────────────────────────
QuoteData EquityResearchService::parse_quote(const QJsonObject& o) const {
QuoteData q;
q.symbol = o["symbol"].toString();
q.price = o["price"].toDouble();
q.change = o["change"].toDouble();
q.change_pct = o["change_percent"].toDouble();
q.open = o["open"].toDouble();
q.high = o["high"].toDouble();
q.low = o["low"].toDouble();
q.prev_close = o["previous_close"].toDouble();
q.volume = o["volume"].toDouble();
q.exchange = o["exchange"].toString();
q.timestamp = static_cast<qint64>(o["timestamp"].toDouble());
return q;
}
StockInfo EquityResearchService::parse_info(const QJsonObject& o) const {
StockInfo s;
s.symbol = o["symbol"].toString();
s.company_name = o["company_name"].toString();
s.sector = o["sector"].toString();
s.industry = o["industry"].toString();
s.description = o["description"].toString();
s.website = o["website"].toString();
s.country = o["country"].toString();
s.currency = o["currency"].toString();
s.financial_currency = o["financial_currency"].toString(); // absent from older payloads → empty
s.exchange = o["exchange"].toString();
s.employees = o["employees"].toInt();
s.market_cap = o["market_cap"].toDouble();
s.enterprise_value = o["enterprise_value"].toDouble();
s.pe_ratio = o["pe_ratio"].toDouble();
s.forward_pe = o["forward_pe"].toDouble();
s.peg_ratio = o["peg_ratio"].toDouble();
s.price_to_book = o["price_to_book"].toDouble();
s.ev_to_revenue = o["enterprise_to_revenue"].toDouble();
s.ev_to_ebitda = o["enterprise_to_ebitda"].toDouble();
s.gross_margins = o["gross_margins"].toDouble();
s.operating_margins = o["operating_margins"].toDouble();
s.ebitda_margins = o["ebitda_margins"].toDouble();
s.profit_margins = o["profit_margins"].toDouble();
s.roe = o["return_on_equity"].toDouble();
s.roa = o["return_on_assets"].toDouble();
s.gross_profits = o["gross_profits"].toDouble();
s.book_value = o["book_value"].toDouble();
s.revenue_per_share = o["revenue_per_share"].toDouble();
s.free_cashflow = o["free_cashflow"].toDouble();
s.operating_cashflow = o["operating_cashflow"].toDouble();
s.total_cash = o["total_cash"].toDouble();
s.total_debt = o["total_debt"].toDouble();
s.total_revenue = o["total_revenue"].toDouble();
s.earnings_growth = o["earnings_growth"].toDouble();
s.revenue_growth = o["revenue_growth"].toDouble();
s.shares_outstanding = o["shares_outstanding"].toDouble();
s.float_shares = o["float_shares"].toDouble();
s.held_insiders_pct = o["held_percent_insiders"].toDouble();
s.held_institutions_pct = o["held_percent_institutions"].toDouble();
s.short_ratio = o["short_ratio"].toDouble();
s.short_pct_of_float = o["short_percent_of_float"].toDouble();
s.week52_high = o["fifty_two_week_high"].toDouble();
s.week52_low = o["fifty_two_week_low"].toDouble();
s.avg_volume = o["average_volume"].toDouble();
s.beta = o["beta"].toDouble();
s.dividend_yield = o["dividend_yield"].toDouble();
s.current_price = o["current_price"].toDouble();
s.target_high = o["target_high_price"].toDouble();
s.target_low = o["target_low_price"].toDouble();
s.target_mean = o["target_mean_price"].toDouble();
s.recommendation_mean = o["recommendation_mean"].toDouble();
s.recommendation_key = o["recommendation_key"].toString();
s.analyst_count = o["number_of_analyst_opinions"].toInt();
return s;
}
QVector<Candle> EquityResearchService::parse_candles(const QJsonArray& arr) const {
QVector<Candle> candles;
candles.reserve(arr.size());
for (const auto& v : arr) {
auto o = v.toObject();
Candle c;
c.timestamp = static_cast<qint64>(o["timestamp"].toDouble());
c.open = o["open"].toDouble();
c.high = o["high"].toDouble();
c.low = o["low"].toDouble();
c.close = o["close"].toDouble();
c.volume = static_cast<qint64>(o["volume"].toDouble());
candles.append(c);
}
return candles;
}
FinancialsData EquityResearchService::parse_financials(const QJsonObject& obj) const {
FinancialsData fd;
fd.symbol = obj["symbol"].toString();
fd.fetched_at = static_cast<qint64>(obj["timestamp"].toDouble());
auto parse_stmt = [](const QJsonObject& stmt) {
QVector<QPair<QString, QJsonObject>> result;
for (auto it = stmt.constBegin(); it != stmt.constEnd(); ++it)
result.append({it.key(), it.value().toObject()});
// Sort by period descending (most recent first)
std::sort(result.begin(), result.end(), [](const auto& a, const auto& b) { return a.first > b.first; });
return result;
};
fd.income_statement = parse_stmt(obj["income_statement"].toObject());
fd.balance_sheet = parse_stmt(obj["balance_sheet"].toObject());
fd.cash_flow = parse_stmt(obj["cash_flow"].toObject());
return fd;
}
TechSignal EquityResearchService::score_indicator(const QString& name, double value, double sma20, double sma50) const {
// RSI (0-100): <=30 buy, >=70 sell
if (name == "rsi") {
if (value <= 25)
return TechSignal::StrongBuy;
if (value <= 40)
return TechSignal::Buy;
if (value <= 60)
return TechSignal::Neutral;
if (value <= 75)
return TechSignal::Sell;
return TechSignal::StrongSell;
}
// MACD vote = the histogram ("macd_diff" = MACD line − signal line): the classic
// crossover signal. The line itself (12-EMA − 26-EMA) used to be scored instead and was
// labelled "MACD above signal line" whenever it was merely above zero; it is now shown
// for information only, so MACD still casts a single vote in the rating.
if (name == "macd_diff") {
if (value > 0)
return TechSignal::Buy;
if (value < 0)
return TechSignal::Sell;
return TechSignal::Neutral;
}
// SMA crossover
if (name == "sma_20" && sma50 > 0) {
if (sma20 > sma50 * 1.02)
return TechSignal::StrongBuy;
if (sma20 > sma50)
return TechSignal::Buy;
if (sma20 < sma50 * 0.98)
return TechSignal::StrongSell;
if (sma20 < sma50)
return TechSignal::Sell;
return TechSignal::Neutral;
}
// CCI: <=-100 buy, >=100 sell
if (name == "cci") {
if (value <= -100)
return TechSignal::StrongBuy;
if (value <= -50)
return TechSignal::Buy;
if (value >= 100)
return TechSignal::StrongSell;
if (value >= 50)
return TechSignal::Sell;
return TechSignal::Neutral;
}
// MFI (0-100): <=20 buy, >=80 sell
if (name == "mfi") {
if (value <= 20)
return TechSignal::StrongBuy;
if (value <= 40)
return TechSignal::Buy;
if (value >= 80)
return TechSignal::StrongSell;
if (value >= 60)
return TechSignal::Sell;
return TechSignal::Neutral;
}
// Stochastic %K and %D
if (name == "stoch_k" || name == "stoch_d") {
if (value <= 20)
return TechSignal::StrongBuy;
if (value <= 40)
return TechSignal::Buy;
if (value >= 80)
return TechSignal::StrongSell;
if (value >= 60)
return TechSignal::Sell;
return TechSignal::Neutral;
}
// Williams %R (-100 to 0): <=-80 buy, >=-20 sell
if (name == "williams_r") {
if (value <= -80)
return TechSignal::StrongBuy;
if (value <= -60)
return TechSignal::Buy;
if (value >= -20)
return TechSignal::StrongSell;
if (value >= -40)
return TechSignal::Sell;
return TechSignal::Neutral;
}
// ROC: positive = buy
if (name == "roc") {
if (value > 5)
return TechSignal::Buy;
if (value < -5)
return TechSignal::Sell;
return TechSignal::Neutral;
}
// ADX: >25 = trending (buy signal), <20 = weak
if (name == "adx") {
return value > 25 ? TechSignal::Buy : TechSignal::Neutral;
}
// BB %B: <0.2 oversold (buy), >0.8 overbought (sell)
if (name == "bb_pband") {
if (value < 0.2)
return TechSignal::StrongBuy;
if (value > 0.8)
return TechSignal::StrongSell;
return TechSignal::Neutral;
}
// CMF: >0.1 buy, <-0.1 sell
if (name == "cmf") {
if (value > 0.1)
return TechSignal::Buy;
if (value < -0.1)
return TechSignal::Sell;
return TechSignal::Neutral;
}
// OBV: use trend direction — positive change from context = neutral (no ref price)
// Aroon Up/Down: aroon_up > aroon_down = buy
if (name == "aroon_up") {
return value > 50 ? TechSignal::Buy : TechSignal::Neutral;
}
if (name == "aroon_down") {
return value > 50 ? TechSignal::Sell : TechSignal::Neutral;
}
return TechSignal::Neutral;
}
TechnicalsData EquityResearchService::parse_technicals(const QString& symbol, const QJsonArray& rows) const {
TechnicalsData td;
td.symbol = symbol;
if (rows.isEmpty())
return td;
// Use the last row (most recent values) — compute_technicals.py outputs lowercase snake_case
auto last = rows.last().toObject();
// compute_technicals.py only emits sma_20, so the "SMA 50" row and the SMA 20/50 crossover
// signal below could never appear. Every row carries its close, so derive the 50-bar mean
// here (the script is shared with the workflow nodes and is left alone).
if (rows.size() >= 50 && (!last.contains("sma_50") || last["sma_50"].isNull())) {
double sum = 0.0;
bool complete = true;
for (qsizetype i = rows.size() - 50; i < rows.size(); ++i) {
const QJsonValue close = rows.at(i).toObject().value("close");
if (!close.isDouble()) {
complete = false;
break;
}
sum += close.toDouble();
}
if (complete)
last["sma_50"] = sum / 50.0;
}
// Extract SMA values for cross scoring
double sma20 = last["sma_20"].toDouble();
double sma50 = last["sma_50"].toDouble(); // may be 0 if not present
// Maps: display name → actual column key in JSON output
// Trend: sma_20, sma_50, ema_12, wma_9, macd, macd_signal, cci, adx, aroon_up, aroon_down
static const QList<QPair<QString, QString>> kTrend = {
{"SMA 20", "sma_20"}, {"SMA 50", "sma_50"}, {"EMA 12", "ema_12"},
{"WMA 9", "wma_9"}, {"MACD", "macd"}, {"MACD Signal", "macd_signal"},
{"MACD Hist", "macd_diff"}, {"CCI", "cci"}, {"ADX", "adx"},
{"Aroon Up", "aroon_up"}, {"Aroon Down", "aroon_down"},
};
// Momentum: rsi, stoch_k, stoch_d, williams_r, roc, mfi, ao, kama
static const QList<QPair<QString, QString>> kMomentum = {
{"RSI", "rsi"}, {"Stoch %K", "stoch_k"}, {"Stoch %D", "stoch_d"}, {"Williams %R", "williams_r"},
{"ROC", "roc"}, {"MFI", "mfi"}, {"Awesome Osc", "ao"}, {"KAMA", "kama"},
};
// Volatility: atr, bb_mavg, bb_hband, bb_lband, bb_pband, bb_wband
// bb_wband comes from ta.BollingerBands.bollinger_wband(): (upper − lower) / mid × 100,
// i.e. already in PERCENT.
static const QList<QPair<QString, QString>> kVolatility = {
{"ATR", "atr"}, {"BB Mid", "bb_mavg"}, {"BB Upper", "bb_hband"},
{"BB Lower", "bb_lband"}, {"BB %B", "bb_pband"}, {"BB Width %", "bb_wband"},
};
// Volume: obv, vwap, cmf, adi. ta's VWAP is a 14-bar ROLLING volume-weighted price, not
// the session VWAP traders usually mean — say so in the name.
static const QList<QPair<QString, QString>> kVolume = {
{"OBV", "obv"},
{"VWAP (14-bar)", "vwap"},
{"CMF", "cmf"},
{"ADI", "adi"},
};
auto build = [&](const QList<QPair<QString, QString>>& keys, const QString& cat) {
QVector<TechIndicator> out;
for (const auto& kv : keys) {
const QString& col = kv.second;
if (!last.contains(col))
continue;
auto jval = last[col];
if (jval.isNull() || jval.isUndefined())
continue;
double val = jval.toDouble();
if (std::isnan(val))
continue;
TechIndicator ti;
ti.name = kv.first;
ti.key = col;
ti.value = val;
ti.category = cat;
ti.signal = score_indicator(col, val, sma20, sma50);
// ADX only measures trend STRENGTH. score_indicator() maps ADX > 25 to Buy, which
// called a strong downtrend bullish and tipped the overall rating; take the side
// from the +DI / -DI pair the same row carries.
if (col == QLatin1String("adx") && ti.signal == TechSignal::Buy) {
const double plus_di = last["adx_pos"].toDouble();
const double minus_di = last["adx_neg"].toDouble();
if (plus_di < minus_di)
ti.signal = TechSignal::Sell;
else if (plus_di == minus_di)
ti.signal = TechSignal::Neutral;
}
out.append(ti);
}
return out;
};
td.trend = build(kTrend, "trend");
td.momentum = build(kMomentum, "momentum");
td.volatility = build(kVolatility, "volatility");
td.volume = build(kVolume, "volume");
// Tally signals
auto tally = [&](const QVector<TechIndicator>& v) {
for (const auto& ti : v) {
switch (ti.signal) {
case TechSignal::StrongBuy:
td.strong_buy++;
break;
case TechSignal::Buy:
td.buy++;
break;
case TechSignal::Neutral:
td.neutral++;
break;
case TechSignal::Sell:
td.sell++;
break;
case TechSignal::StrongSell:
td.strong_sell++;
break;
}
}
};
tally(td.trend);
tally(td.momentum);
tally(td.volatility);
tally(td.volume);
int bulls = td.strong_buy * 2 + td.buy;
int bears = td.strong_sell * 2 + td.sell;
if (bulls > bears * 2)
td.overall_signal = TechSignal::StrongBuy;
else if (bulls > bears)
td.overall_signal = TechSignal::Buy;
else if (bears > bulls * 2)
td.overall_signal = TechSignal::StrongSell;
else if (bears > bulls)
td.overall_signal = TechSignal::Sell;
else
td.overall_signal = TechSignal::Neutral;
return td;
}
QVector<PeerData> EquityResearchService::parse_peers(const QJsonArray& arr) const {
QVector<PeerData> peers;
for (const auto& v : arr) {
auto o = v.toObject();
PeerData p;
p.symbol = o["symbol"].toString();
p.pe_ratio = o["peRatio"].toDouble();
p.forward_pe = o["forwardPE"].toDouble();
p.price_to_book = o["priceToBook"].toDouble();
p.price_to_sales = o["priceToSales"].toDouble();
p.peg_ratio = o["pegRatio"].toDouble();
p.debt_to_equity = o["debtToEquity"].toDouble();
p.roe = o["returnOnEquity"].toDouble();
p.roa = o["returnOnAssets"].toDouble();
p.profit_margin = o["profitMargin"].toDouble();
p.operating_margin = o["operatingMargin"].toDouble();
p.gross_margin = o["grossMargin"].toDouble();
p.current_ratio = o["currentRatio"].toDouble();
p.quick_ratio = o["quickRatio"].toDouble();
p.dividend_yield = o["dividendYield"].toDouble();
peers.append(p);
}
return peers;
}
QVector<NewsArticle> EquityResearchService::parse_news(const QJsonArray& arr) const {
QVector<NewsArticle> articles;
articles.reserve(arr.size());
for (const auto& v : arr) {
auto o = v.toObject();
NewsArticle a;
a.title = o["title"].toString();
a.description = o["description"].toString();
a.url = o["url"].toString();
a.publisher = o["publisher"].toString();
a.published_date = o["published_date"].toString();
if (!a.title.isEmpty())
articles.append(a);
}
return articles;
}
} // namespace fincept::services::equity