jws-backend/src/controllers/03-customer-branch-controller.ts

import { Prisma, Status } from "@prisma/client";
import {
  Body,
  Controller,
  Delete,
  Get,
  Path,
  Post,
  Put,
  Query,
  Request,
  Route,
  Security,
  Tags,
} from "tsoa";
import { RequestWithUser } from "../interfaces/user";
import prisma from "../db";
import HttpStatus from "../interfaces/http-status";
import HttpError from "../interfaces/http-error";
import minio, { deleteFolder } from "../services/minio";
import { isSystem } from "../utils/keycloak";
import {
  branchRelationPermInclude,
  createPermCheck,
  createPermCondition,
} from "../services/permission";
import { filterStatus } from "../services/prisma";
import { connectOrDisconnect, connectOrNot, whereAddressQuery } from "../utils/relation";
import { notFoundError, relationError } from "../utils/error";

if (!process.env.MINIO_BUCKET) {
  throw Error("Require MinIO bucket.");
}

const MINIO_BUCKET = process.env.MINIO_BUCKET;
const MANAGE_ROLES = [
  "system",
  "head_of_admin",
  "admin",
  "head_of_account",
  "account",
  "head_of_sale",
  "sale",
];

function globalAllow(user: RequestWithUser["user"]) {
  const allowList = ["system", "head_of_admin", "admin", "head_of_account", "head_of_sale"];
  return allowList.some((v) => user.roles?.includes(v));
}

const permissionCond = createPermCondition(globalAllow);
const permissionCheck = createPermCheck(globalAllow);

function imageLocation(id: string) {
  return `employee/profile-img-${id}`;
}

function attachmentLocation(customerId: string, branchId: string) {
  return `customer/${customerId}/branch/${branchId}`;
}

export type CustomerBranchCreate = {
  customerId: string;

  // NOTE: About (Natural Person)
  citizenId?: string;
  namePrefix?: string;
  firstName?: string;
  firstNameEN?: string;
  lastName?: string;
  lastNameEN?: string;
  gender?: string;
  birthDate?: Date;

  // NOTE: About (Legal Entity)
  legalPersonNo?: string;
  registerName?: string;
  registerNameEN?: string;
  registerDate?: Date;
  authorizedCapital?: string;
  authorizedName?: string;
  authorizedNameEN?: string;
  customerName?: string;

  telephoneNo: string;

  status?: Status;

  homeCode: string;
  employmentOffice: string;
  employmentOfficeEN: string;
  address: string;
  addressEN: string;
  soi?: string | null;
  soiEN?: string | null;
  moo?: string | null;
  mooEN?: string | null;
  street?: string | null;
  streetEN?: string | null;

  email: string;
  contactTel: string;
  officeTel: string;
  contactName: string;
  agent: string;

  businessType: string;
  jobPosition: string;
  jobDescription: string;
  payDate: string;
  payDateEN: string;
  wageRate: number;
  wageRateText: string;

  subDistrictId?: string | null;
  districtId?: string | null;
  provinceId?: string | null;
};

export type CustomerBranchUpdate = (
  | {
      // NOTE: About (Natural Person)
      citizenId: string;
    }
  | {
      // NOTE: About (Legal Entity)
      legalPersonNo: string;
      registerName?: string;
      registerNameEN?: string;
      registerDate?: Date;
      authorizedCapital?: string;
      authorizedName: string;
      authorizedNameEN: string;
    }
) & {
  customerId?: string;
  customerName?: string;

  telephoneNo: string;

  status?: "ACTIVE" | "INACTIVE";

  homeCode?: string;
  address?: string;
  addressEN?: string;
  soi?: string | null;
  soiEN?: string | null;
  moo?: string | null;
  mooEN?: string | null;
  street?: string | null;
  streetEN?: string | null;

  email?: string;
  contactTel?: string;
  officeTel?: string;
  contactName?: string;
  agent?: string;

  businessType?: string;
  jobPosition?: string;
  jobDescription?: string;
  payDate?: string;
  payDateEN?: string;
  wageRate?: number;
  wageRateText?: string;

  subDistrictId?: string | null;
  districtId?: string | null;
  provinceId?: string | null;
};

@Route("api/v1/customer-branch")
@Tags("Customer Branch")
export class CustomerBranchController extends Controller {
  @Get()
  @Security("keycloak")
  async list(
    @Request() req: RequestWithUser,
    @Query() zipCode?: string,
    @Query() customerId?: string,
    @Query() status?: Status,
    @Query() includeCustomer?: boolean,
    @Query() query: string = "",
    @Query() page: number = 1,
    @Query() pageSize: number = 30,
  ) {
    const where = {
      OR: query
        ? [
            { registerName: { contains: query } },
            { registerNameEN: { contains: query } },
            { email: { contains: query } },
            { code: { contains: query } },
            { firstName: { contains: query } },
            { firstNameEN: { contains: query } },
            { lastName: { contains: query } },
            { lastNameEN: { contains: query } },
            ...whereAddressQuery(query),
          ]
        : undefined,
      AND: {
        customer: isSystem(req.user)
          ? undefined
          : {
              registeredBranch: {
                OR: permissionCond(req.user),
              },
            },
        customerId,
        subDistrict: zipCode ? { zipCode } : undefined,
        ...filterStatus(status),
      },
    } satisfies Prisma.CustomerBranchWhereInput;

    const [result, total] = await prisma.$transaction([
      prisma.customerBranch.findMany({
        orderBy: [{ statusOrder: "asc" }, { createdAt: "asc" }],
        include: {
          customer: includeCustomer,
          province: true,
          district: true,
          subDistrict: true,
          createdBy: true,
          updatedBy: true,
          _count: true,
        },
        where,
        take: pageSize,
        skip: (page - 1) * pageSize,
      }),
      prisma.customerBranch.count({ where }),
    ]);

    return { result, page, pageSize, total };
  }

  @Get("{branchId}")
  @Security("keycloak")
  async getById(@Path() branchId: string) {
    const record = await prisma.customerBranch.findFirst({
      include: {
        customer: true,
        province: true,
        district: true,
        subDistrict: true,
        createdBy: true,
        updatedBy: true,
      },
      where: { id: branchId },
    });

    if (!record) throw notFoundError("Branch");

    return record;
  }

  @Get("{branchId}/employee")
  @Security("keycloak")
  async listEmployee(
    @Path() branchId: string,
    @Query() zipCode?: string,
    @Query() gender?: string,
    @Query() status?: Status,
    @Query() query: string = "",
    @Query() page: number = 1,
    @Query() pageSize: number = 30,
  ) {
    const where = {
      OR: [
        { firstName: { contains: query } },
        { firstNameEN: { contains: query } },
        { lastName: { contains: query } },
        { lastNameEN: { contains: query } },
        ...whereAddressQuery(query),
      ],
      AND: {
        ...filterStatus(status),
        customerBranchId: branchId,
        subDistrict: zipCode ? { zipCode } : undefined,
        gender,
      },
    } satisfies Prisma.EmployeeWhereInput;

    const [result, total] = await prisma.$transaction([
      prisma.employee.findMany({
        orderBy: { createdAt: "asc" },
        include: {
          province: true,
          district: true,
          subDistrict: true,
          createdBy: true,
          updatedBy: true,
        },
        where,
        take: pageSize,
        skip: (page - 1) * pageSize,
      }),
      prisma.employee.count({ where }),
    ]);

    return {
      result: await Promise.all(
        result.map(async (v) => ({
          ...v,
          profileImageUrl: await minio.presignedGetObject(
            MINIO_BUCKET,
            imageLocation(v.id),
            12 * 60 * 60,
          ),
        })),
      ),
      page,
      pageSize,
      total,
    };
  }

  @Post()
  @Security("keycloak", MANAGE_ROLES)
  async create(@Request() req: RequestWithUser, @Body() body: CustomerBranchCreate) {
    const [province, district, subDistrict, customer] = await prisma.$transaction([
      prisma.province.findFirst({ where: { id: body.provinceId || undefined } }),
      prisma.district.findFirst({ where: { id: body.districtId || undefined } }),
      prisma.subDistrict.findFirst({ where: { id: body.subDistrictId || undefined } }),
      prisma.customer.findFirst({
        where: { id: body.customerId || undefined },
        include: {
          registeredBranch: {
            include: branchRelationPermInclude(req.user),
          },
          branch: {
            take: 1,
            orderBy: { createdAt: "asc" },
          },
        },
      }),
    ]);
    if (body.provinceId && !province) throw relationError("Province");
    if (body.districtId && !district) throw relationError("District");
    if (body.subDistrictId && !subDistrict) throw relationError("SubDistrict");
    if (!customer) throw relationError("Customer");

    let company = await permissionCheck(req.user, customer.registeredBranch).then(
      (v) => (v.headOffice || v).code,
    );

    const { provinceId, districtId, subDistrictId, customerId, ...rest } = body;

    const record = await prisma.$transaction(
      async (tx) => {
        const headoffice = customer.branch.at(0);
        const headofficeCode = headoffice?.code.slice(0, -3);

        let runningKey = "";

        if (headofficeCode) {
          runningKey = `CUSTOMER_BRANCH_${company}_${headofficeCode}`;
        } else if ("citizenId" in body) {
          runningKey = `CUSTOMER_BRANCH_${company}_${body.citizenId}`;
        } else {
          runningKey = `CUSTOMER_BRANCH_${company}_${body.legalPersonNo}`;
        }

        const last = await tx.runningNo.upsert({
          where: { key: runningKey },
          create: {
            key: runningKey,
            value: 1,
          },
          update: { value: { increment: 1 } },
        });

        if (headoffice) {
          await tx.customerBranch.updateMany({
            where: {
              id: headoffice.id,
              status: "CREATED",
            },
            data: { status: "ACTIVE" },
          });
        }

        return await tx.customerBranch.create({
          include: {
            province: true,
            district: true,
            subDistrict: true,
            createdBy: true,
            updatedBy: true,
          },
          data: {
            ...rest,
            code: `${runningKey.replace(`CUSTOMER_BRANCH_${company}_`, "")}-${`${last.value - 1}`.padStart(2, "0")}`,
            codeCustomer: runningKey.replace(`CUSTOMER_BRANCH_${company}_`, ""),
            customer: { connect: { id: customerId } },
            province: { connect: provinceId ? { id: provinceId } : undefined },
            district: { connect: districtId ? { id: districtId } : undefined },
            subDistrict: { connect: subDistrictId ? { id: subDistrictId } : undefined },
            createdBy: { connect: { id: req.user.sub } },
            updatedBy: { connect: { id: req.user.sub } },
          },
        });
      },
      { isolationLevel: Prisma.TransactionIsolationLevel.Serializable },
    );

    this.setStatus(HttpStatus.CREATED);

    return record;
  }

  @Put("{branchId}")
  @Security("keycloak", MANAGE_ROLES)
  async editById(
    @Request() req: RequestWithUser,
    @Body() body: CustomerBranchUpdate,
    @Path() branchId: string,
  ) {
    const branch = await prisma.customerBranch.findUnique({
      where: { id: branchId },
      include: {
        customer: {
          include: {
            registeredBranch: {
              include: branchRelationPermInclude(req.user),
            },
          },
        },
      },
    });

    if (!branch) {
      throw new HttpError(HttpStatus.NOT_FOUND, "Branch cannot be found.", "branchNotFound");
    }

    await permissionCheck(req.user, branch.customer.registeredBranch);

    if (!body.customerId) body.customerId = branch.customerId;

    if (body.provinceId || body.districtId || body.subDistrictId || body.customerId) {
      const [province, district, subDistrict, customer] = await prisma.$transaction([
        prisma.province.findFirst({ where: { id: body.provinceId || undefined } }),
        prisma.district.findFirst({ where: { id: body.districtId || undefined } }),
        prisma.subDistrict.findFirst({ where: { id: body.subDistrictId || undefined } }),
        prisma.customer.findFirst({
          where: { id: body.customerId || undefined },
          include: {
            registeredBranch: {
              include: branchRelationPermInclude(req.user),
            },
          },
        }),
      ]);
      if (body.provinceId && !province) throw relationError("Province");
      if (body.districtId && !district) throw relationError("District");
      if (body.subDistrictId && !subDistrict) throw relationError("SubDistrict");
      if (!customer) throw relationError("Customer");
      await permissionCheck(req.user, customer.registeredBranch);
    }

    const { provinceId, districtId, subDistrictId, customerId, ...rest } = body;

    return await prisma.customerBranch.update({
      where: { id: branchId },
      include: {
        province: true,
        district: true,
        subDistrict: true,
        createdBy: true,
        updatedBy: true,
      },
      data: {
        ...rest,
        statusOrder: +(rest.status === "INACTIVE"),
        customer: connectOrNot(customerId),
        province: connectOrDisconnect(provinceId),
        district: connectOrDisconnect(districtId),
        subDistrict: connectOrDisconnect(subDistrictId),
        updatedBy: { connect: { id: req.user.sub } },
      },
    });
  }

  @Delete("{branchId}")
  @Security("keycloak", MANAGE_ROLES)
  async delete(@Request() req: RequestWithUser, @Path() branchId: string) {
    const record = await prisma.customerBranch.findFirst({
      where: { id: branchId },
      include: {
        customer: {
          include: {
            registeredBranch: {
              include: branchRelationPermInclude(req.user),
            },
          },
        },
      },
    });

    if (!record) throw notFoundError("Customer Branch");

    await permissionCheck(req.user, record.customer.registeredBranch);

    if (record.status !== Status.CREATED) {
      throw new HttpError(
        HttpStatus.FORBIDDEN,
        "Customer branch is in used.",
        "customerBranchInUsed",
      );
    }

    return await prisma.customerBranch
      .delete({
        include: { createdBy: true, updatedBy: true },
        where: { id: branchId },
      })
      .then((v) => {
        deleteFolder(MINIO_BUCKET, `${attachmentLocation(record.customerId, branchId)}/`);
        return v;
      });
  }
}

@Route("api/v1/customer-branch/{branchId}/attachment")
@Tags("Customer Branch")
@Security("keycloak")
export class CustomerAttachmentController extends Controller {
  @Get()
  async listAttachment(@Path() branchId: string) {
    const record = await prisma.customerBranch.findFirst({
      where: { id: branchId },
    });

    if (!record) {
      throw new HttpError(
        HttpStatus.NOT_FOUND,
        "Customer branch cannot be found.",
        "customerBranchNotFound",
      );
    }

    const list = await new Promise<string[]>((resolve, reject) => {
      const item: string[] = [];

      const stream = minio.listObjectsV2(
        MINIO_BUCKET,
        `${attachmentLocation(record.customerId, branchId)}/`,
      );

      stream.on("data", (v) => v && v.name && item.push(v.name));
      stream.on("end", () => resolve(item));
      stream.on("error", () => reject(new Error("MinIO error.")));
    });

    return list.map((v) => v.split("/").at(-1) as string);
  }

  @Get("{filename}")
  async getAttachment(
    @Request() req: RequestWithUser,
    @Path() branchId: string,
    @Path() filename: string,
  ) {
    const record = await prisma.customerBranch.findFirst({
      where: { id: branchId },
    });

    if (!record) {
      throw new HttpError(
        HttpStatus.NOT_FOUND,
        "Customer branch cannot be found.",
        "customerBranchNotFound",
      );
    }

    return await minio.presignedGetObject(
      MINIO_BUCKET,
      `${attachmentLocation(record.customerId, branchId)}/${filename}`,
      12 * 60 * 60,
    );
  }

  @Put("{filename}")
  async addAttachment(
    @Request() req: RequestWithUser,
    @Path() branchId: string,
    @Path() filename: string,
  ) {
    const record = await prisma.customerBranch.findFirst({
      where: { id: branchId },
    });

    if (!record) {
      throw new HttpError(
        HttpStatus.NOT_FOUND,
        "Customer branch cannot be found.",
        "customerBranchNotFound",
      );
    }

    return req.res?.redirect(
      await minio.presignedPutObject(
        MINIO_BUCKET,
        `${attachmentLocation(record.customerId, branchId)}/${filename}`,
        12 * 60 * 60,
      ),
    );
  }

  @Delete("{filename}")
  async deleteAttachment(@Path() branchId: string, @Path() filename: string) {
    const record = await prisma.customerBranch.findFirst({
      where: { id: branchId },
    });

    if (!record) {
      throw new HttpError(
        HttpStatus.NOT_FOUND,
        "Customer branch cannot be found.",
        "customerBranchNotFound",
      );
    }

    await minio.removeObject(
      MINIO_BUCKET,
      `${attachmentLocation(record.customerId, branchId)}/${filename}`,
      { forceDelete: true },
    );
  }
}