@neutron.co.id/pendidikan-operation 1.2.1 → 1.3.0-beta.2

package/build/index.cjs

@@ -21,6 +21,564 @@ const setSomething = operation.Action.define({
   }
 });
 
+const presenceSessionStudent = operation.Action.define({
+  key: "presenceSessionStudent",
+  name: "Presence Student",
+  type: "command",
+  category: "domain",
+  execute: async (input, stream) => {
+    const dbs = stream.core.dbs;
+    const sessionResult = await stream.actions.data.getOne.execute({
+      model: "ClassSession",
+      id: input.sessionId,
+      query: query.Query.define({
+        fields: {
+          _id: 1
+        }
+      })
+    });
+    const session = sessionResult.value;
+    const dbAttendance = dbs.jadwal.models.ClassAttendance;
+    const dbStudent = dbs.siswa.models.Student;
+    const siswa = await dbStudent.findOne({
+      userId: stream.context.identitas.userId
+    });
+    await dbAttendance.create({
+      classSessionId: session._id,
+      studentId: siswa.id,
+      presenceAt: new Date(),
+      updatedAt: new Date(),
+      createdBy: stream.context.identitas.userId,
+      updatedBy: stream.context.identitas.userId
+    });
+    return core.Result.ok({
+      state: "presenceSessionStudent",
+      message: "Presensi berhasil!"
+    });
+  }
+});
+
+const presenceSessionTeacher = operation.Action.define({
+  key: "presenceSessionTeacher",
+  name: "Presence Teacher",
+  type: "command",
+  category: "domain",
+  execute: async (input, stream) => {
+    const dbs = stream.core.dbs;
+    const sessionResult = await stream.actions.data.getOne.execute({
+      model: "ClassSession",
+      id: input.sessionId,
+      query: query.Query.define({
+        fields: {
+          _id: 1
+        }
+      })
+    });
+    const session = sessionResult.value;
+    const dbAttendance = dbs.jadwal.models.ClassAttendance;
+    const dbTeacher = dbs.talenta.models.Teacher;
+    const user = stream.context.identitas.userId;
+    const pengajar = await dbTeacher.findOne({ userId: user });
+    await dbAttendance.create({
+      classSessionId: session._id,
+      teacherId: pengajar.id,
+      presenceAt: new Date(),
+      updatedAt: new Date(),
+      createdBy: user,
+      updatedBy: user
+    });
+    return core.Result.ok({
+      state: "presenceSessionTeacher",
+      message: "Presensi berhasil!"
+    });
+  }
+});
+
+const syncCommitment = operation.Action.define({
+  key: "syncCommitment",
+  name: "Sync Commitment",
+  type: "command",
+  category: "domain",
+  execute: async (input, stream) => {
+    const dbs = stream.core.dbs;
+    const teacherResult = await stream.actions.data.getOne.execute({
+      model: "Teacher",
+      id: input.teacherId,
+      query: query.Query.define({
+        fields: {
+          _id: 1,
+          teacherCommitments: {
+            weekdays: 1,
+            startedAt: 1,
+            endedAt: 1
+          }
+        }
+      })
+    });
+    const teacher = teacherResult.value;
+    const dbCommitment = dbs.talenta.models.TeacherCommitment;
+    const dbTeacher = dbs.talenta.models.Teacher;
+    const commitment = await dbCommitment.findOne({ teacherId: teacher._id }).sort({ createdAt: -1 });
+    await dbTeacher.updateOne(
+      { _id: teacher._id },
+      {
+        $set: {
+          weekdays: commitment.weekdays,
+          hourStart: commitment.startedAt,
+          hourEnd: commitment.endedAt
+        }
+      }
+    );
+    return core.Result.ok({
+      state: "syncCommitment",
+      message: "Komitment disinkronasi!"
+    });
+  }
+});
+
+const generateGrading = operation.Action.define({
+  key: "generateGrading",
+  name: "Create Penilaian dan Score",
+  type: "command",
+  category: "domain",
+  execute: async ({ gradingInsertId }, stream) => {
+    const comparator = await _getGradingInsert$1(stream, gradingInsertId);
+    await _generateGradingRasio(stream, comparator);
+    const gradingComparisons = await _getGradingRasio(stream, gradingInsertId);
+    await _generateGradingComparisonItem(stream, comparator, gradingComparisons);
+    return core.Result.ok({
+      state: "allGenerated",
+      message: "All Penilaian have been synced.",
+      data: {}
+    });
+  }
+});
+async function _getGradingInsert$1(stream, gradingInsertId) {
+  const resultInsert = await stream.actions.data.getOne.execute(
+    {
+      model: "neu:penilaian:gradingInsert",
+      id: gradingInsertId,
+      query: query.Query.define({
+        fields: {
+          id: 1,
+          gradingId: 1,
+          gradingContexts: {
+            id: 1,
+            gradingComparators: { id: 1 }
+          }
+        }
+      })
+    },
+    stream
+  );
+  return resultInsert.value;
+}
+async function _getGradingRasio(stream, gradingInsertId) {
+  const resultRasio = await stream.actions.data.getMany.execute(
+    {
+      model: "neu:penilaian:gradingRasionalization",
+      query: query.Query.define({
+        filter: {
+          gradingInsertId
+        },
+        fields: {
+          id: 1,
+          gradingInsertId: 1,
+          gradingContextId: 1,
+          gradingComparatorId: 1
+        },
+        limit: 1e4
+      })
+    },
+    stream
+  );
+  return resultRasio.value;
+}
+async function _generateGradingRasio(stream, gradingInserts) {
+  const operations = [];
+  for (const gradingContext of gradingInserts.gradingContexts) {
+    for (const comparator of gradingContext.gradingComparators) {
+      operations.push({
+        insertOne: {
+          document: {
+            gradingId: gradingInserts.gradingId,
+            gradingInsertId: gradingInserts.id,
+            gradingComparatorId: comparator?.id,
+            gradingContextId: gradingContext?.id
+          }
+        }
+      });
+    }
+  }
+  await stream.core.dbs["neu-penilaian"].models["neu:penilaian:gradingRasionalization"].bulkWrite(operations);
+}
+async function _generateGradingComparisonItem(stream, grading, gradingRasios) {
+  const operations = [];
+  const resultScore = await stream.actions.data.getMany.execute(
+    {
+      model: "neu:penilaian:score",
+      query: query.Query.define({
+        filter: {
+          gradingId: grading.gradingId
+        },
+        fields: {
+          id: 1,
+          gradingComponentId: 1
+        },
+        limit: 100
+      })
+    },
+    stream
+  );
+  for (const rasio of gradingRasios) {
+    resultScore.value.map(async (item) => {
+      operations.push({
+        insertOne: {
+          document: {
+            gradingRasionalizationId: rasio.id,
+            gradingInsertId: rasio.gradingInsertId,
+            gradingComparatorId: rasio?.gradingComparatorId,
+            scoreId: item?.id
+          }
+        }
+      });
+    });
+  }
+  await stream.core.dbs["neu-penilaian"].models["neu:penilaian:gradingComparisonItem"].bulkWrite(operations);
+}
+
+const rasionalizeGrading = operation.Action.define({
+  key: "rasionalizeGrading",
+  name: "Sync All Penilaian",
+  type: "command",
+  category: "domain",
+  execute: async ({ gradingInsertId }, stream) => {
+    await syncModel(stream, "neu:penilaian:gradingComparisonItem", {
+      gradingInsertId
+    });
+    await syncModel(stream, "neu:penilaian:gradingRasionalization", {
+      gradingInsertId
+    });
+    await syncModel(stream, "neu:penilaian:grading", {
+      gradingInsertId
+    });
+    await syncModel(stream, "neu:penilaian:gradingInsert", {
+      _id: gradingInsertId
+    });
+    return core.Result.ok({
+      state: "allSynced",
+      message: "All penilaian modules have been synced.",
+      data: {}
+    });
+  }
+});
+async function syncModel(stream, model, filter) {
+  console.time(`\u23F1\uFE0F syncModel:${model}`);
+  await stream.actions.data.syncMany.execute(
+    {
+      model,
+      useDry: false,
+      query: query.Query.define({
+        filter,
+        limit: 1e5
+      })
+    },
+    stream
+  );
+  console.timeEnd(`\u23F1\uFE0F syncModel:${model}`);
+}
+
+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 });
+    const cached = {
+      gradingContextIds,
+      sourceSchoolId
+    };
+    console.time("\u23F1\uFE0F updateGradingInsertCachedData");
+    await stream.actions.data.updateOne.execute(
+      {
+        model: "neu:penilaian:gradingInsert",
+        id: gradingInsertId,
+        data: { cached },
+        query: query.Query.define({})
+      },
+      stream
+    );
+    console.timeEnd("\u23F1\uFE0F updateGradingInsertCachedData");
+    console.time("\u23F1\uFE0F generateGrading");
+    await generateGrading.execute({ gradingInsertId }, stream);
+    console.timeEnd("\u23F1\uFE0F generateGrading");
+    console.time("\u23F1\uFE0F rasionalizeGrading");
+    await rasionalizeGrading.execute({ gradingInsertId }, stream);
+    console.timeEnd("\u23F1\uFE0F rasionalizeGrading");
+    return core.Result.ok({
+      state: "allCalculated",
+      message: "All Penilaian have been calculated.",
+      data: {}
+    });
+  }
+});
+async function _destroyMany(stream, input) {
+  const { gradingId, gradingInsertId } = input;
+  const db = stream.core.dbs["neu-penilaian"];
+  console.time("\u23F1\uFE0F destroyManyGradingRasionalization");
+  await db.models["neu:penilaian:gradingRasionalization"].deleteMany({
+    gradingId
+  });
+  console.timeEnd("\u23F1\uFE0F destroyManyGradingRasionalization");
+  console.time("\u23F1\uFE0F destroyManyGradingComparisonItem");
+  await db.models["neu:penilaian:gradingComparisonItem"].deleteMany({
+    gradingInsertId
+  });
+  console.timeEnd("\u23F1\uFE0F destroyManyGradingComparisonItem");
+}
+
+const clearGrading = operation.Action.define({
+  key: "clearGrading",
+  name: "Clear Grading",
+  type: "command",
+  category: "domain",
+  execute: async ({ gradingInsertId }, stream) => {
+    const gradingInsert = await _getGradingInsert(stream, gradingInsertId);
+    const gradingId = gradingInsert.gradingId;
+    const db = stream.core.dbs["neu-penilaian"];
+    console.time("\u23F1\uFE0F deleteManyGrading");
+    await db.models["neu:penilaian:grading"].deleteMany({
+      _id: gradingId
+    });
+    console.timeEnd("\u23F1\uFE0F deleteManyGrading");
+    console.time("\u23F1\uFE0F deleteManyScore");
+    await db.models["neu:penilaian:score"].deleteMany({
+      gradingId
+    });
+    console.timeEnd("\u23F1\uFE0F deleteManyScore");
+    console.time("\u23F1\uFE0F deleteManyGradingRasionalization");
+    await db.models["neu:penilaian:gradingRasionalization"].deleteMany({
+      gradingId
+    });
+    console.timeEnd("\u23F1\uFE0F deleteManyGradingRasionalization");
+    console.time("\u23F1\uFE0F deleteManyGradingComparisonItem");
+    await db.models["neu:penilaian:gradingComparisonItem"].deleteMany({
+      gradingInsertId
+    });
+    console.timeEnd("\u23F1\uFE0F deleteManyGradingComparisonItem");
+    return core.Result.ok({
+      state: "gradingCleared",
+      message: "Grading has been cleared.",
+      data: {}
+    });
+  }
+});
+async function _getGradingInsert(stream, gradingInsertId) {
+  const result = await stream.actions.data.getOne.execute(
+    {
+      model: "neu:penilaian:gradingInsert",
+      id: gradingInsertId,
+      query: query.Query.define({
+        fields: { gradingId: 1 },
+        useDeleted: true
+      })
+    },
+    stream
+  );
+  if (result.isFailure)
+    throw result;
+  else
+    return result.value;
+}
+
+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: 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 ({ 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");
+    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 acceptQuestion = operation.Action.define({
   key: "acceptQuestion",
   name: "Accept Question",
@@ -65,6 +623,45 @@ const acceptQuestion = operation.Action.define({
   }
 });
 
+const editAnswer = operation.Action.define({
+  key: "editAnswer",
+  name: "Edit Answer",
+  type: "command",
+  category: "domain",
+  execute: async (input, stream) => {
+    const dbs = stream.core.dbs;
+    const answerResult = await stream.actions.data.getOne.execute({
+      model: "Answer",
+      id: input.answerId,
+      query: query.Query.define({
+        fields: {
+          _id: 1,
+          detail: 1,
+          images: 1
+        }
+      })
+    });
+    const answer = answerResult.value;
+    const dbQuestion = dbs.tanya.models.Question;
+    const userId = stream.context.identitas.userId;
+    await dbQuestion.updateOne(
+      { finalAnswerId: answer._id },
+      {
+        $set: {
+          answeredDetail: answer.detail,
+          answeredImages: answer.images,
+          updatedAt: new Date(),
+          updatedBy: userId
+        }
+      }
+    );
+    return core.Result.ok({
+      state: "editAnswer",
+      message: "Jawaban berhasil dikirim"
+    });
+  }
+});
+
 const sendAnswer = operation.Action.define({
   key: "sendAnswer",
   name: "Send Answer",
@@ -185,210 +782,34 @@ const sendAnswer = operation.Action.define({
   }
 });
 
-const editAnswer = operation.Action.define({
-  key: "editAnswer",
-  name: "Edit Answer",
-  type: "command",
-  category: "domain",
-  execute: async (input, stream) => {
-    const dbs = stream.core.dbs;
-    const answerResult = await stream.actions.data.getOne.execute({
-      model: "Answer",
-      id: input.answerId,
-      query: query.Query.define({
-        fields: {
-          _id: 1,
-          detail: 1,
-          images: 1
-        }
-      })
-    });
-    const answer = answerResult.value;
-    const dbQuestion = dbs.tanya.models.Question;
-    const userId = stream.context.identitas.userId;
-    await dbQuestion.updateOne(
-      { finalAnswerId: answer._id },
-      {
-        $set: {
-          answeredDetail: answer.detail,
-          answeredImages: answer.images,
-          updatedAt: new Date(),
-          updatedBy: userId
-        }
-      }
-    );
-    return core.Result.ok({
-      state: "editAnswer",
-      message: "Jawaban berhasil dikirim"
-    });
-  }
-});
-
-const syncAllPenilaian = operation.Action.define({
-  key: "syncAllPenilaian",
-  name: "Sync All Penilaian",
-  type: "command",
-  category: "domain",
-  execute: async ({}, stream) => {
-    const models = [
-      "neu:penilaian:gradingComponent",
-      "neu:penilaian:gradingInsert",
-      "neu:penilaian:grading",
-      "neu:penilaian:gradingRasionalization",
-      "neu:penilaian:gradingComparator",
-      "neu:penilaian:gradingComparisonItem",
-      "neu:penilaian:gradingComparisonItem",
-      "neu:penilaian:gradingRasionalization",
-      "neu:penilaian:gradingRasionalization"
-    ];
-    await syncModels(stream, models);
-    return core.Result.ok({
-      state: "allSynced",
-      message: "All penilaian modules have been synced.",
-      data: {}
-    });
-  }
-});
-async function syncModels(stream, models) {
-  for (const model of models) {
-    await stream.actions.data.syncMany.execute(
-      {
-        model,
-        useDry: false,
-        query: query.Query.define({
-          limit: 1e5
-        })
-      },
-      stream
-    );
-  }
-}
-
-const syncCommitment = operation.Action.define({
-  key: "syncCommitment",
-  name: "Sync Commitment",
-  type: "command",
-  category: "domain",
-  execute: async (input, stream) => {
-    const dbs = stream.core.dbs;
-    const teacherResult = await stream.actions.data.getOne.execute({
-      model: "Teacher",
-      id: input.teacherId,
-      query: query.Query.define({
-        fields: {
-          _id: 1,
-          teacherCommitments: {
-            weekdays: 1,
-            startedAt: 1,
-            endedAt: 1
-          }
-        }
-      })
-    });
-    const teacher = teacherResult.value;
-    const dbCommitment = dbs.talenta.models.TeacherCommitment;
-    const dbTeacher = dbs.talenta.models.Teacher;
-    const commitment = await dbCommitment.findOne({ teacherId: teacher._id }).sort({ createdAt: -1 });
-    await dbTeacher.updateOne(
-      { _id: teacher._id },
-      {
-        $set: {
-          weekdays: commitment.weekdays,
-          hourStart: commitment.startedAt,
-          hourEnd: commitment.endedAt
-        }
-      }
-    );
-    return core.Result.ok({
-      state: "syncCommitment",
-      message: "Komitment disinkronasi!"
-    });
-  }
-});
-
-const presenceSessionStudent = operation.Action.define({
-  key: "presenceSessionStudent",
-  name: "Presence Student",
-  type: "command",
-  category: "domain",
-  execute: async (input, stream) => {
-    const dbs = stream.core.dbs;
-    const sessionResult = await stream.actions.data.getOne.execute({
-      model: "ClassSession",
-      id: input.sessionId,
-      query: query.Query.define({
-        fields: {
-          _id: 1
-        }
-      })
-    });
-    const session = sessionResult.value;
-    const dbAttendance = dbs.jadwal.models.ClassAttendance;
-    const dbStudent = dbs.siswa.models.Student;
-    const siswa = await dbStudent.findOne({
-      userId: stream.context.identitas.userId
-    });
-    await dbAttendance.create({
-      classSessionId: session._id,
-      studentId: siswa.id,
-      presenceAt: new Date(),
-      updatedAt: new Date(),
-      createdBy: stream.context.identitas.userId,
-      updatedBy: stream.context.identitas.userId
-    });
-    return core.Result.ok({
-      state: "presenceSessionStudent",
-      message: "Presensi berhasil!"
-    });
-  }
-});
-
-const presenceSessionTeacher = operation.Action.define({
-  key: "presenceSessionTeacher",
-  name: "Presence Teacher",
-  type: "command",
-  category: "domain",
-  execute: async (input, stream) => {
-    const dbs = stream.core.dbs;
-    const sessionResult = await stream.actions.data.getOne.execute({
-      model: "ClassSession",
-      id: input.sessionId,
-      query: query.Query.define({
-        fields: {
-          _id: 1
-        }
-      })
-    });
-    const session = sessionResult.value;
-    const dbAttendance = dbs.jadwal.models.ClassAttendance;
-    const dbTeacher = dbs.talenta.models.Teacher;
-    const user = stream.context.identitas.userId;
-    const pengajar = await dbTeacher.findOne({ userId: user });
-    await dbAttendance.create({
-      classSessionId: session._id,
-      teacherId: pengajar.id,
-      presenceAt: new Date(),
-      updatedAt: new Date(),
-      createdBy: user,
-      updatedBy: user
-    });
-    return core.Result.ok({
-      state: "presenceSessionTeacher",
-      message: "Presensi berhasil!"
-    });
-  }
-});
-
 const index = {
   __proto__: null,
   acceptQuestion: acceptQuestion,
+  calculateGrading: calculateGrading,
+  clearGrading: clearGrading,
+  createGradingAndScores: createGradingAndScores,
   editAnswer: editAnswer,
+  generateGrading: generateGrading,
   presenceSessionStudent: presenceSessionStudent,
   presenceSessionTeacher: presenceSessionTeacher,
+  rasionalizeGrading: rasionalizeGrading,
   sendAnswer: sendAnswer,
   setSomething: setSomething,
-  syncAllPenilaian: syncAllPenilaian,
-  syncCommitment: syncCommitment
+  syncCommitment: syncCommitment,
+  updateGradingAndScores: updateGradingAndScores
 };
 
+exports.acceptQuestion = acceptQuestion;
 exports.actions = index;
+exports.calculateGrading = calculateGrading;
+exports.clearGrading = clearGrading;
+exports.createGradingAndScores = createGradingAndScores;
+exports.editAnswer = editAnswer;
+exports.generateGrading = generateGrading;
+exports.presenceSessionStudent = presenceSessionStudent;
+exports.presenceSessionTeacher = presenceSessionTeacher;
+exports.rasionalizeGrading = rasionalizeGrading;
+exports.sendAnswer = sendAnswer;
+exports.setSomething = setSomething;
+exports.syncCommitment = syncCommitment;
+exports.updateGradingAndScores = updateGradingAndScores;