@neutron.co.id/pendidikan-operation 1.29.6 → 1.29.8

package/build/providers/penilaian/usePenilaian.cjs

@@ -30,12 +30,17 @@ function usePenilaian(stream) {
     console.log("grading: ", grading);
     const parsedScores = Object.fromEntries(
       Object.entries(grading?.data?.import?.scores).map(([key, value]) => {
-        const normalizedValue = Number.parseFloat(String(value).replace(",", "."));
+        const normalizedValue = Number.parseFloat(
+          String(value).replace(",", ".")
+        );
         return [key, Number.isNaN(normalizedValue) ? null : normalizedValue];
       })
     );
     const score = parsedScores;
-    const gradingComponent = await _getManyGradingComponents(stream2, { gradingTypeId: grading?.gradingTypeId, score });
+    const gradingComponent = await _getManyGradingComponents(stream2, {
+      gradingTypeId: grading?.gradingTypeId,
+      score
+    });
     const gradingComponentMap = gradingComponent.map((item) => ({
       ...item,
       quantitative: score[item?.code]
@@ -75,45 +80,56 @@ function usePenilaian(stream) {
   }
   async function _getOneGrading(stream2, input) {
     utils.guard(stream2, "streamRequired");
-    const result = await stream2.actions.data.getOne.execute({
-      model: "neu:penilaian:grading",
-      id: input.gradingId,
-      query: query.Query.define({
-        fields: {
-          id: 1,
-          data: 1,
-          gradingTypeId: 1,
-          student: {
-            branchIds: 1
-          },
-          branchId: 1
-        }
-      })
-    }, stream2);
+    const result = await stream2.actions.data.getOne.execute(
+      {
+        model: "neu:penilaian:grading",
+        id: input.gradingId,
+        query: query.Query.define({
+          fields: {
+            id: 1,
+            data: 1,
+            gradingTypeId: 1,
+            student: {
+              branchIds: 1
+            },
+            branchId: 1
+          }
+        })
+      },
+      stream2
+    );
     if (result.isFailure)
       throw result;
     return result.value;
   }
   async function _getManyGrading(stream2, input) {
     utils.guard(stream2, "streamRequired");
-    const result = await stream2.actions.data.getMany.execute({
-      model: "neu:penilaian:grading",
-      query: query.Query.define({
-        filter: { gradingTypeId: input.gradingTypeId, createdAt: { $gt: /* @__PURE__ */ new Date("2024-12-27T00:00:00Z") }, refreshAmount: null, data: { $exists: true } },
-        limit: constants.LIMIT_INFINITY,
-        fields: {
-          id: 1,
-          createdAt: 1,
-          data: 1,
-          gradingTypeId: 1,
-          student: {
-            branchIds: 1
+    const result = await stream2.actions.data.getMany.execute(
+      {
+        model: "neu:penilaian:grading",
+        query: query.Query.define({
+          filter: {
+            gradingTypeId: input.gradingTypeId,
+            createdAt: { $gt: /* @__PURE__ */ new Date("2024-12-27T00:00:00Z") },
+            refreshAmount: null,
+            data: { $exists: true }
           },
-          refreshAmount: 1,
-          branchId: 1
-        }
-      })
-    }, stream2);
+          limit: constants.LIMIT_INFINITY,
+          fields: {
+            id: 1,
+            createdAt: 1,
+            data: 1,
+            gradingTypeId: 1,
+            student: {
+              branchIds: 1
+            },
+            refreshAmount: 1,
+            branchId: 1
+          }
+        })
+      },
+      stream2
+    );
     if (result.isFailure)
       throw result;
     return result.value;
@@ -122,14 +138,20 @@ function usePenilaian(stream) {
     utils.guard(stream2, "streamRequired");
     const score = input.score ?? {};
     const scoreKeys = Object.keys(score);
-    const result = await stream2.actions.data.getMany.execute({
-      model: "neu:penilaian:gradingComponent",
-      query: query.Query.define({
-        filter: { code: { $in: scoreKeys }, gradingTypeId: input.gradingTypeId },
-        limit: constants.LIMIT_INFINITY,
-        fields: { id: 1, name: 1, code: 1, gradingId: 1 }
-      })
-    }, stream2);
+    const result = await stream2.actions.data.getMany.execute(
+      {
+        model: "neu:penilaian:gradingComponent",
+        query: query.Query.define({
+          filter: {
+            code: { $in: scoreKeys },
+            gradingTypeId: input.gradingTypeId
+          },
+          limit: constants.LIMIT_INFINITY,
+          fields: { id: 1, name: 1, code: 1, gradingId: 1 }
+        })
+      },
+      stream2
+    );
     if (result.isFailure)
       throw result;
     return result.value;
@@ -165,9 +187,169 @@ function usePenilaian(stream) {
       stream2
     );
   }
+  function metaBuilder(input) {
+    return {
+      limit: input.limit,
+      page: input.page,
+      total: input.items.length,
+      totalPage: Math.ceil(input.items.length / input.limit)
+    };
+  }
+  async function getManyGradingTypes(stream2, year, limit, page) {
+    const actions = stream2.actions.data;
+    const result = await actions.getMany.execute(
+      {
+        model: "neu:penilaian:gradingType",
+        query: query.Query.define({
+          filter: {
+            year
+          },
+          fields: {
+            id: 1,
+            name: 1
+          },
+          limit,
+          page
+        })
+      },
+      stream2
+    );
+    if (result.isFailure)
+      throw result;
+    return {
+      items: result.value,
+      meta: metaBuilder({
+        items: result.value,
+        limit,
+        page
+      })
+    };
+  }
+  async function getManyGradingComponent(stream2, gradingTypeId, limit, page) {
+    const actions = stream2.actions.data;
+    const result = await actions.getMany.execute(
+      {
+        model: "neu:penilaian:gradingComponent",
+        query: query.Query.define({
+          filter: {
+            gradingTypeId
+          },
+          fields: {
+            id: 1,
+            name: 1
+          },
+          limit,
+          page
+        })
+      },
+      stream2
+    );
+    if (result.isFailure)
+      throw result;
+    return {
+      items: result.value,
+      meta: metaBuilder({
+        items: result.value,
+        limit,
+        page
+      })
+    };
+  }
+  async function getManyGradingByStudent(stream2, studentId, gradingTypeId, branchId, limit, page) {
+    const actions = stream2.actions.data;
+    const result = await actions.getMany.execute(
+      {
+        model: "neu:penilaian:grading",
+        query: query.Query.define({
+          filter: {
+            studentId,
+            gradingTypeId,
+            branchId
+          },
+          fields: {
+            id: 1,
+            description: 1
+          },
+          limit,
+          page
+        })
+      },
+      stream2
+    );
+    if (result.isFailure)
+      throw result;
+    return {
+      items: result.value,
+      meta: metaBuilder({
+        items: result.value,
+        limit,
+        page
+      })
+    };
+  }
+  async function getScoresByGrading(stream2, gradingId, studentId) {
+    utils.guard(gradingId, "gradingIdRequired");
+    utils.guard(studentId, "studentIdRequired");
+    const actions = stream2.actions.data;
+    const gradingResult = await actions.getOne.execute(
+      {
+        model: "neu:penilaian:grading",
+        id: gradingId,
+        query: query.Query.define({
+          fields: {
+            id: 1,
+            studentId: 1,
+            student: {
+              id: 1,
+              name: 1
+            }
+          }
+        })
+      },
+      stream2
+    );
+    if (gradingResult.isFailure)
+      throw gradingResult;
+    const grading = gradingResult.value;
+    const scoresResult = await actions.getMany.execute(
+      {
+        model: "neu:penilaian:score",
+        query: query.Query.define({
+          filter: { gradingId },
+          limit: constants.LIMIT_INFINITY,
+          fields: {
+            id: 1,
+            gradingComponentId: 1,
+            quantitative: 1
+          }
+        })
+      },
+      stream2
+    );
+    if (scoresResult.isFailure)
+      throw scoresResult;
+    const scores = scoresResult.value;
+    const data = {};
+    for (const score of scores) {
+      if (score.gradingComponentId) {
+        data[score.gradingComponentId] = score.quantitative ?? null;
+      }
+    }
+    return [
+      {
+        studentId: grading.studentId ?? null,
+        studentName: grading.student?.name ?? null,
+        data
+      }
+    ];
+  }
   return {
     prepareGradingScore,
-    prepareManyGradingScore
+    prepareManyGradingScore,
+    getManyGradingTypes,
+    getManyGradingComponent,
+    getManyGradingByStudent,
+    getScoresByGrading
   };
 }
 

package/build/providers/penilaian/usePenilaian.d.ts

@@ -1,4 +1,11 @@
 import type { NStream } from '@neon.id/types';
+import type { Schema } from '@neutron.co.id/pendidikan-types';
+export interface TMeta {
+    limit: number;
+    page: number;
+    total: number;
+    totalPage: number;
+}
 export declare function usePenilaian(stream: NStream.Stream | undefined): {
     prepareGradingScore: (stream: NStream.Stream, input: {
         gradingId: string | undefined;
@@ -6,4 +13,21 @@ export declare function usePenilaian(stream: NStream.Stream | undefined): {
     prepareManyGradingScore: (stream: NStream.Stream, input: {
         gradingTypeId: string | undefined;
     }) => Promise<void>;
+    getManyGradingTypes: (stream: NStream.Stream, year: string, limit: number, page: number) => Promise<{
+        items: Schema.GradingType[];
+        meta: TMeta;
+    }>;
+    getManyGradingComponent: (stream: NStream.Stream, gradingTypeId: string, limit: number, page: number) => Promise<{
+        items: Schema.GradingComponent[];
+        meta: TMeta;
+    }>;
+    getManyGradingByStudent: (stream: NStream.Stream, studentId: string, gradingTypeId: string, branchId: string, limit: number, page: number) => Promise<{
+        items: Schema.Grading[];
+        meta: TMeta;
+    }>;
+    getScoresByGrading: (stream: NStream.Stream, gradingId: string, studentId: string) => Promise<Array<{
+        studentId: string | null;
+        studentName: string | null;
+        data: Record<string, number | null>;
+    }>>;
 };

package/build/providers/penilaian/usePenilaian.mjs

@@ -28,12 +28,17 @@ function usePenilaian(stream) {
     console.log("grading: ", grading);
     const parsedScores = Object.fromEntries(
       Object.entries(grading?.data?.import?.scores).map(([key, value]) => {
-        const normalizedValue = Number.parseFloat(String(value).replace(",", "."));
+        const normalizedValue = Number.parseFloat(
+          String(value).replace(",", ".")
+        );
         return [key, Number.isNaN(normalizedValue) ? null : normalizedValue];
       })
     );
     const score = parsedScores;
-    const gradingComponent = await _getManyGradingComponents(stream2, { gradingTypeId: grading?.gradingTypeId, score });
+    const gradingComponent = await _getManyGradingComponents(stream2, {
+      gradingTypeId: grading?.gradingTypeId,
+      score
+    });
     const gradingComponentMap = gradingComponent.map((item) => ({
       ...item,
       quantitative: score[item?.code]
@@ -73,45 +78,56 @@ function usePenilaian(stream) {
   }
   async function _getOneGrading(stream2, input) {
     guard(stream2, "streamRequired");
-    const result = await stream2.actions.data.getOne.execute({
-      model: "neu:penilaian:grading",
-      id: input.gradingId,
-      query: Query.define({
-        fields: {
-          id: 1,
-          data: 1,
-          gradingTypeId: 1,
-          student: {
-            branchIds: 1
-          },
-          branchId: 1
-        }
-      })
-    }, stream2);
+    const result = await stream2.actions.data.getOne.execute(
+      {
+        model: "neu:penilaian:grading",
+        id: input.gradingId,
+        query: Query.define({
+          fields: {
+            id: 1,
+            data: 1,
+            gradingTypeId: 1,
+            student: {
+              branchIds: 1
+            },
+            branchId: 1
+          }
+        })
+      },
+      stream2
+    );
     if (result.isFailure)
       throw result;
     return result.value;
   }
   async function _getManyGrading(stream2, input) {
     guard(stream2, "streamRequired");
-    const result = await stream2.actions.data.getMany.execute({
-      model: "neu:penilaian:grading",
-      query: Query.define({
-        filter: { gradingTypeId: input.gradingTypeId, createdAt: { $gt: /* @__PURE__ */ new Date("2024-12-27T00:00:00Z") }, refreshAmount: null, data: { $exists: true } },
-        limit: LIMIT_INFINITY,
-        fields: {
-          id: 1,
-          createdAt: 1,
-          data: 1,
-          gradingTypeId: 1,
-          student: {
-            branchIds: 1
+    const result = await stream2.actions.data.getMany.execute(
+      {
+        model: "neu:penilaian:grading",
+        query: Query.define({
+          filter: {
+            gradingTypeId: input.gradingTypeId,
+            createdAt: { $gt: /* @__PURE__ */ new Date("2024-12-27T00:00:00Z") },
+            refreshAmount: null,
+            data: { $exists: true }
           },
-          refreshAmount: 1,
-          branchId: 1
-        }
-      })
-    }, stream2);
+          limit: LIMIT_INFINITY,
+          fields: {
+            id: 1,
+            createdAt: 1,
+            data: 1,
+            gradingTypeId: 1,
+            student: {
+              branchIds: 1
+            },
+            refreshAmount: 1,
+            branchId: 1
+          }
+        })
+      },
+      stream2
+    );
     if (result.isFailure)
       throw result;
     return result.value;
@@ -120,14 +136,20 @@ function usePenilaian(stream) {
     guard(stream2, "streamRequired");
     const score = input.score ?? {};
     const scoreKeys = Object.keys(score);
-    const result = await stream2.actions.data.getMany.execute({
-      model: "neu:penilaian:gradingComponent",
-      query: Query.define({
-        filter: { code: { $in: scoreKeys }, gradingTypeId: input.gradingTypeId },
-        limit: LIMIT_INFINITY,
-        fields: { id: 1, name: 1, code: 1, gradingId: 1 }
-      })
-    }, stream2);
+    const result = await stream2.actions.data.getMany.execute(
+      {
+        model: "neu:penilaian:gradingComponent",
+        query: Query.define({
+          filter: {
+            code: { $in: scoreKeys },
+            gradingTypeId: input.gradingTypeId
+          },
+          limit: LIMIT_INFINITY,
+          fields: { id: 1, name: 1, code: 1, gradingId: 1 }
+        })
+      },
+      stream2
+    );
     if (result.isFailure)
       throw result;
     return result.value;
@@ -163,9 +185,169 @@ function usePenilaian(stream) {
       stream2
     );
   }
+  function metaBuilder(input) {
+    return {
+      limit: input.limit,
+      page: input.page,
+      total: input.items.length,
+      totalPage: Math.ceil(input.items.length / input.limit)
+    };
+  }
+  async function getManyGradingTypes(stream2, year, limit, page) {
+    const actions = stream2.actions.data;
+    const result = await actions.getMany.execute(
+      {
+        model: "neu:penilaian:gradingType",
+        query: Query.define({
+          filter: {
+            year
+          },
+          fields: {
+            id: 1,
+            name: 1
+          },
+          limit,
+          page
+        })
+      },
+      stream2
+    );
+    if (result.isFailure)
+      throw result;
+    return {
+      items: result.value,
+      meta: metaBuilder({
+        items: result.value,
+        limit,
+        page
+      })
+    };
+  }
+  async function getManyGradingComponent(stream2, gradingTypeId, limit, page) {
+    const actions = stream2.actions.data;
+    const result = await actions.getMany.execute(
+      {
+        model: "neu:penilaian:gradingComponent",
+        query: Query.define({
+          filter: {
+            gradingTypeId
+          },
+          fields: {
+            id: 1,
+            name: 1
+          },
+          limit,
+          page
+        })
+      },
+      stream2
+    );
+    if (result.isFailure)
+      throw result;
+    return {
+      items: result.value,
+      meta: metaBuilder({
+        items: result.value,
+        limit,
+        page
+      })
+    };
+  }
+  async function getManyGradingByStudent(stream2, studentId, gradingTypeId, branchId, limit, page) {
+    const actions = stream2.actions.data;
+    const result = await actions.getMany.execute(
+      {
+        model: "neu:penilaian:grading",
+        query: Query.define({
+          filter: {
+            studentId,
+            gradingTypeId,
+            branchId
+          },
+          fields: {
+            id: 1,
+            description: 1
+          },
+          limit,
+          page
+        })
+      },
+      stream2
+    );
+    if (result.isFailure)
+      throw result;
+    return {
+      items: result.value,
+      meta: metaBuilder({
+        items: result.value,
+        limit,
+        page
+      })
+    };
+  }
+  async function getScoresByGrading(stream2, gradingId, studentId) {
+    guard(gradingId, "gradingIdRequired");
+    guard(studentId, "studentIdRequired");
+    const actions = stream2.actions.data;
+    const gradingResult = await actions.getOne.execute(
+      {
+        model: "neu:penilaian:grading",
+        id: gradingId,
+        query: Query.define({
+          fields: {
+            id: 1,
+            studentId: 1,
+            student: {
+              id: 1,
+              name: 1
+            }
+          }
+        })
+      },
+      stream2
+    );
+    if (gradingResult.isFailure)
+      throw gradingResult;
+    const grading = gradingResult.value;
+    const scoresResult = await actions.getMany.execute(
+      {
+        model: "neu:penilaian:score",
+        query: Query.define({
+          filter: { gradingId },
+          limit: LIMIT_INFINITY,
+          fields: {
+            id: 1,
+            gradingComponentId: 1,
+            quantitative: 1
+          }
+        })
+      },
+      stream2
+    );
+    if (scoresResult.isFailure)
+      throw scoresResult;
+    const scores = scoresResult.value;
+    const data = {};
+    for (const score of scores) {
+      if (score.gradingComponentId) {
+        data[score.gradingComponentId] = score.quantitative ?? null;
+      }
+    }
+    return [
+      {
+        studentId: grading.studentId ?? null,
+        studentName: grading.student?.name ?? null,
+        data
+      }
+    ];
+  }
   return {
     prepareGradingScore,
-    prepareManyGradingScore
+    prepareManyGradingScore,
+    getManyGradingTypes,
+    getManyGradingComponent,
+    getManyGradingByStudent,
+    getScoresByGrading
   };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neutron.co.id/pendidikan-operation",
-  "version": "1.29.6",
+  "version": "1.29.8",
   "description": "Operation package of Neutron Pendidikan.",
   "license": "SEE LICENSE IN LICENSE",
   "contributors": [
@@ -42,7 +42,7 @@
     "@neutron.co.id/akademik-models": "^1.21.5",
     "@neutron.co.id/jadwal-models": "^1.19.13",
     "@neutron.co.id/pendidikan-types": "^1.24.1",
-    "@neutron.co.id/penilaian-models": "^1.19.0",
+    "@neutron.co.id/penilaian-models": "^1.19.1",
     "@neutron.co.id/personalia-models": "^1.11.6",
     "@neutron.co.id/tanya-models": "^1.13.4",
     "@sentry/node": "8.19.0",
@@ -78,7 +78,7 @@
     "@neutron.co.id/akademik-models": "^1.21.5",
     "@neutron.co.id/jadwal-models": "^1.19.13",
     "@neutron.co.id/pendidikan-types": "^1.24.1",
-    "@neutron.co.id/penilaian-models": "^1.19.0",
+    "@neutron.co.id/penilaian-models": "^1.19.1",
     "@neutron.co.id/personalia-models": "^1.11.6",
     "@neutron.co.id/tanya-models": "^1.13.4",
     "@sentry/node": "8.19.0"
@@ -86,5 +86,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "build": 162
+  "build": 164
 }