From 9e43679d0f4d9c202a1b4e6801cb47f72cdcd7e8 Mon Sep 17 00:00:00 2001
From: Methapon2001 <61303214+Methapon2001@users.noreply.github.com>
Date: Mon, 16 Dec 2024 09:51:25 +0700
Subject: [PATCH] refactor: accept multiple work endpoint

---
 src/controllers/07-task-controller.ts | 119 ++++++++++++++++----------
 1 file changed, 76 insertions(+), 43 deletions(-)

diff --git a/src/controllers/07-task-controller.ts b/src/controllers/07-task-controller.ts
index 85a57bd..ccea097 100644
--- a/src/controllers/07-task-controller.ts
+++ b/src/controllers/07-task-controller.ts
@@ -18,6 +18,7 @@ import { notFoundError } from "../utils/error";
 import {
   Prisma,
   RequestDataStatus,
+  RequestWorkStatus,
   TaskOrderStatus,
   TaskStatus,
   UserTaskStatus,
@@ -252,6 +253,22 @@ export class TaskController extends Controller {
       }
       await permissionCheckCompany(req.user, userAffiliatedBranch);
 
+      const updated = await tx.requestWorkStepStatus.updateMany({
+        where: {
+          OR: taskList,
+          workStatus: RequestWorkStatus.Ready,
+        },
+        data: { workStatus: RequestWorkStatus.InProgress },
+      });
+
+      if (updated.count !== taskList.length) {
+        throw new HttpError(
+          HttpStatus.PRECONDITION_FAILED,
+          "All request work to issue task order must be in ready state.",
+          "requestWorkMustReady",
+        );
+      }
+
       return await tx.taskOrder.create({
         include: {
           taskList: {
@@ -404,62 +421,78 @@ export class TaskController extends Controller {
 @Route("/api/v1/task-order/{taskOrderId}")
 @Tags("Task Order")
 export class TaskActionController extends Controller {
-  @Post("accept")
+  @Post("accept/bulk")
   @Security("keycloak")
-  async acceptTaskOrder(@Request() req: RequestWithUser, @Path() taskOrderId: string) {
-    const record = await prisma.taskOrder.findFirst({
+  async acceptTaskOrderBulk(
+    @Request() req: RequestWithUser,
+    @Body()
+    body: {
+      taskOrderId: string[];
+    },
+  ) {
+    const record = await prisma.taskOrder.findMany({
       include: {
         taskList: {
           orderBy: { step: "asc" },
         },
       },
-      where: { id: taskOrderId },
+      where: { id: { in: body.taskOrderId } },
     });
 
     if (!record) throw notFoundError("Task Order");
 
-    await prisma.$transaction([
-      prisma.taskOrder.update({
-        where: { id: taskOrderId },
-        data: {
-          taskOrderStatus: TaskOrderStatus.InProgress,
-          userTask: {
-            create: {
-              userId: req.user.sub,
-              userTaskStatus: UserTaskStatus.Accept,
-            },
-          },
-        },
-      }),
-      prisma.task.updateMany({
-        where: {
-          taskOrderId: taskOrderId,
-          requestWorkStep: { responsibleUserId: req.user.sub },
-        },
-        data: {
-          taskStatus: TaskStatus.InProgress,
-        },
-      }),
-      prisma.requestData.updateMany({
-        where: {
-          requestWork: {
-            some: {
-              stepStatus: {
-                some: { task: { some: { taskOrderId: taskOrderId } } },
+    await prisma.$transaction(async (tx) => {
+      const promises = body.taskOrderId.flatMap((taskOrderId) => [
+        tx.taskOrder.update({
+          where: { id: taskOrderId },
+          data: {
+            taskOrderStatus: TaskOrderStatus.InProgress,
+            userTask: {
+              create: {
+                userId: req.user.sub,
+                userTaskStatus: UserTaskStatus.Accept,
               },
             },
           },
-        },
-        data: { requestDataStatus: RequestDataStatus.InProgress },
-      }),
-      prisma.userTask.create({
-        data: {
-          userId: req.user.sub,
-          taskOrderId: taskOrderId,
-          userTaskStatus: UserTaskStatus.Accept,
-        },
-      }),
-    ]);
+        }),
+        tx.task.updateMany({
+          where: {
+            taskOrderId: taskOrderId,
+            requestWorkStep: { responsibleUserId: req.user.sub },
+          },
+          data: {
+            taskStatus: TaskStatus.InProgress,
+          },
+        }),
+        tx.requestData.updateMany({
+          where: {
+            requestWork: {
+              some: {
+                stepStatus: {
+                  some: { task: { some: { taskOrderId: taskOrderId } } },
+                },
+              },
+            },
+          },
+          data: { requestDataStatus: RequestDataStatus.InProgress },
+        }),
+        tx.userTask.create({
+          data: {
+            userId: req.user.sub,
+            taskOrderId: taskOrderId,
+            userTaskStatus: UserTaskStatus.Accept,
+          },
+        }),
+      ]);
+
+      await Promise.all(promises);
+    });
+  }
+
+  @Post("accept")
+  @Security("keycloak")
+  async acceptTaskOrder(@Request() req: RequestWithUser, @Path() taskOrderId: string) {
+    await this.acceptTaskOrderBulk(req, { taskOrderId: [taskOrderId] });
   }
 
   @Post("set-task-status")