@neutron.co.id/pendidikan-operation 1.12.0 → 1.16.1

package/build/index.cjs

@@ -4,12 +4,14 @@ const core = require('@neon.id/core');
 const operation = require('@neon.id/operation');
 const query = require('@neon.id/query');
 const code = require('@neon.id/utils/code');
-const bson = require('@neon.id/bson');
 const date = require('@neon.id/utils/date');
 const period = require('@neon.id/utils/period');
-const faker = require('@faker-js/faker');
-const value = require('@neon.id/utils/value');
+const jadwalModels = require('@neutron.co.id/jadwal-models');
 const z = require('@neon.id/z');
+const string = require('@neon.id/utils/string');
+const value = require('@neon.id/utils/value');
+const utils = require('consola/utils');
+const faker = require('@faker-js/faker');
 
 process.env.NODE_ENV === "production";
 function guard(condition, state, message) {
@@ -18,6 +20,57 @@ function guard(condition, state, message) {
   throw core.Result.fail({ state, message });
 }
 
+const dim = utils.getColor("dim");
+const bold = utils.getColor("bold");
+const red = utils.getColor("red");
+function useLog(group, isActive = false) {
+  const title = bold(red(group));
+  const context = { title, space, text, object, warn, fail };
+  return context;
+  function space() {
+    console.log("");
+    return context;
+  }
+  function text(type, payload) {
+    if (!isActive)
+      return;
+    const said = say({ type, message: `"${payload}"` });
+    console.log(said);
+    return context;
+  }
+  function warn(message) {
+    if (!isActive)
+      return;
+    const said = say({ message });
+    console.warn(said);
+    return context;
+  }
+  function fail(message, error) {
+    if (!isActive)
+      return;
+    const said = say({ message });
+    console.log(said);
+    console.error(error);
+    return context;
+  }
+  function object(type, payload, options) {
+    if (!isActive)
+      return;
+    const said = say({ type });
+    console.log(said);
+    const object2 = value.ValueUtil.omitValues(payload, options?.ignore || []);
+    console.dir(object2, { depth: 10 });
+    return context;
+  }
+  function say(input) {
+    if (!isActive)
+      return;
+    const pointer = dim("\u203A");
+    const parts = ["\u{1F6A8}", title, pointer, input.type, input.message];
+    return string.StringUtil.joinIfDefined(parts, " ");
+  }
+}
+
 class NumberUtil {
   static transformDecimal(value) {
     if (!value)
@@ -1010,7 +1063,7 @@ const syncStudentBranch = operation.Action.define({
     }).sort({ startedAt: -1 });
     console.log("ini result Group", resultGroup);
     const arrBranchGroup = resultGroup.map((field) => field.branchIds[0]);
-    const groupBranchId = arrBranchGroup[0];
+    const groupBranchId = arrBranchGroup[0] ? arrBranchGroup[0] : null;
     const resultTagihan = await dbKonsumen.findOne({
       studentId: input.studentId,
       endedAt: {
@@ -1019,17 +1072,49 @@ const syncStudentBranch = operation.Action.define({
       deletedAt: { $exists: false }
     });
     const tagihanBranchId = resultTagihan ? resultTagihan.branchId : null;
-    console.log("Ini hasil..." + tagihanBranchId);
     await dbStudent.updateOne(
       { _id: input.studentId },
       {
         $set: {
           groupBranchId,
-          financeBranchId: tagihanBranchId,
-          branchIds: input.branchIds.concat(input.userIds)
+          financeBranchId: tagihanBranchId
         }
       }
     );
+    if (groupBranchId != null) {
+      const findStudentForGroup = await dbStudent.findOne({
+        _id: input.studentId
+      });
+      const branchForGroupIds = findStudentForGroup.branchIds;
+      if (!branchForGroupIds.includes(groupBranchId)) {
+        branchForGroupIds.push(groupBranchId);
+        await dbStudent.updateOne(
+          { _id: input.studentId },
+          {
+            $set: {
+              branchIds: branchForGroupIds
+            }
+          }
+        );
+      }
+    }
+    if (tagihanBranchId != null) {
+      const findStudentForFinance = await dbStudent.findOne({
+        _id: input.studentId
+      });
+      const branchForFinanceIds = findStudentForFinance.branchIds;
+      if (!branchForFinanceIds.includes(tagihanBranchId)) {
+        branchForFinanceIds.push(tagihanBranchId);
+        await dbStudent.updateOne(
+          { _id: input.studentId },
+          {
+            $set: {
+              branchIds: branchForFinanceIds
+            }
+          }
+        );
+      }
+    }
     return core.Result.ok({
       state: "studentBranchSync",
       message: "Student Branch has been sync.",
@@ -1144,6 +1229,41 @@ const syncStudentInformation = operation.Action.define({
   }
 });
 
+const syncStudentAdmisi = operation.Action.define({
+  key: "syncStudentAdmisi",
+  name: "Sync StudentAdmisi",
+  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 findStudent = await dbStudent.findOne({ _id: input.studentId });
+    const branchIds = findStudent.branchIds;
+    if (input.admisiBranchId != null) {
+      if (!branchIds.includes(input.admisiBranchId)) {
+        branchIds.push(input.admisiBranchId);
+        await dbStudent.updateOne(
+          { _id: input.studentId },
+          {
+            $set: {
+              branchIds
+            }
+          }
+        );
+      }
+    }
+    return core.Result.ok({
+      state: "studentAdmisiSync",
+      message: "Student Admisi has been sync.",
+      data: {
+        code: 1
+      }
+    });
+  }
+});
+
 const allConflict = operation.Action.define({
   key: "allConflict",
   name: "All Conflict",
@@ -1187,6 +1307,47 @@ const allConflict = operation.Action.define({
   }
 });
 
+const checkClassAttendance = operation.Action.define({
+  key: "checkClassAttendance",
+  name: "Check ClassAttendance",
+  type: "command",
+  category: "domain",
+  execute: async (input, stream) => {
+    guard(stream, "streamRequired");
+    guard(input, "inputRequired");
+    const dbs = stream.core.dbs;
+    const dbClassAttendance = dbs["neu-jadwal"].models["neu:jadwal:classAttendance"];
+    const dataAttStudent = await dbClassAttendance.find({
+      classSessionId: input.classSessionId,
+      studentId: input.studentId,
+      deletedAt: null
+    });
+    const dataAttStaff = await dbClassAttendance.find({
+      classSessionId: input.classSessionId,
+      staffId: input.staffId,
+      deletedAt: null
+    });
+    const dataAttTeacher = await dbClassAttendance.find({
+      classSessionId: input.classSessionId,
+      teacherId: input.teacherId,
+      deletedAt: null
+    });
+    console.log("Count Siswa", dataAttStudent.length);
+    console.log("Count Pengajar", dataAttStaff.length);
+    console.log("Count Karyawan", dataAttTeacher.length);
+    return core.Result.ok({
+      state: "classattendanceCheck",
+      message: "ClassAttendance  has been check.",
+      data: {
+        code: 1,
+        countAttendanceStudent: dataAttStudent.length,
+        countAttendanceStaff: dataAttStaff.length,
+        countAttendanceTeacher: dataAttTeacher.length
+      }
+    });
+  }
+});
+
 const classSessionInventoryOccurs = operation.Action.define({
   key: "classSessionInventoryOccurs",
   name: "Persiapan Inventori Sesi Kelas",
@@ -1209,7 +1370,7 @@ const classSessionInventoryOccurs = operation.Action.define({
           fields: {
             itemId: 1,
             item: {
-              unitId: 1
+              inventoryinventoryUnitId: 1
             },
             qtyConvertion: 1,
             qtyStock: 1,
@@ -1228,23 +1389,40 @@ const classSessionInventoryOccurs = operation.Action.define({
     resultInventoryOPerational.payload.data?.map(async (item) => {
       console.log("item", item);
       const dbStock = dbs["neu-inventori"].models["neu:inventori:stock"];
-      const resultStock = await dbStock.findOne({
+      const getStock = await dbStock.find({
         itemId: item.itemId,
         branchId: item.branchId,
-        roomId: item.roomId
-      });
-      console.log("resultStock", resultStock);
+        roomId: item.roomId,
+        deletedAt: null
+      }).count();
+      const resultStock = await stream?.actions.data.getMany.execute(
+        {
+          model: "neu:inventori:stock",
+          query: query.Query.define({
+            filter: {
+              itemId: item.itemId,
+              branchId: item.branchId,
+              roomId: item.roomId
+            },
+            fields: {
+              stock: 1,
+              need: 1
+            }
+          })
+        },
+        stream
+      );
       if (item.status !== "happen") {
-        if (resultStock !== null) {
+        if (getStock > 0) {
           console.log("stock Ada");
-          if (resultStock.stock > item.qtyConvertion) {
+          if (resultStock.value[0].stock > item.qtyConvertion) {
             console.log("stock cukup");
             const createInventory = await dbInventoryTransaction.create({
               code: code.CodeUtil.getCode({ chars: 6, prefix: "T" }),
               transactionType: "out",
               itemId: item.itemId,
               qty: item.qtyConvertion,
-              unitId: item.item?.unitId,
+              inventoryUnitId: item.item?.inventoryUnitId,
               branchId: item.branchId,
               roomId: item.roomId,
               inventoryOperationalId: item.id,
@@ -1253,12 +1431,26 @@ const classSessionInventoryOccurs = operation.Action.define({
               transactionAt: /* @__PURE__ */ new Date()
             });
             console.log("createInventory", createInventory);
+            let qtyNeed = 0;
+            if (resultStock.value[0].need) {
+              qtyNeed = parseFloat(resultStock.value[0].need);
+            }
+            const newNeed = qtyNeed - item.qtyConvertion;
+            const newStock = resultStock.value[0].stock - item.qtyConvertion;
+            let statusStock = "doNotKnow";
+            if (newNeed > newStock) {
+              statusStock = "notEnough";
+            } else {
+              statusStock = "enough";
+            }
+            console.log("newNeed", newNeed);
+            console.log("newStock", newStock);
             await dbStock.updateOne(
-              { _id: resultStock.id },
+              { _id: resultStock.value[0].id },
               {
-                $inc: {
-                  stock: -item.qtyConvertion
-                }
+                stock: newStock,
+                need: newNeed,
+                status: statusStock
               }
             );
             await dbInventoryOperational.updateOne(
@@ -1269,6 +1461,33 @@ const classSessionInventoryOccurs = operation.Action.define({
                 }
               }
             );
+            const resultOperationPracticeSession = await stream.actions.data.getMany.execute(
+              {
+                model: "neu:inventori:inventoryOperational",
+                query: query.Query.define({
+                  filter: {
+                    itemId: item.itemId,
+                    branchId: item.branchId,
+                    roomId: item.roomId,
+                    status: "plan"
+                  },
+                  fields: {
+                    id: 1
+                  }
+                })
+              },
+              stream
+            );
+            resultOperationPracticeSession.payload.data?.map(
+              async (item2) => {
+                await dbInventoryOperational.updateOne(
+                  { _id: item2.id },
+                  {
+                    statusStock
+                  }
+                );
+              }
+            );
           }
         }
       }
@@ -1301,8 +1520,70 @@ const classSessionInventoryPreparation = operation.Action.define({
     const dbInventorySession = dbs["neu-inventori"].models["neu:inventori:inventorySession"];
     const dbInventoryOperational = dbs["neu-inventori"].models["neu:inventori:inventoryOperational"];
     const dbClassSession = dbs["neu-jadwal"].models["neu:jadwal:classSession"];
+    const dbStock = dbs["neu-inventori"].models["neu:inventori:stock"];
+    const operationalCount = await dbInventoryOperational.find({
+      classSessionId: input.classSessionId,
+      deletedAt: null
+    }).count();
+    if (operationalCount > 0) {
+      const getOperational = await dbInventoryOperational.find({
+        classSessionId: input.classSessionId
+      });
+      getOperational.map(async (item) => {
+        const getStock = await dbStock.find({
+          itemId: item.itemId,
+          branchId: item.branchId,
+          roomId: item.roomId,
+          deletedAt: null
+        }).count();
+        if (getStock > 0) {
+          const resultStock = await stream?.actions.data.getMany.execute(
+            {
+              model: "neu:inventori:stock",
+              query: query.Query.define({
+                filter: {
+                  itemId: item.itemId,
+                  branchId: item.branchId,
+                  roomId: item.roomId
+                },
+                fields: {
+                  stock: 1,
+                  need: 1
+                }
+              })
+            },
+            stream
+          );
+          let qtyNeed = 0;
+          if (resultStock.value[0].need) {
+            qtyNeed = parseFloat(resultStock.value[0].need);
+          }
+          const newNeed = qtyNeed - item.qtyConvertion;
+          await dbStock.updateOne(
+            {
+              _id: resultStock.value[0].id
+            },
+            {
+              need: newNeed
+            }
+          );
+        }
+      });
+    }
+    await stream.actions.data.deleteMany.execute(
+      {
+        model: "neu:inventori:inventoryOperational",
+        query: query.Query.define({
+          filter: {
+            classSessionId: new core.ObjectId(input.classSessionId)
+          }
+        })
+      },
+      stream
+    );
     const inventorySessionCount = await dbInventorySession.find({
-      classSessionId: input.classSessionId
+      classSessionId: input.classSessionId,
+      deletedAt: null
     }).count();
     if (inventorySessionCount > 0) {
       const dbInventoryOperationalType = dbs["neu-inventori"].models["neu:inventori:inventoryOperationalType"];
@@ -1319,7 +1600,8 @@ const classSessionInventoryPreparation = operation.Action.define({
           model: "neu:inventori:inventorySession",
           query: query.Query.define({
             filter: {
-              classSessionId: input.classSessionId
+              classSessionId: input.classSessionId,
+              deletedAt: null
             },
             fields: {
               id: 1,
@@ -1339,7 +1621,7 @@ const classSessionInventoryPreparation = operation.Action.define({
               item: {
                 id: 1,
                 item: 1,
-                unitId: 1
+                inventoryUnitId: 1
               },
               practiceSessionType: 1
             }
@@ -1348,14 +1630,14 @@ const classSessionInventoryPreparation = operation.Action.define({
         stream
       );
       getInventorySession.payload.data?.map(async (item) => {
-        console.log("item", item);
         if (item.practiceSessionType === "recipe") {
           const getRecipe = await stream.actions.data.getMany.execute(
             {
               model: "neu:produk:programComponentDetail",
               query: query.Query.define({
                 filter: {
-                  programComponentId: item.programComponentId
+                  programComponentId: item.programComponentId,
+                  deletedAt: null
                 },
                 fields: {
                   id: 1,
@@ -1364,7 +1646,7 @@ const classSessionInventoryPreparation = operation.Action.define({
                   item: {
                     id: 1,
                     item: 1,
-                    unitId: 1
+                    inventoryUnitId: 1
                   },
                   convertionId: 1,
                   convertion: {
@@ -1381,18 +1663,43 @@ const classSessionInventoryPreparation = operation.Action.define({
             stream
           );
           getRecipe.payload.data?.map(async (item1) => {
-            console.log("item1", item1);
             let qtyStock = 0;
-            const dbStock = dbs["neu-inventori"].models["neu:inventori:stock"];
-            const resultStock = await dbStock.findOne({
+            let qtyNeed = 0;
+            const dbStock2 = dbs["neu-inventori"].models["neu:inventori:stock"];
+            const getStock = await dbStock2.find({
               itemId: item1.itemId,
               branchId: item.branchId,
-              roomId: item.roomId
-            });
-            if (resultStock !== null) {
+              roomId: item.roomId,
+              deletedAt: null
+            }).count();
+            const resultStock = await stream?.actions.data.getMany.execute(
+              {
+                model: "neu:inventori:stock",
+                query: query.Query.define({
+                  filter: {
+                    itemId: item1.itemId,
+                    branchId: item.branchId,
+                    roomId: item.roomId
+                  },
+                  fields: {
+                    stock: 1,
+                    need: 1
+                  }
+                })
+              },
+              stream
+            );
+            if (getStock > 0) {
+              console.log("resultStock", resultStock.value[0]);
               console.log("ada stock");
-              if (resultStock.stock !== "") {
-                qtyStock = parseFloat(resultStock.stock);
+              console.log("resultStock.stock", resultStock.value[0].stock);
+              console.log("resultStock.need", resultStock.value[0].need);
+              if (resultStock.value[0].stock) {
+                qtyStock = parseFloat(resultStock.value[0].stock);
+                console.log("resultStock.stockqtyStock", qtyStock);
+              }
+              if (resultStock.value[0].need) {
+                qtyNeed = parseFloat(resultStock.value[0].need);
               }
             }
             let qty = 0;
@@ -1403,16 +1710,23 @@ const classSessionInventoryPreparation = operation.Action.define({
             if (item1.qtyConvertion) {
               qtyConvertion = parseFloat(item1.qtyConvertion) * parseFloat(item.qty);
             }
+            const newNeed = qtyNeed + qtyConvertion;
             let canBeUse = "doNotKnow";
             if (qtyConvertion > qtyStock) {
               canBeUse = "no";
             } else {
               canBeUse = "can";
             }
+            let statusStock = "doNotKnow";
+            if (newNeed > qtyStock) {
+              statusStock = "notEnough";
+            } else {
+              statusStock = "enough";
+            }
             await dbInventoryOperational.create({
               code: code.CodeUtil.getCode({ chars: 4, prefix: "OPS-I" }),
               status: "plan",
-              inventoryOperationalTypeId: new bson.ObjectId(
+              inventoryOperationalTypeId: new core.ObjectId(
                 inventoryOperationalTypeId
               ),
               itemId: item1.itemId,
@@ -1424,27 +1738,82 @@ const classSessionInventoryPreparation = operation.Action.define({
               qtyStock,
               qty,
               qtyConvertion,
-              canBeUse
+              canBeUse,
+              statusStock
             });
+            console.log("newNeed", newNeed);
+            console.log("qtyStock", qtyStock);
+            console.log("statusStock", statusStock);
+            if (getStock > 0) {
+              const updateStock = await dbStock2.updateOne(
+                { _id: resultStock.value[0].id },
+                {
+                  need: newNeed,
+                  status: statusStock
+                }
+              );
+              console.log("update stock");
+              console.log("updateStock", updateStock);
+            } else {
+              await dbStock2.create({
+                itemId: item1.itemId,
+                branchId: item.branchId,
+                roomId: item.roomId,
+                need: newNeed,
+                status: statusStock,
+                stock: 0
+              });
+            }
           });
         } else {
           let qtyStock = 0;
-          const dbStock = dbs["neu-inventori"].models["neu:inventori:stock"];
-          const resultStock = await dbStock.findOne({
+          let qtyNeed = 0;
+          const dbStock2 = dbs["neu-inventori"].models["neu:inventori:stock"];
+          const getStock = await dbStock2.find({
             itemId: item.itemId,
             branchId: item.branchId,
-            roomId: item.roomId
-          });
-          if (resultStock !== null) {
+            roomId: item.roomId,
+            deletedAt: null
+          }).count();
+          const resultStock = await stream?.actions.data.getMany.execute(
+            {
+              model: "neu:inventori:stock",
+              query: query.Query.define({
+                filter: {
+                  itemId: item.itemId,
+                  branchId: item.branchId,
+                  roomId: item.roomId
+                },
+                fields: {
+                  stock: 1,
+                  need: 1
+                }
+              })
+            },
+            stream
+          );
+          if (getStock > 0) {
             console.log("ada stock");
-            if (resultStock.stock !== "") {
-              qtyStock = parseFloat(resultStock.stock);
+            if (resultStock.value[0].stock) {
+              qtyStock = parseFloat(resultStock.value[0].stock);
+            }
+            if (resultStock.value[0].need) {
+              qtyNeed = parseFloat(resultStock.value[0].need);
             }
           }
+          const newNeed = qtyNeed + item.qty;
+          console.log("newNeed", newNeed);
+          console.log("qtyStock", qtyStock);
+          let statusStock = "doNotKnow";
+          if (newNeed > qtyStock) {
+            statusStock = "notEnough";
+          } else {
+            statusStock = "enough";
+          }
           await dbInventoryOperational.create({
             code: code.CodeUtil.getCode({ chars: 4, prefix: "OPS-I" }),
             status: "plan",
-            inventoryOperationalTypeId: new bson.ObjectId(
+            inventoryOperationalTypeId: new core.ObjectId(
               inventoryOperationalTypeId
             ),
             itemId: item.itemId,
@@ -1453,8 +1822,30 @@ const classSessionInventoryPreparation = operation.Action.define({
             inventorySessionId: item.id,
             classSessionId: input.classSessionId,
             qtyStock,
-            qty: item.qty
+            qty: item.qty,
+            statusStock
           });
+          if (getStock > 0) {
+            const updateStock = await dbStock2.updateOne(
+              { _id: resultStock.value[0].id },
+              {
+                need: newNeed,
+                status: statusStock
+              }
+            );
+            console.log("update stock");
+            console.log("updateStock", updateStock);
+          } else {
+            console.log("insert stock");
+            await dbStock2.create({
+              itemId: item.itemId,
+              branchId: item.branchId,
+              roomId: item.roomId,
+              need: newNeed,
+              status: statusStock,
+              stock: 0
+            });
+          }
         }
         const updateClassSession2 = await dbInventorySession.updateOne(
           { _id: item.id },
@@ -1493,20 +1884,22 @@ const createManySession = operation.Action.define({
     guard(input, "inputRequired");
     const dbs = stream.core.dbs;
     const dbSession = dbs["neu-jadwal"].models["neu:jadwal:classSession"];
-    const sekarang = new Date(input.startedAt);
-    let besok = /* @__PURE__ */ new Date();
+    const sekarangStartedAt = new Date(input.repeatStartedAt);
+    const sekarangEndedAt = new Date(input.repeatEndedAt);
+    let besokStartedAt = /* @__PURE__ */ new Date();
+    let besokEndedAt = /* @__PURE__ */ new Date();
     let intervalCount = 0;
+    const lokasi = input.type !== "online" ? "building" : null;
+    const bangunan = input.type !== "online" ? input.buildingId : null;
+    const ruangan = input.type !== "online" ? input.roomId : null;
     for (let i = 0; i < input.frequency; i++) {
-      intervalCount += input.interval;
-      besok = date.DateUtil.add(sekarang, { days: intervalCount }) || /* @__PURE__ */ new Date();
-      const startedAt = date.DateUtil.set(besok, {
-        minutes: 0,
+      besokStartedAt = date.DateUtil.add(sekarangStartedAt, { days: intervalCount }) || /* @__PURE__ */ new Date();
+      const startedAt = date.DateUtil.set(besokStartedAt, {
         seconds: 0,
         milliseconds: 0
       });
-      let endedAt = date.DateUtil.add(besok, { hours: 1 });
-      endedAt = date.DateUtil.set(endedAt, {
-        minutes: 30,
+      besokEndedAt = date.DateUtil.add(sekarangEndedAt, { days: intervalCount }) || /* @__PURE__ */ new Date();
+      const endedAt = date.DateUtil.set(besokEndedAt, {
         seconds: 0,
         milliseconds: 0
       });
@@ -1516,8 +1909,18 @@ const createManySession = operation.Action.define({
         isTeacherShown: true,
         isTeacherSubtituted: false,
         startedAt: startedAt?.toISOString(),
-        endedAt: endedAt?.toISOString()
+        endedAt: endedAt?.toISOString(),
+        buildingId: bangunan,
+        roomId: ruangan,
+        type: input.type,
+        locationType: lokasi,
+        branchIds: input.branchIds,
+        isTitleSession: false,
+        subjectIds: input.subjectIds,
+        teacherIds: input.teacherRepeaterIds,
+        classSessionPurposeId: input.classSessionPurposeId
       });
+      intervalCount += input.interval;
     }
     return core.Result.ok({
       state: "manySessionCreate",
@@ -1529,6 +1932,39 @@ const createManySession = operation.Action.define({
   }
 });
 
+const deleteManySession = operation.Action.define({
+  key: "deleteManySession",
+  name: "Delete ManySession",
+  type: "command",
+  category: "domain",
+  execute: async (input, stream) => {
+    guard(stream, "streamRequired");
+    guard(input, "inputRequired");
+    const dbs = stream.core.dbs;
+    const dbSession = dbs["neu-jadwal"].models["neu:jadwal:classSession"];
+    const findAllSesi = await dbSession.updateMany(
+      {
+        groupIds: { $in: input.groupId },
+        status: { $eq: "draft" },
+        deletedAt: { $eq: null }
+      },
+      {
+        $set: {
+          deletedAt: /* @__PURE__ */ new Date()
+        }
+      }
+    );
+    console.log({ findAllSesi });
+    return core.Result.ok({
+      state: "manySessionDelete",
+      message: "Many Session has been delete.",
+      data: {
+        code: 1
+      }
+    });
+  }
+});
+
 const prepareConflict = operation.Action.define({
   key: "prepareConflict",
   name: "Prepare Conflict",
@@ -1767,6 +2203,276 @@ async function _getUserStats(stream, input) {
   return result;
 }
 
+const LIMIT_INFINITY = 999999;
+
+function useJadwal(stream) {
+  guard(stream, "streamRequired");
+  const actions = stream.actions.data;
+  return {
+    getClassSessions,
+    getManyClassSessions,
+    updateBatchClassSessions,
+    syncManyClassSessions
+  };
+  async function getClassSessions(query) {
+    const result = await actions.getMany.execute(
+      { model: "neu:jadwal:classSession", query },
+      stream
+    );
+    if (result.isFailure)
+      throw result;
+    const items = result.value;
+    const meta = value.ValueUtil.omitValues(result.payload.meta || {}, [
+      "model",
+      "query"
+    ]);
+    return { items, meta };
+  }
+  async function getManyClassSessions(input) {
+    const result = await actions.getMany.execute(
+      {
+        model: "neu:jadwal:classSession",
+        query: query.Query.define({
+          filter: input.filter,
+          limit: LIMIT_INFINITY,
+          fields: input.fragment
+        })
+      },
+      stream
+    );
+    if (result.isFailure)
+      throw result;
+    return result.value;
+  }
+  async function updateBatchClassSessions(classSessions) {
+    const operations = [];
+    for (const classSession of classSessions) {
+      const { id, ...data } = classSession;
+      operations.push({
+        updateOne: {
+          filter: { _id: id },
+          update: {
+            $set: data
+          }
+        }
+      });
+      await stream?.core.dbs["neu-jadwal"].models["neu:jadwal:classSession"].bulkWrite(operations);
+    }
+    const ids = classSessions.map((s) => s.id);
+    const filter = { _id: { $in: ids } };
+    await syncManyClassSessions(filter);
+    await syncManyClassSessions(filter);
+    await syncManyClassSessions(filter);
+  }
+  async function syncManyClassSessions(filter) {
+    await actions.syncMany.execute(
+      {
+        model: "neu:jadwal:classSession",
+        useDry: false,
+        query: query.Query.define({
+          filter,
+          limit: LIMIT_INFINITY
+        })
+      },
+      stream
+    );
+  }
+}
+
+const GetClassSessionConflictsSchema = z.z.object({
+  // startedAt: z.string().datetime().explain({ label: 'Started At' }),
+  // endedAt: z.string().datetime().explain({ label: 'Ended At' }),
+  filter: z.z.any().explain({ label: "Filter" })
+});
+
+const getClassSessionConflicts = operation.Action.define({
+  key: "getClassSessionConflicts",
+  name: "Get Class Session Conflicts",
+  type: "command",
+  category: "domain",
+  execute: async (input, stream) => {
+    const { getActorId } = operation.useStream(stream);
+    const { validate } = operation.useValidation(stream, GetClassSessionConflictsSchema);
+    const { getManyClassSessions } = useJadwal(stream);
+    try {
+      getActorId({ throw: true });
+      const data = validate(input);
+      const classSessions = await getManyClassSessions({
+        filter: data.filter,
+        fragment: {
+          id: 1,
+          _conflicts: 1
+        }
+      });
+      const teacherConflicts = classSessions.reduce((all, classSession) => {
+        const conflicts = classSession._conflicts?.teacherConflicts || [];
+        return all.concat(conflicts);
+      }, []);
+      const roomConflicts = classSessions.reduce((all, classSession) => {
+        const conflicts = classSession._conflicts?.roomConflicts || [];
+        return all.concat(conflicts);
+      }, []);
+      const commitmentConflicts = classSessions.reduce((all, classSession) => {
+        const conflicts = classSession._conflicts?.commitmentConflicts || [];
+        return all.concat(conflicts);
+      }, []);
+      const classSessionCount = classSessions.length;
+      const teacherConflictCount = teacherConflicts.length;
+      const roomConflictCount = roomConflicts.length;
+      const commitmentConflictCount = commitmentConflicts.length;
+      return core.Result.ok({
+        state: "classSessionConflictsFound",
+        message: "Class session conflicts found.",
+        data: {
+          classSessionCount,
+          teacherConflictCount,
+          roomConflictCount,
+          commitmentConflictCount
+        }
+      });
+    } catch (error) {
+      if (error?.isFailure)
+        throw error;
+      console.error(error);
+      return core.Result.fail({
+        state: `getClassSessionConflictsFailed`,
+        message: `Failed to get class session conflicts.`,
+        error: error?.toString()
+      });
+    }
+  }
+});
+
+const SyncClassSessionsSchema = z.z.object({
+  all: z.z.boolean().optional().explain({ label: "All" }),
+  return: z.z.boolean().optional().explain({ label: "Return" }),
+  classSessionIds: z.z.array(z.z.objectId()).optional().explain({
+    label: "Class Session IDs"
+  }),
+  startedAt: z.z.string().datetime().optional().explain({ label: "Started At" }),
+  endedAt: z.z.string().datetime().optional().explain({ label: "Ended At" })
+});
+
+const syncClassSessions = operation.Action.define({
+  key: "syncClassSessions",
+  name: "Sync Class Sessions",
+  type: "command",
+  category: "domain",
+  execute: async (input, stream) => {
+    const log = useLog("syncClassSessions", false);
+    const { getActorId } = operation.useStream(stream);
+    const { validate } = operation.useValidation(stream, SyncClassSessionsSchema);
+    const { getManyClassSessions, updateBatchClassSessions } = useJadwal(stream);
+    const fragment = {
+      id: 1,
+      title: 1,
+      subtitle: 1,
+      type: 1,
+      startedAt: 1,
+      endedAt: 1,
+      day: 1,
+      shortInformationSession: 1,
+      teacherIds: 1,
+      roomId: 1,
+      branches: { id: 1, name: 1 },
+      room: { id: 1, name: 1, branches: { id: 1 } },
+      teachers: { id: 1, name: 1, hourStart: 1, hourEnd: 1, weekdays: 1 }
+    };
+    try {
+      getActorId({ throw: true });
+      const data = validate(input);
+      log.object("input", data);
+      if (!data.all && !data.classSessionIds?.length && !data.startedAt && !data.endedAt) {
+        return core.Result.ok({
+          state: "noClassSessionsSynced",
+          message: "No class sessions synced.",
+          data: {}
+        });
+      }
+      let classSessions = [];
+      let otherClassSessions = [];
+      if (data.all) {
+        classSessions = await getManyClassSessions({
+          filter: {},
+          fragment
+        });
+        otherClassSessions = classSessions;
+      } else if (data.startedAt && data.endedAt) {
+        classSessions = await getManyClassSessions({
+          filter: {
+            $or: period.PeriodUtil.getPassingPeriodFilter(
+              "startedAt",
+              "endedAt",
+              data.startedAt,
+              data.endedAt
+            )
+          },
+          fragment
+        });
+        otherClassSessions = classSessions;
+      } else {
+        classSessions = await getManyClassSessions({
+          filter: { _id: { $in: data.classSessionIds } },
+          fragment
+        });
+        const earliestStartedAt = classSessions.reduce((earliest, s) => {
+          if (!s.startedAt)
+            return earliest;
+          if (!earliest)
+            return s.startedAt;
+          return earliest < s.startedAt ? earliest : s.startedAt;
+        }, "");
+        const latestEndedAt = classSessions.reduce((latest, s) => {
+          if (!s.endedAt)
+            return latest;
+          if (!latest)
+            return s.endedAt;
+          return latest > s.endedAt ? latest : s.endedAt;
+        }, "");
+        otherClassSessions = await getManyClassSessions({
+          filter: {
+            $or: period.PeriodUtil.getPassingPeriodFilter(
+              "startedAt",
+              "endedAt",
+              earliestStartedAt,
+              latestEndedAt
+            )
+          },
+          fragment
+        });
+      }
+      const updates = classSessions.map((classSession) => {
+        const _conflicts = jadwalModels.ClassSessionUtil.getConflicts({
+          classSession,
+          classSessions: otherClassSessions
+        });
+        const conflict = jadwalModels.ClassSessionUtil.formatText(_conflicts);
+        return {
+          id: classSession.id,
+          _conflicts,
+          conflict
+        };
+      });
+      log.object("updates", updates);
+      await updateBatchClassSessions(updates);
+      return core.Result.ok({
+        state: "classSessionsSynced",
+        message: "Class sessions synced.",
+        data: data.return ? { updates } : {}
+      });
+    } catch (error) {
+      if (error?.isFailure)
+        throw error;
+      console.error(error);
+      return core.Result.fail({
+        state: `syncClassSessionsFailed`,
+        message: `Failed to sync class sessions.`,
+        error: error?.toString()
+      });
+    }
+  }
+});
+
 const getGradingCount = operation.Action.define({
   key: "getGradingCount",
   name: "Get GradingCount",
@@ -1854,13 +2560,18 @@ async function _getOneStudent(stream, userId) {
           levels: { id: 1, name: 1 },
           branches: { id: 1, name: 1 },
           seniorSchools: { id: 1, name: 1 },
+          classGroups: {
+            id: 1,
+            name: 1
+          },
           nis: 1,
           nis2: 1,
           phoneSms: 1,
           phone: 1,
           whatsapp: 1,
           email: 1,
-          note: 1
+          note: 1,
+          point: 1
         }
       })
     },
@@ -1939,6 +2650,7 @@ async function _getOneStaff(stream, userId) {
             name: 1,
             rooms: {
               id: 1,
+              buildingId: 1,
               name: 1
             }
           },
@@ -3131,7 +3843,6 @@ function registerOfficePendidikanHooks(hook) {
   hook.onExecute(
     "action:neu:jadwal:classSession:updateOne:after",
     async (payload, _meta, stream) => {
-      console.log(payload);
       const result = await stream.actions.data.syncMany.execute(
         {
           model: "neu:jadwal:classSession",
@@ -3155,6 +3866,101 @@ function registerOfficePendidikanHooks(hook) {
       return payload;
     }
   );
+  hook.onExecute(
+    "action:neu:jadwal:classSession:updateOne:after",
+    async (payload, _meta, stream) => {
+      const dbs = stream.core.dbs;
+      const result = await stream.actions.data.getOne.execute(
+        {
+          model: "neu:jadwal:classSession",
+          id: payload.output.id,
+          query: query.Query.define({
+            fields: {
+              subjects: {
+                name: 1
+              },
+              isTitleSession: 1,
+              stage: {
+                name: 1
+              },
+              classSessionPurpose: {
+                name: 1
+              }
+            }
+          })
+        },
+        stream
+      );
+      const nameSubjects = result.value?.subjects.map((field) => field.name).join(", ");
+      const subtitle = [];
+      if (result.value?.stage) {
+        subtitle.push(result.value?.stage?.name);
+      }
+      if (result.value?.classSessionPurpose) {
+        subtitle.push(result.value?.classSessionPurpose?.name);
+      }
+      const resultSubtitle = subtitle.join(" | ");
+      const dbSession = dbs["neu-jadwal"].models["neu:jadwal:classSession"];
+      if (result.value?.isTitleSession == false) {
+        await dbSession.updateOne(
+          { _id: payload.output.id },
+          { $set: { title: nameSubjects, subtitle: resultSubtitle } }
+        );
+      }
+    }
+  );
+  hook.onExecute(
+    "action:neu:jadwal:classSession:createOne:after",
+    async (payload, _meta, stream) => {
+      const dbs = stream.core.dbs;
+      const result = await stream.actions.data.getOne.execute(
+        {
+          model: "neu:jadwal:classSession",
+          id: payload.output.id,
+          query: query.Query.define({
+            fields: {
+              subjects: {
+                name: 1
+              },
+              isTitleSession: 1,
+              stage: {
+                name: 1
+              },
+              classSessionPurpose: {
+                name: 1
+              },
+              levels: {
+                name: 1
+              }
+            }
+          })
+        },
+        stream
+      );
+      const nameSubjects = result.value?.subjects.map((field) => field.name).join(", ");
+      const subtitle = [];
+      if (result.value?.stage) {
+        subtitle.push(result.value?.stage?.name);
+      }
+      if (result.value?.classSessionPurpose) {
+        subtitle.push(result.value?.classSessionPurpose?.name);
+      }
+      const resultSubtitle = subtitle.join(" | ");
+      const dbSession = dbs["neu-jadwal"].models["neu:jadwal:classSession"];
+      if (result.value?.isTitleSession == false) {
+        await dbSession.updateOne(
+          { _id: payload.output.id },
+          { $set: { title: nameSubjects, subtitle: resultSubtitle } }
+        );
+      }
+      if (result.value?.levels.length > 0) {
+        await dbSession.updateOne(
+          { _id: payload.output.id },
+          { $set: { title: nameSubjects, subtitle: resultSubtitle } }
+        );
+      }
+    }
+  );
 }
 
 const actions = {
@@ -3174,6 +3980,11 @@ const actions = {
   createManySession,
   prepareConflict,
   userCountStats,
+  deleteManySession,
+  syncStudentAdmisi,
+  checkClassAttendance,
+  syncClassSessions,
+  getClassSessionConflicts,
   // Penilaian
   getGradingCount,
   // Rasionalisasi
@@ -3198,7 +4009,9 @@ const actions = {
   sendQuestion
 };
 
+exports.GetClassSessionConflictsSchema = GetClassSessionConflictsSchema;
 exports.PrepareExperienceSchema = PrepareExperienceSchema;
+exports.SyncClassSessionsSchema = SyncClassSessionsSchema;
 exports._calculateComparison = _calculateComparison;
 exports.acceptQuestion = acceptQuestion;
 exports.actions = actions;
@@ -3207,6 +4020,7 @@ exports.allConflict = allConflict;
 exports.calculateGrading = calculateGrading;
 exports.calculateManyComparator = calculateManyComparator;
 exports.calculateOneComparator = calculateOneComparator;
+exports.checkClassAttendance = checkClassAttendance;
 exports.classSessionInventoryOccurs = classSessionInventoryOccurs;
 exports.classSessionInventoryPreparation = classSessionInventoryPreparation;
 exports.clearAllOverrides = clearAllOverrides;
@@ -3214,8 +4028,10 @@ exports.clearGrading = clearGrading;
 exports.clearOneOverrides = clearOneOverrides;
 exports.createGradingAndScores = createGradingAndScores;
 exports.createManySession = createManySession;
+exports.deleteManySession = deleteManySession;
 exports.editAnswer = editAnswer;
 exports.generateGrading = generateGrading;
+exports.getClassSessionConflicts = getClassSessionConflicts;
 exports.getGradingCount = getGradingCount;
 exports.getQuestionCount = getQuestionCount;
 exports.getStaffId = getStaffId;
@@ -3230,8 +4046,10 @@ exports.rasionalizeGrading = rasionalizeGrading;
 exports.registerOfficePendidikanHooks = registerOfficePendidikanHooks;
 exports.sendAnswer = sendAnswer;
 exports.sendQuestion = sendQuestion;
+exports.syncClassSessions = syncClassSessions;
 exports.syncCommitment = syncCommitment;
 exports.syncModel = syncModel;
+exports.syncStudentAdmisi = syncStudentAdmisi;
 exports.syncStudentBranch = syncStudentBranch;
 exports.syncStudentInformation = syncStudentInformation;
 exports.updateGradingAndScores = updateGradingAndScores;