Skip to content

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

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

import type {GuildID, UserID, WebhookID} from '@app/api/BrandedTypes';
import {
	channelToContentWarningView,
	computeEffectiveChannelNsfw,
	guildResponseToContentWarningView,
} from '@app/api/channel/utils/EffectiveContentWarning';
import type {GuildRepository} from '@app/api/guild/repositories/GuildRepository';
import type {MediaProxyNsfwMode} from '@app/api/infrastructure/IMediaService';
import type {LimitConfigService} from '@app/api/limits/LimitConfigService';
import type {Channel} from '@app/api/models/Channel';
import type {UserRepository} from '@app/api/user/repositories/UserRepository';
import * as EmojiUtils from '@app/api/utils/EmojiUtils';
import {ChannelTypes, GUILD_TEXT_BASED_CHANNEL_TYPES} from '@fluxer/constants/src/ChannelConstants';
import {GuildExplicitContentFilterTypes, GuildFeatures, GuildNSFWLevel} from '@fluxer/constants/src/GuildConstants';
import {THREAD_ONLY_CHANNEL_TYPES} from '@fluxer/constants/src/ThreadConstants';
import {RelationshipTypes, SensitiveMediaFilterLevel} from '@fluxer/constants/src/UserConstants';
import type {GuildMemberResponse} from '@fluxer/schema/src/domains/guild/GuildMemberSchemas';
import type {GuildResponse} from '@fluxer/schema/src/domains/guild/GuildResponseSchemas';

export interface DmNsfwContext {
	senderFilterLevel: number;
	recipientFilterLevel: number;
}

interface NsfwScope {
	channel?: Channel;
	parentCategory?: Channel | null;
	guild?: GuildResponse | null;
	member?: GuildMemberResponse | null;
	isBot?: boolean;
	dmNsfwContext?: DmNsfwContext;
}

function isGuildMessageChannel(channel: Channel): boolean {
	return GUILD_TEXT_BASED_CHANNEL_TYPES.has(channel.type) || THREAD_ONLY_CHANNEL_TYPES.has(channel.type);
}

export class MessageContentService {
	constructor(
		private userRepository: UserRepository,
		private guildRepository: GuildRepository,
		private limitConfigService: LimitConfigService,
	) {}

	async sanitizeCustomEmojis(params: {
		content: string;
		userId: UserID | null;
		webhookId: WebhookID | null;
		guildId: GuildID | null;
		hasPermission?: (permission: bigint) => Promise<boolean>;
	}): Promise<string> {
		return await EmojiUtils.sanitizeCustomEmojis({
			...params,
			userRepository: this.userRepository,
			guildRepository: this.guildRepository,
			limitConfigService: this.limitConfigService,
		});
	}

	async resolveDmNsfwContext(channel: Channel, senderId: UserID): Promise<DmNsfwContext | undefined> {
		if (channel.type !== ChannelTypes.DM) {
			return undefined;
		}
		const recipientIds = Array.from(channel.recipientIds).filter((id) => id !== senderId);
		if (recipientIds.length !== 1) {
			return undefined;
		}
		const recipientId = recipientIds[0];
		const [senderSettings, recipientSettings, friendship] = await Promise.all([
			this.userRepository.findSettings(senderId),
			this.userRepository.findSettings(recipientId),
			this.userRepository.getRelationship(senderId, recipientId, RelationshipTypes.FRIEND),
		]);
		const areFriends = friendship != null;
		const senderFilterLevel = areFriends
			? (senderSettings?.sensitiveContentFriendDmFilter ?? SensitiveMediaFilterLevel.SHOW)
			: (senderSettings?.sensitiveContentNonFriendDmFilter ?? SensitiveMediaFilterLevel.BLOCK);
		const recipientFilterLevel = areFriends
			? (recipientSettings?.sensitiveContentFriendDmFilter ?? SensitiveMediaFilterLevel.SHOW)
			: (recipientSettings?.sensitiveContentNonFriendDmFilter ?? SensitiveMediaFilterLevel.BLOCK);
		return {senderFilterLevel, recipientFilterLevel};
	}

	isNSFWContentAllowed(params: NsfwScope): boolean {
		const {guild, member, isBot, dmNsfwContext} = params;
		if (isBot || this.isMatureContext(params)) {
			return true;
		}
		if (!guild) {
			if (dmNsfwContext) {
				const eitherBlocks =
					dmNsfwContext.senderFilterLevel === SensitiveMediaFilterLevel.BLOCK ||
					dmNsfwContext.recipientFilterLevel === SensitiveMediaFilterLevel.BLOCK;
				return !eitherBlocks;
			}
			return false;
		}
		const features = new Set(guild.features ?? []);
		if (features.has(GuildFeatures.DISCOVERABLE)) {
			return false;
		}
		const explicitContentFilter = guild.explicit_content_filter;
		if (explicitContentFilter === GuildExplicitContentFilterTypes.DISABLED) {
			return true;
		}
		if (explicitContentFilter === GuildExplicitContentFilterTypes.MEMBERS_WITHOUT_ROLES) {
			const hasRoles = member && member.roles.length > 0;
			return !!hasRoles;
		}
		return false;
	}

	attachmentNsfwMode(params: NsfwScope): MediaProxyNsfwMode {
		if (!this.isNSFWContentAllowed(params)) {
			return 'block';
		}
		return this.skipsMediaScan(params) ? 'allow' : 'flag';
	}

	skipsMediaScan(params: NsfwScope): boolean {
		if (!this.isMatureContext(params)) {
			return false;
		}
		const {channel, parentCategory, guild} = params;
		if (!channel || !guild || !isGuildMessageChannel(channel)) {
			return true;
		}
		return computeEffectiveChannelNsfw(
			channelToContentWarningView(channel),
			parentCategory ? channelToContentWarningView(parentCategory) : null,
			guildResponseToContentWarningView(guild),
		);
	}

	isMatureContext({channel, guild}: NsfwScope): boolean {
		if (channel && isGuildMessageChannel(channel) && channel.isNsfw) {
			return true;
		}
		if (channel?.type === ChannelTypes.DM_PERSONAL_NOTES) {
			return true;
		}
		if (channel?.type === ChannelTypes.GROUP_DM && channel.isNsfw) {
			return true;
		}
		return guild?.nsfw_level === GuildNSFWLevel.AGE_RESTRICTED;
	}
}