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 {ChannelID, UserID} from '@app/api/BrandedTypes';
import {dispatchThreadEvents, threadMemberUpdateEvent} from '@app/api/channel/services/thread/ThreadDispatch';
import {mapThreadMemberToResponse} from '@app/api/channel/services/thread/ThreadMappers';
import type {ThreadServiceContext} from '@app/api/channel/services/thread/ThreadServiceContext';
import type {MuteConfig} from '@app/api/database/types/UserTypes';
import type {ThreadViewer} from '@app/api/experiment/ChannelThreadsGate';
import {isValidThreadMemberSettingsFlags, ThreadMemberFlags} from '@fluxer/constants/src/ThreadConstants';
import {InvalidChannelTypeError} from '@fluxer/errors/src/domains/channel/InvalidChannelTypeError';
import {InvalidThreadNotificationSettingsError} from '@fluxer/errors/src/domains/channel/InvalidThreadNotificationSettingsError';
import {UnknownThreadMemberError} from '@fluxer/errors/src/domains/channel/UnknownThreadMemberError';
import {ServiceUnavailableError} from '@fluxer/errors/src/domains/core/ServiceUnavailableError';
import type {ThreadMemberResponse} from '@fluxer/schema/src/domains/channel/ThreadSchemas';
import type {ThreadMemberSettingsRequest} from '@fluxer/schema/src/domains/user/UserRequestSchemas';
const SETTINGS_CAS_ATTEMPTS = 3;
function sameMuteConfig(a: MuteConfig | null, b: MuteConfig | null): boolean {
if (a === null || b === null) {
return a === b;
}
return (
(a.end_time?.getTime() ?? null) === (b.end_time?.getTime() ?? null) &&
a.selected_time_window === b.selected_time_window
);
}
export class ThreadMemberSettingsService {
constructor(private readonly ctx: ThreadServiceContext) {}
async update(params: {
viewer: ThreadViewer;
userId: UserID;
channelId: ChannelID;
data: ThreadMemberSettingsRequest;
}): Promise<ThreadMemberResponse | null> {
const {data, userId} = params;
if (data.flags !== undefined && !isValidThreadMemberSettingsFlags(data.flags)) {
throw new InvalidThreadNotificationSettingsError();
}
const auth = await this.ctx.channelAuth.getChannelAuthenticated({
userId,
channelId: params.channelId,
viewer: params.viewer,
skipNsfwValidation: true,
});
if (!auth.thread) {
throw new InvalidChannelTypeError();
}
const threadId = auth.thread.state.threadId;
for (let attempt = 0; attempt < SETTINGS_CAS_ATTEMPTS; attempt++) {
const member =
(attempt === 0 ? auth.thread.member : null) ??
(await this.ctx.channelRepository.threads.getMember(threadId, userId));
if (!member) {
throw new UnknownThreadMemberError();
}
const flags =
data.flags === undefined ? member.flags : (member.flags & ThreadMemberFlags.HAS_INTERACTED) | data.flags;
const muted = data.muted ?? member.muted;
const current = member.muteConfig?.toMuteConfig() ?? null;
let muteConfig: MuteConfig | null;
if (data.mute_config === undefined) {
muteConfig = current;
} else if (data.mute_config === null) {
muteConfig = null;
} else {
muteConfig = {
end_time: data.mute_config.end_time ?? null,
selected_time_window: data.mute_config.selected_time_window,
};
}
if (flags === member.flags && muted === member.muted && sameMuteConfig(muteConfig, current)) {
return null;
}
const updated = await this.ctx.channelRepository.threads.updateMemberSettings(member, {
flags,
muted,
...(data.mute_config === undefined ? {} : {muteConfig}),
});
if (!updated) {
continue;
}
await dispatchThreadEvents(this.ctx.gatewayService, updated.guildId, [threadMemberUpdateEvent(updated)]);
return mapThreadMemberToResponse(updated, {self: true});
}
throw new ServiceUnavailableError();
}
}