hrms-api-org/src/controllers/WorkflowController.ts

import { Body, Controller, Post, Request, Route, Security, Tags } from "tsoa";
import { AppDataSource } from "../database/data-source";
import { RequestWithUser } from "../middlewares/user";
import HttpError from "../interfaces/http-error";
import HttpStatus from "../interfaces/http-status";
import HttpSuccess from "../interfaces/http-success";
import { Workflow } from "../entities/Workflow";
import { State } from "../entities/State";
import { StateOperator } from "../entities/StateOperator";
import { StateOperatorUser } from "../entities/StateOperatorUser";
import CallAPI from "../interfaces/call-api";
import { Profile } from "../entities/Profile";

@Route("api/v1/org/workflow")
@Tags("AuthRole")
@Security("bearerAuth")
export class WorkflowController extends Controller {
  private workflowRepo = AppDataSource.getRepository(Workflow);
  private stateRepo = AppDataSource.getRepository(State);
  private stateOperatorRepo = AppDataSource.getRepository(StateOperator);
  private stateOperatorUserRepo = AppDataSource.getRepository(StateOperatorUser);
  private profileRepo = AppDataSource.getRepository(Profile);

  @Post("check-workflow")
  public async checkWorkflow(
    @Request() req: RequestWithUser,
    @Body()
    body: {
      sysName: string;
      posLevelName: string;
      posTypeName: string;
      profiles: {
        profile: string;
        operator: string;
        order: number;
      }[];
    },
  ) {
    const workflow = await this.workflowRepo.findOne({
      where: {
        sysName: body.sysName,
        posLevelName: body.posLevelName,
        posTypeName: body.posTypeName,
      },
      relations: ["states"],
    });
    if (!workflow) throw new HttpError(HttpStatus.NOT_FOUND, "ไม่พบกระบวนการนี้ได้");
    await Promise.all(
      body.profiles.map(async (item) => {
        const operatoeUser = new StateOperatorUser();
        operatoeUser.profile = item.profile;
        operatoeUser.operator = item.operator.trim().toLocaleUpperCase();
        operatoeUser.order = item.order;
        operatoeUser.workflowId = workflow.id;
        operatoeUser.createdUserId = req.user.sub;
        operatoeUser.createdFullName = req.user.name;
        operatoeUser.createdAt = new Date();
        operatoeUser.lastUpdateUserId = req.user.sub;
        operatoeUser.lastUpdateFullName = req.user.name;
        operatoeUser.lastUpdatedAt = new Date();
        await this.stateOperatorUserRepo.save(operatoeUser);
      }),
    );
    return new HttpSuccess({
      workflowId: workflow.id,
      stateId: workflow.states.sort((a, b) => a.order - b.order)[0].id,
      //   stateName: workflow.states.sort((a, b) => a.order - b.order)[0].name,
      //   stateType: workflow.states.sort((a, b) => a.order - b.order)[0].type,
    });
  }

  @Post("check-iscan")
  public async checkIsCan(
    @Request() req: RequestWithUser,
    @Body()
    body: {
      workflowId: string;
      stateId: string;
      profile: string;
      action: string;
    },
  ) {
    const stateOperatorUser = await this.stateOperatorUserRepo.findOne({
      where: {
        profile: body.profile,
        workflowId: body.workflowId,
      },
    });
    if (!stateOperatorUser)
      throw new HttpError(HttpStatus.NOT_FOUND, "ไม่สามารถดำเนินการกระบวนการนี้ได้");

    const operator = await this.stateOperatorRepo.findOne({
      where: {
        operator: stateOperatorUser.operator,
        state: { id: body.stateId, workflow: { id: body.workflowId } },
      },
    });
    if (!operator) throw new HttpError(HttpStatus.NOT_FOUND, "ไม่พบข้อมูล");

    let isCan = false;
    switch (body.action.trim().toLocaleUpperCase()) {
      case "VIEW":
        isCan = operator.canView;
      case "UPDATE":
        isCan = operator.canUpdate;
      case "DELETE":
        isCan = operator.canDelete;
      case "CANCEL":
        isCan = operator.canCancel;
      case "OPERATE":
        isCan = operator.canOperate;
      case "CHANGESTATE":
        isCan = operator.canChangeState;
      case "COMMENT":
        isCan = operator.canComment;
      case "SIGN":
        isCan = operator.canSign;
      default:
        isCan = false;
    }
    if (isCan == false) {
      throw new HttpError(HttpStatus.NOT_FOUND, "ไม่สามารถดำเนินการได้");
    } else {
      return new HttpSuccess();
    }
  }

  @Post("check-iscan-all")
  public async checkIsCanAll(
    @Request() req: RequestWithUser,
    @Body()
    body: {
      workflowId: string;
      stateId: string;
    },
  ) {
    const profile = await this.profileRepo.findOne({
      where: {
        keycloak: req.user.sub,
      },
    });
    if (!profile) throw new HttpError(HttpStatus.NOT_FOUND, "ไม่พบข้อมูล");
    const stateOperatorUser = await this.stateOperatorUserRepo.findOne({
      where: {
        profile: profile.id,
        workflowId: body.workflowId,
      },
    });
    if (!stateOperatorUser)
      throw new HttpError(HttpStatus.NOT_FOUND, "ไม่สามารถดำเนินการกระบวนการนี้ได้");

    const operator = await this.stateOperatorRepo.findOne({
      where: {
        operator: stateOperatorUser.operator,
        state: { id: body.stateId, workflow: { id: body.workflowId } },
      },
    });
    if (!operator) throw new HttpError(HttpStatus.NOT_FOUND, "ไม่พบข้อมูล");
    return new HttpSuccess(operator);
  }

  @Post("state-next")
  public async stateNext(
    @Request() req: RequestWithUser,
    @Body()
    body: {
      stateId: string;
    },
  ) {
    const state = await this.stateRepo.findOne({
      where: {
        id: body.stateId,
      },
      relations: ["stateOperators", "workflow", "workflow.stateOperatorUsers"],
    });
    if (!state) throw new HttpError(HttpStatus.NOT_FOUND, "ไม่พบข้อมูล");
    const _state = await this.stateRepo.findOne({
      where: {
        order: state.order + 1,
        workflowId: state.workflowId,
      },
      relations: ["stateOperators"],
    });
    //noti
    let profileNow = state.workflow.stateOperatorUsers
      .filter((x) => state.stateOperators.map((s) => s.operator).includes(x.operator))
      .map((x) => x.profile);
    await new CallAPI()
      .PostData(req, "/placement/noti/profiles", {
        subject: `รายการถูกส่ง`,
        body: `รายการถูกส่ง`,
        receiverUserIds: profileNow,
        payload: "", //แนบไฟล์
        isSendMail: true,
        isSendInbox: true,
        isSendNotification: true,
      })
      .catch((error) => {
        console.error("Error calling API:", error);
      });
    if (_state != null) {
      let profileNext = state.workflow.stateOperatorUsers
        .filter((x) => _state.stateOperators.map((s) => s.operator).includes(x.operator))
        .map((x) => x.profile);
      await new CallAPI()
        .PostData(req, "/placement/noti/profiles", {
          subject: `ได้รับรายการ`,
          body: `ได้รับรายการ`,
          receiverUserIds: profileNext,
          payload: "", //แนบไฟล์
          isSendMail: true,
          isSendInbox: true,
          isSendNotification: true,
        })
        .catch((error) => {
          console.error("Error calling API:", error);
        });
    }

    return new HttpSuccess({
      stateId: _state?.id || null,
      stateName: _state?.name || null,
      stateType: _state?.type || null,
    });
  }

  @Post("state-back")
  public async stateBack(
    @Request() req: RequestWithUser,
    @Body()
    body: {
      stateId: string;
    },
  ) {
    const state = await this.stateRepo.findOne({
      where: {
        id: body.stateId,
      },
    });
    if (!state) throw new HttpError(HttpStatus.NOT_FOUND, "ไม่พบข้อมูล");
    const _state = await this.stateRepo.findOne({
      where: {
        order: state.order - 1,
        workflowId: state.workflowId,
      },
    });

    return new HttpSuccess({
      stateId: _state?.id || null,
      stateName: _state?.name || null,
      stateType: _state?.type || null,
    });
  }
}