A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
// SPDX-License-Identifier: AGPL-3.0-or-later
import type {AdminAuditService} from '@app/api/admin/services/AdminAuditService';
import {createGuildID, type GuildID, type UserID} from '@app/api/BrandedTypes';
import type {EnforcementActor} from '@app/api/enforcement/EnforcementActor';
import {decisionAuditMetadata, type EnforcementDecisionService} from '@app/api/enforcement/EnforcementDecisionService';
import type {GuildRepository} from '@app/api/guild/repositories/GuildRepository';
import type {GuildService} from '@app/api/guild/services/GuildService';
import type {IGatewayService} from '@app/api/infrastructure/IGatewayService';
import {UnknownGuildError} from '@fluxer/errors/src/domains/guild/UnknownGuildError';
import type {AdminGuildDeleteRequest} from '@fluxer/schema/src/domains/admin/AdminGuildSchemas';
import type {SuccessResponse} from '@fluxer/schema/src/domains/common/CommonParamSchemas';
interface AdminGuildManagementServiceDeps {
guildRepository: GuildRepository;
gatewayService: IGatewayService;
guildService: GuildService;
auditService: AdminAuditService;
enforcement: EnforcementDecisionService;
}
export class AdminGuildManagementService {
constructor(private readonly deps: AdminGuildManagementServiceDeps) {}
async reloadGuild(guildIdRaw: bigint, adminUserId: UserID, auditLogReason: string | null): Promise<SuccessResponse> {
const {guildRepository, gatewayService, auditService} = this.deps;
const guildId = createGuildID(guildIdRaw);
const guild = await guildRepository.findUnique(guildId);
if (!guild) {
throw new UnknownGuildError();
}
await gatewayService.reloadGuild(guildId);
await auditService.createAuditLog({
adminUserId,
targetType: 'guild',
targetId: guildIdRaw,
action: 'reload_guild',
auditLogReason,
metadata: new Map([['guild_id', guildIdRaw.toString()]]),
});
return {success: true};
}
async shutdownGuild(
guildIdRaw: bigint,
adminUserId: UserID,
auditLogReason: string | null,
): Promise<SuccessResponse> {
const {guildRepository, gatewayService, auditService} = this.deps;
const guildId = createGuildID(guildIdRaw);
const guild = await guildRepository.findUnique(guildId);
if (!guild) {
throw new UnknownGuildError();
}
await gatewayService.shutdownGuild(guildId);
await auditService.createAuditLog({
adminUserId,
targetType: 'guild',
targetId: guildIdRaw,
action: 'shutdown_guild',
auditLogReason,
metadata: new Map([['guild_id', guildIdRaw.toString()]]),
});
return {success: true};
}
async deleteGuild(
guildId: GuildID,
{basis}: AdminGuildDeleteRequest,
actor: EnforcementActor,
): Promise<SuccessResponse> {
const {guildRepository, guildService, auditService, enforcement} = this.deps;
const guild = await guildRepository.findUnique(guildId);
if (!guild) {
throw new UnknownGuildError();
}
const remove = () => guildService.data.operations.deleteGuildById(guildId);
const decision =
basis.type === 'enforcement'
? (
await enforcement.record(
{subject: {type: 'guild', guild}, kind: 'community_removal', input: basis.decision, actor},
remove,
)
).decision
: await remove().then(() => null);
await auditService.createAuditLog({
adminUserId: actor.adminUserId,
targetType: 'guild',
targetId: guildId,
action: 'delete_guild',
auditLogReason: actor.internalNote,
metadata: new Map([
['guild_id', guildId.toString()],
['basis', basis.type],
...(decision ? decisionAuditMetadata(decision) : []),
]),
});
return {success: true};
}
async getGuildMemoryStats(limit: number) {
const {gatewayService, guildRepository} = this.deps;
const memoryStats = await gatewayService.getGuildMemoryStats(limit);
const guildIds = memoryStats.guilds
.map((guild) => guild.guild_id)
.filter((guildId): guildId is string => guildId !== null)
.map((guildId) => createGuildID(BigInt(guildId)));
const guilds = await guildRepository.listGuilds(guildIds);
const guildNsfwLevels = new Map(guilds.map((guild) => [guild.id.toString(), guild.nsfwLevel]));
return {
guilds: memoryStats.guilds.map((guild) => ({
...guild,
nsfw_level: guild.guild_id ? (guildNsfwLevels.get(guild.guild_id) ?? null) : null,
})),
};
}
async reloadAllGuilds(guildIds: Array<GuildID>) {
const {gatewayService} = this.deps;
return gatewayService.reloadAllGuilds(guildIds);
}
async getNodeStats() {
const {gatewayService} = this.deps;
return gatewayService.getNodeStats();
}
async getVoiceStateCounts() {
const {gatewayService} = this.deps;
return gatewayService.getVoiceStateCounts();
}
}