jws-backend/src/controllers/04-institution-controller.ts

import { Prisma } from "@prisma/client";
import {
  Body,
  Controller,
  Delete,
  Get,
  OperationId,
  Path,
  Post,
  Put,
  Query,
  Route,
  Security,
  Tags,
} from "tsoa";
import prisma from "../db";
import { notFoundError } from "../utils/error";
import { queryOrNot } from "../utils/relation";

type InstitutionPayload = {
  name: string;

  code: string;

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

  subDistrictId: string;
  districtId: string;
  provinceId: string;
};

@Route("api/v1/institution")
@Tags("Institution")
export class InstitutionController extends Controller {
  @Get()
  @Security("keycloak")
  @OperationId("getInstitutionList")
  async getInstitutionList(
    @Query() query: string = "",
    @Query() page: number = 1,
    @Query() pageSize: number = 30,
    @Query() group?: string,
  ) {
    const where = {
      group,
      OR: queryOrNot<Prisma.InstitutionWhereInput[]>(query, [{ name: { contains: query } }]),
    } satisfies Prisma.InstitutionWhereInput;

    const [result, total] = await prisma.$transaction([
      prisma.institution.findMany({
        where,
        take: pageSize,
        skip: (page - 1) * pageSize,
      }),
      prisma.institution.count({ where }),
    ]);

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

  @Get("{institutionId}")
  @Security("keycloak")
  @OperationId("getInstitution")
  async getInstitution(@Path() institutionId: string, @Query() group?: string) {
    return await prisma.institution.findFirst({
      where: { id: institutionId, group },
    });
  }

  @Post()
  @Security("keycloak")
  @OperationId("createInstitution")
  async createInstitution(@Body() body: InstitutionPayload) {
    return await prisma.$transaction(async (tx) => {
      const last = await tx.runningNo.upsert({
        where: {
          key: `INST_${body.code}`,
        },
        create: {
          key: `INST_${body.code}`,
          value: 1,
        },
        update: { value: { increment: 1 } },
      });

      return await tx.institution.create({
        data: {
          ...body,
          code: `${body.code}${last.value.toString().padStart(5, "0")}`,
          group: body.code,
        },
      });
    });
  }

  @Put("{institutionId}")
  @Security("keycloak")
  @OperationId("updateInstitution")
  async updateInstitution(@Path() institutionId: string, @Body() body: InstitutionPayload) {
    return await prisma.institution.update({
      where: { id: institutionId },
      data: body,
    });
  }

  @Delete("{institutionId}")
  @Security("keycloak")
  @OperationId("deleteInstitution")
  async deleteInstitution(@Path() institutionId: string) {
    return await prisma.$transaction(async (tx) => {
      const record = await tx.institution.findFirst({
        where: { id: institutionId },
      });

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

      return await tx.institution.delete({
        where: { id: institutionId },
      });
    });
  }
}