From 9102d5b097c6a4212f388dfd20e03b4d5c260908 Mon Sep 17 00:00:00 2001 From: Narul Hidayah Date: Wed, 11 Feb 2026 11:20:24 +0700 Subject: [PATCH] upd --- src/controllers/service.ts | 278 ++++++++++++++++++++++++++++ src/controllers/service_class.ts | 251 +++++++++++++++++++++++++ src/controllers/service_fare.ts | 283 ++++++++++++++++++++++++++++ src/controllers/service_package.ts | 287 +++++++++++++++++++++++++++++ src/controllers/service_type.ts | 255 +++++++++++++++++++++++++ src/helpers/orm.ts | 4 +- src/model/service.ts | 23 +++ src/model/service_class.ts | 23 +++ src/model/service_fare.ts | 23 +++ src/model/service_package.ts | 23 +++ src/model/service_type.ts | 23 +++ src/routes/private.ts | 40 ++++ 12 files changed, 1511 insertions(+), 2 deletions(-) create mode 100644 src/controllers/service.ts create mode 100644 src/controllers/service_class.ts create mode 100644 src/controllers/service_fare.ts create mode 100644 src/controllers/service_package.ts create mode 100644 src/controllers/service_type.ts create mode 100644 src/model/service.ts create mode 100644 src/model/service_class.ts create mode 100644 src/model/service_fare.ts create mode 100644 src/model/service_package.ts create mode 100644 src/model/service_type.ts diff --git a/src/controllers/service.ts b/src/controllers/service.ts new file mode 100644 index 0000000..e585a37 --- /dev/null +++ b/src/controllers/service.ts @@ -0,0 +1,278 @@ +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 { ServiceTypeModel } from "../model/service_type"; +import { RoomModel } from "../model/room"; +import { OrmHelper } from "../helpers/orm"; +import moment from "moment"; + +const log: Logger = new Logger({ + name: "[ServiceController]", + type: "pretty", +}); + +export class ServiceController { + static async list(req: Request, res: Response, next: NextFunction): Promise { + /* + #swagger.tags = ['Service'] + #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) : {}; + + var query = await ServiceModel.list(filter); + + const offset = (param.page - 1) * param.limit; + let limit = param.limit; + + const res_count = query; + const res_list = query + .leftJoinAndSelect("Service.serviceType", "serviceType") + .orderBy("Service." + param.order_field, param.order_direction) + .offset(offset) + .limit(limit); + + if (param.with_deleted) { + res_count.withDeleted(); + res_list.withDeleted(); + } + + const current_page = param.page; + const total_count_data = await res_count.getCount(); + const list_data = await res_list.getMany(); + const count_data = CommonHelper.countObject(list_data); + + return ReturnHelper.successResponselist(res, 200, Language.lang.success_view, count_data, current_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 create(req: Request, res: Response, next: NextFunction): Promise { + /* + #swagger.tags = ['Service'] + #swagger.security = [{ "bearerAuth": [] }] + #swagger.requestBody = { required: true, content: { "application/json": { schema: { $ref: "#/components/schemas/service" } } } } + */ + const queryRunner = OrmHelper.DB.createQueryRunner(); + await queryRunner.startTransaction(); + try { + const schema = Joi.object().keys({ + name: Joi.string().max(256).required().label("Name"), + service_type_id: Joi.string().uuid().required().label("Service Type ID"), + room_ids: Joi.array().items(Joi.string().uuid()).optional().label("Room IDs"), + }); + + let param: any = await schema.validateAsync(req.body); + + let serviceType = await ServiceTypeModel.list({ id: param.service_type_id }).then((q) => q.getOne()); + if (!serviceType) throw { message: "Service Type 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); + } + } + + let service = new Service(); + service.name = param.name; + service.serviceType = serviceType; + service.rooms = rooms; + service.created_by = req.auth.data.name; + service.updated_by = req.auth.data.name; + await queryRunner.manager.save(service); + + await queryRunner.commitTransaction(); + + return ReturnHelper.successResponseAny(res, 200, Language.lang.success_insert, 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(); + } + } + + static async detail(req: Request, res: Response, next: NextFunction): Promise { + /* + #swagger.tags = ['Service'] + #swagger.security = [{ "bearerAuth": [] }] + #swagger.parameters['id'] = { description: '', in: 'path', type: 'string' } + */ + try { + const schema = Joi.object().keys({ + id: Joi.string().uuid().required().label("Service Id"), + }); + + let param: any = await schema.validateAsync(req.params); + + let service = await ServiceModel.list({ id: param.id }) + .then((q) => q.leftJoinAndSelect("Service.serviceType", "serviceType").leftJoinAndSelect("Service.rooms", "rooms").getOne()); + + if (!service) throw { message: "Service Not Found" }; + + return ReturnHelper.successResponseAny(res, 200, Language.lang.success_view, service); + } catch (e: unknown) { + log.error(e); + const err = e as Error; + return ReturnHelper.errorResponse(res, 400, 401, Language.lang.failed_not_found, err.message); + } + } + + static async update(req: Request, res: Response, next: NextFunction): Promise { + /* + #swagger.tags = ['Service'] + #swagger.security = [{ "bearerAuth": [] }] + #swagger.parameters['id'] = { description: '', in: 'path', type: 'string' } + #swagger.requestBody = { required: true, content: { "application/json": { schema: { $ref: "#/components/schemas/service" } } } } + */ + 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"), + name: Joi.string().max(256).required().label("Name"), + service_type_id: Joi.string().uuid().required().label("Service Type ID"), + room_ids: Joi.array().items(Joi.string().uuid()).optional().label("Room IDs"), + }); + + let param: any = await schema.validateAsync(req.body); + + let serviceType = await ServiceTypeModel.list({ id: param.service_type_id }).then((q) => q.getOne()); + if (!serviceType) throw { message: "Service Type not found" }; + + let service = await ServiceModel.list({ 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.name = param.name; + service.serviceType = serviceType; + 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(); + } + } + + static async delete(req: Request, res: Response, next: NextFunction): Promise { + /* + #swagger.tags = ['Service'] + #swagger.security = [{ "bearerAuth": [] }] + #swagger.parameters['id'] = { in: 'path', required: true, type: 'string' } + #swagger.parameters['hard'] = { in: 'path', description: 'Is Hard Delete', required: false, type: 'boolean' } + */ + try { + const schema = Joi.object().keys({ + id: Joi.string().uuid().required().label("ID"), + hard: Joi.bool().optional().allow("").label("Is hard delete?"), + }); + + const param: { id: string; hard: boolean } = await schema.validateAsync(req.params); + + let affected = 0; + if (!param.hard) { + let service: Service = await ServiceModel.list({ id: param.id }).then((q) => q.getOne()); + + if (!service) throw { message: "Service " + Language.lang.failed_not_found }; + + service.deleted_by = req.auth.data.name; + service.deleted_at = moment().toDate(); + await OrmHelper.DB.manager.save(service); + affected = 1; + } else { + const repo = OrmHelper.DB.getRepository(Service); + affected = (await repo.delete({ id: param.id })).affected ?? 0; + } + + if (affected > 0) { + return ReturnHelper.successResponseAny(res, 200, Language.lang.success_delete, {}); + } 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_delete, err.message); + } + } + + static async restore(req: Request, res: Response, next: NextFunction): Promise { + /* + #swagger.tags = ['Service'] + #swagger.security = [{ "bearerAuth": [] }] + #swagger.parameters['id'] = { in: 'path', required: true, type: 'string' } + */ + try { + const schema = Joi.object().keys({ + id: Joi.string().uuid().required().label("ID"), + }); + + const param: any = await schema.validateAsync(req.params); + + const repo = OrmHelper.DB.getRepository(Service); + + const affected = (await repo.restore({ id: param.id })).affected ?? 0; + + if (affected > 0) { + return ReturnHelper.successResponseAny(res, 200, Language.lang.success_restore, {}); + } 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_restore, err.message); + } + } +} diff --git a/src/controllers/service_class.ts b/src/controllers/service_class.ts new file mode 100644 index 0000000..a45865d --- /dev/null +++ b/src/controllers/service_class.ts @@ -0,0 +1,251 @@ +import { ServiceClass, 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 { ServiceClassModel } from "../model/service_class"; +import { OrmHelper } from "../helpers/orm"; +import moment from "moment"; + +const log: Logger = new Logger({ + name: "[ServiceClassController]", + type: "pretty", +}); + +export class ServiceClassController { + static async list(req: Request, res: Response, next: NextFunction): Promise { + /* + #swagger.tags = ['Service Class'] + #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) : {}; + + var query = await ServiceClassModel.list(filter); + + const offset = (param.page - 1) * param.limit; + let limit = param.limit; + + const res_count = query; + const res_list = query + .orderBy("ServiceClass." + param.order_field, param.order_direction) + .offset(offset) + .limit(limit); + + if (param.with_deleted) { + res_count.withDeleted(); + res_list.withDeleted(); + } + + const current_page = param.page; + const total_count_data = await res_count.getCount(); + const list_data = await res_list.getMany(); + const count_data = CommonHelper.countObject(list_data); + + return ReturnHelper.successResponselist(res, 200, Language.lang.success_view, count_data, current_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 create(req: Request, res: Response, next: NextFunction): Promise { + /* + #swagger.tags = ['Service Class'] + #swagger.security = [{ "bearerAuth": [] }] + #swagger.requestBody = { required: true, content: { "application/json": { schema: { $ref: "#/components/schemas/serviceClass" } } } } + */ + const queryRunner = OrmHelper.DB.createQueryRunner(); + await queryRunner.startTransaction(); + try { + const schema = Joi.object().keys({ + name: Joi.string().max(256).required().label("Name"), + }); + + let param: any = await schema.validateAsync(req.body); + + let filter = { name: param.name }; + let exist = await ServiceClassModel.list(filter).then((q) => q.getOne()); + if (exist) throw { message: "Service Class " + Language.lang.failed_duplicate }; + + let serviceClass = new ServiceClass(); + serviceClass.name = param.name; + serviceClass.created_by = req.auth.data.name; + serviceClass.updated_by = req.auth.data.name; + await queryRunner.manager.save(serviceClass); + + await queryRunner.commitTransaction(); + + return ReturnHelper.successResponseAny(res, 200, Language.lang.success_insert, serviceClass); + } 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(); + } + } + + static async detail(req: Request, res: Response, next: NextFunction): Promise { + /* + #swagger.tags = ['Service Class'] + #swagger.security = [{ "bearerAuth": [] }] + #swagger.parameters['id'] = { description: '', in: 'path', type: 'string' } + */ + try { + const schema = Joi.object().keys({ + id: Joi.string().uuid().required().label("Service Class Id"), + }); + + let param: any = await schema.validateAsync(req.params); + + let serviceClass = await ServiceClassModel.list({ id: param.id }).then((q) => q.getOne()); + + if (!serviceClass) throw { message: "Service Class Not Found" }; + + return ReturnHelper.successResponseAny(res, 200, Language.lang.success_view, serviceClass); + } catch (e: unknown) { + log.error(e); + const err = e as Error; + return ReturnHelper.errorResponse(res, 400, 401, Language.lang.failed_not_found, err.message); + } + } + + static async update(req: Request, res: Response, next: NextFunction): Promise { + /* + #swagger.tags = ['Service Class'] + #swagger.security = [{ "bearerAuth": [] }] + #swagger.parameters['id'] = { description: '', in: 'path', type: 'string' } + #swagger.requestBody = { required: true, content: { "application/json": { schema: { $ref: "#/components/schemas/serviceClass" } } } } + */ + 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 Class ID"), + name: Joi.string().max(256).required().label("Name"), + }); + + let param: any = await schema.validateAsync(req.body); + + let filter = { name: param.name }; + let exist = await ServiceClassModel.list(filter).then((q) => q.getOne()); + if (exist && exist.id != param.id) throw { message: "Service Class " + Language.lang.failed_duplicate }; + + let serviceClass = await ServiceClassModel.list({ id: param.id }).then((q) => q.getOne()); + + if (!serviceClass) throw { message: "Service Class " + Language.lang.failed_not_found }; + + serviceClass.name = param.name; + serviceClass.updated_by = req.auth.data.name; + await queryRunner.manager.save(serviceClass); + + await queryRunner.commitTransaction(); + + return ReturnHelper.successResponseAny(res, 200, Language.lang.success_update, serviceClass); + } 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(); + } + } + + static async delete(req: Request, res: Response, next: NextFunction): Promise { + /* + #swagger.tags = ['Service Class'] + #swagger.security = [{ "bearerAuth": [] }] + #swagger.parameters['id'] = { in: 'path', required: true, type: 'string' } + #swagger.parameters['hard'] = { in: 'path', description: 'Is Hard Delete', required: false, type: 'boolean' } + */ + try { + const schema = Joi.object().keys({ + id: Joi.string().uuid().required().label("ID"), + hard: Joi.bool().optional().allow("").label("Is hard delete?"), + }); + + const param: { id: string; hard: boolean } = await schema.validateAsync(req.params); + + let affected = 0; + if (!param.hard) { + let serviceClass: ServiceClass = await ServiceClassModel.list({ id: param.id }).then((q) => q.getOne()); + + if (!serviceClass) throw { message: "Service Class " + Language.lang.failed_not_found }; + + serviceClass.deleted_by = req.auth.data.name; + serviceClass.deleted_at = moment().toDate(); + await OrmHelper.DB.manager.save(serviceClass); + affected = 1; + } else { + const repo = OrmHelper.DB.getRepository(ServiceClass); + affected = (await repo.delete({ id: param.id })).affected ?? 0; + } + + if (affected > 0) { + return ReturnHelper.successResponseAny(res, 200, Language.lang.success_delete, {}); + } 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_delete, err.message); + } + } + + static async restore(req: Request, res: Response, next: NextFunction): Promise { + /* + #swagger.tags = ['Service Class'] + #swagger.security = [{ "bearerAuth": [] }] + #swagger.parameters['id'] = { in: 'path', required: true, type: 'string' } + */ + try { + const schema = Joi.object().keys({ + id: Joi.string().uuid().required().label("ID"), + }); + + const param: any = await schema.validateAsync(req.params); + + const repo = OrmHelper.DB.getRepository(ServiceClass); + + const affected = (await repo.restore({ id: param.id })).affected ?? 0; + + if (affected > 0) { + return ReturnHelper.successResponseAny(res, 200, Language.lang.success_restore, {}); + } 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_restore, err.message); + } + } +} diff --git a/src/controllers/service_fare.ts b/src/controllers/service_fare.ts new file mode 100644 index 0000000..5e644ab --- /dev/null +++ b/src/controllers/service_fare.ts @@ -0,0 +1,283 @@ +import { ServiceFare, 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 { ServiceFareModel } from "../model/service_fare"; +import { ServiceClassModel } from "../model/service_class"; +import { ServiceModel } from "../model/service"; +import { OrmHelper } from "../helpers/orm"; +import moment from "moment"; + +const log: Logger = new Logger({ + name: "[ServiceFareController]", + type: "pretty", +}); + +export class ServiceFareController { + static async list(req: Request, res: Response, next: NextFunction): Promise { + /* + #swagger.tags = ['Service Fare'] + #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) : {}; + + var query = await ServiceFareModel.list(filter); + + const offset = (param.page - 1) * param.limit; + let limit = param.limit; + + const res_count = query; + const res_list = query + .leftJoinAndSelect("ServiceFare.serviceClass", "serviceClass") + .leftJoinAndSelect("ServiceFare.service", "service") + .orderBy("ServiceFare." + param.order_field, param.order_direction) + .offset(offset) + .limit(limit); + + if (param.with_deleted) { + res_count.withDeleted(); + res_list.withDeleted(); + } + + const current_page = param.page; + const total_count_data = await res_count.getCount(); + const list_data = await res_list.getMany(); + const count_data = CommonHelper.countObject(list_data); + + return ReturnHelper.successResponselist(res, 200, Language.lang.success_view, count_data, current_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 create(req: Request, res: Response, next: NextFunction): Promise { + /* + #swagger.tags = ['Service Fare'] + #swagger.security = [{ "bearerAuth": [] }] + #swagger.requestBody = { required: true, content: { "application/json": { schema: { $ref: "#/components/schemas/serviceFare" } } } } + */ + const queryRunner = OrmHelper.DB.createQueryRunner(); + await queryRunner.startTransaction(); + try { + const schema = Joi.object().keys({ + service_class_id: Joi.string().uuid().required().label("Service Class ID"), + service_id: Joi.string().uuid().required().label("Service ID"), + fare: Joi.number().min(0).required().label("Fare"), + }); + + let param: any = await schema.validateAsync(req.body); + + let serviceClass = await ServiceClassModel.list({ id: param.service_class_id }).then((q) => q.getOne()); + if (!serviceClass) throw { message: "Service Class not found" }; + + let service = await ServiceModel.list({ id: param.service_id }).then((q) => q.getOne()); + if (!service) throw { message: "Service not found" }; + + let filter = { + serviceClassId: param.service_class_id, + serviceId: param.service_id, + }; + let exist = await ServiceFareModel.list(filter).then((q) => q.getOne()); + if (exist) throw { message: "Service Fare " + Language.lang.failed_duplicate }; + + let serviceFare = new ServiceFare(); + serviceFare.serviceClass = serviceClass; + serviceFare.service = service; + serviceFare.fare = String(param.fare); + serviceFare.created_by = req.auth.data.name; + serviceFare.updated_by = req.auth.data.name; + await queryRunner.manager.save(serviceFare); + + await queryRunner.commitTransaction(); + + return ReturnHelper.successResponseAny(res, 200, Language.lang.success_insert, serviceFare); + } 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(); + } + } + + static async detail(req: Request, res: Response, next: NextFunction): Promise { + /* + #swagger.tags = ['Service Fare'] + #swagger.security = [{ "bearerAuth": [] }] + #swagger.parameters['id'] = { description: '', in: 'path', type: 'string' } + */ + try { + const schema = Joi.object().keys({ + id: Joi.string().uuid().required().label("Service Fare Id"), + }); + + let param: any = await schema.validateAsync(req.params); + + let serviceFare = await ServiceFareModel.list({ id: param.id }) + .then((q) => + q.leftJoinAndSelect("ServiceFare.serviceClass", "serviceClass").leftJoinAndSelect("ServiceFare.service", "service").getOne() + ); + + if (!serviceFare) throw { message: "Service Fare Not Found" }; + + return ReturnHelper.successResponseAny(res, 200, Language.lang.success_view, serviceFare); + } catch (e: unknown) { + log.error(e); + const err = e as Error; + return ReturnHelper.errorResponse(res, 400, 401, Language.lang.failed_not_found, err.message); + } + } + + static async update(req: Request, res: Response, next: NextFunction): Promise { + /* + #swagger.tags = ['Service Fare'] + #swagger.security = [{ "bearerAuth": [] }] + #swagger.parameters['id'] = { description: '', in: 'path', type: 'string' } + #swagger.requestBody = { required: true, content: { "application/json": { schema: { $ref: "#/components/schemas/serviceFare" } } } } + */ + 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 Fare ID"), + service_class_id: Joi.string().uuid().required().label("Service Class ID"), + service_id: Joi.string().uuid().required().label("Service ID"), + fare: Joi.number().min(0).required().label("Fare"), + }); + + let param: any = await schema.validateAsync(req.body); + + let serviceClass = await ServiceClassModel.list({ id: param.service_class_id }).then((q) => q.getOne()); + if (!serviceClass) throw { message: "Service Class not found" }; + + let service = await ServiceModel.list({ id: param.service_id }).then((q) => q.getOne()); + if (!service) throw { message: "Service not found" }; + + let serviceFare = await ServiceFareModel.list({ id: param.id }).then((q) => q.getOne()); + if (!serviceFare) throw { message: "Service Fare " + Language.lang.failed_not_found }; + + let filter = { + serviceClassId: param.service_class_id, + serviceId: param.service_id, + }; + let exist = await ServiceFareModel.list(filter).then((q) => q.getOne()); + if (exist && exist.id != param.id) throw { message: "Service Fare " + Language.lang.failed_duplicate }; + + serviceFare.serviceClass = serviceClass; + serviceFare.service = service; + serviceFare.fare = String(param.fare); + serviceFare.updated_by = req.auth.data.name; + await queryRunner.manager.save(serviceFare); + + await queryRunner.commitTransaction(); + + return ReturnHelper.successResponseAny(res, 200, Language.lang.success_update, serviceFare); + } 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(); + } + } + + static async delete(req: Request, res: Response, next: NextFunction): Promise { + /* + #swagger.tags = ['Service Fare'] + #swagger.security = [{ "bearerAuth": [] }] + #swagger.parameters['id'] = { in: 'path', required: true, type: 'string' } + #swagger.parameters['hard'] = { in: 'path', description: 'Is Hard Delete', required: false, type: 'boolean' } + */ + try { + const schema = Joi.object().keys({ + id: Joi.string().uuid().required().label("ID"), + hard: Joi.bool().optional().allow("").label("Is hard delete?"), + }); + + const param: { id: string; hard: boolean } = await schema.validateAsync(req.params); + + let affected = 0; + if (!param.hard) { + let serviceFare: ServiceFare = await ServiceFareModel.list({ id: param.id }).then((q) => q.getOne()); + + if (!serviceFare) throw { message: "Service Fare " + Language.lang.failed_not_found }; + + serviceFare.deleted_by = req.auth.data.name; + serviceFare.deleted_at = moment().toDate(); + await OrmHelper.DB.manager.save(serviceFare); + affected = 1; + } else { + const repo = OrmHelper.DB.getRepository(ServiceFare); + affected = (await repo.delete({ id: param.id })).affected ?? 0; + } + + if (affected > 0) { + return ReturnHelper.successResponseAny(res, 200, Language.lang.success_delete, {}); + } 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_delete, err.message); + } + } + + static async restore(req: Request, res: Response, next: NextFunction): Promise { + /* + #swagger.tags = ['Service Fare'] + #swagger.security = [{ "bearerAuth": [] }] + #swagger.parameters['id'] = { in: 'path', required: true, type: 'string' } + */ + try { + const schema = Joi.object().keys({ + id: Joi.string().uuid().required().label("ID"), + }); + + const param: any = await schema.validateAsync(req.params); + + const repo = OrmHelper.DB.getRepository(ServiceFare); + + const affected = (await repo.restore({ id: param.id })).affected ?? 0; + + if (affected > 0) { + return ReturnHelper.successResponseAny(res, 200, Language.lang.success_restore, {}); + } 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_restore, err.message); + } + } +} diff --git a/src/controllers/service_package.ts b/src/controllers/service_package.ts new file mode 100644 index 0000000..6280239 --- /dev/null +++ b/src/controllers/service_package.ts @@ -0,0 +1,287 @@ +import { ServicePackage, 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 { ServicePackageModel } from "../model/service_package"; +import { ServiceClassModel } from "../model/service_class"; +import { ServiceModel } from "../model/service"; +import { OrmHelper } from "../helpers/orm"; +import moment from "moment"; + +const log: Logger = new Logger({ + name: "[ServicePackageController]", + type: "pretty", +}); + +export class ServicePackageController { + static async list(req: Request, res: Response, next: NextFunction): Promise { + /* + #swagger.tags = ['Service Package'] + #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) : {}; + + var query = await ServicePackageModel.list(filter); + + const offset = (param.page - 1) * param.limit; + let limit = param.limit; + + const res_count = query; + const res_list = query + .leftJoinAndSelect("ServicePackage.serviceClass", "serviceClass") + .leftJoinAndSelect("ServicePackage.services", "services") + .orderBy("ServicePackage." + param.order_field, param.order_direction) + .offset(offset) + .limit(limit); + + if (param.with_deleted) { + res_count.withDeleted(); + res_list.withDeleted(); + } + + const current_page = param.page; + const total_count_data = await res_count.getCount(); + const list_data = await res_list.getMany(); + const count_data = CommonHelper.countObject(list_data); + + return ReturnHelper.successResponselist(res, 200, Language.lang.success_view, count_data, current_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 create(req: Request, res: Response, next: NextFunction): Promise { + /* + #swagger.tags = ['Service Package'] + #swagger.security = [{ "bearerAuth": [] }] + #swagger.requestBody = { required: true, content: { "application/json": { schema: { $ref: "#/components/schemas/servicePackage" } } } } + */ + const queryRunner = OrmHelper.DB.createQueryRunner(); + await queryRunner.startTransaction(); + try { + const schema = Joi.object().keys({ + name: Joi.string().max(256).required().label("Name"), + service_class_id: Joi.string().uuid().required().label("Service Class ID"), + fare: Joi.number().min(0).required().label("Fare"), + service_ids: Joi.array().items(Joi.string().uuid()).optional().label("Service IDs"), + }); + + let param: any = await schema.validateAsync(req.body); + + let serviceClass = await ServiceClassModel.list({ id: param.service_class_id }).then((q) => q.getOne()); + if (!serviceClass) throw { message: "Service Class not found" }; + + let services: any[] = []; + if (param.service_ids && param.service_ids.length > 0) { + for (const serviceId of param.service_ids) { + const svc = await ServiceModel.list({ id: serviceId }).then((q) => q.getOne()); + if (svc) services.push(svc); + } + } + + let servicePackage = new ServicePackage(); + servicePackage.name = param.name; + servicePackage.serviceClass = serviceClass; + servicePackage.fare = String(param.fare); + servicePackage.services = services; + servicePackage.created_by = req.auth.data.name; + servicePackage.updated_by = req.auth.data.name; + await queryRunner.manager.save(servicePackage); + + await queryRunner.commitTransaction(); + + return ReturnHelper.successResponseAny(res, 200, Language.lang.success_insert, servicePackage); + } 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(); + } + } + + static async detail(req: Request, res: Response, next: NextFunction): Promise { + /* + #swagger.tags = ['Service Package'] + #swagger.security = [{ "bearerAuth": [] }] + #swagger.parameters['id'] = { description: '', in: 'path', type: 'string' } + */ + try { + const schema = Joi.object().keys({ + id: Joi.string().uuid().required().label("Service Package Id"), + }); + + let param: any = await schema.validateAsync(req.params); + + let servicePackage = await ServicePackageModel.list({ id: param.id }) + .then((q) => + q + .leftJoinAndSelect("ServicePackage.serviceClass", "serviceClass") + .leftJoinAndSelect("ServicePackage.services", "services") + .getOne() + ); + + if (!servicePackage) throw { message: "Service Package Not Found" }; + + return ReturnHelper.successResponseAny(res, 200, Language.lang.success_view, servicePackage); + } catch (e: unknown) { + log.error(e); + const err = e as Error; + return ReturnHelper.errorResponse(res, 400, 401, Language.lang.failed_not_found, err.message); + } + } + + static async update(req: Request, res: Response, next: NextFunction): Promise { + /* + #swagger.tags = ['Service Package'] + #swagger.security = [{ "bearerAuth": [] }] + #swagger.parameters['id'] = { description: '', in: 'path', type: 'string' } + #swagger.requestBody = { required: true, content: { "application/json": { schema: { $ref: "#/components/schemas/servicePackage" } } } } + */ + 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 Package ID"), + name: Joi.string().max(256).required().label("Name"), + service_class_id: Joi.string().uuid().required().label("Service Class ID"), + fare: Joi.number().min(0).required().label("Fare"), + service_ids: Joi.array().items(Joi.string().uuid()).optional().label("Service IDs"), + }); + + let param: any = await schema.validateAsync(req.body); + + let serviceClass = await ServiceClassModel.list({ id: param.service_class_id }).then((q) => q.getOne()); + if (!serviceClass) throw { message: "Service Class not found" }; + + let servicePackage = await ServicePackageModel.list({ id: param.id }) + .then((q) => q.leftJoinAndSelect("ServicePackage.serviceClass", "sc").leftJoinAndSelect("ServicePackage.services", "s").getOne()); + if (!servicePackage) throw { message: "Service Package " + 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 svc = await ServiceModel.list({ id: serviceId }).then((q) => q.getOne()); + if (svc) services.push(svc); + } + } + + servicePackage.name = param.name; + servicePackage.serviceClass = serviceClass; + servicePackage.fare = String(param.fare); + servicePackage.services = services; + servicePackage.updated_by = req.auth.data.name; + await queryRunner.manager.save(servicePackage); + + await queryRunner.commitTransaction(); + + return ReturnHelper.successResponseAny(res, 200, Language.lang.success_update, servicePackage); + } 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(); + } + } + + static async delete(req: Request, res: Response, next: NextFunction): Promise { + /* + #swagger.tags = ['Service Package'] + #swagger.security = [{ "bearerAuth": [] }] + #swagger.parameters['id'] = { in: 'path', required: true, type: 'string' } + #swagger.parameters['hard'] = { in: 'path', description: 'Is Hard Delete', required: false, type: 'boolean' } + */ + try { + const schema = Joi.object().keys({ + id: Joi.string().uuid().required().label("ID"), + hard: Joi.bool().optional().allow("").label("Is hard delete?"), + }); + + const param: { id: string; hard: boolean } = await schema.validateAsync(req.params); + + let affected = 0; + if (!param.hard) { + let servicePackage: ServicePackage = await ServicePackageModel.list({ id: param.id }).then((q) => q.getOne()); + + if (!servicePackage) throw { message: "Service Package " + Language.lang.failed_not_found }; + + servicePackage.deleted_by = req.auth.data.name; + servicePackage.deleted_at = moment().toDate(); + await OrmHelper.DB.manager.save(servicePackage); + affected = 1; + } else { + const repo = OrmHelper.DB.getRepository(ServicePackage); + affected = (await repo.delete({ id: param.id })).affected ?? 0; + } + + if (affected > 0) { + return ReturnHelper.successResponseAny(res, 200, Language.lang.success_delete, {}); + } 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_delete, err.message); + } + } + + static async restore(req: Request, res: Response, next: NextFunction): Promise { + /* + #swagger.tags = ['Service Package'] + #swagger.security = [{ "bearerAuth": [] }] + #swagger.parameters['id'] = { in: 'path', required: true, type: 'string' } + */ + try { + const schema = Joi.object().keys({ + id: Joi.string().uuid().required().label("ID"), + }); + + const param: any = await schema.validateAsync(req.params); + + const repo = OrmHelper.DB.getRepository(ServicePackage); + + const affected = (await repo.restore({ id: param.id })).affected ?? 0; + + if (affected > 0) { + return ReturnHelper.successResponseAny(res, 200, Language.lang.success_restore, {}); + } 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_restore, err.message); + } + } +} diff --git a/src/controllers/service_type.ts b/src/controllers/service_type.ts new file mode 100644 index 0000000..e29cf90 --- /dev/null +++ b/src/controllers/service_type.ts @@ -0,0 +1,255 @@ +import { ServiceType, 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 { ServiceTypeModel } from "../model/service_type"; +import { OrmHelper } from "../helpers/orm"; +import moment from "moment"; + +const log: Logger = new Logger({ + name: "[ServiceTypeController]", + type: "pretty", +}); + +export class ServiceTypeController { + static async list(req: Request, res: Response, next: NextFunction): Promise { + /* + #swagger.tags = ['Service Type'] + #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) : {}; + + var query = await ServiceTypeModel.list(filter); + + const offset = (param.page - 1) * param.limit; + let limit = param.limit; + + const res_count = query; + const res_list = query + .orderBy("ServiceType." + param.order_field, param.order_direction) + .offset(offset) + .limit(limit); + + if (param.with_deleted) { + res_count.withDeleted(); + res_list.withDeleted(); + } + + const current_page = param.page; + const total_count_data = await res_count.getCount(); + const list_data = await res_list.getMany(); + const count_data = CommonHelper.countObject(list_data); + + return ReturnHelper.successResponselist(res, 200, Language.lang.success_view, count_data, current_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 create(req: Request, res: Response, next: NextFunction): Promise { + /* + #swagger.tags = ['Service Type'] + #swagger.security = [{ "bearerAuth": [] }] + #swagger.requestBody = { required: true, content: { "application/json": { schema: { $ref: "#/components/schemas/serviceType" } } } } + */ + const queryRunner = OrmHelper.DB.createQueryRunner(); + await queryRunner.startTransaction(); + try { + const schema = Joi.object().keys({ + name: Joi.string().max(256).required().label("Name"), + status: Joi.string().required().label("Status"), + }); + + let param: any = await schema.validateAsync(req.body); + + let filter = { name: param.name }; + let exist = await ServiceTypeModel.list(filter).then((q) => q.getOne()); + if (exist) throw { message: "Service Type " + Language.lang.failed_duplicate }; + + let serviceType = new ServiceType(); + serviceType.name = param.name; + serviceType.status = param.status; + serviceType.created_by = req.auth.data.name; + serviceType.updated_by = req.auth.data.name; + await queryRunner.manager.save(serviceType); + + await queryRunner.commitTransaction(); + + return ReturnHelper.successResponseAny(res, 200, Language.lang.success_insert, serviceType); + } 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(); + } + } + + static async detail(req: Request, res: Response, next: NextFunction): Promise { + /* + #swagger.tags = ['Service Type'] + #swagger.security = [{ "bearerAuth": [] }] + #swagger.parameters['id'] = { description: '', in: 'path', type: 'string' } + */ + try { + const schema = Joi.object().keys({ + id: Joi.string().uuid().required().label("Service Type Id"), + }); + + let param: any = await schema.validateAsync(req.params); + + let serviceType = await ServiceTypeModel.list({ id: param.id }).then((q) => q.getOne()); + + if (!serviceType) throw { message: "Service Type Not Found" }; + + return ReturnHelper.successResponseAny(res, 200, Language.lang.success_view, serviceType); + } catch (e: unknown) { + log.error(e); + const err = e as Error; + return ReturnHelper.errorResponse(res, 400, 401, Language.lang.failed_not_found, err.message); + } + } + + static async update(req: Request, res: Response, next: NextFunction): Promise { + /* + #swagger.tags = ['Service Type'] + #swagger.security = [{ "bearerAuth": [] }] + #swagger.parameters['id'] = { description: '', in: 'path', type: 'string' } + #swagger.requestBody = { required: true, content: { "application/json": { schema: { $ref: "#/components/schemas/serviceType" } } } } + */ + 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 Type ID"), + name: Joi.string().max(256).required().label("Name"), + status: Joi.string().required().label("Status"), + }); + + let param: any = await schema.validateAsync(req.body); + + let filter = { name: param.name }; + let exist = await ServiceTypeModel.list(filter).then((q) => q.getOne()); + if (exist && exist.id != param.id) throw { message: "Service Type " + Language.lang.failed_duplicate }; + + let serviceType = await ServiceTypeModel.list({ id: param.id }).then((q) => q.getOne()); + + if (!serviceType) throw { message: "Service Type " + Language.lang.failed_not_found }; + + serviceType.name = param.name; + serviceType.status = param.status; + serviceType.updated_by = req.auth.data.name; + await queryRunner.manager.save(serviceType); + + await queryRunner.commitTransaction(); + + return ReturnHelper.successResponseAny(res, 200, Language.lang.success_update, serviceType); + } 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(); + } + } + + static async delete(req: Request, res: Response, next: NextFunction): Promise { + /* + #swagger.tags = ['Service Type'] + #swagger.security = [{ "bearerAuth": [] }] + #swagger.parameters['id'] = { in: 'path', required: true, type: 'string' } + #swagger.parameters['hard'] = { in: 'path', description: 'Is Hard Delete', required: false, type: 'boolean' } + */ + try { + const schema = Joi.object().keys({ + id: Joi.string().uuid().required().label("ID"), + hard: Joi.bool().optional().allow("").label("Is hard delete?"), + }); + + const param: { id: string; hard: boolean } = await schema.validateAsync(req.params); + + let affected = 0; + if (!param.hard) { + let serviceType: ServiceType = await ServiceTypeModel.list({ id: param.id }).then((q) => q.getOne()); + + if (!serviceType) throw { message: "Service Type " + Language.lang.failed_not_found }; + + serviceType.deleted_by = req.auth.data.name; + serviceType.deleted_at = moment().toDate(); + await OrmHelper.DB.manager.save(serviceType); + affected = 1; + } else { + const repo = OrmHelper.DB.getRepository(ServiceType); + affected = (await repo.delete({ id: param.id })).affected ?? 0; + } + + if (affected > 0) { + return ReturnHelper.successResponseAny(res, 200, Language.lang.success_delete, {}); + } 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_delete, err.message); + } + } + + static async restore(req: Request, res: Response, next: NextFunction): Promise { + /* + #swagger.tags = ['Service Type'] + #swagger.security = [{ "bearerAuth": [] }] + #swagger.parameters['id'] = { in: 'path', required: true, type: 'string' } + */ + try { + const schema = Joi.object().keys({ + id: Joi.string().uuid().required().label("ID"), + }); + + const param: any = await schema.validateAsync(req.params); + + const repo = OrmHelper.DB.getRepository(ServiceType); + + const affected = (await repo.restore({ id: param.id })).affected ?? 0; + + if (affected > 0) { + return ReturnHelper.successResponseAny(res, 200, Language.lang.success_restore, {}); + } 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_restore, err.message); + } + } +} diff --git a/src/helpers/orm.ts b/src/helpers/orm.ts index 7aea88d..088d7dd 100644 --- a/src/helpers/orm.ts +++ b/src/helpers/orm.ts @@ -1,7 +1,7 @@ import config from 'config'; import { DataSource } from "typeorm"; import { ILogObj, Logger } from 'tslog'; -import { Administrativu, Aldeia, District, Menu, Munisipo, Suco, Application, Nationality, Diagnosis, DiagnosticProcedure, Poli, Room } from 'entity' +import { Administrativu, Aldeia, District, Menu, Munisipo, Suco, Application, Nationality, Diagnosis, DiagnosticProcedure, Poli, Room, ServiceType, ServiceClass, Service, ServiceFare, ServicePackage } from 'entity' export class OrmHelper { static DB: DataSource = null @@ -20,7 +20,7 @@ export class OrmHelper { database: String(config.get("database.database")), synchronize: true, logging: config.get('database.logging'), - entities: [Menu, Administrativu, Aldeia, District, Munisipo, Suco, Application, Nationality, Diagnosis, DiagnosticProcedure, Poli, Room], + entities: [Menu, Administrativu, Aldeia, District, Munisipo, Suco, Application, Nationality, Diagnosis, DiagnosticProcedure, Poli, Room, ServiceType, ServiceClass, Service, ServiceFare, ServicePackage], subscribers: [], migrations: [], }) diff --git a/src/model/service.ts b/src/model/service.ts new file mode 100644 index 0000000..c5c57a5 --- /dev/null +++ b/src/model/service.ts @@ -0,0 +1,23 @@ +import { Service } from "entity"; +import { SelectQueryBuilder } from "typeorm"; +import CommonHelper from "../helpers/common"; +import { OrmHelper } from "../helpers/orm"; + +export class ServiceModel { + static async list(filter = {}): Promise> { + const repo = OrmHelper.DB.getRepository(Service); + let whereAttr: string[] = []; + let whereVal: any = {}; + if (filter && Object.keys(filter).length > 0) { + whereAttr = [...whereAttr, ...CommonHelper.handleQueryFilter(filter).whereAttr]; + whereVal = { ...whereVal, ...CommonHelper.handleQueryFilter(filter).whereVal }; + } + + var query = repo.createQueryBuilder("Service"); + if (whereAttr.length != 0) { + query = query.where(whereAttr.join(" and "), whereVal); + } + + return query; + } +} diff --git a/src/model/service_class.ts b/src/model/service_class.ts new file mode 100644 index 0000000..c9d08e0 --- /dev/null +++ b/src/model/service_class.ts @@ -0,0 +1,23 @@ +import { ServiceClass } from "entity"; +import { SelectQueryBuilder } from "typeorm"; +import CommonHelper from "../helpers/common"; +import { OrmHelper } from "../helpers/orm"; + +export class ServiceClassModel { + static async list(filter = {}): Promise> { + const repo = OrmHelper.DB.getRepository(ServiceClass); + let whereAttr: string[] = []; + let whereVal: any = {}; + if (filter && Object.keys(filter).length > 0) { + whereAttr = [...whereAttr, ...CommonHelper.handleQueryFilter(filter).whereAttr]; + whereVal = { ...whereVal, ...CommonHelper.handleQueryFilter(filter).whereVal }; + } + + var query = repo.createQueryBuilder("ServiceClass"); + if (whereAttr.length != 0) { + query = query.where(whereAttr.join(" and "), whereVal); + } + + return query; + } +} diff --git a/src/model/service_fare.ts b/src/model/service_fare.ts new file mode 100644 index 0000000..99e55dc --- /dev/null +++ b/src/model/service_fare.ts @@ -0,0 +1,23 @@ +import { ServiceFare } from "entity"; +import { SelectQueryBuilder } from "typeorm"; +import CommonHelper from "../helpers/common"; +import { OrmHelper } from "../helpers/orm"; + +export class ServiceFareModel { + static async list(filter = {}): Promise> { + const repo = OrmHelper.DB.getRepository(ServiceFare); + let whereAttr: string[] = []; + let whereVal: any = {}; + if (filter && Object.keys(filter).length > 0) { + whereAttr = [...whereAttr, ...CommonHelper.handleQueryFilter(filter).whereAttr]; + whereVal = { ...whereVal, ...CommonHelper.handleQueryFilter(filter).whereVal }; + } + + var query = repo.createQueryBuilder("ServiceFare"); + if (whereAttr.length != 0) { + query = query.where(whereAttr.join(" and "), whereVal); + } + + return query; + } +} diff --git a/src/model/service_package.ts b/src/model/service_package.ts new file mode 100644 index 0000000..c2bf0d0 --- /dev/null +++ b/src/model/service_package.ts @@ -0,0 +1,23 @@ +import { ServicePackage } from "entity"; +import { SelectQueryBuilder } from "typeorm"; +import CommonHelper from "../helpers/common"; +import { OrmHelper } from "../helpers/orm"; + +export class ServicePackageModel { + static async list(filter = {}): Promise> { + const repo = OrmHelper.DB.getRepository(ServicePackage); + let whereAttr: string[] = []; + let whereVal: any = {}; + if (filter && Object.keys(filter).length > 0) { + whereAttr = [...whereAttr, ...CommonHelper.handleQueryFilter(filter).whereAttr]; + whereVal = { ...whereVal, ...CommonHelper.handleQueryFilter(filter).whereVal }; + } + + var query = repo.createQueryBuilder("ServicePackage"); + if (whereAttr.length != 0) { + query = query.where(whereAttr.join(" and "), whereVal); + } + + return query; + } +} diff --git a/src/model/service_type.ts b/src/model/service_type.ts new file mode 100644 index 0000000..d53002f --- /dev/null +++ b/src/model/service_type.ts @@ -0,0 +1,23 @@ +import { ServiceType } from "entity"; +import { SelectQueryBuilder } from "typeorm"; +import CommonHelper from "../helpers/common"; +import { OrmHelper } from "../helpers/orm"; + +export class ServiceTypeModel { + static async list(filter = {}): Promise> { + const repo = OrmHelper.DB.getRepository(ServiceType); + let whereAttr: string[] = []; + let whereVal: any = {}; + if (filter && Object.keys(filter).length > 0) { + whereAttr = [...whereAttr, ...CommonHelper.handleQueryFilter(filter).whereAttr]; + whereVal = { ...whereVal, ...CommonHelper.handleQueryFilter(filter).whereVal }; + } + + var query = repo.createQueryBuilder("ServiceType"); + if (whereAttr.length != 0) { + query = query.where(whereAttr.join(" and "), whereVal); + } + + return query; + } +} diff --git a/src/routes/private.ts b/src/routes/private.ts index b6606b8..2cbc425 100644 --- a/src/routes/private.ts +++ b/src/routes/private.ts @@ -13,6 +13,11 @@ import { DiagnosisController } from '../controllers/diagnosis'; import { DiagnosticProcedureController } from '../controllers/diagnostic_procedure'; import { PoliController } from '../controllers/poli'; import { RoomController } from '../controllers/room'; +import { ServiceTypeController } from '../controllers/service_type'; +import { ServiceClassController } from '../controllers/service_class'; +import { ServiceController } from '../controllers/service'; +import { ServiceFareController } from '../controllers/service_fare'; +import { ServicePackageController } from '../controllers/service_package'; export class RoutePrivate { static setup(app: express.Application) { @@ -104,5 +109,40 @@ export class RoutePrivate { app.put('/api/room/update/:id', RoomController.update) app.delete('/api/room/delete/:id/:hard', RoomController.delete) app.put('/api/room/restore/:id', RoomController.restore) + + 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) + app.put('/api/service-type/update/:id', ServiceTypeController.update) + app.delete('/api/service-type/delete/:id/:hard', ServiceTypeController.delete) + app.put('/api/service-type/restore/:id', ServiceTypeController.restore) + + app.get('/api/service-class/list', ServiceClassController.list) + app.post('/api/service-class/create', ServiceClassController.create) + app.get('/api/service-class/detail/:id', ServiceClassController.detail) + app.put('/api/service-class/update/:id', ServiceClassController.update) + app.delete('/api/service-class/delete/:id/:hard', ServiceClassController.delete) + app.put('/api/service-class/restore/:id', ServiceClassController.restore) + + app.get('/api/service/list', ServiceController.list) + app.post('/api/service/create', ServiceController.create) + app.get('/api/service/detail/:id', ServiceController.detail) + 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.get('/api/service-fare/list', ServiceFareController.list) + app.post('/api/service-fare/create', ServiceFareController.create) + app.get('/api/service-fare/detail/:id', ServiceFareController.detail) + app.put('/api/service-fare/update/:id', ServiceFareController.update) + app.delete('/api/service-fare/delete/:id/:hard', ServiceFareController.delete) + app.put('/api/service-fare/restore/:id', ServiceFareController.restore) + + app.get('/api/service-package/list', ServicePackageController.list) + app.post('/api/service-package/create', ServicePackageController.create) + app.get('/api/service-package/detail/:id', ServicePackageController.detail) + app.put('/api/service-package/update/:id', ServicePackageController.update) + app.delete('/api/service-package/delete/:id/:hard', ServicePackageController.delete) + app.put('/api/service-package/restore/:id', ServicePackageController.restore) } } \ No newline at end of file