refactor

src/db/services/db/UserService.ts

@@ -1,4 +1,4 @@
-import {IUser, UserModel} from "../../models/user";
+import {IUser, SpotifyConfig, UserModel} from "../../models/user";
 import {connectToDatabase} from "./database.service";
 
 export class UserService {
@@ -25,15 +25,15 @@ export class UserService {
     }
 
     public async getAllUsers(): Promise<IUser[]> {
-        return await UserModel.find().exec();
+        return await UserModel.find({}, {password: 0, spotifyConfig: 0, lastState: 0}).exec();
     }
 
     public async getUserById(id: string): Promise<IUser | null> {
-        return await UserModel.findById(id).exec();
+        return await UserModel.findById(id, {password: 0}).exec();
     }
 
     public async getUserByUUID(uuid: string): Promise<IUser | null> {
-        return await UserModel.findOne({uuid}).exec();
+        return await UserModel.findOne({uuid}, {password: 0}).exec();
     }
 
     public async getUserByName(name: string): Promise<IUser | null> {
@@ -42,7 +42,19 @@ export class UserService {
             .exec();
     }
 
-    public async createUser(user: IUser): Promise<IUser> {
-        return await UserModel.create(user);
+    public async getSpotifyConfigByUUID(uuid: string): Promise<SpotifyConfig | undefined> {
+        return await UserModel.findOne({uuid}, {spotifyConfig: 1}).exec().then(user => user?.spotifyConfig);
     }
+
+    public async createUser(user: IUser): Promise<IUser> {
+        const createdUser = await UserModel.create(user);
+
+        const {password, ...rest} = createdUser.toObject();
+        return rest as IUser;
+    }
+
+    public async existsUserByName(name: string): Promise<boolean> {
+        return !!(await UserModel.findOne({name}).exec());
+    }
+
 }

src/interfaces/decodedToken.ts

@@ -1,4 +1,5 @@
 export interface DecodedToken {
-  name: string;
-  _id: string;
+  username: string;
+  id: string;
+  uuid: string;
 }

src/rest/auth.ts

@@ -15,29 +15,28 @@ export class RestAuth {
             const location = req.body.location;
             const password = req.body.password;
             const userService = await UserService.create();
-            const user = await userService.getUserByName(username);
 
-            if (user) {
+            if (await userService.existsUserByName(username)) {
                 res.status(409).send({message: "Username already exists"});
-            } else {
-                const hashedPassword = await bcrypt.hash(password, 10);
-                const newUser: IUser = {
-                    id: ObjectId.createFromTime(Date.now()),
-                    name: username,
-                    password: hashedPassword,
-                    uuid: crypto.randomUUID(),
-                    config: {
-                        isVisible: false,
-                        isAdmin: false,
-                        canBeModified: false
-                    },
-                    timezone,
-                    location
-                };
-                const result = await userService.createUser(newUser);
-                result.password = undefined;
-                res.status(201).send({success: true, user: result});
+                return;
             }
+
+            const hashedPassword = await bcrypt.hash(password, 10);
+            const newUser: IUser = {
+                id: ObjectId.createFromTime(Date.now()),
+                name: username,
+                password: hashedPassword,
+                uuid: crypto.randomUUID(),
+                config: {
+                    isVisible: false,
+                    isAdmin: false,
+                    canBeModified: false
+                },
+                timezone,
+                location
+            };
+            const result = await userService.createUser(newUser);
+            res.status(201).send({success: true, user: result});
         });
 
         router.post("/login", async (req, res) => {
@@ -45,6 +44,7 @@ export class RestAuth {
             const password = req.body.password;
             const userService = await UserService.create();
             const user = await userService.getUserByName(username);
+            console.log(user);
 
             if (!user) {
                 res.status(404).send({success: false, message: "User not found", id: "username"});
@@ -58,10 +58,11 @@ export class RestAuth {
                 return;
             }
 
+
             // generate JWT token here
             const jwtToken = new JwtAuthenticator(
                 process.env.SECRET_KEY!,
-            ).generateToken({username: user.name, id: user.id, uuid: user.uuid});
+            ).generateToken({username: user.name, id: user.id.toString(), uuid: user.uuid});
 
             res.status(200).send({success: true, token: jwtToken});
         });

src/rest/jwtTokenPropertiesExtractor.ts

@@ -1,13 +1,22 @@
 import express from "express";
 
 export class JwtTokenPropertiesExtractor {
-  public createRouter() {
-    const router = express.Router();
+    public createRouter() {
+        const router = express.Router();
 
-    router.get("/_id", (req, res) => {
-      res.status(200).send(req.payload._id);
-    });
+        router.get("/id", (req, res) => {
+            res.status(200).send(req.payload.id);
+        });
 
-    return router;
-  }
+        router.get("/username", (req, res) => {
+            res.status(200).send(req.payload.username);
+        });
+
+        router.get("/uuid", (req, res) => {
+            res.status(200).send(req.payload.uuid);
+        });
+
+
+        return router;
+    }
 }

src/utils/jwtAuthenticator.ts

@@ -18,7 +18,7 @@ export class JwtAuthenticator {
     return null;
   }
 
-  public generateToken(payload: object): string {
+  public generateToken(payload: DecodedToken): string {
     return jwt.sign(payload, this.secret);
   }
 }

src/utils/websocket/websocketEventHandler.ts

@@ -23,7 +23,7 @@ export class WebsocketEventHandler {
     public enableDisconnectEvent(callback: () => void) {
         this.webSocket.onclose = (event) => {
             console.log("WebSocket closed:", event.code, event.reason, event.wasClean, event.type);
-            console.log(`User: ${this.webSocket.payload.name} disconnected`);
+            console.log(`User: ${this.webSocket.payload.username} disconnected`);
             if (this.webSocket.asyncUpdates) {
                 clearInterval(this.webSocket.asyncUpdates);
                 console.log("Async updates stopped");

src/utils/websocket/websocketServerEventHandler.ts

@@ -17,7 +17,7 @@ export class WebsocketServerEventHandler {
         this.webSocketServer.on(
             "connection",
             async (ws: ExtendedWebSocket, request: ExtendedIncomingMessage) => {
-                const user = await (await UserService.create()).getUserByUUID(request.payload._id);
+                const user = await (await UserService.create()).getUserByUUID(request.payload.id);
 
                 ws.user = user!;
 

src/utils/websocket/websocketServerHeartbeatInterval.ts

@@ -8,7 +8,7 @@ export function heartbeat(wss: WebSocketServer) {
         console.log(
           new Date().toLocaleString("de-DE") +
             ":" +
-            ws.payload?.name +
+            ws.payload?.username +
             ": isAlive: " +
             ws.isAlive,
         );

src/websocket.ts

@@ -31,11 +31,11 @@ export class ExtendedWebSocketServer {
         });
     }
 
-    public sendMessageToUser(_id: string, message: string) {
+    public sendMessageToUser(uuid: string, message: string) {
         this.wss.clients.forEach(
             (client: WebSocket & { payload?: DecodedToken }) => {
                 if (
-                    client.payload?._id === _id &&
+                    client.payload?.uuid === uuid &&
                     client.readyState === WebSocket.OPEN
                 ) {
                     client.send(message, {binary: false});
@@ -62,11 +62,12 @@ export class ExtendedWebSocketServer {
             const updateUserInterval = setInterval(async () => {
                 console.log("Updating user")
                 const userService = await UserService.create();
-                const user = await userService.getUserByUUID(ws.payload._id);
+                const user = await userService.getUserByUUID(ws.payload.id);
                 if (user) {
                     ws.user = user;
                 }
             }, 15000);
+
             socketEventHandler.enableDisconnectEvent(() => {
                 clearInterval(updateUserInterval);
                 console.log("stopped updating user");