RocketChat/Rocket.Chat

import type { IUser } from '@rocket.chat/core-typings';

import { FederatedUser } from '../domain/FederatedUser';
import type { IFederationBridge } from '../domain/IFederationBridge';
import type { RocketChatFileAdapter } from '../infrastructure/rocket-chat/adapters/File';
import type { RocketChatSettingsAdapter } from '../infrastructure/rocket-chat/adapters/Settings';
import type { RocketChatUserAdapter } from '../infrastructure/rocket-chat/adapters/User';

export abstract class AbstractFederationApplicationService {
    protected internalHomeServerDomain: string;

    constructor(
        protected bridge: IFederationBridge,
        protected internalUserAdapter: RocketChatUserAdapter,
        protected internalFileAdapter: RocketChatFileAdapter,
        protected internalSettingsAdapter: RocketChatSettingsAdapter,
    ) {
        this.internalHomeServerDomain = this.internalSettingsAdapter.getHomeServerDomain();
    }

    protected async createFederatedUserInternallyOnly(
        externalUserId: string,
        username: string,
        existsOnlyOnProxyServer = false,
        providedName?: string,
    ): Promise<void> {
        const internalUser = await this.internalUserAdapter.getInternalUserByUsername(username);
        const externalUserProfileInformation = await this.bridge.getUserProfileInformation(externalUserId);
        let federatedUser;
        if (internalUser) {
            federatedUser = FederatedUser.createWithInternalReference(externalUserId, existsOnlyOnProxyServer, internalUser);
        } else {
            const name = externalUserProfileInformation?.displayName || providedName || username;
            federatedUser = FederatedUser.createInstance(externalUserId, {
                name,
                username,
                existsOnlyOnProxyServer,
            });
        }
        await this.internalUserAdapter.createFederatedUser(federatedUser);
        const insertedUser = await this.internalUserAdapter.getFederatedUserByExternalId(externalUserId);
        if (!insertedUser) {
            return;
        }
        await this.updateUserAvatarInternally(insertedUser, externalUserProfileInformation?.avatarUrl);
        await this.updateUserDisplayNameInternally(insertedUser, externalUserProfileInformation?.displayName);
    }

    protected async updateUserAvatarInternally(federatedUser: FederatedUser, avatarUrl?: string): Promise<void> {
        if (!avatarUrl) {
            return;
        }
        if (!federatedUser.isRemote()) {
            return;
        }
        if (federatedUser.shouldUpdateFederationAvatar(avatarUrl)) {
            await this.internalUserAdapter.setAvatar(federatedUser, this.bridge.convertMatrixUrlToHttp(federatedUser.getExternalId(), avatarUrl));
            await this.internalUserAdapter.updateFederationAvatar(federatedUser.getInternalId(), avatarUrl);
        }
    }

    protected async updateUserDisplayNameInternally(federatedUser: FederatedUser, displayName?: string): Promise<void> {
        if (!displayName) {
            return;
        }
        if (!federatedUser.isRemote()) {
            return;
        }
        if (federatedUser.shouldUpdateDisplayName(displayName)) {
            await this.internalUserAdapter.updateRealName(federatedUser.getInternalReference(), displayName);
        }
    }

    protected async createFederatedUserIncludingHomeserverUsingLocalInformation(internalInviterId: string): Promise<string> {
        const internalUser = await this.internalUserAdapter.getInternalUserById(internalInviterId);
        if (!internalUser || !internalUser?.username) {
            throw new Error(`Could not find user id for ${internalInviterId}`);
        }
        const name = internalUser.name || internalUser.username;
        const externalInviterId = await this.bridge.createUser(internalUser.username, name, this.internalHomeServerDomain);
        const existsOnlyOnProxyServer = true;
        await this.createFederatedUserInternallyOnly(externalInviterId, internalUser.username, existsOnlyOnProxyServer, name);
        await this.updateUserAvatarExternally(
            internalUser,
            (await this.internalUserAdapter.getFederatedUserByExternalId(externalInviterId)) as FederatedUser,
        );

        return externalInviterId;
    }

    protected async updateUserAvatarExternally(internalUser: IUser, externalInviter: FederatedUser): Promise<void> {
        if (!internalUser.username) {
            return;
        }
        const buffer = await this.internalFileAdapter.getBufferForAvatarFile(internalUser.username);
        if (!buffer) {
            return;
        }
        const avatarFileRecord = await this.internalFileAdapter.getFileMetadataForAvatarFile(internalUser.username);
        if (!avatarFileRecord?.type || !avatarFileRecord?.name) {
            return;
        }
        const externalFileUri = await this.bridge.uploadContent(externalInviter.getExternalId(), buffer, {
            type: avatarFileRecord.type,
            name: avatarFileRecord.name,
        });
        if (!externalFileUri) {
            return;
        }
        await this.internalUserAdapter.updateFederationAvatar(internalUser._id, externalFileUri);
        await this.bridge.setUserAvatar(externalInviter.getExternalId(), externalFileUri);
    }
}