mail/back/test/test-utils/db/test-saveMessage.ts

import { AttrsWithEnvelope, User } from "../../../interfaces/mail/attrs.interface";
import { RoomType } from "../../../mails/saveMessage";
import { getMembers } from "../../../mails/utils/envelopeUtils";
import { hasSameElements } from "../../../utils/array";
import { generateUsers, UserTest } from "../test-attrsUtils";

interface Room {
    room_id: number;
    room_name: string;
    owner_id: number;
    message_id: number;
    room_type: RoomType;
    notSeen: number;
    lastUpdate: string;
    members?: UserTest[];
    is_thread?: boolean;
    parent_id?: number;
    root_id?: number;
}

export default class saveMessageDatabase {
    rooms: Room[];
    roomId: number;
    messages: {attrs: AttrsWithEnvelope, message_id: number}[];
    room_message: {room_id: number, message_id: number}[];
    users: UserTest[];

    constructor(_users) {
        this.rooms = [];
        this.messages = [];
        this.room_message = [];
        this.users = generateUsers(5); // todo
        this.roomId = 0;
    }

    clear() {
        this.rooms = [];
        this.messages = [];
        this.roomId = 0;
    }

    _findRoomById(roomId: number): Room {
        return this.rooms.find((room) => room.room_id === roomId);
    }

    _findUserByMailbox(mailbox: string): UserTest {
        return this.users.find((user) => user.user.mailbox === mailbox);
    }

    createRoom = (
        roomName: string | null | undefined,
        ownerId: number,
        messageId: number,
        roomType: RoomType,
    ): Promise<number> => {
        this.rooms.push({
            room_id: this.roomId,
            room_name: roomName,
            owner_id: ownerId,
            message_id: messageId,
            room_type: roomType,
            notSeen: 0,
            lastUpdate: "0",
        });
        this.roomId++;
        return Promise.resolve(this.roomId - 1);
    };

    registerMessageInRoom = (messageId: number, roomId: number, idate: string | undefined | null): Promise<void> => {
        this.room_message.push({ message_id: messageId, room_id: roomId });
        return Promise.resolve();
    };

    isRoomGroup(roomId: number): Promise<boolean> {
        return new Promise((resolve, reject) => {
            resolve(this.rooms.find((room) => room.room_id == roomId).room_type === RoomType.GROUP);
        });
    }

    findRoomsFromMessage = (messageID: string): Promise<{ room_id: number }[]> => {
        return new Promise((resolve, reject) => {
            const rooms = this.rooms.filter((room) => room.message_id.toString() === messageID);
            const res: { room_id: number }[] = [];
            rooms.forEach((room) => {
                res.push({ room_id: room.room_id });
            });
            resolve(res);
        });
    };

    hasSameMembersAsParent(messageId: number, messageID: string): Promise<boolean> {
        const msg1 = this.messages.find((message) => message.attrs.envelope.messageId === messageID );
        const msg2 = this.messages.find((message) => message.message_id === messageId );
        const members1 = getMembers(msg1.attrs.envelope);
        const members2 = getMembers(msg2.attrs.envelope);
        let ids1 = [];
        let ids2 = [];
        members1.forEach((member) => ids1.push(this._findUserByMailbox(member.mailbox).id));
        members2.forEach((member) => ids2.push(this._findUserByMailbox(member.mailbox).id));
        return Promise.resolve(hasSameElements(ids1, ids2));
    }

    registerThread = async (roomId: number, parentId: number, rootId: number) => {
        const room = this._findRoomById(roomId);
        room.parent_id = parentId;
        room.room_id = rootId;
    };

    registerMember(roomId: number, memberId: number): Promise<any> {
        const room = this._findRoomById(roomId);
        room.members.push(this.users.find((user) => user.id === memberId));
        return Promise.resolve(true);
    }

    getAllMembers(messageId: number): Promise<any> {
        // test_todo
        return Promise.resolve(true);
    }

    getThreadInfo = (messageID: string): Promise<{ room_id: number; root_id: number }[]> => {
        return new Promise((resolve, reject) => {
            const room = this.rooms.find((room) => room.message_id.toString() === messageID);
            resolve([{ room_id: room.room_id, root_id: room.root_id }]);
        });
    };

    incrementNotSeenRoom = (roomId: number): Promise<void> => {
        const room = this._findRoomById(roomId);
        room.notSeen++;
        return Promise.resolve();
    };

    findRoomByOwner = (ownerId: number): Promise<{ room_id: number }[]> => {
        return new Promise((resolve, reject) => {
            const rooms = this.rooms.filter((room) => room.owner_id === ownerId);
            const res = [];
            rooms.forEach((room) => {
                res.push({ room_id: room.room_id });
            });
            resolve(res);
        });
    };

    getAddresseId = (email: string, name?: string): Promise<number> => {
        const match = this.users.find((user) => user.user.mailbox + "@" + user.user.host == email);
        return new Promise((resolve, reject) => resolve(match?.id));
    };

    getUserIdOfMailbox = (boxId: number): Promise<{ user_id: number }[]> => {
        return new Promise((resolve, rejects) => resolve([{ user_id: this.users[0].id }]));
    };
}