This repository has been archived on 2026-11-17. You can view files and clone it, but cannot push or open issues or pull requests.
caelum0x 49b183818c Unify gitgram + aitimemachine into the monorepo (de-submodule) and merge vendored engines
Convert gitgram/ and aitimemachine/ from embedded git repos (which showed as
opaque submodule gitlinks on GitHub) into fully-tracked first-party content.

AITM now merges its 7 vendored repos as first-party engines:
- memory: beads (Go task DAG) + context7 (docs SDK), unified into saved_contexts
- git: vendored C git (bundled binary) + gitnexus (in-process code intelligence)
- agentic: a2a (@a2a-js/sdk) + pal (AITM-managed Python subprocess)

Includes the full session's product build: Gitgram web/mobile/backend features,
AITM website/CLI/MCP, the unified memory layer, engine build tooling
(scripts/build-engines.sh, Dockerfile, CI), docs (README, ENGINES.md, ARCHITECTURE.md),
and extensive test suites.

Build artifacts, node_modules, external/, and gemini-cli are gitignored.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-06-23 14:14:09 +03:00

1154 lines
31 KiB
TypeScript

import { Request, Response } from 'express';
import { AuthRequest } from '../middleware/auth';
import { prisma } from '../utils/prisma';
import logger from '../utils/logger';
import { Prisma } from '@prisma/client';
import { asyncHandler, Errors, ApiError } from '../middleware/errorHandler';
// ============================================================================
// USER MANAGEMENT
// ============================================================================
/**
* Get all users with pagination and filters
*/
export const getUsers = asyncHandler(async (req: Request, res: Response) => {
const page = parseInt(req.query.page as string) || 1;
const limit = Math.min(parseInt(req.query.limit as string) || 20, 100);
const search = req.query.search as string;
const status = req.query.status as string;
const sortBy = (req.query.sortBy as string) || 'createdAt';
const sortOrder = (req.query.sortOrder as string) === 'asc' ? 'asc' : 'desc';
const where: Prisma.UserWhereInput = {};
if (search) {
where.OR = [
{ username: { contains: search, mode: 'insensitive' } },
{ email: { contains: search, mode: 'insensitive' } },
{ displayName: { contains: search, mode: 'insensitive' } },
];
}
if (status === 'verified') {
where.verified = true;
} else if (status === 'unverified') {
where.verified = false;
}
const [users, total] = await Promise.all([
prisma.user.findMany({
where,
select: {
id: true,
username: true,
email: true,
displayName: true,
avatar: true,
verified: true,
createdAt: true,
_count: {
select: {
posts: true,
followers: true,
following: true,
},
},
},
orderBy: { [sortBy]: sortOrder },
skip: (page - 1) * limit,
take: limit,
}),
prisma.user.count({ where }),
]);
res.json({
users,
pagination: {
page,
limit,
total,
totalPages: Math.ceil(total / limit),
},
});
});
/**
* Get single user details
*/
export const getUserDetails = asyncHandler(async (req: Request, res: Response) => {
const { userId } = req.params;
const user = await prisma.user.findUnique({
where: { id: userId },
include: {
_count: {
select: {
posts: true,
followers: true,
following: true,
comments: true,
likes: true,
},
},
sessions: {
select: {
id: true,
createdAt: true,
expiresAt: true,
},
orderBy: { createdAt: 'desc' },
take: 10,
},
},
});
if (!user) {
throw Errors.notFound('User');
}
// Get recent activity
const recentPosts = await prisma.post.findMany({
where: { userId },
orderBy: { createdAt: 'desc' },
take: 5,
select: {
id: true,
content: true,
createdAt: true,
likesCount: true,
commentsCount: true,
},
});
res.json({
...user,
recentPosts,
});
});
/**
* Update user (verification status)
*/
export const updateUser = asyncHandler(async (req: Request, res: Response) => {
const { userId } = req.params;
const { verified, isPrivate } = req.body;
const adminId = (req as AuthRequest).user!.id;
const updateData: Prisma.UserUpdateInput = {};
if (verified !== undefined) updateData.verified = verified;
if (isPrivate !== undefined) updateData.isPrivate = isPrivate;
const user = await prisma.user.update({
where: { id: userId },
data: updateData,
select: {
id: true,
username: true,
verified: true,
isPrivate: true,
},
});
// Log admin action
await logAdminAction(adminId, 'USER_UPDATE', userId, updateData);
logger.info(`Admin ${adminId} updated user ${userId}`);
res.json(user);
});
/**
* Ban user (soft ban - invalidate sessions)
*/
export const banUser = asyncHandler(async (req: Request, res: Response) => {
const { userId } = req.params;
const { reason } = req.body;
const adminId = (req as AuthRequest).user!.id;
// Invalidate all sessions for this user
const result = await prisma.session.deleteMany({ where: { userId } });
await logAdminAction(adminId, 'USER_BAN', userId, { reason, sessionsDeleted: result.count });
logger.info(`Admin ${adminId} banned user ${userId} (${result.count} sessions invalidated)`);
res.json({
message: 'User sessions invalidated successfully',
sessionsInvalidated: result.count,
note: 'User will need to re-authenticate'
});
});
/**
* Unban user (no-op since we don't have ban flag, just a log action)
*/
export const unbanUser = asyncHandler(async (req: Request, res: Response) => {
const { userId } = req.params;
const adminId = (req as AuthRequest).user!.id;
await logAdminAction(adminId, 'USER_UNBAN', userId, {});
logger.info(`Admin ${adminId} unbanned user ${userId}`);
res.json({ message: 'User unban noted' });
});
/**
* Delete user account
*/
export const deleteUser = asyncHandler(async (req: Request, res: Response) => {
const { userId } = req.params;
const adminId = (req as AuthRequest).user!.id;
// Delete user (cascades to related data)
await prisma.user.delete({ where: { id: userId } });
await logAdminAction(adminId, 'USER_DELETE', userId, {});
logger.info(`Admin ${adminId} deleted user ${userId}`);
res.json({ message: 'User deleted successfully' });
});
// ============================================================================
// CONTENT MODERATION
// ============================================================================
/**
* Get reports for moderation (with pagination)
*/
export const getReports = asyncHandler(async (req: Request, res: Response) => {
const page = parseInt(req.query.page as string) || 1;
const limit = Math.min(parseInt(req.query.limit as string) || 20, 100);
const status = req.query.status as string || 'pending';
const where: Prisma.PostReportWhereInput = {};
if (status && status !== 'all') {
where.status = status;
}
const [reports, total] = await Promise.all([
prisma.postReport.findMany({
where,
orderBy: { createdAt: 'desc' },
skip: (page - 1) * limit,
take: limit,
}),
prisma.postReport.count({ where }),
]);
// Fetch related posts and reporters
const postIds = [...new Set(reports.map(r => r.postId))];
const reporterIds = [...new Set(reports.map(r => r.userId).filter(Boolean))] as string[];
const [posts, reporters] = await Promise.all([
prisma.post.findMany({
where: { id: { in: postIds } },
select: {
id: true,
content: true,
mediaUrls: true,
createdAt: true,
user: {
select: { id: true, username: true, avatar: true },
},
},
}),
prisma.user.findMany({
where: { id: { in: reporterIds } },
select: { id: true, username: true, avatar: true },
}),
]);
const postMap = new Map(posts.map(p => [p.id, p]));
const reporterMap = new Map(reporters.map(r => [r.id, r]));
const enrichedReports = reports.map(report => ({
...report,
post: postMap.get(report.postId) || null,
reporter: report.userId ? reporterMap.get(report.userId) || null : null,
}));
res.json({
reports: enrichedReports,
pagination: {
page,
limit,
total,
totalPages: Math.ceil(total / limit),
},
});
});
/**
* Resolve a content report
*/
export const resolveReport = asyncHandler(async (req: Request, res: Response) => {
const { reportId } = req.params;
const { action, note } = req.body;
const adminId = (req as AuthRequest).user!.id;
// Valid actions: dismiss, warn, remove_content, ban_user
const validActions = ['dismiss', 'warn', 'remove_content', 'ban_user'];
if (!validActions.includes(action)) {
throw Errors.badRequest(`Invalid action. Valid actions: ${validActions.join(', ')}`);
}
// Get the report
const report = await prisma.postReport.findUnique({
where: { id: reportId },
});
if (!report) {
throw Errors.notFound('Report');
}
if (report.status !== 'pending') {
throw Errors.badRequest('Report already resolved');
}
// Get the reported post
const post = await prisma.post.findUnique({
where: { id: report.postId },
select: { id: true, userId: true },
});
// Execute the action
let actionResult = '';
if (action === 'remove_content' && post) {
// Delete the post
await prisma.post.delete({ where: { id: post.id } });
actionResult = 'Post removed';
} else if (action === 'ban_user' && post?.userId) {
// Invalidate all sessions for the post author
const result = await prisma.session.deleteMany({
where: { userId: post.userId }
});
actionResult = `User banned (${result.count} sessions invalidated)`;
} else if (action === 'warn' && post?.userId) {
// Create a notification warning the user
await prisma.notification.create({
data: {
userId: post.userId,
type: 'MENTION',
content: `Your post has been flagged for review. Reason: ${report.reason}`,
},
});
actionResult = 'User warned via notification';
} else {
actionResult = 'Report dismissed';
}
// Update report status
await prisma.postReport.update({
where: { id: reportId },
data: { status: action === 'dismiss' ? 'dismissed' : 'resolved' },
});
// Log the action
await logAdminAction(adminId, 'REPORT_RESOLVE', reportId, {
action,
note,
postId: report.postId,
result: actionResult,
});
res.json({
message: 'Report resolved',
action,
result: actionResult,
});
});
/**
* Get posts for moderation
*/
export const getFlaggedContent = asyncHandler(async (req: Request, res: Response) => {
const page = parseInt(req.query.page as string) || 1;
const limit = Math.min(parseInt(req.query.limit as string) || 20, 100);
const [posts, total] = await Promise.all([
prisma.post.findMany({
include: {
user: {
select: { id: true, username: true, avatar: true },
},
_count: { select: { likes: true, comments: true } },
},
orderBy: { createdAt: 'desc' },
skip: (page - 1) * limit,
take: limit,
}),
prisma.post.count(),
]);
res.json({
posts,
pagination: {
page,
limit,
total,
totalPages: Math.ceil(total / limit),
},
});
});
/**
* Delete post (moderation action)
*/
export const moderatePost = asyncHandler(async (req: Request, res: Response) => {
const { postId } = req.params;
const { action, reason } = req.body;
const adminId = (req as AuthRequest).user!.id;
if (action === 'remove') {
await prisma.post.delete({ where: { id: postId } });
}
await logAdminAction(adminId, 'POST_MODERATE', postId, { action, reason });
logger.info(`Admin ${adminId} moderated post ${postId}: ${action}`);
res.json({ message: `Post ${action === 'remove' ? 'removed' : 'action noted'}` });
});
// ============================================================================
// ANALYTICS DASHBOARD
// ============================================================================
/**
* Get dashboard overview stats
*/
export const getDashboardStats = asyncHandler(async (req: Request, res: Response) => {
const now = new Date();
const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
const lastWeek = new Date(today.getTime() - 7 * 24 * 60 * 60 * 1000);
const lastMonth = new Date(today.getTime() - 30 * 24 * 60 * 60 * 1000);
const [
totalUsers,
newUsersToday,
newUsersThisWeek,
totalPosts,
postsToday,
postsThisWeek,
totalComments,
totalLikes,
totalStories,
totalReels,
] = await Promise.all([
prisma.user.count(),
prisma.user.count({ where: { createdAt: { gte: today } } }),
prisma.user.count({ where: { createdAt: { gte: lastWeek } } }),
prisma.post.count(),
prisma.post.count({ where: { createdAt: { gte: today } } }),
prisma.post.count({ where: { createdAt: { gte: lastWeek } } }),
prisma.comment.count(),
prisma.like.count(),
prisma.story.count(),
prisma.reel.count(),
]);
res.json({
users: {
total: totalUsers,
newToday: newUsersToday,
newThisWeek: newUsersThisWeek,
},
content: {
posts: totalPosts,
postsToday,
postsThisWeek,
comments: totalComments,
likes: totalLikes,
stories: totalStories,
reels: totalReels,
},
engagement: {
avgLikesPerPost: totalPosts > 0 ? (totalLikes / totalPosts).toFixed(2) : 0,
avgCommentsPerPost: totalPosts > 0 ? (totalComments / totalPosts).toFixed(2) : 0,
},
});
});
/**
* Get detailed analytics
*/
export const getAnalytics = asyncHandler(async (req: Request, res: Response) => {
const { timeframe = '30d' } = req.query;
let startDate: Date;
const now = new Date();
switch (timeframe) {
case '24h':
startDate = new Date(now.getTime() - 24 * 60 * 60 * 1000);
break;
case '7d':
startDate = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
break;
case '30d':
startDate = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000);
break;
case '90d':
startDate = new Date(now.getTime() - 90 * 24 * 60 * 60 * 1000);
break;
default:
startDate = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000);
}
const [
newUsers,
newPosts,
newComments,
newLikes,
topUsers,
topPosts,
] = await Promise.all([
prisma.user.count({ where: { createdAt: { gte: startDate } } }),
prisma.post.count({ where: { createdAt: { gte: startDate } } }),
prisma.comment.count({ where: { createdAt: { gte: startDate } } }),
prisma.like.count({ where: { createdAt: { gte: startDate } } }),
prisma.user.findMany({
orderBy: { followers: { _count: 'desc' } },
take: 10,
select: {
id: true,
username: true,
avatar: true,
_count: { select: { followers: true, posts: true } },
},
}),
prisma.post.findMany({
where: { createdAt: { gte: startDate } },
orderBy: { likesCount: 'desc' },
take: 10,
select: {
id: true,
content: true,
likesCount: true,
commentsCount: true,
user: { select: { username: true } },
},
}),
]);
res.json({
timeframe,
metrics: {
newUsers,
newPosts,
newComments,
newLikes,
engagementRate: newPosts > 0 ? ((newLikes + newComments) / newPosts).toFixed(2) : 0,
},
topUsers,
topPosts,
});
});
// ============================================================================
// AUDIT LOGS
// ============================================================================
interface AuditLogEntry {
adminId: string;
action: string;
targetId: string;
details: Record<string, unknown>;
timestamp: Date;
ipAddress?: string;
}
// In-memory audit log
const auditLog: AuditLogEntry[] = [];
async function logAdminAction(
adminId: string,
action: string,
targetId: string,
details: Record<string, unknown>,
ipAddress?: string
) {
const entry: AuditLogEntry = {
adminId,
action,
targetId,
details,
timestamp: new Date(),
ipAddress,
};
auditLog.unshift(entry);
// Keep only last 1000 entries in memory
if (auditLog.length > 1000) {
auditLog.pop();
}
// Log to file
logger.info(`ADMIN_AUDIT: ${action} by ${adminId} on ${targetId}`, details);
}
/**
* Get audit logs
*/
export const getAuditLogs = asyncHandler(async (req: Request, res: Response) => {
const page = parseInt(req.query.page as string) || 1;
const limit = Math.min(parseInt(req.query.limit as string) || 50, 100);
const adminId = req.query.adminId as string;
const action = req.query.action as string;
let filteredLogs = [...auditLog];
if (adminId) {
filteredLogs = filteredLogs.filter(log => log.adminId === adminId);
}
if (action) {
filteredLogs = filteredLogs.filter(log => log.action === action);
}
const start = (page - 1) * limit;
const paginatedLogs = filteredLogs.slice(start, start + limit);
// Enrich with admin usernames
const adminIds = [...new Set(paginatedLogs.map(log => log.adminId))];
const admins = await prisma.user.findMany({
where: { id: { in: adminIds } },
select: { id: true, username: true },
});
const adminMap = new Map(admins.map(a => [a.id, a.username]));
const enrichedLogs = paginatedLogs.map(log => ({
...log,
adminUsername: adminMap.get(log.adminId) || 'Unknown',
}));
res.json({
logs: enrichedLogs,
pagination: {
page,
limit,
total: filteredLogs.length,
totalPages: Math.ceil(filteredLogs.length / limit),
},
});
});
// ============================================================================
// SYSTEM CONFIGURATION
// ============================================================================
/**
* Get system configuration
*/
export const getSystemConfig = asyncHandler(async (req: Request, res: Response) => {
res.json({
features: {
registrationEnabled: process.env.REGISTRATION_ENABLED !== 'false',
emailVerificationRequired: process.env.EMAIL_VERIFICATION_REQUIRED !== 'false',
twoFactorEnabled: process.env.TWO_FACTOR_ENABLED !== 'false',
maintenanceMode: process.env.MAINTENANCE_MODE === 'true',
},
limits: {
maxPostLength: parseInt(process.env.MAX_POST_LENGTH || '2000'),
maxMediaPerPost: parseInt(process.env.MAX_MEDIA_PER_POST || '10'),
maxFileSize: parseInt(process.env.MAX_FILE_SIZE || '10485760'),
rateLimit: parseInt(process.env.RATE_LIMIT || '100'),
},
integrations: {
githubEnabled: !!process.env.GITHUB_CLIENT_ID,
googleEnabled: !!process.env.GOOGLE_CLIENT_ID,
sentryEnabled: !!process.env.SENTRY_DSN,
resendEnabled: !!process.env.RESEND_API_KEY,
},
});
});
/**
* Update system configuration (runtime only)
*/
export const updateSystemConfig = asyncHandler(async (req: Request, res: Response) => {
const { key, value } = req.body;
const adminId = (req as AuthRequest).user!.id;
const allowedKeys = ['MAINTENANCE_MODE', 'REGISTRATION_ENABLED'];
if (!allowedKeys.includes(key)) {
throw Errors.badRequest('This configuration cannot be updated at runtime');
}
process.env[key] = value;
await logAdminAction(adminId, 'CONFIG_UPDATE', key, { value });
logger.info(`Admin ${adminId} updated config: ${key}=${value}`);
res.json({ message: 'Configuration updated', key, value });
});
// ============================================================================
// BULK ACTIONS
// ============================================================================
/**
* Send announcement to all users
*/
export const sendAnnouncement = asyncHandler(async (req: Request, res: Response) => {
const { title, message } = req.body;
const adminId = (req as AuthRequest).user!.id;
const users = await prisma.user.findMany({
select: { id: true },
});
// Create notifications for all users
await prisma.notification.createMany({
data: users.map(user => ({
userId: user.id,
type: 'MENTION' as const, // Using MENTION as closest type for announcements
content: `[Announcement] ${title}: ${message}`,
})),
});
await logAdminAction(adminId, 'ANNOUNCEMENT_SENT', 'all', { title, userCount: users.length });
logger.info(`Admin ${adminId} sent announcement to ${users.length} users`);
res.json({ message: `Announcement sent to ${users.length} users` });
});
/**
* Bulk invalidate user sessions (soft ban)
*/
export const bulkBanUsers = asyncHandler(async (req: Request, res: Response) => {
const { userIds, reason } = req.body;
const adminId = (req as AuthRequest).user!.id;
if (!Array.isArray(userIds) || userIds.length === 0) {
throw Errors.badRequest('userIds array is required');
}
// Invalidate sessions for all specified users
const result = await prisma.session.deleteMany({
where: { userId: { in: userIds } },
});
await logAdminAction(adminId, 'BULK_BAN', 'multiple', { userIds, reason, sessionsDeleted: result.count });
logger.info(`Admin ${adminId} bulk banned ${userIds.length} users (${result.count} sessions invalidated)`);
res.json({
message: `${userIds.length} users' sessions invalidated`,
sessionsDeleted: result.count,
});
});
/**
* Export data for reporting
*/
export const exportData = asyncHandler(async (req: Request, res: Response) => {
const { type, format = 'json', startDate, endDate } = req.query;
const adminId = (req as AuthRequest).user!.id;
const dateFilter: { gte?: Date; lte?: Date } = {};
if (startDate) dateFilter.gte = new Date(startDate as string);
if (endDate) dateFilter.lte = new Date(endDate as string);
const createdAtFilter = Object.keys(dateFilter).length > 0 ? { createdAt: dateFilter } : {};
let data: Record<string, unknown>[];
switch (type) {
case 'users':
data = await prisma.user.findMany({
where: createdAtFilter,
select: {
id: true,
username: true,
email: true,
createdAt: true,
verified: true,
},
});
break;
case 'posts':
data = await prisma.post.findMany({
where: createdAtFilter,
select: {
id: true,
userId: true,
content: true,
createdAt: true,
likesCount: true,
commentsCount: true,
},
});
break;
default:
throw Errors.badRequest('Invalid export type. Use: users, posts');
}
await logAdminAction(adminId, 'DATA_EXPORT', type as string, { format, count: data.length });
if (format === 'csv') {
const csv = convertToCSV(data);
res.setHeader('Content-Type', 'text/csv');
res.setHeader('Content-Disposition', `attachment; filename=${type}_export.csv`);
return res.send(csv);
}
res.json(data);
});
function convertToCSV(data: Record<string, unknown>[]): string {
if (data.length === 0) return '';
const headers = Object.keys(data[0]);
const rows = data.map(item =>
headers.map(header => {
const value = item[header];
if (value === null || value === undefined) return '';
if (typeof value === 'object') return JSON.stringify(value);
return String(value).includes(',') ? `"${value}"` : value;
}).join(',')
);
return [headers.join(','), ...rows].join('\n');
}
// ============================================================================
// ADMIN PANEL — SUSPEND / UNSUSPEND
// ============================================================================
/**
* Suspend a user account (sets isSuspended = true)
*/
export const suspendUser = asyncHandler(async (req: Request, res: Response) => {
const { userId } = req.params;
const { reason, suspendedUntil } = req.body as {
reason?: string;
suspendedUntil?: string;
};
const adminId = (req as AuthRequest).user!.id;
const user = await prisma.user.findUnique({
where: { id: userId },
select: { id: true, username: true, isSuspended: true },
});
if (!user) {
throw Errors.notFound('User');
}
const updatedUser = await prisma.user.update({
where: { id: userId },
data: {
isSuspended: true,
suspendedReason: reason ?? null,
suspendedUntil: suspendedUntil ? new Date(suspendedUntil) : null,
},
select: {
id: true,
username: true,
isSuspended: true,
suspendedReason: true,
suspendedUntil: true,
},
});
await logAdminAction(adminId, 'USER_SUSPEND', userId, {
reason,
suspendedUntil: suspendedUntil ?? null,
});
logger.info(`Admin ${adminId} suspended user ${userId}`);
res.json({
success: true,
message: `User ${user.username} has been suspended`,
user: updatedUser,
});
});
/**
* Unsuspend a user account (sets isSuspended = false)
*/
export const unsuspendUser = asyncHandler(async (req: Request, res: Response) => {
const { userId } = req.params;
const adminId = (req as AuthRequest).user!.id;
const user = await prisma.user.findUnique({
where: { id: userId },
select: { id: true, username: true, isSuspended: true },
});
if (!user) {
throw Errors.notFound('User');
}
const updatedUser = await prisma.user.update({
where: { id: userId },
data: {
isSuspended: false,
suspendedReason: null,
suspendedUntil: null,
},
select: {
id: true,
username: true,
isSuspended: true,
},
});
await logAdminAction(adminId, 'USER_UNSUSPEND', userId, {});
logger.info(`Admin ${adminId} unsuspended user ${userId}`);
res.json({
success: true,
message: `User ${user.username} has been unsuspended`,
user: updatedUser,
});
});
// ============================================================================
// ADMIN PANEL — PENDING REPORTS
// ============================================================================
/**
* Get pending (unresolved) content reports with reporter and target preview
*/
export const getPendingReports = asyncHandler(async (req: Request, res: Response) => {
const page = parseInt(req.query.page as string) || 1;
const limit = Math.min(parseInt(req.query.limit as string) || 20, 100);
const [reports, total] = await Promise.all([
prisma.report.findMany({
where: { status: 'PENDING' },
orderBy: [{ priority: 'desc' }, { createdAt: 'asc' }],
skip: (page - 1) * limit,
take: limit,
select: {
id: true,
targetType: true,
targetId: true,
reason: true,
description: true,
status: true,
priority: true,
escalated: true,
autoFlagged: true,
createdAt: true,
reporterId: true,
},
}),
prisma.report.count({ where: { status: 'PENDING' } }),
]);
// Collect unique reporter IDs
const reporterIds = [...new Set(reports.map(r => r.reporterId).filter(Boolean))];
const reporters = await prisma.user.findMany({
where: { id: { in: reporterIds } },
select: { id: true, username: true, avatar: true },
});
const reporterMap = new Map(reporters.map(r => [r.id, r]));
const enriched = reports.map(report => ({
...report,
reporter: reporterMap.get(report.reporterId) ?? null,
}));
res.json({
success: true,
data: enriched,
meta: {
total,
page,
limit,
totalPages: Math.ceil(total / limit),
},
});
});
/**
* Resolve a pending report with a specified action
* Actions: 'dismiss' | 'remove_content' | 'suspend_user'
*/
export const resolveReportPanel = asyncHandler(async (req: Request, res: Response) => {
const { reportId } = req.params;
const { action, note } = req.body as {
action: 'dismiss' | 'remove_content' | 'suspend_user';
note?: string;
};
const adminId = (req as AuthRequest).user!.id;
const validActions = ['dismiss', 'remove_content', 'suspend_user'] as const;
if (!validActions.includes(action)) {
throw Errors.badRequest(
`Invalid action. Valid actions: ${validActions.join(', ')}`
);
}
const report = await prisma.report.findUnique({
where: { id: reportId },
select: {
id: true,
status: true,
targetType: true,
targetId: true,
reporterId: true,
},
});
if (!report) {
throw Errors.notFound('Report');
}
if (report.status !== 'PENDING') {
throw Errors.badRequest('Report is already resolved');
}
let actionResult = 'Report dismissed';
if (action === 'remove_content') {
// Attempt to delete the target content based on type
try {
switch (report.targetType) {
case 'POST':
await prisma.post.delete({ where: { id: report.targetId } });
break;
case 'REEL':
await prisma.reel.delete({ where: { id: report.targetId } });
break;
case 'COMMENT':
await prisma.comment.delete({ where: { id: report.targetId } });
break;
default:
break;
}
actionResult = `Content (${report.targetType}:${report.targetId}) removed`;
} catch {
actionResult = 'Content not found or already removed';
}
} else if (action === 'suspend_user') {
// Find the owner of the reported content
let ownerId: string | null = null;
try {
switch (report.targetType) {
case 'POST': {
const post = await prisma.post.findUnique({
where: { id: report.targetId },
select: { userId: true },
});
ownerId = post?.userId ?? null;
break;
}
case 'REEL': {
const reel = await prisma.reel.findUnique({
where: { id: report.targetId },
select: { userId: true },
});
ownerId = reel?.userId ?? null;
break;
}
case 'COMMENT': {
const comment = await prisma.comment.findUnique({
where: { id: report.targetId },
select: { userId: true },
});
ownerId = comment?.userId ?? null;
break;
}
default:
break;
}
} catch {
// Content may not exist
}
if (ownerId) {
await prisma.user.update({
where: { id: ownerId },
data: {
isSuspended: true,
suspendedReason: `Suspended via report resolution (reportId: ${reportId})`,
},
});
actionResult = `User ${ownerId} suspended`;
} else {
actionResult = 'Target user not found — no suspension applied';
}
}
// Mark report resolved
await prisma.report.update({
where: { id: reportId },
data: {
status: 'RESOLVED',
resolvedBy: adminId,
resolvedAt: new Date(),
resolution: note ?? action,
},
});
await logAdminAction(adminId, 'REPORT_RESOLVE_PANEL', reportId, {
action,
note,
targetType: report.targetType,
targetId: report.targetId,
result: actionResult,
});
res.json({
success: true,
message: 'Report resolved',
action,
result: actionResult,
});
});
/**
* Get recent admin audit log entries (panel-facing, paginated)
*/
export const getAuditLog = asyncHandler(async (req: Request, res: Response) => {
const page = parseInt(req.query.page as string) || 1;
const limit = Math.min(parseInt(req.query.limit as string) || 50, 200);
const filterAdminId = req.query.adminId as string | undefined;
const filterAction = req.query.action as string | undefined;
let filteredLogs = [...auditLog];
if (filterAdminId) {
filteredLogs = filteredLogs.filter(entry => entry.adminId === filterAdminId);
}
if (filterAction) {
filteredLogs = filteredLogs.filter(entry => entry.action === filterAction);
}
const start = (page - 1) * limit;
const paginated = filteredLogs.slice(start, start + limit);
const adminIds = [...new Set(paginated.map(entry => entry.adminId))];
const admins = await prisma.user.findMany({
where: { id: { in: adminIds } },
select: { id: true, username: true },
});
const adminMap = new Map(admins.map(a => [a.id, a.username]));
const enriched = paginated.map(entry => ({
...entry,
adminUsername: adminMap.get(entry.adminId) ?? 'Unknown',
}));
res.json({
success: true,
data: enriched,
meta: {
total: filteredLogs.length,
page,
limit,
totalPages: Math.ceil(filteredLogs.length / limit),
},
});
});