update: add Endpoint to Calculate Average Score By Sub Aspect and Aspect

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

@@ -7,6 +7,7 @@ import { options } from "../../drizzle/schema/options";
 import { questions } from "../../drizzle/schema/questions";
 import { subAspects } from "../../drizzle/schema/subAspects";
 import { aspects } from "../../drizzle/schema/aspects";
+import { assessments } from "../../drizzle/schema/assessments";
 import HonoEnv from "../../types/HonoEnv";
 import requestValidator from "../../utils/requestValidator";
 import authInfo from "../../middlewares/authInfo";
@@ -403,6 +404,133 @@ const assessmentsRoute = new Hono<HonoEnv>()
                 answer: updatedAnswer[0],  
             });
         }
-    )    
+    )
+
+    // Get data for One Sub Aspect average score By Sub Aspect Id and Assessment Id
+    .get(
+        '/average-score/sub-aspects/:subAspectId/assessments/:assessmentId', 
+        // checkPermission("assessments.readAssessmentScore"),
+        async (c) => {
+            const { subAspectId, assessmentId } = c.req.param();
+        
+            const averageScore = await db
+                .select({
+                    subAspectName: subAspects.name,
+                    average: sql`AVG(options.score)`
+                })
+                .from(answers)
+                .innerJoin(options, eq(answers.optionId, options.id))
+                .innerJoin(questions, eq(options.questionId, questions.id))
+                .innerJoin(subAspects, eq(questions.subAspectId, subAspects.id))
+                .innerJoin(assessments, eq(answers.assessmentId, assessments.id))
+                .where(
+                    sql`sub_aspects.id = ${subAspectId} AND assessments.id = ${assessmentId}`
+                )
+                .groupBy(subAspects.id);
+        
+            return c.json({
+                subAspectId,
+                subAspectName: averageScore[0].subAspectName,
+                assessmentId,
+                averageScore: averageScore.length > 0 ? averageScore[0].average : 0
+            });
+        }
+    )
+
+     // Get data for All Sub Aspects average score By Assessment Id
+    .get(
+        '/average-score/sub-aspects/assessments/:assessmentId', 
+        // checkPermission("assessments.readAssessmentScore"),
+        async (c) => {
+            const { assessmentId } = c.req.param();
+        
+            const averageScores = await db
+                .select({
+                    subAspectId: subAspects.id,
+                    subAspectName: subAspects.name,
+                    average: sql`AVG(options.score)`
+                })
+                .from(answers)
+                .innerJoin(options, eq(answers.optionId, options.id))
+                .innerJoin(questions, eq(options.questionId, questions.id))
+                .innerJoin(subAspects, eq(questions.subAspectId, subAspects.id))
+                .innerJoin(assessments, eq(answers.assessmentId, assessments.id))
+                .where(eq(assessments.id, assessmentId))
+                .groupBy(subAspects.id);
+        
+            return c.json({
+                assessmentId,
+                subAspects: averageScores.map(score => ({
+                    subAspectId: score.subAspectId,
+                    subAspectName: score.subAspectName,
+                    averageScore: score.average
+                }))
+            });
+        }
+    )
+
+    // Get data for One Aspect average score By Aspect Id and Assessment Id
+    .get(
+        "/average-score/aspects/:aspectId/assessments/:assessmentId", 
+        async (c) => {
+            const { aspectId, assessmentId } = c.req.param();
+        
+            const averageScore = await db
+                .select({
+                    aspectName: aspects.name,
+                    average: sql`AVG(options.score)`
+                })
+                .from(answers)
+                .innerJoin(options, eq(answers.optionId, options.id))
+                .innerJoin(questions, eq(options.questionId, questions.id))
+                .innerJoin(subAspects, eq(questions.subAspectId, subAspects.id))
+                .innerJoin(aspects, eq(subAspects.aspectId, aspects.id))
+                .innerJoin(assessments, eq(answers.assessmentId, assessments.id))
+                .where(
+                    sql`aspects.id = ${aspectId} AND assessments.id = ${assessmentId}`
+                )
+                .groupBy(aspects.id);
+        
+            return c.json({
+                aspectId,
+                aspectName: averageScore[0].aspectName,
+                assessmentId,
+                averageScore: averageScore.length > 0 ? averageScore[0].average : 0
+            });
+        }
+    )
+
+    // Get data for All Aspects average score By Assessment Id
+    .get(
+        '/average-score/aspects/assessments/:assessmentId', 
+        // checkPermission("assessments.readAssessmentScore"),
+        async (c) => {
+            const { assessmentId } = c.req.param();
+        
+            const averageScores = await db
+                .select({
+                    AspectId: aspects.id,
+                    AspectName: aspects.name,
+                    average: sql`AVG(options.score)`
+                })
+                .from(answers)
+                .innerJoin(options, eq(answers.optionId, options.id))
+                .innerJoin(questions, eq(options.questionId, questions.id))
+                .innerJoin(subAspects, eq(questions.subAspectId, subAspects.id))
+                .innerJoin(aspects, eq(subAspects.aspectId, aspects.id))
+                .innerJoin(assessments, eq(answers.assessmentId, assessments.id))
+                .where(eq(assessments.id, assessmentId))
+                .groupBy(aspects.id);
+        
+            return c.json({
+                assessmentId,
+                aspects: averageScores.map(score => ({
+                    AspectId: score.AspectId,
+                    AspectName: score.AspectName,
+                    averageScore: score.average
+                }))
+            });
+        }
+    )
 
 export default assessmentsRoute;