Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp
3.8 KB
Raw Blame
// SPDX-License-Identifier: AGPL-3.0-or-later

import type {GuildID, UserID} from '@app/api/BrandedTypes';
import {mapGuildRoleToResponse, mapGuildToGuildResponse} from '@app/api/guild/GuildModel';
import type {GuildDiscoveryRepository} from '@app/api/guild/repositories/GuildDiscoveryRepository';
import type {IGatewayService} from '@app/api/infrastructure/IGatewayService';
import {Logger} from '@app/api/Logger';
import type {Guild} from '@app/api/models/Guild';
import type {GuildRole} from '@app/api/models/GuildRole';
import {getGuildSearchService} from '@app/api/SearchFactory';
import type {GuildDiscoveryContext} from '@app/api/search/guild/GuildSearchSerializer';
import {DiscoveryApplicationStatus} from '@fluxer/constants/src/DiscoveryConstants';
import {GuildFeatures} from '@fluxer/constants/src/GuildConstants';

interface AdminGuildUpdatePropagatorDeps {
	gatewayService: IGatewayService;
	discoveryRepository: GuildDiscoveryRepository;
}

interface AdminGuildUpdateDispatchOptions {
	adminUserId?: UserID;
	reconcileDiscoveryFeature?: boolean;
}

export class AdminGuildUpdatePropagator {
	constructor(private readonly deps: AdminGuildUpdatePropagatorDeps) {}

	async dispatchGuildRoleUpdate(guildId: GuildID, role: GuildRole): Promise<void> {
		await this.deps.gatewayService.dispatchGuild({
			guildId,
			event: 'GUILD_ROLE_UPDATE',
			data: {role: mapGuildRoleToResponse(role)},
		});
	}

	async dispatchGuildUpdate(
		guildId: GuildID,
		updatedGuild: Guild,
		options: AdminGuildUpdateDispatchOptions = {},
	): Promise<void> {
		const {gatewayService, discoveryRepository} = this.deps;
		await gatewayService.dispatchGuild({
			guildId,
			event: 'GUILD_UPDATE',
			data: mapGuildToGuildResponse(updatedGuild),
		});
		let discoveryRow =
			options.reconcileDiscoveryFeature || updatedGuild.features.has(GuildFeatures.DISCOVERABLE)
				? await discoveryRepository.findByGuildId(guildId).catch(() => null)
				: null;
		if (options.reconcileDiscoveryFeature && discoveryRow) {
			const hasDiscoverable = updatedGuild.features.has(GuildFeatures.DISCOVERABLE);
			const shouldApprove = hasDiscoverable && discoveryRow.status !== DiscoveryApplicationStatus.APPROVED;
			const shouldRemove = !hasDiscoverable && discoveryRow.status === DiscoveryApplicationStatus.APPROVED;
			if (shouldApprove || shouldRemove) {
				const now = new Date();
				const updatedRow = shouldApprove
					? {
							...discoveryRow,
							status: DiscoveryApplicationStatus.APPROVED,
							reviewed_at: discoveryRow.reviewed_at ?? now,
							reviewed_by: discoveryRow.reviewed_by ?? options.adminUserId ?? null,
							review_reason: discoveryRow.review_reason ?? 'DISCOVERABLE feature enabled by admin',
							removed_at: null,
							removed_by: null,
							removal_reason: null,
						}
					: {
							...discoveryRow,
							status: DiscoveryApplicationStatus.REMOVED,
							removed_at: now,
							removed_by: options.adminUserId ?? null,
							removal_reason: 'Guild no longer has DISCOVERABLE feature',
						};
				await discoveryRepository.updateStatus(guildId, discoveryRow.status, discoveryRow.applied_at, updatedRow);
				discoveryRow = updatedRow;
			}
		}
		const guildSearchService = getGuildSearchService();
		if (guildSearchService) {
			let discoveryContext: GuildDiscoveryContext | undefined;
			if (updatedGuild.features.has(GuildFeatures.DISCOVERABLE)) {
				if (discoveryRow?.status === DiscoveryApplicationStatus.APPROVED) {
					discoveryContext = {
						description: discoveryRow.description,
						categoryId: discoveryRow.category_type,
						primaryLanguage: discoveryRow.primary_language ?? null,
						tags: discoveryRow.custom_tags ?? [],
					};
				}
			}
			await guildSearchService.updateGuild(updatedGuild, discoveryContext).catch((error) => {
				Logger.error({guildId, error}, 'Failed to update guild in search after admin update');
			});
		}
	}
}