@neutron.co.id/pendidikan-operation 1.27.9 → 1.27.12

package/build/actions/importData/importData.action.cjs

@@ -21,12 +21,19 @@ const importData = operation.Action.define({
       data
     }, async () => {
       const { getActorId } = operation.useStream(stream);
-      const { prepareGradingMapper } = useImportData.useImportData(stream);
+      const { prepareGradingMapper, prepareClassSessionMapper } = useImportData.useImportData(stream);
       try {
         getActorId({ throw: true });
-        await prepareGradingMapper(stream, {
-          datas: data?.csvData
-        });
+        if (data?.type === "classSession") {
+          await prepareClassSessionMapper(stream, {
+            datas: data?.csvData,
+            classGroupName: data?.classGroupName
+          });
+        } else {
+          await prepareGradingMapper(stream, {
+            datas: data?.csvData
+          });
+        }
         return core.Result.ok({
           state: "importData",
           message: "Import Data has been sucessfully executed. CSV has been processed on background.",

package/build/actions/importData/importData.action.d.ts

@@ -7,6 +7,8 @@ export interface ImportDataOutput {
 export interface ImportDataMeta {
 }
 export declare const importData: Action<"importData", {
+    type: string;
     csvData?: any[] | undefined;
+    classGroupName?: string | undefined;
 }, ImportDataOutput, ImportDataMeta>;
 export type ImportDataAction = typeof importData;

package/build/actions/importData/importData.action.mjs

@@ -19,12 +19,19 @@ const importData = Action.define({
       data
     }, async () => {
       const { getActorId } = useStream(stream);
-      const { prepareGradingMapper } = useImportData(stream);
+      const { prepareGradingMapper, prepareClassSessionMapper } = useImportData(stream);
       try {
         getActorId({ throw: true });
-        await prepareGradingMapper(stream, {
-          datas: data?.csvData
-        });
+        if (data?.type === "classSession") {
+          await prepareClassSessionMapper(stream, {
+            datas: data?.csvData,
+            classGroupName: data?.classGroupName
+          });
+        } else {
+          await prepareGradingMapper(stream, {
+            datas: data?.csvData
+          });
+        }
         return Result.ok({
           state: "importData",
           message: "Import Data has been sucessfully executed. CSV has been processed on background.",

package/build/actions/importData/importData.schema.cjs

@@ -3,7 +3,9 @@
 const z = require('@neon.id/z');
 
 const ImportDataSchema = z.z.object({
-  csvData: z.z.array(z.z.any()).optional().explain({ label: "Data" })
+  csvData: z.z.array(z.z.any()).optional().explain({ label: "Data" }),
+  classGroupName: z.z.string().optional(),
+  type: z.z.string().default("grading")
 });
 
 exports.ImportDataSchema = ImportDataSchema;

package/build/actions/importData/importData.schema.d.ts

@@ -1,8 +1,14 @@
 import { z } from '@neon.id/z';
 export declare const ImportDataSchema: z.ZodObject<{
     csvData: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+    classGroupName: z.ZodOptional<z.ZodString>;
+    type: z.ZodDefault<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
+    type: string;
     csvData?: any[] | undefined;
+    classGroupName?: string | undefined;
 }, {
+    type?: string | undefined;
     csvData?: any[] | undefined;
+    classGroupName?: string | undefined;
 }>;

package/build/actions/importData/importData.schema.mjs

@@ -1,7 +1,9 @@
 import { z } from '@neon.id/z';
 
 const ImportDataSchema = z.object({
-  csvData: z.array(z.any()).optional().explain({ label: "Data" })
+  csvData: z.array(z.any()).optional().explain({ label: "Data" }),
+  classGroupName: z.string().optional(),
+  type: z.string().default("grading")
 });
 
 export { ImportDataSchema };

package/build/actions/jadwal/action.bulkDeleteSession.cjs

@@ -0,0 +1,43 @@
+'use strict';
+
+const core = require('@neon.id/core');
+const operation = require('@neon.id/operation');
+const utils = require('@neon.id/utils');
+const useTelemetry = require('../../providers/useTelemetry.cjs');
+
+const bulkDeleteSession = operation.Action.define({
+  key: "bulkDeleteSession",
+  name: "Bulk Delete Session",
+  type: "command",
+  category: "domain",
+  execute: async (input, stream) => {
+    utils.guard(stream, "streamRequired");
+    utils.guard(input, "inputRequired");
+    return useTelemetry.useTelemetry(stream, "bulkDeleteSession", {
+      userId: stream.context.identitas.userId,
+      ...input
+    }, async () => {
+      const dbs = stream.core.dbs;
+      const dbSession = dbs["neu-jadwal"].models["neu:jadwal:classSession"];
+      await dbSession.updateMany(
+        {
+          _id: { $in: input.ids }
+        },
+        {
+          $set: {
+            deletedAt: /* @__PURE__ */ new Date()
+          }
+        }
+      );
+      return core.Result.ok({
+        state: "bulkSessionDelete",
+        message: "Sessions have been deleted.",
+        data: {
+          code: 1
+        }
+      });
+    });
+  }
+});
+
+exports.bulkDeleteSession = bulkDeleteSession;

package/build/actions/jadwal/action.bulkDeleteSession.d.ts

@@ -0,0 +1,11 @@
+import { Action } from '@neon.id/operation';
+export interface BulkDeleteSessionInput {
+    ids: string[];
+}
+export interface BulkDeleteSessionOutput {
+    code: number;
+}
+export interface BulkDeleteSessionMeta {
+}
+export declare const bulkDeleteSession: Action<"bulkDeleteSession", BulkDeleteSessionInput, BulkDeleteSessionOutput, BulkDeleteSessionMeta>;
+export type BulkDeleteSessionAction = typeof bulkDeleteSession;

package/build/actions/jadwal/action.bulkDeleteSession.mjs

@@ -0,0 +1,41 @@
+import { Result } from '@neon.id/core';
+import { Action } from '@neon.id/operation';
+import { guard } from '@neon.id/utils';
+import { useTelemetry } from '../../providers/useTelemetry.mjs';
+
+const bulkDeleteSession = Action.define({
+  key: "bulkDeleteSession",
+  name: "Bulk Delete Session",
+  type: "command",
+  category: "domain",
+  execute: async (input, stream) => {
+    guard(stream, "streamRequired");
+    guard(input, "inputRequired");
+    return useTelemetry(stream, "bulkDeleteSession", {
+      userId: stream.context.identitas.userId,
+      ...input
+    }, async () => {
+      const dbs = stream.core.dbs;
+      const dbSession = dbs["neu-jadwal"].models["neu:jadwal:classSession"];
+      await dbSession.updateMany(
+        {
+          _id: { $in: input.ids }
+        },
+        {
+          $set: {
+            deletedAt: /* @__PURE__ */ new Date()
+          }
+        }
+      );
+      return Result.ok({
+        state: "bulkSessionDelete",
+        message: "Sessions have been deleted.",
+        data: {
+          code: 1
+        }
+      });
+    });
+  }
+});
+
+export { bulkDeleteSession };

package/build/actions/jadwal/action.bulkUpdateSession.cjs

@@ -0,0 +1,56 @@
+'use strict';
+
+const core = require('@neon.id/core');
+const operation = require('@neon.id/operation');
+const utils = require('@neon.id/utils');
+const useTelemetry = require('../../providers/useTelemetry.cjs');
+
+const bulkUpdateSession = operation.Action.define({
+  key: "bulkUpdateSession",
+  name: "Bulk Update Session",
+  type: "command",
+  category: "domain",
+  execute: async (input, stream) => {
+    utils.guard(stream, "streamRequired");
+    utils.guard(input, "inputRequired");
+    return useTelemetry.useTelemetry(stream, "bulkUpdateSession", {
+      userId: stream.context.identitas.userId,
+      ...input
+    }, async () => {
+      const dbs = stream.core.dbs;
+      const dbSession = dbs["neu-jadwal"].models["neu:jadwal:classSession"];
+      const updateData = {};
+      if (input.data.teacherRepeaterIds)
+        updateData.teacherIds = input.data.teacherRepeaterIds;
+      if (input.data.teacherIds)
+        updateData.teacherIds = input.data.teacherIds;
+      if (input.data.subjectIds)
+        updateData.subjectIds = input.data.subjectIds;
+      if (input.data.roomId)
+        updateData.roomId = input.data.roomId;
+      if (input.data.buildingId)
+        updateData.buildingId = input.data.buildingId;
+      if (input.data.status)
+        updateData.status = input.data.status;
+      if (input.data.classSessionPurposeId)
+        updateData.classSessionPurposeId = input.data.classSessionPurposeId;
+      await dbSession.updateMany(
+        {
+          _id: { $in: input.ids }
+        },
+        {
+          $set: updateData
+        }
+      );
+      return core.Result.ok({
+        state: "bulkSessionUpdate",
+        message: "Sessions have been updated.",
+        data: {
+          code: 1
+        }
+      });
+    });
+  }
+});
+
+exports.bulkUpdateSession = bulkUpdateSession;

package/build/actions/jadwal/action.bulkUpdateSession.d.ts

@@ -0,0 +1,20 @@
+import { Action } from '@neon.id/operation';
+export interface BulkUpdateSessionInput {
+    ids: string[];
+    data: {
+        teacherRepeaterIds?: string[];
+        teacherIds?: string[];
+        subjectIds?: string[];
+        roomId?: string;
+        buildingId?: string;
+        status?: string;
+        classSessionPurposeId?: string;
+    };
+}
+export interface BulkUpdateSessionOutput {
+    code: number;
+}
+export interface BulkUpdateSessionMeta {
+}
+export declare const bulkUpdateSession: Action<"bulkUpdateSession", BulkUpdateSessionInput, BulkUpdateSessionOutput, BulkUpdateSessionMeta>;
+export type BulkUpdateSessionAction = typeof bulkUpdateSession;

package/build/actions/jadwal/action.bulkUpdateSession.mjs

@@ -0,0 +1,54 @@
+import { Result } from '@neon.id/core';
+import { Action } from '@neon.id/operation';
+import { guard } from '@neon.id/utils';
+import { useTelemetry } from '../../providers/useTelemetry.mjs';
+
+const bulkUpdateSession = Action.define({
+  key: "bulkUpdateSession",
+  name: "Bulk Update Session",
+  type: "command",
+  category: "domain",
+  execute: async (input, stream) => {
+    guard(stream, "streamRequired");
+    guard(input, "inputRequired");
+    return useTelemetry(stream, "bulkUpdateSession", {
+      userId: stream.context.identitas.userId,
+      ...input
+    }, async () => {
+      const dbs = stream.core.dbs;
+      const dbSession = dbs["neu-jadwal"].models["neu:jadwal:classSession"];
+      const updateData = {};
+      if (input.data.teacherRepeaterIds)
+        updateData.teacherIds = input.data.teacherRepeaterIds;
+      if (input.data.teacherIds)
+        updateData.teacherIds = input.data.teacherIds;
+      if (input.data.subjectIds)
+        updateData.subjectIds = input.data.subjectIds;
+      if (input.data.roomId)
+        updateData.roomId = input.data.roomId;
+      if (input.data.buildingId)
+        updateData.buildingId = input.data.buildingId;
+      if (input.data.status)
+        updateData.status = input.data.status;
+      if (input.data.classSessionPurposeId)
+        updateData.classSessionPurposeId = input.data.classSessionPurposeId;
+      await dbSession.updateMany(
+        {
+          _id: { $in: input.ids }
+        },
+        {
+          $set: updateData
+        }
+      );
+      return Result.ok({
+        state: "bulkSessionUpdate",
+        message: "Sessions have been updated.",
+        data: {
+          code: 1
+        }
+      });
+    });
+  }
+});
+
+export { bulkUpdateSession };

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

@@ -14,3 +14,5 @@ export * from './action.customSaveOneClassSession';
 export * from './syncClassGroups';
 export * from './sendClassConsultationNotification';
 export * from './sendClassSessionNotification';
+export * from './action.bulkDeleteSession';
+export * from './action.bulkUpdateSession';

package/build/index.cjs

@@ -30,6 +30,8 @@ const setAksesModulSiswaDiClassGroup_action = require('./actions/jadwal/setAkses
 const getClassSessionConflicts_action = require('./actions/jadwal/getClassSessionConflicts/getClassSessionConflicts.action.cjs');
 const setTravelWageSessions_action = require('./actions/jadwal/setTravelWageSessions/setTravelWageSessions.action.cjs');
 const action_customSaveOneClassSession = require('./actions/jadwal/action.customSaveOneClassSession.cjs');
+const action_bulkDeleteSession = require('./actions/jadwal/action.bulkDeleteSession.cjs');
+const action_bulkUpdateSession = require('./actions/jadwal/action.bulkUpdateSession.cjs');
 const action_getGradingCount = require('./actions/penilaian/getGradingCount/action.getGradingCount.cjs');
 const refreshGrading_action = require('./actions/penilaian/refreshGrading/refreshGrading.action.cjs');
 const refreshManyGrading_action = require('./actions/penilaian/refreshManyGrading/refreshManyGrading.action.cjs');
@@ -118,6 +120,8 @@ const actions = {
   getClassSessionConflicts: getClassSessionConflicts_action.getClassSessionConflicts,
   setTravelWageSessions: setTravelWageSessions_action.setTravelWageSessions,
   customSaveOneClassSession: action_customSaveOneClassSession.customSaveOneClassSession,
+  bulkDeleteSession: action_bulkDeleteSession.bulkDeleteSession,
+  bulkUpdateSession: action_bulkUpdateSession.bulkUpdateSession,
   // Penilaian
   getGradingCount: action_getGradingCount.getGradingCount,
   refreshGrading: refreshGrading_action.refreshGrading,
@@ -184,6 +188,8 @@ exports.setAksesModulSiswaDiClassGroup = setAksesModulSiswaDiClassGroup_action.s
 exports.getClassSessionConflicts = getClassSessionConflicts_action.getClassSessionConflicts;
 exports.setTravelWageSessions = setTravelWageSessions_action.setTravelWageSessions;
 exports.customSaveOneClassSession = action_customSaveOneClassSession.customSaveOneClassSession;
+exports.bulkDeleteSession = action_bulkDeleteSession.bulkDeleteSession;
+exports.bulkUpdateSession = action_bulkUpdateSession.bulkUpdateSession;
 exports.getGradingCount = action_getGradingCount.getGradingCount;
 exports.refreshGrading = refreshGrading_action.refreshGrading;
 exports.refreshManyGrading = refreshManyGrading_action.refreshManyGrading;

package/build/index.d.ts

@@ -78,6 +78,8 @@ export declare const actions: {
         classSessionIds?: string[] | undefined;
     }, import("./actions").SetTravelWageSessionsOutput, import("./actions").SetTravelWageSessionsMeta>;
     customSaveOneClassSession: import("@neon.id/operation").Action<"customSaveOneClassSession", import("./actions").CustomSaveOneClassSessionInput, import("./actions").CustomSaveOneClassSessionOutput, import("./actions").CustomSaveOneClassSessionMeta>;
+    bulkDeleteSession: import("@neon.id/operation").Action<"bulkDeleteSession", import("./actions").BulkDeleteSessionInput, import("./actions").BulkDeleteSessionOutput, import("./actions").BulkDeleteSessionMeta>;
+    bulkUpdateSession: import("@neon.id/operation").Action<"bulkUpdateSession", import("./actions").BulkUpdateSessionInput, import("./actions").BulkUpdateSessionOutput, import("./actions").BulkUpdateSessionMeta>;
     getGradingCount: import("@neon.id/operation").Action<"getGradingCount", import("./actions").GetGradingCountInput, import("./actions").GetGradingCountOutput, import("./actions").GetGradingCountMeta>;
     refreshGrading: import("@neon.id/operation").Action<"refreshGrading", {
         gradingId?: string | undefined;
@@ -108,7 +110,9 @@ export declare const actions: {
         eventId?: string | undefined;
     }, import("./actions").PrepareMediaScanterGradingInsertOutput, import("./actions").PrepareMediaScanterGradingInsertMeta>;
     importData: import("@neon.id/operation").Action<"importData", {
+        type: string;
         csvData?: any[] | undefined;
+        classGroupName?: string | undefined;
     }, import("./actions").ImportDataOutput, import("./actions").ImportDataMeta>;
     updateReportStudent: import("@neon.id/operation").Action<"updateReportStudent", {
         reportBranchId: string;

package/build/index.mjs

@@ -28,6 +28,8 @@ import { setAksesModulSiswaDiClassGroup } from './actions/jadwal/setAksesModulSi
 import { getClassSessionConflicts } from './actions/jadwal/getClassSessionConflicts/getClassSessionConflicts.action.mjs';
 import { setTravelWageSessions } from './actions/jadwal/setTravelWageSessions/setTravelWageSessions.action.mjs';
 import { customSaveOneClassSession } from './actions/jadwal/action.customSaveOneClassSession.mjs';
+import { bulkDeleteSession } from './actions/jadwal/action.bulkDeleteSession.mjs';
+import { bulkUpdateSession } from './actions/jadwal/action.bulkUpdateSession.mjs';
 import { getGradingCount } from './actions/penilaian/getGradingCount/action.getGradingCount.mjs';
 import { refreshGrading } from './actions/penilaian/refreshGrading/refreshGrading.action.mjs';
 import { refreshManyGrading } from './actions/penilaian/refreshManyGrading/refreshManyGrading.action.mjs';
@@ -118,6 +120,8 @@ const actions = {
   getClassSessionConflicts,
   setTravelWageSessions,
   customSaveOneClassSession,
+  bulkDeleteSession,
+  bulkUpdateSession,
   // Penilaian
   getGradingCount,
   refreshGrading,
@@ -154,4 +158,4 @@ const actions = {
   syncStudents
 };
 
-export { acceptQuestion, actions, addManyGradingComponent, allConflict, calculateGrading, calculateManyComparator, calculateOneComparator, checkClassAttendance, classSessionInventoryOccurs, classSessionInventoryPreparation, clearAllOverrides, clearGrading, clearOneOverrides, createGradingAndScores, createManySession, customSaveOneClassSession, deleteManySession, editAnswer, generateGrading, getClassSessionConflicts, getGradingCount, getQuestionCount, getStaffId, getStaffPoint, getStudentId, getStudentPoint, getTeacherPoint, hasUnderstand, importData, notUnderstand, prepareConflict, prepareExperience, prepareMediaScanterGradingInsert, presenceSessionStudent, presenceSessionTeacher, rasionalizeGrading, refreshGrading, refreshManyGrading, refreshModuleAccess, reminderQuestions, replaceModuleAccess, replaceModuleAccessManyStudent, sendAnswer, sendClassConsultationNotification, sendClassSessionNotification, sendQuestion, sendScoreNotification, setAksesModulSiswaDiClassGroup, setTravelWageSessions, syncClassGroups, syncClassSessions, syncCommitment, syncStudentAdmisi, syncStudentBranch, syncStudentInformation, syncStudentReport, syncStudents, updateGradingAndScores, updateMany, updateReportStudent, userCountStats };
+export { acceptQuestion, actions, addManyGradingComponent, allConflict, bulkDeleteSession, bulkUpdateSession, calculateGrading, calculateManyComparator, calculateOneComparator, checkClassAttendance, classSessionInventoryOccurs, classSessionInventoryPreparation, clearAllOverrides, clearGrading, clearOneOverrides, createGradingAndScores, createManySession, customSaveOneClassSession, deleteManySession, editAnswer, generateGrading, getClassSessionConflicts, getGradingCount, getQuestionCount, getStaffId, getStaffPoint, getStudentId, getStudentPoint, getTeacherPoint, hasUnderstand, importData, notUnderstand, prepareConflict, prepareExperience, prepareMediaScanterGradingInsert, presenceSessionStudent, presenceSessionTeacher, rasionalizeGrading, refreshGrading, refreshManyGrading, refreshModuleAccess, reminderQuestions, replaceModuleAccess, replaceModuleAccessManyStudent, sendAnswer, sendClassConsultationNotification, sendClassSessionNotification, sendQuestion, sendScoreNotification, setAksesModulSiswaDiClassGroup, setTravelWageSessions, syncClassGroups, syncClassSessions, syncCommitment, syncStudentAdmisi, syncStudentBranch, syncStudentInformation, syncStudentReport, syncStudents, updateGradingAndScores, updateMany, updateReportStudent, userCountStats };

package/build/providers/data/useImportData.cjs

@@ -121,7 +121,268 @@ function useImportData(stream) {
     await _gradingMapper(stream2, { gradings: batch });
     await new Promise((resolve) => setTimeout(resolve, 5e3));
   }
-  return { prepareGradingMapper };
+  async function prepareClassSessionMapper(stream2, input) {
+    utils.guard(stream2, "streamRequired");
+    if (!input.classGroupName) {
+      throw new Error("Class Group Name is required for import.");
+    }
+    const classGroup = await findClassGroupByName(stream2, input.classGroupName);
+    if (!classGroup) {
+      console.error(`[ImportClassSession] Class Group '${input.classGroupName}' not found.`);
+      throw new Error(`Class Group '${input.classGroupName}' not found.`);
+    }
+    const groupId = classGroup._id || classGroup.id;
+    const stageId = classGroup.stageId;
+    const branchIds = classGroup.branchIds || [];
+    void queueArrayInChunks(stream2, input.datas, 100, async (s, batch) => {
+      await _classSessionMapper(s, { sessions: batch, classGroupId: groupId, stageId, branchIds });
+    });
+    return { status: "CSV has being processed" };
+  }
+  async function findClassGroupByName(stream2, name) {
+    const result = await stream2.actions.data.getMany.execute({
+      model: "neu:jadwal:classGroup",
+      query: query.Query.define({
+        filter: { name },
+        fields: { _id: 1, id: 1, stageId: 1, branchIds: 1 },
+        limit: 1
+      })
+    }, stream2);
+    return result.isOk && result.payload?.data?.[0] || null;
+  }
+  async function _classSessionMapper(stream2, input) {
+    const operations = [];
+    const subjectCodes = [...new Set(input.sessions.flatMap(
+      (s) => (s.pelajaran || "").split(";").map((code) => code.trim()).filter(Boolean)
+    ))];
+    const subjectMap = await findSubjectsByCodes(stream2, subjectCodes);
+    const stageNames = [...new Set(input.sessions.flatMap(
+      (s) => s.jenjangStudi ? [s.jenjangStudi.trim()] : []
+    ))];
+    const stageMap = await findStages(stream2, stageNames);
+    const teacherIdentifiers = [];
+    input.sessions.forEach((s) => {
+      if (s.idIdentitasPengajar)
+        teacherIdentifiers.push({ type: "idIdentitas", value: s.idIdentitasPengajar });
+      if (s.nomorIndukPengajar)
+        teacherIdentifiers.push({ type: "nip", value: s.nomorIndukPengajar });
+      if (s.idPengajar)
+        teacherIdentifiers.push({ type: "idPengajar", value: s.idPengajar });
+    });
+    const teacherMap = await findTeachers(stream2, teacherIdentifiers);
+    for (const session of input.sessions) {
+      const title = session.judulJadwal || null;
+      let status = "draft";
+      if (session.status?.toLowerCase() === "tayang")
+        status = "published";
+      else if (session.status?.toLowerCase() === "arsip")
+        status = "archived";
+      let type = "offline";
+      if (session.tipe?.toLowerCase() === "live")
+        type = "online";
+      else if (session.tipe?.toLowerCase() === "hybrid")
+        type = "hybrid";
+      let startedAt = null;
+      let endedAt = null;
+      try {
+        const parseDate = (dateStr, timeStr) => {
+          if (!dateStr || !timeStr)
+            return null;
+          const parts = dateStr.split("/");
+          let formattedDate = dateStr;
+          if (parts.length === 3) {
+            formattedDate = `${parts[2]}-${parts[1]}-${parts[0]}`;
+          }
+          return (/* @__PURE__ */ new Date(`${formattedDate}T${timeStr}:00+07:00`)).toISOString();
+        };
+        if (session.tanggal && session.mulai)
+          startedAt = parseDate(session.tanggal, session.mulai);
+        if (session.tanggal && session.selesai)
+          endedAt = parseDate(session.tanggal, session.selesai);
+      } catch (e) {
+        console.error("[ImportClassSession] Date parsing error", e);
+      }
+      const teacherIds = [];
+      let teacherIdStr;
+      if (session.idIdentitasPengajar)
+        teacherIdStr = teacherMap.get(`idIdentitas:${session.idIdentitasPengajar}`);
+      else if (session.nomorIndukPengajar)
+        teacherIdStr = teacherMap.get(`nip:${session.nomorIndukPengajar}`);
+      else if (session.idPengajar)
+        teacherIdStr = teacherMap.get(`idPengajar:${session.idPengajar}`);
+      if (teacherIdStr) {
+        teacherIds.push(new core.ObjectId(teacherIdStr));
+      }
+      const subjectIds = [];
+      if (session.pelajaran) {
+        const codes = session.pelajaran.split(";").map((c) => c.trim()).filter(Boolean);
+        codes.forEach((code) => {
+          const sId = subjectMap.get(code);
+          if (sId)
+            subjectIds.push(new core.ObjectId(sId));
+        });
+      }
+      let sessionStageId = input.stageId;
+      if (session.jenjangStudi) {
+        const sName = session.jenjangStudi.trim();
+        const mappedStageId = stageMap.get(sName);
+        if (mappedStageId)
+          sessionStageId = mappedStageId;
+      }
+      const newId = new core.ObjectId();
+      operations.push({
+        insertOne: {
+          document: {
+            name: title,
+            description: session.subjudul,
+            note: session.catatanLokasi,
+            title,
+            subtitle: session.subjudul || null,
+            locationText: session.catatanLokasi || null,
+            map: session.peta || null,
+            link: session.link || null,
+            password: session.password || null,
+            startedAt,
+            endedAt,
+            _id: newId,
+            id: newId.toString(),
+            groupIds: [input.classGroupId],
+            stageId: sessionStageId,
+            branchIds: input.branchIds.map((id) => new core.ObjectId(id)),
+            teacherIds,
+            subjectIds,
+            status,
+            isTeacherShown: true,
+            isTeacherSubtituted: false,
+            type,
+            locationType: type === "online" ? null : "building",
+            isTitleSession: !!(session.judulJadwal && session.judulJadwal.trim()),
+            createdAt: /* @__PURE__ */ new Date(),
+            updatedAt: /* @__PURE__ */ new Date(),
+            meta: {
+              importData: session,
+              source: "import-csv"
+            }
+          }
+        }
+      });
+    }
+    if (operations.length > 0) {
+      await stream2.core.dbs["neu-jadwal"].models["neu:jadwal:classSession"].bulkWrite(operations);
+    }
+  }
+  async function findSubjectsByCodes(stream2, codes) {
+    if (codes.length === 0) {
+      return /* @__PURE__ */ new Map();
+    }
+    console.log("[ImportClassSession] findSubjectsByCodes input:", codes);
+    const result = await stream2.actions.data.getMany.execute({
+      model: "neu:akademik:academicSubject",
+      query: query.Query.define({
+        filter: { code: { $in: codes } },
+        fields: { _id: 1, id: 1, code: 1, name: 1 },
+        limit: constants.LIMIT_INFINITY
+      })
+    }, stream2);
+    const map = /* @__PURE__ */ new Map();
+    if (result.isOk && result.payload?.data) {
+      console.log(`[ImportClassSession] Found ${result.payload.data.length} subjects`);
+      result.payload.data.forEach((subject) => {
+        console.log(`[ImportClassSession] Mapping Subject Code: '${subject.code}' -> ID: '${subject.id || subject._id}'`);
+        map.set(subject.code, subject.id || subject._id);
+      });
+    } else {
+      console.log("[ImportClassSession] findSubjectsByCodes failed or empty:", result.message);
+    }
+    return map;
+  }
+  async function findStages(stream2, namesOrCodes) {
+    if (namesOrCodes.length === 0) {
+      return /* @__PURE__ */ new Map();
+    }
+    const result = await stream2.actions.data.getMany.execute({
+      model: "neo:akademik:stage",
+      query: query.Query.define({
+        filter: {
+          $or: [
+            { name: { $in: namesOrCodes } },
+            { code: { $in: namesOrCodes } }
+          ]
+        },
+        fields: { _id: 1, id: 1, name: 1, code: 1 },
+        limit: constants.LIMIT_INFINITY
+      })
+    }, stream2);
+    const map = /* @__PURE__ */ new Map();
+    if (result.isOk && result.payload?.data) {
+      result.payload.data.forEach((st) => {
+        if (st.name) {
+          map.set(st.name, st.id || st._id);
+        }
+        if (st.code) {
+          map.set(st.code, st.id || st._id);
+        }
+      });
+    }
+    return map;
+  }
+  async function findTeachers(stream2, identifiers) {
+    if (identifiers.length === 0) {
+      return /* @__PURE__ */ new Map();
+    }
+    const teacherIds = identifiers.filter((i) => i.type === "idPengajar").map((i) => i.value.trim());
+    const userIds = identifiers.filter((i) => i.type === "idIdentitas").map((i) => i.value.trim());
+    const nips = identifiers.filter((i) => i.type === "nip").map((i) => i.value.trim());
+    const conditions = [];
+    if (userIds.length) {
+      conditions.push({ userId: { $in: userIds } });
+    }
+    if (nips.length) {
+      conditions.push({ nip: { $in: nips } });
+    }
+    if (teacherIds.length) {
+      const validIds = teacherIds.filter((id) => /^[0-9a-f]{24}$/i.test(id)).map((id) => new core.ObjectId(id));
+      if (validIds.length > 0) {
+        conditions.push({ _id: { $in: validIds } });
+      }
+      conditions.push({ id: { $in: teacherIds } });
+      if (validIds.length === 0 && teacherIds.length > 0) {
+        console.warn("[ImportClassSession] No valid Hex ObjectIds found for idPengajar:", teacherIds);
+      }
+    }
+    if (conditions.length === 0) {
+      console.warn("[ImportClassSession] findTeachers: No valid query conditions.");
+      return /* @__PURE__ */ new Map();
+    }
+    const result = await stream2.actions.data.getMany.execute({
+      model: "neu:akademik:teacher",
+      query: query.Query.define({
+        filter: { $or: conditions },
+        fields: { _id: 1, id: 1, nip: 1, userId: 1 },
+        limit: constants.LIMIT_INFINITY
+      })
+    }, stream2);
+    const map = /* @__PURE__ */ new Map();
+    if (result.isOk && result.payload?.data) {
+      result.payload.data.forEach((t) => {
+        const id = t.id || t._id?.toString();
+        const { userId, nip } = t;
+        if (userId) {
+          map.set(`idIdentitas:${userId}`, id);
+        }
+        if (id) {
+          map.set(`idPengajar:${id}`, id);
+        }
+        if (nip) {
+          map.set(`nip:${nip}`, id);
+        }
+      });
+    } else {
+      console.error("[ImportClassSession] findTeachers failed:", result.message);
+    }
+    return map;
+  }
+  return { prepareGradingMapper, prepareClassSessionMapper };
 }
 
 exports.useImportData = useImportData;

package/build/providers/data/useImportData.d.ts

@@ -5,4 +5,10 @@ export declare function useImportData(stream: Stream | undefined): {
     }) => Promise<{
         status: string;
     }>;
+    prepareClassSessionMapper: (stream: NStream.Stream, input: {
+        datas: [];
+        classGroupName: string;
+    }) => Promise<{
+        status: string;
+    }>;
 };

package/build/providers/data/useImportData.mjs

@@ -119,7 +119,268 @@ function useImportData(stream) {
     await _gradingMapper(stream2, { gradings: batch });
     await new Promise((resolve) => setTimeout(resolve, 5e3));
   }
-  return { prepareGradingMapper };
+  async function prepareClassSessionMapper(stream2, input) {
+    guard(stream2, "streamRequired");
+    if (!input.classGroupName) {
+      throw new Error("Class Group Name is required for import.");
+    }
+    const classGroup = await findClassGroupByName(stream2, input.classGroupName);
+    if (!classGroup) {
+      console.error(`[ImportClassSession] Class Group '${input.classGroupName}' not found.`);
+      throw new Error(`Class Group '${input.classGroupName}' not found.`);
+    }
+    const groupId = classGroup._id || classGroup.id;
+    const stageId = classGroup.stageId;
+    const branchIds = classGroup.branchIds || [];
+    void queueArrayInChunks(stream2, input.datas, 100, async (s, batch) => {
+      await _classSessionMapper(s, { sessions: batch, classGroupId: groupId, stageId, branchIds });
+    });
+    return { status: "CSV has being processed" };
+  }
+  async function findClassGroupByName(stream2, name) {
+    const result = await stream2.actions.data.getMany.execute({
+      model: "neu:jadwal:classGroup",
+      query: Query.define({
+        filter: { name },
+        fields: { _id: 1, id: 1, stageId: 1, branchIds: 1 },
+        limit: 1
+      })
+    }, stream2);
+    return result.isOk && result.payload?.data?.[0] || null;
+  }
+  async function _classSessionMapper(stream2, input) {
+    const operations = [];
+    const subjectCodes = [...new Set(input.sessions.flatMap(
+      (s) => (s.pelajaran || "").split(";").map((code) => code.trim()).filter(Boolean)
+    ))];
+    const subjectMap = await findSubjectsByCodes(stream2, subjectCodes);
+    const stageNames = [...new Set(input.sessions.flatMap(
+      (s) => s.jenjangStudi ? [s.jenjangStudi.trim()] : []
+    ))];
+    const stageMap = await findStages(stream2, stageNames);
+    const teacherIdentifiers = [];
+    input.sessions.forEach((s) => {
+      if (s.idIdentitasPengajar)
+        teacherIdentifiers.push({ type: "idIdentitas", value: s.idIdentitasPengajar });
+      if (s.nomorIndukPengajar)
+        teacherIdentifiers.push({ type: "nip", value: s.nomorIndukPengajar });
+      if (s.idPengajar)
+        teacherIdentifiers.push({ type: "idPengajar", value: s.idPengajar });
+    });
+    const teacherMap = await findTeachers(stream2, teacherIdentifiers);
+    for (const session of input.sessions) {
+      const title = session.judulJadwal || null;
+      let status = "draft";
+      if (session.status?.toLowerCase() === "tayang")
+        status = "published";
+      else if (session.status?.toLowerCase() === "arsip")
+        status = "archived";
+      let type = "offline";
+      if (session.tipe?.toLowerCase() === "live")
+        type = "online";
+      else if (session.tipe?.toLowerCase() === "hybrid")
+        type = "hybrid";
+      let startedAt = null;
+      let endedAt = null;
+      try {
+        const parseDate = (dateStr, timeStr) => {
+          if (!dateStr || !timeStr)
+            return null;
+          const parts = dateStr.split("/");
+          let formattedDate = dateStr;
+          if (parts.length === 3) {
+            formattedDate = `${parts[2]}-${parts[1]}-${parts[0]}`;
+          }
+          return (/* @__PURE__ */ new Date(`${formattedDate}T${timeStr}:00+07:00`)).toISOString();
+        };
+        if (session.tanggal && session.mulai)
+          startedAt = parseDate(session.tanggal, session.mulai);
+        if (session.tanggal && session.selesai)
+          endedAt = parseDate(session.tanggal, session.selesai);
+      } catch (e) {
+        console.error("[ImportClassSession] Date parsing error", e);
+      }
+      const teacherIds = [];
+      let teacherIdStr;
+      if (session.idIdentitasPengajar)
+        teacherIdStr = teacherMap.get(`idIdentitas:${session.idIdentitasPengajar}`);
+      else if (session.nomorIndukPengajar)
+        teacherIdStr = teacherMap.get(`nip:${session.nomorIndukPengajar}`);
+      else if (session.idPengajar)
+        teacherIdStr = teacherMap.get(`idPengajar:${session.idPengajar}`);
+      if (teacherIdStr) {
+        teacherIds.push(new ObjectId(teacherIdStr));
+      }
+      const subjectIds = [];
+      if (session.pelajaran) {
+        const codes = session.pelajaran.split(";").map((c) => c.trim()).filter(Boolean);
+        codes.forEach((code) => {
+          const sId = subjectMap.get(code);
+          if (sId)
+            subjectIds.push(new ObjectId(sId));
+        });
+      }
+      let sessionStageId = input.stageId;
+      if (session.jenjangStudi) {
+        const sName = session.jenjangStudi.trim();
+        const mappedStageId = stageMap.get(sName);
+        if (mappedStageId)
+          sessionStageId = mappedStageId;
+      }
+      const newId = new ObjectId();
+      operations.push({
+        insertOne: {
+          document: {
+            name: title,
+            description: session.subjudul,
+            note: session.catatanLokasi,
+            title,
+            subtitle: session.subjudul || null,
+            locationText: session.catatanLokasi || null,
+            map: session.peta || null,
+            link: session.link || null,
+            password: session.password || null,
+            startedAt,
+            endedAt,
+            _id: newId,
+            id: newId.toString(),
+            groupIds: [input.classGroupId],
+            stageId: sessionStageId,
+            branchIds: input.branchIds.map((id) => new ObjectId(id)),
+            teacherIds,
+            subjectIds,
+            status,
+            isTeacherShown: true,
+            isTeacherSubtituted: false,
+            type,
+            locationType: type === "online" ? null : "building",
+            isTitleSession: !!(session.judulJadwal && session.judulJadwal.trim()),
+            createdAt: /* @__PURE__ */ new Date(),
+            updatedAt: /* @__PURE__ */ new Date(),
+            meta: {
+              importData: session,
+              source: "import-csv"
+            }
+          }
+        }
+      });
+    }
+    if (operations.length > 0) {
+      await stream2.core.dbs["neu-jadwal"].models["neu:jadwal:classSession"].bulkWrite(operations);
+    }
+  }
+  async function findSubjectsByCodes(stream2, codes) {
+    if (codes.length === 0) {
+      return /* @__PURE__ */ new Map();
+    }
+    console.log("[ImportClassSession] findSubjectsByCodes input:", codes);
+    const result = await stream2.actions.data.getMany.execute({
+      model: "neu:akademik:academicSubject",
+      query: Query.define({
+        filter: { code: { $in: codes } },
+        fields: { _id: 1, id: 1, code: 1, name: 1 },
+        limit: LIMIT_INFINITY
+      })
+    }, stream2);
+    const map = /* @__PURE__ */ new Map();
+    if (result.isOk && result.payload?.data) {
+      console.log(`[ImportClassSession] Found ${result.payload.data.length} subjects`);
+      result.payload.data.forEach((subject) => {
+        console.log(`[ImportClassSession] Mapping Subject Code: '${subject.code}' -> ID: '${subject.id || subject._id}'`);
+        map.set(subject.code, subject.id || subject._id);
+      });
+    } else {
+      console.log("[ImportClassSession] findSubjectsByCodes failed or empty:", result.message);
+    }
+    return map;
+  }
+  async function findStages(stream2, namesOrCodes) {
+    if (namesOrCodes.length === 0) {
+      return /* @__PURE__ */ new Map();
+    }
+    const result = await stream2.actions.data.getMany.execute({
+      model: "neo:akademik:stage",
+      query: Query.define({
+        filter: {
+          $or: [
+            { name: { $in: namesOrCodes } },
+            { code: { $in: namesOrCodes } }
+          ]
+        },
+        fields: { _id: 1, id: 1, name: 1, code: 1 },
+        limit: LIMIT_INFINITY
+      })
+    }, stream2);
+    const map = /* @__PURE__ */ new Map();
+    if (result.isOk && result.payload?.data) {
+      result.payload.data.forEach((st) => {
+        if (st.name) {
+          map.set(st.name, st.id || st._id);
+        }
+        if (st.code) {
+          map.set(st.code, st.id || st._id);
+        }
+      });
+    }
+    return map;
+  }
+  async function findTeachers(stream2, identifiers) {
+    if (identifiers.length === 0) {
+      return /* @__PURE__ */ new Map();
+    }
+    const teacherIds = identifiers.filter((i) => i.type === "idPengajar").map((i) => i.value.trim());
+    const userIds = identifiers.filter((i) => i.type === "idIdentitas").map((i) => i.value.trim());
+    const nips = identifiers.filter((i) => i.type === "nip").map((i) => i.value.trim());
+    const conditions = [];
+    if (userIds.length) {
+      conditions.push({ userId: { $in: userIds } });
+    }
+    if (nips.length) {
+      conditions.push({ nip: { $in: nips } });
+    }
+    if (teacherIds.length) {
+      const validIds = teacherIds.filter((id) => /^[0-9a-f]{24}$/i.test(id)).map((id) => new ObjectId(id));
+      if (validIds.length > 0) {
+        conditions.push({ _id: { $in: validIds } });
+      }
+      conditions.push({ id: { $in: teacherIds } });
+      if (validIds.length === 0 && teacherIds.length > 0) {
+        console.warn("[ImportClassSession] No valid Hex ObjectIds found for idPengajar:", teacherIds);
+      }
+    }
+    if (conditions.length === 0) {
+      console.warn("[ImportClassSession] findTeachers: No valid query conditions.");
+      return /* @__PURE__ */ new Map();
+    }
+    const result = await stream2.actions.data.getMany.execute({
+      model: "neu:akademik:teacher",
+      query: Query.define({
+        filter: { $or: conditions },
+        fields: { _id: 1, id: 1, nip: 1, userId: 1 },
+        limit: LIMIT_INFINITY
+      })
+    }, stream2);
+    const map = /* @__PURE__ */ new Map();
+    if (result.isOk && result.payload?.data) {
+      result.payload.data.forEach((t) => {
+        const id = t.id || t._id?.toString();
+        const { userId, nip } = t;
+        if (userId) {
+          map.set(`idIdentitas:${userId}`, id);
+        }
+        if (id) {
+          map.set(`idPengajar:${id}`, id);
+        }
+        if (nip) {
+          map.set(`nip:${nip}`, id);
+        }
+      });
+    } else {
+      console.error("[ImportClassSession] findTeachers failed:", result.message);
+    }
+    return map;
+  }
+  return { prepareGradingMapper, prepareClassSessionMapper };
 }
 
 export { useImportData };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neutron.co.id/pendidikan-operation",
-  "version": "1.27.9",
+  "version": "1.27.12",
   "description": "Operation package of Neutron Pendidikan.",
   "license": "SEE LICENSE IN LICENSE",
   "contributors": [
@@ -39,9 +39,9 @@
     "@neon.id/types": "^1.69.0",
     "@neon.id/utils": "^1.52.0",
     "@neon.id/z": "^1.16.0",
-    "@neutron.co.id/akademik-models": "^1.21.4",
+    "@neutron.co.id/akademik-models": "^1.21.5-beta.1",
     "@neutron.co.id/jadwal-models": "^1.19.13",
-    "@neutron.co.id/pendidikan-types": "^1.23.2",
+    "@neutron.co.id/pendidikan-types": "^1.23.3",
     "@neutron.co.id/penilaian-models": "^1.17.8",
     "@neutron.co.id/personalia-models": "^1.11.6",
     "@neutron.co.id/tanya-models": "^1.13.4",
@@ -75,9 +75,9 @@
     "@neon.id/types": "^1.69.0",
     "@neon.id/utils": "^1.52.0",
     "@neon.id/z": "^1.16.0",
-    "@neutron.co.id/akademik-models": "^1.21.4",
+    "@neutron.co.id/akademik-models": "^1.21.5-beta.1",
     "@neutron.co.id/jadwal-models": "^1.19.13",
-    "@neutron.co.id/pendidikan-types": "^1.23.2",
+    "@neutron.co.id/pendidikan-types": "^1.23.3",
     "@neutron.co.id/penilaian-models": "^1.17.8",
     "@neutron.co.id/personalia-models": "^1.11.6",
     "@neutron.co.id/tanya-models": "^1.13.4",
@@ -86,5 +86,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "build": 134
+  "build": 137
 }