better notificationController API and docs

server/src/controllers/notificationController.ts

@@ -1,27 +1,72 @@
 import { WebSocket } from 'ws';
 
 class NotificationController {
-    private active: Map<number, WebSocket>;
+    private active: Map<number, WebSocket | null>;
 
     constructor() {
         this.active = new Map();
     }
 
-    add(ticketNumber: number, ws: WebSocket): void {
-        this.active.set(ticketNumber, ws);
+    hasTicket(ticketNumber: number): boolean {
+        return this.active.has(ticketNumber);
     }
 
-    remove(ticketNumber: number): boolean {
-        const ws = this.active.get(ticketNumber);
+    /**
+     * To be called when delivering the ticket number to the customer.
+     * @returns `false` if the ticket already exists, `true` otherwise
+     */
+    addTicket(ticketNumber: number): boolean {
+        if (this.hasTicket(ticketNumber))
+            return false;
+        this.active.set(ticketNumber, null);
+        return true;
+    }
+
+    /**
+     * To be called when a the user connects to the endpoint corresponding to the ticket.
+     * If a connection already exists, it is overridden.
+     * @returns `false` if the ticket does not exist, `true` otherwise
+     */
+    addConnection(ticketNumber: number, ws: WebSocket): boolean {
+        if (!this.removeConnection(ticketNumber))
+            return false;
+
+        this.active.set(ticketNumber, ws);
+        return true;
+    }
 
-        if (!ws)
+    /**
+     * Removes a ticket from the active tickets. To be called when an user has been served.
+     * @returns `false` if the ticket does not exist, `true` otherwise
+     */
+    removeTicket(ticketNumber: number): boolean {
+        if (!this.removeConnection(ticketNumber))
             return false;
-        if (ws.readyState !== ws.CLOSED && ws.readyState !== ws.CLOSING)
-            ws.close();
 
         return this.active.delete(ticketNumber);
     }
 
+    /**
+     * Closes an existing connection for a specific ticket.
+     * To be called in case the connection is interrupted.
+     * @returns `false` if the ticket does not exist, `true` otherwise
+     */
+    removeConnection(ticketNumber: number): boolean {
+        const curr = this.active.get(ticketNumber);
+        if (curr === undefined)
+            return false;
+        if (curr && curr.readyState !== curr.CLOSED && curr.readyState !== curr.CLOSING) {
+            curr.close();
+        }
+
+        this.active.set(ticketNumber, null);
+        return true;
+    }
+
+    /**
+     * Notifies the user corresponding to the `ticketNumber`
+     * @returns `false` if the ticket does not exist, `true` otherwise
+     */
     notify(ticketNumber: number, counter: number): boolean {
         const ws = this.active.get(ticketNumber);
         if(!ws)

server/src/routers/notificationRoutes.ts

@@ -11,11 +11,14 @@ router.ws("/tickets/notification/:ticketId", [
     validateWsRequest,
     async (req: any, res: WSResponse) => {
         const ticketId = Number(req.params.ticketId);
+        if (!notificationController.hasTicket(ticketId)) {
+            return res.status(422);
+        }
 
         const ws = await res.accept();
-        notificationController.add(ticketId, ws)
+        notificationController.addConnection(ticketId, ws)
         ws.on('close', () => {
-            notificationController.remove(ticketId);
+            notificationController.removeConnection(ticketId);
         });
     }
 );

server/test_integration/notificationIntegration.test.ts

@@ -16,14 +16,16 @@ describe('Notification controller API tests', () => {
     const ticketNumber = 3;
     const counter = 3;
 
+    notificationController.addTicket(ticketNumber);
     const ws = await request(server).ws(`/api/tickets/notification/${ticketNumber}`);
 
     ws.on('message', (data: WebSocket.RawData, isBinary: boolean) => {
       expect(isBinary).toBe(false);
       expect(data).toStrictEqual(Buffer.from(`${counter}\n`))
     });
 
-    notificationController.notify(ticketNumber, counter);
+    const ret = notificationController.notify(ticketNumber, counter);
+    expect(ret).toBe(true);
   });
 
   it('2 - negative ticket number', async () => {