up

src/controllers/application.ts

@@ -7,14 +7,21 @@ import { ILogObj, Logger } from "tslog";
 import { Language } from "../langs/lang";
 import { Paging } from "entity";
 import CommonHelper from "../helpers/common";
-import * as fastcsv from 'fast-csv';
+import * as fastcsv from "fast-csv";
 import dayjs from "dayjs";
 import { Application } from "entity";
 
-const log: Logger<ILogObj> = new Logger({ name: '[ApplicationController]', type: 'pretty' });
+const log: Logger<ILogObj> = new Logger({
+  name: "[ApplicationController]",
+  type: "pretty",
+});
 
 export class ApplicationController {
-    static async list(req: Request, res: Response, next: NextFunction): Promise<Response> {
+  static async list(
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ): Promise<Response> {
     /*
         #swagger.tags = ['Application']
         #swagger.parameters['filter'] = {
@@ -58,30 +65,33 @@ export class ApplicationController {
 
     try {
       const schema = Joi.object().keys({
-                filter: Joi.string().allow('').optional().label('Filter'),
+        filter: Joi.string().allow("").optional().label("Filter"),
-                page: Joi.number().required().min(1).label('Page'),
+        page: Joi.number().required().min(1).label("Page"),
-                limit: Joi.number().required().min(1).label('Limit'),
+        limit: Joi.number().required().min(1).label("Limit"),
-                with_deleted: Joi.bool().required().label('With Deleted'),
+        with_deleted: Joi.bool().required().label("With Deleted"),
-                order_field: Joi.string().required().label('Order Field'),
+        order_field: Joi.string().required().label("Order Field"),
-                order_direction: Joi.string().allow('asc', 'desc').required().label('Order Direction'),
+        order_direction: Joi.string()
-                token: Joi.string().required().label('Token'),
+          .allow("asc", "desc")
+          .required()
+          .label("Order Direction"),
+        token: Joi.string().required().label("Token"),
       });
 
       const param: Paging = await schema.validateAsync(req.query);
 
       const repo = OrmHelper.DB.getRepository(Application);
 
-            const offset = (param.page - 1) * param.limit
+      const offset = (param.page - 1) * param.limit;
 
       const { whereAttr, whereVal } = CommonHelper.handleFilter({
         filter: param.filter,
-                col_any_eq: ['code'],
+        col_any_eq: ["code"],
-                col_any_like: ['name']
+        col_any_like: ["name"],
       });
 
-            const res_count = repo.createQueryBuilder()
+      const res_count = repo.createQueryBuilder().where(whereAttr, whereVal);
-                .where(whereAttr, whereVal);
+      const res_list = repo
-            const res_list = repo.createQueryBuilder()
+        .createQueryBuilder()
         .where(whereAttr, whereVal)
         .orderBy(param.order_field, param.order_direction)
         .offset(offset)
@@ -97,16 +107,34 @@ export class ApplicationController {
       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);
+      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);
+      return ReturnHelper.errorResponse(
+        res,
+        400,
+        401,
+        Language.lang.failed_view,
+        err.message
+      );
     }
   }
 
-    static async export(req: Request, res: Response, next: NextFunction): Promise<void | Response> {
+  static async export(
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ): Promise<void | Response> {
     /*
         #swagger.tags = ['Application']
         #swagger.parameters['filter'] = {
@@ -139,10 +167,13 @@ export class ApplicationController {
 
     try {
       const schema = Joi.object().keys({
-                filter: Joi.string().allow('').optional().label('Filter'),
+        filter: Joi.string().allow("").optional().label("Filter"),
-                order_field: Joi.string().required().label('Order Field'),
+        order_field: Joi.string().required().label("Order Field"),
-                order_direction: Joi.string().allow('asc', 'desc').required().label('Order Direction'),
+        order_direction: Joi.string()
-                token: Joi.string().required().label('Token'),
+          .allow("asc", "desc")
+          .required()
+          .label("Order Direction"),
+        token: Joi.string().required().label("Token"),
       });
 
       const param: Paging = await schema.validateAsync(req.query);
@@ -151,41 +182,38 @@ export class ApplicationController {
 
       const { whereAttr, whereVal } = CommonHelper.handleFilter({
         filter: param.filter,
-                col_any_eq: ['code'],
+        col_any_eq: ["code"],
-                col_any_like: ['name']
+        col_any_like: ["name"],
       });
 
       const filename = "application.csv";
 
-            res.setHeader('Content-Type', 'text/csv');
+      res.setHeader("Content-Type", "text/csv");
-            res.setHeader('Content-Disposition', 'attachment; filename=' + filename);
+      res.setHeader("Content-Disposition", "attachment; filename=" + filename);
 
       const csvStream = fastcsv.format({
         headers: true,
         writeHeaders: true,
         transform: (row: Application): any => ({
           ...row,
-                    created_at: dayjs(row.created_at).format('DD-MM-YYYY HH:MM:ss'),
+          created_at: dayjs(row.created_at).format("DD-MM-YYYY HH:MM:ss"),
-                })
+        }),
       });
       csvStream.pipe(res);
 
       const limit = 50;
 
       const fetchAndWrite = async (page: any) => {
-                const offset = (page - 1) * limit
+        const offset = (page - 1) * limit;
 
-                const data = await repo.createQueryBuilder()
+        const data = await repo
+          .createQueryBuilder()
           .where(whereAttr, whereVal)
-                    .select([
+          .select(["id", "code", "name", "status", "created_at"])
-                        'id',
-                        'code',
-                        'name',
-                        'status',
-                        'created_at'])
           .orderBy(param.order_field, param.order_direction)
           .offset(offset)
-                    .limit(limit).getRawMany();
+          .limit(limit)
+          .getRawMany();
 
         if (CommonHelper.countObject(data) === 0) {
           csvStream.end();
@@ -205,11 +233,21 @@ export class ApplicationController {
       log.error(e);
       const err = e as Error;
 
-            return ReturnHelper.errorResponse(res, 400, 401, Language.lang.failed_view, err.message);
+      return ReturnHelper.errorResponse(
+        res,
+        400,
+        401,
+        Language.lang.failed_view,
+        err.message
+      );
     }
   }
 
-    static async create(req: Request, res: Response, next: NextFunction): Promise<Response> {
+  static async create(
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ): Promise<Response> {
     /*
         #swagger.tags = ['Application']
         #swagger.security = [{
@@ -230,32 +268,51 @@ export class ApplicationController {
 
     try {
       const schema = Joi.object().keys({
-                id: Joi.string().max(32).required().label('ID'),
+        id: Joi.string().max(32).required().label("ID"),
-                name: Joi.string().max(256).required().label('Name'),
+        name: Joi.string().max(256).required().label("Name"),
-                reset_password_url: Joi.string().max(512).optional().allow('').label('Url reset password'),
+        reset_password_url: Joi.string()
-                status: Joi.string().required().label('Status'),
+          .max(512)
+          .optional()
+          .allow("")
+          .label("Url reset password"),
+        status: Joi.string().required().label("Status"),
       });
 
       const param: Application = await schema.validateAsync(req.body);
 
-            const data = new Application()
+      const data = new Application();
-            data.id = param.id
+      data.id = param.id;
-            data.name = param.name
+      data.name = param.name;
-            data.reset_password_url = param.reset_password_url
+      data.reset_password_url = param.reset_password_url;
-            data.status = param.status
+      data.status = param.status;
 
       await OrmHelper.DB.manager.save(data);
 
-            return ReturnHelper.successResponseAny(res, 200, Language.lang.success_insert, data);
+      return ReturnHelper.successResponseAny(
+        res,
+        200,
+        Language.lang.success_insert,
+        data
+      );
     } catch (e: unknown) {
       log.error(e);
       const err = e as Error;
 
-            return ReturnHelper.errorResponse(res, 500, 401, Language.lang.failed_insert, err.message);
+      return ReturnHelper.errorResponse(
+        res,
+        500,
+        401,
+        Language.lang.failed_insert,
+        err.message
+      );
     }
   }
 
-    static async update(req: Request, res: Response, next: NextFunction): Promise<Response> {
+  static async update(
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ): Promise<Response> {
     /*
         #swagger.tags = ['Application']
         #swagger.security = [{
@@ -282,39 +339,62 @@ export class ApplicationController {
 
     try {
       const schema = Joi.object().keys({
-                name: Joi.string().max(256).required().label('Name'),
+        name: Joi.string().max(256).required().label("Name"),
-                reset_password_url: Joi.string().max(512).optional().allow('').label('Url reset password'),
+        reset_password_url: Joi.string()
-                status: Joi.string().required().label('Status'),
+          .max(512)
+          .optional()
+          .allow("")
+          .label("Url reset password"),
+        status: Joi.string().required().label("Status"),
       });
 
-            req.body.id = req.params['id'];
+      const param: Application = await schema.validateAsync(req.params);
-
-            const param: Application = await schema.validateAsync(req.body);
 
       const repo = OrmHelper.DB.getRepository(Application);
 
       const data = await repo.findOneBy({ id: param.id });
 
       if (data != null) {
-                data.name = param.name
+        data.name = param.name;
-                data.reset_password_url = param.reset_password_url
+        data.reset_password_url = param.reset_password_url;
-                data.status = param.status
+        data.status = param.status;
 
         await repo.save(data);
 
-                return ReturnHelper.successResponseAny(res, 200, Language.lang.success_update, data);
+        return ReturnHelper.successResponseAny(
+          res,
+          200,
+          Language.lang.success_update,
+          data
+        );
       } else {
-                return ReturnHelper.errorResponse(res, 404, 401, Language.lang.failed_not_found, "");
+        return ReturnHelper.errorResponse(
+          res,
+          404,
+          401,
+          Language.lang.failed_not_found,
+          ""
+        );
       }
     } catch (e: unknown) {
       log.error(e);
       const err = e as Error;
 
-            return ReturnHelper.errorResponse(res, 500, 402, Language.lang.failed_update, err.message);
+      return ReturnHelper.errorResponse(
+        res,
+        500,
+        402,
+        Language.lang.failed_update,
+        err.message
+      );
     }
   }
 
-    static async delete(req: Request, res: Response, next: NextFunction): Promise<Response> {
+  static async delete(
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ): Promise<Response> {
     /*
         #swagger.tags = ['Application']
         #swagger.security = [{
@@ -335,30 +415,57 @@ export class ApplicationController {
         */
     try {
       const schema = Joi.object().keys({
-                id: Joi.string().uuid().required().label('ID'),
+        id: Joi.string().uuid().required().label("ID"),
-                hard: Joi.bool().optional().allow('').label('Is hard delete?')
+        hard: Joi.bool().optional().allow("").label("Is hard delete?"),
       });
 
-            const param: { id: string, hard: boolean } = await schema.validateAsync(req.params);
+      const param: { id: string; hard: boolean } = await schema.validateAsync(
+        req.params
+      );
 
       const repo = OrmHelper.DB.getRepository(Application);
 
-            const affected = (!param.hard ? await repo.softDelete({ id: param.id }) : await repo.delete({ id: param.id })).affected;
+      const affected = (
+        !param.hard
+          ? await repo.softDelete({ id: param.id })
+          : await repo.delete({ id: param.id })
+      ).affected;
 
       if (affected > 0) {
-                return ReturnHelper.successResponseAny(res, 200, Language.lang.success_delete, {});
+        return ReturnHelper.successResponseAny(
+          res,
+          200,
+          Language.lang.success_delete,
+          {}
+        );
       } else {
-                return ReturnHelper.errorResponse(res, 404, 401, Language.lang.failed_not_found, "");
+        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);
+      return ReturnHelper.errorResponse(
+        res,
+        500,
+        402,
+        Language.lang.failed_delete,
+        err.message
+      );
     }
   }
 
-    static async restore(req: Request, res: Response, next: NextFunction): Promise<Response> {
+  static async restore(
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ): Promise<Response> {
     /*
         #swagger.tags = ['Application']
         #swagger.security = [{
@@ -374,7 +481,7 @@ export class ApplicationController {
         */
     try {
       const schema = Joi.object().keys({
-                id: Joi.string().uuid().required().label('ID')
+        id: Joi.string().uuid().required().label("ID"),
       });
 
       const param: Application = await schema.validateAsync(req.params);
@@ -384,15 +491,32 @@ export class ApplicationController {
       const affected = (await repo.restore({ id: param.id })).affected;
 
       if (affected > 0) {
-                return ReturnHelper.successResponseAny(res, 200, Language.lang.success_restore, {});
+        return ReturnHelper.successResponseAny(
+          res,
+          200,
+          Language.lang.success_restore,
+          {}
+        );
       } else {
-                return ReturnHelper.errorResponse(res, 404, 401, Language.lang.failed_not_found, "");
+        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);
+      return ReturnHelper.errorResponse(
+        res,
+        500,
+        402,
+        Language.lang.failed_restore,
+        err.message
+      );
     }
   }
 }