@neutron.co.id/pendidikan-operation 1.29.7 → 1.30.0

package/build/@packages/pendidikan-operation/@package/actions/giveModuleAccessByProgram/giveModuleAccessByProgram.action.cjs

@@ -0,0 +1,200 @@
+'use strict';
+
+const core = require('@neon.id/core');
+const operation = require('@neon.id/operation');
+const utils = require('@neon.id/utils');
+const useAkademik = require('../../providers/akademik/useAkademik.cjs');
+const query = require('@neon.id/query');
+const giveModuleAccessByProgram_schema = require('./giveModuleAccessByProgram.schema.cjs');
+const useTelemetry = require('../../providers/useTelemetry.cjs');
+
+const giveModuleAccessByProgram = operation.Action.define({
+  key: "giveModuleAccessByProgram",
+  name: "Refresh Module Access",
+  type: "command",
+  category: "domain",
+  execute: async (input, stream) => {
+    if (!stream)
+      throw core.Result.fail("streamRequired");
+    const { validate } = operation.useValidation(stream, giveModuleAccessByProgram_schema.GiveModuleAccessByProgramSchema);
+    const { getManyModules, getManyStudentProgram, setGerbangAccess, deleteGerbangAccess } = useAkademik.useAkademik(stream);
+    const data = validate(input);
+    const dbs = stream.core.dbs;
+    const dbStudentProgram = dbs["neu-akademik"].models["neu:akademik:studentProgram"];
+    return useTelemetry.useTelemetry(
+      stream,
+      "giveModuleAccessByProgram",
+      {
+        userId: stream?.context?.identitas?.userId,
+        data
+      },
+      async () => {
+        try {
+          const { items: studentPrograms } = await getManyStudentProgram({
+            query: query.Query.define({
+              filter: { _id: { $in: data.studentProgramIds } },
+              fields: {
+                id: 1,
+                paymentStatus: 1,
+                startedAt: 1,
+                endedAt: 1,
+                virtualCourseCollection: {
+                  id: 1,
+                  name: 1,
+                  neutronModules: { id: 1 }
+                },
+                studentId: 1,
+                student: { id: 1, email: 1, userId: 1 }
+              }
+            })
+          });
+          const now = Date.now();
+          for (const sp of studentPrograms) {
+            utils.guard(sp, "studentProgramNotFound");
+            utils.guard(sp.paymentStatus === "paid", "studentProgramIsNotPaid");
+            if (sp.startedAt && sp.endedAt) {
+              const startedAt = new Date(sp.startedAt).getTime();
+              const endedAt = new Date(sp.endedAt).getTime();
+              utils.guard(
+                now > startedAt || now < endedAt,
+                "studentProgramPeriodExpired"
+              );
+            }
+          }
+          const allModuleIds = [
+            ...new Set(
+              studentPrograms.flatMap(
+                (sp) => sp.virtualCourseCollection?.flatMap(
+                  (x) => x.neutronModules?.map((m) => m.id || "") || []
+                ) || []
+              )
+            )
+          ];
+          const userIds = studentPrograms.map((sp) => sp.student?.userId || "");
+          const deleteManyQuery = {
+            givenTo: { $in: userIds },
+            $and: [
+              { "meta.moduleId": { $exists: true } },
+              { "meta.moduleId": { $nin: allModuleIds } }
+            ]
+          };
+          await deleteGerbangAccess(deleteManyQuery);
+          const { items: modules } = await getManyModules({
+            query: _prepareQueryModules({ moduleIds: allModuleIds })
+          });
+          utils.guard(modules?.length, "moduleNotFound");
+          const moduleMap = new Map(modules.map((m) => [m.id, m]));
+          const bulkOps = studentPrograms.flatMap(
+            (sp) => (sp.virtualCourseCollection ?? []).flatMap(
+              (vc) => (vc.neutronModules ?? []).flatMap((nm) => {
+                const module = moduleMap.get(nm.id);
+                if (!module)
+                  return [];
+                const key = `neu:app:module:${module.id}`;
+                const statements = prepareStatements(
+                  module.courseCollectionIds || []
+                );
+                return [
+                  {
+                    updateOne: {
+                      filter: { key, givenTo: sp.student?.userId },
+                      update: {
+                        $set: {
+                          key,
+                          status: "active",
+                          givenBy: data.staffId,
+                          givenTo: sp.student?.userId,
+                          applicationId: "61b41fc1db516fc9dcdc0eec",
+                          statements,
+                          startedAt: sp.startedAt,
+                          endedAt: sp.endedAt,
+                          meta: { moduleId: new core.ObjectId(module.id) },
+                          version: "2022-07-21",
+                          updatedAt: /* @__PURE__ */ new Date(),
+                          updatedBy: data.staffId
+                        },
+                        $setOnInsert: {
+                          createdAt: /* @__PURE__ */ new Date(),
+                          createdBy: data.staffId
+                        }
+                      },
+                      upsert: true
+                    }
+                  }
+                ];
+              })
+            )
+          );
+          await setGerbangAccess(bulkOps);
+          const allKeys = modules.map((m) => `neu:app:module:${m.id}`);
+          await stream.actions.data.syncMany.execute(
+            {
+              model: "neo:gerbang:access",
+              useDry: false,
+              query: query.Query.define({
+                filter: { key: { $in: allKeys }, givenTo: { $in: userIds } }
+              })
+            },
+            stream
+          );
+          await dbStudentProgram.updateMany(
+            { _id: { $in: data.studentProgramIds } },
+            { $set: { givenAt: /* @__PURE__ */ new Date() } }
+          );
+          await stream.actions.data.syncMany.execute(
+            {
+              model: "neu:akademik:studentProgram",
+              useDry: false,
+              query: query.Query.define({
+                filter: { _id: { $in: data.studentProgramIds } },
+                fields: { id: 1 }
+              })
+            },
+            stream
+          );
+          return core.Result.ok({
+            state: "moduleRefreshed",
+            message: "Module refreshed.",
+            data: {}
+          });
+        } catch (error) {
+          if (error?.isFailure)
+            throw error;
+          console.error(error);
+          return core.Result.fail({
+            state: `giveModuleAccessByProgramFailed`,
+            message: `Failed to set module.`,
+            error: error?.toString()
+          });
+        }
+      }
+    );
+  }
+});
+function _prepareQueryModules(input) {
+  return query.Query.define({
+    filter: {
+      _id: { $in: input.moduleIds }
+    },
+    fields: {
+      id: 1,
+      name: 1,
+      code: 1,
+      status: 1,
+      startedAt: 1,
+      endedAt: 1,
+      courseCollectionIds: 1
+    }
+  });
+}
+function prepareStatements(ids) {
+  return ids.map((id) => {
+    return {
+      effect: "allow",
+      action: "neo:belajar:learnCourse",
+      object: `neo:belajar:courseCollection:${id}`
+    };
+  });
+}
+
+exports.giveModuleAccessByProgram = giveModuleAccessByProgram;

package/build/@packages/pendidikan-operation/@package/actions/giveModuleAccessByProgram/giveModuleAccessByProgram.action.mjs

@@ -0,0 +1,198 @@
+import { Result, ObjectId } from '@neon.id/core';
+import { Action, useValidation } from '@neon.id/operation';
+import { guard } from '@neon.id/utils';
+import { useAkademik } from '../../providers/akademik/useAkademik.mjs';
+import { Query } from '@neon.id/query';
+import { GiveModuleAccessByProgramSchema } from './giveModuleAccessByProgram.schema.mjs';
+import { useTelemetry } from '../../providers/useTelemetry.mjs';
+
+const giveModuleAccessByProgram = Action.define({
+  key: "giveModuleAccessByProgram",
+  name: "Refresh Module Access",
+  type: "command",
+  category: "domain",
+  execute: async (input, stream) => {
+    if (!stream)
+      throw Result.fail("streamRequired");
+    const { validate } = useValidation(stream, GiveModuleAccessByProgramSchema);
+    const { getManyModules, getManyStudentProgram, setGerbangAccess, deleteGerbangAccess } = useAkademik(stream);
+    const data = validate(input);
+    const dbs = stream.core.dbs;
+    const dbStudentProgram = dbs["neu-akademik"].models["neu:akademik:studentProgram"];
+    return useTelemetry(
+      stream,
+      "giveModuleAccessByProgram",
+      {
+        userId: stream?.context?.identitas?.userId,
+        data
+      },
+      async () => {
+        try {
+          const { items: studentPrograms } = await getManyStudentProgram({
+            query: Query.define({
+              filter: { _id: { $in: data.studentProgramIds } },
+              fields: {
+                id: 1,
+                paymentStatus: 1,
+                startedAt: 1,
+                endedAt: 1,
+                virtualCourseCollection: {
+                  id: 1,
+                  name: 1,
+                  neutronModules: { id: 1 }
+                },
+                studentId: 1,
+                student: { id: 1, email: 1, userId: 1 }
+              }
+            })
+          });
+          const now = Date.now();
+          for (const sp of studentPrograms) {
+            guard(sp, "studentProgramNotFound");
+            guard(sp.paymentStatus === "paid", "studentProgramIsNotPaid");
+            if (sp.startedAt && sp.endedAt) {
+              const startedAt = new Date(sp.startedAt).getTime();
+              const endedAt = new Date(sp.endedAt).getTime();
+              guard(
+                now > startedAt || now < endedAt,
+                "studentProgramPeriodExpired"
+              );
+            }
+          }
+          const allModuleIds = [
+            ...new Set(
+              studentPrograms.flatMap(
+                (sp) => sp.virtualCourseCollection?.flatMap(
+                  (x) => x.neutronModules?.map((m) => m.id || "") || []
+                ) || []
+              )
+            )
+          ];
+          const userIds = studentPrograms.map((sp) => sp.student?.userId || "");
+          const deleteManyQuery = {
+            givenTo: { $in: userIds },
+            $and: [
+              { "meta.moduleId": { $exists: true } },
+              { "meta.moduleId": { $nin: allModuleIds } }
+            ]
+          };
+          await deleteGerbangAccess(deleteManyQuery);
+          const { items: modules } = await getManyModules({
+            query: _prepareQueryModules({ moduleIds: allModuleIds })
+          });
+          guard(modules?.length, "moduleNotFound");
+          const moduleMap = new Map(modules.map((m) => [m.id, m]));
+          const bulkOps = studentPrograms.flatMap(
+            (sp) => (sp.virtualCourseCollection ?? []).flatMap(
+              (vc) => (vc.neutronModules ?? []).flatMap((nm) => {
+                const module = moduleMap.get(nm.id);
+                if (!module)
+                  return [];
+                const key = `neu:app:module:${module.id}`;
+                const statements = prepareStatements(
+                  module.courseCollectionIds || []
+                );
+                return [
+                  {
+                    updateOne: {
+                      filter: { key, givenTo: sp.student?.userId },
+                      update: {
+                        $set: {
+                          key,
+                          status: "active",
+                          givenBy: data.staffId,
+                          givenTo: sp.student?.userId,
+                          applicationId: "61b41fc1db516fc9dcdc0eec",
+                          statements,
+                          startedAt: sp.startedAt,
+                          endedAt: sp.endedAt,
+                          meta: { moduleId: new ObjectId(module.id) },
+                          version: "2022-07-21",
+                          updatedAt: /* @__PURE__ */ new Date(),
+                          updatedBy: data.staffId
+                        },
+                        $setOnInsert: {
+                          createdAt: /* @__PURE__ */ new Date(),
+                          createdBy: data.staffId
+                        }
+                      },
+                      upsert: true
+                    }
+                  }
+                ];
+              })
+            )
+          );
+          await setGerbangAccess(bulkOps);
+          const allKeys = modules.map((m) => `neu:app:module:${m.id}`);
+          await stream.actions.data.syncMany.execute(
+            {
+              model: "neo:gerbang:access",
+              useDry: false,
+              query: Query.define({
+                filter: { key: { $in: allKeys }, givenTo: { $in: userIds } }
+              })
+            },
+            stream
+          );
+          await dbStudentProgram.updateMany(
+            { _id: { $in: data.studentProgramIds } },
+            { $set: { givenAt: /* @__PURE__ */ new Date() } }
+          );
+          await stream.actions.data.syncMany.execute(
+            {
+              model: "neu:akademik:studentProgram",
+              useDry: false,
+              query: Query.define({
+                filter: { _id: { $in: data.studentProgramIds } },
+                fields: { id: 1 }
+              })
+            },
+            stream
+          );
+          return Result.ok({
+            state: "moduleRefreshed",
+            message: "Module refreshed.",
+            data: {}
+          });
+        } catch (error) {
+          if (error?.isFailure)
+            throw error;
+          console.error(error);
+          return Result.fail({
+            state: `giveModuleAccessByProgramFailed`,
+            message: `Failed to set module.`,
+            error: error?.toString()
+          });
+        }
+      }
+    );
+  }
+});
+function _prepareQueryModules(input) {
+  return Query.define({
+    filter: {
+      _id: { $in: input.moduleIds }
+    },
+    fields: {
+      id: 1,
+      name: 1,
+      code: 1,
+      status: 1,
+      startedAt: 1,
+      endedAt: 1,
+      courseCollectionIds: 1
+    }
+  });
+}
+function prepareStatements(ids) {
+  return ids.map((id) => {
+    return {
+      effect: "allow",
+      action: "neo:belajar:learnCourse",
+      object: `neo:belajar:courseCollection:${id}`
+    };
+  });
+}
+
+export { giveModuleAccessByProgram };

package/build/@packages/pendidikan-operation/@package/actions/giveModuleAccessByProgram/giveModuleAccessByProgram.schema.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+const z = require('@neon.id/z');
+
+const GiveModuleAccessByProgramSchema = z.z.object({
+  studentProgramIds: z.z.array(z.z.objectId()).min(1).explain({
+    label: "Student Program IDs"
+  }),
+  staffId: z.z.string().optional().explain({
+    label: "Staff ID"
+  })
+});
+
+exports.GiveModuleAccessByProgramSchema = GiveModuleAccessByProgramSchema;

package/build/@packages/pendidikan-operation/@package/actions/giveModuleAccessByProgram/giveModuleAccessByProgram.schema.mjs

@@ -0,0 +1,12 @@
+import { z } from '@neon.id/z';
+
+const GiveModuleAccessByProgramSchema = z.object({
+  studentProgramIds: z.array(z.objectId()).min(1).explain({
+    label: "Student Program IDs"
+  }),
+  staffId: z.string().optional().explain({
+    label: "Staff ID"
+  })
+});
+
+export { GiveModuleAccessByProgramSchema };

package/build/{providers → @packages/pendidikan-operation/@package/providers}/akademik/useAkademik.cjs

@@ -21,20 +21,22 @@ function useAkademik(stream) {
     getOneModule,
     getManySubjects,
     getManyTopics,
-    getManyStudents
+    getManyStudents,
+    getManyStudentProgram,
+    getOneStudentProgram
   };
   async function setGerbangAccess(operations) {
     console.log(operations);
     await dbGerbang.bulkWrite(operations);
   }
   async function updateGerbangAccess(key, updates) {
-    await dbGerbang.updateMany({ key }, { $set: updates });
+    return await dbGerbang.updateMany({ key }, { $set: updates });
   }
   async function deleteGerbangAccess(filter) {
     await dbGerbang.deleteMany(filter);
   }
   async function syncGerbangAccess(key) {
-    await actions.syncMany.execute(
+    return await actions.syncMany.execute(
       {
         model: "neo:gerbang:access",
         useDry: false,
@@ -90,7 +92,6 @@ function useAkademik(stream) {
     return result.value;
   }
   async function getManyModules(input) {
-    console.log("fragment", input.fragment);
     const result = await actions.getMany.execute(
       {
         model: "neu:akademik:module",
@@ -107,6 +108,54 @@ function useAkademik(stream) {
     ]);
     return { items, meta };
   }
+  async function getOneStudentProgram(stream2, studentProgramId) {
+    const result = await actions.getMany.execute(
+      {
+        model: "neu:akademik:studentProgram",
+        query: query.Query.define({
+          filter: {
+            _id: studentProgramId
+          },
+          fields: {
+            id: 1,
+            programId: 1,
+            paymentStatus: 1,
+            virtualCourseCollectionIds: 1,
+            startedAt: 1,
+            endedAt: 1,
+            virtualCourseCollection: {
+              id: 1,
+              name: 1,
+              neutronModules: {
+                id: 1
+              }
+            }
+          }
+        })
+      },
+      stream2
+    );
+    if (result.isFailure)
+      throw result;
+    return result.value[0];
+  }
+  async function getManyStudentProgram(input) {
+    const result = await actions.getMany.execute(
+      {
+        model: "neu:akademik:studentProgram",
+        query: input.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 getOneModule(stream2, id) {
     const result = await actions.getMany.execute(
       {

package/build/{providers → @packages/pendidikan-operation/@package/providers}/akademik/useAkademik.mjs

@@ -19,20 +19,22 @@ function useAkademik(stream) {
     getOneModule,
     getManySubjects,
     getManyTopics,
-    getManyStudents
+    getManyStudents,
+    getManyStudentProgram,
+    getOneStudentProgram
   };
   async function setGerbangAccess(operations) {
     console.log(operations);
     await dbGerbang.bulkWrite(operations);
   }
   async function updateGerbangAccess(key, updates) {
-    await dbGerbang.updateMany({ key }, { $set: updates });
+    return await dbGerbang.updateMany({ key }, { $set: updates });
   }
   async function deleteGerbangAccess(filter) {
     await dbGerbang.deleteMany(filter);
   }
   async function syncGerbangAccess(key) {
-    await actions.syncMany.execute(
+    return await actions.syncMany.execute(
       {
         model: "neo:gerbang:access",
         useDry: false,
@@ -88,7 +90,6 @@ function useAkademik(stream) {
     return result.value;
   }
   async function getManyModules(input) {
-    console.log("fragment", input.fragment);
     const result = await actions.getMany.execute(
       {
         model: "neu:akademik:module",
@@ -105,6 +106,54 @@ function useAkademik(stream) {
     ]);
     return { items, meta };
   }
+  async function getOneStudentProgram(stream2, studentProgramId) {
+    const result = await actions.getMany.execute(
+      {
+        model: "neu:akademik:studentProgram",
+        query: Query.define({
+          filter: {
+            _id: studentProgramId
+          },
+          fields: {
+            id: 1,
+            programId: 1,
+            paymentStatus: 1,
+            virtualCourseCollectionIds: 1,
+            startedAt: 1,
+            endedAt: 1,
+            virtualCourseCollection: {
+              id: 1,
+              name: 1,
+              neutronModules: {
+                id: 1
+              }
+            }
+          }
+        })
+      },
+      stream2
+    );
+    if (result.isFailure)
+      throw result;
+    return result.value[0];
+  }
+  async function getManyStudentProgram(input) {
+    const result = await actions.getMany.execute(
+      {
+        model: "neu:akademik:studentProgram",
+        query: input.query
+      },
+      stream
+    );
+    if (result.isFailure)
+      throw result;
+    const items = result.value;
+    const meta = ValueUtil.omitValues(result.payload.meta || {}, [
+      "model",
+      "query"
+    ]);
+    return { items, meta };
+  }
   async function getOneModule(stream2, id) {
     const result = await actions.getMany.execute(
       {

package/build/_virtual/_commonjsHelpers.cjs

@@ -0,0 +1,5 @@
+'use strict';
+
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+exports.commonjsGlobal = commonjsGlobal;

package/build/_virtual/_commonjsHelpers.mjs

@@ -0,0 +1,3 @@
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+export { commonjsGlobal };

package/build/_virtual/papaparse.cjs

@@ -0,0 +1,5 @@
+'use strict';
+
+var papaparse = {exports: {}};
+
+exports.__module = papaparse;

package/build/_virtual/papaparse.mjs

@@ -0,0 +1,3 @@
+var papaparse = {exports: {}};
+
+export { papaparse as __module };

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

@@ -7,7 +7,7 @@ export interface CheckStudentProgramExistanceOutput {
 export interface CheckStudentProgramExistanceMeta {
 }
 export declare const checkStudentProgramExistance: Action<"checkStudentProgramExistance", {
-    studentId: string;
     programId: string;
+    studentId: string;
 }, CheckStudentProgramExistanceOutput, CheckStudentProgramExistanceMeta>;
 export type CheckStudentProgramExistanceAction = typeof checkStudentProgramExistance;

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

@@ -3,9 +3,9 @@ export declare const CheckStudentProgramExistanceSchema: z.ZodObject<{
     studentId: z.ZodString;
     programId: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    studentId: string;
     programId: string;
-}, {
     studentId: string;
+}, {
     programId: string;
+    studentId: string;
 }>;

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

@@ -0,0 +1,13 @@
+import { Action } from '@neon.id/operation';
+import type { z } from '@neon.id/z';
+import { DeleteStudentProgramSchema } from './deleteStudentProgram.schema';
+export type DeleteStudentProgramInput = z.parse<typeof DeleteStudentProgramSchema>;
+export interface DeleteStudentProgramOutput {
+    code: number;
+}
+export interface DeleteStudentProgramMeta {
+}
+export declare const deleteStudentProgram: Action<"deleteStudentProgram", {
+    studentProgramId: string;
+}, DeleteStudentProgramOutput, DeleteStudentProgramMeta>;
+export type DeleteStudentProgramAction = typeof deleteStudentProgram;

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

@@ -0,0 +1,8 @@
+import { z } from '@neon.id/z';
+export declare const DeleteStudentProgramSchema: z.ZodObject<{
+    studentProgramId: z.ZodEffects<z.ZodString, string, string>;
+}, "strip", z.ZodTypeAny, {
+    studentProgramId: string;
+}, {
+    studentProgramId: string;
+}>;

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

@@ -0,0 +1 @@
+export * from './deleteStudentProgram.action';

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

@@ -0,0 +1,13 @@
+import { Action } from '@neon.id/operation';
+import type { z } from '@neon.id/z';
+import { ExportStudentProgramSchema } from './exportStudentProgram.schema';
+export type ExportStudentProgramInput = z.parse<typeof ExportStudentProgramSchema>;
+export interface ExportStudentProgramOutput {
+    url: string;
+}
+export interface ExportStudentProgramMeta {
+}
+export declare const exportStudentProgram: Action<"exportStudentProgram", {
+    branchIds?: string[] | undefined;
+}, ExportStudentProgramOutput, ExportStudentProgramMeta>;
+export type ExportStudentProgramAction = typeof exportStudentProgram;