initial commit

fluxer_api/src/admin/services/AdminReportService.ts

@@ -0,0 +1,301 @@
+/*
+ * Copyright (C) 2026 Fluxer Contributors
+ *
+ * This file is part of Fluxer.
+ *
+ * Fluxer is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Fluxer is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with Fluxer. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import type {ChannelID, ReportID, UserID} from '~/BrandedTypes';
+import {createReportID} from '~/BrandedTypes';
+import {Config} from '~/Config';
+import {makeAttachmentCdnKey} from '~/channel/services/message/MessageHelpers';
+import type {MessageAttachment} from '~/database/types/MessageTypes';
+import type {IEmailService} from '~/infrastructure/IEmailService';
+import type {IStorageService} from '~/infrastructure/IStorageService';
+import type {UserCacheService} from '~/infrastructure/UserCacheService';
+import {Logger} from '~/Logger';
+import {getReportSearchService} from '~/Meilisearch';
+import type {RequestCache} from '~/middleware/RequestCacheMiddleware';
+import {createRequestCache} from '~/middleware/RequestCacheMiddleware';
+import type {IARMessageContext, IARSubmission} from '~/report/IReportRepository';
+import type {ReportService} from '~/report/ReportService';
+import type {IUserRepository} from '~/user/IUserRepository';
+import type {SearchReportsRequest} from '../AdminModel';
+import type {AdminAuditService} from './AdminAuditService';
+
+interface AdminReportServiceDeps {
+	reportService: ReportService;
+	userRepository: IUserRepository;
+	emailService: IEmailService;
+	storageService: IStorageService;
+	auditService: AdminAuditService;
+	userCacheService: UserCacheService;
+}
+
+export class AdminReportService {
+	constructor(private readonly deps: AdminReportServiceDeps) {}
+
+	async listReports(status: number, limit?: number, offset?: number) {
+		const {reportService} = this.deps;
+		const requestedLimit = limit || 50;
+		const currentOffset = offset || 0;
+
+		const reports = await reportService.listReportsByStatus(status, requestedLimit, currentOffset);
+		const requestCache = createRequestCache();
+		const reportResponses = await Promise.all(
+			reports.map((report: IARSubmission) => this.mapReportToResponse(report, false, requestCache)),
+		);
+
+		return {
+			reports: reportResponses,
+		};
+	}
+
+	async getReport(reportId: ReportID) {
+		const {reportService} = this.deps;
+		const report = await reportService.getReport(reportId);
+		const requestCache = createRequestCache();
+		return this.mapReportToResponse(report, true, requestCache);
+	}
+
+	async resolveReport(
+		reportId: ReportID,
+		adminUserId: UserID,
+		publicComment: string | null,
+		auditLogReason: string | null,
+	) {
+		const {reportService, userRepository, emailService, auditService} = this.deps;
+		const resolvedReport = await reportService.resolveReport(reportId, adminUserId, publicComment, auditLogReason);
+
+		await auditService.createAuditLog({
+			adminUserId,
+			targetType: 'report',
+			targetId: BigInt(reportId),
+			action: 'resolve_report',
+			auditLogReason,
+			metadata: new Map([
+				['report_id', reportId.toString()],
+				['report_type', resolvedReport.reportType.toString()],
+			]),
+		});
+
+		if (resolvedReport.reporterId && publicComment) {
+			const reporter = await userRepository.findUnique(resolvedReport.reporterId);
+			if (reporter?.email) {
+				await emailService.sendReportResolvedEmail(
+					reporter.email,
+					reporter.username,
+					reportId.toString(),
+					publicComment,
+					reporter.locale,
+				);
+			}
+		}
+
+		return {
+			report_id: resolvedReport.reportId.toString(),
+			status: resolvedReport.status,
+			resolved_at: resolvedReport.resolvedAt?.toISOString() ?? null,
+			public_comment: resolvedReport.publicComment,
+		};
+	}
+
+	async searchReports(data: SearchReportsRequest) {
+		const reportSearchService = getReportSearchService();
+		if (!reportSearchService) {
+			throw new Error('Search is not enabled');
+		}
+
+		const filters: Record<string, string | number> = {};
+		if (data.reporter_id !== undefined) {
+			filters.reporterId = data.reporter_id.toString();
+		}
+		if (data.status !== undefined) {
+			filters.status = data.status;
+		}
+		if (data.report_type !== undefined) {
+			filters.reportType = data.report_type;
+		}
+		if (data.category !== undefined) {
+			filters.category = data.category;
+		}
+		if (data.reported_user_id !== undefined) {
+			filters.reportedUserId = data.reported_user_id.toString();
+		}
+		if (data.reported_guild_id !== undefined) {
+			filters.reportedGuildId = data.reported_guild_id.toString();
+		}
+		if (data.reported_channel_id !== undefined) {
+			filters.reportedChannelId = data.reported_channel_id.toString();
+		}
+		if (data.guild_context_id !== undefined) {
+			filters.guildContextId = data.guild_context_id.toString();
+		}
+		if (data.resolved_by_admin_id !== undefined) {
+			filters.resolvedByAdminId = data.resolved_by_admin_id.toString();
+		}
+		if (data.sort_by) {
+			filters.sortBy = data.sort_by;
+		}
+		if (data.sort_order) {
+			filters.sortOrder = data.sort_order;
+		}
+
+		const {hits, total} = await reportSearchService.searchReports(data.query || '', filters, {
+			limit: data.limit,
+			offset: data.offset,
+		});
+
+		const requestCache = createRequestCache();
+		const reports = await Promise.all(
+			hits.map(async (hit) => {
+				const report = await this.deps.reportService.getReport(createReportID(BigInt(hit.id)));
+				return this.mapReportToResponse(report, false, requestCache);
+			}),
+		);
+
+		return {
+			reports,
+			total,
+			offset: data.offset,
+			limit: data.limit,
+		};
+	}
+
+	private async mapReportToResponse(report: IARSubmission, includeContext: boolean, requestCache: RequestCache) {
+		const reporterInfo = await this.buildUserTag(report.reporterId, requestCache);
+		const reportedUserInfo = await this.buildUserTag(report.reportedUserId, requestCache);
+
+		const baseResponse = {
+			report_id: report.reportId.toString(),
+			reporter_id: report.reporterId?.toString() ?? null,
+			reporter_tag: reporterInfo?.tag ?? null,
+			reporter_username: reporterInfo?.username ?? null,
+			reporter_discriminator: reporterInfo?.discriminator ?? null,
+			reporter_email: report.reporterEmail,
+			reporter_full_legal_name: report.reporterFullLegalName,
+			reporter_country_of_residence: report.reporterCountryOfResidence,
+			reported_at: report.reportedAt.toISOString(),
+			status: report.status,
+			report_type: report.reportType,
+			category: report.category,
+			additional_info: report.additionalInfo,
+			reported_user_id: report.reportedUserId?.toString() ?? null,
+			reported_user_tag: reportedUserInfo?.tag ?? null,
+			reported_user_username: reportedUserInfo?.username ?? null,
+			reported_user_discriminator: reportedUserInfo?.discriminator ?? null,
+			reported_user_avatar_hash: report.reportedUserAvatarHash,
+			reported_guild_id: report.reportedGuildId?.toString() ?? null,
+			reported_guild_name: report.reportedGuildName,
+			reported_message_id: report.reportedMessageId?.toString() ?? null,
+			reported_channel_id: report.reportedChannelId?.toString() ?? null,
+			reported_channel_name: report.reportedChannelName,
+			reported_guild_invite_code: report.reportedGuildInviteCode,
+			resolved_at: report.resolvedAt?.toISOString() ?? null,
+			resolved_by_admin_id: report.resolvedByAdminId?.toString() ?? null,
+			public_comment: report.publicComment,
+		};
+
+		if (!includeContext) {
+			return baseResponse;
+		}
+
+		const messageContext =
+			report.messageContext && report.messageContext.length > 0
+				? await Promise.all(
+						report.messageContext.map((message) =>
+							this.mapReportMessageContextToResponse(message, report.reportedChannelId ?? null),
+						),
+					)
+				: [];
+
+		return {
+			...baseResponse,
+			message_context: messageContext,
+		};
+	}
+
+	private async mapReportMessageContextToResponse(message: IARMessageContext, fallbackChannelId: ChannelID | null) {
+		const channelId = message.channelId ?? fallbackChannelId;
+		const attachments =
+			message.attachments && message.attachments.length > 0
+				? (
+						await Promise.all(
+							message.attachments.map((attachment) => this.mapReportAttachmentToResponse(attachment, channelId)),
+						)
+					).filter((attachment): attachment is {filename: string; url: string} => attachment !== null)
+				: [];
+
+		return {
+			id: message.messageId.toString(),
+			channel_id: channelId ? channelId.toString() : '',
+			content: message.content ?? '',
+			timestamp: message.timestamp.toISOString(),
+			attachments,
+			author_id: message.authorId.toString(),
+			author_username: message.authorUsername,
+		};
+	}
+
+	private async mapReportAttachmentToResponse(
+		attachment: MessageAttachment,
+		channelId: ChannelID | null,
+	): Promise<{filename: string; url: string} | null> {
+		if (!attachment || attachment.attachment_id == null || !attachment.filename || !channelId) {
+			return null;
+		}
+
+		const {storageService} = this.deps;
+		const attachmentId = attachment.attachment_id;
+		const filename = String(attachment.filename);
+		const key = makeAttachmentCdnKey(channelId, attachmentId, filename);
+
+		try {
+			const url = await storageService.getPresignedDownloadURL({
+				bucket: Config.s3.buckets.reports,
+				key,
+				expiresIn: 300,
+			});
+			return {filename, url};
+		} catch (error) {
+			Logger.error(
+				{error, attachmentId, filename, channelId},
+				'Failed to generate presigned URL for report attachment',
+			);
+		}
+		return null;
+	}
+
+	private async buildUserTag(userId: UserID | null, requestCache: RequestCache): Promise<UserTagInfo | null> {
+		if (!userId) {
+			return null;
+		}
+
+		try {
+			const user = await this.deps.userCacheService.getUserPartialResponse(userId, requestCache);
+			const discriminator = user.discriminator?.padStart(4, '0') ?? '0000';
+			return {tag: `${user.username}#${discriminator}`, username: user.username, discriminator};
+		} catch (error) {
+			Logger.warn({userId: userId.toString(), error}, 'Failed to resolve user tag for report');
+			return null;
+		}
+	}
+}
+
+interface UserTagInfo {
+	tag: string;
+	username: string;
+	discriminator: string;
+}