create: API for assessment request

apps/backend/src/data/permissions.ts

@@ -62,6 +62,12 @@ const permissionsData = [
 	{
 		code: "managementAspect.restore",
 	},
+	{
+		code: "assessmentRequest.read",
+	},
+	{
+		code: "assessmentRequest.create",
+	},
 ] as const;
 
 export type SpecificPermissionCode = (typeof permissionsData)[number]["code"];

apps/backend/src/index.ts

@@ -18,6 +18,7 @@ import HonoEnv from "./types/HonoEnv";
 import devRoutes from "./routes/dev/route";
 import appEnv from "./appEnv";
 import questionsRoute from "./routes/questions/route";
+import assessmentRequestRoute from "./routes/assessmentRequest/route";
 
 configDotenv();
 
@@ -84,6 +85,7 @@ const routes = app
 	.route("/questions", questionsRoute)
 	.route("/management-aspect", managementAspectsRoute)
 	.route("/register", respondentsRoute)
+	.route("/assessmentRequest", assessmentRequestRoute)
 	.onError((err, c) => {
 		if (err instanceof DashboardError) {
 			return c.json(

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

@@ -0,0 +1,105 @@
+import { eq } from "drizzle-orm";
+import { Hono } from "hono";
+import { z } from "zod";
+import db from "../../drizzle";
+import { respondents } from "../../drizzle/schema/respondents";
+import { assessments } from "../../drizzle/schema/assessments";
+import { users } from "../../drizzle/schema/users";
+import { rolesToUsers } from "../../drizzle/schema/rolesToUsers";
+import { rolesSchema } from "../../drizzle/schema/roles";
+import HonoEnv from "../../types/HonoEnv";
+import authInfo from "../../middlewares/authInfo";
+import { notFound } from "../../errors/DashboardError";
+import checkPermission from "../../middlewares/checkPermission";
+import requestValidator from "../../utils/requestValidator";
+import { HTTPException } from "hono/http-exception";
+import { createId } from "@paralleldrive/cuid2";
+
+const assessmentRequestRoute = new Hono<HonoEnv>()
+    .use(authInfo)
+
+    // Get assessment request by user ID
+    .get(
+        "/:id",
+        checkPermission("assessmentRequest.read"),
+        requestValidator(
+            "query",
+            z.object({
+                includeTrashed: z.string().default("false"),
+            })
+        ),
+        async (c) => {
+            const userId = c.req.param("id");
+
+            const queryResult = await db
+                .select({
+                    userId: users.id,
+                    createdAt: assessments.createdAt,
+                    name: users.name,
+                    code: rolesSchema.code,
+                    status: assessments.status,
+                })
+                .from(users)
+                .leftJoin(rolesToUsers, eq(users.id, rolesToUsers.userId))
+                .leftJoin(rolesSchema, eq(rolesToUsers.roleId, rolesSchema.id))
+                .leftJoin(respondents, eq(users.id, respondents.userId))
+                .leftJoin(assessments, eq(respondents.id, assessments.respondentId))
+                .where(eq(users.id, userId));
+
+            if (!queryResult[0]) throw notFound();
+
+            const assessmentRequestData = {
+                ...queryResult,
+            };
+
+            return c.json(assessmentRequestData);
+        }
+    )
+
+    // Post assessment request by user ID
+    .post(
+        "/:id",
+        checkPermission("assessmentRequest.create"),
+        requestValidator(
+            "json",
+            z.object({
+                respondentId: z.string().min(1),
+            })
+        ),
+        async (c) => {
+            const { respondentId } = c.req.valid("json");
+            const userId = c.req.param("id");
+
+            // Make sure the userId exists
+            if (!userId) {
+                throw new HTTPException(400, { message: "User ID is required." });
+            }
+
+            // Validate if respondent exists
+            const respondent = await db
+                .select()
+                .from(respondents)
+                .where(eq(respondents.id, respondentId));
+
+            if (!respondent.length) {
+                throw new HTTPException(404, { message: "Respondent not found." });
+            }
+
+            // Create the assessment request
+            const newAssessment = await db
+                .insert(assessments)
+                .values({
+                    id: createId(),
+                    respondentId,
+                    status: "menunggu konfirmasi",
+                    validatedBy: null,
+                    validatedAt: null,
+                    createdAt: new Date(),
+                })
+                .returning();
+
+            return c.json({ message: "Successfully submitted the assessment request" }, 201);
+        }
+    );
+
+export default assessmentRequestRoute;