jws-backend/src/controllers/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 from "../services/minio";

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

const MINIO_BUCKET = process.env.MINIO_BUCKET;

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;

  status?: Status;

  legalPersonNo: string;

  taxNo: string | null;
  name: string;
  nameEN: string;
  addressEN: string;
  address: string;
  zipCode: string;
  email: string;
  telephoneNo: string;

  registerName: string;
  registerDate: Date;
  authorizedCapital: string;

  employmentOffice: string;
  bussinessType: string;
  bussinessTypeEN: string;
  jobPosition: string;
  jobPositionEN: string;
  jobDescription: string;
  saleEmployee: string;
  payDate: Date;
  wageRate: number;

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

export type CustomerBranchUpdate = {
  customerId?: string;

  status?: "ACTIVE" | "INACTIVE";

  legalPersonNo?: string;

  taxNo?: string | null;
  name?: string;
  nameEN?: string;
  addressEN?: string;
  address?: string;
  zipCode?: string;
  email?: string;
  telephoneNo?: string;

  registerName?: string;
  registerDate?: Date;
  authorizedCapital?: string;

  employmentOffice?: string;
  bussinessType?: string;
  bussinessTypeEN?: string;
  jobPosition?: string;
  jobPositionEN?: string;
  jobDescription?: string;
  saleEmployee?: string;
  payDate?: Date;
  wageRate?: number;

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

@Route("api/v1/customer-branch")
@Tags("Customer Branch")
@Security("keycloak")
export class CustomerBranchController extends Controller {
  @Get()
  async list(
    @Query() zipCode?: string,
    @Query() customerId?: string,
    @Query() status?: Status,
    @Query() includeCustomer?: boolean,
    @Query() query: string = "",
    @Query() page: number = 1,
    @Query() pageSize: number = 30,
  ) {
    const filterStatus = (val?: Status) => {
      if (!val) return {};

      return val !== Status.CREATED && val !== Status.ACTIVE
        ? { status: val }
        : { OR: [{ status: Status.CREATED }, { status: Status.ACTIVE }] };
    };

    const where = {
      OR: [
        { nameEN: { contains: query }, zipCode, ...filterStatus(status) },
        { name: { contains: query }, zipCode, ...filterStatus(status) },
        { email: { contains: query }, zipCode, ...filterStatus(status) },
        { code: { contains: query }, zipCode, ...filterStatus(status) },
        { address: { contains: query }, zipCode, ...filterStatus(status) },
        { addressEN: { contains: query }, zipCode, ...filterStatus(status) },
        { province: { name: { contains: query } }, zipCode, ...filterStatus(status) },
        { province: { nameEN: { contains: query } }, zipCode, ...filterStatus(status) },
        { district: { name: { contains: query } }, zipCode, ...filterStatus(status) },
        { district: { nameEN: { contains: query } }, zipCode, ...filterStatus(status) },
        { subDistrict: { name: { contains: query } }, zipCode, ...filterStatus(status) },
        { subDistrict: { nameEN: { contains: query } }, zipCode, ...filterStatus(status) },
        {
          customer: {
            OR: [{ customerName: { contains: query } }, { customerNameEN: { contains: query } }],
          },
          zipCode,
          status,
        },
      ],
      AND: { customerId },
    } 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,
          _count: true,
        },
        where,
        take: pageSize,
        skip: (page - 1) * pageSize,
      }),
      prisma.customerBranch.count({ where }),
    ]);

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

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

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

    return record;
  }

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

    const [result, total] = await prisma.$transaction([
      prisma.employee.findMany({
        orderBy: { createdAt: "asc" },
        include: {
          province: true,
          district: true,
          subDistrict: 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()
  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 } }),
    ]);
    if (body.provinceId && !province)
      throw new HttpError(
        HttpStatus.BAD_REQUEST,
        "Province cannot be found.",
        "relationProvinceNotFound",
      );
    if (body.districtId && !district)
      throw new HttpError(
        HttpStatus.BAD_REQUEST,
        "District cannot be found.",
        "relationDistrictNotFound",
      );
    if (body.subDistrictId && !subDistrict)
      throw new HttpError(
        HttpStatus.BAD_REQUEST,
        "Sub-district cannot be found.",
        "relationSubDistrictNotFound",
      );
    if (!customer)
      throw new HttpError(
        HttpStatus.BAD_REQUEST,
        "Customer cannot be found.",
        "relationCustomerNotFound",
      );

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

    const record = await prisma.$transaction(
      async (tx) => {
        const count = await tx.customerBranch.count({
          where: { customerId },
        });

        return await tx.customerBranch.create({
          include: {
            province: true,
            district: true,
            subDistrict: true,
          },
          data: {
            ...rest,
            statusOrder: +(rest.status === "INACTIVE"),
            branchNo: count + 1,
            code: `${customer.code}-${(count + 1).toString().padStart(2, "0")}`,
            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 },
    );

    await prisma.customer.updateMany({
      where: { id: customerId, status: Status.CREATED },
      data: { status: Status.ACTIVE },
    });

    this.setStatus(HttpStatus.CREATED);

    return record;
  }

  @Put("{branchId}")
  async editById(
    @Request() req: RequestWithUser,
    @Body() body: CustomerBranchUpdate,
    @Path() branchId: string,
  ) {
    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 } }),
      ]);
      if (body.provinceId && !province)
        throw new HttpError(
          HttpStatus.BAD_REQUEST,
          "Province cannot be found.",
          "relationProvinceNotFound",
        );
      if (body.districtId && !district)
        throw new HttpError(
          HttpStatus.BAD_REQUEST,
          "District cannot be found.",
          "relationDistrictNotFound",
        );
      if (body.subDistrictId && !subDistrict)
        throw new HttpError(
          HttpStatus.BAD_REQUEST,
          "Sub-district cannot be found.",
          "relationSubDistrictNotFound",
        );
      if (body.customerId && !customer)
        throw new HttpError(
          HttpStatus.BAD_REQUEST,
          "Customer cannot be found.",
          "relationCustomerNotFound",
        );
    }

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

    if (!(await prisma.customerBranch.findUnique({ where: { id: branchId } }))) {
      throw new HttpError(HttpStatus.NOT_FOUND, "Branch cannot be found.", "branchNotFound");
    }

    const record = await prisma.customerBranch.update({
      where: { id: branchId },
      include: {
        province: true,
        district: true,
        subDistrict: true,
      },
      data: {
        ...rest,
        statusOrder: +(rest.status === "INACTIVE"),
        customer: { connect: customerId ? { id: customerId } : undefined },
        province: {
          connect: provinceId ? { id: provinceId } : undefined,
          disconnect: provinceId === null || undefined,
        },
        district: {
          connect: districtId ? { id: districtId } : undefined,
          disconnect: districtId === null || undefined,
        },
        subDistrict: {
          connect: subDistrictId ? { id: subDistrictId } : undefined,
          disconnect: subDistrictId === null || undefined,
        },
        updatedBy: { connect: { id: req.user.sub } },
      },
    });

    this.setStatus(HttpStatus.CREATED);

    return record;
  }

  @Delete("{branchId}")
  async delete(@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",
      );
    }

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

    return await prisma.customerBranch.delete({ where: { id: branchId } }).then((v) => {
      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.")));
      }).then((list) => {
        list.map(async (v) => {
          await minio.removeObject(MINIO_BUCKET, v, {
            forceDelete: true,
          });
        });
      });
      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 await Promise.all(
      list.map(async (v) => ({
        name: v.split("/").at(-1) as string,
        url: await minio.presignedGetObject(MINIO_BUCKET, v, 12 * 60 * 60),
      })),
    );
  }

  @Post()
  async addAttachment(@Path() branchId: string, @Body() payload: { file: 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 Promise.all(
      payload.file.map(async (v) => ({
        name: v,
        url: await minio.presignedGetObject(
          MINIO_BUCKET,
          `${attachmentLocation(record.customerId, branchId)}/${v}`,
        ),
        uploadUrl: await minio.presignedPutObject(
          MINIO_BUCKET,
          `${attachmentLocation(record.customerId, branchId)}/${v}`,
          12 * 60 * 60,
        ),
      })),
    );
  }

  @Delete()
  async deleteAttachment(@Path() branchId: string, @Body() payload: { file: 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 Promise.all(
      payload.file.map(async (v) => {
        await minio.removeObject(
          MINIO_BUCKET,
          `${attachmentLocation(record.customerId, branchId)}/${v}`,
          {
            forceDelete: true,
          },
        );
      }),
    );
  }
}