fixing user to room

src/controllers/user_to_room.ts

@@ -176,41 +176,53 @@ export class UserToRoomController {
                 .uuid()
                 .required()
                 .label("User ID"),
+
+                room_id: Joi.string()
+                .uuid()
+                .required()
+                .label("Room ID"),
         
-                room_ids: Joi.array()
+                // room_ids: Joi.array()
-                    .items(Joi.string().uuid().required())
+                //     .items(Joi.string().uuid().required())
-                    .min(1)
+                //     .min(1)
-                    .required()
+                //     .required()
-                    .label("Factory IDs")
+                //     .label("Factory IDs")
             });
 
             const param: any = await schema.validateAsync(req.body);
 
-            const userToRoomRepo = OrmHelper.DB.getRepository(UserToRoom);
+            // const userToRoomRepo = OrmHelper.DB.getRepository(UserToRoom);
-            const userRepo = OrmHelper.DB.getRepository(User);
+            // const userRepo = OrmHelper.DB.getRepository(User);
-            const roomRepo = OrmHelper.DB.getRepository(Room);
+            // const roomRepo = OrmHelper.DB.getRepository(Room);
 
-            await userToRoomRepo
+            // await userToRoomRepo
-                .createQueryBuilder()
+            //     .createQueryBuilder()
-                .delete()
+            //     .delete()
-                .from(UserToRoom)
+            //     .from(UserToRoom)
-                .where("service_id = :userId", { userId: param.user_id })
+            //     .where("service_id = :userId", { userId: param.user_id })
-                .execute();
+            //     .execute();
 
-            let relation : UserToRoom;
+            const data = new UserToRoom()
-            for (const roomId of param.room_ids) {
+            data.user = param.user_id;
-                relation = new UserToRoom();
+            data.room = param.room_id;
-                relation.user = await userRepo.findOneBy({ id: param.user_id });
+            data.created_by = req.auth.data.name;
-                relation.room = await roomRepo.findOneBy({ id: roomId });
-                relation.created_by = req.auth.data.name;
 
-                await userToRoomRepo.save(relation);
+            await OrmHelper.DB.manager.save(data);
-            }
 
-            const data = await userToRoomRepo.createQueryBuilder("user_to_room")
+            // let relation : UserToRoom;
-            .leftJoinAndSelect("user_to_room.user", "user")
+            // for (const roomId of param.room_ids) {
-            .leftJoinAndSelect("user_to_room.room", "room")
+            //     relation = new UserToRoom();
-            .where("user_to_room.service_id = :userId", { userId: param.user_id }).getMany();
+            //     relation.user = await userRepo.findOneBy({ id: param.user_id });
+            //     relation.room = await roomRepo.findOneBy({ id: roomId });
+            //     relation.created_by = req.auth.data.name;
+
+            //     await userToRoomRepo.save(relation);
+            // }
+
+            // const data = await userToRoomRepo.createQueryBuilder("user_to_room")
+            // .leftJoinAndSelect("user_to_room.user", "user")
+            // .leftJoinAndSelect("user_to_room.room", "room")
+            // .where("user_to_room.service_id = :userId", { userId: param.user_id }).getMany();
 
             return ReturnHelper.successResponseAny(res, 200, Language.lang.success_insert, data);
         } catch (e: unknown) {
@@ -220,4 +232,87 @@ export class UserToRoomController {
             return ReturnHelper.errorResponse(res, 500, 401, Language.lang.failed_insert, err.message);
         }
     }
+
+    static async update(req: Request, res: Response, next: NextFunction): Promise<Response> {
+            /*
+            #swagger.tags = ['UserToRoom']
+            #swagger.security = [{
+                "bearerAuth": []
+            }]
+             #swagger.parameters['id'] = {
+                in: 'path',
+                description: 'UserToRoom ID.',
+                required: true,
+                type: 'string'
+            }
+        
+             #swagger.requestBody = {
+                required: true,
+                content: {
+                    "application/json": {
+                        schema: {
+                             $ref: "#/components/schemas/user_to_room"
+                        }  
+                    }
+                }
+            }
+            */
+    
+            try {
+                const schema = Joi.object().keys({
+                    id: Joi.string().uuid().required().label('ID'),
+                    user_id: Joi.string().uuid().required().label('User ID'),
+                    room_id: Joi.string().uuid().required().label('Room ID'),
+                });
+    
+                req.body.id = req.params['id'];
+    
+                const param: any = await schema.validateAsync(req.body);
+    
+                const repo = OrmHelper.DB.getRepository(UserToRoom);
+    
+                const data = await repo.findOneBy({ id: param.id });
+    
+                if (data != null) {
+                    data.user = param.user_id;
+                    data.room = param.room_id;
+                    data.updated_by = req.auth.data.name;
+    
+                    await repo.save(data);
+    
+                    return ReturnHelper.successResponseAny(res, 200, Language.lang.success_update, data);
+                } else {
+                    return ReturnHelper.errorResponse(res, 404, 401, Language.lang.failed_not_found, "");
+                }
+            } catch (e: unknown) {
+                log.error(e);
+                const err = e as Error;
+    
+                return ReturnHelper.errorResponse(res, 500, 402, Language.lang.failed_update, err.message);
+            }
+        }
+
+    static async detail(req: Request, res: Response, next: NextFunction): Promise<void | Response> {
+            /*
+                #swagger.tags = ['UserToRoom']
+                #swagger.security = [{ "bearerAuth": [] }]
+                #swagger.parameters['id'] = { description: '', in: 'path', type: 'string' }
+                */
+            try {
+                const schema = Joi.object().keys({
+                    id: Joi.string().uuid().required().label("UserToRoom Id"),
+                });
+    
+                let param: any = await schema.validateAsync(req.params);
+    
+                let data = await UserToRoomModel.list({ "id": param.id }).then((q) => q.getOne());
+                if (!data) throw { message: "UserToRoom Not Found" };
+    
+                return ReturnHelper.successResponseAny(res, 200, Language.lang.success_view, data);
+            } catch (e: unknown) {
+                log.error(e);
+                const err = e as Error;
+                return ReturnHelper.errorResponse(res, 400, 401, Language.lang.failed_not_found, err.message);
+            }
+        }
 }

src/routes/private.ts

@@ -442,6 +442,8 @@ export class RoutePrivate {
         app.get('/api/user-to-room/list', UserToRoomController.list)
         app.get('/api/user-to-room/export', UserToRoomController.export)
         app.post('/api/user-to-room/create', UserToRoomController.create)
+        app.put('/api/user-to-room/update/:id', UserToRoomController.update)
+        app.get('/api/user-to-room/view/:id', UserToRoomController.detail)
 
         app.get('/api/room-to-pharmacy/list', RoomToPharmacyController.list)
         app.get('/api/room-to-pharmacy/export', RoomToPharmacyController.export)

src/swagger/builder.js

@@ -348,7 +348,7 @@ const doc = {
       },
       user_to_room: {
         $user_id: "user ID (required, UUID)",
-        $room_ids: "Array [room-uuid-1, room-uuid-2]",
+        $room_id: "Room ID (required, UUID)",
       },
       room_to_pharmacy: {
         $pharmacy_room_id: "Pharmacy Room ID (required, UUID)",