service-master-data-revenue/src/controllers/application.ts

import { Response, NextFunction } from "express";
import { Request } from "express-jwt";
import { ReturnHelper } from "../helpers/express/return";
import { OrmHelper } from "../helpers/orm";
import Joi from "joi";
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 dayjs from "dayjs";
import { Application } from "entity";

const log: Logger<ILogObj> = new Logger({
  name: "[ApplicationController]",
  type: "pretty",
});

export class ApplicationController {
  static async list(
    req: Request,
    res: Response,
    next: NextFunction
  ): Promise<Response> {
    /*
        #swagger.tags = ['Application']
        #swagger.security = [{
            "bearerAuth": []
        }]
        #swagger.parameters['filter'] = {
            description: 'Filter with 2 format : <ul><li>Simple format use text plaint will filter eq:code or like %name%</li><li>Advance format using field existing {status:\'Y\', any:\'SAME AS PLAINT LOGIC\', etc...}</li></ul>',
            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"),
      });

      const param: Paging = await schema.validateAsync(req.query);

      const repo = OrmHelper.DB.getRepository(Application);

      const offset = (param.page - 1) * param.limit;

      const { whereAttr, whereVal } = CommonHelper.handleFilter({
        filter: param.filter,
        col_any_eq: ["code"],
        col_any_like: ["name"],
      });

      const res_count = repo.createQueryBuilder().where(whereAttr, whereVal);
      const res_list = repo
        .createQueryBuilder()
        .where(whereAttr, whereVal)
        .orderBy(param.order_field, param.order_direction)
        .offset(offset)
        .limit(param.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 export(
    req: Request,
    res: Response,
    next: NextFunction
  ): Promise<void | Response> {
    /*
        #swagger.tags = ['Application']
        #swagger.security = [{
            "bearerAuth": []
        }]
        #swagger.parameters['filter'] = {
            description: 'Filter with 2 format : <ul><li>Simple format use text plaint will filter eq:code or like %name%</li><li>Advance format using field existing {status:\'Y\', any:\'SAME AS PLAINT LOGIC\', etc...}</li></ul>',
            in: 'query',
            type: 'string'
        }
        #swagger.parameters['filter'] = {
            in: 'query',
            type: 'string'
        }
        #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"),
        order_field: Joi.string().required().label("Order Field"),
        order_direction: Joi.string()
          .allow("asc", "desc")
          .required()
          .label("Order Direction"),
      });

      const param: Paging = await schema.validateAsync(req.query);

      const repo = OrmHelper.DB.getRepository(Application);

      const { whereAttr, whereVal } = CommonHelper.handleFilter({
        filter: param.filter,
        col_any_eq: ["code"],
        col_any_like: ["name"],
      });

      const filename = "application.csv";

      res.setHeader("Content-Type", "text/csv");
      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"),
        }),
      });
      csvStream.pipe(res);

      const limit = 50;

      const fetchAndWrite = async (page: any) => {
        const offset = (page - 1) * limit;

        const data = await repo
          .createQueryBuilder()
          .where(whereAttr, whereVal)
          .select(["id", "code", "name", "status", "created_at"])
          .orderBy(param.order_field, param.order_direction)
          .offset(offset)
          .limit(limit)
          .getRawMany();

        if (CommonHelper.countObject(data) === 0) {
          csvStream.end();
        } else {
          data.forEach((item: any) => csvStream.write(item));

          if (CommonHelper.countObject(data) == limit) {
            fetchAndWrite(page + 1);
          } else {
            csvStream.end();
          }
        }
      };

      fetchAndWrite(1);
    } 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<Response> {
    /*
        #swagger.tags = ['Application']
        #swagger.security = [{
            "bearerAuth": []
        }]
        
        #swagger.requestBody = {
            required: true,
            content: {
                "application/json": {
                    schema: {
                         $ref: "#/components/schemas/application"
                    }  
                }
            }
        }
        */

    try {
      const schema = Joi.object().keys({
        id: Joi.string().max(32).required().label("ID"),
        name: Joi.string().max(256).required().label("Name"),
        reset_password_url: Joi.string()
          .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();
      data.id = param.id;
      data.name = param.name;
      data.reset_password_url = param.reset_password_url;
      data.status = param.status;

      await OrmHelper.DB.manager.save(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
      );
    }
  }

  static async update(
    req: Request,
    res: Response,
    next: NextFunction
  ): Promise<Response> {
    /*
        #swagger.tags = ['Application']
        #swagger.security = [{
            "bearerAuth": []
        }]
         #swagger.parameters['id'] = {
            in: 'path',
            description: 'Application ID.',
            required: true,
            type: 'string'
        }
    
         #swagger.requestBody = {
            required: true,
            content: {
                "application/json": {
                    schema: {
                         $ref: "#/components/schemas/application"
                    }  
                }
            }
        }
        */

    try {
      const schema = Joi.object().keys({
        id: Joi.string().required().label("ID"),
        name: Joi.string().max(256).required().label("Name"),
        reset_password_url: Joi.string()
          .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.body);

      const repo = OrmHelper.DB.getRepository(Application);

      const data = await repo.findOneBy({ id: param.id });

      if (data != null) {
        data.name = param.name;
        data.reset_password_url = param.reset_password_url;
        data.status = param.status;

        await repo.save(data);

        return ReturnHelper.successResponseAny(
          res,
          200,
          Language.lang.success_update,
          data
        );
      } else {
        return ReturnHelper.errorResponse(
          res,
          404,
          401,
          Language.lang.failed_not_found,
          ""
        );
      }
    } catch (e: unknown) {
      log.error(e);
      const err = e as Error;

      return ReturnHelper.errorResponse(
        res,
        500,
        402,
        Language.lang.failed_update,
        err.message
      );
    }
  }

  static async delete(
    req: Request,
    res: Response,
    next: NextFunction
  ): Promise<Response> {
    /*
        #swagger.tags = ['Application']
        #swagger.security = [{
            "bearerAuth": []
        }]
        #swagger.parameters['id'] = {
            in: 'path',
            description: 'Application ID.',
            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
      );

      const repo = OrmHelper.DB.getRepository(Application);

      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,
          {}
        );
      } 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<Response> {
    /*
        #swagger.tags = ['Application']
        #swagger.security = [{
            "bearerAuth": []
        }]
            
        #swagger.parameters['id'] = {
            in: 'path',
            description: 'Application ID.',
            required: true,
            type: 'string'
        }
        */
    try {
      const schema = Joi.object().keys({
        id: Joi.string().uuid().required().label("ID"),
      });

      const param: Application = await schema.validateAsync(req.params);

      const repo = OrmHelper.DB.getRepository(Application);

      const affected = (await repo.restore({ id: param.id })).affected;

      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
      );
    }
  }
}