Dev

src/api/modules/student/controllers/StudentCalendarResultRead.controller.ts

@@ -0,0 +1,43 @@
+import { autoInjectable } from "tsyringe";
+import BaseController from "../../base/contollers/Base.controller";
+import { HttpHeaderEnum } from "~/api/shared/helpers/enums/HttpHeader.enum";
+import { HttpMethodEnum } from "~/api/shared/helpers/enums/HttpMethod.enum";
+import { HttpStatusCodeEnum } from "~/api/shared/helpers/enums/HttpStatusCode.enum";
+import ApplicationStatusEnum from "~/api/shared/helpers/enums/ApplicationStatus.enum";
+import { HttpContentTypeEnum } from "~/api/shared/helpers/enums/HttpContentType.enum";
+import StudentCalendarResultReadService from "../services/StudentCalendarResultRead.service";
+import { EntryPointHandler, INextFunction, IRequest, IResponse, IRouter } from "~/infrastructure/internal/types";
+
+@autoInjectable()
+export default class StudentTermResultReadController extends BaseController {
+  static controllerName: string;
+  private studentCalendarResultReadService: StudentCalendarResultReadService;
+  constructor(studentCalendarResultReadService: StudentCalendarResultReadService) {
+    super();
+    this.controllerName = "StudentCalendarResultReadController";
+    this.studentCalendarResultReadService = studentCalendarResultReadService;
+  }
+
+  read: EntryPointHandler = async (req: IRequest, res: IResponse, next: INextFunction): Promise<void> => {
+    return this.handleResultData(res, next, this.studentCalendarResultReadService.execute(res.trace, req), {
+      [HttpHeaderEnum.CONTENT_TYPE]: HttpContentTypeEnum.APPLICATION_JSON,
+    });
+  };
+
+  public initializeRoutes(router: IRouter): void {
+    this.setRouter(router());
+
+    this.addRoute({
+      method: HttpMethodEnum.POST,
+      path: "/student/calendarresult/list",
+      handlers: [this.read],
+      produces: [
+        {
+          applicationStatus: ApplicationStatusEnum.CREATED,
+          httpStatus: HttpStatusCodeEnum.CREATED,
+        },
+      ],
+      description: "List of Student Calendar Results",
+    });
+  }
+}

src/api/modules/student/providers/StudentCalendarResultCreate.provider.ts

@@ -0,0 +1,33 @@
+import { StudentCalendarResult } from "@prisma/client";
+import { StudentCalendarResultCreateType } from "../types/StudentTypes";
+import DbClient, { PrismaTransactionClient } from "~/infrastructure/internal/database";
+import { EnforceTenantId } from "~/api/modules/base/decorators/EnforceTenantId.decorator";
+import { InternalServerError } from "~/infrastructure/internal/exceptions/InternalServerError";
+
+@EnforceTenantId
+export default class StudentCalendarResultCreateProvider {
+  public async create(args: StudentCalendarResultCreateType, dbClient: PrismaTransactionClient = DbClient): Promise<StudentCalendarResult> {
+    try {
+      const { studentId, calendarId, tenantId, totalScore, averageScore, subjectCountGraded, finalized, finalizedTermResultsCount, classId, classDivisionId } = args;
+
+      const result = await dbClient.studentCalendarResult.create({
+        data: {
+          calendarId,
+          classId,
+          tenantId,
+          studentId,
+          finalized,
+          finalizedTermResultsCount,
+          totalScore,
+          averageScore,
+          classDivisionId,
+          subjectCountGraded,
+        },
+      });
+
+      return result;
+    } catch (error: any) {
+      throw new InternalServerError(error);
+    }
+  }
+}

src/api/modules/student/providers/StudentCalendarResultRead.provider.ts

@@ -1,4 +1,6 @@
 import { StudentCalendarResult } from "@prisma/client";
+import { StudentCalendarResultReadType } from "../types/StudentTypes";
+import { userObjectWithoutPassword } from "~/api/shared/helpers/objects";
 import DbClient, { PrismaTransactionClient } from "~/infrastructure/internal/database";
 import { EnforceTenantId } from "~/api/modules/base/decorators/EnforceTenantId.decorator";
 import { InternalServerError } from "~/infrastructure/internal/exceptions/InternalServerError";
@@ -20,4 +22,36 @@ export default class StudentCalendarResultReadProvider {
       throw new InternalServerError(error);
     }
   }
+
+  public async getByCriteria(criteria: StudentCalendarResultReadType, dbClient: PrismaTransactionClient = DbClient): Promise<StudentCalendarResult[]> {
+    try {
+      const { studentId, calendarId, tenantId, classId, classDivisionId } = criteria;
+
+      const results = await dbClient.studentCalendarResult.findMany({
+        where: {
+          ...(calendarId && { calendarId }),
+          ...(classId && { classId }),
+          ...(tenantId && { tenantId }),
+          ...(studentId && { studentId }),
+          ...(classDivisionId && { classDivisionId }),
+        },
+        include: {
+          student: {
+            include: {
+              user: { select: userObjectWithoutPassword },
+              _count: {
+                select: {
+                  subjectsRegistered: true,
+                },
+              },
+            },
+          },
+        },
+      });
+
+      return results;
+    } catch (error: any) {
+      throw new InternalServerError(error.message);
+    }
+  }
 }

src/api/modules/student/providers/StudentCalendarResultUpdate.provider.ts

@@ -0,0 +1,34 @@
+import { StudentCalendarResult } from "@prisma/client";
+import { StudentCalendarResultUpdateType } from "../types/StudentTypes";
+import DbClient, { PrismaTransactionClient } from "~/infrastructure/internal/database";
+import { EnforceTenantId } from "~/api/modules/base/decorators/EnforceTenantId.decorator";
+import { InternalServerError } from "~/infrastructure/internal/exceptions/InternalServerError";
+
+@EnforceTenantId
+export default class StudentCalendarResultUpdateProvider {
+  public async update(args: StudentCalendarResultUpdateType, dbClient: PrismaTransactionClient = DbClient): Promise<StudentCalendarResult> {
+    try {
+      const { studentId, calendarId, tenantId, averageScore, finalized, subjectCountGraded, totalScore } = args;
+
+      const result = await dbClient.studentCalendarResult.update({
+        where: {
+          studentId_calendarId_tenantId: {
+            studentId,
+            calendarId,
+            tenantId,
+          },
+        },
+        data: {
+          averageScore,
+          finalized,
+          subjectCountGraded,
+          totalScore,
+        },
+      });
+
+      return result;
+    } catch (error: any) {
+      throw new InternalServerError(error);
+    }
+  }
+}

src/api/modules/student/providers/StudentTermResultCreate.provider.ts

@@ -8,7 +8,7 @@ import { InternalServerError } from "~/infrastructure/internal/exceptions/Intern
 export default class StudentTermResultCreateProvider {
   public async create(args: StudentTermResultCreateType, dbClient: PrismaTransactionClient = DbClient): Promise<StudentTermResult> {
     try {
-      const { studentId, termId, tenantId, totalScore, averageScore, subjectCountGraded, subjectCountOffered, finalized, classId, classDivisionId } = args;
+      const { studentId, termId, tenantId, totalScore, averageScore, subjectCountGraded, finalized, classId, classDivisionId } = args;
 
       const result = await dbClient.studentTermResult.create({
         data: {
@@ -21,7 +21,6 @@ export default class StudentTermResultCreateProvider {
           averageScore,
           classDivisionId,
           subjectCountGraded,
-          subjectCountOffered,
         },
       });
 

src/api/modules/student/providers/StudentTermResultRead.provider.ts

@@ -33,6 +33,11 @@ export default class StudentTermResultReadProvider {
                   },
                 },
               },
+              _count: {
+                select: {
+                  subjectsRegistered: true,
+                },
+              },
             },
           },
         },

src/api/modules/student/providers/StudentTermResultUpdate.provider.ts

@@ -8,7 +8,7 @@ import { InternalServerError } from "~/infrastructure/internal/exceptions/Intern
 export default class StudentTermResultUpdateProvider {
   public async update(args: StudentTermResultUpdateType, dbClient: PrismaTransactionClient = DbClient): Promise<StudentTermResult> {
     try {
-      const { studentId, termId, tenantId, averageScore, finalized, subjectCountGraded, subjectCountOffered, totalScore } = args;
+      const { studentId, termId, tenantId, averageScore, finalized, subjectCountGraded, totalScore } = args;
 
       const result = await dbClient.studentTermResult.update({
         where: {
@@ -22,7 +22,6 @@ export default class StudentTermResultUpdateProvider {
           averageScore,
           finalized,
           subjectCountGraded,
-          subjectCountOffered,
           totalScore,
         },
       });

src/api/modules/student/services/StudentCalendarResultRead.service.ts

@@ -0,0 +1,46 @@
+import { autoInjectable } from "tsyringe";
+import { IRequest } from "~/infrastructure/internal/types";
+import { BaseService } from "../../base/services/Base.service";
+import { IResult } from "~/api/shared/helpers/results/IResult";
+import { ERROR } from "~/api/shared/helpers/messages/SystemMessages";
+import { ServiceTrace } from "~/api/shared/helpers/trace/ServiceTrace";
+import { ILoggingDriver } from "~/infrastructure/internal/logger/ILoggingDriver";
+import { HttpStatusCodeEnum } from "~/api/shared/helpers/enums/HttpStatusCode.enum";
+import { SUCCESS, STUDENT_RESOURCE } from "~/api/shared/helpers/messages/SystemMessages";
+import StudentCalendarResultReadProvider from "../providers/StudentCalendarResultRead.provider";
+import { LoggingProviderFactory } from "~/infrastructure/internal/logger/LoggingProviderFactory";
+import { RESOURCE_FETCHED_SUCCESSFULLY } from "~/api/shared/helpers/messages/SystemMessagesFunction";
+
+@autoInjectable()
+export default class StudentCalendarResultReadService extends BaseService<IRequest> {
+  static serviceName = "StudentCalendarResultReadService";
+  loggingProvider: ILoggingDriver;
+  studentCalendarResultReadProvider: StudentCalendarResultReadProvider;
+
+  constructor(studentCalendarResultReadProvider: StudentCalendarResultReadProvider) {
+    super(StudentCalendarResultReadService.serviceName);
+    this.studentCalendarResultReadProvider = studentCalendarResultReadProvider;
+    this.loggingProvider = LoggingProviderFactory.build();
+  }
+
+  public async execute(trace: ServiceTrace, args: IRequest): Promise<IResult> {
+    try {
+      this.initializeServiceTrace(trace, args.query);
+
+      const { tenantId } = args.body;
+      const { calendarId, classId, classDivisionId } = args.query;
+
+      const calendarResults = await this.studentCalendarResultReadProvider.getByCriteria({ tenantId: Number(tenantId), calendarId: Number(calendarId), classId: Number(classId), classDivisionId: Number(classDivisionId) });
+
+      trace.setSuccessful();
+
+      this.result.setData(SUCCESS, HttpStatusCodeEnum.SUCCESS, RESOURCE_FETCHED_SUCCESSFULLY(STUDENT_RESOURCE), calendarResults);
+
+      return this.result;
+    } catch (error: any) {
+      this.loggingProvider.error(error);
+      this.result.setError(ERROR, error.httpStatusCode, error.description);
+      return this.result;
+    }
+  }
+}

src/api/modules/student/types/StudentTypes.ts

@@ -149,7 +149,6 @@ export interface StudentTermResultCreateType {
   averageScore?: number;
   classId: number;
   subjectCountGraded?: number;
-  subjectCountOffered?: number;
   classDivisionId: number;
 }
 
@@ -160,7 +159,6 @@ export interface StudentTermResultUpdateType {
   totalScore?: number;
   averageScore?: number;
   subjectCountGraded?: number;
-  subjectCountOffered?: number;
   finalized?: boolean;
 }
 
@@ -171,3 +169,34 @@ export interface StudentTermResultReadType {
   studentId?: number;
   classDivisionId?: number;
 }
+
+export interface StudentCalendarResultCreateType {
+  calendarId: number;
+  tenantId: number;
+  studentId: number;
+  totalScore?: number;
+  finalized?: boolean;
+  averageScore?: number;
+  classId: number;
+  subjectCountGraded?: number;
+  classDivisionId: number;
+  finalizedTermResultsCount?: number;
+}
+
+export interface StudentCalendarResultUpdateType {
+  studentId: number;
+  calendarId: number;
+  tenantId: number;
+  totalScore?: number;
+  averageScore?: number;
+  subjectCountGraded?: number;
+  finalized?: boolean;
+}
+
+export interface StudentCalendarResultReadType {
+  calendarId: number;
+  classId?: number;
+  tenantId?: number;
+  studentId?: number;
+  classDivisionId?: number;
+}