Merge pull request #33 from CodeLog-Development/dev

Merge dev into main for v0.1.2

Author: JacoMalan1

api/src/lib/firebase/firebase.module.ts

@@ -1,7 +1,9 @@
 import { Module } from '@nestjs/common';
 import { FirebaseService } from './firebase.service';
+import { UserModule } from '../user/user.module';
 
 @Module({
+  imports: [UserModule],
   providers: [FirebaseService],
 })
 export class FirebaseModule { }

api/src/lib/firebase/firebase.service.ts

@@ -3,11 +3,24 @@ import { Firestore, getFirestore } from 'firebase-admin/firestore';
 import { credential } from 'firebase-admin';
 import { ServiceAccount, initializeApp } from 'firebase-admin/app';
 import { ConfigService } from '@nestjs/config';
+import { GatekeeperNotification } from './notification.interface';
+import {
+  ConditionMessage,
+  getMessaging,
+  Messaging,
+  TopicMessage,
+} from 'firebase-admin/messaging';
+import { UserService } from '../user/user.service';
 
 @Injectable()
 export class FirebaseService {
   private readonly firestore?: Firestore;
-  constructor(private configService: ConfigService) {
+  private readonly messaging?: Messaging;
+
+  constructor(
+    private configService: ConfigService,
+    private userService: UserService,
+  ) {
     const serviceAccount =
       this.configService.get<ServiceAccount>('serviceAccount');
 
@@ -20,6 +33,7 @@ export class FirebaseService {
         credential: credential.cert(serviceAccount),
       });
       this.firestore = getFirestore(app);
+      this.messaging = getMessaging(app);
     } catch (e) {
       console.info('Firebase app already initialized');
     }
@@ -28,4 +42,25 @@ export class FirebaseService {
   getFirestore(): Firestore | undefined {
     return this.firestore;
   }
+
+  async sendNotification(
+    notification: GatekeeperNotification,
+  ): Promise<boolean> {
+    try {
+      const tokens: string[] =
+        await this.userService.getAllNotificationTokens();
+
+      await this.messaging?.sendEachForMulticast({
+        tokens,
+        notification: {
+          title: notification.title,
+          body: notification.message,
+        },
+      });
+
+      return true;
+    } catch (_e) {
+      return false;
+    }
+  }
 }

api/src/lib/firebase/notification.interface.ts

@@ -0,0 +1,4 @@
+export interface GatekeeperNotification {
+  title: string;
+  message: string;
+}

api/src/lib/server/server.controller.spec.ts

@@ -0,0 +1,83 @@
+import { ServerController } from './server.controller';
+import {
+  StartInstanceRequest,
+  StartServerResponse,
+  StopServerResponse,
+} from './server.interface';
+import { ServerService, ServerStatus } from './server.service';
+import { Test } from '@nestjs/testing';
+
+describe('ServerController', () => {
+  let serverController: ServerController;
+  let serverService: ServerService;
+
+  beforeEach(async () => {
+    const moduleRef = await Test.createTestingModule({
+      controllers: [ServerController],
+      providers: [ServerService],
+    }).compile();
+
+    serverService = moduleRef.get<ServerService>(ServerService);
+    serverController = new ServerController(serverService);
+  });
+
+  describe('getStatus', () => {
+    it('should return the server status', async () => {
+      const result: ServerStatus = {
+        success: true,
+        message: 'Lorem ipsum',
+        running: [],
+      };
+
+      jest
+        .spyOn(serverService, 'getServerStatus')
+        .mockImplementation(async () => {
+          return result;
+        });
+
+      expect(await serverController.getStatus()).toBe(result);
+    });
+  });
+
+  describe('startServer', () => {
+    it('should start the server', async () => {
+      const result: StartServerResponse = {
+        success: true,
+        message: 'Lorem ipsum',
+        started: ['1234'],
+      };
+
+      jest
+        .spyOn(serverService, 'startInstance')
+        .mockImplementation(async (id: string) => {
+          return {
+            success: true,
+            message: 'Lorem ipsum',
+            started: [id],
+          };
+        });
+
+      expect(
+        await serverController.startServer({ instanceId: '1234' }),
+      ).toStrictEqual(result);
+    });
+  });
+
+  describe('stopServer', () => {
+    it('should stop the server', async () => {
+      const result: StopServerResponse = {
+        success: true,
+        message: 'Lorem ipsum',
+        stopped: ['1234'],
+      };
+
+      jest.spyOn(serverService, 'stopServer').mockImplementation(async () => {
+        return result;
+      });
+
+      expect(
+        await serverController.stopServer({ instanceId: '1234' }),
+      ).toStrictEqual(result);
+    });
+  });
+});

api/src/lib/server/server.controller.ts

@@ -18,14 +18,14 @@ export class ServerController {
 
   @Post('start')
   async startServer(
-    @Body() startRequest: StartInstanceRequest
+    @Body() startRequest: StartInstanceRequest,
   ): Promise<StartServerResponse> {
     return await this.serverService.startInstance(startRequest.instanceId);
   }
 
   @Post('stop')
   async stopServer(
-    @Body() stopRequest: StopServerRequest
+    @Body() stopRequest: StopServerRequest,
   ): Promise<StopServerResponse> {
     return await this.serverService.stopServer(stopRequest.instanceId);
   }

api/src/lib/server/server.service.ts

@@ -2,6 +2,7 @@ import { Injectable, OnModuleInit } from '@nestjs/common';
 import { Ec2Service } from '../aws/ec2/ec2.service';
 import { ModuleRef } from '@nestjs/core';
 import { StartServerResponse, StopServerResponse } from './server.interface';
+import { FirebaseService } from '../firebase/firebase.service';
 
 export interface ServerStatus {
   success: boolean;
@@ -12,10 +13,14 @@ export interface ServerStatus {
 @Injectable()
 export class ServerService implements OnModuleInit {
   private ec2Service?: Ec2Service;
+  private firebaseService?: FirebaseService;
   constructor(private moduleRef: ModuleRef) { }
 
   onModuleInit() {
     this.ec2Service = this.moduleRef.get(Ec2Service, { strict: false });
+    this.firebaseService = this.moduleRef.get(FirebaseService, {
+      strict: false,
+    });
   }
 
   async getServerStatus(): Promise<ServerStatus> {
@@ -42,33 +47,49 @@ export class ServerService implements OnModuleInit {
   }
 
   async startInstance(id: string): Promise<StartServerResponse> {
-    if (!this.ec2Service) {
+    if (!this.ec2Service || !this.firebaseService) {
       return {
         success: false,
-        message: "Couldn't communicate with EC2 service",
+        message: "Couldn't communicate with required services",
       };
     }
 
     try {
       await this.ec2Service.startInstance(id);
+      await this.firebaseService.sendNotification({
+        title: 'Server started',
+        message: '✅ The Ultimate Reloaded server has been started',
+      });
       return { success: true, message: 'Instance started', started: [id] };
     } catch (e) {
+      console.warn(
+        ' 🚀 ~ server.service.ts → Caught an error trying to start the server',
+        e,
+      );
       return { success: false, message: 'Failed to start instance' };
     }
   }
 
   async stopServer(id: string): Promise<StopServerResponse> {
-    if (!this.ec2Service) {
+    if (!this.ec2Service || !this.firebaseService) {
       return {
         success: false,
-        message: "Could't communicate with EC2 service",
+        message: "Could't communicate with required services",
       };
     }
 
     try {
       await this.ec2Service.stopInstance(id);
+      await this.firebaseService.sendNotification({
+        title: 'Server stopped',
+        message: '⛔ The Ultimate Reloaded server has been stopped',
+      });
       return { success: true, message: 'Instance stopped', stopped: [id] };
     } catch (e) {
+      console.warn(
+        ' 🚀 ~ server.service.ts → Caught an error trying to stop the server',
+        e,
+      );
       return { success: false, message: 'Failed to stop instance' };
     }
   }

api/src/lib/user/user.controller.ts

@@ -11,6 +11,7 @@ import {
 import {
   AuthRequest,
   ChangePasswordRequest,
+  ChangeTokenRequest,
   NewUser,
   UserInfoResponse,
   validatePassword,
@@ -45,6 +46,31 @@ export class UserController {
     };
   }
 
+  @Patch('/notificationToken')
+  async setNotificationToken(
+    @Body() input: ChangeTokenRequest,
+    @Req() request: Request,
+  ): Promise<ApiResponse> {
+    if (!request.user) {
+      return { success: false, message: 'Could not find user information' };
+    }
+
+    try {
+      const ref = await this.userService.findUserByUsernameRef(
+        request.user.username,
+      );
+      if (ref !== undefined) {
+        await this.userService.setNotificationToken(ref, input.token);
+        return { success: true, message: 'Notification token updated' };
+      } else {
+        return { success: false, message: 'Could not find user information' };
+      }
+    } catch (e) {
+      console.error('Failed to update notification token', e);
+      return { success: false, message: 'An unkown error occurred' };
+    }
+  }
+
   @Patch('/password')
   async changePassword(
     @Body() input: ChangePasswordRequest,

api/src/lib/user/user.interface.ts

@@ -1,6 +1,10 @@
 import { DocumentReference } from 'firebase-admin/firestore';
 import { ApiResponse } from '../api.interface';
 
+export interface ChangeTokenRequest {
+  token: string;
+}
+
 export interface NewUser {
   username: string;
   email: string;
@@ -12,6 +16,7 @@ export interface User {
   email: string;
   passwordHash: string;
   verified: boolean;
+  notificationToken?: string;
 }
 
 export interface AuthRequest {

api/src/lib/user/user.module.ts

@@ -11,6 +11,7 @@ import { AuthenticationMiddleware } from '../auth/auth.middleware';
 @Module({
   providers: [UserService],
   controllers: [UserController],
+  exports: [UserService],
 })
 export class UserModule implements NestModule {
   configure(consumer: MiddlewareConsumer) {
@@ -23,6 +24,10 @@ export class UserModule implements NestModule {
         path: 'user/info',
         method: RequestMethod.GET,
       },
+      {
+        path: 'user/notificationToken',
+        method: RequestMethod.PATCH,
+      },
     );
   }
 }

api/src/lib/user/user.service.ts

@@ -4,7 +4,11 @@ import { FirebaseService } from '../firebase/firebase.service';
 import * as argon2 from 'argon2';
 import { ModuleRef } from '@nestjs/core';
 import { randomBytes } from 'crypto';
-import { DocumentData, DocumentReference } from 'firebase-admin/firestore';
+import {
+  CollectionReference,
+  DocumentData,
+  DocumentReference,
+} from 'firebase-admin/firestore';
 
 @Injectable()
 export class UserService implements OnModuleInit {
@@ -16,6 +20,10 @@ export class UserService implements OnModuleInit {
     });
   }
 
+  async setNotificationToken(userRef: DocumentReference<User>, token: string) {
+    await userRef.set({ notificationToken: token }, { merge: true });
+  }
+
   async changePassword(
     userRef: DocumentReference,
     newPassword: string,
@@ -182,4 +190,20 @@ export class UserService implements OnModuleInit {
 
     return user;
   }
+
+  async getAllNotificationTokens(): Promise<string[]> {
+    const firestore = this.firebaseService?.getFirestore();
+    const collection = firestore?.collection('/users');
+    const docs = await collection?.get();
+    const tokens = [];
+
+    for (const d of docs?.docs || []) {
+      const doc = d.data() as User;
+      if (doc.notificationToken) {
+        tokens.push(doc.notificationToken);
+      }
+    }
+
+    return tokens;
+  }
 }