@neutron.co.id/pendidikan-operation 1.9.0 → 1.10.0

package/build/index.cjs

@@ -641,6 +641,115 @@ async function _getUserStats(stream, input) {
   return result;
 }
 
+const createGradingAndScores = operation.Action.define({
+  key: "createGradingAndScores",
+  name: "Create Penilaian dan Score",
+  type: "command",
+  category: "domain",
+  execute: async ({ gradingTypeId, studentId, gradingInsertId }, stream) => {
+    if (!gradingTypeId || !studentId || !gradingInsertId) {
+      throw core.Result.fail({
+        state: "invalidInput",
+        message: "Invalid input.",
+        data: {}
+      });
+    }
+    console.time("\u23F1\uFE0F createGrading");
+    const grading = await _createGrading(stream, { gradingTypeId, studentId });
+    console.timeEnd("\u23F1\uFE0F createGrading");
+    console.time("\u23F1\uFE0F getGradingComponents");
+    const gradingComponents = await _getGradingComponents$1(stream, gradingTypeId);
+    console.timeEnd("\u23F1\uFE0F getGradingComponents");
+    console.time("\u23F1\uFE0F generateScores");
+    await _generateScores(stream, grading, gradingComponents);
+    console.timeEnd("\u23F1\uFE0F generateScores");
+    console.time("\u23F1\uFE0F updateGradingInsert");
+    await _updateGradingInsert(stream, {
+      gradingInsertId,
+      gradingId: grading.id
+    });
+    console.timeEnd("\u23F1\uFE0F updateGradingInsert");
+    return core.Result.ok({
+      state: "allGradingAndScoresCreated",
+      message: "All Penilaian Score have been synced.",
+      data: {
+        gradingId: grading.id
+      }
+    });
+  }
+});
+async function _createGrading(stream, input) {
+  const result = await stream.actions.data.createOne.execute(
+    {
+      model: "neu:penilaian:grading",
+      data: {
+        gradingTypeId: input.gradingTypeId,
+        studentId: input.studentId,
+        reportedAt: /* @__PURE__ */ new Date()
+      },
+      query: query.Query.define({ fields: { id: 1 } })
+    },
+    stream
+  );
+  if (result.isFailure)
+    throw result;
+  return result.value;
+}
+async function _getGradingComponents$1(stream, gradingTypeId) {
+  const result = await stream.actions.data.getMany.execute(
+    {
+      model: "neu:penilaian:gradingComponent",
+      query: query.Query.define({
+        filter: { gradingTypeId },
+        fields: { id: 1, gradingTypeId: 1, subjectId: 1 },
+        limit: 200
+      })
+    },
+    stream
+  );
+  if (result.isFailure)
+    throw result;
+  return result.value;
+}
+async function _generateScores(stream, grading, gradingComponents) {
+  const operations = [];
+  for (const component of gradingComponents) {
+    operations.push({
+      insertOne: {
+        document: {
+          gradingId: grading.id,
+          gradingComponentId: component.id
+        }
+      }
+    });
+  }
+  await stream.core.dbs["neu-penilaian"].models["neu:penilaian:score"].bulkWrite(operations);
+  await stream.actions.data.syncMany.execute(
+    {
+      model: "neo:penilaian:score",
+      useDry: false,
+      query: query.Query.define({
+        filter: { gradingId: grading.id },
+        limit: 1e4
+      })
+    },
+    stream
+  );
+}
+async function _updateGradingInsert(stream, input) {
+  await stream.actions.data.updateOne.execute(
+    {
+      model: "neu:penilaian:gradingInsert",
+      id: input.gradingInsertId,
+      data: {
+        gradingId: input.gradingId
+      },
+      query: query.Query.define({})
+    },
+    stream
+  );
+}
+
 const generateGrading = operation.Action.define({
   key: "generateGrading",
   name: "Create Penilaian dan Score",
@@ -793,13 +902,115 @@ async function syncModel(stream, model, filter) {
   console.timeEnd(`\u23F1\uFE0F syncModel:${model}`);
 }
 
+const updateGradingAndScores = operation.Action.define({
+  key: "updateGradingAndScores",
+  name: "Update Penilaian dan Score",
+  type: "command",
+  category: "domain",
+  execute: async ({ gradingInsertId, gradingTypeId, gradingId, studentId, data }, stream) => {
+    console.time("\u23F1\uFE0F updateGrading");
+    await _updateGrading(stream, { gradingId, studentId });
+    console.timeEnd("\u23F1\uFE0F updateGrading");
+    console.time("\u23F1\uFE0F getGradingComponents");
+    const gradingComponents = await _getGradingComponents(stream, gradingTypeId);
+    console.timeEnd("\u23F1\uFE0F getGradingComponents");
+    console.time("\u23F1\uFE0F updateScores");
+    await _updateScores(stream, gradingId, gradingComponents, data);
+    console.timeEnd("\u23F1\uFE0F updateScores");
+    console.time(`\u23F1\uFE0F syncModel:gradingRasionalization`);
+    await stream.actions.data.syncMany.execute(
+      {
+        model: "neu:penilaian:gradingRasionalization",
+        useDry: false,
+        query: query.Query.define({
+          filter: {
+            gradingInsertId
+          },
+          limit: 1e5
+        })
+      },
+      stream
+    );
+    console.timeEnd(`\u23F1\uFE0F syncModel:gradingRasionalization`);
+    return core.Result.ok({
+      state: "allUpdated",
+      message: "All Penilaian have been updated.",
+      data: {}
+    });
+  }
+});
+async function _updateGrading(stream, input) {
+  await stream.actions.data.updateOne.execute(
+    {
+      model: "neu:penilaian:grading",
+      id: input.gradingId,
+      data: {
+        studentId: input.studentId
+      },
+      query: query.Query.define({})
+    },
+    stream
+  );
+}
+async function _getGradingComponents(stream, gradingTypeId) {
+  const result = await stream.actions.data.getMany.execute(
+    {
+      model: "neu:penilaian:gradingComponent",
+      query: query.Query.define({
+        filter: { gradingTypeId },
+        fields: { id: 1, code: 1 },
+        limit: 200
+      })
+    },
+    stream
+  );
+  if (result.isFailure)
+    throw result;
+  return result.value;
+}
+async function _updateScores(stream, gradingId, gradingComponents, data) {
+  const operations = [];
+  for (const component of gradingComponents) {
+    operations.push({
+      updateOne: {
+        filter: {
+          gradingId,
+          gradingComponentId: component.id
+        },
+        update: {
+          quantitative: data[component.code] || 0
+        }
+      }
+    });
+  }
+  await stream.core.dbs["neu-penilaian"].models["neu:penilaian:score"].bulkWrite(operations);
+  await stream.actions.data.syncMany.execute(
+    {
+      model: "neo:penilaian:score",
+      useDry: false,
+      query: query.Query.define({
+        filter: { gradingId },
+        limit: 1e4
+      })
+    },
+    stream
+  );
+}
+
 const calculateGrading = operation.Action.define({
   key: "calculateGrading",
   name: "Create Penilaian dan Score",
   type: "command",
   category: "domain",
-  execute: async ({ gradingInsertId, gradingContextIds, sourceSchoolId, gradingId }, stream) => {
-    await _destroyMany(stream, { gradingId, gradingInsertId });
+  execute: async ({
+    gradingInsertId,
+    gradingContextIds,
+    sourceSchoolId,
+    gradingId,
+    gradingTypeId,
+    studentId,
+    data
+  }, stream) => {
     const cached = {
       gradingContextIds,
       sourceSchoolId
@@ -809,12 +1020,51 @@ const calculateGrading = operation.Action.define({
       {
         model: "neu:penilaian:gradingInsert",
         id: gradingInsertId,
-        data: { cached },
+        data: { cached, gradingTypeId: "63ce5979e1166b8bb4bbc220" },
         query: query.Query.define({})
       },
       stream
     );
     console.timeEnd("\u23F1\uFE0F updateGradingInsertCachedData");
+    console.log("ini Grading e", gradingId);
+    console.time("\u23F1\uFE0F generateEmptyGradingScore");
+    let result;
+    if (gradingId === null) {
+      result = await createGradingAndScores.execute(
+        {
+          gradingTypeId,
+          studentId,
+          gradingInsertId
+        },
+        stream
+      );
+      console.log("ini hasil", result);
+      await updateGradingAndScores.execute(
+        {
+          gradingInsertId,
+          gradingTypeId,
+          gradingId: result.payload.data.gradingId,
+          studentId,
+          data
+        },
+        stream
+      );
+    }
+    console.timeEnd("\u23F1\uFE0F generateEmptyGradingScore");
+    await _destroyMany(stream, {
+      gradingId: gradingId || result.payload.data.gradingId,
+      gradingInsertId
+    });
+    await updateGradingAndScores.execute(
+      {
+        gradingInsertId,
+        gradingTypeId,
+        gradingId: gradingId || result.payload.data.gradingId,
+        studentId,
+        data
+      },
+      stream
+    );
     console.time("\u23F1\uFE0F generateGrading");
     await generateGrading.execute({ gradingInsertId }, stream);
     console.timeEnd("\u23F1\uFE0F generateGrading");
@@ -1164,208 +1414,6 @@ async function _clearOneOverrides(stream, gradingComparatorId) {
   );
 }
 
-const createGradingAndScores = operation.Action.define({
-  key: "createGradingAndScores",
-  name: "Create Penilaian dan Score",
-  type: "command",
-  category: "domain",
-  execute: async ({ gradingTypeId, studentId, gradingInsertId }, stream) => {
-    if (!gradingTypeId || !studentId || !gradingInsertId) {
-      throw core.Result.fail({
-        state: "invalidInput",
-        message: "Invalid input.",
-        data: {}
-      });
-    }
-    console.time("\u23F1\uFE0F createGrading");
-    const grading = await _createGrading(stream, { gradingTypeId, studentId });
-    console.timeEnd("\u23F1\uFE0F createGrading");
-    console.time("\u23F1\uFE0F getGradingComponents");
-    const gradingComponents = await _getGradingComponents$1(stream, gradingTypeId);
-    console.timeEnd("\u23F1\uFE0F getGradingComponents");
-    console.time("\u23F1\uFE0F generateScores");
-    await _generateScores(stream, grading, gradingComponents);
-    console.timeEnd("\u23F1\uFE0F generateScores");
-    console.time("\u23F1\uFE0F updateGradingInsert");
-    await _updateGradingInsert(stream, {
-      gradingInsertId,
-      gradingId: grading.id
-    });
-    console.timeEnd("\u23F1\uFE0F updateGradingInsert");
-    return core.Result.ok({
-      state: "allGradingAndScoresCreated",
-      message: "All Penilaian Score have been synced.",
-      data: {}
-    });
-  }
-});
-async function _createGrading(stream, input) {
-  const result = await stream.actions.data.createOne.execute(
-    {
-      model: "neu:penilaian:grading",
-      data: {
-        gradingTypeId: input.gradingTypeId,
-        studentId: input.studentId,
-        reportedAt: /* @__PURE__ */ new Date()
-      },
-      query: query.Query.define({ fields: { id: 1 } })
-    },
-    stream
-  );
-  if (result.isFailure)
-    throw result;
-  return result.value;
-}
-async function _getGradingComponents$1(stream, gradingTypeId) {
-  const result = await stream.actions.data.getMany.execute(
-    {
-      model: "neu:penilaian:gradingComponent",
-      query: query.Query.define({
-        filter: { gradingTypeId },
-        fields: { id: 1, gradingTypeId: 1, subjectId: 1 },
-        limit: 200
-      })
-    },
-    stream
-  );
-  if (result.isFailure)
-    throw result;
-  return result.value;
-}
-async function _generateScores(stream, grading, gradingComponents) {
-  const operations = [];
-  for (const component of gradingComponents) {
-    operations.push({
-      insertOne: {
-        document: {
-          gradingId: grading.id,
-          gradingComponentId: component.id
-        }
-      }
-    });
-  }
-  await stream.core.dbs["neu-penilaian"].models["neu:penilaian:score"].bulkWrite(operations);
-  await stream.actions.data.syncMany.execute(
-    {
-      model: "neo:penilaian:score",
-      useDry: false,
-      query: query.Query.define({
-        filter: { gradingId: grading.id },
-        limit: 1e4
-      })
-    },
-    stream
-  );
-}
-async function _updateGradingInsert(stream, input) {
-  await stream.actions.data.updateOne.execute(
-    {
-      model: "neu:penilaian:gradingInsert",
-      id: input.gradingInsertId,
-      data: {
-        gradingId: input.gradingId
-      },
-      query: query.Query.define({})
-    },
-    stream
-  );
-}
-
-const updateGradingAndScores = operation.Action.define({
-  key: "updateGradingAndScores",
-  name: "Update Penilaian dan Score",
-  type: "command",
-  category: "domain",
-  execute: async ({ gradingInsertId, gradingTypeId, gradingId, studentId, data }, stream) => {
-    console.time("\u23F1\uFE0F updateGrading");
-    await _updateGrading(stream, { gradingId, studentId });
-    console.timeEnd("\u23F1\uFE0F updateGrading");
-    console.time("\u23F1\uFE0F getGradingComponents");
-    const gradingComponents = await _getGradingComponents(stream, gradingTypeId);
-    console.timeEnd("\u23F1\uFE0F getGradingComponents");
-    console.time("\u23F1\uFE0F updateScores");
-    await _updateScores(stream, gradingId, gradingComponents, data);
-    console.timeEnd("\u23F1\uFE0F updateScores");
-    console.time(`\u23F1\uFE0F syncModel:gradingRasionalization`);
-    await stream.actions.data.syncMany.execute(
-      {
-        model: "neu:penilaian:gradingRasionalization",
-        useDry: false,
-        query: query.Query.define({
-          filter: {
-            gradingInsertId
-          },
-          limit: 1e5
-        })
-      },
-      stream
-    );
-    console.timeEnd(`\u23F1\uFE0F syncModel:gradingRasionalization`);
-    return core.Result.ok({
-      state: "allUpdated",
-      message: "All Penilaian have been updated.",
-      data: {}
-    });
-  }
-});
-async function _updateGrading(stream, input) {
-  await stream.actions.data.updateOne.execute(
-    {
-      model: "neu:penilaian:grading",
-      id: input.gradingId,
-      data: {
-        studentId: input.studentId
-      },
-      query: query.Query.define({})
-    },
-    stream
-  );
-}
-async function _getGradingComponents(stream, gradingTypeId) {
-  const result = await stream.actions.data.getMany.execute(
-    {
-      model: "neu:penilaian:gradingComponent",
-      query: query.Query.define({
-        filter: { gradingTypeId },
-        fields: { id: 1, code: 1 },
-        limit: 200
-      })
-    },
-    stream
-  );
-  if (result.isFailure)
-    throw result;
-  return result.value;
-}
-async function _updateScores(stream, gradingId, gradingComponents, data) {
-  const operations = [];
-  for (const component of gradingComponents) {
-    operations.push({
-      updateOne: {
-        filter: {
-          gradingId,
-          gradingComponentId: component.id
-        },
-        update: {
-          quantitative: data[component.code] || 0
-        }
-      }
-    });
-  }
-  await stream.core.dbs["neu-penilaian"].models["neu:penilaian:score"].bulkWrite(operations);
-  await stream.actions.data.syncMany.execute(
-    {
-      model: "neo:penilaian:score",
-      useDry: false,
-      query: query.Query.define({
-        filter: { gradingId },
-        limit: 1e4
-      })
-    },
-    stream
-  );
-}
-
 const addManyGradingComponent = operation.Action.define({
   key: "addManyGradingComponent",
   name: "Add Many Grading Component",

package/build/index.d.ts

@@ -156,6 +156,9 @@ interface CalculateGradingInput {
     gradingContextIds: string[];
     sourceSchoolId: string;
     gradingId: string;
+    gradingTypeId: string;
+    studentId: string;
+    data: any;
 }
 interface CalculateGradingOutput {
 }
@@ -237,6 +240,7 @@ interface CreateGradingAndScoresInput {
     gradingInsertId: string;
 }
 interface CreateGradingAndScoresOutput {
+    gradingId: string;
 }
 interface CreateGradingAndScoresMeta {
 }

package/build/index.mjs

@@ -635,6 +635,115 @@ async function _getUserStats(stream, input) {
   return result;
 }
 
+const createGradingAndScores = Action.define({
+  key: "createGradingAndScores",
+  name: "Create Penilaian dan Score",
+  type: "command",
+  category: "domain",
+  execute: async ({ gradingTypeId, studentId, gradingInsertId }, stream) => {
+    if (!gradingTypeId || !studentId || !gradingInsertId) {
+      throw Result.fail({
+        state: "invalidInput",
+        message: "Invalid input.",
+        data: {}
+      });
+    }
+    console.time("\u23F1\uFE0F createGrading");
+    const grading = await _createGrading(stream, { gradingTypeId, studentId });
+    console.timeEnd("\u23F1\uFE0F createGrading");
+    console.time("\u23F1\uFE0F getGradingComponents");
+    const gradingComponents = await _getGradingComponents$1(stream, gradingTypeId);
+    console.timeEnd("\u23F1\uFE0F getGradingComponents");
+    console.time("\u23F1\uFE0F generateScores");
+    await _generateScores(stream, grading, gradingComponents);
+    console.timeEnd("\u23F1\uFE0F generateScores");
+    console.time("\u23F1\uFE0F updateGradingInsert");
+    await _updateGradingInsert(stream, {
+      gradingInsertId,
+      gradingId: grading.id
+    });
+    console.timeEnd("\u23F1\uFE0F updateGradingInsert");
+    return Result.ok({
+      state: "allGradingAndScoresCreated",
+      message: "All Penilaian Score have been synced.",
+      data: {
+        gradingId: grading.id
+      }
+    });
+  }
+});
+async function _createGrading(stream, input) {
+  const result = await stream.actions.data.createOne.execute(
+    {
+      model: "neu:penilaian:grading",
+      data: {
+        gradingTypeId: input.gradingTypeId,
+        studentId: input.studentId,
+        reportedAt: /* @__PURE__ */ new Date()
+      },
+      query: Query.define({ fields: { id: 1 } })
+    },
+    stream
+  );
+  if (result.isFailure)
+    throw result;
+  return result.value;
+}
+async function _getGradingComponents$1(stream, gradingTypeId) {
+  const result = await stream.actions.data.getMany.execute(
+    {
+      model: "neu:penilaian:gradingComponent",
+      query: Query.define({
+        filter: { gradingTypeId },
+        fields: { id: 1, gradingTypeId: 1, subjectId: 1 },
+        limit: 200
+      })
+    },
+    stream
+  );
+  if (result.isFailure)
+    throw result;
+  return result.value;
+}
+async function _generateScores(stream, grading, gradingComponents) {
+  const operations = [];
+  for (const component of gradingComponents) {
+    operations.push({
+      insertOne: {
+        document: {
+          gradingId: grading.id,
+          gradingComponentId: component.id
+        }
+      }
+    });
+  }
+  await stream.core.dbs["neu-penilaian"].models["neu:penilaian:score"].bulkWrite(operations);
+  await stream.actions.data.syncMany.execute(
+    {
+      model: "neo:penilaian:score",
+      useDry: false,
+      query: Query.define({
+        filter: { gradingId: grading.id },
+        limit: 1e4
+      })
+    },
+    stream
+  );
+}
+async function _updateGradingInsert(stream, input) {
+  await stream.actions.data.updateOne.execute(
+    {
+      model: "neu:penilaian:gradingInsert",
+      id: input.gradingInsertId,
+      data: {
+        gradingId: input.gradingId
+      },
+      query: Query.define({})
+    },
+    stream
+  );
+}
+
 const generateGrading = Action.define({
   key: "generateGrading",
   name: "Create Penilaian dan Score",
@@ -787,13 +896,115 @@ async function syncModel(stream, model, filter) {
   console.timeEnd(`\u23F1\uFE0F syncModel:${model}`);
 }
 
+const updateGradingAndScores = Action.define({
+  key: "updateGradingAndScores",
+  name: "Update Penilaian dan Score",
+  type: "command",
+  category: "domain",
+  execute: async ({ gradingInsertId, gradingTypeId, gradingId, studentId, data }, stream) => {
+    console.time("\u23F1\uFE0F updateGrading");
+    await _updateGrading(stream, { gradingId, studentId });
+    console.timeEnd("\u23F1\uFE0F updateGrading");
+    console.time("\u23F1\uFE0F getGradingComponents");
+    const gradingComponents = await _getGradingComponents(stream, gradingTypeId);
+    console.timeEnd("\u23F1\uFE0F getGradingComponents");
+    console.time("\u23F1\uFE0F updateScores");
+    await _updateScores(stream, gradingId, gradingComponents, data);
+    console.timeEnd("\u23F1\uFE0F updateScores");
+    console.time(`\u23F1\uFE0F syncModel:gradingRasionalization`);
+    await stream.actions.data.syncMany.execute(
+      {
+        model: "neu:penilaian:gradingRasionalization",
+        useDry: false,
+        query: Query.define({
+          filter: {
+            gradingInsertId
+          },
+          limit: 1e5
+        })
+      },
+      stream
+    );
+    console.timeEnd(`\u23F1\uFE0F syncModel:gradingRasionalization`);
+    return Result.ok({
+      state: "allUpdated",
+      message: "All Penilaian have been updated.",
+      data: {}
+    });
+  }
+});
+async function _updateGrading(stream, input) {
+  await stream.actions.data.updateOne.execute(
+    {
+      model: "neu:penilaian:grading",
+      id: input.gradingId,
+      data: {
+        studentId: input.studentId
+      },
+      query: Query.define({})
+    },
+    stream
+  );
+}
+async function _getGradingComponents(stream, gradingTypeId) {
+  const result = await stream.actions.data.getMany.execute(
+    {
+      model: "neu:penilaian:gradingComponent",
+      query: Query.define({
+        filter: { gradingTypeId },
+        fields: { id: 1, code: 1 },
+        limit: 200
+      })
+    },
+    stream
+  );
+  if (result.isFailure)
+    throw result;
+  return result.value;
+}
+async function _updateScores(stream, gradingId, gradingComponents, data) {
+  const operations = [];
+  for (const component of gradingComponents) {
+    operations.push({
+      updateOne: {
+        filter: {
+          gradingId,
+          gradingComponentId: component.id
+        },
+        update: {
+          quantitative: data[component.code] || 0
+        }
+      }
+    });
+  }
+  await stream.core.dbs["neu-penilaian"].models["neu:penilaian:score"].bulkWrite(operations);
+  await stream.actions.data.syncMany.execute(
+    {
+      model: "neo:penilaian:score",
+      useDry: false,
+      query: Query.define({
+        filter: { gradingId },
+        limit: 1e4
+      })
+    },
+    stream
+  );
+}
+
 const calculateGrading = Action.define({
   key: "calculateGrading",
   name: "Create Penilaian dan Score",
   type: "command",
   category: "domain",
-  execute: async ({ gradingInsertId, gradingContextIds, sourceSchoolId, gradingId }, stream) => {
-    await _destroyMany(stream, { gradingId, gradingInsertId });
+  execute: async ({
+    gradingInsertId,
+    gradingContextIds,
+    sourceSchoolId,
+    gradingId,
+    gradingTypeId,
+    studentId,
+    data
+  }, stream) => {
     const cached = {
       gradingContextIds,
       sourceSchoolId
@@ -803,12 +1014,51 @@ const calculateGrading = Action.define({
       {
         model: "neu:penilaian:gradingInsert",
         id: gradingInsertId,
-        data: { cached },
+        data: { cached, gradingTypeId: "63ce5979e1166b8bb4bbc220" },
         query: Query.define({})
       },
       stream
     );
     console.timeEnd("\u23F1\uFE0F updateGradingInsertCachedData");
+    console.log("ini Grading e", gradingId);
+    console.time("\u23F1\uFE0F generateEmptyGradingScore");
+    let result;
+    if (gradingId === null) {
+      result = await createGradingAndScores.execute(
+        {
+          gradingTypeId,
+          studentId,
+          gradingInsertId
+        },
+        stream
+      );
+      console.log("ini hasil", result);
+      await updateGradingAndScores.execute(
+        {
+          gradingInsertId,
+          gradingTypeId,
+          gradingId: result.payload.data.gradingId,
+          studentId,
+          data
+        },
+        stream
+      );
+    }
+    console.timeEnd("\u23F1\uFE0F generateEmptyGradingScore");
+    await _destroyMany(stream, {
+      gradingId: gradingId || result.payload.data.gradingId,
+      gradingInsertId
+    });
+    await updateGradingAndScores.execute(
+      {
+        gradingInsertId,
+        gradingTypeId,
+        gradingId: gradingId || result.payload.data.gradingId,
+        studentId,
+        data
+      },
+      stream
+    );
     console.time("\u23F1\uFE0F generateGrading");
     await generateGrading.execute({ gradingInsertId }, stream);
     console.timeEnd("\u23F1\uFE0F generateGrading");
@@ -1158,208 +1408,6 @@ async function _clearOneOverrides(stream, gradingComparatorId) {
   );
 }
 
-const createGradingAndScores = Action.define({
-  key: "createGradingAndScores",
-  name: "Create Penilaian dan Score",
-  type: "command",
-  category: "domain",
-  execute: async ({ gradingTypeId, studentId, gradingInsertId }, stream) => {
-    if (!gradingTypeId || !studentId || !gradingInsertId) {
-      throw Result.fail({
-        state: "invalidInput",
-        message: "Invalid input.",
-        data: {}
-      });
-    }
-    console.time("\u23F1\uFE0F createGrading");
-    const grading = await _createGrading(stream, { gradingTypeId, studentId });
-    console.timeEnd("\u23F1\uFE0F createGrading");
-    console.time("\u23F1\uFE0F getGradingComponents");
-    const gradingComponents = await _getGradingComponents$1(stream, gradingTypeId);
-    console.timeEnd("\u23F1\uFE0F getGradingComponents");
-    console.time("\u23F1\uFE0F generateScores");
-    await _generateScores(stream, grading, gradingComponents);
-    console.timeEnd("\u23F1\uFE0F generateScores");
-    console.time("\u23F1\uFE0F updateGradingInsert");
-    await _updateGradingInsert(stream, {
-      gradingInsertId,
-      gradingId: grading.id
-    });
-    console.timeEnd("\u23F1\uFE0F updateGradingInsert");
-    return Result.ok({
-      state: "allGradingAndScoresCreated",
-      message: "All Penilaian Score have been synced.",
-      data: {}
-    });
-  }
-});
-async function _createGrading(stream, input) {
-  const result = await stream.actions.data.createOne.execute(
-    {
-      model: "neu:penilaian:grading",
-      data: {
-        gradingTypeId: input.gradingTypeId,
-        studentId: input.studentId,
-        reportedAt: /* @__PURE__ */ new Date()
-      },
-      query: Query.define({ fields: { id: 1 } })
-    },
-    stream
-  );
-  if (result.isFailure)
-    throw result;
-  return result.value;
-}
-async function _getGradingComponents$1(stream, gradingTypeId) {
-  const result = await stream.actions.data.getMany.execute(
-    {
-      model: "neu:penilaian:gradingComponent",
-      query: Query.define({
-        filter: { gradingTypeId },
-        fields: { id: 1, gradingTypeId: 1, subjectId: 1 },
-        limit: 200
-      })
-    },
-    stream
-  );
-  if (result.isFailure)
-    throw result;
-  return result.value;
-}
-async function _generateScores(stream, grading, gradingComponents) {
-  const operations = [];
-  for (const component of gradingComponents) {
-    operations.push({
-      insertOne: {
-        document: {
-          gradingId: grading.id,
-          gradingComponentId: component.id
-        }
-      }
-    });
-  }
-  await stream.core.dbs["neu-penilaian"].models["neu:penilaian:score"].bulkWrite(operations);
-  await stream.actions.data.syncMany.execute(
-    {
-      model: "neo:penilaian:score",
-      useDry: false,
-      query: Query.define({
-        filter: { gradingId: grading.id },
-        limit: 1e4
-      })
-    },
-    stream
-  );
-}
-async function _updateGradingInsert(stream, input) {
-  await stream.actions.data.updateOne.execute(
-    {
-      model: "neu:penilaian:gradingInsert",
-      id: input.gradingInsertId,
-      data: {
-        gradingId: input.gradingId
-      },
-      query: Query.define({})
-    },
-    stream
-  );
-}
-
-const updateGradingAndScores = Action.define({
-  key: "updateGradingAndScores",
-  name: "Update Penilaian dan Score",
-  type: "command",
-  category: "domain",
-  execute: async ({ gradingInsertId, gradingTypeId, gradingId, studentId, data }, stream) => {
-    console.time("\u23F1\uFE0F updateGrading");
-    await _updateGrading(stream, { gradingId, studentId });
-    console.timeEnd("\u23F1\uFE0F updateGrading");
-    console.time("\u23F1\uFE0F getGradingComponents");
-    const gradingComponents = await _getGradingComponents(stream, gradingTypeId);
-    console.timeEnd("\u23F1\uFE0F getGradingComponents");
-    console.time("\u23F1\uFE0F updateScores");
-    await _updateScores(stream, gradingId, gradingComponents, data);
-    console.timeEnd("\u23F1\uFE0F updateScores");
-    console.time(`\u23F1\uFE0F syncModel:gradingRasionalization`);
-    await stream.actions.data.syncMany.execute(
-      {
-        model: "neu:penilaian:gradingRasionalization",
-        useDry: false,
-        query: Query.define({
-          filter: {
-            gradingInsertId
-          },
-          limit: 1e5
-        })
-      },
-      stream
-    );
-    console.timeEnd(`\u23F1\uFE0F syncModel:gradingRasionalization`);
-    return Result.ok({
-      state: "allUpdated",
-      message: "All Penilaian have been updated.",
-      data: {}
-    });
-  }
-});
-async function _updateGrading(stream, input) {
-  await stream.actions.data.updateOne.execute(
-    {
-      model: "neu:penilaian:grading",
-      id: input.gradingId,
-      data: {
-        studentId: input.studentId
-      },
-      query: Query.define({})
-    },
-    stream
-  );
-}
-async function _getGradingComponents(stream, gradingTypeId) {
-  const result = await stream.actions.data.getMany.execute(
-    {
-      model: "neu:penilaian:gradingComponent",
-      query: Query.define({
-        filter: { gradingTypeId },
-        fields: { id: 1, code: 1 },
-        limit: 200
-      })
-    },
-    stream
-  );
-  if (result.isFailure)
-    throw result;
-  return result.value;
-}
-async function _updateScores(stream, gradingId, gradingComponents, data) {
-  const operations = [];
-  for (const component of gradingComponents) {
-    operations.push({
-      updateOne: {
-        filter: {
-          gradingId,
-          gradingComponentId: component.id
-        },
-        update: {
-          quantitative: data[component.code] || 0
-        }
-      }
-    });
-  }
-  await stream.core.dbs["neu-penilaian"].models["neu:penilaian:score"].bulkWrite(operations);
-  await stream.actions.data.syncMany.execute(
-    {
-      model: "neo:penilaian:score",
-      useDry: false,
-      query: Query.define({
-        filter: { gradingId },
-        limit: 1e4
-      })
-    },
-    stream
-  );
-}
-
 const addManyGradingComponent = Action.define({
   key: "addManyGradingComponent",
   name: "Add Many Grading Component",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neutron.co.id/pendidikan-operation",
-  "version": "1.9.0",
+  "version": "1.10.0",
   "description": "Operation package of Neutron Pendidikan.",
   "license": "SEE LICENSE IN LICENSE",
   "contributors": [
@@ -30,42 +30,42 @@
   "dependencies": {
     "@bluelibs/nova": "1.4.2",
     "@neon.id/core": "^1.32.0",
-    "@neon.id/gerbang-js": "^1.4.0",
+    "@neon.id/gerbang-js": "^1.5.0",
     "@neon.id/model": "^0.66.0",
     "@neon.id/operation": "^0.46.0",
     "@neon.id/permit": "^0.21.0",
-    "@neon.id/query": "^0.49.0",
+    "@neon.id/query": "^0.50.0",
     "@neon.id/types": "^1.45.0",
     "@neon.id/utils": "^0.44.0",
     "@neutron.co.id/akademik-models": "^1.5.1",
     "@neutron.co.id/jadwal-models": "^1.5.0",
     "@neutron.co.id/penilaian-models": "^1.9.3",
-    "@neutron.co.id/personalia-models": "^1.6.2",
+    "@neutron.co.id/personalia-models": "^1.7.1",
     "@neutron.co.id/tanya-models": "^1.4.1",
-    "dayjs": "^1.11.7",
-    "mongoose": "^6.11.1",
+    "dayjs": "^1.11.8",
+    "mongoose": "^6.11.2",
     "nanoid": "^4.0.2",
-    "ofetch": "^1.0.1"
+    "ofetch": "^1.1.1"
   },
   "devDependencies": {
-    "@types/node": "20.2.5",
-    "@vitest/coverage-c8": "0.31.1",
-    "@vitest/ui": "0.31.1",
+    "@types/node": "20.3.1",
+    "@vitest/coverage-c8": "0.32.2",
+    "@vitest/ui": "0.32.2",
     "@vortex.so/eslint-plugin": "0.7.0",
     "tsx": "3.12.7",
-    "typescript": "5.0.4",
+    "typescript": "5.1.3",
     "unbuild": "1.2.1",
     "vite": "4.3.9",
-    "vitest": "0.31.1"
+    "vitest": "0.32.2"
   },
   "peerDependencies": {
     "@bluelibs/nova": "1.4.2",
     "@neon.id/core": "^1.32.0",
-    "@neon.id/gerbang-js": "^1.4.0",
+    "@neon.id/gerbang-js": "^1.5.0",
     "@neon.id/model": "^0.66.0",
     "@neon.id/operation": "^0.46.0",
     "@neon.id/permit": "^0.21.0",
-    "@neon.id/query": "^0.49.0",
+    "@neon.id/query": "^0.50.0",
     "@neon.id/types": "^1.45.0",
     "@neon.id/utils": "^0.44.0",
     "@neutron.co.id/akademik-models": "^1.5.1",
@@ -73,13 +73,13 @@
     "@neutron.co.id/penilaian-models": "^1.9.3",
     "@neutron.co.id/personalia-models": "^1.6.2",
     "@neutron.co.id/tanya-models": "^1.4.1",
-    "dayjs": "^1.11.7",
-    "mongoose": "^6.11.1",
+    "dayjs": "^1.11.8",
+    "mongoose": "^6.11.2",
     "nanoid": "^4.0.2",
-    "ofetch": "^1.0.1"
+    "ofetch": "^1.1.1"
   },
   "publishConfig": {
     "access": "public"
   },
-  "build": 47
+  "build": 49
 }