update:feature to room done

src/controllers/servicetodepart.ts

@@ -0,0 +1,156 @@
+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/service_to_depart.ts

@@ -0,0 +1,57 @@
+// 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

@@ -19,6 +19,7 @@ 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'
 
 export class RoutePrivate {
     static setup(app: express.Application) {
@@ -124,7 +125,6 @@ export class RoutePrivate {
         app.put('/api/service/update/:id', ServiceController.update)
         app.delete('/api/service/delete/:id/:hard', ServiceController.delete)
         app.put('/api/service/restore/:id', ServiceController.restore)
-        app.put('/api/service/update-service-rooms/:id', ServiceController.updateservicerooms)
 
         app.get('/api/service-fare/list', ServiceFareController.list)
         app.post('/api/service-fare/create', ServiceFareController.create)
@@ -153,5 +153,8 @@ 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)
     }
 }

src/swagger/builder.js

@@ -125,7 +125,7 @@ const doc = {
                 $service_type_id: "uuid-string",
                 $room_ids: ["uuid-string"]
             },
-            servicerooms: {
+            servicetodepart: {
                 $room_ids: ["uuid-string"]
             },
             serviceFare: {