705 lines
34 KiB
JavaScript
705 lines
34 KiB
JavaScript
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.getSettings = getSettings;
|
|
exports.updateSettings = updateSettings;
|
|
exports.listLevels = listLevels;
|
|
exports.getLevelByNumber = getLevelByNumber;
|
|
exports.upsertLevel = upsertLevel;
|
|
exports.deleteLevel = deleteLevel;
|
|
exports.findUserByReferralCode = findUserByReferralCode;
|
|
exports.generateUniqueReferralCode = generateUniqueReferralCode;
|
|
exports.getUserReferralCode = getUserReferralCode;
|
|
exports.ensureUserReferralCode = ensureUserReferralCode;
|
|
exports.recordCommissionPayout = recordCommissionPayout;
|
|
exports.findCommissionPayoutById = findCommissionPayoutById;
|
|
exports.listPendingCommissionsDue = listPendingCommissionsDue;
|
|
exports.listReviewQueue = listReviewQueue;
|
|
exports.markCommissionPaid = markCommissionPaid;
|
|
exports.moveCommissionToReview = moveCommissionToReview;
|
|
exports.rejectCommissionPayout = rejectCommissionPayout;
|
|
exports.recordCommissionReviewDecision = recordCommissionReviewDecision;
|
|
exports.countReferredUserRealPredictions = countReferredUserRealPredictions;
|
|
exports.beneficiaryHasCompletedDeposit = beneficiaryHasCompletedDeposit;
|
|
exports.getReferralChain = getReferralChain;
|
|
exports.countDirectReferrals = countDirectReferrals;
|
|
exports.getMainAccountPredictionNetProfit = getMainAccountPredictionNetProfit;
|
|
exports.getWithdrawalGainsAlreadyCommissioned = getWithdrawalGainsAlreadyCommissioned;
|
|
exports.getReferrerProfile = getReferrerProfile;
|
|
exports.getReferralDownline = getReferralDownline;
|
|
exports.getBeneficiaryCommissionSummary = getBeneficiaryCommissionSummary;
|
|
exports.listBeneficiaryCommissions = listBeneficiaryCommissions;
|
|
exports.formatUserDisplayName = formatUserDisplayName;
|
|
exports.getAdminStats = getAdminStats;
|
|
exports.getBeneficiaryMonthlyCommissionStats = getBeneficiaryMonthlyCommissionStats;
|
|
exports.markCommissionClawedBack = markCommissionClawedBack;
|
|
exports.recordCommissionClawback = recordCommissionClawback;
|
|
exports.listRecentClawbacks = listRecentClawbacks;
|
|
exports.listClawbacksForExport = listClawbacksForExport;
|
|
exports.getFraudDashboardData = getFraudDashboardData;
|
|
const crypto_1 = require("crypto");
|
|
const connection_1 = require("../db/connection");
|
|
const PAYOUT_COLUMNS = `
|
|
id, beneficiary_user_id, referred_user_id, level_number, commission_source,
|
|
first_deposit_transaction_id, withdrawal_transaction_id, deposit_amount::text, commission_percent::text,
|
|
commission_amount::text, wallet_type_id, status, eligible_at, paid_at,
|
|
rejection_reason, sybil_score, sybil_signals, reviewed_by, reviewed_at,
|
|
review_note, created_at, updated_at
|
|
`;
|
|
function mapPayoutRow(row) {
|
|
const signals = row.sybil_signals;
|
|
return {
|
|
...row,
|
|
sybil_signals: Array.isArray(signals) ? signals : [],
|
|
};
|
|
}
|
|
async function getSettings() {
|
|
const rows = await (0, connection_1.query)(`SELECT id, enabled, default_referrer_user_id, bonus_withdrawable,
|
|
referrer_must_be_verified, referrer_must_have_deposited,
|
|
referred_must_be_verified, commission_hold_days, min_referred_predictions,
|
|
commission_max_pending_days, sybil_detection_enabled, sybil_review_threshold,
|
|
sybil_block_threshold, max_referrals_per_day,
|
|
max_commission_amount_per_referrer_month_raw::text,
|
|
max_commissions_per_referrer_month, slack_alerts_enabled,
|
|
deposit_commissions_enabled, withdrawal_commissions_enabled,
|
|
min_first_deposit_raw::text, commission_wallet_type_id, updated_at
|
|
FROM referral_program_settings WHERE id = 1`);
|
|
return rows[0];
|
|
}
|
|
async function updateSettings(input) {
|
|
const updates = [];
|
|
const values = [];
|
|
let i = 1;
|
|
const fieldMap = [
|
|
['enabled', 'enabled'],
|
|
['defaultReferrerUserId', 'default_referrer_user_id'],
|
|
['bonusWithdrawable', 'bonus_withdrawable'],
|
|
['referrerMustBeVerified', 'referrer_must_be_verified'],
|
|
['referrerMustHaveDeposited', 'referrer_must_have_deposited'],
|
|
['referredMustBeVerified', 'referred_must_be_verified'],
|
|
['commissionHoldDays', 'commission_hold_days'],
|
|
['minReferredPredictions', 'min_referred_predictions'],
|
|
['commissionMaxPendingDays', 'commission_max_pending_days'],
|
|
['sybilDetectionEnabled', 'sybil_detection_enabled'],
|
|
['sybilReviewThreshold', 'sybil_review_threshold'],
|
|
['sybilBlockThreshold', 'sybil_block_threshold'],
|
|
['maxReferralsPerDay', 'max_referrals_per_day'],
|
|
['maxCommissionAmountPerReferrerMonthRaw', 'max_commission_amount_per_referrer_month_raw'],
|
|
['maxCommissionsPerReferrerMonth', 'max_commissions_per_referrer_month'],
|
|
['slackAlertsEnabled', 'slack_alerts_enabled'],
|
|
['depositCommissionsEnabled', 'deposit_commissions_enabled'],
|
|
['withdrawalCommissionsEnabled', 'withdrawal_commissions_enabled'],
|
|
['minFirstDepositRaw', 'min_first_deposit_raw'],
|
|
['commissionWalletTypeId', 'commission_wallet_type_id'],
|
|
];
|
|
for (const [inputKey, column] of fieldMap) {
|
|
const value = input[inputKey];
|
|
if (value !== undefined) {
|
|
updates.push(`${column} = $${i++}`);
|
|
values.push(value);
|
|
}
|
|
}
|
|
if (updates.length > 0) {
|
|
updates.push('updated_at = NOW()');
|
|
await (0, connection_1.query)(`UPDATE referral_program_settings SET ${updates.join(', ')} WHERE id = 1`, values);
|
|
}
|
|
return getSettings();
|
|
}
|
|
async function listLevels() {
|
|
return (0, connection_1.query)(`SELECT level_number, commission_percent::text, is_active,
|
|
monthly_max_amount_raw::text, monthly_max_count,
|
|
created_at, updated_at
|
|
FROM referral_levels ORDER BY level_number ASC`);
|
|
}
|
|
async function getLevelByNumber(levelNumber) {
|
|
const rows = await (0, connection_1.query)(`SELECT level_number, commission_percent::text, is_active,
|
|
monthly_max_amount_raw::text, monthly_max_count,
|
|
created_at, updated_at
|
|
FROM referral_levels WHERE level_number = $1`, [levelNumber]);
|
|
return rows[0] ?? null;
|
|
}
|
|
async function upsertLevel(levelNumber, commissionPercent, isActive = true, monthlyMaxAmountRaw = '0', monthlyMaxCount = 0) {
|
|
await (0, connection_1.query)(`INSERT INTO referral_levels (level_number, commission_percent, is_active, monthly_max_amount_raw, monthly_max_count)
|
|
VALUES ($1, $2, $3, $4, $5)
|
|
ON CONFLICT (level_number) DO UPDATE SET
|
|
commission_percent = EXCLUDED.commission_percent,
|
|
is_active = EXCLUDED.is_active,
|
|
monthly_max_amount_raw = EXCLUDED.monthly_max_amount_raw,
|
|
monthly_max_count = EXCLUDED.monthly_max_count,
|
|
updated_at = NOW()`, [levelNumber, commissionPercent, isActive, monthlyMaxAmountRaw, monthlyMaxCount]);
|
|
}
|
|
async function deleteLevel(levelNumber) {
|
|
await (0, connection_1.query)('DELETE FROM referral_levels WHERE level_number = $1', [levelNumber]);
|
|
}
|
|
async function findUserByReferralCode(code) {
|
|
const normalized = code.trim().toUpperCase();
|
|
const rows = await (0, connection_1.query)(`SELECT id, email_verified FROM users
|
|
WHERE UPPER(referral_code) = $1 AND is_enabled = TRUE`, [normalized]);
|
|
return rows[0] ?? null;
|
|
}
|
|
async function generateUniqueReferralCode() {
|
|
for (let attempt = 0; attempt < 20; attempt++) {
|
|
const code = (0, crypto_1.randomBytes)(5).toString('hex').toUpperCase().slice(0, 8);
|
|
const existing = await (0, connection_1.query)('SELECT id FROM users WHERE referral_code = $1', [code]);
|
|
if (!existing[0])
|
|
return code;
|
|
}
|
|
throw new Error('Failed to generate unique referral code');
|
|
}
|
|
/**
|
|
* Returns the user's referral code, or null if none is assigned.
|
|
*/
|
|
async function getUserReferralCode(userId) {
|
|
const rows = await (0, connection_1.query)('SELECT referral_code FROM users WHERE id = $1', [userId]);
|
|
return rows[0]?.referral_code ?? null;
|
|
}
|
|
/**
|
|
* Ensures the user has a unique referral code, generating one when missing.
|
|
*/
|
|
async function ensureUserReferralCode(userId) {
|
|
const existing = await getUserReferralCode(userId);
|
|
if (existing)
|
|
return existing;
|
|
const code = await generateUniqueReferralCode();
|
|
await (0, connection_1.query)('UPDATE users SET referral_code = $1, updated_at = NOW() WHERE id = $2', [code, userId]);
|
|
return code;
|
|
}
|
|
async function recordCommissionPayout(input) {
|
|
const source = input.commissionSource ?? 'deposit';
|
|
const rows = await (0, connection_1.query)(`INSERT INTO referral_commission_payouts
|
|
(beneficiary_user_id, referred_user_id, level_number, commission_source,
|
|
first_deposit_transaction_id, withdrawal_transaction_id,
|
|
deposit_amount, commission_percent, commission_amount, wallet_type_id,
|
|
status, eligible_at, sybil_score, sybil_signals)
|
|
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14)
|
|
ON CONFLICT DO NOTHING
|
|
RETURNING id`, [
|
|
input.beneficiaryUserId,
|
|
input.referredUserId,
|
|
input.levelNumber,
|
|
source,
|
|
input.firstDepositTransactionId ?? null,
|
|
input.withdrawalTransactionId ?? null,
|
|
input.baseAmount.toString(),
|
|
input.commissionPercent,
|
|
input.commissionAmount.toString(),
|
|
input.walletTypeId,
|
|
input.status,
|
|
input.eligibleAt,
|
|
input.sybilScore ?? 0,
|
|
JSON.stringify(input.sybilSignals ?? []),
|
|
]);
|
|
return rows[0]?.id ?? '';
|
|
}
|
|
async function findCommissionPayoutById(payoutId) {
|
|
const rows = await (0, connection_1.query)(`SELECT ${PAYOUT_COLUMNS} FROM referral_commission_payouts WHERE id = $1`, [payoutId]);
|
|
return rows[0] ? mapPayoutRow(rows[0]) : null;
|
|
}
|
|
async function listPendingCommissionsDue(limit) {
|
|
const rows = await (0, connection_1.query)(`SELECT ${PAYOUT_COLUMNS}
|
|
FROM referral_commission_payouts
|
|
WHERE status = 'pending' AND eligible_at <= NOW()
|
|
ORDER BY eligible_at ASC
|
|
LIMIT $1`, [limit]);
|
|
return rows.map(mapPayoutRow);
|
|
}
|
|
async function listReviewQueue(opts) {
|
|
const limit = Math.min(opts.limit ?? 50, 100);
|
|
const offset = Math.max(opts.offset ?? 0, 0);
|
|
const countRows = await (0, connection_1.query)(`SELECT COUNT(*)::text AS count FROM referral_commission_payouts WHERE status = 'review'`);
|
|
const rows = await (0, connection_1.query)(`SELECT ${PAYOUT_COLUMNS}
|
|
FROM referral_commission_payouts
|
|
WHERE status = 'review'
|
|
ORDER BY sybil_score DESC, created_at ASC
|
|
LIMIT $1 OFFSET $2`, [limit, offset]);
|
|
return { items: rows.map(mapPayoutRow), total: Number(countRows[0]?.count ?? 0) };
|
|
}
|
|
async function markCommissionPaid(payoutId, fromStatuses = ['pending', 'review']) {
|
|
const rows = await (0, connection_1.query)(`UPDATE referral_commission_payouts
|
|
SET status = 'paid', paid_at = NOW(), updated_at = NOW()
|
|
WHERE id = $1 AND status = ANY($2::varchar[])
|
|
RETURNING id`, [payoutId, fromStatuses]);
|
|
return Boolean(rows[0]);
|
|
}
|
|
async function moveCommissionToReview(payoutId, sybilScore, sybilSignals) {
|
|
const rows = await (0, connection_1.query)(`UPDATE referral_commission_payouts
|
|
SET status = 'review', sybil_score = $2, sybil_signals = $3, updated_at = NOW()
|
|
WHERE id = $1 AND status = 'pending'
|
|
RETURNING id`, [payoutId, sybilScore, JSON.stringify(sybilSignals)]);
|
|
return Boolean(rows[0]);
|
|
}
|
|
async function rejectCommissionPayout(payoutId, status, reason, fromStatuses = ['pending', 'review']) {
|
|
const rows = await (0, connection_1.query)(`UPDATE referral_commission_payouts
|
|
SET status = $2, rejection_reason = $3, updated_at = NOW()
|
|
WHERE id = $1 AND status = ANY($4::varchar[])
|
|
RETURNING id`, [payoutId, status, reason, fromStatuses]);
|
|
return Boolean(rows[0]);
|
|
}
|
|
async function recordCommissionReviewDecision(input) {
|
|
const rows = await (0, connection_1.query)(`UPDATE referral_commission_payouts
|
|
SET reviewed_by = $2, reviewed_at = NOW(), review_note = $3, updated_at = NOW()
|
|
WHERE id = $1 AND status = 'review'
|
|
RETURNING id`, [input.payoutId, input.reviewerId, input.note ?? null]);
|
|
return Boolean(rows[0]);
|
|
}
|
|
async function countReferredUserRealPredictions(userId) {
|
|
const rows = await (0, connection_1.query)(`SELECT COUNT(*)::text AS count
|
|
FROM candle_predict_bets
|
|
WHERE user_id = $1 AND stake_account_kind IN ('main', 'bonus')`, [userId]);
|
|
return Number(rows[0]?.count ?? 0);
|
|
}
|
|
async function beneficiaryHasCompletedDeposit(userId) {
|
|
const rows = await (0, connection_1.query)(`SELECT 1 AS n FROM transactions
|
|
WHERE user_id = $1 AND type = 'deposit' AND status = 'completed'
|
|
LIMIT 1`, [userId]);
|
|
return Boolean(rows[0]);
|
|
}
|
|
async function getReferralChain(userId, maxLevels) {
|
|
const chain = [];
|
|
let currentId = userId;
|
|
for (let level = 1; level <= maxLevels; level++) {
|
|
if (!currentId)
|
|
break;
|
|
const rows = await (0, connection_1.query)('SELECT referred_by_user_id FROM users WHERE id = $1', [currentId]);
|
|
const referrerId = rows[0]?.referred_by_user_id ?? null;
|
|
if (!referrerId)
|
|
break;
|
|
chain.push({ userId: referrerId, level });
|
|
currentId = referrerId;
|
|
}
|
|
return chain;
|
|
}
|
|
async function countDirectReferrals(userId) {
|
|
const rows = await (0, connection_1.query)('SELECT COUNT(*)::text AS count FROM users WHERE referred_by_user_id = $1', [userId]);
|
|
return Number(rows[0]?.count ?? 0);
|
|
}
|
|
async function getMainAccountPredictionNetProfit(userId) {
|
|
const rows = await (0, connection_1.query)(`SELECT COALESCE(SUM(
|
|
CASE
|
|
WHEN status = 'won' THEN GREATEST(COALESCE(payout_raw, 0) - stake_raw, 0)
|
|
WHEN status = 'lost' THEN -stake_raw
|
|
ELSE 0
|
|
END
|
|
), 0)::text AS net
|
|
FROM candle_predict_bets
|
|
WHERE user_id = $1 AND stake_account_kind = 'main'
|
|
AND status IN ('won', 'lost')`, [userId]);
|
|
return BigInt(rows[0]?.net ?? '0');
|
|
}
|
|
async function getWithdrawalGainsAlreadyCommissioned(referredUserId) {
|
|
const rows = await (0, connection_1.query)(`SELECT COALESCE(SUM(deposit_amount), 0)::text AS total
|
|
FROM referral_commission_payouts
|
|
WHERE referred_user_id = $1
|
|
AND commission_source = 'withdrawal'
|
|
AND status NOT IN ('rejected', 'expired')`, [referredUserId]);
|
|
return BigInt(rows[0]?.total ?? '0');
|
|
}
|
|
async function getReferrerProfile(userId) {
|
|
const rows = await (0, connection_1.query)(`SELECT r.id AS referrer_id, r.referral_code, r.first_name, r.last_name, r.created_at
|
|
FROM users u
|
|
JOIN users r ON r.id = u.referred_by_user_id
|
|
WHERE u.id = $1`, [userId]);
|
|
const row = rows[0];
|
|
if (!row)
|
|
return null;
|
|
return {
|
|
userId: row.referrer_id,
|
|
referralCode: row.referral_code,
|
|
firstName: row.first_name,
|
|
lastName: row.last_name,
|
|
createdAt: row.created_at,
|
|
};
|
|
}
|
|
async function getReferralDownline(rootUserId, maxDepth) {
|
|
return (0, connection_1.query)(`WITH RECURSIVE downline AS (
|
|
SELECT u.id AS user_id,
|
|
u.referred_by_user_id AS parent_user_id,
|
|
1 AS level_number,
|
|
u.referral_code,
|
|
u.first_name,
|
|
u.last_name,
|
|
u.created_at,
|
|
u.first_deposit_at,
|
|
u.email_verified,
|
|
u.country_of_residence
|
|
FROM users u
|
|
WHERE u.referred_by_user_id = $1
|
|
UNION ALL
|
|
SELECT u.id,
|
|
u.referred_by_user_id,
|
|
d.level_number + 1,
|
|
u.referral_code,
|
|
u.first_name,
|
|
u.last_name,
|
|
u.created_at,
|
|
u.first_deposit_at,
|
|
u.email_verified,
|
|
u.country_of_residence
|
|
FROM users u
|
|
INNER JOIN downline d ON u.referred_by_user_id = d.user_id
|
|
WHERE d.level_number < $2
|
|
)
|
|
SELECT d.user_id,
|
|
d.parent_user_id,
|
|
d.level_number,
|
|
d.referral_code,
|
|
d.first_name,
|
|
d.last_name,
|
|
d.created_at,
|
|
d.first_deposit_at,
|
|
d.email_verified,
|
|
d.country_of_residence,
|
|
(SELECT COUNT(*)::text FROM users c WHERE c.referred_by_user_id = d.user_id) AS direct_referrals_count,
|
|
(SELECT COUNT(*)::text FROM candle_predict_bets b
|
|
WHERE b.user_id = d.user_id AND b.stake_account_kind IN ('main', 'bonus')) AS real_predictions_count,
|
|
COALESCE((
|
|
SELECT SUM(p.commission_amount)::text
|
|
FROM referral_commission_payouts p
|
|
WHERE p.beneficiary_user_id = $1 AND p.referred_user_id = d.user_id
|
|
AND p.status NOT IN ('rejected', 'expired')
|
|
), '0') AS commissions_generated_raw,
|
|
COALESCE((
|
|
SELECT SUM(p.commission_amount)::text
|
|
FROM referral_commission_payouts p
|
|
WHERE p.beneficiary_user_id = $1 AND p.referred_user_id = d.user_id
|
|
AND p.status = 'paid'
|
|
), '0') AS commissions_paid_raw,
|
|
COALESCE((
|
|
SELECT SUM(p.commission_amount)::text
|
|
FROM referral_commission_payouts p
|
|
WHERE p.beneficiary_user_id = $1 AND p.referred_user_id = d.user_id
|
|
AND p.status IN ('pending', 'review')
|
|
), '0') AS commissions_pending_raw
|
|
FROM downline d
|
|
ORDER BY d.level_number ASC, d.created_at ASC`, [rootUserId, maxDepth]);
|
|
}
|
|
async function getBeneficiaryCommissionSummary(beneficiaryUserId) {
|
|
const summaryRows = await (0, connection_1.query)(`SELECT
|
|
COALESCE(SUM(commission_amount) FILTER (
|
|
WHERE status NOT IN ('rejected', 'expired')
|
|
), 0)::text AS total,
|
|
COALESCE(SUM(commission_amount) FILTER (WHERE status = 'paid'), 0)::text AS paid,
|
|
COALESCE(SUM(commission_amount) FILTER (WHERE status = 'pending'), 0)::text AS pending,
|
|
COALESCE(SUM(commission_amount) FILTER (WHERE status = 'review'), 0)::text AS review,
|
|
COUNT(*)::text AS payout_count
|
|
FROM referral_commission_payouts
|
|
WHERE beneficiary_user_id = $1`, [beneficiaryUserId]);
|
|
const networkRows = await (0, connection_1.query)(`WITH RECURSIVE downline AS (
|
|
SELECT id FROM users WHERE referred_by_user_id = $1
|
|
UNION ALL
|
|
SELECT u.id FROM users u
|
|
INNER JOIN downline d ON u.referred_by_user_id = d.id
|
|
)
|
|
SELECT COUNT(*)::text AS count FROM downline`, [beneficiaryUserId]);
|
|
const s = summaryRows[0];
|
|
return {
|
|
totalEarnedRaw: BigInt(s?.total ?? '0'),
|
|
paidRaw: BigInt(s?.paid ?? '0'),
|
|
pendingRaw: BigInt(s?.pending ?? '0'),
|
|
reviewRaw: BigInt(s?.review ?? '0'),
|
|
networkSize: Number(networkRows[0]?.count ?? 0),
|
|
payoutCount: Number(s?.payout_count ?? 0),
|
|
};
|
|
}
|
|
async function listBeneficiaryCommissions(beneficiaryUserId, opts) {
|
|
const limit = Math.min(opts?.limit ?? 50, 200);
|
|
const offset = opts?.offset ?? 0;
|
|
const countRows = await (0, connection_1.query)(`SELECT COUNT(*)::text AS count FROM referral_commission_payouts WHERE beneficiary_user_id = $1`, [beneficiaryUserId]);
|
|
const rows = await (0, connection_1.query)(`SELECT p.id, p.referred_user_id, u.first_name, u.last_name, p.level_number,
|
|
p.commission_source, p.deposit_amount::text, p.commission_amount::text,
|
|
p.commission_percent::text, p.status, p.eligible_at, p.paid_at, p.created_at
|
|
FROM referral_commission_payouts p
|
|
JOIN users u ON u.id = p.referred_user_id
|
|
WHERE p.beneficiary_user_id = $1
|
|
ORDER BY p.created_at DESC
|
|
LIMIT $2 OFFSET $3`, [beneficiaryUserId, limit, offset]);
|
|
return {
|
|
total: Number(countRows[0]?.count ?? 0),
|
|
items: rows.map((r) => ({
|
|
id: r.id,
|
|
referredUserId: r.referred_user_id,
|
|
referredDisplayName: formatUserDisplayName(r.first_name, r.last_name, r.referred_user_id),
|
|
levelNumber: r.level_number,
|
|
commissionSource: r.commission_source,
|
|
baseAmount: r.deposit_amount,
|
|
commissionAmount: r.commission_amount,
|
|
commissionPercent: r.commission_percent,
|
|
status: r.status,
|
|
eligibleAt: r.eligible_at,
|
|
paidAt: r.paid_at,
|
|
createdAt: r.created_at,
|
|
})),
|
|
};
|
|
}
|
|
function formatUserDisplayName(firstName, lastName, userId) {
|
|
if (firstName?.trim()) {
|
|
const initial = lastName?.trim() ? ` ${lastName.trim().charAt(0)}.` : '';
|
|
return `${firstName.trim()}${initial}`;
|
|
}
|
|
return `User ${userId.slice(0, 8)}`;
|
|
}
|
|
async function getAdminStats() {
|
|
const usersByCountry = await (0, connection_1.query)(`SELECT COALESCE(c.name,
|
|
CASE
|
|
WHEN u.country_of_residence IS NULL OR u.country_of_residence = 'XX' THEN 'Non renseigné'
|
|
ELSE u.country_of_residence
|
|
END) AS country,
|
|
COUNT(*)::text AS count
|
|
FROM users u
|
|
LEFT JOIN countries c ON c.code = u.country_of_residence
|
|
GROUP BY u.country_of_residence, c.name
|
|
ORDER BY COUNT(*) DESC`);
|
|
const usersByNationality = await (0, connection_1.query)(`SELECT COALESCE(c.name, u.nationality, 'Non renseigné') AS nationality,
|
|
COUNT(*)::text AS count
|
|
FROM users u
|
|
LEFT JOIN countries c ON c.code = u.nationality
|
|
WHERE u.nationality IS NOT NULL
|
|
GROUP BY u.nationality, c.name
|
|
ORDER BY COUNT(*) DESC`);
|
|
const referralSummaryRows = await (0, connection_1.query)(`SELECT
|
|
(SELECT COUNT(*) FROM users WHERE referred_by_user_id IS NOT NULL)::text AS total_referred,
|
|
COALESCE((SELECT SUM(commission_amount) FROM referral_commission_payouts WHERE status = 'paid'), 0)::text AS total_commissions,
|
|
(SELECT COUNT(*) FROM referral_commission_payouts WHERE status = 'paid')::text AS payout_count,
|
|
COALESCE((SELECT SUM(commission_amount) FROM referral_commission_payouts WHERE status = 'pending'), 0)::text AS pending_commissions,
|
|
(SELECT COUNT(*) FROM referral_commission_payouts WHERE status = 'pending')::text AS pending_count,
|
|
COALESCE((SELECT SUM(commission_amount) FROM referral_commission_payouts WHERE status = 'review'), 0)::text AS review_commissions,
|
|
(SELECT COUNT(*) FROM referral_commission_payouts WHERE status = 'review')::text AS review_count`);
|
|
const topReferrers = await (0, connection_1.query)(`SELECT u.id AS user_id, u.referral_code,
|
|
COUNT(DISTINCT r.id)::text AS direct_referrals,
|
|
COALESCE(SUM(p.commission_amount) FILTER (WHERE p.status = 'paid'), 0)::text AS total_earned
|
|
FROM users u
|
|
LEFT JOIN users r ON r.referred_by_user_id = u.id
|
|
LEFT JOIN referral_commission_payouts p ON p.beneficiary_user_id = u.id
|
|
WHERE u.referral_code IS NOT NULL
|
|
GROUP BY u.id, u.referral_code
|
|
ORDER BY COUNT(DISTINCT r.id) DESC, COALESCE(SUM(p.commission_amount) FILTER (WHERE p.status = 'paid'), 0) DESC
|
|
LIMIT 20`);
|
|
const summary = referralSummaryRows[0];
|
|
return {
|
|
usersByCountry: usersByCountry.map((r) => ({ country: r.country, count: Number(r.count) })),
|
|
usersByNationality: usersByNationality.map((r) => ({ nationality: r.nationality, count: Number(r.count) })),
|
|
referralSummary: {
|
|
totalReferred: Number(summary?.total_referred ?? 0),
|
|
totalCommissionsPaid: summary?.total_commissions ?? '0',
|
|
payoutCount: Number(summary?.payout_count ?? 0),
|
|
pendingCommissions: summary?.pending_commissions ?? '0',
|
|
pendingCount: Number(summary?.pending_count ?? 0),
|
|
reviewCommissions: summary?.review_commissions ?? '0',
|
|
reviewCount: Number(summary?.review_count ?? 0),
|
|
},
|
|
topReferrers: topReferrers.map((r) => ({
|
|
userId: r.user_id,
|
|
referralCode: r.referral_code,
|
|
directReferrals: Number(r.direct_referrals),
|
|
totalEarned: r.total_earned,
|
|
})),
|
|
};
|
|
}
|
|
const ACTIVE_COMMISSION_STATUSES = ['pending', 'review', 'paid'];
|
|
async function getBeneficiaryMonthlyCommissionStats(beneficiaryUserId, levelNumber) {
|
|
const levelFilter = levelNumber != null ? 'AND level_number = $3' : '';
|
|
const params = [beneficiaryUserId, ACTIVE_COMMISSION_STATUSES];
|
|
if (levelNumber != null)
|
|
params.push(levelNumber);
|
|
const rows = await (0, connection_1.query)(`SELECT
|
|
COALESCE(SUM(commission_amount) FILTER (
|
|
WHERE status = ANY($2::varchar[])
|
|
AND created_at >= date_trunc('month', NOW() AT TIME ZONE 'UTC')
|
|
), 0)::text AS reserved_amount,
|
|
COUNT(*) FILTER (
|
|
WHERE status = ANY($2::varchar[])
|
|
AND created_at >= date_trunc('month', NOW() AT TIME ZONE 'UTC')
|
|
)::text AS reserved_count,
|
|
COALESCE(SUM(commission_amount) FILTER (
|
|
WHERE status = 'paid'
|
|
AND COALESCE(paid_at, created_at) >= date_trunc('month', NOW() AT TIME ZONE 'UTC')
|
|
), 0)::text AS paid_amount,
|
|
COUNT(*) FILTER (
|
|
WHERE status = 'paid'
|
|
AND COALESCE(paid_at, created_at) >= date_trunc('month', NOW() AT TIME ZONE 'UTC')
|
|
)::text AS paid_count
|
|
FROM referral_commission_payouts
|
|
WHERE beneficiary_user_id = $1 ${levelFilter}`, params);
|
|
const row = rows[0];
|
|
return {
|
|
reservedAmount: BigInt(row?.reserved_amount ?? '0'),
|
|
reservedCount: Number(row?.reserved_count ?? 0),
|
|
paidAmount: BigInt(row?.paid_amount ?? '0'),
|
|
paidCount: Number(row?.paid_count ?? 0),
|
|
};
|
|
}
|
|
async function markCommissionClawedBack(payoutId) {
|
|
const rows = await (0, connection_1.query)(`UPDATE referral_commission_payouts
|
|
SET status = 'clawed_back', updated_at = NOW()
|
|
WHERE id = $1 AND status = 'paid'
|
|
RETURNING id`, [payoutId]);
|
|
return Boolean(rows[0]);
|
|
}
|
|
async function recordCommissionClawback(input) {
|
|
const rows = await (0, connection_1.query)(`INSERT INTO referral_commission_clawbacks
|
|
(payout_id, beneficiary_user_id, amount, reason, clawed_by)
|
|
VALUES ($1, $2, $3, $4, $5)
|
|
RETURNING id`, [
|
|
input.payoutId,
|
|
input.beneficiaryUserId,
|
|
input.amount.toString(),
|
|
input.reason,
|
|
input.clawedBy,
|
|
]);
|
|
return rows[0].id;
|
|
}
|
|
async function listRecentClawbacks(limit = 20) {
|
|
return (0, connection_1.query)(`SELECT id, payout_id, beneficiary_user_id, amount::text, reason, clawed_by, created_at
|
|
FROM referral_commission_clawbacks
|
|
ORDER BY created_at DESC
|
|
LIMIT $1`, [limit]);
|
|
}
|
|
async function listClawbacksForExport(opts) {
|
|
const limit = Math.min(opts?.limit ?? 10000, 50000);
|
|
const conditions = [];
|
|
const values = [];
|
|
let i = 1;
|
|
if (opts?.from) {
|
|
conditions.push(`c.created_at >= $${i++}`);
|
|
values.push(opts.from);
|
|
}
|
|
if (opts?.to) {
|
|
conditions.push(`c.created_at <= $${i++}`);
|
|
values.push(opts.to);
|
|
}
|
|
const where = conditions.length ? `WHERE ${conditions.join(' AND ')}` : '';
|
|
values.push(limit);
|
|
return (0, connection_1.query)(`SELECT c.id, c.payout_id, c.beneficiary_user_id, p.referred_user_id, p.level_number,
|
|
p.commission_amount::text AS payout_commission_amount, c.amount::text, c.reason,
|
|
c.clawed_by, c.created_at, p.status AS payout_status
|
|
FROM referral_commission_clawbacks c
|
|
JOIN referral_commission_payouts p ON p.id = c.payout_id
|
|
${where}
|
|
ORDER BY c.created_at DESC
|
|
LIMIT $${i}`, values);
|
|
}
|
|
async function getFraudDashboardData() {
|
|
const summaryRows = await (0, connection_1.query)(`SELECT
|
|
(SELECT COUNT(*) FROM referral_commission_payouts WHERE status = 'pending')::text AS pending_count,
|
|
COALESCE((SELECT SUM(commission_amount) FROM referral_commission_payouts WHERE status = 'pending'), 0)::text AS pending_amount,
|
|
(SELECT COUNT(*) FROM referral_commission_payouts WHERE status = 'review')::text AS review_count,
|
|
COALESCE((SELECT SUM(commission_amount) FROM referral_commission_payouts WHERE status = 'review'), 0)::text AS review_amount,
|
|
(SELECT COUNT(*) FROM referral_commission_payouts
|
|
WHERE status = 'paid' AND COALESCE(paid_at, created_at) >= date_trunc('month', NOW() AT TIME ZONE 'UTC'))::text AS paid_month_count,
|
|
COALESCE((SELECT SUM(commission_amount) FROM referral_commission_payouts
|
|
WHERE status = 'paid' AND COALESCE(paid_at, created_at) >= date_trunc('month', NOW() AT TIME ZONE 'UTC')), 0)::text AS paid_month_amount,
|
|
(SELECT COUNT(*) FROM referral_commission_clawbacks
|
|
WHERE created_at >= date_trunc('month', NOW() AT TIME ZONE 'UTC'))::text AS clawed_month_count,
|
|
COALESCE((SELECT SUM(amount) FROM referral_commission_clawbacks
|
|
WHERE created_at >= date_trunc('month', NOW() AT TIME ZONE 'UTC')), 0)::text AS clawed_month_amount`);
|
|
const blockedRows = await (0, connection_1.query)(`SELECT
|
|
(SELECT COUNT(*) FROM audit_logs
|
|
WHERE action = 'referral_commission_blocked'
|
|
AND created_at >= date_trunc('month', NOW() AT TIME ZONE 'UTC'))::text AS blocked_count,
|
|
(SELECT COUNT(*) FROM audit_logs
|
|
WHERE action = 'referral_commission_cap_blocked'
|
|
AND created_at >= date_trunc('month', NOW() AT TIME ZONE 'UTC'))::text AS cap_blocked_count`);
|
|
const sybilRows = await (0, connection_1.query)(`SELECT signal, COUNT(*)::text AS count
|
|
FROM referral_commission_payouts p,
|
|
LATERAL jsonb_array_elements_text(p.sybil_signals) AS signal
|
|
WHERE p.created_at >= date_trunc('month', NOW() AT TIME ZONE 'UTC')
|
|
AND p.status IN ('pending', 'review', 'paid', 'clawed_back')
|
|
GROUP BY signal
|
|
ORDER BY COUNT(*) DESC
|
|
LIMIT 20`);
|
|
const highRiskRows = await (0, connection_1.query)(`SELECT u.id AS user_id, u.referral_code,
|
|
COALESCE(AVG(p.sybil_score), 0)::text AS avg_sybil,
|
|
COUNT(*) FILTER (WHERE p.status = 'review')::text AS review_count,
|
|
COALESCE(SUM(p.commission_amount) FILTER (
|
|
WHERE p.status = 'paid'
|
|
AND COALESCE(p.paid_at, p.created_at) >= date_trunc('month', NOW() AT TIME ZONE 'UTC')
|
|
), 0)::text AS paid_month_amount,
|
|
COALESCE(SUM(p.commission_amount) FILTER (
|
|
WHERE p.status IN ('pending', 'review', 'paid')
|
|
AND p.created_at >= date_trunc('month', NOW() AT TIME ZONE 'UTC')
|
|
), 0)::text AS reserved_month_amount,
|
|
(SELECT COUNT(*)::text FROM users r
|
|
WHERE r.referred_by_user_id = u.id
|
|
AND r.first_deposit_at IS NOT NULL
|
|
AND NOT EXISTS (
|
|
SELECT 1 FROM candle_predict_bets b
|
|
WHERE b.user_id = r.id AND b.stake_account_kind IN ('main', 'bonus')
|
|
)) AS inactive_referrals
|
|
FROM users u
|
|
LEFT JOIN referral_commission_payouts p ON p.beneficiary_user_id = u.id
|
|
WHERE u.referral_code IS NOT NULL
|
|
GROUP BY u.id, u.referral_code
|
|
HAVING COALESCE(AVG(p.sybil_score), 0) >= 2
|
|
OR COUNT(*) FILTER (WHERE p.status = 'review') > 0
|
|
OR (SELECT COUNT(*) FROM users r
|
|
WHERE r.referred_by_user_id = u.id
|
|
AND r.first_deposit_at IS NOT NULL
|
|
AND NOT EXISTS (
|
|
SELECT 1 FROM candle_predict_bets b
|
|
WHERE b.user_id = r.id AND b.stake_account_kind IN ('main', 'bonus')
|
|
)) >= 3
|
|
ORDER BY COALESCE(AVG(p.sybil_score), 0) DESC, COUNT(*) FILTER (WHERE p.status = 'review') DESC
|
|
LIMIT 15`);
|
|
const recentClawbacks = await listRecentClawbacks(15);
|
|
const clawbackCandidates = await (0, connection_1.query)(`SELECT id, beneficiary_user_id, referred_user_id, commission_amount::text,
|
|
paid_at, sybil_score
|
|
FROM referral_commission_payouts
|
|
WHERE status = 'paid'
|
|
ORDER BY COALESCE(paid_at, created_at) DESC
|
|
LIMIT 25`);
|
|
const capBlocks = await (0, connection_1.query)(`SELECT user_id, action, resource_id, metadata, created_at
|
|
FROM audit_logs
|
|
WHERE action IN ('referral_commission_cap_blocked', 'referral_commission_blocked')
|
|
ORDER BY created_at DESC
|
|
LIMIT 20`);
|
|
const summary = summaryRows[0];
|
|
const blocked = blockedRows[0];
|
|
return {
|
|
summary: {
|
|
pendingCount: Number(summary?.pending_count ?? 0),
|
|
pendingAmount: summary?.pending_amount ?? '0',
|
|
reviewCount: Number(summary?.review_count ?? 0),
|
|
reviewAmount: summary?.review_amount ?? '0',
|
|
paidThisMonthCount: Number(summary?.paid_month_count ?? 0),
|
|
paidThisMonthAmount: summary?.paid_month_amount ?? '0',
|
|
clawedBackThisMonthCount: Number(summary?.clawed_month_count ?? 0),
|
|
clawedBackThisMonthAmount: summary?.clawed_month_amount ?? '0',
|
|
blockedThisMonthCount: Number(blocked?.blocked_count ?? 0),
|
|
capBlockedThisMonthCount: Number(blocked?.cap_blocked_count ?? 0),
|
|
},
|
|
sybilSignalBreakdown: sybilRows.map((r) => ({ signal: r.signal, count: Number(r.count) })),
|
|
highRiskReferrers: highRiskRows.map((r) => ({
|
|
userId: r.user_id,
|
|
referralCode: r.referral_code,
|
|
avgSybilScore: Number(r.avg_sybil),
|
|
reviewCount: Number(r.review_count),
|
|
paidThisMonthAmount: r.paid_month_amount,
|
|
reservedThisMonthAmount: r.reserved_month_amount,
|
|
inactiveReferrals: Number(r.inactive_referrals),
|
|
})),
|
|
recentClawbacks: recentClawbacks.map((c) => ({
|
|
id: c.id,
|
|
payoutId: c.payout_id,
|
|
beneficiaryUserId: c.beneficiary_user_id,
|
|
amount: c.amount,
|
|
reason: c.reason,
|
|
clawedBy: c.clawed_by,
|
|
createdAt: c.created_at,
|
|
})),
|
|
recentCapBlocks: capBlocks.map((r) => ({
|
|
userId: r.user_id,
|
|
action: r.action,
|
|
resourceId: r.resource_id,
|
|
metadata: r.metadata ?? null,
|
|
createdAt: r.created_at,
|
|
})),
|
|
clawbackCandidates: clawbackCandidates.map((p) => ({
|
|
id: p.id,
|
|
beneficiaryUserId: p.beneficiary_user_id,
|
|
referredUserId: p.referred_user_id,
|
|
commissionAmount: p.commission_amount,
|
|
paidAt: p.paid_at,
|
|
sybilScore: p.sybil_score,
|
|
})),
|
|
};
|
|
}
|
|
//# sourceMappingURL=referralRepository.js.map
|