fix: change servicedepart to roomservices

src/controllers/room_services.ts

@@ -0,0 +1,226 @@
+import { Service, Room, Paging } from "entity";
+import { NextFunction, Response } from "express";
+import { Request } from "express-jwt";
+import Joi from "joi";
+import { ILogObj, Logger } from "tslog";
+import CommonHelper from "../helpers/common";
+import { ReturnHelper } from "../helpers/express/return";
+import { Language } from "../langs/lang";
+import { ServiceModel } from "../model/service";
+import { RoomServicesModel } from "../model/room_services";
+import { RoomModel } from "../model/room";
+import { OrmHelper } from "../helpers/orm";
+import moment from "moment";
+
+const log: Logger<ILogObj> = new Logger({
+    name: "[RoomServicesController]",
+    type: "pretty",
+});
+
+export class RoomServicesController {
+
+    // Controller - List (Room-sided, default)
+    static async list(req: Request, res: Response, next: NextFunction): Promise<void | Response> {
+        /*
+           #swagger.tags = ['Room Services']
+           #swagger.security = [{ "bearerAuth": [] }]
+           #swagger.parameters['filter'] = { description: '', in: 'query', type: 'string' }
+           #swagger.parameters['limit'] = { in: 'query', required: true, type: 'number' }
+           #swagger.parameters['page'] = { in: 'query', required: true, type: 'number' }
+          #swagger.parameters['with_deleted'] = { in: 'query', required: true, type: 'boolean' }
+           #swagger.parameters['order_field'] = { in: 'query', required: true, type: 'string' }
+           #swagger.parameters['order_direction'] = { in: 'query', required: true, schema: { '@enum': ['ASC', 'DESC'] } }
+           */
+        try {
+            const schema = Joi.object().keys({
+                filter: Joi.string().allow("").optional().label("Filter"),
+                page: Joi.number().required().min(1).label("Page"),
+                limit: Joi.number().required().min(1).label("Limit"),
+                with_deleted: Joi.bool().required().label("With Deleted"),
+                order_field: Joi.string().required().label("Order Field"),
+                order_direction: Joi.string().allow("asc", "desc").required().label("Order Direction"),
+            });
+
+            let param: Paging = await schema.validateAsync(req.query);
+            let filter = param.filter && param.filter !== "" ? JSON.parse(param.filter) : {};
+
+            // Get total count of rooms
+            const query = await RoomServicesModel.listByRoom(filter, param.with_deleted);
+            const total_count_data = await query.getCount();
+
+            // Get all rooms with services
+            const rooms = await query
+                .orderBy("Room." + param.order_field, param.order_direction)
+                .skip((param.page - 1) * param.limit)
+                .take(param.limit)
+                .getMany();
+
+            // Transform data: Format room with services
+            const list_data = rooms.map(room => ({
+                id: room.id,
+                room: room.room,
+                code: room.code,
+                description: room.description,
+                status: room.status,
+                department: room.department ? {
+                    id: room.department.id,
+                    name: room.department.name
+                } : null,
+                services: room.services ? room.services.map(service => ({
+                    service_id: service.id,
+                    service_name: service.name
+                })) : []
+            }));
+
+            const count_data = list_data.length;
+
+            return ReturnHelper.successResponselist(
+                res,
+                200,
+                Language.lang.success_view,
+                count_data,
+                param.page,
+                total_count_data,
+                list_data
+            );
+        } catch (e: unknown) {
+            log.error(e);
+            const err = e as Error;
+            return ReturnHelper.errorResponse(
+                res,
+                400,
+                401,
+                Language.lang.failed_view,
+                err.message
+            );
+        }
+    }
+
+    // Controller - List by Service (Service-sided)
+    static async listByService(req: Request, res: Response, next: NextFunction): Promise<void | Response> {
+        /*
+           #swagger.tags = ['Room Services']
+           #swagger.security = [{ "bearerAuth": [] }]
+           #swagger.parameters['filter'] = { description: '', in: 'query', type: 'string' }
+           #swagger.parameters['limit'] = { in: 'query', required: true, type: 'number' }
+           #swagger.parameters['page'] = { in: 'query', required: true, type: 'number' }
+          #swagger.parameters['with_deleted'] = { in: 'query', required: true, type: 'boolean' }
+           #swagger.parameters['order_field'] = { in: 'query', required: true, type: 'string' }
+           #swagger.parameters['order_direction'] = { in: 'query', required: true, schema: { '@enum': ['ASC', 'DESC'] } }
+           */
+        try {
+            const schema = Joi.object().keys({
+                filter: Joi.string().allow("").optional().label("Filter"),
+                page: Joi.number().required().min(1).label("Page"),
+                limit: Joi.number().required().min(1).label("Limit"),
+                with_deleted: Joi.bool().required().label("With Deleted"),
+                order_field: Joi.string().required().label("Order Field"),
+                order_direction: Joi.string().allow("asc", "desc").required().label("Order Direction"),
+            });
+
+            let param: Paging = await schema.validateAsync(req.query);
+            let filter = param.filter && param.filter !== "" ? JSON.parse(param.filter) : {};
+
+            // Get total count of unique services
+            const query = await RoomServicesModel.listByService(filter, param.with_deleted);
+            const total_count_data = await query.getCount();
+
+            // Get all services with rooms
+            const services = await query
+                .orderBy("Service." + param.order_field, param.order_direction)
+                .skip((param.page - 1) * param.limit)
+                .take(param.limit)
+                .getMany();
+
+            // Transform data: Format service with rooms
+            const list_data = services.map(service => ({
+                id: service.id,
+                name: service.name,
+                rooms: service.rooms ? service.rooms.map(room => ({
+                    room_id: room.id,
+                    room: room.room,
+                    code: room.code,
+                    description: room.description,
+                    status: room.status,
+                    department: room.department ? {
+                        id: room.department.id,
+                        name: room.department.name
+                    } : null
+                })) : []
+            }));
+
+            const count_data = list_data.length;
+
+            return ReturnHelper.successResponselist(
+                res,
+                200,
+                Language.lang.success_view,
+                count_data,
+                param.page,
+                total_count_data,
+                list_data
+            );
+        } catch (e: unknown) {
+            log.error(e);
+            const err = e as Error;
+            return ReturnHelper.errorResponse(
+                res,
+                400,
+                401,
+                Language.lang.failed_view,
+                err.message
+            );
+        }
+    }
+
+    static async update(req: Request, res: Response, next: NextFunction): Promise<void | Response> {
+        /*
+     #swagger.tags = ['Room Services']
+     #swagger.security = [{ "bearerAuth": [] }]
+     #swagger.parameters['id'] = { description: 'Room ID', in: 'path', type: 'string' }
+     #swagger.requestBody = { required: true, content: { "application/json": { schema: { $ref: "#/components/schemas/roomServices" } } } }
+     */
+        const queryRunner = OrmHelper.DB.createQueryRunner();
+        await queryRunner.startTransaction();
+
+        try {
+            req.body.id = req.params["id"];
+
+            const schema = Joi.object().keys({
+                id: Joi.string().uuid().required().label("Room ID"),
+                service_ids: Joi.array().items(Joi.string().uuid()).optional().label("Service IDs"),
+            });
+
+            let param: any = await schema.validateAsync(req.body);
+
+            let room = await RoomModel.list({ "Room.id": param.id })
+                .then((q) => q.leftJoinAndSelect("Room.services", "s")
+                    .leftJoinAndSelect("Room.department", "department").getOne());
+
+            if (!room) throw { message: "Room " + Language.lang.failed_not_found };
+
+            let services: any[] = [];
+            if (param.service_ids && param.service_ids.length > 0) {
+                for (const serviceId of param.service_ids) {
+                    const service = await ServiceModel.list({ id: serviceId }).then((q) => q.getOne());
+                    if (service) services.push(service);
+                }
+            }
+
+            room.services = services;
+            room.updated_by = req.auth.data.name;
+            await queryRunner.manager.save(room);
+
+            await queryRunner.commitTransaction();
+
+            return ReturnHelper.successResponseAny(res, 200, Language.lang.success_update, room);
+        } catch (e: unknown) {
+            await queryRunner.rollbackTransaction();
+            log.error(e);
+            const err = e as Error;
+            return ReturnHelper.errorResponse(res, 400, 401, Language.lang.failed_view, err.message);
+        } finally {
+            await queryRunner.release();
+        }
+    }
+}

src/controllers/servicetodepart.ts

@@ -1,156 +0,0 @@
-import { Service, Paging } from "entity";
-import { NextFunction, Response } from "express";
-import { Request } from "express-jwt";
-import Joi from "joi";
-import { ILogObj, Logger } from "tslog";
-import CommonHelper from "../helpers/common";
-import { ReturnHelper } from "../helpers/express/return";
-import { Language } from "../langs/lang";
-import { ServiceModel } from "../model/service";
-import { ServiceToDepartModel } from "../model/service_to_depart";
-import { RoomModel } from "../model/room";
-import { OrmHelper } from "../helpers/orm";
-import moment from "moment";
-
-const log: Logger<ILogObj> = new Logger({
-    name: "[ServiceToDepartController]",
-    type: "pretty",
-});
-
-export class ServiceToDepartController {
-
-    // Controller
-    static async list(req: Request, res: Response, next: NextFunction): Promise<void | Response> {
-        /*
-           #swagger.tags = ['Service to Depart']
-           #swagger.security = [{ "bearerAuth": [] }]
-           #swagger.parameters['filter'] = { description: '', in: 'query', type: 'string' }
-           #swagger.parameters['limit'] = { in: 'query', required: true, type: 'number' }
-           #swagger.parameters['page'] = { in: 'query', required: true, type: 'number' }
-          #swagger.parameters['with_deleted'] = { in: 'query', required: true, type: 'boolean' }
-           #swagger.parameters['order_field'] = { in: 'query', required: true, type: 'string' }
-           #swagger.parameters['order_direction'] = { in: 'query', required: true, schema: { '@enum': ['ASC', 'DESC'] } }
-           */
-        try {
-            const schema = Joi.object().keys({
-                filter: Joi.string().allow("").optional().label("Filter"),
-                page: Joi.number().required().min(1).label("Page"),
-                limit: Joi.number().required().min(1).label("Limit"),
-                with_deleted: Joi.bool().required().label("With Deleted"),
-                order_field: Joi.string().required().label("Order Field"),
-                order_direction: Joi.string().allow("asc", "desc").required().label("Order Direction"),
-            });
-
-            let param: Paging = await schema.validateAsync(req.query);
-            let filter = param.filter && param.filter !== "" ? JSON.parse(param.filter) : {};
-
-            // Get total count of unique rooms
-            const total_count_data = await ServiceToDepartModel.countRooms(filter, param.with_deleted);
-
-            // Get all services dengan rooms
-            const query = await ServiceToDepartModel.list(filter, param.with_deleted);
-            const services = await query
-                .orderBy("Service." + param.order_field, param.order_direction)
-                .getMany();
-
-            // Transform data: Group by room
-            const roomMap = new Map();
-
-            services.forEach(service => {
-                service.rooms.forEach(room => {
-                    if (!roomMap.has(room.id)) {
-                        roomMap.set(room.id, {
-                            room_id: room.id,
-                            department_name: room.department?.name || null,
-                            services: []
-                        });
-                    }
-
-                    // Add service to room's services array
-                    roomMap.get(room.id).services.push({
-                        service_id: service.id,
-                        service_name: service.name
-                    });
-                });
-            });
-
-            // Convert Map to Array
-            const allRooms = Array.from(roomMap.values());
-
-            // Apply paging
-            const offset = (param.page - 1) * param.limit;
-            const list_data = allRooms.slice(offset, offset + param.limit);
-            const count_data = list_data.length;
-
-            return ReturnHelper.successResponselist(
-                res,
-                200,
-                Language.lang.success_view,
-                count_data,
-                param.page,
-                total_count_data,
-                list_data
-            );
-        } catch (e: unknown) {
-            log.error(e);
-            const err = e as Error;
-            return ReturnHelper.errorResponse(
-                res,
-                400,
-                401,
-                Language.lang.failed_view,
-                err.message
-            );
-        }
-    }
-
-    static async update(req: Request, res: Response, next: NextFunction): Promise<void | Response> {
-        /*
-     #swagger.tags = ['Service to Depart']
-     #swagger.security = [{ "bearerAuth": [] }]
-     #swagger.parameters['id'] = { description: 'Service ID', in: 'path', type: 'string' }
-     #swagger.requestBody = { required: true, content: { "application/json": { schema: { $ref: "#/components/schemas/servicetodepart" } } } }
-     */
-        const queryRunner = OrmHelper.DB.createQueryRunner();
-        await queryRunner.startTransaction();
-
-        try {
-            req.body.id = req.params["id"];
-
-            const schema = Joi.object().keys({
-                id: Joi.string().uuid().required().label("Service ID"),
-                room_ids: Joi.array().items(Joi.string().uuid()).optional().label("Room IDs"),
-            });
-
-            let param: any = await schema.validateAsync(req.body);
-
-            let service = await ServiceModel.list({ "Service.id": param.id })
-                .then((q) => q.leftJoinAndSelect("Service.serviceType", "st").leftJoinAndSelect("Service.rooms", "r").getOne());
-
-            if (!service) throw { message: "Service " + Language.lang.failed_not_found };
-
-            let rooms: any[] = [];
-            if (param.room_ids && param.room_ids.length > 0) {
-                for (const roomId of param.room_ids) {
-                    const room = await RoomModel.list({ id: roomId }).then((q) => q.getOne());
-                    if (room) rooms.push(room);
-                }
-            }
-
-            service.rooms = rooms;
-            service.updated_by = req.auth.data.name;
-            await queryRunner.manager.save(service);
-
-            await queryRunner.commitTransaction();
-
-            return ReturnHelper.successResponseAny(res, 200, Language.lang.success_update, service);
-        } catch (e: unknown) {
-            await queryRunner.rollbackTransaction();
-            log.error(e);
-            const err = e as Error;
-            return ReturnHelper.errorResponse(res, 400, 401, Language.lang.failed_view, err.message);
-        } finally {
-            await queryRunner.release();
-        }
-    }
-}

src/model/room_services.ts

@@ -0,0 +1,107 @@
+// RoomServicesModel.ts
+import { Service, Room } from "entity";
+import { SelectQueryBuilder } from "typeorm";
+import CommonHelper from "../helpers/common";
+import { OrmHelper } from "../helpers/orm";
+
+export class RoomServicesModel {
+    static async listByService(filter = {}, withDeleted = false): Promise<SelectQueryBuilder<Service>> {
+        const repo = OrmHelper.DB.getRepository(Service);
+        let whereAttr: string[] = [];
+        let whereVal: any = {};
+        
+        if (filter && Object.keys(filter).length > 0) {
+            const filterResult = CommonHelper.handleQueryFilter(filter);
+            whereAttr = [...whereAttr, ...filterResult.whereAttr];
+            whereVal = { ...whereVal, ...filterResult.whereVal };
+        }
+
+        let query = repo.createQueryBuilder("Service")
+            .leftJoinAndSelect("Service.rooms", "Room")
+            .leftJoinAndSelect("Room.department", "Department");
+
+        if (whereAttr.length != 0) {
+            query = query.where(whereAttr.join(" and "), whereVal);
+        }
+
+        if (withDeleted) {
+            query = query.withDeleted();
+        }
+
+        return query;
+    }
+
+    static async listByRoom(filter = {}, withDeleted = false): Promise<SelectQueryBuilder<Room>> {
+        const repo = OrmHelper.DB.getRepository(Room);
+        let whereAttr: string[] = [];
+        let whereVal: any = {};
+        
+        if (filter && Object.keys(filter).length > 0) {
+            const filterResult = CommonHelper.handleQueryFilter(filter, "Room");
+            whereAttr = [...whereAttr, ...filterResult.whereAttr];
+            whereVal = { ...whereVal, ...filterResult.whereVal };
+        }
+
+        let query = repo.createQueryBuilder("Room")
+            .leftJoinAndSelect("Room.services", "Service")
+            .leftJoinAndSelect("Room.department", "Department");
+
+        if (whereAttr.length != 0) {
+            query = query.where(whereAttr.join(" and "), whereVal);
+        }
+
+        if (withDeleted) {
+            query = query.withDeleted();
+        }
+
+        return query;
+    }
+
+    // Method untuk count rooms (bukan relationships)
+    static async countRooms(filter = {}, withDeleted = false): Promise<number> {
+        const repo = OrmHelper.DB.getRepository(Service);
+        
+        // Query untuk menghitung total unique rooms yang punya services
+        let queryBuilder = repo.createQueryBuilder("Service")
+            .innerJoin("Service.rooms", "Room")
+            .select("COUNT(DISTINCT Room.id)", "count");
+
+        if (filter && Object.keys(filter).length > 0) {
+            const filterResult = CommonHelper.handleQueryFilter(filter);
+            if (filterResult.whereAttr.length > 0) {
+                queryBuilder = queryBuilder.where(filterResult.whereAttr.join(" and "), filterResult.whereVal);
+            }
+        }
+
+        if (withDeleted) {
+            queryBuilder = queryBuilder.withDeleted();
+        }
+
+        const result = await queryBuilder.getRawOne();
+        return parseInt(result.count) || 0;
+    }
+
+    // Method untuk count services
+    static async countServices(filter = {}, withDeleted = false): Promise<number> {
+        const repo = OrmHelper.DB.getRepository(Room);
+        
+        // Query untuk menghitung total unique services yang punya rooms
+        let queryBuilder = repo.createQueryBuilder("Room")
+            .innerJoin("Room.services", "Service")
+            .select("COUNT(DISTINCT Service.id)", "count");
+
+        if (filter && Object.keys(filter).length > 0) {
+            const filterResult = CommonHelper.handleQueryFilter(filter, "Room");
+            if (filterResult.whereAttr.length > 0) {
+                queryBuilder = queryBuilder.where(filterResult.whereAttr.join(" and "), filterResult.whereVal);
+            }
+        }
+
+        if (withDeleted) {
+            queryBuilder = queryBuilder.withDeleted();
+        }
+
+        const result = await queryBuilder.getRawOne();
+        return parseInt(result.count) || 0;
+    }
+}

src/model/service_to_depart.ts

@@ -1,57 +0,0 @@
-// ServiceToDepartModel.ts
-import { Service } from "entity";
-import { SelectQueryBuilder } from "typeorm";
-import CommonHelper from "../helpers/common";
-import { OrmHelper } from "../helpers/orm";
-
-export class ServiceToDepartModel {
-    static async list(filter = {}, withDeleted = false): Promise<SelectQueryBuilder<Service>> {
-        const repo = OrmHelper.DB.getRepository(Service);
-        let whereAttr: string[] = [];
-        let whereVal: any = {};
-        
-        if (filter && Object.keys(filter).length > 0) {
-            const filterResult = CommonHelper.handleQueryFilter(filter);
-            whereAttr = [...whereAttr, ...filterResult.whereAttr];
-            whereVal = { ...whereVal, ...filterResult.whereVal };
-        }
-
-        let query = repo.createQueryBuilder("Service")
-            .leftJoinAndSelect("Service.rooms", "Room")
-            .leftJoinAndSelect("Room.department", "Department");
-
-        if (whereAttr.length != 0) {
-            query = query.where(whereAttr.join(" and "), whereVal);
-        }
-
-        if (withDeleted) {
-            query = query.withDeleted();
-        }
-
-        return query;
-    }
-
-    // Method baru untuk count rooms (bukan relationships)
-    static async countRooms(filter = {}, withDeleted = false): Promise<number> {
-        const repo = OrmHelper.DB.getRepository(Service);
-        
-        // Query untuk menghitung total unique rooms yang punya services
-        let queryBuilder = repo.createQueryBuilder("Service")
-            .innerJoin("Service.rooms", "Room")
-            .select("COUNT(DISTINCT Room.id)", "count");
-
-        if (filter && Object.keys(filter).length > 0) {
-            const filterResult = CommonHelper.handleQueryFilter(filter);
-            if (filterResult.whereAttr.length > 0) {
-                queryBuilder = queryBuilder.where(filterResult.whereAttr.join(" and "), filterResult.whereVal);
-            }
-        }
-
-        if (withDeleted) {
-            queryBuilder = queryBuilder.withDeleted();
-        }
-
-        const result = await queryBuilder.getRawOne();
-        return parseInt(result.count) || 0;
-    }
-}

src/routes/private.ts

@@ -12,6 +12,7 @@ import { NationalityController } from '../controllers/nationality';
 import { DiagnosisController } from '../controllers/diagnosis';
 import { DiagnosticProcedureController } from '../controllers/diagnostic_procedure';
 import { RoomController } from '../controllers/room';
+import { RoomServicesController } from '../controllers/room_services';
 import { ServiceTypeController } from '../controllers/service_type';
 import { ServiceClassController } from '../controllers/service_class';
 import { ServiceController } from '../controllers/service';
@@ -19,7 +20,6 @@ import { ServiceFareController } from '../controllers/service_fare';
 import { ServicePackageController } from '../controllers/service_package';
 import { DepartmentController } from '../controllers/department';
 import { DoctorScheduleController } from '../controllers/doctor_schedule';
-import { ServiceToDepartController } from '../controllers/servicetodepart'
 import { MeasurementUnitController } from '../controllers/measurement_unit';
 import { ReferenceRangeController } from '../controllers/reference_range';
 import { QueueMonitoringController } from '../controllers/queue_monitoring';
@@ -111,6 +111,10 @@ export class RoutePrivate {
         app.delete('/api/room/delete/:id/:hard', RoomController.delete)
         app.put('/api/room/restore/:id', RoomController.restore)
 
+        app.get('/api/room-services/list', RoomServicesController.list)
+        app.get('/api/room-services/list-by-service', RoomServicesController.listByService)
+        app.put('/api/room-services/:id', RoomServicesController.update)
+
         app.get('/api/service-type/list', ServiceTypeController.list)
         app.post('/api/service-type/create', ServiceTypeController.create)
         app.get('/api/service-type/detail/:id', ServiceTypeController.detail)
@@ -159,9 +163,6 @@ export class RoutePrivate {
         app.put('/api/doctor-schedule/update/:id', DoctorScheduleController.update)
         app.delete('/api/doctor-schedule/delete/:id/:hard', DoctorScheduleController.delete)
         app.put('/api/doctor-schedule/restore/:id', DoctorScheduleController.restore)
-
-        app.get('/api/service-to-depart/list', ServiceToDepartController.list)
-        app.put('/api/service-to-depart/:id', ServiceToDepartController.update)
         
         app.get('/api/measurement-unit/list', MeasurementUnitController.list)
         app.post('/api/measurement-unit/create', MeasurementUnitController.create)

src/swagger/builder.js

@@ -126,8 +126,8 @@ const doc = {
                 $room_ids: ["uuid-string"],
                 $status: { "@enum": ["Y", "N"] }
             },
-            servicetodepart: {
+            roomServices: {
-                $room_ids: ["uuid-string"]
+                $service_ids: ["uuid-string"]
             },
             serviceFare: {
                 $service_class_id: "uuid-string",