785 lines
41 KiB
TypeScript
785 lines
41 KiB
TypeScript
/**
|
|
* API route definitions.
|
|
* Mounts public auth endpoints, applies authentication to protected routes, and wires controllers.
|
|
*/
|
|
|
|
import { Router } from 'express';
|
|
import { authMiddleware, requireRoles, requirePermissions } from '../middleware/auth';
|
|
import { auditAction } from '../middleware/audit';
|
|
import { asyncHandler } from '../middleware/errorHandler';
|
|
import { validateBody, validateQuery, validateParams } from '../middleware/validate';
|
|
import {
|
|
loginBodySchema,
|
|
registerBodySchema,
|
|
changePasswordBodySchema,
|
|
withdrawBodySchema,
|
|
transferBodySchema,
|
|
totpEnableBodySchema,
|
|
totpDisableBodySchema,
|
|
refreshBodySchema,
|
|
logoutBodySchema,
|
|
settingsUpdateBodySchema,
|
|
} from '../validation/schemas';
|
|
import {
|
|
forgotPasswordBodySchema,
|
|
resetPasswordBodySchema,
|
|
updateProfileBodySchema,
|
|
candlePredictBetBodySchema,
|
|
candlePredictMultiBetBodySchema,
|
|
adminUserFlagsBodySchema,
|
|
adminBatchUserFlagsBodySchema,
|
|
adminBatchSecurityBodySchema,
|
|
adminBatchLedgerCreditBodySchema,
|
|
adminUserRoleBodySchema,
|
|
adminUserRolesBodySchema,
|
|
adminLedgerCreditBodySchema,
|
|
fundRequestCreateBodySchema,
|
|
fundRequestRejectBodySchema,
|
|
approvalPolicyDraftBodySchema,
|
|
securityAlertResolveBodySchema,
|
|
securitySettingsBodySchema,
|
|
adminUserSecurityBodySchema,
|
|
bonusTransferBodySchema,
|
|
testWalletCreditBodySchema,
|
|
setupFirstAdminBodySchema,
|
|
setupPromoteAdminBodySchema,
|
|
resendVerificationBodySchema,
|
|
verifyEmailBodySchema,
|
|
gameBetBodySchema,
|
|
candlePredictAutoBodySchema,
|
|
referralSettingsBodySchema,
|
|
referralLevelBodySchema,
|
|
referralFundPoolBodySchema,
|
|
referralReasonBodySchema,
|
|
referralNoteBodySchema,
|
|
referralRegularizeBodySchema,
|
|
treasuryColdWalletBodySchema,
|
|
treasuryFundingBodySchema,
|
|
treasuryFundingConfirmBodySchema,
|
|
treasuryGasTransferBodySchema,
|
|
countryRegistrationBodySchema,
|
|
reportsBulkActionBodySchema,
|
|
adminUsersExportBodySchema,
|
|
adminDeleteUserBodySchema,
|
|
supportMessageBodySchema,
|
|
supportTypingBodySchema,
|
|
faqHelpfulBodySchema,
|
|
} from '../validation/adminSchemas';
|
|
import {
|
|
candlePredictAdminConfigBodySchema,
|
|
candlePredictIntervalCreateBodySchema,
|
|
candlePredictIntervalUpdateBodySchema,
|
|
candlePredictMultiLevelsBodySchema,
|
|
gameCreateBodySchema,
|
|
gameUpdateBodySchema,
|
|
advertisementCreateBodySchema,
|
|
advertisementUpdateBodySchema,
|
|
testWalletConfigBodySchema,
|
|
shareCardSettingsBodySchema,
|
|
soloEncouragementConfigBodySchema,
|
|
marketingLiveActivitySettingsBodySchema,
|
|
marketingPersonaCreateBodySchema,
|
|
marketingPersonaUpdateBodySchema,
|
|
supportConversationUpdateBodySchema,
|
|
faqCategoryCreateBodySchema,
|
|
faqCategoryUpdateBodySchema,
|
|
faqEntryCreateBodySchema,
|
|
faqEntryUpdateBodySchema,
|
|
} from '../validation/adminResourceSchemas';
|
|
import {
|
|
auditLogQuerySchema,
|
|
auditLogExportQuerySchema,
|
|
securityAlertsQuerySchema,
|
|
dbTamperEventsQuerySchema,
|
|
adminUsersListQuerySchema,
|
|
walletTransactionsQuerySchema,
|
|
uuidParamSchema,
|
|
alertIdParamSchema,
|
|
} from '../validation/querySchemas';
|
|
import { apiLimiter, loginLimiter, verificationEmailLimiter, passwordResetLimiter } from '../middleware/rateLimit';
|
|
import * as authController from '../controllers/authController';
|
|
import * as walletController from '../controllers/walletController';
|
|
import * as withdrawalController from '../controllers/withdrawalController';
|
|
import * as transferController from '../controllers/transferController';
|
|
import * as adminController from '../controllers/adminController';
|
|
import * as userController from '../controllers/userController';
|
|
import * as settingsController from '../controllers/settingsController';
|
|
import * as overviewController from '../controllers/overviewController';
|
|
import * as analyticsController from '../controllers/analyticsController';
|
|
import * as reportsController from '../controllers/reportsController';
|
|
import * as gameController from '../controllers/gameController';
|
|
import * as advertisementController from '../controllers/advertisementController';
|
|
import * as marketingController from '../controllers/marketingController';
|
|
import * as candlePredictController from '../controllers/candlePredictController';
|
|
import * as gamePlayController from '../controllers/gamePlayController';
|
|
import * as securityController from '../controllers/securityController';
|
|
import * as treasuryController from '../controllers/treasuryController';
|
|
import * as notificationController from '../controllers/notificationController';
|
|
import * as referralController from '../controllers/referralController';
|
|
import * as adminCreditController from '../controllers/adminCreditController';
|
|
import * as testWalletController from '../controllers/testWalletController';
|
|
import * as soloEncouragementController from '../controllers/soloEncouragementController';
|
|
import * as shareCardController from '../controllers/shareCardController';
|
|
import * as mobileAppReleaseController from '../controllers/mobileAppReleaseController';
|
|
import { apkUpload } from '../middleware/apkUpload';
|
|
import { requireSupportedAppVersion } from '../middleware/requireSupportedAppVersion';
|
|
import {
|
|
mobileReleaseCreateBodySchema,
|
|
mobileReleaseUpdateBodySchema,
|
|
mobileUpdateSettingsBodySchema,
|
|
mobileReleaseListQuerySchema,
|
|
mobileUpdateCheckQuerySchema,
|
|
mobileUpdateEventBodySchema,
|
|
mobileReleaseIdParamSchema,
|
|
} from '../validation/mobileReleaseSchemas';
|
|
import * as countryController from '../controllers/countryController';
|
|
import * as presenceController from '../controllers/presenceController';
|
|
import * as supportController from '../controllers/supportController';
|
|
import { optionalAuthMiddleware } from '../middleware/optionalAuth';
|
|
import { supportUpload } from '../middleware/supportUpload';
|
|
import { requireStaff } from '../middleware/auth';
|
|
import * as faqController from '../controllers/faqController';
|
|
import { faqUpload } from '../middleware/faqUpload';
|
|
import * as setupController from '../controllers/setupController';
|
|
import * as fundApprovalController from '../controllers/fundApprovalController';
|
|
import * as rbacController from '../controllers/rbacController';
|
|
|
|
const router = Router();
|
|
|
|
router.use(apiLimiter);
|
|
|
|
/** One-time platform setup (before any administrator exists). */
|
|
router.get('/setup/status', setupController.getSetupStatus);
|
|
router.post('/setup/first-admin', loginLimiter, validateBody(setupFirstAdminBodySchema), setupController.createFirstAdmin);
|
|
router.post('/setup/promote-admin', loginLimiter, validateBody(setupPromoteAdminBodySchema), setupController.promoteExistingUser);
|
|
|
|
router.post('/auth/register', validateBody(registerBodySchema), asyncHandler(authController.register));
|
|
router.get('/auth/referral/validate/:code', asyncHandler(authController.validateReferralCode));
|
|
router.get('/countries', countryController.listRegistrationCountries);
|
|
router.post('/auth/login', loginLimiter, validateBody(loginBodySchema), asyncHandler(authController.login));
|
|
router.get('/auth/captcha-config', asyncHandler(authController.getCaptchaConfig));
|
|
router.get('/auth/captcha-challenge', asyncHandler(authController.getCaptchaChallenge));
|
|
router.post('/auth/refresh', validateBody(refreshBodySchema), authController.refresh);
|
|
router.post('/auth/logout', validateBody(logoutBodySchema), authController.logout);
|
|
router.post('/auth/verify-email', validateBody(verifyEmailBodySchema), authController.verifyEmail);
|
|
router.get('/auth/verify-email', authController.verifyEmail);
|
|
router.post(
|
|
'/auth/resend-verification-email',
|
|
verificationEmailLimiter,
|
|
validateBody(resendVerificationBodySchema),
|
|
authController.resendVerificationEmail
|
|
);
|
|
router.post('/auth/forgot-password', passwordResetLimiter, validateBody(forgotPasswordBodySchema), authController.forgotPassword);
|
|
router.post('/auth/reset-password', validateBody(resetPasswordBodySchema), authController.resetPassword);
|
|
router.get('/auth/reset-password/validate/:token', authController.validateResetToken);
|
|
|
|
/** Public FAQ */
|
|
router.get('/faq/categories', faqController.listPublicCategories);
|
|
router.get('/faq/entries/popular', faqController.listPopularFaqs);
|
|
router.get('/faq/entries', faqController.listPublicFaqs);
|
|
router.get('/faq/entries/:id', faqController.getPublicFaq);
|
|
router.post('/faq/entries/:id/view', faqController.recordView);
|
|
router.post('/faq/entries/:id/helpful', optionalAuthMiddleware, validateBody(faqHelpfulBodySchema), faqController.recordHelpful);
|
|
router.get('/faq/files/:filename', faqController.getFaqFile);
|
|
|
|
/** Public marketing reads (landing / welcome) — catalogue + social-proof feeds. */
|
|
router.get('/games', gameController.listGames);
|
|
router.get('/advertisements', advertisementController.listAdvertisements);
|
|
router.get('/marketing/daily-stats', marketingController.getDailyStats);
|
|
router.get('/marketing/activity-feed', marketingController.getActivityFeed);
|
|
router.get('/marketing/withdrawal-feed', marketingController.getWithdrawalFeed);
|
|
|
|
/** Public Share Card verification (HMAC token). */
|
|
router.get('/share-cards/verify/:token', shareCardController.verifyShareCard);
|
|
|
|
/** Public Android in-app update check / APK download / telemetry (no auth). */
|
|
router.get(
|
|
'/app-updates/android',
|
|
validateQuery(mobileUpdateCheckQuerySchema),
|
|
mobileAppReleaseController.checkAndroid
|
|
);
|
|
router.get(
|
|
'/app-updates/android/download/:id',
|
|
validateParams(mobileReleaseIdParamSchema),
|
|
mobileAppReleaseController.downloadAndroid
|
|
);
|
|
router.post(
|
|
'/app-updates/android/events',
|
|
optionalAuthMiddleware,
|
|
validateBody(mobileUpdateEventBodySchema),
|
|
mobileAppReleaseController.postEvent
|
|
);
|
|
|
|
/** Support messaging — guests (visitor token) and optional authenticated users. */
|
|
router.get('/support/files/:filename', supportController.getAttachment);
|
|
router.post('/support/conversations/current', optionalAuthMiddleware, supportController.getOrCreateConversation);
|
|
router.post(
|
|
'/support/conversations/current/messages',
|
|
optionalAuthMiddleware,
|
|
validateBody(supportMessageBodySchema),
|
|
supportController.postCurrentMessage
|
|
);
|
|
router.post(
|
|
'/support/conversations/current/messages/attachment',
|
|
optionalAuthMiddleware,
|
|
supportController.userSendCurrentWithAttachment
|
|
);
|
|
router.post(
|
|
'/support/conversations/current/upload',
|
|
optionalAuthMiddleware,
|
|
supportUpload.single('file'),
|
|
supportController.uploadCurrentAttachment
|
|
);
|
|
router.get('/support/conversations', optionalAuthMiddleware, supportController.listMyConversations);
|
|
router.get('/support/conversations/:id/messages', optionalAuthMiddleware, supportController.getMessages);
|
|
router.post('/support/conversations/:id/messages', optionalAuthMiddleware, validateBody(supportMessageBodySchema), supportController.postMessage);
|
|
router.patch(
|
|
'/support/conversations/:id/messages/:messageId',
|
|
optionalAuthMiddleware,
|
|
validateBody(supportMessageBodySchema),
|
|
supportController.patchMessage
|
|
);
|
|
router.delete(
|
|
'/support/conversations/:id/messages/:messageId',
|
|
optionalAuthMiddleware,
|
|
supportController.removeMessage
|
|
);
|
|
router.post(
|
|
'/support/conversations/:id/messages/attachment',
|
|
optionalAuthMiddleware,
|
|
supportController.userSendWithAttachment
|
|
);
|
|
router.post('/support/conversations/:id/typing', optionalAuthMiddleware, validateBody(supportTypingBodySchema), supportController.postTyping);
|
|
router.post(
|
|
'/support/conversations/:id/upload',
|
|
optionalAuthMiddleware,
|
|
supportUpload.single('file'),
|
|
supportController.uploadAttachment
|
|
);
|
|
|
|
router.use(authMiddleware);
|
|
|
|
router.get('/me', userController.getMe);
|
|
router.get('/me/security-notifications', userController.listSecurityNotifications);
|
|
router.patch('/me/security-notifications/read-all', userController.markAllSecurityNotificationsRead);
|
|
router.patch('/me/security-notifications/:notificationId/read', userController.markSecurityNotificationRead);
|
|
router.post('/presence/ping', presenceController.pingPresence);
|
|
router.patch('/me', validateBody(updateProfileBodySchema), userController.updateMe);
|
|
router.post('/auth/change-password', validateBody(changePasswordBodySchema), asyncHandler(authController.changePassword));
|
|
router.post('/auth/logout-all', authController.logoutAll);
|
|
router.post(
|
|
'/auth/send-verification-email',
|
|
verificationEmailLimiter,
|
|
authController.sendVerificationEmail
|
|
);
|
|
|
|
router.get('/wallet-types', walletController.getWalletTypes);
|
|
router.get('/balances', walletController.getBalances);
|
|
router.get('/bonus/balances', referralController.getBonusBalances);
|
|
router.post('/bonus/transfer-to-main', validateBody(bonusTransferBodySchema), referralController.transferBonusToMain);
|
|
router.get('/test-wallet', testWalletController.getTestWalletStatus);
|
|
router.post('/test-wallet/request-credits', validateBody(testWalletCreditBodySchema), testWalletController.requestTestCredits);
|
|
router.get('/share-cards/config', shareCardController.getConfig);
|
|
router.get('/share-cards/bets/:betId', shareCardController.getBetShareCard);
|
|
router.get('/share-cards/transactions/:transactionId', shareCardController.getTransactionShareCard);
|
|
router.get('/referral/me', referralController.getMyReferralInfo);
|
|
router.get('/referral/dashboard', referralController.getMyReferralDashboard);
|
|
router.get('/referral/commissions', referralController.getMyReferralCommissions);
|
|
router.get('/deposit-address/:walletType', walletController.getDepositAddress);
|
|
router.get('/transactions', validateQuery(walletTransactionsQuerySchema), walletController.getTransactions);
|
|
|
|
router.post('/2fa/setup', authController.setup2FA);
|
|
router.post('/2fa/enable', validateBody(totpEnableBodySchema), authController.enable2FA);
|
|
router.post('/2fa/disable', validateBody(totpDisableBodySchema), authController.disable2FA);
|
|
router.post('/2fa/recovery/regenerate', authController.regenerateRecoveryCodes);
|
|
|
|
router.post(
|
|
'/withdraw',
|
|
requireSupportedAppVersion,
|
|
validateBody(withdrawBodySchema),
|
|
auditAction('withdrawal_requested', 'wallet'),
|
|
asyncHandler(withdrawalController.withdraw)
|
|
);
|
|
router.post(
|
|
'/transfer',
|
|
requireSupportedAppVersion,
|
|
validateBody(transferBodySchema),
|
|
auditAction('transfer_requested', 'wallet'),
|
|
asyncHandler(transferController.transfer)
|
|
);
|
|
|
|
router.get('/games/candle-predict/state', candlePredictController.getState);
|
|
router.get('/games/candle-predict/candles', candlePredictController.getCandles);
|
|
router.post(
|
|
'/games/candle-predict/bets',
|
|
requireSupportedAppVersion,
|
|
validateBody(candlePredictBetBodySchema),
|
|
candlePredictController.placeBet
|
|
);
|
|
router.get('/games/candle-predict/bets/outcome/:idempotencyKey', candlePredictController.getBetOutcome);
|
|
router.post(
|
|
'/games/candle-predict/bets/multi',
|
|
requireSupportedAppVersion,
|
|
validateBody(candlePredictMultiBetBodySchema),
|
|
candlePredictController.placeMultiBet
|
|
);
|
|
router.get('/games/candle-predict/bets/me', candlePredictController.getMyBets);
|
|
router.get('/games/candle-predict/auto', candlePredictController.getAutoSettings);
|
|
router.put('/games/candle-predict/auto', validateBody(candlePredictAutoBodySchema), candlePredictController.updateAutoSettings);
|
|
router.get('/games/:slug/state', gamePlayController.getState);
|
|
router.get('/games/:slug/bets/me', gamePlayController.getMyBets);
|
|
router.post('/games/:slug/bets', validateBody(gameBetBodySchema), gamePlayController.placeBet);
|
|
router.get('/games/:slug/auto', gamePlayController.getAutoSettings);
|
|
router.put('/games/:slug/auto', validateBody(candlePredictAutoBodySchema), gamePlayController.updateAutoSettings);
|
|
router.get('/games/:slug/:customAction', gamePlayController.customGet);
|
|
router.get('/games/:slug', gameController.getGame);
|
|
|
|
router.get('/admin/candle-predict/config', requireRoles('admin'), requirePermissions('games.admin'), candlePredictController.getAdminConfig);
|
|
router.patch('/admin/candle-predict/config', requireRoles('admin'), requirePermissions('games.admin'), validateBody(candlePredictAdminConfigBodySchema), candlePredictController.updateAdminConfig);
|
|
router.get('/admin/candle-predict/intervals', requireRoles('admin'), requirePermissions('games.admin'), candlePredictController.listAdminIntervals);
|
|
router.post('/admin/candle-predict/intervals', requireRoles('admin'), requirePermissions('games.admin'), validateBody(candlePredictIntervalCreateBodySchema), candlePredictController.createAdminInterval);
|
|
router.patch('/admin/candle-predict/intervals/:id', requireRoles('admin'), requirePermissions('games.admin'), validateBody(candlePredictIntervalUpdateBodySchema), candlePredictController.updateAdminInterval);
|
|
router.delete('/admin/candle-predict/intervals/:id', requireRoles('admin'), requirePermissions('games.admin'), candlePredictController.deleteAdminInterval);
|
|
router.get('/admin/candle-predict/multi-levels', requireRoles('admin'), requirePermissions('games.admin'), candlePredictController.listAdminMultiLevels);
|
|
router.put('/admin/candle-predict/multi-levels', requireRoles('admin'), requirePermissions('games.admin'), validateBody(candlePredictMultiLevelsBodySchema), candlePredictController.updateAdminMultiLevels);
|
|
|
|
router.get('/admin/games', requireRoles('admin'), requirePermissions('games.admin'), gameController.listGamesAdmin);
|
|
router.get('/admin/games/implementations', requireRoles('admin'), requirePermissions('games.admin'), gameController.listImplementationsAdmin);
|
|
router.post('/admin/games', requireRoles('admin'), requirePermissions('games.admin'), validateBody(gameCreateBodySchema), gameController.createGame);
|
|
router.patch('/admin/games/:id', requireRoles('admin'), requirePermissions('games.admin'), validateBody(gameUpdateBodySchema), gameController.updateGame);
|
|
router.delete('/admin/games/:id', requireRoles('admin'), requirePermissions('games.admin'), gameController.deleteGame);
|
|
|
|
router.get('/admin/advertisements', requireRoles('admin'), requirePermissions('games.admin'), advertisementController.listAdvertisementsAdmin);
|
|
router.post('/admin/advertisements', requireRoles('admin'), requirePermissions('games.admin'), validateBody(advertisementCreateBodySchema), advertisementController.createAdvertisement);
|
|
router.patch('/admin/advertisements/:id', requireRoles('admin'), requirePermissions('games.admin'), validateBody(advertisementUpdateBodySchema), advertisementController.updateAdvertisement);
|
|
router.delete('/admin/advertisements/:id', requireRoles('admin'), requirePermissions('games.admin'), advertisementController.deleteAdvertisement);
|
|
|
|
router.get(
|
|
'/admin/marketing/live-activity-settings',
|
|
requireRoles('admin'),
|
|
requirePermissions('games.admin'),
|
|
marketingController.getLiveActivitySettings
|
|
);
|
|
router.patch(
|
|
'/admin/marketing/live-activity-settings',
|
|
requireRoles('admin'),
|
|
requirePermissions('games.admin'),
|
|
validateBody(marketingLiveActivitySettingsBodySchema),
|
|
marketingController.updateLiveActivitySettings
|
|
);
|
|
router.get(
|
|
'/admin/marketing/personas',
|
|
requireRoles('admin'),
|
|
requirePermissions('games.admin'),
|
|
marketingController.listPersonas
|
|
);
|
|
router.post(
|
|
'/admin/marketing/personas',
|
|
requireRoles('admin'),
|
|
requirePermissions('games.admin'),
|
|
validateBody(marketingPersonaCreateBodySchema),
|
|
marketingController.createPersona
|
|
);
|
|
router.patch(
|
|
'/admin/marketing/personas/:id',
|
|
requireRoles('admin'),
|
|
requirePermissions('games.admin'),
|
|
validateBody(marketingPersonaUpdateBodySchema),
|
|
marketingController.updatePersona
|
|
);
|
|
router.delete(
|
|
'/admin/marketing/personas/:id',
|
|
requireRoles('admin'),
|
|
requirePermissions('games.admin'),
|
|
marketingController.deletePersona
|
|
);
|
|
|
|
router.get('/admin/users', requireRoles('admin'), requirePermissions('users.admin'), validateQuery(adminUsersListQuerySchema), adminController.listUsers);
|
|
router.post('/admin/users/export', requireRoles('admin'), requirePermissions('users.admin'), validateBody(adminUsersExportBodySchema), adminController.startUsersExport);
|
|
router.get('/admin/users/export/:jobId', requireRoles('admin'), requirePermissions('users.admin'), adminController.getUsersExportStatus);
|
|
router.get('/admin/users/export/:jobId/download', requireRoles('admin'), requirePermissions('users.admin'), adminController.downloadUsersExport);
|
|
router.post('/admin/users/batch/flags', requireRoles('admin'), requirePermissions('users.admin'), validateBody(adminBatchUserFlagsBodySchema), adminController.batchUpdateUserFlags);
|
|
router.post('/admin/users/batch/security', requireRoles('admin'), requirePermissions('users.admin'), validateBody(adminBatchSecurityBodySchema), adminController.batchUpdateUserSecurity);
|
|
router.post('/admin/users/batch/ledger-credit', requireRoles('admin'), requirePermissions('ledger.credit'), validateBody(adminBatchLedgerCreditBodySchema), adminController.batchGrantLedgerCredit);
|
|
router.get('/admin/users/:userId', requireRoles('admin'), requirePermissions('users.admin'), adminController.getUserDetails);
|
|
router.patch('/admin/users/:userId/flags', requireRoles('admin'), requirePermissions('users.admin'), validateBody(adminUserFlagsBodySchema), adminController.updateUserFlags);
|
|
router.patch('/admin/users/:userId/role', requireRoles('admin'), requirePermissions('user.manage_roles'), validateBody(adminUserRoleBodySchema), adminController.updateUserRole);
|
|
router.patch('/admin/users/:userId/roles', requireRoles('admin'), requirePermissions('user.manage_roles'), validateBody(adminUserRolesBodySchema), adminController.updateUserRoles);
|
|
|
|
// RBAC — roles & permissions management
|
|
router.get('/admin/rbac/permissions', requireRoles('admin'), requirePermissions('admin.rbac.view'), asyncHandler(rbacController.listPermissions));
|
|
router.get('/admin/rbac/roles', requireRoles('admin'), requirePermissions('admin.rbac.view'), asyncHandler(rbacController.listRoles));
|
|
router.get('/admin/rbac/roles/:roleId', requireRoles('admin'), requirePermissions('admin.rbac.view'), asyncHandler(rbacController.getRole));
|
|
router.post('/admin/rbac/roles', requireRoles('admin'), requirePermissions('admin.rbac.manage'), asyncHandler(rbacController.createRole));
|
|
router.patch('/admin/rbac/roles/:roleId', requireRoles('admin'), requirePermissions('admin.rbac.manage'), asyncHandler(rbacController.updateRole));
|
|
router.delete('/admin/rbac/roles/:roleId', requireRoles('admin'), requirePermissions('admin.rbac.manage'), asyncHandler(rbacController.deleteRole));
|
|
router.get('/admin/rbac/admin-users', requireRoles('admin'), requirePermissions('admin.rbac.view'), asyncHandler(rbacController.listAdminUsers));
|
|
router.get('/admin/rbac/admin-users/:userId/permissions', requireRoles('admin'), requirePermissions('admin.rbac.view'), asyncHandler(rbacController.getAdminUserPermissions));
|
|
router.patch('/admin/rbac/admin-users/:userId/permissions', requireRoles('admin'), requirePermissions('admin.rbac.manage'), asyncHandler(rbacController.updateAdminUserPermissions));
|
|
router.get('/admin/rbac/admin-users/:userId', requireRoles('admin'), requirePermissions('admin.rbac.view'), asyncHandler(rbacController.getAdminUser));
|
|
router.get('/admin/rbac/me', authMiddleware, asyncHandler(rbacController.getMyPermissions));
|
|
router.delete(
|
|
'/admin/users/:userId',
|
|
requireRoles('admin'),
|
|
requirePermissions('users.admin'),
|
|
validateBody(adminDeleteUserBodySchema),
|
|
adminController.deleteUser
|
|
);
|
|
|
|
router.post(
|
|
'/admin/fund-requests',
|
|
requirePermissions('fund_operation.request'),
|
|
validateBody(fundRequestCreateBodySchema),
|
|
fundApprovalController.createFundRequest
|
|
);
|
|
router.get('/admin/fund-requests', requireRoles('admin'), requirePermissions('fund_operation.request'), fundApprovalController.listFundRequests);
|
|
router.get('/admin/fund-requests/:id', requireRoles('admin'), requirePermissions('fund_operation.request'), fundApprovalController.getFundRequest);
|
|
router.post(
|
|
'/admin/fund-requests/:id/approve',
|
|
requirePermissions('fund_operation.approve'),
|
|
fundApprovalController.approveFundRequest
|
|
);
|
|
router.post(
|
|
'/admin/fund-requests/:id/reject',
|
|
requirePermissions('fund_operation.approve'),
|
|
validateBody(fundRequestRejectBodySchema),
|
|
fundApprovalController.rejectFundRequest
|
|
);
|
|
router.delete(
|
|
'/admin/fund-requests/:id',
|
|
requireRoles('admin'),
|
|
requirePermissions('fund_operation.request'),
|
|
fundApprovalController.cancelFundRequest
|
|
);
|
|
router.get(
|
|
'/admin/approval-policies',
|
|
requireRoles('admin'),
|
|
requirePermissions('fund_operation.approve'),
|
|
fundApprovalController.listApprovalPolicies
|
|
);
|
|
router.get(
|
|
'/admin/approval-policies/revisions',
|
|
requireRoles('admin'),
|
|
requirePermissions('fund_operation.approve'),
|
|
fundApprovalController.listPolicyRevisions
|
|
);
|
|
router.post(
|
|
'/admin/approval-policies/draft-change',
|
|
requireRoles('admin'),
|
|
requirePermissions('fund_operation.approve'),
|
|
validateBody(approvalPolicyDraftBodySchema),
|
|
fundApprovalController.draftPolicyChange
|
|
);
|
|
router.post(
|
|
'/admin/users/:userId/verify-email',
|
|
requireRoles('admin'),
|
|
requirePermissions('users.admin'),
|
|
adminController.verifyUserEmail
|
|
);
|
|
router.patch(
|
|
'/admin/users/:userId/security',
|
|
requireRoles('admin'),
|
|
requirePermissions('security.admin'),
|
|
validateBody(adminUserSecurityBodySchema),
|
|
securityController.updateUserSecurity
|
|
);
|
|
router.get(
|
|
'/admin/security/alerts',
|
|
requireRoles('admin'),
|
|
requirePermissions('security.admin'),
|
|
validateQuery(securityAlertsQuerySchema),
|
|
securityController.listAlerts
|
|
);
|
|
router.patch(
|
|
'/admin/security/alerts/:alertId',
|
|
requireRoles('admin'),
|
|
requirePermissions('security.admin'),
|
|
validateParams(alertIdParamSchema),
|
|
validateBody(securityAlertResolveBodySchema),
|
|
securityController.resolveAlert
|
|
);
|
|
router.get(
|
|
'/admin/security/settings',
|
|
requireRoles('admin'),
|
|
requirePermissions('security.admin'),
|
|
securityController.getSecuritySettings
|
|
);
|
|
router.patch(
|
|
'/admin/security/settings',
|
|
requireRoles('admin'),
|
|
requirePermissions('security.admin'),
|
|
validateBody(securitySettingsBodySchema),
|
|
securityController.updateSecuritySettings
|
|
);
|
|
router.post(
|
|
'/admin/security/integrity-check',
|
|
requireRoles('admin'),
|
|
requirePermissions('security.admin'),
|
|
securityController.runIntegrityCheck
|
|
);
|
|
router.get(
|
|
'/admin/security/db-tamper-events',
|
|
requireRoles('admin'),
|
|
requirePermissions('security.admin'),
|
|
validateQuery(dbTamperEventsQuerySchema),
|
|
securityController.listDbTamperEvents
|
|
);
|
|
router.get(
|
|
'/admin/security/db-tamper-events/export.csv',
|
|
requireRoles('admin'),
|
|
requirePermissions('security.admin'),
|
|
validateQuery(dbTamperEventsQuerySchema.omit({ limit: true, offset: true })),
|
|
securityController.exportDbTamperEventsCsv
|
|
);
|
|
router.post(
|
|
'/admin/security/db-tamper-check',
|
|
requireRoles('admin'),
|
|
requirePermissions('security.admin'),
|
|
securityController.processDbTamperCheck
|
|
);
|
|
router.post(
|
|
'/admin/security/dismiss-spurious-tamper-alerts',
|
|
requireRoles('admin'),
|
|
requirePermissions('security.admin'),
|
|
securityController.dismissSpuriousTamperAlerts
|
|
);
|
|
router.get(
|
|
'/admin/security/audit-logs',
|
|
requireRoles('admin'),
|
|
requirePermissions('security.admin'),
|
|
validateQuery(auditLogQuerySchema),
|
|
securityController.listAuditLogs
|
|
);
|
|
router.get(
|
|
'/admin/security/failed-logins',
|
|
requireRoles('admin'),
|
|
requirePermissions('security.admin'),
|
|
validateQuery(auditLogQuerySchema),
|
|
securityController.listFailedLogins
|
|
);
|
|
router.get(
|
|
'/admin/security/locked-accounts',
|
|
requireRoles('admin'),
|
|
requirePermissions('security.admin'),
|
|
securityController.listLockedAccounts
|
|
);
|
|
router.post(
|
|
'/admin/security/locked-accounts/:userId/unlock',
|
|
requireRoles('admin'),
|
|
requirePermissions('security.admin'),
|
|
securityController.unlockAccount
|
|
);
|
|
router.get(
|
|
'/admin/security/audit-logs/export.csv',
|
|
requireRoles('admin'),
|
|
requirePermissions('security.admin'),
|
|
validateQuery(auditLogExportQuerySchema),
|
|
securityController.exportAuditLogsCsv
|
|
);
|
|
|
|
router.get('/admin/notifications', requireRoles('admin'), requirePermissions('users.admin'), notificationController.listNotifications);
|
|
router.patch('/admin/notifications/read-all', requireRoles('admin'), requirePermissions('users.admin'), notificationController.markAllNotificationsRead);
|
|
router.patch('/admin/notifications/:notificationId/read', requireRoles('admin'), requirePermissions('users.admin'), notificationController.markNotificationRead);
|
|
|
|
router.post('/admin/users/:userId/ledger-credit', requireRoles('admin'), requirePermissions('ledger.credit'), validateBody(adminLedgerCreditBodySchema), adminCreditController.grantCredit);
|
|
router.get('/admin/ledger-credits', requireRoles('admin'), requirePermissions('ledger.credit'), adminCreditController.listCredits);
|
|
|
|
router.get('/admin/referral/config', requireRoles('admin'), requirePermissions('referral.admin'), referralController.getAdminReferralConfig);
|
|
router.patch('/admin/referral/settings', requireRoles('admin'), requirePermissions('referral.admin'), validateBody(referralSettingsBodySchema), referralController.updateAdminReferralSettings);
|
|
router.put('/admin/referral/levels', requireRoles('admin'), requirePermissions('referral.admin'), validateBody(referralLevelBodySchema), referralController.upsertReferralLevel);
|
|
router.delete('/admin/referral/levels/:levelNumber', requireRoles('admin'), requirePermissions('referral.admin'), referralController.deleteReferralLevel);
|
|
router.get('/admin/referral/stats', requireRoles('admin'), requirePermissions('referral.admin'), referralController.getReferralStats);
|
|
router.get('/admin/referral/commissions/review', requireRoles('admin'), requirePermissions('referral.admin'), referralController.getReferralReviewQueue);
|
|
router.post('/admin/referral/commissions/:payoutId/approve', requireRoles('admin'), requirePermissions('referral.admin'), validateBody(referralNoteBodySchema), referralController.approveReferralCommission);
|
|
router.post('/admin/referral/commissions/:payoutId/reject', requireRoles('admin'), requirePermissions('referral.admin'), validateBody(referralReasonBodySchema), referralController.rejectReferralCommission);
|
|
router.get('/admin/referral/fraud-dashboard', requireRoles('admin'), requirePermissions('referral.admin'), referralController.getReferralFraudDashboard);
|
|
router.get('/admin/referral/clawbacks/export.csv', requireRoles('admin'), requirePermissions('referral.admin'), referralController.exportReferralClawbacksCsv);
|
|
router.post('/admin/referral/commissions/:payoutId/clawback', requireRoles('admin'), requirePermissions('referral.admin'), validateBody(referralReasonBodySchema), referralController.clawbackReferralCommission);
|
|
router.post('/admin/referral/pool/fund', requireRoles('admin'), requirePermissions('referral.admin'), validateBody(referralFundPoolBodySchema), referralController.fundBonusPool);
|
|
router.get('/admin/referral/regularization', requireRoles('admin'), requirePermissions('referral.admin'), referralController.getReferralRegularization);
|
|
router.post('/admin/referral/regularization/apply', requireRoles('admin'), requirePermissions('referral.admin'), validateBody(referralRegularizeBodySchema), referralController.applyReferralRegularization);
|
|
|
|
router.get('/admin/test-wallet/config', requireRoles('admin'), requirePermissions('settings.admin'), testWalletController.getAdminConfig);
|
|
router.patch('/admin/test-wallet/config', requireRoles('admin'), requirePermissions('settings.admin'), validateBody(testWalletConfigBodySchema), testWalletController.updateAdminConfig);
|
|
router.get('/admin/test-wallet/credits', requireRoles('admin'), requirePermissions('settings.admin'), testWalletController.listAdminCredits);
|
|
router.get('/admin/share-cards/settings', requireRoles('admin'), requirePermissions('settings.admin'), shareCardController.getAdminSettings);
|
|
router.patch('/admin/share-cards/settings', requireRoles('admin'), requirePermissions('settings.admin'), validateBody(shareCardSettingsBodySchema), shareCardController.updateAdminSettings);
|
|
|
|
/** Admin — mobile APK release management */
|
|
router.get(
|
|
'/admin/mobile-releases/stats',
|
|
requireRoles('admin'),
|
|
requirePermissions('admin.mobile_releases.view'),
|
|
mobileAppReleaseController.adminStats
|
|
);
|
|
router.get(
|
|
'/admin/mobile-update-settings',
|
|
requireRoles('admin'),
|
|
requirePermissions('admin.mobile_releases.view'),
|
|
mobileAppReleaseController.adminGetSettings
|
|
);
|
|
router.patch(
|
|
'/admin/mobile-update-settings',
|
|
requireRoles('admin'),
|
|
requirePermissions('admin.mobile_releases.manage'),
|
|
validateBody(mobileUpdateSettingsBodySchema),
|
|
mobileAppReleaseController.adminUpdateSettings
|
|
);
|
|
router.get(
|
|
'/admin/mobile-releases',
|
|
requireRoles('admin'),
|
|
requirePermissions('admin.mobile_releases.view'),
|
|
validateQuery(mobileReleaseListQuerySchema),
|
|
mobileAppReleaseController.adminList
|
|
);
|
|
router.post(
|
|
'/admin/mobile-releases',
|
|
requireRoles('admin'),
|
|
requirePermissions('admin.mobile_releases.manage'),
|
|
validateBody(mobileReleaseCreateBodySchema),
|
|
mobileAppReleaseController.adminCreate
|
|
);
|
|
router.get(
|
|
'/admin/mobile-releases/:id',
|
|
requireRoles('admin'),
|
|
requirePermissions('admin.mobile_releases.view'),
|
|
validateParams(mobileReleaseIdParamSchema),
|
|
mobileAppReleaseController.adminGet
|
|
);
|
|
router.patch(
|
|
'/admin/mobile-releases/:id',
|
|
requireRoles('admin'),
|
|
requirePermissions('admin.mobile_releases.manage'),
|
|
validateParams(mobileReleaseIdParamSchema),
|
|
validateBody(mobileReleaseUpdateBodySchema),
|
|
mobileAppReleaseController.adminUpdate
|
|
);
|
|
router.post(
|
|
'/admin/mobile-releases/:id/apk',
|
|
requireRoles('admin'),
|
|
requirePermissions('admin.mobile_releases.manage'),
|
|
validateParams(mobileReleaseIdParamSchema),
|
|
apkUpload.single('file'),
|
|
mobileAppReleaseController.adminUploadApk
|
|
);
|
|
router.post(
|
|
'/admin/mobile-releases/:id/submit',
|
|
requireRoles('admin'),
|
|
requirePermissions('admin.mobile_releases.manage'),
|
|
validateParams(mobileReleaseIdParamSchema),
|
|
mobileAppReleaseController.adminSubmit
|
|
);
|
|
router.post(
|
|
'/admin/mobile-releases/:id/publish',
|
|
requireRoles('admin'),
|
|
requirePermissions('admin.mobile_releases.manage'),
|
|
validateParams(mobileReleaseIdParamSchema),
|
|
mobileAppReleaseController.adminPublish
|
|
);
|
|
router.post(
|
|
'/admin/mobile-releases/:id/suspend',
|
|
requireRoles('admin'),
|
|
requirePermissions('admin.mobile_releases.manage'),
|
|
validateParams(mobileReleaseIdParamSchema),
|
|
mobileAppReleaseController.adminSuspend
|
|
);
|
|
router.post(
|
|
'/admin/mobile-releases/:id/retire',
|
|
requireRoles('admin'),
|
|
requirePermissions('admin.mobile_releases.manage'),
|
|
validateParams(mobileReleaseIdParamSchema),
|
|
mobileAppReleaseController.adminRetire
|
|
);
|
|
|
|
router.get('/admin/solo-encouragement/config', requireRoles('admin'), requirePermissions('settings.admin'), soloEncouragementController.getAdminConfig);
|
|
router.patch('/admin/solo-encouragement/config', requireRoles('admin'), requirePermissions('settings.admin'), validateBody(soloEncouragementConfigBodySchema), soloEncouragementController.updateAdminConfig);
|
|
router.get('/admin/solo-encouragement/streaks', requireRoles('admin'), requirePermissions('settings.admin'), soloEncouragementController.listActiveStreaks);
|
|
router.get('/admin/solo-encouragement/grants/export', requireRoles('admin'), requirePermissions('settings.admin'), soloEncouragementController.exportGrants);
|
|
router.get('/admin/solo-encouragement/grants', requireRoles('admin'), requirePermissions('settings.admin'), soloEncouragementController.listGrants);
|
|
router.post('/admin/solo-encouragement/grants/:grantId/grant', requireRoles('admin'), requirePermissions('settings.admin'), soloEncouragementController.grantBonus);
|
|
router.post('/admin/solo-encouragement/grants/:grantId/reject', requireRoles('admin'), requirePermissions('settings.admin'), soloEncouragementController.rejectBonus);
|
|
|
|
router.get('/admin/countries', requireRoles('admin'), requirePermissions('settings.admin'), countryController.listCountriesAdmin);
|
|
router.post('/admin/countries/sync', requireRoles('admin'), requirePermissions('settings.admin'), countryController.syncCountriesAdmin);
|
|
router.patch('/admin/countries/:code', requireRoles('admin'), requirePermissions('settings.admin'), validateBody(countryRegistrationBodySchema), countryController.updateCountryRegistration);
|
|
|
|
router.get('/admin/treasury/overview', requireRoles('admin'), requirePermissions('treasury.view'), treasuryController.getOverview);
|
|
router.get('/admin/treasury/cold-wallets', requireRoles('admin'), requirePermissions('treasury.view'), treasuryController.listColdWallets);
|
|
router.post('/admin/treasury/cold-wallets', requireRoles('admin'), requirePermissions('treasury.view'), validateBody(treasuryColdWalletBodySchema), treasuryController.setColdWallet);
|
|
router.get('/admin/treasury/sweeps', requireRoles('admin'), requirePermissions('treasury.view'), treasuryController.listSweeps);
|
|
router.post('/admin/treasury/sweeps/run', requireRoles('admin'), requirePermissions('treasury.view'), treasuryController.runSweeps);
|
|
router.get('/admin/treasury/funding', requireRoles('admin'), requirePermissions('treasury.view'), treasuryController.listFunding);
|
|
router.post('/admin/treasury/funding', requireRoles('admin'), requirePermissions('treasury.view'), validateBody(treasuryFundingBodySchema), treasuryController.requestFunding);
|
|
router.get('/admin/treasury/funding/hot-to-cold/preview', requireRoles('admin'), requirePermissions('treasury.view'), treasuryController.previewHotToColdUsdt);
|
|
router.post('/admin/treasury/funding/hot-to-cold', requireRoles('admin'), requirePermissions('treasury.view'), validateBody(treasuryFundingBodySchema), treasuryController.requestHotToColdUsdt);
|
|
router.patch('/admin/treasury/funding/:fundingId/confirm', requireRoles('admin'), requirePermissions('treasury.view'), validateBody(treasuryFundingConfirmBodySchema), treasuryController.confirmFunding);
|
|
router.delete('/admin/treasury/funding/:fundingId', requireRoles('admin'), requirePermissions('treasury.view'), treasuryController.cancelFunding);
|
|
router.get('/admin/treasury/stuck-deposits', requireRoles('admin'), requirePermissions('treasury.view'), treasuryController.listStuckDeposits);
|
|
router.post('/admin/treasury/stuck-deposits/scan', requireRoles('admin'), requirePermissions('treasury.view'), treasuryController.scanStuckDeposits);
|
|
router.get('/admin/treasury/gas-transfer/preview', requireRoles('admin'), requirePermissions('treasury.view'), treasuryController.previewGasTransfer);
|
|
router.post('/admin/treasury/gas-transfer', requireRoles('admin'), requirePermissions('treasury.view'), validateBody(treasuryGasTransferBodySchema), treasuryController.requestGasTransfer);
|
|
|
|
router.get('/admin/overview', requireRoles('admin'), requirePermissions('reports.admin'), overviewController.getAdminOverview);
|
|
router.get('/admin/analytics/dashboard', requireRoles('admin'), requirePermissions('reports.admin'), analyticsController.getDashboardAnalytics);
|
|
router.get('/admin/reports/catalog', requireRoles('admin'), requirePermissions('reports.admin'), reportsController.getCatalog);
|
|
router.get('/admin/reports/export/:jobId/download', requireRoles('admin'), requirePermissions('reports.admin'), reportsController.downloadReportExportJob);
|
|
router.get('/admin/reports/export/:jobId', requireRoles('admin'), requirePermissions('reports.admin'), reportsController.getReportExportJobStatus);
|
|
router.post('/admin/reports/:reportKey/export/async', requireRoles('admin'), requirePermissions('reports.admin'), reportsController.startReportExportAsync);
|
|
router.get('/admin/reports/:reportKey', requireRoles('admin'), requirePermissions('reports.admin'), reportsController.getReport);
|
|
router.get('/admin/reports/:reportKey/export', requireRoles('admin'), requirePermissions('reports.admin'), reportsController.exportReport);
|
|
router.post('/admin/reports/:reportKey/export', requireRoles('admin'), requirePermissions('reports.admin'), reportsController.exportReportPost);
|
|
router.post('/admin/reports/:reportKey/bulk-action', requireRoles('admin'), requirePermissions('reports.admin'), validateBody(reportsBulkActionBodySchema), reportsController.runBulkAction);
|
|
router.get('/admin/settings', requireRoles('admin'), requirePermissions('settings.admin'), settingsController.getSettings);
|
|
router.patch(
|
|
'/admin/settings',
|
|
requireRoles('admin'),
|
|
requirePermissions('settings.admin'),
|
|
validateBody(settingsUpdateBodySchema),
|
|
settingsController.updateSettings
|
|
);
|
|
|
|
/** Support desk — admin and moderator. */
|
|
router.get('/admin/support/unread', requireStaff(), supportController.adminUnreadCount);
|
|
router.get('/admin/support/conversations', requireStaff(), supportController.adminListConversations);
|
|
router.get('/admin/support/conversations/:id', requireStaff(), supportController.adminGetConversation);
|
|
router.patch('/admin/support/conversations/:id', requireStaff(), validateBody(supportConversationUpdateBodySchema), supportController.adminUpdateConversation);
|
|
router.get('/admin/support/conversations/:id/messages', requireStaff(), supportController.adminGetMessages);
|
|
router.post('/admin/support/conversations/:id/messages', requireStaff(), validateBody(supportMessageBodySchema), supportController.adminPostMessage);
|
|
router.patch(
|
|
'/admin/support/conversations/:id/messages/:messageId',
|
|
requireStaff(),
|
|
validateBody(supportMessageBodySchema),
|
|
supportController.patchMessage
|
|
);
|
|
router.delete(
|
|
'/admin/support/conversations/:id/messages/:messageId',
|
|
requireStaff(),
|
|
supportController.removeMessage
|
|
);
|
|
router.post(
|
|
'/admin/support/conversations/:id/messages/attachment',
|
|
requireStaff(),
|
|
supportController.adminSendWithAttachment
|
|
);
|
|
router.post('/admin/support/conversations/:id/typing', requireStaff(), supportController.postTyping);
|
|
router.post(
|
|
'/admin/support/conversations/:id/upload',
|
|
requireStaff(),
|
|
supportUpload.single('file'),
|
|
supportController.adminUploadAttachment
|
|
);
|
|
|
|
/** FAQ management — admin and moderator. */
|
|
router.get('/admin/faq/categories', requireStaff(), faqController.adminListCategories);
|
|
router.post('/admin/faq/categories', requireStaff(), validateBody(faqCategoryCreateBodySchema), faqController.adminCreateCategory);
|
|
router.patch('/admin/faq/categories/:id', requireStaff(), validateBody(faqCategoryUpdateBodySchema), faqController.adminUpdateCategory);
|
|
router.delete('/admin/faq/categories/:id', requireStaff(), faqController.adminDeleteCategory);
|
|
router.get('/admin/faq/entries', requireStaff(), faqController.adminListFaqs);
|
|
router.post('/admin/faq/entries', requireStaff(), validateBody(faqEntryCreateBodySchema), faqController.adminCreateFaq);
|
|
router.patch('/admin/faq/entries/:id', requireStaff(), validateBody(faqEntryUpdateBodySchema), faqController.adminUpdateFaq);
|
|
router.delete('/admin/faq/entries/:id', requireStaff(), faqController.adminDeleteFaq);
|
|
router.post('/admin/faq/upload', requireStaff(), faqUpload.single('file'), faqController.adminUploadMedia);
|
|
|
|
/** Express router mounted at config.apiPrefix (default /api/v1). */
|
|
export default router;
|