742 lines
34 KiB
JavaScript
742 lines
34 KiB
JavaScript
"use strict";
|
|
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
|
if (k2 === undefined) k2 = k;
|
|
var desc = Object.getOwnPropertyDescriptor(m, k);
|
|
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
|
desc = { enumerable: true, get: function() { return m[k]; } };
|
|
}
|
|
Object.defineProperty(o, k2, desc);
|
|
}) : (function(o, m, k, k2) {
|
|
if (k2 === undefined) k2 = k;
|
|
o[k2] = m[k];
|
|
}));
|
|
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
}) : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar = (this && this.__importStar) || (function () {
|
|
var ownKeys = function(o) {
|
|
ownKeys = Object.getOwnPropertyNames || function (o) {
|
|
var ar = [];
|
|
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
|
|
return ar;
|
|
};
|
|
return ownKeys(o);
|
|
};
|
|
return function (mod) {
|
|
if (mod && mod.__esModule) return mod;
|
|
var result = {};
|
|
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
|
|
__setModuleDefault(result, mod);
|
|
return result;
|
|
};
|
|
})();
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.getUserKpis = getUserKpis;
|
|
exports.getDepositKpis = getDepositKpis;
|
|
exports.getWithdrawalKpis = getWithdrawalKpis;
|
|
exports.getBonusKpis = getBonusKpis;
|
|
exports.getAdjustmentKpis = getAdjustmentKpis;
|
|
exports.getWalletBalances = getWalletBalances;
|
|
exports.getFinancialPerformance = getFinancialPerformance;
|
|
exports.getGameAnalytics = getGameAnalytics;
|
|
exports.getUserSecurityKpis = getUserSecurityKpis;
|
|
exports.getUserActivityKpis = getUserActivityKpis;
|
|
exports.getRecentLogins = getRecentLogins;
|
|
exports.getGeographyStats = getGeographyStats;
|
|
exports.getDemographics = getDemographics;
|
|
exports.getTimeSeries = getTimeSeries;
|
|
exports.getAlertsSummary = getAlertsSummary;
|
|
const connection_1 = require("../db/connection");
|
|
const mvCharts = __importStar(require("./analyticsMaterializedQueries"));
|
|
const analyticsCache_1 = require("../utils/analyticsCache");
|
|
const onlineUsersRepository_1 = require("./onlineUsersRepository");
|
|
async function useDashboardMv() {
|
|
return mvCharts.areDashboardMaterializedViewsReady();
|
|
}
|
|
function num(v) {
|
|
if (v == null)
|
|
return 0;
|
|
return typeof v === 'number' ? v : parseInt(String(v), 10) || 0;
|
|
}
|
|
/** User KPI aggregates. */
|
|
async function getUserKpis(range) {
|
|
if (await useDashboardMv()) {
|
|
const rows = await (0, connection_1.query)(`WITH period AS (
|
|
SELECT $1::timestamptz AS from_ts, $2::timestamptz AS to_ts
|
|
),
|
|
prev AS (
|
|
SELECT ($1::timestamptz - ($2::timestamptz - $1::timestamptz)) AS from_ts, $1::timestamptz AS to_ts
|
|
)
|
|
SELECT
|
|
(SELECT COUNT(*)::text FROM users) AS total_users,
|
|
(SELECT COUNT(*)::text FROM users u, period p WHERE u.created_at BETWEEN p.from_ts AND p.to_ts) AS new_users,
|
|
(SELECT COUNT(*)::text FROM users u
|
|
LEFT JOIN user_admin_stats s ON s.user_id = u.id
|
|
CROSS JOIN period p
|
|
WHERE COALESCE(s.last_activity_at, u.created_at) < p.from_ts) AS inactive_users,
|
|
(SELECT COUNT(*)::text FROM users u, prev WHERE u.created_at BETWEEN prev.from_ts AND prev.to_ts) AS prev_new_users,
|
|
(SELECT COUNT(*)::text FROM users u JOIN roles r ON r.id = u.role_id WHERE r.name IN ('admin', 'moderator')) AS admin_count`, [range.from, range.to]);
|
|
const activeUsers = await mvCharts.mvActiveUsersInPeriod(range);
|
|
const [onlineNow, onlineInApp] = await Promise.all([
|
|
(0, onlineUsersRepository_1.countConnectedOnGame)(),
|
|
(0, onlineUsersRepository_1.countConnectedInApp)(),
|
|
]);
|
|
const r = rows[0];
|
|
const newUsers = num(r?.new_users);
|
|
const prevNew = num(r?.prev_new_users);
|
|
const growthRate = prevNew > 0 ? ((newUsers - prevNew) / prevNew) * 100 : newUsers > 0 ? 100 : 0;
|
|
return {
|
|
totalUsers: num(r?.total_users),
|
|
newUsers,
|
|
activeUsers,
|
|
inactiveUsers: num(r?.inactive_users),
|
|
signupGrowthRate: Math.round(growthRate * 100) / 100,
|
|
onlineNow,
|
|
onlineInApp,
|
|
adminCount: num(r?.admin_count),
|
|
};
|
|
}
|
|
const rows = await (0, connection_1.query)(`WITH period AS (
|
|
SELECT $1::timestamptz AS from_ts, $2::timestamptz AS to_ts
|
|
),
|
|
prev AS (
|
|
SELECT ($1::timestamptz - ($2::timestamptz - $1::timestamptz)) AS from_ts, $1::timestamptz AS to_ts
|
|
)
|
|
SELECT
|
|
(SELECT COUNT(*)::text FROM users) AS total_users,
|
|
(SELECT COUNT(*)::text FROM users u, period p WHERE u.created_at BETWEEN p.from_ts AND p.to_ts) AS new_users,
|
|
(SELECT COUNT(DISTINCT x.user_id)::text FROM (
|
|
SELECT user_id FROM audit_logs, period p WHERE action = 'login' AND created_at BETWEEN p.from_ts AND p.to_ts
|
|
UNION
|
|
SELECT user_id FROM candle_predict_bets, period p WHERE created_at BETWEEN p.from_ts AND p.to_ts
|
|
) x) AS active_users,
|
|
(SELECT COUNT(*)::text FROM users u
|
|
LEFT JOIN user_admin_stats s ON s.user_id = u.id
|
|
CROSS JOIN period p
|
|
WHERE COALESCE(s.last_activity_at, u.created_at) < p.from_ts) AS inactive_users,
|
|
(SELECT COUNT(*)::text FROM users u, prev WHERE u.created_at BETWEEN prev.from_ts AND prev.to_ts) AS prev_new_users,
|
|
(SELECT COUNT(*)::text FROM users u JOIN roles r ON r.id = u.role_id WHERE r.name IN ('admin', 'moderator')) AS admin_count`, [range.from, range.to]);
|
|
const [onlineNow, onlineInApp] = await Promise.all([
|
|
(0, onlineUsersRepository_1.countConnectedOnGame)(),
|
|
(0, onlineUsersRepository_1.countConnectedInApp)(),
|
|
]);
|
|
const r = rows[0];
|
|
const newUsers = num(r?.new_users);
|
|
const prevNew = num(r?.prev_new_users);
|
|
const growthRate = prevNew > 0 ? ((newUsers - prevNew) / prevNew) * 100 : newUsers > 0 ? 100 : 0;
|
|
return {
|
|
totalUsers: num(r?.total_users),
|
|
newUsers,
|
|
activeUsers: num(r?.active_users),
|
|
inactiveUsers: num(r?.inactive_users),
|
|
signupGrowthRate: Math.round(growthRate * 100) / 100,
|
|
onlineNow,
|
|
onlineInApp,
|
|
adminCount: num(r?.admin_count),
|
|
};
|
|
}
|
|
/** Deposit aggregates for the selected period. */
|
|
async function getDepositKpis(range) {
|
|
if (await useDashboardMv()) {
|
|
return mvCharts.mvTransactionKpis(range, 'deposit');
|
|
}
|
|
const rows = await (0, connection_1.query)(`SELECT
|
|
COALESCE(SUM(amount), 0)::text AS total_amount,
|
|
COUNT(*)::text AS total_count,
|
|
COUNT(DISTINCT user_id)::text AS unique_users,
|
|
COALESCE(MAX(amount), 0)::text AS max_amount
|
|
FROM transactions
|
|
WHERE type = 'deposit' AND status = 'completed'
|
|
AND created_at BETWEEN $1 AND $2`, [range.from, range.to]);
|
|
const r = rows[0];
|
|
const totalAmount = num(r?.total_amount);
|
|
const uniqueUsers = num(r?.unique_users);
|
|
return {
|
|
totalAmountRaw: totalAmount,
|
|
totalCount: num(r?.total_count),
|
|
uniqueUsers,
|
|
averagePerUserRaw: uniqueUsers > 0 ? Math.round(totalAmount / uniqueUsers) : 0,
|
|
maxAmountRaw: num(r?.max_amount),
|
|
};
|
|
}
|
|
/** Withdrawal aggregates for the selected period. */
|
|
async function getWithdrawalKpis(range) {
|
|
if (await useDashboardMv()) {
|
|
return mvCharts.mvTransactionKpis(range, 'withdrawal');
|
|
}
|
|
const rows = await (0, connection_1.query)(`SELECT
|
|
COALESCE(SUM(amount), 0)::text AS total_amount,
|
|
COUNT(*)::text AS total_count,
|
|
COUNT(DISTINCT user_id)::text AS unique_users,
|
|
COALESCE(MAX(amount), 0)::text AS max_amount
|
|
FROM transactions
|
|
WHERE type = 'withdrawal' AND status = 'completed'
|
|
AND created_at BETWEEN $1 AND $2`, [range.from, range.to]);
|
|
const r = rows[0];
|
|
const totalAmount = num(r?.total_amount);
|
|
const uniqueUsers = num(r?.unique_users);
|
|
return {
|
|
totalAmountRaw: totalAmount,
|
|
totalCount: num(r?.total_count),
|
|
uniqueUsers,
|
|
averagePerUserRaw: uniqueUsers > 0 ? Math.round(totalAmount / uniqueUsers) : 0,
|
|
maxAmountRaw: num(r?.max_amount),
|
|
};
|
|
}
|
|
/** Bonus aggregates for the selected period. */
|
|
async function getBonusKpis(range) {
|
|
if (await useDashboardMv()) {
|
|
return mvCharts.mvBonusKpis(range);
|
|
}
|
|
const rows = await (0, connection_1.query)(`SELECT
|
|
(SELECT COALESCE(SUM(amount), 0)::text FROM ledger_adjustments
|
|
WHERE adjustment_type = 'bonus' AND created_at BETWEEN $1 AND $2) AS bonus_total,
|
|
(SELECT COUNT(DISTINCT user_id)::text FROM ledger_adjustments
|
|
WHERE adjustment_type = 'bonus' AND created_at BETWEEN $1 AND $2) AS bonus_users,
|
|
(SELECT COALESCE(SUM(commission_amount), 0)::text FROM referral_commission_payouts
|
|
WHERE status = 'paid' AND COALESCE(paid_at, created_at) BETWEEN $1 AND $2) AS referral_total,
|
|
(SELECT COALESCE(SUM(amount), 0)::text FROM ledger_adjustments
|
|
WHERE adjustment_type = 'bonus' AND created_at BETWEEN $1 AND $2) AS manual_bonus`, [range.from, range.to]);
|
|
const r = rows[0];
|
|
const bonusTotal = num(r?.bonus_total) + num(r?.referral_total);
|
|
const bonusUsers = num(r?.bonus_users);
|
|
return {
|
|
totalAmountRaw: bonusTotal,
|
|
uniqueUsers: bonusUsers,
|
|
averagePerUserRaw: bonusUsers > 0 ? Math.round(bonusTotal / bonusUsers) : 0,
|
|
byType: {
|
|
manualBonusRaw: num(r?.manual_bonus),
|
|
referralCommissionRaw: num(r?.referral_total),
|
|
},
|
|
};
|
|
}
|
|
async function getAdjustmentKpis(range) {
|
|
if (await useDashboardMv()) {
|
|
return mvCharts.mvAdjustmentKpis(range);
|
|
}
|
|
const rows = await (0, connection_1.query)(`SELECT
|
|
COALESCE(SUM(amount), 0)::text AS total_amount,
|
|
COUNT(DISTINCT user_id)::text AS unique_users,
|
|
COUNT(*)::text AS total_count
|
|
FROM ledger_adjustments
|
|
WHERE adjustment_type = 'admin_adjustment'
|
|
AND created_at BETWEEN $1 AND $2`, [range.from, range.to]);
|
|
const r = rows[0];
|
|
const totalAmount = num(r?.total_amount);
|
|
const uniqueUsers = num(r?.unique_users);
|
|
const totalCount = num(r?.total_count);
|
|
return {
|
|
uniqueUsers,
|
|
totalAmountRaw: totalAmount,
|
|
averageRaw: totalCount > 0 ? Math.round(totalAmount / totalCount) : 0,
|
|
};
|
|
}
|
|
/** Current wallet balances across all users. */
|
|
async function getWalletBalances() {
|
|
const rows = await (0, connection_1.query)(`SELECT
|
|
COALESCE(SUM(s.main_balance_raw), 0)::text AS main_raw,
|
|
COALESCE(SUM(s.bonus_balance_raw), 0)::text AS bonus_raw,
|
|
COALESCE((
|
|
SELECT SUM(la.available_balance) FROM ledger_accounts la
|
|
JOIN wallet_types wt ON wt.id = la.wallet_type_id
|
|
WHERE wt.code = 'USDT_TRC20' AND la.account_kind = 'test'
|
|
), 0)::text AS test_raw
|
|
FROM user_admin_stats s`);
|
|
const r = rows[0];
|
|
const main = num(r?.main_raw);
|
|
const bonus = num(r?.bonus_raw);
|
|
const test = num(r?.test_raw);
|
|
return {
|
|
mainWalletRaw: main,
|
|
bonusWalletRaw: bonus,
|
|
testWalletRaw: test,
|
|
totalRaw: main + bonus + test,
|
|
distribution: [
|
|
{ kind: 'main', amountRaw: main },
|
|
{ kind: 'bonus', amountRaw: bonus },
|
|
{ kind: 'test', amountRaw: test },
|
|
],
|
|
};
|
|
}
|
|
async function getGameHousePnl(range, scope = 'real') {
|
|
const accountFilter = scope === 'real'
|
|
? "AND stake_account_kind IN ('main', 'bonus')"
|
|
: "AND stake_account_kind = 'test'";
|
|
if (await useDashboardMv()) {
|
|
return mvCharts.mvGameHousePnl(range, scope);
|
|
}
|
|
const rows = await (0, connection_1.query)(`SELECT
|
|
COALESCE(SUM(stake_raw), 0)::text AS stake,
|
|
COALESCE(SUM(payout_raw), 0)::text AS payout
|
|
FROM candle_predict_bets
|
|
WHERE created_at BETWEEN $1 AND $2
|
|
AND status IN ('won', 'lost', 'refunded')
|
|
${accountFilter}`, [range.from, range.to]);
|
|
const stake = num(rows[0]?.stake);
|
|
const payout = num(rows[0]?.payout);
|
|
return { houseNetPnlRaw: stake - payout };
|
|
}
|
|
async function getFinancialPerformance(range) {
|
|
const [deposits, withdrawals, bonus, adjustments, gamePnlReal, gamePnlTest] = await Promise.all([
|
|
getDepositKpis(range),
|
|
getWithdrawalKpis(range),
|
|
getBonusKpis(range),
|
|
getAdjustmentKpis(range),
|
|
getGameHousePnl(range, 'real'),
|
|
getGameHousePnl(range, 'test'),
|
|
]);
|
|
const depositRaw = deposits.totalAmountRaw;
|
|
const withdrawalRaw = withdrawals.totalAmountRaw;
|
|
return {
|
|
platformNetPnlRaw: gamePnlReal.houseNetPnlRaw,
|
|
platformNetPnlTestRaw: gamePnlTest.houseNetPnlRaw,
|
|
bonusCostRaw: bonus.totalAmountRaw,
|
|
adjustmentCostRaw: adjustments.totalAmountRaw,
|
|
depositWithdrawalRatio: withdrawalRaw > 0 ? Math.round((depositRaw / withdrawalRaw) * 100) / 100 : depositRaw > 0 ? null : 0,
|
|
};
|
|
}
|
|
async function getBetSegmentStats(range, whereExtra) {
|
|
const needsDirectQuery = /prediction_mode/i.test(whereExtra) || /stake_account_kind/i.test(whereExtra);
|
|
if (await useDashboardMv() && !needsDirectQuery) {
|
|
const filters = parseBetSegmentFilters(whereExtra);
|
|
return mvCharts.mvBetSegmentStats(range, filters);
|
|
}
|
|
const rows = await (0, connection_1.query)(`SELECT
|
|
COUNT(DISTINCT user_id)::text AS users,
|
|
COUNT(*)::text AS predictions,
|
|
COALESCE(SUM(stake_raw), 0)::text AS stake,
|
|
COALESCE(SUM(payout_raw), 0)::text AS payout,
|
|
SUM(CASE WHEN status = 'won' THEN 1 ELSE 0 END)::text AS won,
|
|
SUM(CASE WHEN status IN ('won', 'lost') THEN 1 ELSE 0 END)::text AS settled
|
|
FROM candle_predict_bets
|
|
WHERE created_at BETWEEN $1 AND $2 ${whereExtra}`, [range.from, range.to]);
|
|
const r = rows[0];
|
|
const stake = num(r?.stake);
|
|
const payout = num(r?.payout);
|
|
const settled = num(r?.settled);
|
|
const won = num(r?.won);
|
|
return {
|
|
users: num(r?.users),
|
|
predictions: num(r?.predictions),
|
|
stakeRaw: stake,
|
|
netPnlRaw: payout - stake,
|
|
winRate: settled > 0 ? Math.round((won / settled) * 10000) / 100 : 0,
|
|
};
|
|
}
|
|
function parseBetSegmentFilters(whereExtra) {
|
|
const filters = {};
|
|
if (/is_auto\s*=\s*FALSE/i.test(whereExtra))
|
|
filters.isAuto = false;
|
|
if (/is_auto\s*=\s*TRUE/i.test(whereExtra))
|
|
filters.isAuto = true;
|
|
if (/stake_account_kind\s*=\s*'test'/i.test(whereExtra)) {
|
|
filters.stakeAccountKinds = ['test'];
|
|
}
|
|
else if (/stake_account_kind\s+IN\s*\(\s*'main'\s*,\s*'bonus'\s*\)/i.test(whereExtra)) {
|
|
filters.stakeAccountKinds = ['main', 'bonus'];
|
|
}
|
|
return filters;
|
|
}
|
|
async function dailyPredictionCounts(range, whereExtra) {
|
|
return dailySeries(`SELECT to_char(date_trunc('day', created_at), 'YYYY-MM-DD') AS day, COUNT(*)::text AS value
|
|
FROM candle_predict_bets WHERE created_at BETWEEN $1 AND $2 ${whereExtra}
|
|
GROUP BY 1 ORDER BY 1`, range);
|
|
}
|
|
function emptySegment() {
|
|
return { users: 0, predictions: 0, stakeRaw: 0, netPnlRaw: 0, winRate: 0 };
|
|
}
|
|
async function getGameAnalytics(range, gameKey) {
|
|
if (gameKey !== 'all' && gameKey !== 'candle-predict') {
|
|
return {
|
|
participation: {
|
|
uniqueParticipants: 0,
|
|
totalPredictions: 0,
|
|
avgPredictionsPerUser: 0,
|
|
totalStakeRaw: 0,
|
|
},
|
|
manual: emptySegment(),
|
|
auto: emptySegment(),
|
|
multiCandle: emptySegment(),
|
|
testWallet: { uniqueUsers: 0, totalStakeRaw: 0, netPnlRaw: 0 },
|
|
cross: {
|
|
realManual: emptySegment(),
|
|
realAuto: emptySegment(),
|
|
realMulti: emptySegment(),
|
|
testManual: emptySegment(),
|
|
testAuto: emptySegment(),
|
|
testMulti: emptySegment(),
|
|
},
|
|
};
|
|
}
|
|
const overall = await getBetSegmentStats(range, '');
|
|
const manual = await getBetSegmentStats(range, `AND is_auto = FALSE AND prediction_mode = 'single' AND stake_account_kind IN ('main', 'bonus')`);
|
|
const auto = await getBetSegmentStats(range, `AND is_auto = TRUE AND stake_account_kind IN ('main', 'bonus')`);
|
|
const multiCandle = await getBetSegmentStats(range, `AND prediction_mode = 'multi_candle' AND stake_account_kind IN ('main', 'bonus')`);
|
|
const test = await getBetSegmentStats(range, `AND stake_account_kind = 'test'`);
|
|
return {
|
|
participation: {
|
|
uniqueParticipants: overall.users,
|
|
totalPredictions: overall.predictions,
|
|
avgPredictionsPerUser: overall.users > 0 ? Math.round((overall.predictions / overall.users) * 100) / 100 : 0,
|
|
totalStakeRaw: overall.stakeRaw,
|
|
},
|
|
manual,
|
|
auto,
|
|
multiCandle,
|
|
testWallet: {
|
|
uniqueUsers: test.users,
|
|
totalStakeRaw: test.stakeRaw,
|
|
netPnlRaw: test.netPnlRaw,
|
|
},
|
|
cross: {
|
|
realManual: await getBetSegmentStats(range, `AND stake_account_kind IN ('main', 'bonus') AND is_auto = FALSE AND prediction_mode = 'single'`),
|
|
realAuto: await getBetSegmentStats(range, `AND stake_account_kind IN ('main', 'bonus') AND is_auto = TRUE`),
|
|
realMulti: await getBetSegmentStats(range, `AND stake_account_kind IN ('main', 'bonus') AND prediction_mode = 'multi_candle'`),
|
|
testManual: await getBetSegmentStats(range, `AND stake_account_kind = 'test' AND is_auto = FALSE AND prediction_mode = 'single'`),
|
|
testAuto: await getBetSegmentStats(range, `AND stake_account_kind = 'test' AND is_auto = TRUE`),
|
|
testMulti: await getBetSegmentStats(range, `AND stake_account_kind = 'test' AND prediction_mode = 'multi_candle'`),
|
|
},
|
|
};
|
|
}
|
|
async function getUserSecurityKpis() {
|
|
const cached = (0, analyticsCache_1.getCachedSecurityKpis)();
|
|
if (cached)
|
|
return cached;
|
|
const rows = await (0, connection_1.query)(`SELECT
|
|
SUM(CASE WHEN email_verified THEN 1 ELSE 0 END)::text AS email_verified,
|
|
SUM(CASE WHEN NOT email_verified THEN 1 ELSE 0 END)::text AS email_unverified,
|
|
SUM(CASE WHEN totp_enabled THEN 1 ELSE 0 END)::text AS totp_on,
|
|
SUM(CASE WHEN NOT totp_enabled THEN 1 ELSE 0 END)::text AS totp_off,
|
|
SUM(CASE WHEN security_suspended_at IS NOT NULL THEN 1 ELSE 0 END)::text AS suspended,
|
|
SUM(CASE WHEN NOT is_enabled THEN 1 ELSE 0 END)::text AS disabled,
|
|
SUM(CASE WHEN NOT is_account_non_expired THEN 1 ELSE 0 END)::text AS expired,
|
|
SUM(CASE WHEN NOT is_credentials_non_expired THEN 1 ELSE 0 END)::text AS creds_expired,
|
|
SUM(CASE WHEN under_surveillance THEN 1 ELSE 0 END)::text AS under_surveillance,
|
|
SUM(CASE WHEN withdrawals_suspended THEN 1 ELSE 0 END)::text AS withdrawals_blocked
|
|
FROM users`);
|
|
const r = rows[0];
|
|
const result = {
|
|
emailVerified: num(r?.email_verified),
|
|
emailUnverified: num(r?.email_unverified),
|
|
totpEnabled: num(r?.totp_on),
|
|
totpDisabled: num(r?.totp_off),
|
|
suspendedAccounts: num(r?.suspended),
|
|
disabledAccounts: num(r?.disabled),
|
|
expiredAccounts: num(r?.expired),
|
|
credentialsExpired: num(r?.creds_expired),
|
|
underSurveillance: num(r?.under_surveillance),
|
|
withdrawalsBlocked: num(r?.withdrawals_blocked),
|
|
};
|
|
(0, analyticsCache_1.setCachedSecurityKpis)(result);
|
|
return result;
|
|
}
|
|
async function getUserActivityKpis(range) {
|
|
const rows = await (0, connection_1.query)(`SELECT
|
|
(SELECT COUNT(DISTINCT user_id)::text FROM audit_logs
|
|
WHERE action = 'login' AND created_at >= date_trunc('day', NOW())) AS active_today,
|
|
(SELECT COUNT(DISTINCT user_id)::text FROM audit_logs
|
|
WHERE action = 'login' AND created_at >= date_trunc('week', NOW())) AS active_week,
|
|
(SELECT COUNT(DISTINCT user_id)::text FROM audit_logs
|
|
WHERE action = 'login' AND created_at >= date_trunc('month', NOW())) AS active_month,
|
|
(SELECT COUNT(*)::text FROM users u
|
|
LEFT JOIN user_admin_stats s ON s.user_id = u.id
|
|
WHERE COALESCE(s.last_activity_at, u.created_at) < $1) AS inactive_period`, [range.from]);
|
|
const r = rows[0];
|
|
return {
|
|
activeToday: num(r?.active_today),
|
|
activeThisWeek: num(r?.active_week),
|
|
activeThisMonth: num(r?.active_month),
|
|
inactiveInPeriod: num(r?.inactive_period),
|
|
};
|
|
}
|
|
async function getRecentLogins(limit = 10) {
|
|
const rows = await (0, connection_1.query)(`SELECT al.user_id, u.first_name, u.last_name, MAX(al.created_at) AS logged_at
|
|
FROM audit_logs al
|
|
JOIN users u ON u.id = al.user_id
|
|
WHERE al.action = 'login'
|
|
GROUP BY al.user_id, u.first_name, u.last_name
|
|
ORDER BY logged_at DESC
|
|
LIMIT $1`, [limit]);
|
|
return rows.map((r) => ({
|
|
userId: r.user_id,
|
|
name: [r.first_name, r.last_name].filter(Boolean).join(' ') || 'User',
|
|
loggedAt: r.logged_at.toISOString(),
|
|
}));
|
|
}
|
|
async function getGeographyStats(range) {
|
|
if (await useDashboardMv()) {
|
|
return mvCharts.mvGeographyStats(range);
|
|
}
|
|
const rows = await (0, connection_1.query)(`WITH dep AS (
|
|
SELECT user_id, SUM(amount)::bigint AS total
|
|
FROM transactions
|
|
WHERE type = 'deposit' AND status = 'completed' AND created_at BETWEEN $1 AND $2
|
|
GROUP BY user_id
|
|
),
|
|
wdr AS (
|
|
SELECT user_id, SUM(amount)::bigint AS total
|
|
FROM transactions
|
|
WHERE type = 'withdrawal' AND status = 'completed' AND created_at BETWEEN $1 AND $2
|
|
GROUP BY user_id
|
|
),
|
|
act AS (
|
|
SELECT DISTINCT user_id FROM audit_logs
|
|
WHERE action = 'login' AND created_at BETWEEN $1 AND $2
|
|
)
|
|
SELECT
|
|
COALESCE(u.country_of_residence, 'XX') AS country,
|
|
COUNT(DISTINCT u.id)::text AS users,
|
|
COALESCE(SUM(dep.total), 0)::text AS deposits_raw,
|
|
COALESCE(SUM(wdr.total), 0)::text AS withdrawals_raw,
|
|
COALESCE(SUM(s.net_pnl_raw), 0)::text AS net_pnl_raw,
|
|
COUNT(DISTINCT act.user_id)::text AS active_users
|
|
FROM users u
|
|
LEFT JOIN user_admin_stats s ON s.user_id = u.id
|
|
LEFT JOIN dep ON dep.user_id = u.id
|
|
LEFT JOIN wdr ON wdr.user_id = u.id
|
|
LEFT JOIN act ON act.user_id = u.id
|
|
GROUP BY COALESCE(u.country_of_residence, 'XX')
|
|
ORDER BY COUNT(DISTINCT u.id) DESC
|
|
LIMIT 50`, [range.from, range.to]);
|
|
return rows.map((r) => ({
|
|
country: r.country,
|
|
users: num(r.users),
|
|
depositsRaw: num(r.deposits_raw),
|
|
withdrawalsRaw: num(r.withdrawals_raw),
|
|
netPnlRaw: num(r.net_pnl_raw),
|
|
activeUsers: num(r.active_users),
|
|
}));
|
|
}
|
|
async function getDemographics(range) {
|
|
if (await useDashboardMv()) {
|
|
return mvCharts.mvDemographics(range);
|
|
}
|
|
const [byGender, byAge] = await Promise.all([
|
|
(0, connection_1.query)(`SELECT
|
|
COALESCE(u.gender, 'unknown') AS gender,
|
|
COUNT(DISTINCT u.id)::text AS users,
|
|
COALESCE(SUM(s.total_stake_raw), 0)::text AS stake_raw,
|
|
COALESCE(SUM(s.net_pnl_raw), 0)::text AS net_pnl_raw,
|
|
COALESCE(SUM(dep.total), 0)::text AS deposits_raw
|
|
FROM users u
|
|
LEFT JOIN user_admin_stats s ON s.user_id = u.id
|
|
LEFT JOIN LATERAL (
|
|
SELECT SUM(amount)::bigint AS total FROM transactions
|
|
WHERE user_id = u.id AND type = 'deposit' AND status = 'completed'
|
|
AND created_at BETWEEN $1 AND $2
|
|
) dep ON TRUE
|
|
GROUP BY COALESCE(u.gender, 'unknown')`, [range.from, range.to]),
|
|
(0, connection_1.query)(`SELECT
|
|
CASE
|
|
WHEN u.date_of_birth IS NULL THEN 'unknown'
|
|
WHEN EXTRACT(YEAR FROM age(u.date_of_birth)) < 18 THEN 'under_18'
|
|
WHEN EXTRACT(YEAR FROM age(u.date_of_birth)) BETWEEN 18 AND 24 THEN '18_24'
|
|
WHEN EXTRACT(YEAR FROM age(u.date_of_birth)) BETWEEN 25 AND 34 THEN '25_34'
|
|
WHEN EXTRACT(YEAR FROM age(u.date_of_birth)) BETWEEN 35 AND 44 THEN '35_44'
|
|
WHEN EXTRACT(YEAR FROM age(u.date_of_birth)) BETWEEN 45 AND 54 THEN '45_54'
|
|
ELSE '55_plus'
|
|
END AS age_bucket,
|
|
COUNT(DISTINCT u.id)::text AS users,
|
|
COALESCE(SUM(s.total_stake_raw), 0)::text AS stake_raw,
|
|
COALESCE(SUM(s.net_pnl_raw), 0)::text AS net_pnl_raw,
|
|
COALESCE(SUM(dep.total), 0)::text AS deposits_raw
|
|
FROM users u
|
|
LEFT JOIN user_admin_stats s ON s.user_id = u.id
|
|
LEFT JOIN LATERAL (
|
|
SELECT SUM(amount)::bigint AS total FROM transactions
|
|
WHERE user_id = u.id AND type = 'deposit' AND status = 'completed'
|
|
AND created_at BETWEEN $1 AND $2
|
|
) dep ON TRUE
|
|
GROUP BY 1
|
|
ORDER BY 1`, [range.from, range.to]),
|
|
]);
|
|
return {
|
|
byGender: byGender.map((r) => ({
|
|
gender: r.gender,
|
|
users: num(r.users),
|
|
stakeRaw: num(r.stake_raw),
|
|
netPnlRaw: num(r.net_pnl_raw),
|
|
depositsRaw: num(r.deposits_raw),
|
|
})),
|
|
byAge: byAge.map((r) => ({
|
|
ageBucket: r.age_bucket,
|
|
users: num(r.users),
|
|
stakeRaw: num(r.stake_raw),
|
|
netPnlRaw: num(r.net_pnl_raw),
|
|
depositsRaw: num(r.deposits_raw),
|
|
})),
|
|
};
|
|
}
|
|
async function dailySeries(sql, range) {
|
|
const rows = await (0, connection_1.query)(sql, [range.from, range.to]);
|
|
return rows.map((r) => ({ date: r.day, value: num(r.value) }));
|
|
}
|
|
async function getTimeSeries(range) {
|
|
const useMv = await mvCharts.areChartMaterializedViewsReady();
|
|
const [signups, activeUsers, verifiedUsers, totpEnabled, deposits, withdrawals, bonuses, adjustments, netPnl, predictionsManual, predictionsAuto, predictionsMultiCandle, shortLong, stakesByInterval,] = await Promise.all([
|
|
dailySeries(`SELECT to_char(d, 'YYYY-MM-DD') AS day, COALESCE(COUNT(u.id), 0)::text AS value
|
|
FROM generate_series(date_trunc('day', $1::timestamptz), date_trunc('day', $2::timestamptz), '1 day') d
|
|
LEFT JOIN users u ON date_trunc('day', u.created_at) = d
|
|
GROUP BY d ORDER BY d`, range),
|
|
dailySeries(`SELECT to_char(d, 'YYYY-MM-DD') AS day, COUNT(DISTINCT al.user_id)::text AS value
|
|
FROM generate_series(date_trunc('day', $1::timestamptz), date_trunc('day', $2::timestamptz), '1 day') d
|
|
LEFT JOIN audit_logs al ON date_trunc('day', al.created_at) = d AND al.action = 'login'
|
|
GROUP BY d ORDER BY d`, range),
|
|
dailySeries(`SELECT to_char(d, 'YYYY-MM-DD') AS day, COUNT(u.id)::text AS value
|
|
FROM generate_series(date_trunc('day', $1::timestamptz), date_trunc('day', $2::timestamptz), '1 day') d
|
|
LEFT JOIN users u ON date_trunc('day', u.created_at) = d AND u.email_verified = TRUE
|
|
GROUP BY d ORDER BY d`, range),
|
|
dailySeries(`SELECT to_char(d, 'YYYY-MM-DD') AS day, COUNT(u.id)::text AS value
|
|
FROM generate_series(date_trunc('day', $1::timestamptz), date_trunc('day', $2::timestamptz), '1 day') d
|
|
LEFT JOIN users u ON date_trunc('day', u.updated_at) = d AND u.totp_enabled = TRUE
|
|
GROUP BY d ORDER BY d`, range),
|
|
useMv
|
|
? mvCharts.mvDailyDepositAmounts(range)
|
|
: dailySeries(`SELECT to_char(date_trunc('day', created_at), 'YYYY-MM-DD') AS day, COALESCE(SUM(amount), 0)::text AS value
|
|
FROM transactions WHERE type = 'deposit' AND status = 'completed' AND created_at BETWEEN $1 AND $2
|
|
GROUP BY 1 ORDER BY 1`, range),
|
|
useMv
|
|
? mvCharts.mvDailyWithdrawalAmounts(range)
|
|
: dailySeries(`SELECT to_char(date_trunc('day', created_at), 'YYYY-MM-DD') AS day, COALESCE(SUM(amount), 0)::text AS value
|
|
FROM transactions WHERE type = 'withdrawal' AND status = 'completed' AND created_at BETWEEN $1 AND $2
|
|
GROUP BY 1 ORDER BY 1`, range),
|
|
useMv
|
|
? mvCharts.mvDailyBonusAmountsWithReferrals(range)
|
|
: dailySeries(`SELECT to_char(date_trunc('day', created_at), 'YYYY-MM-DD') AS day, COALESCE(SUM(amount), 0)::text AS value
|
|
FROM ledger_adjustments WHERE adjustment_type = 'bonus' AND created_at BETWEEN $1 AND $2
|
|
GROUP BY 1 ORDER BY 1`, range),
|
|
useMv
|
|
? mvCharts.mvDailyAdjustmentAmounts(range)
|
|
: dailySeries(`SELECT to_char(date_trunc('day', created_at), 'YYYY-MM-DD') AS day, COALESCE(SUM(amount), 0)::text AS value
|
|
FROM ledger_adjustments WHERE adjustment_type = 'admin_adjustment' AND created_at BETWEEN $1 AND $2
|
|
GROUP BY 1 ORDER BY 1`, range),
|
|
useMv
|
|
? mvCharts.mvDailyNetPnl(range, 'real')
|
|
: dailySeries(`SELECT to_char(date_trunc('day', created_at), 'YYYY-MM-DD') AS day,
|
|
(COALESCE(SUM(stake_raw), 0) - COALESCE(SUM(payout_raw), 0))::text AS value
|
|
FROM candle_predict_bets
|
|
WHERE created_at BETWEEN $1 AND $2
|
|
AND status IN ('won','lost','refunded')
|
|
AND stake_account_kind IN ('main', 'bonus')
|
|
GROUP BY 1 ORDER BY 1`, range),
|
|
dailyPredictionCounts(range, `AND is_auto = FALSE AND prediction_mode = 'single'`),
|
|
useMv
|
|
? mvCharts.mvDailyPredictionCounts(range, true)
|
|
: dailyPredictionCounts(range, `AND is_auto = TRUE`),
|
|
dailyPredictionCounts(range, `AND prediction_mode = 'multi_candle'`),
|
|
useMv
|
|
? mvCharts.mvShortVsLong(range).then((rows) => rows.map((r) => ({
|
|
direction: r.direction,
|
|
count: String(r.count),
|
|
stake: String(r.stakeRaw),
|
|
})))
|
|
: (0, connection_1.query)(`SELECT direction, COUNT(*)::text AS count, COALESCE(SUM(stake_raw), 0)::text AS stake
|
|
FROM candle_predict_bets WHERE created_at BETWEEN $1 AND $2 GROUP BY direction`, [range.from, range.to]),
|
|
(0, connection_1.query)(`SELECT interval_minutes::text,
|
|
COUNT(DISTINCT user_id)::text AS participants,
|
|
COALESCE(SUM(stake_raw), 0)::text AS stake,
|
|
(COALESCE(SUM(stake_raw), 0) - COALESCE(SUM(payout_raw), 0))::text AS house_pnl
|
|
FROM candle_predict_bets WHERE created_at BETWEEN $1 AND $2
|
|
GROUP BY interval_minutes ORDER BY interval_minutes`, [range.from, range.to]),
|
|
]);
|
|
const loginHours = await (0, connection_1.query)(`SELECT EXTRACT(HOUR FROM created_at)::int::text AS hour, COUNT(*)::text AS count
|
|
FROM audit_logs WHERE action = 'login' AND created_at BETWEEN $1 AND $2
|
|
GROUP BY 1 ORDER BY 1`, [range.from, range.to]);
|
|
const betHoursPoints = useMv
|
|
? await mvCharts.mvBetHours(range)
|
|
: (await (0, connection_1.query)(`SELECT EXTRACT(HOUR FROM created_at)::int::text AS hour, COUNT(*)::text AS count
|
|
FROM candle_predict_bets WHERE created_at BETWEEN $1 AND $2
|
|
GROUP BY 1 ORDER BY 1`, [range.from, range.to])).map((r) => ({ hour: num(r.hour), count: num(r.count) }));
|
|
const periodUsers = await (0, connection_1.query)(`SELECT
|
|
(SELECT COUNT(*)::text FROM users WHERE created_at BETWEEN $1 AND $2) AS new_users,
|
|
(SELECT COUNT(DISTINCT al.user_id)::text FROM audit_logs al
|
|
JOIN users u ON u.id = al.user_id
|
|
WHERE al.action = 'login' AND al.created_at BETWEEN $1 AND $2 AND u.created_at < $1) AS returning`, [range.from, range.to]);
|
|
return {
|
|
signups,
|
|
activeUsers,
|
|
verifiedUsers,
|
|
totpEnabled,
|
|
deposits,
|
|
withdrawals,
|
|
bonuses,
|
|
adjustments,
|
|
netPnl,
|
|
predictionsManual,
|
|
predictionsAuto,
|
|
predictionsMultiCandle,
|
|
shortVsLong: shortLong.map((r) => ({
|
|
direction: r.direction,
|
|
count: num(r.count),
|
|
stakeRaw: num(r.stake),
|
|
})),
|
|
byInterval: stakesByInterval.map((r) => ({
|
|
intervalMinutes: num(r.interval_minutes),
|
|
participants: num(r.participants),
|
|
stakeRaw: num(r.stake),
|
|
housePnlRaw: num(r.house_pnl),
|
|
})),
|
|
loginHours: loginHours.map((r) => ({ hour: num(r.hour), count: num(r.count) })),
|
|
betHours: betHoursPoints,
|
|
retention: {
|
|
newUsers: num(periodUsers[0]?.new_users),
|
|
returningUsers: num(periodUsers[0]?.returning),
|
|
},
|
|
};
|
|
}
|
|
async function getAlertsSummary(range) {
|
|
const [openAlerts, recentAlerts, failedLogins] = await Promise.all([
|
|
(0, connection_1.query)(`SELECT COUNT(*)::text AS count FROM security_alerts WHERE status = 'open'`),
|
|
(0, connection_1.query)(`SELECT id, alert_type, severity, status, created_at, user_id
|
|
FROM security_alerts
|
|
WHERE created_at BETWEEN $1 AND $2
|
|
ORDER BY created_at DESC LIMIT 20`, [range.from, range.to]),
|
|
(0, connection_1.query)(`SELECT COUNT(*)::text AS count FROM security_alerts
|
|
WHERE alert_type ILIKE '%login%' AND created_at BETWEEN $1 AND $2`, [range.from, range.to]),
|
|
]);
|
|
const depositSpike = await detectSpike('deposit', range);
|
|
const withdrawalSpike = await detectSpike('withdrawal', range);
|
|
return {
|
|
openAlertsCount: num(openAlerts[0]?.count),
|
|
failedLoginAlerts: num(failedLogins[0]?.count),
|
|
depositSpike,
|
|
withdrawalSpike,
|
|
recentAlerts: recentAlerts.map((a) => ({
|
|
id: a.id,
|
|
type: a.alert_type,
|
|
severity: a.severity,
|
|
status: a.status,
|
|
userId: a.user_id,
|
|
createdAt: a.created_at.toISOString(),
|
|
})),
|
|
};
|
|
}
|
|
async function detectSpike(txType, range) {
|
|
const { currentRaw, previousRaw } = (await useDashboardMv())
|
|
? await mvCharts.mvTransactionSpike(txType, range)
|
|
: await (async () => {
|
|
const durationMs = range.to.getTime() - range.from.getTime();
|
|
const prevFrom = new Date(range.from.getTime() - durationMs);
|
|
const rows = await (0, connection_1.query)(`SELECT 'current' AS period, COALESCE(SUM(amount), 0)::text AS v
|
|
FROM transactions
|
|
WHERE type = $5 AND status = 'completed' AND created_at BETWEEN $1 AND $2
|
|
UNION ALL
|
|
SELECT 'previous', COALESCE(SUM(amount), 0)::text
|
|
FROM transactions
|
|
WHERE type = $5 AND status = 'completed' AND created_at BETWEEN $3 AND $4`, [range.from, range.to, prevFrom, range.from, txType]);
|
|
return {
|
|
currentRaw: num(rows.find((r) => r.period === 'current')?.v),
|
|
previousRaw: num(rows.find((r) => r.period === 'previous')?.v),
|
|
};
|
|
})();
|
|
const spikePercent = previousRaw > 0 ? Math.round(((currentRaw - previousRaw) / previousRaw) * 10000) / 100 : currentRaw > 0 ? 100 : 0;
|
|
return {
|
|
currentRaw,
|
|
previousRaw,
|
|
spikePercent,
|
|
isUnusual: Math.abs(spikePercent) >= 50 && currentRaw > previousRaw,
|
|
};
|
|
}
|
|
//# sourceMappingURL=analyticsRepository.js.map
|