fix deletion back

back/abl/Message-abl.ts

@@ -1,7 +1,5 @@
 import statusCode from "../utils/statusCodes";
 import { Response } from "express";
-import { getMessageUid, getUserOfMailbox } from "../db/utils/mail";
-import emailManager from "../mails/EmailManager";
 import logger from "../system/Logger";
 import Message from "../mails/message/Message";
 import Room from "../mails/room/Room";
@@ -36,76 +34,71 @@ export default class MessageAbl {
     }
 
     static async addFlag(body, res: Response) {
-        await MessageAbl.changeFlag(body, res, false);
+        await this.changeFlag(body, res, false);
     }
 
     static async removeFlag(body, res: Response) {
-        await MessageAbl.changeFlag(body, res, true);
+        await this.changeFlag(body, res, true);
     }
 
-    static deleteRemoteOnly = async (body, res: Response) => {
+    static async deleteRemoteUtil(message: Message, mailboxId: number, res, isFull: boolean): Promise<boolean> {
-        const { mailboxId, messageId } = body;
-        const message = new Message().setMessageId(messageId);
-
         try {
             await message.useUid();
         } catch (error) {
             logger.err(error);
             res.status(statusCode.NOT_FOUND).send({ error: "Message uid not found." });
-            return;
+            return false;
         }
 
         try {
             await message.useMailbox(mailboxId);
         } catch (error) {
             res.status(statusCode.NOT_FOUND).send({ error: "Not account for this mailbox." });
-            return;
+            return false;
         }
 
         try {
             await message.mailbox.addFlag(message.uid.toString(), ["\\Deleted"]);
             await message.mailbox.moveToTrash(message.uid.toString(), (err) => {
-                throw err;
+                if (err) {
+                    logger.err(err);
+                }
+                // throw err;
             });
         } catch (err) {
             logger.log(err);
             res.status(statusCode.METHOD_FAILURE).send({ error: err });
-            return;
+            return false;
         }
 
-        res.status(statusCode.OK).send();
+        if (isFull) {
+            res.status(statusCode.OK).send();
+        }
+        return true;
+    }
+
+    static deleteRemoteOnly = async (body, res: Response) => {
+        const { mailboxId, messageId } = body;
+        const message = new Message().setMessageId(messageId);
+        await this.deleteRemoteUtil(message, mailboxId, res, true);
     };
 
     static deleteEverywhere = async (body, res: Response) => {
         const { mailboxId, messageId } = body;
         const message = new Message().setMessageId(messageId);
-        await message.useFlags();
 
         try {
-            await message.useUid();
+            await message.useFlags();
-        } catch (error) {
+        } catch (err) {
-            logger.err(error);
+            res.status(statusCode.METHOD_FAILURE).send({ error: err });
-            res.status(statusCode.NOT_FOUND).send({ error: "Message uid not found." });
+            logger.err(err);
             return;
         }
 
         // if message not deleted remotly, delete it
         if (!message.isDeleted) {
-            try {
+            const success = await this.deleteRemoteUtil(message, mailboxId, res, false);
-                await message.useMailbox(mailboxId);
+            if (!success) {
-            } catch (error) {
-                res.status(statusCode.NOT_FOUND).send({ error: "Not account for this mailbox." });
-                return;
-            }
-
-            try {
-                await message.mailbox.addFlag(message.uid.toString(), ["\\Deleted"]);
-                await message.mailbox.moveToTrash(message.uid.toString(), (err) => {
-                    throw err;
-                });
-            } catch (err) {
-                logger.log(err);
-                res.status(statusCode.METHOD_FAILURE).send({ error: err });
                 return;
             }
         }

back/db/Room-db.ts

@@ -70,10 +70,10 @@ export async function getRoomOnMessageId(messageId: number) {
 
 export async function getRoomNbMessageAndThread(roomId: number): Promise<{ nbMessage: number; nbThread: number }[]> {
     const query = `
-        SELECT COUNT(arm.room_id) AS nbMessage, COUND(app_thread.room_id) AS nbThread
+        SELECT COUNT(arm.room_id) AS nbMessage, COUNT(app_thread.room_id) AS nbThread
         FROM app_room_message arm
         INNER JOIN app_thread ON (app_thread.root_id = arm.room_id OR app_thread.parent_id = arm.room_id)
-        WHERE room_id = ?`;
+        WHERE arm.room_id = ?`;
     const values = [roomId];
     return await execQueryAsync(query, values);
 }

back/db/message/message-db.ts

@@ -2,7 +2,7 @@ import { execQueryAsync } from "../db";
 
 export async function getFlagsOnUid(uid: number): Promise<{ flag_id: number; flag_name: string }[]> {
     const query = `
-        SELECT * FROM flag_name
+        SELECT flag_name FROM flag_name
         INNER JOIN flag ON flag.flag_id = flag_name.flag_id
         INNER JOIN mailbox_message ON mailbox_message.message_id = flag.message_id
         WHERE mailbox_message.uid = ?
@@ -13,7 +13,7 @@ export async function getFlagsOnUid(uid: number): Promise<{ flag_id: number; fla
 
 export async function getFlagsOnId(messageId: number): Promise<{ flag_id: number; flag_name: string }[]> {
     const query = `
-        SELECT * FROM flag_name
+        SELECT flag_name FROM flag_name
         INNER JOIN flag ON flag.flag_id = flag_name.flag_id
         INNER JOIN mailbox_message ON mailbox_message.message_id = flag.message_id
         WHERE mailbox_message.message_id = ?

back/db/message/updateMessage-db.ts

@@ -25,7 +25,7 @@ export async function updateMailboxSeen(messageId: number, isSeen: boolean) {
 
 export async function updateMailboxDeleted(messageId: number, isDeleted: boolean) {
     const query = `UPDATE mailbox_message SET deleted = ? WHERE message_id = ?`;
-    const values = [messageId, isDeleted];
+    const values = [isDeleted, messageId];
     return await execQueryAsync(query, values);
 }
 

back/mails/message/Message.ts

@@ -30,17 +30,18 @@ export default class Message {
     }
 
     async useFlags(): Promise<Message> {
+        let flags;
         if (!this._flags) {
             if (this.messageId) {
-                await getFlagsOnId(this.messageId);
+                flags = await getFlagsOnId(this.messageId);
-                return this;
             } else if (this.uid) {
-                await getFlagsOnUid(this.uid);
+                flags = await getFlagsOnUid(this.uid);
-                return this;
             } else {
                 throw "Neither message id or uid are set, please do so before attempting to load flags";
             }
+            this._flags = flags;
         }
+        return this;
     }
 
     async useMailbox(mailboxId: number, user?: string): Promise<Message> {
@@ -62,6 +63,8 @@ export default class Message {
     }
 
     get flags(): string[] {
+        console.log("called");
+        console.log(this._flags);
         if (!this._flags) {
             throw "Flags not loaded, call useFlags before calling functions related to flags";
         } else {

front/src/store/models/model.ts

@@ -33,6 +33,7 @@ export interface Room {
     members: Address[];
     notSeen: number;
     threadIds: number[];
+    parent_id?: number;
 }
 
 export interface Account {

front/src/store/store.ts

@@ -32,6 +32,7 @@ function createRoom(options: RoomFromBack): Room {
         user: options.user,
         notSeen: options.notSeen,
         threadIds: [],
+        parent_id: options.parent_id,
     };
 }
 
@@ -133,9 +134,19 @@ const store = createStore<State>({
             });
         },
         removeRoom(state, payload) {
+            console.log(payload);
             const roomMessageIndex = state.roomMessages.findIndex((roomM) => roomM.roomId === payload.roomId);
             state.roomMessages.splice(roomMessageIndex, 1);
             const roomIndex = state.rooms.findIndex((room) => room.id === payload.roomId);
+            const roomToDelete = state.rooms[roomIndex];
+            // todo debug parent_id to root_id
+            // remove thread
+            if (roomToDelete.roomType === RoomType.THREAD && roomToDelete.parent_id) {
+                const parentRoom = roomOnId(state, roomToDelete.parent_id);
+                if (parentRoom) {
+                    parentRoom.threadIds = parentRoom?.threadIds.filter((id) => id !== roomToDelete.id);
+                }
+            }
             state.rooms.splice(roomIndex, 1);
             // state.activeRoom = state.rooms[0].id;
             // router.push(`/${state.activeRoom}`);