@tak-ps/cloudtak 12.54.0

package/src/base/chatroom-chats.ts

@@ -0,0 +1,124 @@
+import { db } from './database.ts';
+import { std, stdurl } from '../std.ts';
+import type {
+    ProfileChatList,
+    APIProfileChat
+} from '../types.ts'
+import type { DBChatroomChat } from './database.ts';
+import type Atlas from '../workers/atlas.ts';
+
+export default class ChatroomChats {
+    chatroom: string;
+
+    constructor(
+        chatroom: string
+    ) {
+        this.chatroom = chatroom;
+    }
+
+    async refresh(): Promise<void> {
+        const url = stdurl(`/api/profile/chatroom/${encodeURIComponent(this.chatroom)}/chat`);
+
+        const list = await std(url) as ProfileChatList;
+
+        await db.transaction('rw', db.chatroom_chats, async () => {
+            await db.chatroom_chats
+                .where('chatroom')
+                .equals(this.chatroom)
+                .delete();
+
+            for (const chat of list.items) {
+                const c = chat as APIProfileChat;
+                await db.chatroom_chats.put({
+                    id: c.message_id,
+                    chatroom: this.chatroom,
+                    sender: c.sender_callsign,
+                    sender_uid: c.sender_uid,
+                    message: c.message,
+                    created: c.created
+                });
+            }
+        });
+    }
+
+    async list(
+        opts?: {
+            refresh?: boolean,
+        }
+    ): Promise<Array<DBChatroomChat>> {
+        if (opts?.refresh) {
+            await this.refresh();
+        }
+
+        const chats = await db.chatroom_chats
+            .where("chatroom")
+            .equals(this.chatroom)
+            .toArray();
+
+        chats.sort((a, b) => {
+            return a.created.localeCompare(b.created);
+        });
+
+        return chats;
+    }
+
+    async send(
+        message: string,
+        sender: { uid: string, callsign: string },
+        worker: Atlas,
+        recipient?: { uid: string, callsign: string }
+    ): Promise<void> {
+        const id = crypto.randomUUID();
+        const created = new Date().toISOString();
+
+        await db.chatroom_chats.put({
+            id: id,
+            chatroom: this.chatroom,
+            sender: sender.callsign,
+            sender_uid: sender.uid,
+            message: message,
+            created: created
+        });
+
+        if (!recipient) {
+            const chats = await this.list();
+            const single = chats.find((chat) => {
+                return chat.sender_uid !== sender.uid
+            });
+
+            if (single) {
+                recipient = {
+                    uid: single.sender_uid,
+                    callsign: single.sender
+                }
+            } else {
+                const contact = await worker.team.getByCallsign(this.chatroom);
+                if (contact) {
+                    recipient = {
+                        uid: contact.uid,
+                        callsign: contact.callsign
+                    }
+                } else {
+                    recipient = {
+                        uid: this.chatroom,
+                        callsign: this.chatroom
+                    }
+                }
+            }
+        }
+
+        if (!recipient) throw new Error('Error sending Chat - Contact is not defined');
+
+        await worker.conn.sendCOT({
+            chatroom: this.chatroom,
+            from: {
+                uid: sender.uid,
+                callsign: sender.callsign
+            },
+            to: recipient,
+            message: message,
+            messageId: id,
+            time: created
+        }, 'chat');
+    }
+}

package/src/base/chatroom.ts

@@ -0,0 +1,202 @@
+import { db } from './database.ts'
+import type { DBChatroom } from './database.ts';
+import { std, stdurl } from '../std.ts';
+import ChatroomChats from './chatroom-chats.ts';
+import type {
+    ProfileChatroomList,
+    ProfileChatList
+} from '../types.ts';
+
+/**
+ * High Level Wrapper around the Profile Chatroom API
+ *
+ * @property {string} name - The name of the chatroom
+ */
+export default class Chatroom {
+    name: string;
+    chats: ChatroomChats;
+
+    constructor(
+        name: string
+    ) {
+        this.name = name;
+        this.chats = new ChatroomChats(name);
+    }
+
+    /**
+     * Return a Chatroom instance if one already exists in the local DB,
+     */
+    static async from(
+        name: string,
+    ): Promise<Chatroom | undefined> {
+        const exists = await db.chatroom
+            .get(name)
+
+        if (!exists) {
+            return;
+        }
+
+        return new Chatroom(
+            exists.name,
+        );
+    }
+
+    /**
+     * Loads an existing Chatroom from the local DB and refresh it,
+     *
+     * @param name - The unique identifier for the chatroom
+     * @param opts - Options for loading the chatroom
+     * @param opts.reload - Whether to reload the chatroom from the local DB
+     */
+    static async load(
+        name: string,
+        opts: {
+            reload?: boolean,
+        } = {}
+    ): Promise<Chatroom> {
+        const exists = await this.from(name);
+
+        if (exists) {
+            if (opts.reload !== false) {
+                await exists.refresh();
+            }
+
+            return exists;
+        } else {
+            const room = new Chatroom(name);
+
+            await db.chatroom.put({
+                id: room.name,
+                name: room.name,
+                created: new Date().toISOString(),
+                updated: new Date().toISOString(),
+                last_read: null
+            });
+
+            await room.refresh();
+
+            return room;
+        }
+    }
+
+    static async delete(names: string[]): Promise<void> {
+        const url = stdurl('/api/profile/chatroom');
+        for (const name of names) {
+            url.searchParams.append('chatroom', name);
+        }
+
+        await std(url, {
+            method: 'DELETE'
+        });
+
+        await db.chatroom.bulkDelete(names);
+    }
+
+    /**
+     * Reload the Chatroom from the local Database
+     */
+    async reload(): Promise<void> {
+        const exists = await db.chatroom
+            .get(this.name)
+
+        if (exists) {
+            this.name = exists.name;
+        }
+    };
+
+    /**
+     * Perform a hard refresh of the Chatroom from the Server
+     */
+    async refresh(): Promise<void> {
+        await this.fetch();
+    };
+
+    async fetch(): Promise<void> {
+        const url = stdurl('/api/profile/chatroom');
+
+        const list = await std(url) as ProfileChatroomList;
+
+        const found = list.items.find((c) => c.chatroom === this.name);
+        if (found) {
+            this.name = found.chatroom;
+        }
+    }
+
+    async getChats(): Promise<ProfileChatList> {
+        const url = stdurl(`/api/profile/chatroom/${encodeURIComponent(this.name)}/chat`);
+        return await std(url) as ProfileChatList;
+    }
+    async deleteChats(ids: string[]): Promise<void> {
+        const url = stdurl(`/api/profile/chatroom/${encodeURIComponent(this.name)}/chat`);
+        for (const id of ids) {
+            url.searchParams.append('chat', id);
+        }
+
+        await std(url, {
+            method: 'DELETE'
+        });
+    }
+
+    /**
+     * List all locally stored chatrooms
+     */
+    static async localList(): Promise<Set<{
+        name: string;
+    }>> {
+        const list = await db.chatroom.toArray();
+
+        const names = new Set<{
+            name: string;
+        }>();
+
+        for (const sub of list) {
+            names.add({
+                name: sub.name,
+            });
+        }
+
+        return names;
+    }
+
+    static async list(filter?: string): Promise<DBChatroom[]> {
+        let collection = db.chatroom.toCollection();
+
+        if (filter) {
+            collection = collection.filter((room) => {
+                return room.name.toLowerCase().includes(filter.toLowerCase());
+            });
+        }
+
+        return (await collection.sortBy('name')).reverse();
+    }
+
+    static async sync(): Promise<ProfileChatroomList> {
+        const url = stdurl('/api/profile/chatroom');
+
+        const list = await std(url) as ProfileChatroomList;
+
+        const serverNames = new Set(list.items.map(c => c.chatroom));
+        const local = await db.chatroom.toArray();
+
+        for (const chat of local) {
+            if (!serverNames.has(chat.name)) {
+                await db.chatroom.delete(chat.id);
+            }
+        }
+
+        for (const chat of list.items) {
+            const exists = await db.chatroom.get(chat.chatroom);
+            if (!exists) {
+                await db.chatroom.put({
+                    id: chat.chatroom,
+                    name: chat.chatroom,
+                    created: new Date().toISOString(),
+                    updated: new Date().toISOString(),
+                    last_read: null
+                });
+            }
+        }
+
+        return list;
+    }
+}