refactor: accept multiple work endpoint

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) {
+  async acceptTaskOrderBulk(
-    const record = await prisma.taskOrder.findFirst({
+    @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([
+    await prisma.$transaction(async (tx) => {
-      prisma.taskOrder.update({
+      const promises = body.taskOrderId.flatMap((taskOrderId) => [
-        where: { id: taskOrderId },
+        tx.taskOrder.update({
-        data: {
+          where: { id: taskOrderId },
-          taskOrderStatus: TaskOrderStatus.InProgress,
+          data: {
-          userTask: {
+            taskOrderStatus: TaskOrderStatus.InProgress,
-            create: {
+            userTask: {
-              userId: req.user.sub,
+              create: {
-              userTaskStatus: UserTaskStatus.Accept,
+                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 } } },
               },
             },
           },
-        },
+        }),
-        data: { requestDataStatus: RequestDataStatus.InProgress },
+        tx.task.updateMany({
-      }),
+          where: {
-      prisma.userTask.create({
+            taskOrderId: taskOrderId,
-        data: {
+            requestWorkStep: { responsibleUserId: req.user.sub },
-          userId: req.user.sub,
+          },
-          taskOrderId: taskOrderId,
+          data: {
-          userTaskStatus: UserTaskStatus.Accept,
+            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")