@neutron.co.id/pendidikan-operation 1.26.5 → 1.26.7

package/build/actions/akademik/action.presenceSessionStudent.cjs

@@ -34,7 +34,7 @@ const presenceSessionStudent = operation.Action.define({
         data: {
           classSessionId: input.sessionId,
           studentId: input.studentId,
-          teacherId: input.teacherId,
+          // teacherId: input.teacherId,
           classSessionBranchIds: session.branchIds,
           presenceType: "student",
           isAbsent: false,

package/build/actions/akademik/action.presenceSessionStudent.mjs

@@ -32,7 +32,7 @@ const presenceSessionStudent = Action.define({
         data: {
           classSessionId: input.sessionId,
           studentId: input.studentId,
-          teacherId: input.teacherId,
+          // teacherId: input.teacherId,
           classSessionBranchIds: session.branchIds,
           presenceType: "student",
           isAbsent: false,

package/build/actions/akademik/index.d.ts

@@ -9,3 +9,4 @@ export * from './action.syncStudentAdmisi';
 export * from './action.getStudentPoint';
 export * from './action.getTeacherPoint';
 export * from './action.getStaffPoint';
+export * from './studentReport';

package/build/actions/akademik/studentReport/index.d.ts

@@ -0,0 +1,2 @@
+export * from './syncStudentReport.action';
+export * from './syncStudentReport.schema';

package/build/actions/akademik/studentReport/syncStudentReport.action.cjs

@@ -0,0 +1,310 @@
+'use strict';
+
+const core = require('@neon.id/core');
+const operation = require('@neon.id/operation');
+const utils = require('@neon.id/utils');
+const query = require('@neon.id/query');
+
+const syncStudentReport = operation.Action.define({
+  key: "syncStudentReport",
+  name: "Sync Student Report",
+  type: "command",
+  category: "domain",
+  execute: async (input, stream) => {
+    utils.guard(stream, "streamRequired");
+    utils.guard(input, "inputRequired");
+    const dbs = stream.core.dbs;
+    const dbStudent = dbs["neu-akademik"].models["neu:akademik:student"];
+    const dbAttendance = dbs["neu-jadwal"].models["neu:jadwal:classAttendance"];
+    const dbConsultation = dbs["neu-jadwal"].models["neu:jadwal:classConsultation"];
+    const dbQuestion = dbs["neu-tanya"].models["neu:tanya:question"];
+    const dbCheckIn = dbs["neu-tempat"].models["neu:tempat:checkIn"];
+    const dbGrading = dbs["neu-penilaian"].models["neu:penilaian:grading"];
+    const resultGrading = await dbGrading.find({
+      studentId: input.studentId,
+      createdAt: {
+        $gte: input.startedAt,
+        $lte: input.endedAt
+      },
+      deletedAt: { $exists: false }
+    }).sort({ createdAt: -1 });
+    const gradingCount = resultGrading.length;
+    if (resultGrading.length > 0) {
+      await dbStudent.updateOne(
+        { _id: input.studentId },
+        {
+          $set: {
+            totalGrading: gradingCount
+          }
+        }
+      );
+    } else {
+      await dbStudent.updateOne(
+        { _id: input.studentId },
+        {
+          $set: {
+            totalGrading: gradingCount
+          }
+        }
+      );
+    }
+    const resultAttendance = await dbAttendance.find({
+      studentId: input.studentId,
+      createdAt: {
+        $gte: input.startedAt,
+        $lte: input.endedAt
+      },
+      // isAbsent: { $exists: false, $ne: true },
+      deletedAt: { $exists: false }
+    }).sort({ createdAt: -1 });
+    const attendanceCount = resultAttendance.length;
+    const attendanceOffline = resultAttendance.filter((field) => field?.sessionType === "offline");
+    const totalAttendanceOffline = attendanceOffline.length;
+    const attendanceOnline = resultAttendance.filter((field) => field?.sessionType === "online");
+    const totalAttendanceOnline = attendanceOnline.length;
+    if (resultAttendance.length > 0) {
+      await dbStudent.updateOne(
+        { _id: input.studentId },
+        {
+          $set: {
+            totalAttendance: attendanceCount,
+            attendanceOffline: totalAttendanceOffline,
+            attendanceOnline: totalAttendanceOnline
+          }
+        }
+      );
+    } else {
+      await dbStudent.updateOne(
+        { _id: input.studentId },
+        {
+          $set: {
+            totalAttendance: attendanceCount,
+            attendanceOffline: totalAttendanceOffline,
+            attendanceOnline: totalAttendanceOnline
+          }
+        }
+      );
+    }
+    const resultCheckIn = await dbCheckIn.find({
+      studentId: input.studentId,
+      checkInAt: {
+        $gte: input.startedAt,
+        $lte: input.endedAt
+      },
+      deletedAt: { $exists: false }
+    }).sort({ createdAt: -1 });
+    const checkInCount = resultCheckIn.length;
+    if (resultCheckIn.length > 0) {
+      await dbStudent.updateOne(
+        { _id: input.studentId },
+        {
+          $set: {
+            totalCheckin: checkInCount
+          }
+        }
+      );
+    } else {
+      await dbStudent.updateOne(
+        { _id: input.studentId },
+        {
+          $set: {
+            totalCheckin: checkInCount
+          }
+        }
+      );
+    }
+    const resultConsultation = await dbConsultation.find({
+      studentIds: { $in: input.studentId },
+      branchId: { $in: input.branchIds },
+      createdAt: {
+        $gte: input.startedAt,
+        $lte: input.endedAt
+      },
+      deletedAt: { $exists: false }
+    });
+    const consultationCount = resultConsultation.length;
+    if (resultConsultation.length > 0) {
+      await dbStudent.updateOne(
+        { _id: input.studentId },
+        {
+          $set: {
+            totalConsultation: consultationCount
+          }
+        }
+      );
+    } else {
+      await dbStudent.updateOne(
+        { _id: input.studentId },
+        {
+          $set: {
+            totalConsultation: consultationCount
+          }
+        }
+      );
+    }
+    const resultQuestion = await dbQuestion.find({
+      studentId: input.studentId,
+      branchIds: { $in: input.branchIds },
+      createdAt: {
+        $gte: input.startedAt,
+        $lte: input.endedAt
+      },
+      deletedAt: { $exists: false }
+    }).sort({ createdAt: -1 });
+    const questionCount = resultQuestion.length;
+    if (resultQuestion.length > 0) {
+      await dbStudent.updateOne(
+        { _id: input.studentId },
+        {
+          $set: {
+            totalQuestion: questionCount
+          }
+        }
+      );
+    } else {
+      await dbStudent.updateOne(
+        { _id: input.studentId },
+        {
+          $set: {
+            totalQuestion: questionCount
+          }
+        }
+      );
+    }
+    const resultSession = await stream.actions.data.count.execute({
+      model: "neu:jadwal:classSession",
+      query: query.Query.define({
+        filter: {
+          startedAt: { $gte: input.startedAt, $lte: input.endedAt },
+          branchIds: { $in: input.branchIds },
+          studentIds: { $in: [input.studentId] }
+        }
+      })
+    }, stream);
+    const sessionCount = resultSession.payload?.data?.total || 0;
+    const resultSchedule = await stream.actions.data.getMany.execute({
+      model: "neu:jadwal:classSession",
+      query: query.Query.define({
+        filter: {
+          startedAt: { $gte: input.startedAt, $lte: input.endedAt },
+          branchIds: { $in: input.branchIds },
+          studentIds: { $in: [input.studentId] }
+        },
+        fields: {
+          id: 1,
+          createdAt: 1,
+          startedAt: 1
+        }
+      })
+    }, stream);
+    const startedDates = resultSchedule?.payload?.data?.map((item) => {
+      return utils.DateUtil.format(new Date(item.startedAt), { format: "yyyy-MM-dd" });
+    });
+    const uniqueDays = new Set(startedDates);
+    const scheduleCount = uniqueDays.size;
+    const sessionOffline = await stream.actions.data.count.execute({
+      model: "neu:jadwal:classSession",
+      query: query.Query.define({
+        filter: {
+          startedAt: { $gte: input.startedAt, $lte: input.endedAt },
+          branchIds: { $in: input.branchIds },
+          studentIds: { $in: [input.studentId] },
+          type: "offline"
+        }
+      })
+    }, stream);
+    const totalOffline = sessionOffline.payload?.data?.total || 0;
+    const sessionOnline = await stream.actions.data.count.execute({
+      model: "neu:jadwal:classSession",
+      query: query.Query.define({
+        filter: {
+          startedAt: { $gte: input.startedAt, $lte: input.endedAt },
+          branchIds: { $in: input.branchIds },
+          studentIds: { $in: [input.studentId] },
+          type: "online"
+        }
+      })
+    }, stream);
+    const totalOnline = sessionOnline.payload?.data?.total || 0;
+    const sessionHybrid = await stream.actions.data.count.execute({
+      model: "neu:jadwal:classSession",
+      query: query.Query.define({
+        filter: {
+          startedAt: { $gte: input.startedAt, $lte: input.endedAt },
+          branchIds: { $in: input.branchIds },
+          studentIds: { $in: [input.studentId] },
+          type: "hybrid"
+        }
+      })
+    }, stream);
+    const totalHybrid = sessionHybrid.payload?.data?.total || 0;
+    if (sessionCount > 0) {
+      await dbStudent.updateOne(
+        { _id: input.studentId },
+        {
+          $set: {
+            totalSession: sessionCount,
+            sessionOffline: totalOffline,
+            sessionOnline: totalOnline,
+            sessionHybrid: totalHybrid,
+            daySession: scheduleCount
+          }
+        }
+      );
+    } else {
+      await dbStudent.updateOne(
+        { _id: input.studentId },
+        {
+          $set: {
+            totalSession: sessionCount,
+            sessionOffline: totalOffline,
+            sessionOnline: totalOnline,
+            sessionHybrid: totalHybrid,
+            daySession: scheduleCount
+          }
+        }
+      );
+    }
+    const activityResult = await stream.actions.data.count.execute({
+      model: "neu:jadwal:classActivity",
+      query: query.Query.define({
+        filter: {
+          studentId: input.studentId,
+          createdAt: {
+            $gte: input.startedAt,
+            $lte: input.endedAt
+          }
+        }
+      })
+    }, stream);
+    const totalActivities = activityResult.payload?.data?.total || 0;
+    if (sessionCount > 0) {
+      await dbStudent.updateOne(
+        { _id: input.studentId },
+        {
+          $set: {
+            totalActivity: totalActivities
+          }
+        }
+      );
+    } else {
+      await dbStudent.updateOne(
+        { _id: input.studentId },
+        {
+          $set: {
+            totalActivity: totalActivities
+          }
+        }
+      );
+    }
+    return core.Result.ok({
+      state: "studentReportSync",
+      message: "Student Report has been sync.",
+      data: {
+        code: 1
+      }
+    });
+  }
+});
+
+exports.syncStudentReport = syncStudentReport;

package/build/actions/akademik/studentReport/syncStudentReport.action.d.ts

@@ -0,0 +1,16 @@
+import { Action } from '@neon.id/operation';
+import type { z } from '@neon.id/z';
+import type { StudentReportSchema } from './syncStudentReport.schema';
+export type SyncStudentReportInput = z.parse<typeof StudentReportSchema>;
+export interface SyncStudentReportOutput {
+    code: number;
+}
+export interface SyncStudentReportMeta {
+}
+export declare const syncStudentReport: Action<"syncStudentReport", {
+    branchIds?: string[] | undefined;
+    studentId?: string | undefined;
+    startedAt?: string | undefined;
+    endedAt?: string | undefined;
+}, SyncStudentReportOutput, SyncStudentReportMeta>;
+export type SyncStudentReportAction = typeof syncStudentReport;

package/build/actions/akademik/studentReport/syncStudentReport.action.mjs

@@ -0,0 +1,308 @@
+import { Result } from '@neon.id/core';
+import { Action } from '@neon.id/operation';
+import { guard, DateUtil } from '@neon.id/utils';
+import { Query } from '@neon.id/query';
+
+const syncStudentReport = Action.define({
+  key: "syncStudentReport",
+  name: "Sync Student Report",
+  type: "command",
+  category: "domain",
+  execute: async (input, stream) => {
+    guard(stream, "streamRequired");
+    guard(input, "inputRequired");
+    const dbs = stream.core.dbs;
+    const dbStudent = dbs["neu-akademik"].models["neu:akademik:student"];
+    const dbAttendance = dbs["neu-jadwal"].models["neu:jadwal:classAttendance"];
+    const dbConsultation = dbs["neu-jadwal"].models["neu:jadwal:classConsultation"];
+    const dbQuestion = dbs["neu-tanya"].models["neu:tanya:question"];
+    const dbCheckIn = dbs["neu-tempat"].models["neu:tempat:checkIn"];
+    const dbGrading = dbs["neu-penilaian"].models["neu:penilaian:grading"];
+    const resultGrading = await dbGrading.find({
+      studentId: input.studentId,
+      createdAt: {
+        $gte: input.startedAt,
+        $lte: input.endedAt
+      },
+      deletedAt: { $exists: false }
+    }).sort({ createdAt: -1 });
+    const gradingCount = resultGrading.length;
+    if (resultGrading.length > 0) {
+      await dbStudent.updateOne(
+        { _id: input.studentId },
+        {
+          $set: {
+            totalGrading: gradingCount
+          }
+        }
+      );
+    } else {
+      await dbStudent.updateOne(
+        { _id: input.studentId },
+        {
+          $set: {
+            totalGrading: gradingCount
+          }
+        }
+      );
+    }
+    const resultAttendance = await dbAttendance.find({
+      studentId: input.studentId,
+      createdAt: {
+        $gte: input.startedAt,
+        $lte: input.endedAt
+      },
+      // isAbsent: { $exists: false, $ne: true },
+      deletedAt: { $exists: false }
+    }).sort({ createdAt: -1 });
+    const attendanceCount = resultAttendance.length;
+    const attendanceOffline = resultAttendance.filter((field) => field?.sessionType === "offline");
+    const totalAttendanceOffline = attendanceOffline.length;
+    const attendanceOnline = resultAttendance.filter((field) => field?.sessionType === "online");
+    const totalAttendanceOnline = attendanceOnline.length;
+    if (resultAttendance.length > 0) {
+      await dbStudent.updateOne(
+        { _id: input.studentId },
+        {
+          $set: {
+            totalAttendance: attendanceCount,
+            attendanceOffline: totalAttendanceOffline,
+            attendanceOnline: totalAttendanceOnline
+          }
+        }
+      );
+    } else {
+      await dbStudent.updateOne(
+        { _id: input.studentId },
+        {
+          $set: {
+            totalAttendance: attendanceCount,
+            attendanceOffline: totalAttendanceOffline,
+            attendanceOnline: totalAttendanceOnline
+          }
+        }
+      );
+    }
+    const resultCheckIn = await dbCheckIn.find({
+      studentId: input.studentId,
+      checkInAt: {
+        $gte: input.startedAt,
+        $lte: input.endedAt
+      },
+      deletedAt: { $exists: false }
+    }).sort({ createdAt: -1 });
+    const checkInCount = resultCheckIn.length;
+    if (resultCheckIn.length > 0) {
+      await dbStudent.updateOne(
+        { _id: input.studentId },
+        {
+          $set: {
+            totalCheckin: checkInCount
+          }
+        }
+      );
+    } else {
+      await dbStudent.updateOne(
+        { _id: input.studentId },
+        {
+          $set: {
+            totalCheckin: checkInCount
+          }
+        }
+      );
+    }
+    const resultConsultation = await dbConsultation.find({
+      studentIds: { $in: input.studentId },
+      branchId: { $in: input.branchIds },
+      createdAt: {
+        $gte: input.startedAt,
+        $lte: input.endedAt
+      },
+      deletedAt: { $exists: false }
+    });
+    const consultationCount = resultConsultation.length;
+    if (resultConsultation.length > 0) {
+      await dbStudent.updateOne(
+        { _id: input.studentId },
+        {
+          $set: {
+            totalConsultation: consultationCount
+          }
+        }
+      );
+    } else {
+      await dbStudent.updateOne(
+        { _id: input.studentId },
+        {
+          $set: {
+            totalConsultation: consultationCount
+          }
+        }
+      );
+    }
+    const resultQuestion = await dbQuestion.find({
+      studentId: input.studentId,
+      branchIds: { $in: input.branchIds },
+      createdAt: {
+        $gte: input.startedAt,
+        $lte: input.endedAt
+      },
+      deletedAt: { $exists: false }
+    }).sort({ createdAt: -1 });
+    const questionCount = resultQuestion.length;
+    if (resultQuestion.length > 0) {
+      await dbStudent.updateOne(
+        { _id: input.studentId },
+        {
+          $set: {
+            totalQuestion: questionCount
+          }
+        }
+      );
+    } else {
+      await dbStudent.updateOne(
+        { _id: input.studentId },
+        {
+          $set: {
+            totalQuestion: questionCount
+          }
+        }
+      );
+    }
+    const resultSession = await stream.actions.data.count.execute({
+      model: "neu:jadwal:classSession",
+      query: Query.define({
+        filter: {
+          startedAt: { $gte: input.startedAt, $lte: input.endedAt },
+          branchIds: { $in: input.branchIds },
+          studentIds: { $in: [input.studentId] }
+        }
+      })
+    }, stream);
+    const sessionCount = resultSession.payload?.data?.total || 0;
+    const resultSchedule = await stream.actions.data.getMany.execute({
+      model: "neu:jadwal:classSession",
+      query: Query.define({
+        filter: {
+          startedAt: { $gte: input.startedAt, $lte: input.endedAt },
+          branchIds: { $in: input.branchIds },
+          studentIds: { $in: [input.studentId] }
+        },
+        fields: {
+          id: 1,
+          createdAt: 1,
+          startedAt: 1
+        }
+      })
+    }, stream);
+    const startedDates = resultSchedule?.payload?.data?.map((item) => {
+      return DateUtil.format(new Date(item.startedAt), { format: "yyyy-MM-dd" });
+    });
+    const uniqueDays = new Set(startedDates);
+    const scheduleCount = uniqueDays.size;
+    const sessionOffline = await stream.actions.data.count.execute({
+      model: "neu:jadwal:classSession",
+      query: Query.define({
+        filter: {
+          startedAt: { $gte: input.startedAt, $lte: input.endedAt },
+          branchIds: { $in: input.branchIds },
+          studentIds: { $in: [input.studentId] },
+          type: "offline"
+        }
+      })
+    }, stream);
+    const totalOffline = sessionOffline.payload?.data?.total || 0;
+    const sessionOnline = await stream.actions.data.count.execute({
+      model: "neu:jadwal:classSession",
+      query: Query.define({
+        filter: {
+          startedAt: { $gte: input.startedAt, $lte: input.endedAt },
+          branchIds: { $in: input.branchIds },
+          studentIds: { $in: [input.studentId] },
+          type: "online"
+        }
+      })
+    }, stream);
+    const totalOnline = sessionOnline.payload?.data?.total || 0;
+    const sessionHybrid = await stream.actions.data.count.execute({
+      model: "neu:jadwal:classSession",
+      query: Query.define({
+        filter: {
+          startedAt: { $gte: input.startedAt, $lte: input.endedAt },
+          branchIds: { $in: input.branchIds },
+          studentIds: { $in: [input.studentId] },
+          type: "hybrid"
+        }
+      })
+    }, stream);
+    const totalHybrid = sessionHybrid.payload?.data?.total || 0;
+    if (sessionCount > 0) {
+      await dbStudent.updateOne(
+        { _id: input.studentId },
+        {
+          $set: {
+            totalSession: sessionCount,
+            sessionOffline: totalOffline,
+            sessionOnline: totalOnline,
+            sessionHybrid: totalHybrid,
+            daySession: scheduleCount
+          }
+        }
+      );
+    } else {
+      await dbStudent.updateOne(
+        { _id: input.studentId },
+        {
+          $set: {
+            totalSession: sessionCount,
+            sessionOffline: totalOffline,
+            sessionOnline: totalOnline,
+            sessionHybrid: totalHybrid,
+            daySession: scheduleCount
+          }
+        }
+      );
+    }
+    const activityResult = await stream.actions.data.count.execute({
+      model: "neu:jadwal:classActivity",
+      query: Query.define({
+        filter: {
+          studentId: input.studentId,
+          createdAt: {
+            $gte: input.startedAt,
+            $lte: input.endedAt
+          }
+        }
+      })
+    }, stream);
+    const totalActivities = activityResult.payload?.data?.total || 0;
+    if (sessionCount > 0) {
+      await dbStudent.updateOne(
+        { _id: input.studentId },
+        {
+          $set: {
+            totalActivity: totalActivities
+          }
+        }
+      );
+    } else {
+      await dbStudent.updateOne(
+        { _id: input.studentId },
+        {
+          $set: {
+            totalActivity: totalActivities
+          }
+        }
+      );
+    }
+    return Result.ok({
+      state: "studentReportSync",
+      message: "Student Report has been sync.",
+      data: {
+        code: 1
+      }
+    });
+  }
+});
+
+export { syncStudentReport };

package/build/actions/akademik/studentReport/syncStudentReport.schema.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+const z = require('@neon.id/z');
+
+const StudentReportSchema = z.z.object({
+  studentId: z.z.string().optional().explain({ label: "Student ID" }),
+  branchIds: z.z.array(z.z.string()).optional().explain({
+    label: "Branch IDs"
+  }),
+  startedAt: z.z.string().datetime().optional().explain({ label: "Started At" }),
+  endedAt: z.z.string().datetime().optional().explain({ label: "Ended At" })
+});
+
+exports.StudentReportSchema = StudentReportSchema;

package/build/actions/akademik/studentReport/syncStudentReport.schema.d.ts

@@ -0,0 +1,17 @@
+import { z } from '@neon.id/z';
+export declare const StudentReportSchema: z.ZodObject<{
+    studentId: z.ZodOptional<z.ZodString>;
+    branchIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    startedAt: z.ZodOptional<z.ZodString>;
+    endedAt: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    branchIds?: string[] | undefined;
+    studentId?: string | undefined;
+    startedAt?: string | undefined;
+    endedAt?: string | undefined;
+}, {
+    branchIds?: string[] | undefined;
+    studentId?: string | undefined;
+    startedAt?: string | undefined;
+    endedAt?: string | undefined;
+}>;