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
// Paper Trading Engine — Business logic layer
// Delegates all DB access to PaperTradingRepository.
// Contains: validation, margin checks, fill engine, position management.
#include "trading/PaperTrading.h"
#include "core/events/EventBus.h"
#include "core/logging/Logger.h"
#include "storage/repositories/PaperTradingRepository.h"
#include "storage/sqlite/Database.h"
#include <QDate>
#include <QDateTime>
#include <QHash>
#include <QMutex>
#include <QMutexLocker>
#include <QTime>
#include <QTimeZone>
#include <QUuid>
#include <cmath>
#include <stdexcept>
namespace fincept::trading {
static QString generate_uuid() {
return QUuid::createUuid().toString(QUuid::WithoutBraces);
}
static QString now_rfc3339() {
return QDateTime::currentDateTimeUtc().toString(Qt::ISODate);
}
static auto& repo() {
return PaperTradingRepository::instance();
}
// Mutex protecting fill engine — prevents concurrent fills on the same portfolio
// from corrupting balance or positions.
static QMutex s_fill_mutex;
// ============================================================================
// Leverage / Market-hours Config (Phase 3 §4)
// ============================================================================
//
// Per-portfolio leverage rules and the market-hours enforcement flag are held
// in memory rather than in the pt_portfolios table. The existing schema has no
// columns for them and the task forbids adding a migration / editing CMake, so
// an in-memory map (rebuilt at runtime by callers via the setters) is the
// source of truth. Defaults match OpenAlgo's sandbox.
namespace {
struct PtRuntimeConfig {
PtLeverageConfig leverage;
bool enforce_market_hours = false;
};
QMutex s_config_mutex;
QHash<QString, PtRuntimeConfig>& config_map() {
static QHash<QString, PtRuntimeConfig> m;
return m;
}
PtRuntimeConfig config_for(const QString& portfolio_id) {
QMutexLocker lock(&s_config_mutex);
return config_map().value(portfolio_id, PtRuntimeConfig{});
}
} // namespace
void pt_set_leverage_config(const QString& portfolio_id, const PtLeverageConfig& cfg) {
QMutexLocker lock(&s_config_mutex);
config_map()[portfolio_id].leverage = cfg;
}
PtLeverageConfig pt_get_leverage_config(const QString& portfolio_id) {
return config_for(portfolio_id).leverage;
}
void pt_set_enforce_market_hours(const QString& portfolio_id, bool enforce) {
QMutexLocker lock(&s_config_mutex);
config_map()[portfolio_id].enforce_market_hours = enforce;
}
bool pt_get_enforce_market_hours(const QString& portfolio_id) {
return config_for(portfolio_id).enforce_market_hours;
}
// ============================================================================
// Instrument-type helpers (Phase 3 §4)
// ============================================================================
bool pt_is_option(const QString& symbol) {
// Canonical option symbols end with CE (call) or PE (put), e.g.
// "NIFTY28FEB2520000CE". Match case-insensitively on the suffix.
return symbol.endsWith("CE", Qt::CaseInsensitive) || symbol.endsWith("PE", Qt::CaseInsensitive);
}
bool pt_is_future(const QString& symbol) {
// Canonical future symbols end with FUT, e.g. "NIFTY28FEB25FUT".
return symbol.endsWith("FUT", Qt::CaseInsensitive);
}
// ============================================================================
// Margin calculation (Phase 3 §4)
// ============================================================================
namespace {
// Select leverage for a trade based on instrument type, product, exchange and
// side. Mirrors OpenAlgo fund_manager.py::_get_leverage.
double select_leverage(const PtLeverageConfig& cfg, const QString& symbol, const QString& exchange,
const QString& product, const QString& side) {
// Futures take priority (FUT suffix), then options (CE/PE suffix).
if (pt_is_future(symbol))
return cfg.futures;
if (pt_is_option(symbol))
return (side.compare("buy", Qt::CaseInsensitive) == 0) ? cfg.options_buy : cfg.options_sell;
// Equity: leverage depends on product. MIS (intraday) gets equity_mis,
// everything else (CNC/NRML/delivery/blank) gets equity_cnc.
const QString ex = exchange.toUpper();
if (ex == "NSE" || ex == "BSE" || ex.isEmpty()) {
if (product.compare("MIS", Qt::CaseInsensitive) == 0 || product.compare("intraday", Qt::CaseInsensitive) == 0)
return cfg.equity_mis;
return cfg.equity_cnc;
}
// Unknown exchange: fall back to 1x (full margin) — safest default.
return 1.0;
}
} // namespace
double pt_calculate_required_margin(const QString& portfolio_id, const QString& symbol, const QString& exchange,
const QString& product, double quantity, double price, const QString& side) {
if (!std::isfinite(quantity) || quantity <= 0.0 || !std::isfinite(price) || price <= 0.0)
return 0.0;
PtLeverageConfig cfg = pt_get_leverage_config(portfolio_id);
double leverage = select_leverage(cfg, symbol, exchange, product, side);
if (!std::isfinite(leverage) || leverage <= 0.0)
leverage = 1.0;
double trade_value = quantity * price;
return trade_value / leverage;
}
// ============================================================================
// Exchange hours (Phase 3 §4)
// ============================================================================
bool pt_is_market_open(const QString& exchange) {
// IST = UTC + 5:30.
QDateTime ist = QDateTime::currentDateTimeUtc().addSecs(5 * 3600 + 30 * 60);
QTime t = ist.time();
const QString ex = exchange.toUpper();
if (ex == "NSE" || ex == "BSE" || ex == "NFO" || ex == "BFO") {
// Equity / equity derivatives: 09:15 – 15:30 IST.
return t >= QTime(9, 15) && t <= QTime(15, 30);
}
if (ex == "MCX") {
// Commodities: 09:00 – 23:30 IST.
return t >= QTime(9, 0) && t <= QTime(23, 30);
}
if (ex == "CDS" || ex == "BCD") {
// Currency derivatives: 09:00 – 17:00 IST.
return t >= QTime(9, 0) && t <= QTime(17, 0);
}
// Unknown / crypto / international: always open (24/7).
return true;
}
// ============================================================================
// Portfolio Operations
// ============================================================================
PtPortfolio pt_create_portfolio(const QString& name, double balance, const QString& currency, double leverage,
const QString& margin_mode, double fee_rate, const QString& exchange) {
if (name.isEmpty())
throw std::runtime_error("Portfolio name cannot be empty");
if (!std::isfinite(balance) || balance <= 0.0)
throw std::runtime_error("Invalid balance: must be positive");
if (!std::isfinite(leverage) || leverage <= 0.0)
throw std::runtime_error("Invalid leverage: must be positive");
if (!std::isfinite(fee_rate) || fee_rate < 0.0 || fee_rate > 1.0)
throw std::runtime_error("Invalid fee_rate: must be between 0 and 1");
PtPortfolio p;
p.id = generate_uuid();
p.name = name;
p.initial_balance = balance;
p.balance = balance;
p.currency = currency;
p.leverage = leverage;
p.margin_mode = margin_mode;
p.fee_rate = fee_rate;
p.exchange = exchange;
p.created_at = now_rfc3339();
auto r = repo().insert_portfolio(p);
if (r.is_err())
throw std::runtime_error(r.error());
return p;
}
PtPortfolio pt_get_portfolio(const QString& id) {
auto r = repo().get_portfolio(id);
if (r.is_err())
throw std::runtime_error(r.error());
return r.value();
}
void pt_set_balance(const QString& portfolio_id, double new_balance) {
if (!std::isfinite(new_balance) || new_balance < 0.0)
throw std::runtime_error("Invalid balance: must be finite and non-negative");
auto r = repo().update_balance(portfolio_id, new_balance);
if (r.is_err())
throw std::runtime_error(r.error());
}
std::optional<PtPortfolio> pt_find_portfolio(const QString& name, const QString& exchange) {
return repo().find_portfolio(name, exchange);
}
QVector<PtPortfolio> pt_list_portfolios(const QString& exchange) {
auto r = repo().list_portfolios(exchange);
if (r.is_err())
return {};
return r.value();
}
void pt_delete_portfolio(const QString& id) {
repo().delete_all_trades(id);
repo().cancel_all_orders(id);
repo().delete_all_positions(id);
repo().delete_portfolio(id);
}
PtPortfolio pt_reset_portfolio(const QString& id) {
pt_get_portfolio(id); // verify exists
repo().delete_all_trades(id);
repo().cancel_all_orders(id);
repo().delete_all_positions(id);
repo().delete_all_margin_blocks(id); // clear any blocked margin (Phase 3 §4)
// Reset balance to initial
auto p = pt_get_portfolio(id);
repo().update_balance(id, p.initial_balance);
return pt_get_portfolio(id);
}
// ============================================================================
// Order Operations
// ============================================================================
// Persist a rejected order record (best-effort) then throw, so the rejection is
// both visible in the order book and surfaced to callers via the existing
// exception-based contract.
[[noreturn]] static void reject_order(const QString& portfolio_id, const QString& symbol, const QString& side,
const QString& order_type, double quantity, std::optional<double> price,
std::optional<double> stop_price, bool reduce_only, const QString& product,
const QString& exchange, const std::string& reason) {
PtOrder rej;
rej.id = generate_uuid();
rej.portfolio_id = portfolio_id;
rej.symbol = symbol;
rej.side = side;
rej.order_type = order_type;
rej.quantity = quantity;
rej.price = price;
rej.stop_price = stop_price;
rej.filled_qty = 0.0;
rej.status = "rejected";
rej.reduce_only = reduce_only;
rej.margin_blocked = 0.0;
rej.product = product;
rej.exchange = exchange;
rej.created_at = now_rfc3339();
repo().insert_order(rej); // best-effort; ignore failure
throw std::runtime_error(reason);
}
PtOrder pt_place_order(const QString& portfolio_id, const QString& symbol, const QString& side,
const QString& order_type, double quantity, std::optional<double> price,
std::optional<double> stop_price, bool reduce_only, const QString& exchange,
const QString& product) {
// Normalize order-type vocabulary. UnifiedOrder serializes via order_type_str()
// as "stop_loss"/"stop_loss_limit", but the paper engine's canonical spellings
// are "stop"/"stop_limit" (what OrderMatcher matches on). Accept both and store
// the canonical form so SL / SL-Limit paper orders are not rejected here.
QString type = order_type;
if (type == "stop_loss")
type = "stop";
else if (type == "stop_loss_limit")
type = "stop_limit";
// Validation
if (type != "market" && type != "limit" && type != "stop" && type != "stop_limit")
throw std::runtime_error("Invalid order type: " + type.toStdString());
if (side != "buy" && side != "sell")
throw std::runtime_error("Invalid side: " + side.toStdString());
if (!std::isfinite(quantity) || quantity <= 0.0)
throw std::runtime_error("Invalid quantity");
if (price && (!std::isfinite(*price) || *price <= 0.0))
throw std::runtime_error("Invalid price");
if (stop_price && (!std::isfinite(*stop_price) || *stop_price <= 0.0))
throw std::runtime_error("Invalid stop price");
if (type == "limit" && !price)
throw std::runtime_error("Limit order requires price");
if ((type == "stop" || type == "stop_limit") && !stop_price)
throw std::runtime_error("Stop order requires stop_price");
// Serialize the balance read-modify-write against concurrent fills/cancels.
// pt_fill_order / pt_cancel_order already hold s_fill_mutex while they read
// and write portfolio.balance; without this lock a fill landing between our
// balance read (here) and the margin-block write (below) has its balance
// delta silently reverted. Safe: the helpers called under the lock
// (pt_get_portfolio, pt_calculate_required_margin, pt_is_market_open) never
// take s_fill_mutex — pt_convert_position_product already calls them under
// it — and reject_order's throw releases the lock via RAII.
QMutexLocker fill_lock(&s_fill_mutex);
auto portfolio = pt_get_portfolio(portfolio_id);
// Exchange-hours enforcement — opt-in per portfolio (default off preserves
// existing behavior). Only enforced when an exchange is supplied.
if (pt_get_enforce_market_hours(portfolio_id) && !exchange.isEmpty() && !pt_is_market_open(exchange)) {
reject_order(portfolio_id, symbol, side, type, quantity, price, stop_price, reduce_only, product, exchange,
("Market closed for exchange " + exchange).toStdString());
}
// Margin blocking — skip for reduce_only orders and for the portion of an
// order that closes/reduces an existing opposite position. Only the net new
// exposure consumes margin.
double margin_to_block = 0.0;
if (!reduce_only) {
QString opposite_side = (side == "buy") ? "short" : "long";
auto opposite_pos = repo().find_position(portfolio_id, symbol, opposite_side);
double net_new_qty = quantity;
if (opposite_pos) {
// Subtract the quantity that will close the existing position
net_new_qty = std::max(0.0, quantity - opposite_pos->quantity);
}
if (net_new_qty > 0.0) {
double ref = price.value_or(stop_price.value_or(0.0));
if (ref <= 0.0)
throw std::runtime_error("Market orders require a reference price for margin calculation");
// Per-product / per-instrument leverage. If exchange/product are not
// supplied, select_leverage falls back to the equity rules /
// portfolio default, and for blank exchange the equity CNC path.
margin_to_block =
pt_calculate_required_margin(portfolio_id, symbol, exchange, product, net_new_qty, ref, side);
if (margin_to_block > portfolio.balance) {
reject_order(portfolio_id, symbol, side, type, quantity, price, stop_price, reduce_only, product,
exchange, "Insufficient margin");
}
}
}
PtOrder order;
order.id = generate_uuid();
order.portfolio_id = portfolio_id;
order.symbol = symbol;
order.side = side;
order.order_type = type;
order.quantity = quantity;
order.price = price;
order.stop_price = stop_price;
order.filled_qty = 0.0;
order.status = "pending";
order.reduce_only = reduce_only;
order.margin_blocked = margin_to_block;
order.product = product;
order.exchange = exchange;
order.created_at = now_rfc3339();
auto r = repo().insert_order(order);
if (r.is_err())
throw std::runtime_error(r.error());
// Block the margin from available balance and record it against the order so
// the exact amount can be released on fill/cancel.
if (margin_to_block > 0.0) {
repo().update_balance(portfolio_id, portfolio.balance - margin_to_block);
repo().insert_margin_block(generate_uuid(), portfolio_id, order.id, symbol, margin_to_block);
}
return order;
}
void pt_cancel_order(const QString& order_id) {
// Release any margin blocked when the order was placed back to available
// balance (no realized P&L — the order never filled). Serialized under the
// fill mutex so a concurrent fill can't double-release the same block.
QMutexLocker lock(&s_fill_mutex);
// Only a resting order can be cancelled. repo().cancel_order() is an
// unconditional "SET status='cancelled'", so without this gate cancelling an
// already-FILLED order (stale blotter row, double click, MCP tool, workflow
// node) silently rewrote its history to "cancelled" while the position and the
// trade it produced stayed on the books. An unknown id stays a silent no-op,
// exactly as before.
auto ord = repo().get_order(order_id);
if (ord.is_err())
return;
if (ord.value().status != "pending" && ord.value().status != "partial") {
LOG_DEBUG("PaperTrading", QString("pt_cancel_order: order %1 is %2 — nothing to cancel")
.arg(order_id, ord.value().status));
return;
}
double blocked = repo().get_margin_block(order_id);
if (blocked > 0.0) {
auto portfolio = pt_get_portfolio(ord.value().portfolio_id);
repo().update_balance(portfolio.id, portfolio.balance + blocked);
repo().delete_margin_block(order_id);
}
repo().cancel_order(order_id);
}
QVector<PtOrder> pt_get_orders(const QString& portfolio_id, const QString& status) {
auto r = repo().get_orders(portfolio_id, status);
if (r.is_err())
return {};
return r.value();
}
// ============================================================================
// Fill Order — The Core Engine
// ============================================================================
PtTrade pt_fill_order(const QString& order_id, double fill_price, std::optional<double> fill_qty,
const QString& fill_time) {
if (!std::isfinite(fill_price) || fill_price <= 0.0)
throw std::runtime_error("Invalid fill price");
if (fill_qty && (!std::isfinite(*fill_qty) || *fill_qty <= 0.0))
throw std::runtime_error("Invalid fill quantity");
// Serialize fills to prevent concurrent corruption of balance/positions
QMutexLocker fill_lock(&s_fill_mutex);
// 1. Get order
auto or1 = repo().get_order(order_id);
if (or1.is_err())
throw std::runtime_error(or1.error());
PtOrder order = or1.value();
if (order.status != "pending" && order.status != "partial")
throw std::runtime_error("Order not fillable");
// 2. Get portfolio
PtPortfolio portfolio = pt_get_portfolio(order.portfolio_id);
// 3. Fill qty and fee
double qty = fill_qty.value_or(order.quantity - order.filled_qty);
if (qty <= 0.0)
throw std::runtime_error("Nothing left to fill");
QString position_side = (order.side == "buy") ? "long" : "short";
QString opposite_side = (order.side == "buy") ? "short" : "long";
// Reduce-only: the order may only shrink an existing opposite position — it
// must never open or flip one. pt_place_order skips the margin check for
// reduce-only orders, so letting the closing leg's surplus fall through to the
// opening leg below would open an UNCHECKED opposite position (e.g. a
// reduce-only sell of 10 against a long of 1 closed the 1 and opened a 9-lot
// short, charging margin that was never validated). Cap the fill at the
// position size and treat the order as complete (exchanges cancel the
// surplus); with nothing to reduce, cancel the order and refuse the fill.
bool reduce_capped = false;
if (order.reduce_only) {
const auto reducible_pos = repo().find_position(order.portfolio_id, order.symbol, opposite_side);
const double reducible = reducible_pos ? reducible_pos->quantity : 0.0;
if (reducible <= 0.0) {
repo().cancel_order(order_id);
throw std::runtime_error("Reduce-only order has no position to reduce");
}
if (qty > reducible) {
qty = reducible;
reduce_capped = true;
}
}
double fee = qty * fill_price * portfolio.fee_rate;
QString now = fill_time.isEmpty() ? now_rfc3339() : fill_time;
double pnl = 0.0;
double new_filled = order.filled_qty + qty;
bool fully_filled = (new_filled >= order.quantity) || reduce_capped;
// ── Begin DB transaction for atomicity ──────────────────────────────
auto& db = Database::instance();
db.begin_transaction();
try {
// Net change to available cash from this fill. Margin model (v040):
// • Opening exposure KEEPS its margin locked on the position (held_margin)
// — it is NOT released to cash on fill. This is what finally makes
// available balance drop when a position is opened (the old code released
// the block on fill, so an open position locked no cash — "stuck at 10L").
// • Closing/reducing a position RELEASES that position's held margin back
// to cash, proportionally, plus realized P&L.
// • Brokerage (fee) is charged on every fill.
double balance_delta = -fee;
const double order_blocked = repo().get_margin_block(order_id);
double block_consumed = 0.0; // portion of the order's block turned into position margin
// ── Closing leg: net against an opposite-side position ──
double close_qty = 0.0;
auto opp = repo().find_position(order.portfolio_id, order.symbol, opposite_side);
if (opp) {
PtPosition pos = *opp;
close_qty = std::min(qty, pos.quantity);
pnl = (pos.side == "long") ? (fill_price - pos.entry_price) * close_qty
: (pos.entry_price - fill_price) * close_qty;
const double frac_close = pos.quantity > 0.0 ? (close_qty / pos.quantity) : 1.0;
const double margin_released = pos.held_margin * frac_close;
if (close_qty >= pos.quantity) {
repo().delete_position(pos.id);
} else {
repo().update_position(pos.id, pos.quantity - close_qty, pos.entry_price);
repo().set_position_margin(pos.id, pos.held_margin - margin_released);
repo().add_realized_pnl(pos.id, pnl);
}
balance_delta += margin_released + pnl;
}
// ── Opening leg: net-new exposure on the order's own side ──
const double open_qty = qty - close_qty;
if (open_qty > 0.0) {
// Margin the new exposure must lock, per product / leverage at fill price.
double open_margin = pt_calculate_required_margin(order.portfolio_id, order.symbol, order.exchange,
order.product, open_qty, fill_price, order.side);
// That margin was pre-blocked on the order at placement: convert the
// block into position margin (release the block, re-lock the actual).
block_consumed = fully_filled ? order_blocked : std::min(order_blocked, open_margin);
balance_delta += block_consumed - open_margin;
const QString product = order.product.isEmpty() ? QStringLiteral("MIS") : order.product;
auto same = repo().find_position(order.portfolio_id, order.symbol, position_side);
if (same) {
PtPosition pos = *same;
double new_qty = pos.quantity + open_qty;
if (new_qty <= 0.0)
throw std::runtime_error("Invalid position quantity after averaging");
double new_entry = (pos.entry_price * pos.quantity + fill_price * open_qty) / new_qty;
repo().update_position(pos.id, new_qty, new_entry);
repo().set_position_margin(pos.id, pos.held_margin + open_margin);
} else {
PtPosition np;
np.id = generate_uuid();
np.portfolio_id = order.portfolio_id;
np.symbol = order.symbol;
np.side = position_side;
np.quantity = open_qty;
np.entry_price = fill_price;
np.current_price = fill_price;
np.leverage = open_margin > 0.0 ? (open_qty * fill_price) / open_margin : portfolio.leverage;
np.opened_at = now;
np.product = product;
np.held_margin = open_margin;
repo().insert_position(np);
}
}
// ── Settle the order's margin block ──
if (order_blocked > 0.0) {
if (fully_filled) {
// A fill that only closed existing exposure (open_qty == 0) never
// reached the opening leg, so none of this order's pre-blocked margin
// was converted or handed back — dropping the row here without
// crediting it leaked the whole block out of cash for good.
if (open_qty <= 0.0)
balance_delta += order_blocked;
repo().delete_margin_block(order_id);
} else {
double remaining = std::max(0.0, order_blocked - block_consumed);
repo().insert_margin_block(generate_uuid(), order.portfolio_id, order_id, order.symbol, remaining);
}
}
repo().update_balance(order.portfolio_id, portfolio.balance + balance_delta);
// 8. Update order
QString new_status = fully_filled ? "filled" : "partial";
double prev_avg = order.avg_price.value_or(0.0);
double new_avg =
(new_filled > 0.0) ? (prev_avg * order.filled_qty + fill_price * qty) / new_filled : fill_price;
repo().update_order_fill(order_id, new_filled, new_avg, new_status, now);
// 9. Create trade record
PtTrade trade;
trade.id = generate_uuid();
trade.portfolio_id = order.portfolio_id;
trade.order_id = order_id;
trade.symbol = order.symbol;
trade.side = order.side;
trade.price = fill_price;
trade.quantity = qty;
trade.fee = fee;
trade.pnl = pnl;
trade.timestamp = now;
repo().insert_trade(trade);
db.commit();
// Emit event (outside transaction — non-critical)
EventBus::instance().publish("paper_trading.order_filled", {{"trade_id", trade.id},
{"portfolio_id", trade.portfolio_id},
{"symbol", trade.symbol},
{"side", trade.side},
{"price", trade.price},
{"quantity", trade.quantity},
{"pnl", trade.pnl},
{"fee", trade.fee}});
return trade;
} catch (...) {
db.rollback();
throw;
}
}
// ============================================================================
// Position & Trade Queries
// ============================================================================
QVector<PtPosition> pt_get_positions(const QString& portfolio_id) {
auto r = repo().get_positions(portfolio_id);
if (r.is_err())
return {};
return r.value();
}
void pt_update_position_price(const QString& portfolio_id, const QString& symbol, double price) {
repo().update_position_price(portfolio_id, symbol, price);
}
QVector<PtTrade> pt_get_trades(const QString& portfolio_id, int64_t limit) {
auto r = repo().get_trades(portfolio_id, limit);
if (r.is_err())
return {};
return r.value();
}
PtStats pt_get_stats(const QString& portfolio_id) {
auto r = repo().get_stats(portfolio_id);
if (r.is_err())
return {};
return r.value();
}
// ============================================================================
// Day-scoped queries / Settlement / Product conversion (v040)
// ============================================================================
namespace {
// IST = UTC + 5:30. The UTC instant at which the given IST calendar day begins.
QDateTime ist_day_start_utc(const QDate& ist_day) {
QDateTime utc_midnight(ist_day, QTime(0, 0, 0), QTimeZone::UTC);
return utc_midnight.addSecs(-330 * 60); // shift IST-midnight back to its UTC instant
}
// The IST calendar date of a stored (naive/Z UTC) ISO timestamp.
QDate ist_date_of(const QString& iso_utc, const QDate& fallback) {
QDateTime dt = QDateTime::fromString(iso_utc, Qt::ISODate);
if (!dt.isValid())
return fallback;
dt.setTimeZone(QTimeZone::UTC); // timestamps are UTC; reinterpret if no zone was parsed
return dt.addSecs(330 * 60).date();
}
} // namespace
QVector<PtOrder> pt_get_orders_for_day(const QString& portfolio_id, const QDate& ist_day) {
const QDateTime start = ist_day_start_utc(ist_day);
auto r =
repo().get_orders_between(portfolio_id, start.toString(Qt::ISODate), start.addDays(1).toString(Qt::ISODate));
return r.is_ok() ? r.value() : QVector<PtOrder>{};
}
QVector<PtTrade> pt_get_trades_for_day(const QString& portfolio_id, const QDate& ist_day) {
const QDateTime start = ist_day_start_utc(ist_day);
auto r =
repo().get_trades_between(portfolio_id, start.toString(Qt::ISODate), start.addDays(1).toString(Qt::ISODate));
return r.is_ok() ? r.value() : QVector<PtTrade>{};
}
void pt_convert_position_product(const QString& position_id, const QString& new_product) {
QMutexLocker lock(&s_fill_mutex);
auto pr = repo().get_position(position_id);
if (pr.is_err())
throw std::runtime_error(pr.error());
PtPosition pos = pr.value();
if (pos.product.compare(new_product, Qt::CaseInsensitive) == 0)
return; // already that product — no-op
auto portfolio = pt_get_portfolio(pos.portfolio_id);
// Margin the position would lock under the NEW product, at its entry basis.
// (CNC/delivery = full notional at 1x; MIS = notional/leverage.)
const QString side = (pos.side == "long") ? "buy" : "sell";
const double new_margin = pt_calculate_required_margin(pos.portfolio_id, pos.symbol, QString(), new_product,
pos.quantity, pos.entry_price, side);
const double extra = new_margin - pos.held_margin; // additional cash to lock (CNC needs more than MIS)
if (extra > portfolio.balance + 1e-6)
throw std::runtime_error(("Insufficient balance to convert to " + new_product).toStdString());
auto& db = Database::instance();
db.begin_transaction();
try {
repo().update_balance(pos.portfolio_id, portfolio.balance - extra);
repo().set_position_margin(position_id, new_margin);
repo().set_position_product(position_id, new_product);
db.commit();
} catch (...) {
db.rollback();
throw;
}
}
int pt_settle_intraday(const QString& portfolio_id) {
// Intraday auto-square applies ONLY to Indian (INR) equity portfolios. Crypto
// and US (USD) paper portfolios trade on other schedules and must never be
// squared at the IST 15:30 cutoff (this previously closed month-old crypto
// positions because their product had defaulted to MIS).
PtPortfolio portfolio;
try {
portfolio = pt_get_portfolio(portfolio_id);
} catch (...) {
return 0;
}
if (portfolio.currency.compare("INR", Qt::CaseInsensitive) != 0)
return 0;
const QDateTime ist_now = QDateTime::currentDateTimeUtc().addSecs(330 * 60);
const QDate ist_today = ist_now.date();
const bool past_close = ist_now.time() >= QTime(15, 30);
int squared = 0;
const auto positions = pt_get_positions(portfolio_id);
for (const auto& pos : positions) {
if (!product_is_intraday(pos.product))
continue; // CNC / NRML carry forward
const QDate opened_ist = ist_date_of(pos.opened_at, ist_today);
const bool from_prior_day = opened_ist < ist_today;
if (!past_close && !from_prior_day)
continue; // still within today's session and not yet 15:30
const double price = pos.current_price > 0.0 ? pos.current_price : pos.entry_price;
if (price <= 0.0)
continue; // can't price the square-off
// Stamp the square-off at the session close it actually belongs to: 15:30
// IST on the day the position was opened. For a same-day position past the
// cutoff that's today's 15:30; for a carried-over position it's that prior
// day's close — so a catch-up auto-square lands in THAT day's book, never
// polluting today's order list with trades the user didn't place.
const QDateTime close_utc = QDateTime(opened_ist, QTime(15, 30, 0), QTimeZone::UTC).addSecs(-330 * 60);
const QString close_iso = close_utc.toString(Qt::ISODate);
// Square off = insert a reduce-only market order on the opposite side and
// fill it at the last price. Reuses the fill engine's closing leg (margin
// release + realized P&L + trade record), and leaves an auto-square order
// in the book just like a real broker's 3:30 cutoff.
try {
PtOrder o;
o.id = generate_uuid();
o.portfolio_id = portfolio_id;
o.symbol = pos.symbol;
o.side = (pos.side == "long") ? QStringLiteral("sell") : QStringLiteral("buy");
o.order_type = "market";
o.quantity = pos.quantity;
o.price = price;
o.filled_qty = 0.0;
o.status = "pending";
o.reduce_only = true;
o.margin_blocked = 0.0;
o.product = pos.product;
o.created_at = close_iso;
auto ir = repo().insert_order(o);
if (ir.is_err())
continue;
pt_fill_order(o.id, price, std::nullopt, close_iso);
++squared;
} catch (const std::exception& e) {
LOG_WARN("PaperTrading", QString("Auto-square failed for %1: %2").arg(pos.symbol, e.what()));
}
}
// Stale DAY orders from earlier IST sessions expire at the close — cancel them
// so they don't linger as pending or fire on a later day.
const auto pending = pt_get_orders(portfolio_id, "pending");
for (const auto& o : pending) {
if (ist_date_of(o.created_at, ist_today) < ist_today) {
try {
pt_cancel_order(o.id);
} catch (...) {
}
}
}
return squared;
}
int pt_settle_intraday_all() {
int total = 0;
for (const auto& p : pt_list_portfolios())
total += pt_settle_intraday(p.id);
return total;
}
} // namespace fincept::trading