@neutron.co.id/pendidikan-operation 1.3.0 → 1.4.0-beta.1

package/build/index.cjs

@@ -3,6 +3,7 @@
 const core = require('@neon.id/core');
 const operation = require('@neon.id/operation');
 const query = require('@neon.id/query');
+const value = require('@neon.id/utils/value');
 const nanoid = require('nanoid');
 
 const setSomething = operation.Action.define({
@@ -136,34 +137,6 @@ const syncCommitment = operation.Action.define({
   }
 });
 
-const calculateManyComparator = operation.Action.define({
-  key: "calculateManyComparator",
-  name: "Create Penilaian dan Score",
-  type: "command",
-  category: "domain",
-  execute: async ({ gradingComparatorId }, stream) => {
-    console.log("id", gradingComparatorId);
-    console.time("\u23F1\uFE0F syncGradingComparator");
-    const result = await stream.actions.data.syncMany.execute(
-      {
-        model: "neu:penilaian:gradingComparator",
-        useDry: false,
-        query: query.Query.define({
-          limit: 1e5
-        })
-      },
-      stream
-    );
-    console.log(result);
-    console.timeEnd("\u23F1\uFE0F syncGradingComparator");
-    return core.Result.ok({
-      state: "ComparatorCalculated",
-      message: "Camparator have been calculated.",
-      data: {}
-    });
-  }
-});
-
 const generateGrading = operation.Action.define({
   key: "generateGrading",
   name: "Create Penilaian dan Score",
@@ -366,6 +339,240 @@ async function _destroyMany(stream, input) {
   console.timeEnd("\u23F1\uFE0F destroyManyGradingComparisonItem");
 }
 
+class NumberUtil {
+  static transformDecimal(value) {
+    if (!value)
+      return 0;
+    const string = value.toString();
+    const float = parseFloat(string);
+    return float || 0;
+  }
+  static twoDecimal(value) {
+    return Math.round(value * 100) / 100;
+  }
+}
+
+const calculateManyComparator = operation.Action.define({
+  key: "calculateManyComparator",
+  name: "Create Penilaian dan Score",
+  type: "command",
+  category: "domain",
+  execute: async (_, stream) => {
+    console.time("\u23F1\uFE0F getManyComparators");
+    const comparators = await _getManyComparators(stream);
+    console.timeEnd("\u23F1\uFE0F getManyComparators");
+    console.time("\u23F1\uFE0F updateManyComparators");
+    await _updateManyComparators(stream, comparators);
+    console.timeEnd("\u23F1\uFE0F updateManyComparators");
+    console.time("\u23F1\uFE0F syncGradingComparator");
+    const result = await stream.actions.data.syncMany.execute(
+      {
+        model: "neu:penilaian:gradingComparator",
+        useDry: false,
+        query: query.Query.define({
+          limit: 1e5
+        })
+      },
+      stream
+    );
+    console.log(result);
+    console.timeEnd("\u23F1\uFE0F syncGradingComparator");
+    return core.Result.ok({
+      state: "ComparatorCalculated",
+      message: "Camparator have been calculated.",
+      data: {}
+    });
+  }
+});
+async function _getManyComparators(stream) {
+  const result = await stream.actions.data.getMany.execute(
+    {
+      model: "neu:penilaian:gradingComparator",
+      query: query.Query.define({
+        fields: {
+          id: 1,
+          overrideComparison: 1,
+          derivativeComparison: 1,
+          acceptedGradingRasionalizations: {
+            student: {
+              name: 1
+            },
+            acceptedValidation: 1,
+            scores: 1
+          }
+        },
+        limit: 1e4
+      })
+    },
+    stream
+  );
+  if (result.isFailure)
+    throw result;
+  return result.value;
+}
+async function _updateManyComparators(stream, comparators) {
+  const operations = [];
+  comparators.map((comparator) => {
+    const comparison = _calculateComparison(comparator);
+    operations.push({
+      updateOne: {
+        filter: {
+          _id: comparator.id
+        },
+        update: {
+          $set: {
+            comparison
+          }
+        }
+      }
+    });
+  });
+  console.dir({ operations }, { depth: 5 });
+  await stream.core.dbs["neu-penilaian"].models["neu:penilaian:gradingComparator"].bulkWrite(operations);
+}
+function _calculateComparison(o) {
+  console.dir(o, { depth: 10 });
+  if (o.overrideComparison && !value.ValueUtil.isEmpty(o.overrideComparison)) {
+    return o.overrideComparison;
+  }
+  if (!o.acceptedGradingRasionalizations?.length) {
+    if (o.derivativeComparison && !value.ValueUtil.isEmpty(o.derivativeComparison)) {
+      return o.derivativeComparison;
+    }
+    return {};
+  }
+  const comparison = o.acceptedGradingRasionalizations.filter((item) => item.acceptedValidation == "verified").reduce((final, comparison2) => {
+    if (!comparison2.scores)
+      return final;
+    const scores = Object.entries(comparison2.scores);
+    for (const [gradingComponentId, score] of scores) {
+      let value = NumberUtil.transformDecimal(score);
+      value = NumberUtil.twoDecimal(value);
+      if (!final[gradingComponentId]) {
+        final[gradingComponentId] = {
+          total: 0,
+          count: 0,
+          average: 0,
+          max: 0,
+          min: 1e4
+        };
+      }
+      final[gradingComponentId].total += value;
+      final[gradingComponentId].count += 1;
+      final[gradingComponentId].max = Math.max(
+        final[gradingComponentId].max,
+        value
+      );
+      final[gradingComponentId].min = Math.min(
+        final[gradingComponentId].min,
+        value
+      );
+    }
+    for (const gradingComponentId of Object.keys(final)) {
+      const average = final[gradingComponentId].total / final[gradingComponentId].count;
+      final[gradingComponentId].average = NumberUtil.twoDecimal(average);
+    }
+    return final;
+  }, {});
+  return comparison;
+}
+
+const calculateOneComparator = operation.Action.define({
+  key: "calculateOneComparator",
+  name: "Calculate One Comparator",
+  type: "command",
+  category: "domain",
+  execute: async ({ gradingComparatorId }, stream) => {
+    console.time("\u23F1\uFE0F getOneComparator");
+    const gradingComparator = await _getOneComparator(
+      stream,
+      gradingComparatorId
+    );
+    console.timeEnd("\u23F1\uFE0F getOneComparator");
+    console.time("\u23F1\uFE0F updateOneComparator");
+    await _updateOneComparator(stream, gradingComparator);
+    console.timeEnd("\u23F1\uFE0F updateOneComparator");
+    return core.Result.ok({
+      state: "comparatorCalculated",
+      message: "Comparator have been calculated.",
+      data: {}
+    });
+  }
+});
+async function _getOneComparator(stream, gradingComparatorId) {
+  const result = await stream.actions.data.getOne.execute(
+    {
+      model: "neu:penilaian:gradingComparator",
+      id: gradingComparatorId,
+      query: query.Query.define({
+        fields: {
+          id: 1,
+          overrideComparison: 1,
+          derivativeComparison: 1,
+          acceptedGradingRasionalizations: {
+            student: {
+              name: 1
+            },
+            acceptedValidation: 1,
+            scores: 1
+          }
+        }
+      })
+    },
+    stream
+  );
+  if (result.isFailure)
+    throw result;
+  return result.value;
+}
+async function _updateOneComparator(stream, comparator) {
+  const comparison = _calculateComparison(comparator);
+  console.dir({ comparison }, { depth: 10 });
+  const result = await stream.actions.data.updateOne.execute(
+    {
+      model: "neu:penilaian:gradingComparator",
+      id: comparator.id,
+      data: {
+        comparison
+      },
+      query: query.Query.define({})
+    },
+    stream
+  );
+  if (result.isFailure)
+    throw result;
+  return result.value;
+}
+
+const clearAllOverrides = operation.Action.define({
+  key: "clearAllOverrides",
+  name: "Clear All Overrides",
+  type: "command",
+  category: "domain",
+  execute: async (_, stream) => {
+    console.time("\u23F1\uFE0F clearAllOverrides");
+    await _clearAllOverrides(stream);
+    console.timeEnd("\u23F1\uFE0F clearAllOverrides");
+    return core.Result.ok({
+      state: "overridesCleared",
+      message: "Overrides have been cleared.",
+      data: {}
+    });
+  }
+});
+async function _clearAllOverrides(stream) {
+  await stream.actions.data.updateMany.execute(
+    {
+      model: "neu:penilaian:gradingComparator",
+      data: { overrideComparison: {} },
+      query: query.Query.define({
+        limit: 1e4
+      })
+    },
+    stream
+  );
+}
+
 const clearGrading = operation.Action.define({
   key: "clearGrading",
   name: "Clear Grading",
@@ -827,9 +1034,12 @@ const sendAnswer = operation.Action.define({
 
 const index = {
   __proto__: null,
+  _calculateComparison: _calculateComparison,
   acceptQuestion: acceptQuestion,
   calculateGrading: calculateGrading,
   calculateManyComparator: calculateManyComparator,
+  calculateOneComparator: calculateOneComparator,
+  clearAllOverrides: clearAllOverrides,
   clearGrading: clearGrading,
   createGradingAndScores: createGradingAndScores,
   editAnswer: editAnswer,
@@ -843,10 +1053,13 @@ const index = {
   updateGradingAndScores: updateGradingAndScores
 };
 
+exports._calculateComparison = _calculateComparison;
 exports.acceptQuestion = acceptQuestion;
 exports.actions = index;
 exports.calculateGrading = calculateGrading;
 exports.calculateManyComparator = calculateManyComparator;
+exports.calculateOneComparator = calculateOneComparator;
+exports.clearAllOverrides = clearAllOverrides;
 exports.clearGrading = clearGrading;
 exports.createGradingAndScores = createGradingAndScores;
 exports.editAnswer = editAnswer;

package/build/index.d.ts

@@ -43,14 +43,27 @@ interface SyncCommitmentMeta {
 declare const syncCommitment: Action<"syncCommitment", SyncCommitmentInput, SyncCommitmentOutput, SyncCommitmentMeta>;
 type SyncCommitmentAction = typeof syncCommitment;
 
+interface CalculateGradingInput {
+    gradingInsertId: string;
+    gradingContextIds: string[];
+    sourceSchoolId: string;
+    gradingId: string;
+}
+interface CalculateGradingOutput {
+}
+interface CalculateGradingMeta {
+}
+declare const calculateGrading: Action<"calculateGrading", CalculateGradingInput, CalculateGradingOutput, CalculateGradingMeta>;
+type CalculateGradingAction = typeof calculateGrading;
+
 interface CalculateManyComparatorInput {
-    gradingComparatorId: string;
 }
 interface CalculateManyComparatorOutput {
 }
 interface CalculateManyComparatorMeta {
 }
 declare const calculateManyComparator: Action<"calculateManyComparator", CalculateManyComparatorInput, CalculateManyComparatorOutput, CalculateManyComparatorMeta>;
+declare function _calculateComparison(o: GradingComparator): GradingComparatorComparison;
 interface GradingComparatorComparison {
     [key: string]: {
         total: number;
@@ -61,27 +74,34 @@ interface GradingComparatorComparison {
     };
 }
 interface GradingComparator {
-    gradingRasionalizations?: {
+    id: string;
+    acceptedGradingRasionalizations?: {
         scores?: Record<string, number>;
+        acceptedValidation?: 'verified' | 'accept' | 'rejected';
     }[];
-    comparison?: GradingComparatorComparison;
     derivativeComparison?: GradingComparatorComparison;
     overrideComparison?: GradingComparatorComparison;
 }
 type CalculateManyComparatorAction = typeof calculateManyComparator;
 
-interface CalculateGradingInput {
-    gradingInsertId: string;
-    gradingContextIds: string[];
-    sourceSchoolId: string;
-    gradingId: string;
+interface CalculateOneComparatorInput {
+    gradingComparatorId: string;
 }
-interface CalculateGradingOutput {
+interface CalculateOneComparatorOutput {
 }
-interface CalculateGradingMeta {
+interface CalculateOneComparatorMeta {
 }
-declare const calculateGrading: Action<"calculateGrading", CalculateGradingInput, CalculateGradingOutput, CalculateGradingMeta>;
-type CalculateGradingAction = typeof calculateGrading;
+declare const calculateOneComparator: Action<"calculateOneComparator", CalculateOneComparatorInput, CalculateOneComparatorOutput, CalculateOneComparatorMeta>;
+type CalculateOneComparatorAction = typeof calculateOneComparator;
+
+interface ClearAllOverridesInput {
+}
+interface ClearAllOverridesOutput {
+}
+interface ClearAllOverridesMeta {
+}
+declare const clearAllOverrides: Action<"clearAllOverrides", ClearAllOverridesInput, ClearAllOverridesOutput, ClearAllOverridesMeta>;
+type ClearAllOverridesAction = typeof clearAllOverrides;
 
 interface ClearGradingInput {
     gradingInsertId: string;
@@ -184,6 +204,14 @@ type index_CalculateManyComparatorAction = CalculateManyComparatorAction;
 type index_CalculateManyComparatorInput = CalculateManyComparatorInput;
 type index_CalculateManyComparatorMeta = CalculateManyComparatorMeta;
 type index_CalculateManyComparatorOutput = CalculateManyComparatorOutput;
+type index_CalculateOneComparatorAction = CalculateOneComparatorAction;
+type index_CalculateOneComparatorInput = CalculateOneComparatorInput;
+type index_CalculateOneComparatorMeta = CalculateOneComparatorMeta;
+type index_CalculateOneComparatorOutput = CalculateOneComparatorOutput;
+type index_ClearAllOverridesAction = ClearAllOverridesAction;
+type index_ClearAllOverridesInput = ClearAllOverridesInput;
+type index_ClearAllOverridesMeta = ClearAllOverridesMeta;
+type index_ClearAllOverridesOutput = ClearAllOverridesOutput;
 type index_ClearGradingAction = ClearGradingAction;
 type index_ClearGradingInput = ClearGradingInput;
 type index_ClearGradingMeta = ClearGradingMeta;
@@ -230,9 +258,12 @@ type index_UpdateGradingAndScoresAction = UpdateGradingAndScoresAction;
 type index_UpdateGradingAndScoresInput = UpdateGradingAndScoresInput;
 type index_UpdateGradingAndScoresMeta = UpdateGradingAndScoresMeta;
 type index_UpdateGradingAndScoresOutput = UpdateGradingAndScoresOutput;
+declare const index__calculateComparison: typeof _calculateComparison;
 declare const index_acceptQuestion: typeof acceptQuestion;
 declare const index_calculateGrading: typeof calculateGrading;
 declare const index_calculateManyComparator: typeof calculateManyComparator;
+declare const index_calculateOneComparator: typeof calculateOneComparator;
+declare const index_clearAllOverrides: typeof clearAllOverrides;
 declare const index_clearGrading: typeof clearGrading;
 declare const index_createGradingAndScores: typeof createGradingAndScores;
 declare const index_editAnswer: typeof editAnswer;
@@ -258,6 +289,14 @@ declare namespace index {
     index_CalculateManyComparatorInput as CalculateManyComparatorInput,
     index_CalculateManyComparatorMeta as CalculateManyComparatorMeta,
     index_CalculateManyComparatorOutput as CalculateManyComparatorOutput,
+    index_CalculateOneComparatorAction as CalculateOneComparatorAction,
+    index_CalculateOneComparatorInput as CalculateOneComparatorInput,
+    index_CalculateOneComparatorMeta as CalculateOneComparatorMeta,
+    index_CalculateOneComparatorOutput as CalculateOneComparatorOutput,
+    index_ClearAllOverridesAction as ClearAllOverridesAction,
+    index_ClearAllOverridesInput as ClearAllOverridesInput,
+    index_ClearAllOverridesMeta as ClearAllOverridesMeta,
+    index_ClearAllOverridesOutput as ClearAllOverridesOutput,
     index_ClearGradingAction as ClearGradingAction,
     index_ClearGradingInput as ClearGradingInput,
     index_ClearGradingMeta as ClearGradingMeta,
@@ -304,9 +343,12 @@ declare namespace index {
     index_UpdateGradingAndScoresInput as UpdateGradingAndScoresInput,
     index_UpdateGradingAndScoresMeta as UpdateGradingAndScoresMeta,
     index_UpdateGradingAndScoresOutput as UpdateGradingAndScoresOutput,
+    index__calculateComparison as _calculateComparison,
     index_acceptQuestion as acceptQuestion,
     index_calculateGrading as calculateGrading,
     index_calculateManyComparator as calculateManyComparator,
+    index_calculateOneComparator as calculateOneComparator,
+    index_clearAllOverrides as clearAllOverrides,
     index_clearGrading as clearGrading,
     index_createGradingAndScores as createGradingAndScores,
     index_editAnswer as editAnswer,
@@ -321,4 +363,4 @@ declare namespace index {
   };
 }
 
-export { AcceptQuestionAction, AcceptQuestionInput, AcceptQuestionMeta, AcceptQuestionOutput, CalculateGradingAction, CalculateGradingInput, CalculateGradingMeta, CalculateGradingOutput, CalculateManyComparatorAction, CalculateManyComparatorInput, CalculateManyComparatorMeta, CalculateManyComparatorOutput, ClearGradingAction, ClearGradingInput, ClearGradingMeta, ClearGradingOutput, CreateGradingAndScoresAction, CreateGradingAndScoresInput, CreateGradingAndScoresMeta, CreateGradingAndScoresOutput, EditAnswerAction, EditAnswerInput, EditAnswerMeta, EditAnswerOutput, GenerateGradingAction, GenerateGradingInput, GenerateGradingMeta, GenerateGradingOutput, GradingComparator, GradingComparatorComparison, PresenceSessionStudentAction, PresenceSessionStudentInput, PresenceSessionStudentMeta, PresenceSessionStudentOutput, PresenceSessionTeacherAction, PresenceSessionTeacherInput, PresenceSessionTeacherMeta, PresenceSessionTeacherOutput, RasionalizeGradingAction, RasionalizeGradingInput, RasionalizeGradingMeta, RasionalizeGradingOutput, SendAnswerAction, SendAnswerInput, SendAnswerMeta, SendAnswerOutput, SetSomethingAction, SetSomethingInput, SetSomethingMeta, SetSomethingOutput, SyncCommitmentAction, SyncCommitmentInput, SyncCommitmentMeta, SyncCommitmentOutput, UpdateGradingAndScoresAction, UpdateGradingAndScoresInput, UpdateGradingAndScoresMeta, UpdateGradingAndScoresOutput, acceptQuestion, index as actions, calculateGrading, calculateManyComparator, clearGrading, createGradingAndScores, editAnswer, generateGrading, presenceSessionStudent, presenceSessionTeacher, rasionalizeGrading, sendAnswer, setSomething, syncCommitment, updateGradingAndScores };
+export { AcceptQuestionAction, AcceptQuestionInput, AcceptQuestionMeta, AcceptQuestionOutput, CalculateGradingAction, CalculateGradingInput, CalculateGradingMeta, CalculateGradingOutput, CalculateManyComparatorAction, CalculateManyComparatorInput, CalculateManyComparatorMeta, CalculateManyComparatorOutput, CalculateOneComparatorAction, CalculateOneComparatorInput, CalculateOneComparatorMeta, CalculateOneComparatorOutput, ClearAllOverridesAction, ClearAllOverridesInput, ClearAllOverridesMeta, ClearAllOverridesOutput, ClearGradingAction, ClearGradingInput, ClearGradingMeta, ClearGradingOutput, CreateGradingAndScoresAction, CreateGradingAndScoresInput, CreateGradingAndScoresMeta, CreateGradingAndScoresOutput, EditAnswerAction, EditAnswerInput, EditAnswerMeta, EditAnswerOutput, GenerateGradingAction, GenerateGradingInput, GenerateGradingMeta, GenerateGradingOutput, GradingComparator, GradingComparatorComparison, PresenceSessionStudentAction, PresenceSessionStudentInput, PresenceSessionStudentMeta, PresenceSessionStudentOutput, PresenceSessionTeacherAction, PresenceSessionTeacherInput, PresenceSessionTeacherMeta, PresenceSessionTeacherOutput, RasionalizeGradingAction, RasionalizeGradingInput, RasionalizeGradingMeta, RasionalizeGradingOutput, SendAnswerAction, SendAnswerInput, SendAnswerMeta, SendAnswerOutput, SetSomethingAction, SetSomethingInput, SetSomethingMeta, SetSomethingOutput, SyncCommitmentAction, SyncCommitmentInput, SyncCommitmentMeta, SyncCommitmentOutput, UpdateGradingAndScoresAction, UpdateGradingAndScoresInput, UpdateGradingAndScoresMeta, UpdateGradingAndScoresOutput, _calculateComparison, acceptQuestion, index as actions, calculateGrading, calculateManyComparator, calculateOneComparator, clearAllOverrides, clearGrading, createGradingAndScores, editAnswer, generateGrading, presenceSessionStudent, presenceSessionTeacher, rasionalizeGrading, sendAnswer, setSomething, syncCommitment, updateGradingAndScores };

package/build/index.mjs

@@ -1,6 +1,7 @@
 import { Result } from '@neon.id/core';
 import { Action } from '@neon.id/operation';
 import { Query } from '@neon.id/query';
+import { ValueUtil } from '@neon.id/utils/value';
 import { customAlphabet } from 'nanoid';
 
 const setSomething = Action.define({
@@ -134,34 +135,6 @@ const syncCommitment = Action.define({
   }
 });
 
-const calculateManyComparator = Action.define({
-  key: "calculateManyComparator",
-  name: "Create Penilaian dan Score",
-  type: "command",
-  category: "domain",
-  execute: async ({ gradingComparatorId }, stream) => {
-    console.log("id", gradingComparatorId);
-    console.time("\u23F1\uFE0F syncGradingComparator");
-    const result = await stream.actions.data.syncMany.execute(
-      {
-        model: "neu:penilaian:gradingComparator",
-        useDry: false,
-        query: Query.define({
-          limit: 1e5
-        })
-      },
-      stream
-    );
-    console.log(result);
-    console.timeEnd("\u23F1\uFE0F syncGradingComparator");
-    return Result.ok({
-      state: "ComparatorCalculated",
-      message: "Camparator have been calculated.",
-      data: {}
-    });
-  }
-});
-
 const generateGrading = Action.define({
   key: "generateGrading",
   name: "Create Penilaian dan Score",
@@ -364,6 +337,240 @@ async function _destroyMany(stream, input) {
   console.timeEnd("\u23F1\uFE0F destroyManyGradingComparisonItem");
 }
 
+class NumberUtil {
+  static transformDecimal(value) {
+    if (!value)
+      return 0;
+    const string = value.toString();
+    const float = parseFloat(string);
+    return float || 0;
+  }
+  static twoDecimal(value) {
+    return Math.round(value * 100) / 100;
+  }
+}
+
+const calculateManyComparator = Action.define({
+  key: "calculateManyComparator",
+  name: "Create Penilaian dan Score",
+  type: "command",
+  category: "domain",
+  execute: async (_, stream) => {
+    console.time("\u23F1\uFE0F getManyComparators");
+    const comparators = await _getManyComparators(stream);
+    console.timeEnd("\u23F1\uFE0F getManyComparators");
+    console.time("\u23F1\uFE0F updateManyComparators");
+    await _updateManyComparators(stream, comparators);
+    console.timeEnd("\u23F1\uFE0F updateManyComparators");
+    console.time("\u23F1\uFE0F syncGradingComparator");
+    const result = await stream.actions.data.syncMany.execute(
+      {
+        model: "neu:penilaian:gradingComparator",
+        useDry: false,
+        query: Query.define({
+          limit: 1e5
+        })
+      },
+      stream
+    );
+    console.log(result);
+    console.timeEnd("\u23F1\uFE0F syncGradingComparator");
+    return Result.ok({
+      state: "ComparatorCalculated",
+      message: "Camparator have been calculated.",
+      data: {}
+    });
+  }
+});
+async function _getManyComparators(stream) {
+  const result = await stream.actions.data.getMany.execute(
+    {
+      model: "neu:penilaian:gradingComparator",
+      query: Query.define({
+        fields: {
+          id: 1,
+          overrideComparison: 1,
+          derivativeComparison: 1,
+          acceptedGradingRasionalizations: {
+            student: {
+              name: 1
+            },
+            acceptedValidation: 1,
+            scores: 1
+          }
+        },
+        limit: 1e4
+      })
+    },
+    stream
+  );
+  if (result.isFailure)
+    throw result;
+  return result.value;
+}
+async function _updateManyComparators(stream, comparators) {
+  const operations = [];
+  comparators.map((comparator) => {
+    const comparison = _calculateComparison(comparator);
+    operations.push({
+      updateOne: {
+        filter: {
+          _id: comparator.id
+        },
+        update: {
+          $set: {
+            comparison
+          }
+        }
+      }
+    });
+  });
+  console.dir({ operations }, { depth: 5 });
+  await stream.core.dbs["neu-penilaian"].models["neu:penilaian:gradingComparator"].bulkWrite(operations);
+}
+function _calculateComparison(o) {
+  console.dir(o, { depth: 10 });
+  if (o.overrideComparison && !ValueUtil.isEmpty(o.overrideComparison)) {
+    return o.overrideComparison;
+  }
+  if (!o.acceptedGradingRasionalizations?.length) {
+    if (o.derivativeComparison && !ValueUtil.isEmpty(o.derivativeComparison)) {
+      return o.derivativeComparison;
+    }
+    return {};
+  }
+  const comparison = o.acceptedGradingRasionalizations.filter((item) => item.acceptedValidation == "verified").reduce((final, comparison2) => {
+    if (!comparison2.scores)
+      return final;
+    const scores = Object.entries(comparison2.scores);
+    for (const [gradingComponentId, score] of scores) {
+      let value = NumberUtil.transformDecimal(score);
+      value = NumberUtil.twoDecimal(value);
+      if (!final[gradingComponentId]) {
+        final[gradingComponentId] = {
+          total: 0,
+          count: 0,
+          average: 0,
+          max: 0,
+          min: 1e4
+        };
+      }
+      final[gradingComponentId].total += value;
+      final[gradingComponentId].count += 1;
+      final[gradingComponentId].max = Math.max(
+        final[gradingComponentId].max,
+        value
+      );
+      final[gradingComponentId].min = Math.min(
+        final[gradingComponentId].min,
+        value
+      );
+    }
+    for (const gradingComponentId of Object.keys(final)) {
+      const average = final[gradingComponentId].total / final[gradingComponentId].count;
+      final[gradingComponentId].average = NumberUtil.twoDecimal(average);
+    }
+    return final;
+  }, {});
+  return comparison;
+}
+
+const calculateOneComparator = Action.define({
+  key: "calculateOneComparator",
+  name: "Calculate One Comparator",
+  type: "command",
+  category: "domain",
+  execute: async ({ gradingComparatorId }, stream) => {
+    console.time("\u23F1\uFE0F getOneComparator");
+    const gradingComparator = await _getOneComparator(
+      stream,
+      gradingComparatorId
+    );
+    console.timeEnd("\u23F1\uFE0F getOneComparator");
+    console.time("\u23F1\uFE0F updateOneComparator");
+    await _updateOneComparator(stream, gradingComparator);
+    console.timeEnd("\u23F1\uFE0F updateOneComparator");
+    return Result.ok({
+      state: "comparatorCalculated",
+      message: "Comparator have been calculated.",
+      data: {}
+    });
+  }
+});
+async function _getOneComparator(stream, gradingComparatorId) {
+  const result = await stream.actions.data.getOne.execute(
+    {
+      model: "neu:penilaian:gradingComparator",
+      id: gradingComparatorId,
+      query: Query.define({
+        fields: {
+          id: 1,
+          overrideComparison: 1,
+          derivativeComparison: 1,
+          acceptedGradingRasionalizations: {
+            student: {
+              name: 1
+            },
+            acceptedValidation: 1,
+            scores: 1
+          }
+        }
+      })
+    },
+    stream
+  );
+  if (result.isFailure)
+    throw result;
+  return result.value;
+}
+async function _updateOneComparator(stream, comparator) {
+  const comparison = _calculateComparison(comparator);
+  console.dir({ comparison }, { depth: 10 });
+  const result = await stream.actions.data.updateOne.execute(
+    {
+      model: "neu:penilaian:gradingComparator",
+      id: comparator.id,
+      data: {
+        comparison
+      },
+      query: Query.define({})
+    },
+    stream
+  );
+  if (result.isFailure)
+    throw result;
+  return result.value;
+}
+
+const clearAllOverrides = Action.define({
+  key: "clearAllOverrides",
+  name: "Clear All Overrides",
+  type: "command",
+  category: "domain",
+  execute: async (_, stream) => {
+    console.time("\u23F1\uFE0F clearAllOverrides");
+    await _clearAllOverrides(stream);
+    console.timeEnd("\u23F1\uFE0F clearAllOverrides");
+    return Result.ok({
+      state: "overridesCleared",
+      message: "Overrides have been cleared.",
+      data: {}
+    });
+  }
+});
+async function _clearAllOverrides(stream) {
+  await stream.actions.data.updateMany.execute(
+    {
+      model: "neu:penilaian:gradingComparator",
+      data: { overrideComparison: {} },
+      query: Query.define({
+        limit: 1e4
+      })
+    },
+    stream
+  );
+}
+
 const clearGrading = Action.define({
   key: "clearGrading",
   name: "Clear Grading",
@@ -825,9 +1032,12 @@ const sendAnswer = Action.define({
 
 const index = {
   __proto__: null,
+  _calculateComparison: _calculateComparison,
   acceptQuestion: acceptQuestion,
   calculateGrading: calculateGrading,
   calculateManyComparator: calculateManyComparator,
+  calculateOneComparator: calculateOneComparator,
+  clearAllOverrides: clearAllOverrides,
   clearGrading: clearGrading,
   createGradingAndScores: createGradingAndScores,
   editAnswer: editAnswer,
@@ -841,4 +1051,4 @@ const index = {
   updateGradingAndScores: updateGradingAndScores
 };
 
-export { acceptQuestion, index as actions, calculateGrading, calculateManyComparator, clearGrading, createGradingAndScores, editAnswer, generateGrading, presenceSessionStudent, presenceSessionTeacher, rasionalizeGrading, sendAnswer, setSomething, syncCommitment, updateGradingAndScores };
+export { _calculateComparison, acceptQuestion, index as actions, calculateGrading, calculateManyComparator, calculateOneComparator, clearAllOverrides, clearGrading, createGradingAndScores, editAnswer, generateGrading, presenceSessionStudent, presenceSessionTeacher, rasionalizeGrading, sendAnswer, setSomething, syncCommitment, updateGradingAndScores };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neutron.co.id/pendidikan-operation",
-  "version": "1.3.0",
+  "version": "1.4.0-beta.1",
   "description": "Operation package of Neutron Pendidikan.",
   "license": "SEE LICENSE IN LICENSE",
   "contributors": [
@@ -39,7 +39,7 @@
     "@neon.id/utils": "0.33.5",
     "@neutron.co.id/akademik-models": "1.2.0",
     "@neutron.co.id/jadwal-models": "1.2.0",
-    "@neutron.co.id/penilaian-models": "1.3.0",
+    "@neutron.co.id/penilaian-models": "1.4.0-beta.1",
     "@neutron.co.id/tanya-models": "1.1.0",
     "mongoose": "6.9.1",
     "nanoid": "4.0.1",
@@ -68,7 +68,7 @@
     "@neon.id/utils": "^0.33.5",
     "@neutron.co.id/akademik-models": "^1.2.0",
     "@neutron.co.id/jadwal-models": "^1.2.0",
-    "@neutron.co.id/penilaian-models": "^1.3.0",
+    "@neutron.co.id/penilaian-models": "^1.4.0-beta.1",
     "@neutron.co.id/tanya-models": "^1.1.0",
     "mongoose": "^6.9.1",
     "ofetch": "^1.0.0"
@@ -76,5 +76,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "build": 15
+  "build": 16
 }