diff --git a/back/abl/Message-abl.ts b/back/abl/Message-abl.ts
index dc35dce..e137954 100644
--- a/back/abl/Message-abl.ts
+++ b/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) => {
-        const { mailboxId, messageId } = body;
-        const message = new Message().setMessageId(messageId);
-
+    static async deleteRemoteUtil(message: Message, mailboxId: number, res, isFull: boolean): Promise<boolean> {
         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();
-        } catch (error) {
-            logger.err(error);
-            res.status(statusCode.NOT_FOUND).send({ error: "Message uid not found." });
+            await message.useFlags();
+        } catch (err) {
+            res.status(statusCode.METHOD_FAILURE).send({ error: err });
+            logger.err(err);
             return;
         }
 
         // if message not deleted remotly, delete it
         if (!message.isDeleted) {
-            try {
-                await message.useMailbox(mailboxId);
-            } 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 });
+            const success = await this.deleteRemoteUtil(message, mailboxId, res, false);
+            if (!success) {
                 return;
             }
         }
diff --git a/back/db/Room-db.ts b/back/db/Room-db.ts
index c4b630e..0abe702 100644
--- a/back/db/Room-db.ts
+++ b/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);
 }
diff --git a/back/db/message/message-db.ts b/back/db/message/message-db.ts
index 09fd71b..775c205 100644
--- a/back/db/message/message-db.ts
+++ b/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 = ?
diff --git a/back/db/message/updateMessage-db.ts b/back/db/message/updateMessage-db.ts
index 7f48804..3d88a08 100644
--- a/back/db/message/updateMessage-db.ts
+++ b/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);
 }
 
diff --git a/back/mails/message/Message.ts b/back/mails/message/Message.ts
index 018649b..899a261 100644
--- a/back/mails/message/Message.ts
+++ b/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);
-                return this;
+                flags = await getFlagsOnId(this.messageId);
             } else if (this.uid) {
-                await getFlagsOnUid(this.uid);
-                return this;
+                flags = await getFlagsOnUid(this.uid);
             } 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 {