Update : All method API for management-aspect

apps/backend/src/routes/managementAspect/route.ts

@@ -1,6 +1,6 @@
-import { and, eq, ilike, isNull, or, sql } from "drizzle-orm";
+import { and, eq, ilike, isNull, or, sql, inArray } from "drizzle-orm";
 import { Hono } from "hono";
-
+import { questions } from "../../drizzle/schema/questions";
 import { z } from "zod";
 import db from "../../drizzle";
 import { aspects } from "../../drizzle/schema/aspects";
@@ -33,14 +33,16 @@ export const aspectFormSchema = z.object({
     .optional(),
 });
 
-export const aspectUpdateSchema = aspectFormSchema.extend({
-  subAspects: z.string().optional().or(z.literal("")),
-});
-
 // Schema for creating and updating subAspects
 export const subAspectFormSchema = z.object({
+  id: z.string(),
   name: z.string().min(1).max(50),
-  aspectId: z.string()
+  aspectId: z.string().optional(),
+});
+
+export const aspectUpdateSchema = z.object({
+  name: z.string(),
+  subAspects: z.array(subAspectFormSchema),
 });
 
 export const subAspectUpdateSchema = subAspectFormSchema.extend({});
@@ -71,7 +73,7 @@ const managementAspectRoute = new Hono<HonoEnv>()
             .optional()
             .transform((v) => v?.toLowerCase() === "true"),
           page: z.coerce.number().int().min(0).default(0),
-          limit: z.coerce.number().int().min(1).max(1000).default(10),
+          limit: z.coerce.number().int().min(1).max(1000).default(1000),
           q: z.string().default(""),
         })
       ),
@@ -104,8 +106,37 @@ const managementAspectRoute = new Hono<HonoEnv>()
           .offset(page * limit)
           .limit(limit);
     
+        // Grouping sub-aspects by aspect ID
+        const groupedResult = result.reduce((acc, curr) => {
+          const aspectId = curr.id;
+    
+          if (!acc[aspectId]) {
+            acc[aspectId] = {
+              id: curr.id,
+              name: curr.name,
+              createdAt: curr.createdAt ? new Date(curr.createdAt).toISOString() : null,
+              updatedAt: curr.updatedAt ? new Date(curr.updatedAt).toISOString() : null,
+              subAspects: curr.subAspectName ? [{ id: curr.subAspectId!, name: curr.subAspectName }] : [],
+            };
+          } else {
+            if (curr.subAspectName) {
+              acc[aspectId].subAspects.push({ id: curr.subAspectId!, name: curr.subAspectName });
+            }
+          }
+    
+          return acc;
+        }, {} as Record<string, {
+          id: string;
+          name: string;
+          createdAt: string | null;
+          updatedAt: string | null;
+          subAspects: { id: string; name: string }[];
+        }>);
+    
+        const groupedArray = Object.values(groupedResult);
+    
         return c.json({
-          data: result.map((d) => ({ ...d, fullCount: undefined })),
+          data: groupedArray,
           _metadata: {
             currentPage: page,
             totalPages: Math.ceil((Number(result[0]?.fullCount) ?? 0) / limit),
@@ -146,11 +177,14 @@ const managementAspectRoute = new Hono<HonoEnv>()
             subAspect: {
               name: subAspects.name,
               id: subAspects.id,
+              questionCount: sql`COUNT(${questions.id})`.as("questionCount"),
             },
           })
           .from(aspects)
           .leftJoin(subAspects, eq(aspects.id, subAspects.aspectId))
-          .where(and(eq(aspects.id, aspectId), !includeTrashed ? isNull(aspects.deletedAt) : undefined));
+          .leftJoin(questions, eq(subAspects.id, questions.subAspectId))
+          .where(and(eq(aspects.id, aspectId), !includeTrashed ? isNull(aspects.deletedAt) : undefined))
+          .groupBy(aspects.id, aspects.name, aspects.createdAt, aspects.updatedAt, subAspects.id, subAspects.name);
     
         if (!queryResult.length)
           throw forbidden({
@@ -159,14 +193,17 @@ const managementAspectRoute = new Hono<HonoEnv>()
     
         const subAspectsList = queryResult.reduce((prev, curr) => {
           if (!curr.subAspect) return prev;
-          prev.set(curr.subAspect.id, curr.subAspect.name);
+          prev.set(curr.subAspect.id, {
+            name: curr.subAspect.name,
+            questionCount: Number(curr.subAspect.questionCount), 
+          });
           return prev;
-        }, new Map<string, string>()); // Map<id, name>
+        }, new Map<string, { name: string; questionCount: number }>()); 
     
         const aspectData = {
           ...queryResult[0],
           subAspect: undefined,
-          subAspects: Array.from(subAspectsList, ([id, name]) => ({ id, name })),
+          subAspects: Array.from(subAspectsList, ([id, { name, questionCount }]) => ({ id, name, questionCount })),
         };
     
         return c.json(aspectData);
@@ -180,33 +217,36 @@ const managementAspectRoute = new Hono<HonoEnv>()
       async (c) => {
         const aspectData = c.req.valid("json");
     
-      // Validation to check if the aspect name already exists
+        // Cek jika nama aspek sudah ada
         const existingAspect = await db
           .select()
           .from(aspects)
           .where(eq(aspects.name, aspectData.name));
     
+        let aspectId;
         if (existingAspect.length > 0) {
-        throw forbidden({
+          // Jika aspek sudah ada, ambil ID-nya
-          message: "Aspect name already exists",
+          aspectId = existingAspect[0].id;
-        });
+        } else {
-      }
+          // Jika tidak ada, buat aspek baru
-
           const aspect = await db
             .insert(aspects)
             .values({
               name: aspectData.name,
             })
             .returning();
+          aspectId = aspect[0].id;
+        }
     
-      // if sub-aspects are available, parse them into a string array
+        // Jika ada data sub-aspek, parse dan masukkan ke database
         if (aspectData.subAspects) {
           const subAspectsArray = JSON.parse(aspectData.subAspects) as string[];
-        // if there are sub-aspects, insert them into the database
+    
+          // Masukkan sub-aspek baru ke database tanpa cek duplikasi sub-aspek
           if (subAspectsArray.length) {
             await db.insert(subAspects).values(
               subAspectsArray.map((subAspect) => ({
-              aspectId: aspect[0].id,
+                aspectId,
                 name: subAspect,
               }))
             );
@@ -215,7 +255,7 @@ const managementAspectRoute = new Hono<HonoEnv>()
     
         return c.json(
           {
-            message: "Aspect created successfully",
+            message: "Aspect and sub-aspects created successfully",
           },
           201
         );
@@ -231,7 +271,7 @@ const managementAspectRoute = new Hono<HonoEnv>()
         const aspectId = c.req.param("id");
         const aspectData = c.req.valid("json");
     
-      // Validation to check if the new aspect name already exists
+        // Cek jika nama aspek baru sudah ada
         const existingAspect = await db
           .select()
           .from(aspects)
@@ -249,6 +289,7 @@ const managementAspectRoute = new Hono<HonoEnv>()
           });
         }
     
+        // Cek jika aspek yang dimaksud ada
         const aspect = await db
           .select()
           .from(aspects)
@@ -256,16 +297,76 @@ const managementAspectRoute = new Hono<HonoEnv>()
     
         if (!aspect[0]) throw notFound();
     
+        // Update nama aspek
         await db
           .update(aspects)
           .set({
-          ...aspectData,
+            name: aspectData.name,
             updatedAt: new Date(),
           })
           .where(eq(aspects.id, aspectId));
     
+        // Ambil data sub-aspek baru dari request
+        const newSubAspects = aspectData.subAspects || [];
+    
+        // Ambil sub-aspek yang ada saat ini
+        const currentSubAspects = await db
+          .select({ id: subAspects.id, name: subAspects.name })
+          .from(subAspects)
+          .where(eq(subAspects.aspectId, aspectId));
+    
+        const currentSubAspectMap = new Map(currentSubAspects.map(sub => [sub.id, sub.name]));
+    
+        // Sub-aspek yang harus dihapus
+        const subAspectsToDelete = currentSubAspects
+          .filter(sub => !newSubAspects.some(newSub => newSub.id === sub.id))
+          .map(sub => sub.id);
+    
+        // Hapus sub-aspek yang tidak ada di data baru
+        if (subAspectsToDelete.length) {
+          await db
+            .delete(subAspects)
+            .where(
+              and(
+                eq(subAspects.aspectId, aspectId),
+                inArray(subAspects.id, subAspectsToDelete)
+              )
+            );
+        }
+    
+        // Update atau tambahkan sub-aspek baru
+        for (const subAspect of newSubAspects) {
+          const existingSubAspect = currentSubAspectMap.has(subAspect.id);
+    
+          if (existingSubAspect) {
+            // Update jika sub-aspek sudah ada
+            await db
+              .update(subAspects)
+              .set({
+                name: subAspect.name,
+                updatedAt: new Date(),
+              })
+              .where(
+                and(
+                  eq(subAspects.id, subAspect.id),
+                  eq(subAspects.aspectId, aspectId)
+                )
+              );
+          } else {
+            // Tambah jika sub-aspek baru
+            await db
+              .insert(subAspects)
+              .values({
+                id: subAspect.id, // Pastikan `id` diberikan
+                aspectId,
+                name: subAspect.name,
+                createdAt: new Date(),
+              });
+          }
+        }
+    
         return c.json({
-          message: "Aspect updated successfully",
+          message: "Aspect and sub-aspects updated successfully",
         });
       }
     )                              
@@ -333,159 +434,4 @@ const managementAspectRoute = new Hono<HonoEnv>()
       }
     )
 
-    // Get sub aspects by aspect ID
-    .get(
-      "/subAspects/:aspectId", 
-      checkPermission("managementAspect.readAll"), 
-      async (c) => {
-        const aspectId = c.req.param("aspectId");
-
-        const aspect = await db
-          .select()
-          .from(aspects)
-          .where(and(
-            eq(aspects.id, aspectId), 
-            isNull(aspects.deletedAt)));
-
-        if (!aspect[0])
-          throw notFound({
-            message: "The aspect is not found",
-          });
-
-        const subAspectsData = await db
-          .select()
-          .from(subAspects)
-          .where(eq(subAspects.aspectId, aspectId));
-
-        return c.json({
-          subAspects: subAspectsData,
-        });
-      }
-    )
-
-    // Create sub aspect
-    .post(
-      "/subAspect", 
-      checkPermission("managementAspect.create"), 
-      requestValidator("json", subAspectFormSchema), 
-      async (c) => {
-        const subAspectData = c.req.valid("json");
-
-        // Validation to check if the sub aspect name already exists
-        const existingSubAspect = await db
-          .select()
-          .from(subAspects)
-          .where(
-            and(
-              eq(subAspects.name, subAspectData.name), 
-              eq(subAspects.aspectId, subAspectData.aspectId)));
-
-        if (existingSubAspect.length > 0) {
-          throw forbidden({ message: "Sub aspect name already exists!" });
-        }
-
-        const [aspect] = await db
-          .select()
-          .from(aspects)
-          .where(
-            and(
-              eq(aspects.id, subAspectData.aspectId), 
-              isNull(aspects.deletedAt)));
-
-        if (!aspect)
-          throw forbidden({
-            message: "The aspect is not found",
-          });
-
-        await db.insert(subAspects).values(subAspectData);
-
-        return c.json(
-          {
-            message: "Sub aspect created successfully",
-          },
-          201
-        );
-      }
-    )
-
-    // Update sub aspect
-    .patch(
-      "/subAspect/:id", 
-      checkPermission("managementAspect.update"), 
-      requestValidator("json", subAspectUpdateSchema), 
-      async (c) => {
-        const subAspectId = c.req.param("id");
-        const subAspectData = c.req.valid("json");
-    
-        // Validate if the new sub aspect name already exists for the given aspect
-        const existingSubAspect = await db
-          .select()
-          .from(subAspects)
-          .where(
-            and(
-              eq(subAspects.name, subAspectData.name), 
-              eq(subAspects.aspectId, subAspectData.aspectId),
-            )
-          );
-    
-        if (existingSubAspect.length > 0) {
-          throw forbidden({ message: "Sub Aspect name already exists" });
-        }
-    
-        const [currentSubAspect] = await db
-          .select()
-          .from(subAspects)
-          .where(eq(subAspects.id, subAspectId));
-    
-        if (!currentSubAspect)
-          throw notFound({
-            message: "The sub aspect is not found",
-          });
-    
-        // Update the sub aspect
-        await db
-          .update(subAspects)
-          .set({
-            ...subAspectData,
-            updatedAt: new Date(),
-          })
-          .where(eq(subAspects.id, subAspectId));
-    
-        return c.json({
-          message: "Sub Aspect updated successfully",
-        });
-      }
-    )    
-
-    // Delete sub aspect
-    .delete(
-      "/subAspect/:id", 
-      checkPermission("managementAspect.delete"), 
-      async (c) => {
-        const subAspectId = c.req.param("id");
-
-        const subAspect = await db
-          .select()
-          .from(subAspects)
-          .where(eq(subAspects.id, subAspectId));
-
-        if (!subAspect[0])
-          throw notFound({
-            message: "The sub aspect is not found",
-          });
-
-        await db
-          .update(subAspects)
-          .set({
-            deletedAt: new Date(),
-          })
-          .where(eq(subAspects.id, subAspectId));
-        // await db.delete(subAspects).where(eq(subAspects.id, subAspectId));
-
-        return c.json({
-          message: "Sub aspect deleted successfully",
-        });
-      }
-    );
-
 export default managementAspectRoute;