Implemented SessionManager and TextChannelService + several improvements and fixes

src/domain/fileUploadService.schema.ts

@@ -33,8 +33,13 @@ export interface FileUploadRegistration {
 }
 
 export interface FileData {
+    fileId: string
     name: string
     extension: string
     type: string
     data: File
+}
+
+export interface FileUploadProgressListener {
+    fileProgressUpdate: (fileId: string, allChunks: number, chunksDone: number) => void
 }

src/domain/sessionManager.schema.ts

@@ -0,0 +1,19 @@
+import {PublicUserData} from "./common.schema";
+import {GIF} from "./userService.schema";
+
+export interface Session {
+    userData: PersonalUserData
+    token: string
+}
+
+export interface ValidateSessionReq {
+    token: string
+}
+
+export interface ValidateSessionResp {
+    validationOk: boolean
+}
+
+export interface UpdateUserDataReq {
+    userid: string
+}

src/domain/textChannelService.schema.ts

@@ -0,0 +1,138 @@
+import {Attachment, PublicUserData, TimeStamp} from "./common.schema";
+
+export interface GetMessageReq {
+    from: number
+    channelId: string
+    networkId: string
+    categoryId: string
+}
+
+export interface GetMessagePosReq {
+    messageId: string
+    channelId: string
+    networkId: string
+    categoryId: string
+}
+
+export interface GetPinnedMessagesReq {
+    channelId: string
+    networkId: string
+    categoryId: string
+}
+
+export interface EditMessageReq {
+    message: string
+    messageId: string
+    channelId: string
+    networkId: string
+    categoryId: string
+    userid: string
+}
+
+export interface FinishMessageReq {
+    uploadId: string | null
+    message: string
+    replyTo: string
+    replyToMessage: string
+    channelId: string
+    networkId: string
+    categoryId: string
+    userid: string
+}
+
+export interface ReadMessagesReq {
+    channelId: string
+    networkId: string
+    categoryId: string
+    userid: string
+}
+
+export interface PinMessageReq {
+    channelId: string
+    networkId: string
+    categoryId: string
+    messageId: string
+    userid: string
+    message: string
+}
+
+export interface UnpinMessageReq {
+    channelId: string
+    networkId: string
+    categoryId: string,
+    messageId: string,
+    userid: string
+}
+
+export interface DeleteMessagesReq {
+    messageIds: string[]
+    channelId: string
+    networkId: string
+    categoryId: string
+    userid: string
+}
+
+export interface JoinWsRoomReq {
+    connId: string
+    channelId: string
+    networkId: string
+    categoryId: string
+    userid: string
+}
+
+// Response schemas
+export interface GetMessagePosResp {
+    messagePos: number
+}
+
+// Types
+export interface Message {
+    msgid: string
+    author: PublicUserData
+    message: string
+    sent_at: TimeStamp
+    isEdited: boolean
+    channelId: string
+    networkId: string
+    categoryId: string
+    files: Attachment[]
+    seen: boolean
+    replyTo: string
+    replyToId: string
+    forwardedFrom: string
+    forwardedFromName: string
+}
+
+export interface PinnedMessage {
+    message: string
+    messageId: string
+}
+
+// WebSocket payloads
+export interface WSMessageDeletedPayload {
+    messageId: string
+}
+
+export interface WSMessageEditedPayload {
+    messageId: string
+    message: string
+}
+
+export interface WSMessagePinnedPayload {
+    channelId: string
+    networkId: string
+    categoryId: string
+    messageId: string
+    message: string
+}
+
+export interface WSMessagesReadPayload {
+    userid: string
+}
+
+export interface WSMessageUnpinnedPayload {
+    channelId: string
+    networkId: string
+    categoryId: string
+    messageId: string
+}

src/services/dmService.ts

@@ -13,7 +13,7 @@ import {
 } from "../domain/dmService.schema";
 import {NetworkInvite} from "../domain/networkService.schema";
 import {GenericErrorBody} from "../domain/http.schema";
-import {FileData} from "../domain/fileUploadService.schema";
+import {FileData, FileUploadProgressListener} from "../domain/fileUploadService.schema";
 import {FileUploadService} from "./fileUploadService";
 
 export class DMService {
@@ -133,12 +133,13 @@ export class DMService {
      * @param replyTo
      * @param replyToMessage
      * @param attachments
+     * @param progressListener
      */
-    async sendMessage(message: string, replyTo: string | null = null, replyToMessage: string | null = null, attachments: FileData[] | null = null): Promise<Message> {
+    async sendMessage(message: string, replyTo: string | null = null, replyToMessage: string | null = null, attachments: FileData[] | null = null, progressListener: FileUploadProgressListener | null = null): Promise<Message> {
         let uploadId = ""
         if (attachments) {
             const uploader = new FileUploadService(this.token)
-            uploadId = await uploader.uploadFiles(this.chatid, this.userid, attachments)
+            uploadId = await uploader.uploadFiles(this.chatid, this.userid, attachments, progressListener!)
         }
         try {
             const resp = await this.client.post<Message>("chat/dm/finishMessage", <FinishMessageReq>{

src/services/fileUploadService.ts

@@ -1,6 +1,6 @@
 import {
     ChunkUploadReq,
-    FileData,
+    FileData, FileUploadProgressListener,
     FileUploadRegistration, FinishUploadReq,
     RegisterUploadReq,
     RegisterUploadResp
@@ -42,13 +42,14 @@ export class FileUploadService {
      * @param roomId chatid or channelId
      * @param userid
      * @param files
+     * @param listener
      */
-    async uploadFiles(roomId: string, userid: string, files: FileData[]): Promise<string> {
+    async uploadFiles(roomId: string, userid: string, files: FileData[], listener: FileUploadProgressListener): Promise<string> {
         let registrations: FileUploadRegistration[] = [];
 
         files.forEach(file => {
             registrations.push({
-                fileId: uuidv4(),
+                fileId: file.fileId,
                 name: file.name,
                 type: file.type,
                 size: file.data.size,
@@ -62,7 +63,7 @@ export class FileUploadService {
                 files: registrations,
             });
             for (let filesUploaded = 0; filesUploaded < files.length; filesUploaded++) {
-                await this.uploadFile(resp.data.uploadId, roomId, userid, files[filesUploaded], registrations[filesUploaded])
+                await this.uploadFile(resp.data.uploadId, roomId, userid, files[filesUploaded], registrations[filesUploaded], listener)
             }
             await this.finishUpload(roomId, userid, resp.data.uploadId)
             return resp.data.uploadId
@@ -92,7 +93,7 @@ export class FileUploadService {
         }
     }
 
-    private async uploadFile(uploadId: string, roomId: string, userid: string, file: FileData, registration: FileUploadRegistration): Promise<void> {
+    private async uploadFile(uploadId: string, roomId: string, userid: string, file: FileData, registration: FileUploadRegistration, listener: FileUploadProgressListener): Promise<void> {
         const chunkSize = this.calculateChunkSize(file.data.size);
         const totalChunks = Math.ceil(file.data.size / chunkSize);
 
@@ -104,6 +105,7 @@ export class FileUploadService {
             const chunk = new Uint8Array(arrayBuffer.slice(start, end));
             const base64 = this.uint8ToBase64(chunk);
             await this.uploadChunk(uploadId, roomId, userid, registration.fileId, base64);
+            listener.fileProgressUpdate(file.fileId, totalChunks, i)
         }
     }
 

src/services/sessionManager.ts

@@ -0,0 +1,133 @@
+import {PublicUserData} from "../domain/common.schema";
+import {DatabaseAPI} from "../storage/database";
+import {KeyringAPI} from "../storage/keyring";
+import {KeyValueAPI} from "../storage/keyvalue";
+import {Session, ValidateSessionReq, ValidateSessionResp} from "../domain/sessionManager.schema";
+import {AxiosInstance} from "axios";
+import {getClient} from "../core/http";
+import {PersonalUserData} from "../domain/userService.schema";
+
+export class SessionManager {
+    client: AxiosInstance;
+    database: DatabaseAPI;
+    keyring: KeyringAPI;
+    KeyValue: KeyValueAPI;
+
+    constructor(database: DatabaseAPI, keyring: KeyringAPI, KeyValue: KeyValueAPI) {
+        this.database = database;
+        this.keyring = keyring;
+        this.KeyValue = KeyValue;
+        this.client = getClient(false)
+    }
+
+    /**
+     * Saves the new session to the database and the keyring
+     * @param userData
+     * @param token
+     */
+    addSession(userData: PublicUserData, token: string): void {
+        this.database.set("sessions", userData.userid, JSON.stringify(userData))
+        this.keyring.set(userData.userid, token)
+    }
+
+    /**
+     * Loads all saved sessions
+     */
+    loadSessions(): Session[] {
+        const tokens = this.keyring.getAll()
+        const sessions: Session[] = []
+        tokens.forEach(token => {
+            const userData = this.database.get("sessions", token.split(".")[0])
+            if (userData) {
+                sessions.push({
+                    token: token,
+                    userData: JSON.parse(userData)
+                })
+            }
+        })
+
+        return sessions
+    }
+
+    /**
+     * Gets the preferred user set by the client
+     */
+    getPreferredUser(): string {
+        return this.KeyValue.get("preferredUser") ?? ""
+    }
+
+    /**
+     * Sets a new preferred user
+     * @param userid
+     */
+    setPreferredUser(userid: string): void {
+        this.KeyValue.set("preferredUser", userid)
+    }
+
+    /**
+     * Loads the preferred session by the client
+     */
+    loadPreferredSession() {
+        const sessions = this.loadSessions()
+        let preferredUser = this.getPreferredUser()
+        if (preferredUser == "") {
+            preferredUser = sessions[0].userData.userid
+            this.setPreferredUser(sessions[0].userData.userid)
+        }
+
+        const preferredSession = sessions.find(s => s.userData.userid == preferredUser)
+        if (preferredSession) {
+            return preferredSession
+        } else {
+            return sessions[0]
+        }
+    }
+
+    /**
+     * Validates and updates all sessions and returns with a new session list
+     * @param sessions
+     */
+    updateSessions(sessions: Session[]): Session[] {
+        sessions.forEach(async session => {
+            const index = sessions.indexOf(session)
+            if (!await this.validateSession(session.token)) {
+                this.database.delete("sessions", session.userData.userid)
+                this.keyring.delete(session.userData.userid)
+                sessions.splice(index, 1)
+            }
+
+            const updatedUserData = await this.updateUserData(session)
+            this.database.set("sessions", session.userData.userid, updatedUserData)
+            sessions[index] = updatedUserData
+        })
+
+        return sessions
+    }
+
+    private async validateSession(token: string): Promise<boolean> {
+        try {
+            const resp = await this.client.post<ValidateSessionResp>("v2/user/validateSession", <ValidateSessionReq>{
+                token: token,
+            })
+            return resp.data.validationOk
+        } catch (e) {
+            return true
+        }
+    }
+
+    private async updateUserData(session: Session): Promise<Session> {
+        const authenticatedClient = this.client.create({
+            headers: {
+                "Authorization": session.token,
+            }
+        })
+
+        try {
+            const resp = await authenticatedClient.get<PersonalUserData>(`user/byUseridPersonal?userid=${session.userData.userid}`)
+            session.userData = resp.data
+            return session
+        } catch (e) {
+            throw new Error("Session update error")
+        }
+    }
+}

src/services/textChannelService.ts

@@ -0,0 +1,280 @@
+import {DatabaseAPI} from "../storage/database";
+import {AxiosInstance, isAxiosError} from "axios";
+import {MessageListener} from "../domain/websocket.schema";
+import {getClient} from "../core/http";
+import {WebSocketHandler} from "../core/webSocketHandler";
+import {
+    DeleteMessagesReq,
+    EditMessageReq,
+    FinishMessageReq,
+    GetMessagePosResp, JoinWsRoomReq,
+    Message, PinMessageReq,
+    PinnedMessage, ReadMessagesReq, UnpinMessageReq
+} from "../domain/textChannelService.schema";
+import {NetworkInvite} from "../domain/networkService.schema";
+import {GenericErrorBody} from "../domain/http.schema";
+import {FileData, FileUploadProgressListener} from "../domain/fileUploadService.schema";
+import {FileUploadService} from "./fileUploadService";
+
+export class TextChannelServiceService {
+    userid: string;
+    networkId: string;
+    categoryId: string;
+    channelId: string;
+    token: string;
+    database: DatabaseAPI;
+    client: AxiosInstance
+
+    constructor(userid: string, token: string, networkId: string, categoryId: string, channelId: string, database: DatabaseAPI, wsMessageListener: MessageListener) {
+        this.userid = userid;
+        this.networkId = networkId;
+        this.categoryId = categoryId;
+        this.channelId = channelId;
+        this.database = database;
+        this.token = token;
+        this.client = getClient(false).create({
+            headers: {
+                "Authorization": token,
+                "X-WS-ID": WebSocketHandler.getInstance().connId
+            }
+        })
+        WebSocketHandler.getInstance().registerService({
+            identifier: channelId,
+            onNewConnId: this.onNewConnId,
+            onNewMessage: wsMessageListener,
+        })
+    }
+
+    private onNewConnId(newConnId: string) {
+        console.log("NetworkService: New connection id")
+        this.client.defaults.headers["X-WS-ID"] = newConnId;
+    }
+
+    /**
+     * Fetches all messages in the chat
+     * @param from
+     */
+    async get(from: number = 0): Promise<Message[]> {
+        try {
+            const resp = await this.client.get<Message[]>(`network/channel/messages?networkId=${this.networkId}&channelId=${this.channelId}&categoryId=${this.categoryId}&userid=${this.userid}&from=${from}`);
+            if (from == 0) {
+                this.database.set("networkmessages", this.channelId, JSON.stringify(resp.data))
+            }
+            console.log(resp.data, "ASD")
+            return resp.data
+        } catch (e) {
+            console.log(e)
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    getQuick(): Message[] {
+        const messages = this.database.get("networkmessages", this.channelId)
+        if (messages) {
+            return JSON.parse(messages)
+        } else {
+            throw new Error("No messages in database")
+        }
+    }
+
+    /**
+     * Fetches the position of the specified message which can be used in get() to fetch an old message with it's surrounding messages
+     * @param messageId
+     */
+    async getMessagePos(messageId: string): Promise<number> {
+        try {
+            const resp = await this.client.get<GetMessagePosResp>(`network/channel/getMessagePosition?networkId=${this.networkId}&channelId=${this.channelId}&categoryId=${this.categoryId}&userid=${this.userid}&messageId=${messageId}`);
+            return resp.data.messagePos
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Gets all messages pinned in the chat
+     */
+    async getPinnedMessages(): Promise<PinnedMessage[]> {
+        try {
+            const resp = await this.client.get<PinnedMessage[]>(`network/channel/pinnedMessages?networkId=${this.networkId}&channelId=${this.channelId}&categoryId=${this.categoryId}&userid=${this.userid}`);
+            return resp.data
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Edits the specified message
+     * @param messageId
+     * @param newMessage
+     */
+    async editMessage(messageId: string, newMessage: string): Promise<void> {
+        try {
+            const resp = await this.client.patch("network/channel/editMessage", <EditMessageReq>{
+                messageId: messageId,
+                networkId: this.networkId,
+                channelId: this.channelId,
+                categoryId: this.categoryId,
+                userid: this.userid,
+                message: newMessage
+            });
+            return resp.data
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Sends a new message to the chat
+     * @param message
+     * @param replyTo
+     * @param replyToMessage
+     * @param attachments
+     * @param progressListener
+     */
+    async sendMessage(message: string, replyTo: string | null = null, replyToMessage: string | null = null, attachments: FileData[] | null = null, progressListener: FileUploadProgressListener | null = null): Promise<Message> {
+        let uploadId = ""
+        if (attachments) {
+            const uploader = new FileUploadService(this.token)
+            uploadId = await uploader.uploadFiles(this.channelId, this.userid, attachments, progressListener!)
+        }
+        try {
+            const resp = await this.client.post<Message>("network/channel/finishMessage", <FinishMessageReq>{
+                message: message,
+                networkId: this.networkId,
+                channelId: this.channelId,
+                categoryId: this.categoryId,
+                replyTo: replyTo,
+                replyToMessage: replyToMessage,
+                userid: this.userid,
+                uploadId: uploadId,
+            });
+            return resp.data
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Reads all messages sent to you in the chat
+     */
+    async readMessages(): Promise<void> {
+        try {
+            await this.client.patch("network/channel/readMessages", <ReadMessagesReq>{
+                networkId: this.networkId,
+                channelId: this.channelId,
+                categoryId: this.categoryId,
+                userid: this.userid,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Pins the specified message
+     * @param messageId
+     * @param message
+     */
+    async pinMessage(messageId: string, message: string): Promise<void> {
+        try {
+            const resp = await this.client.patch("network/channel/pinMessage", <PinMessageReq>{
+                messageId: messageId,
+                networkId: this.networkId,
+                channelId: this.channelId,
+                categoryId: this.categoryId,
+                userid: this.userid,
+                message: message
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Unpins the specified message
+     * @param messageId
+     */
+    async unpinMessage(messageId: string): Promise<void> {
+        try {
+            const resp = await this.client.patch("network/channel/unpinMessage", <UnpinMessageReq>{
+                messageId: messageId,
+                networkId: this.networkId,
+                channelId: this.channelId,
+                categoryId: this.categoryId,
+                userid: this.userid,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Deletes the message(s)
+     * @param messageIds
+     */
+    async deleteMessages(messageIds: string[]): Promise<void> {
+        try {
+            const resp = await this.client.patch("network/channel/deleteMessages", <DeleteMessagesReq>{
+                networkId: this.networkId,
+                channelId: this.channelId,
+                categoryId: this.categoryId,
+                userid: this.userid,
+                messageIds: messageIds
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Joins the WebSocket room to start receiving realtime messages
+     */
+    async joinWebSocketRoom(): Promise<void> {
+        try {
+            const resp = await this.client.patch("network/channel/joinWebSocketRoom", <JoinWsRoomReq>{
+                networkId: this.networkId,
+                channelId: this.channelId,
+                categoryId: this.categoryId,
+                userid: this.userid,
+                connId: WebSocketHandler.getInstance().connId,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+}

src/storage/keyring.ts

@@ -1,6 +1,6 @@
 export interface KeyringAPI {
     set(key: string, value: any): void;
     get(key: string): string;
+    getAll(): string[];
     delete(key: string): void;
-    flush(): void;
 }

src/storage/keyvalue.ts

@@ -0,0 +1,6 @@
+export interface KeyValueAPI {
+    set(key: string, value: any): void;
+    get(key: string): string;
+    delete(key: string): void;
+    flush(): void;
+}