340 lines
14 KiB
TypeScript
340 lines
14 KiB
TypeScript
/*
|
|
* 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, createChannelID, createGuildID, type GuildID, type UserID} from '@fluxer/api/src/BrandedTypes';
|
|
import type {ChannelOverride, UserGuildSettingsRow} from '@fluxer/api/src/database/types/UserTypes';
|
|
import type {IGuildRepositoryAggregate} from '@fluxer/api/src/guild/repositories/IGuildRepositoryAggregate';
|
|
import {getMetricsService} from '@fluxer/api/src/infrastructure/MetricsService';
|
|
import type {LimitConfigService} from '@fluxer/api/src/limits/LimitConfigService';
|
|
import type {UserGuildSettings} from '@fluxer/api/src/models/UserGuildSettings';
|
|
import type {UserSettings} from '@fluxer/api/src/models/UserSettings';
|
|
import type {PackService} from '@fluxer/api/src/pack/PackService';
|
|
import type {IUserAccountRepository} from '@fluxer/api/src/user/repositories/IUserAccountRepository';
|
|
import type {IUserSettingsRepository} from '@fluxer/api/src/user/repositories/IUserSettingsRepository';
|
|
import {CustomStatusValidator} from '@fluxer/api/src/user/services/CustomStatusValidator';
|
|
import type {UserAccountUpdatePropagator} from '@fluxer/api/src/user/services/UserAccountUpdatePropagator';
|
|
import {
|
|
DEFAULT_GUILD_FOLDER_ICON,
|
|
FriendSourceFlags,
|
|
GroupDmAddPermissionFlags,
|
|
IncomingCallFlags,
|
|
UNCATEGORIZED_FOLDER_ID,
|
|
UserNotificationSettings,
|
|
} from '@fluxer/constants/src/UserConstants';
|
|
import {UnknownUserError} from '@fluxer/errors/src/domains/user/UnknownUserError';
|
|
import {ValidationError} from '@fluxer/errors/src/ValidationError';
|
|
import type {
|
|
UserGuildSettingsUpdateRequest,
|
|
UserSettingsUpdateRequest,
|
|
} from '@fluxer/schema/src/domains/user/UserRequestSchemas';
|
|
|
|
interface UserAccountSettingsServiceDeps {
|
|
userAccountRepository: IUserAccountRepository;
|
|
userSettingsRepository: IUserSettingsRepository;
|
|
updatePropagator: UserAccountUpdatePropagator;
|
|
guildRepository: IGuildRepositoryAggregate;
|
|
packService: PackService;
|
|
limitConfigService: LimitConfigService;
|
|
}
|
|
|
|
export class UserAccountSettingsService {
|
|
private readonly customStatusValidator: CustomStatusValidator;
|
|
|
|
constructor(private readonly deps: UserAccountSettingsServiceDeps) {
|
|
this.customStatusValidator = new CustomStatusValidator(
|
|
this.deps.userAccountRepository,
|
|
this.deps.guildRepository,
|
|
this.deps.packService,
|
|
this.deps.limitConfigService,
|
|
);
|
|
}
|
|
|
|
async findSettings(userId: UserID): Promise<UserSettings> {
|
|
const userSettings = await this.deps.userSettingsRepository.findSettings(userId);
|
|
if (!userSettings) throw new UnknownUserError();
|
|
return userSettings;
|
|
}
|
|
|
|
async updateSettings(params: {userId: UserID; data: UserSettingsUpdateRequest}): Promise<UserSettings> {
|
|
const {userId, data} = params;
|
|
const currentSettings = await this.deps.userSettingsRepository.findSettings(userId);
|
|
if (!currentSettings) {
|
|
throw new UnknownUserError();
|
|
}
|
|
|
|
const updatedRowData = {...currentSettings.toRow(), user_id: userId};
|
|
const localeChanged = data.locale !== undefined && data.locale !== currentSettings.locale;
|
|
|
|
if (data.status !== undefined) updatedRowData.status = data.status;
|
|
if (data.status_resets_at !== undefined) updatedRowData.status_resets_at = data.status_resets_at;
|
|
if (data.status_resets_to !== undefined) updatedRowData.status_resets_to = data.status_resets_to;
|
|
if (data.theme !== undefined) {
|
|
if (data.theme !== currentSettings.theme) {
|
|
getMetricsService().counter({
|
|
name: 'fluxer.users.theme_changed',
|
|
dimensions: {
|
|
new_theme: data.theme,
|
|
old_theme: currentSettings.theme,
|
|
},
|
|
});
|
|
}
|
|
updatedRowData.theme = data.theme;
|
|
}
|
|
if (data.locale !== undefined) updatedRowData.locale = data.locale;
|
|
if (data.custom_status !== undefined) {
|
|
if (data.custom_status === null) {
|
|
updatedRowData.custom_status = null;
|
|
} else {
|
|
const validated = await this.customStatusValidator.validate(userId, data.custom_status);
|
|
updatedRowData.custom_status = {
|
|
text: validated.text,
|
|
expires_at: validated.expiresAt,
|
|
emoji_id: validated.emojiId,
|
|
emoji_name: validated.emojiName,
|
|
emoji_animated: validated.emojiAnimated,
|
|
};
|
|
}
|
|
}
|
|
if (data.flags !== undefined) updatedRowData.friend_source_flags = data.flags;
|
|
if (data.restricted_guilds !== undefined) {
|
|
updatedRowData.restricted_guilds = data.restricted_guilds
|
|
? new Set(data.restricted_guilds.map(createGuildID))
|
|
: null;
|
|
}
|
|
if (data.bot_restricted_guilds !== undefined) {
|
|
updatedRowData.bot_restricted_guilds = data.bot_restricted_guilds
|
|
? new Set(data.bot_restricted_guilds.map(createGuildID))
|
|
: null;
|
|
}
|
|
if (data.default_guilds_restricted !== undefined) {
|
|
updatedRowData.default_guilds_restricted = data.default_guilds_restricted;
|
|
}
|
|
if (data.bot_default_guilds_restricted !== undefined) {
|
|
updatedRowData.bot_default_guilds_restricted = data.bot_default_guilds_restricted;
|
|
}
|
|
if (data.inline_attachment_media !== undefined) {
|
|
updatedRowData.inline_attachment_media = data.inline_attachment_media;
|
|
}
|
|
if (data.inline_embed_media !== undefined) updatedRowData.inline_embed_media = data.inline_embed_media;
|
|
if (data.gif_auto_play !== undefined) updatedRowData.gif_auto_play = data.gif_auto_play;
|
|
if (data.render_embeds !== undefined) updatedRowData.render_embeds = data.render_embeds;
|
|
if (data.render_reactions !== undefined) updatedRowData.render_reactions = data.render_reactions;
|
|
if (data.animate_emoji !== undefined) updatedRowData.animate_emoji = data.animate_emoji;
|
|
if (data.animate_stickers !== undefined) updatedRowData.animate_stickers = data.animate_stickers;
|
|
if (data.render_spoilers !== undefined) updatedRowData.render_spoilers = data.render_spoilers;
|
|
if (data.message_display_compact !== undefined) {
|
|
updatedRowData.message_display_compact = data.message_display_compact;
|
|
}
|
|
if (data.friend_source_flags !== undefined) {
|
|
updatedRowData.friend_source_flags = this.normalizeFriendSourceFlags(data.friend_source_flags);
|
|
}
|
|
if (data.incoming_call_flags !== undefined) {
|
|
updatedRowData.incoming_call_flags = this.normalizeIncomingCallFlags(data.incoming_call_flags);
|
|
}
|
|
if (data.group_dm_add_permission_flags !== undefined) {
|
|
updatedRowData.group_dm_add_permission_flags = this.normalizeGroupDmAddPermissionFlags(
|
|
data.group_dm_add_permission_flags,
|
|
);
|
|
}
|
|
if (data.guild_folders !== undefined) {
|
|
const mappedFolders = data.guild_folders.map((folder) => ({
|
|
folder_id: folder.id,
|
|
name: folder.name ?? null,
|
|
color: folder.color ?? 0x000000,
|
|
flags: folder.flags ?? 0,
|
|
icon: folder.icon ?? DEFAULT_GUILD_FOLDER_ICON,
|
|
guild_ids: folder.guild_ids.map(createGuildID),
|
|
}));
|
|
const hasUncategorized = mappedFolders.some((folder) => folder.folder_id === UNCATEGORIZED_FOLDER_ID);
|
|
if (!hasUncategorized) {
|
|
mappedFolders.unshift({
|
|
folder_id: UNCATEGORIZED_FOLDER_ID,
|
|
name: null,
|
|
color: 0x000000,
|
|
flags: 0,
|
|
icon: DEFAULT_GUILD_FOLDER_ICON,
|
|
guild_ids: [],
|
|
});
|
|
}
|
|
updatedRowData.guild_folders = mappedFolders;
|
|
}
|
|
if (data.afk_timeout !== undefined) updatedRowData.afk_timeout = data.afk_timeout;
|
|
if (data.time_format !== undefined) updatedRowData.time_format = data.time_format;
|
|
if (data.developer_mode !== undefined) updatedRowData.developer_mode = data.developer_mode;
|
|
if (data.trusted_domains !== undefined) {
|
|
const domainsSet = new Set(data.trusted_domains);
|
|
if (domainsSet.has('*') && domainsSet.size > 1) {
|
|
throw ValidationError.fromField(
|
|
'trusted_domains',
|
|
'INVALID_TRUSTED_DOMAINS',
|
|
'Cannot combine wildcard (*) with specific domains',
|
|
);
|
|
}
|
|
updatedRowData.trusted_domains = domainsSet.size > 0 ? domainsSet : null;
|
|
}
|
|
if (data.default_hide_muted_channels !== undefined) {
|
|
updatedRowData.default_hide_muted_channels = data.default_hide_muted_channels;
|
|
}
|
|
|
|
await this.deps.userSettingsRepository.upsertSettings(updatedRowData);
|
|
const updatedSettings = await this.findSettings(userId);
|
|
await this.deps.updatePropagator.dispatchUserSettingsUpdate({userId, settings: updatedSettings});
|
|
|
|
if (localeChanged) {
|
|
const user = await this.deps.userAccountRepository.findUnique(userId);
|
|
if (user) {
|
|
const updatedUser = await this.deps.userAccountRepository.patchUpsert(
|
|
userId,
|
|
{locale: data.locale},
|
|
user.toRow(),
|
|
);
|
|
await this.deps.updatePropagator.dispatchUserUpdate(updatedUser);
|
|
}
|
|
}
|
|
|
|
return updatedSettings;
|
|
}
|
|
|
|
async findGuildSettings(userId: UserID, guildId: GuildID | null): Promise<UserGuildSettings | null> {
|
|
return await this.deps.userSettingsRepository.findGuildSettings(userId, guildId);
|
|
}
|
|
|
|
async updateGuildSettings(params: {
|
|
userId: UserID;
|
|
guildId: GuildID | null;
|
|
data: UserGuildSettingsUpdateRequest;
|
|
}): Promise<UserGuildSettings> {
|
|
const {userId, guildId, data} = params;
|
|
const currentSettings = await this.deps.userSettingsRepository.findGuildSettings(userId, guildId);
|
|
const resolvedGuildId = guildId ?? createGuildID(0n);
|
|
const baseRow: UserGuildSettingsRow = currentSettings
|
|
? {
|
|
...currentSettings.toRow(),
|
|
user_id: userId,
|
|
guild_id: resolvedGuildId,
|
|
}
|
|
: {
|
|
user_id: userId,
|
|
guild_id: resolvedGuildId,
|
|
message_notifications: UserNotificationSettings.INHERIT,
|
|
muted: false,
|
|
mute_config: null,
|
|
mobile_push: false,
|
|
suppress_everyone: false,
|
|
suppress_roles: false,
|
|
hide_muted_channels: false,
|
|
channel_overrides: null,
|
|
version: 1,
|
|
};
|
|
|
|
const updatedRowData: UserGuildSettingsRow = {...baseRow};
|
|
|
|
if (data.message_notifications !== undefined) updatedRowData.message_notifications = data.message_notifications;
|
|
if (data.muted !== undefined) updatedRowData.muted = data.muted;
|
|
if (data.mute_config !== undefined) {
|
|
updatedRowData.mute_config = data.mute_config
|
|
? {
|
|
end_time: data.mute_config.end_time ?? null,
|
|
selected_time_window: data.mute_config.selected_time_window,
|
|
}
|
|
: null;
|
|
}
|
|
if (data.mobile_push !== undefined) updatedRowData.mobile_push = data.mobile_push;
|
|
if (data.suppress_everyone !== undefined) updatedRowData.suppress_everyone = data.suppress_everyone;
|
|
if (data.suppress_roles !== undefined) updatedRowData.suppress_roles = data.suppress_roles;
|
|
if (data.hide_muted_channels !== undefined) updatedRowData.hide_muted_channels = data.hide_muted_channels;
|
|
if (data.channel_overrides !== undefined) {
|
|
if (data.channel_overrides) {
|
|
const channelOverrides = new Map<ChannelID, ChannelOverride>();
|
|
for (const [channelIdStr, override] of Object.entries(data.channel_overrides)) {
|
|
const channelId = createChannelID(BigInt(channelIdStr));
|
|
channelOverrides.set(channelId, {
|
|
collapsed: override.collapsed,
|
|
message_notifications: override.message_notifications,
|
|
muted: override.muted,
|
|
mute_config: override.mute_config
|
|
? {
|
|
end_time: override.mute_config.end_time ?? null,
|
|
selected_time_window: override.mute_config.selected_time_window,
|
|
}
|
|
: null,
|
|
});
|
|
}
|
|
updatedRowData.channel_overrides = channelOverrides.size > 0 ? channelOverrides : null;
|
|
} else {
|
|
updatedRowData.channel_overrides = null;
|
|
}
|
|
}
|
|
|
|
const updatedSettings = await this.deps.userSettingsRepository.upsertGuildSettings(updatedRowData);
|
|
await this.deps.updatePropagator.dispatchUserGuildSettingsUpdate({userId, settings: updatedSettings});
|
|
return updatedSettings;
|
|
}
|
|
|
|
private normalizeFriendSourceFlags(flags: number): number {
|
|
let normalizedFlags = flags;
|
|
|
|
if ((normalizedFlags & FriendSourceFlags.NO_RELATION) === FriendSourceFlags.NO_RELATION) {
|
|
const hasMutualFriends =
|
|
(normalizedFlags & FriendSourceFlags.MUTUAL_FRIENDS) === FriendSourceFlags.MUTUAL_FRIENDS;
|
|
const hasMutualGuilds = (normalizedFlags & FriendSourceFlags.MUTUAL_GUILDS) === FriendSourceFlags.MUTUAL_GUILDS;
|
|
|
|
if (!hasMutualFriends || !hasMutualGuilds) {
|
|
normalizedFlags &= ~FriendSourceFlags.NO_RELATION;
|
|
}
|
|
}
|
|
|
|
return normalizedFlags;
|
|
}
|
|
|
|
private normalizeIncomingCallFlags(flags: number): number {
|
|
let normalizedFlags = flags;
|
|
|
|
const modifierFlags = flags & IncomingCallFlags.SILENT_EVERYONE;
|
|
|
|
if ((normalizedFlags & IncomingCallFlags.FRIENDS_ONLY) === IncomingCallFlags.FRIENDS_ONLY) {
|
|
normalizedFlags = IncomingCallFlags.FRIENDS_ONLY | modifierFlags;
|
|
}
|
|
|
|
if ((normalizedFlags & IncomingCallFlags.NOBODY) === IncomingCallFlags.NOBODY) {
|
|
normalizedFlags = IncomingCallFlags.NOBODY | modifierFlags;
|
|
}
|
|
|
|
return normalizedFlags;
|
|
}
|
|
|
|
private normalizeGroupDmAddPermissionFlags(flags: number): number {
|
|
let normalizedFlags = flags;
|
|
|
|
if ((normalizedFlags & GroupDmAddPermissionFlags.FRIENDS_ONLY) === GroupDmAddPermissionFlags.FRIENDS_ONLY) {
|
|
normalizedFlags = GroupDmAddPermissionFlags.FRIENDS_ONLY;
|
|
}
|
|
|
|
if ((normalizedFlags & GroupDmAddPermissionFlags.NOBODY) === GroupDmAddPermissionFlags.NOBODY) {
|
|
normalizedFlags = GroupDmAddPermissionFlags.NOBODY;
|
|
}
|
|
|
|
if ((normalizedFlags & GroupDmAddPermissionFlags.EVERYONE) === GroupDmAddPermissionFlags.EVERYONE) {
|
|
normalizedFlags = GroupDmAddPermissionFlags.EVERYONE;
|
|
}
|
|
|
|
return normalizedFlags;
|
|
}
|
|
}
|