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

package/build/actions/checkProgramExistance/checkProgramExistance.action.cjs

@@ -0,0 +1,64 @@
+'use strict';
+
+const core = require('@neon.id/core');
+const operation = require('@neon.id/operation');
+const utils = require('@neon.id/utils');
+const query = require('@neon.id/query');
+const checkProgramExistance_schema = require('./checkProgramExistance.schema.cjs');
+const useTelemetry = require('../../providers/useTelemetry.cjs');
+
+const checkProgramExistance = operation.Action.define({
+  key: "checkProgramExistance",
+  name: "Import Data",
+  type: "command",
+  category: "domain",
+  execute: async (input, stream) => {
+    utils.guard(stream, "streamRequired");
+    const { validate } = operation.useValidation(stream, checkProgramExistance_schema.CheckProgramExistanceSchema);
+    const actions = stream.actions.data;
+    const data = validate(input);
+    return useTelemetry.useTelemetry(stream, "importData", {
+      userId: stream.context.identitas.userId,
+      data
+    }, async () => {
+      const { getActorId } = operation.useStream(stream);
+      try {
+        getActorId({ throw: true });
+        console.log("data", data);
+        const programs = await actions.getMany.execute({
+          model: "neu:akademik:program",
+          query: query.Query.define({
+            filter: {
+              $or: [
+                { name: data.name },
+                { code: data.code }
+              ]
+            },
+            fields: {
+              id: 1
+            }
+          })
+        }, stream);
+        const isExist = programs?.value?.length > 0;
+        return core.Result.ok({
+          state: "checkProgramExistance",
+          message: "Check Program Existance",
+          data: {
+            isExist
+          }
+        });
+      } catch (error) {
+        if (error?.isFailure)
+          throw error;
+        console.error(error);
+        return core.Result.fail({
+          state: `checkProgramExistanceFailed`,
+          message: `Failed to check existance program.`,
+          error: error?.toString()
+        });
+      }
+    });
+  }
+});
+
+exports.checkProgramExistance = checkProgramExistance;

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

@@ -0,0 +1,13 @@
+import { Action } from '@neon.id/operation';
+import type { z } from '@neon.id/z';
+import { CheckProgramExistanceSchema } from './checkProgramExistance.schema';
+export type CheckProgramExistanceInput = z.parse<typeof CheckProgramExistanceSchema>;
+export interface CheckProgramExistanceOutput {
+}
+export interface CheckProgramExistanceMeta {
+}
+export declare const checkProgramExistance: Action<"checkProgramExistance", {
+    name: string;
+    code: string;
+}, CheckProgramExistanceOutput, CheckProgramExistanceMeta>;
+export type CheckProgramExistanceAction = typeof checkProgramExistance;

package/build/actions/checkProgramExistance/checkProgramExistance.action.mjs

@@ -0,0 +1,62 @@
+import { Result } from '@neon.id/core';
+import { Action, useValidation, useStream } from '@neon.id/operation';
+import { guard } from '@neon.id/utils';
+import { Query } from '@neon.id/query';
+import { CheckProgramExistanceSchema } from './checkProgramExistance.schema.mjs';
+import { useTelemetry } from '../../providers/useTelemetry.mjs';
+
+const checkProgramExistance = Action.define({
+  key: "checkProgramExistance",
+  name: "Import Data",
+  type: "command",
+  category: "domain",
+  execute: async (input, stream) => {
+    guard(stream, "streamRequired");
+    const { validate } = useValidation(stream, CheckProgramExistanceSchema);
+    const actions = stream.actions.data;
+    const data = validate(input);
+    return useTelemetry(stream, "importData", {
+      userId: stream.context.identitas.userId,
+      data
+    }, async () => {
+      const { getActorId } = useStream(stream);
+      try {
+        getActorId({ throw: true });
+        console.log("data", data);
+        const programs = await actions.getMany.execute({
+          model: "neu:akademik:program",
+          query: Query.define({
+            filter: {
+              $or: [
+                { name: data.name },
+                { code: data.code }
+              ]
+            },
+            fields: {
+              id: 1
+            }
+          })
+        }, stream);
+        const isExist = programs?.value?.length > 0;
+        return Result.ok({
+          state: "checkProgramExistance",
+          message: "Check Program Existance",
+          data: {
+            isExist
+          }
+        });
+      } catch (error) {
+        if (error?.isFailure)
+          throw error;
+        console.error(error);
+        return Result.fail({
+          state: `checkProgramExistanceFailed`,
+          message: `Failed to check existance program.`,
+          error: error?.toString()
+        });
+      }
+    });
+  }
+});
+
+export { checkProgramExistance };

package/build/actions/checkProgramExistance/checkProgramExistance.schema.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+const z = require('@neon.id/z');
+
+const CheckProgramExistanceSchema = z.z.object({
+  name: z.z.string().explain({ label: "Program Name" }),
+  code: z.z.string().explain({ label: "Program Code" })
+});
+
+exports.CheckProgramExistanceSchema = CheckProgramExistanceSchema;

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

@@ -0,0 +1,11 @@
+import { z } from '@neon.id/z';
+export declare const CheckProgramExistanceSchema: z.ZodObject<{
+    name: z.ZodString;
+    code: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    code: string;
+}, {
+    name: string;
+    code: string;
+}>;

package/build/actions/checkProgramExistance/checkProgramExistance.schema.mjs

@@ -0,0 +1,8 @@
+import { z } from '@neon.id/z';
+
+const CheckProgramExistanceSchema = z.object({
+  name: z.string().explain({ label: "Program Name" }),
+  code: z.string().explain({ label: "Program Code" })
+});
+
+export { CheckProgramExistanceSchema };

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

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

package/build/actions/checkStudentProgramExistance/checkStudentProgramExistance.action.cjs

@@ -0,0 +1,65 @@
+'use strict';
+
+const core = require('@neon.id/core');
+const operation = require('@neon.id/operation');
+const utils = require('@neon.id/utils');
+const query = require('@neon.id/query');
+const checkStudentProgramExistance_schema = require('./checkStudentProgramExistance.schema.cjs');
+const useTelemetry = require('../../providers/useTelemetry.cjs');
+
+const checkStudentProgramExistance = operation.Action.define({
+  key: "checkStudentProgramExistance",
+  name: "Check Student Program Data",
+  type: "command",
+  category: "domain",
+  execute: async (input, stream) => {
+    utils.guard(stream, "streamRequired");
+    const { validate } = operation.useValidation(stream, checkStudentProgramExistance_schema.CheckStudentProgramExistanceSchema);
+    const actions = stream.actions.data;
+    const data = validate(input);
+    return useTelemetry.useTelemetry(stream, "checkStudentProgramExistance", {
+      userId: stream.context.identitas.userId,
+      data
+    }, async () => {
+      const { getActorId } = operation.useStream(stream);
+      try {
+        getActorId({ throw: true });
+        console.log("data", data);
+        const studentPrograms = await actions.getMany.execute({
+          model: "neu:akademik:studentProgram",
+          query: query.Query.define({
+            filter: {
+              $and: [
+                { studentId: data.studentId },
+                { programId: data.programId },
+                { deletedAt: { $exists: false } }
+              ]
+            },
+            fields: {
+              id: 1
+            }
+          })
+        }, stream);
+        const isExist = studentPrograms?.value?.length > 0;
+        return core.Result.ok({
+          state: "checkStudentProgramExistance",
+          message: "Check Student Program Existance",
+          data: {
+            isExist
+          }
+        });
+      } catch (error) {
+        if (error?.isFailure)
+          throw error;
+        console.error(error);
+        return core.Result.fail({
+          state: `checkStudentProgramExistanceFailed`,
+          message: `Failed to check existance Student program.`,
+          error: error?.toString()
+        });
+      }
+    });
+  }
+});
+
+exports.checkStudentProgramExistance = checkStudentProgramExistance;

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

@@ -0,0 +1,13 @@
+import { Action } from '@neon.id/operation';
+import type { z } from '@neon.id/z';
+import { CheckStudentProgramExistanceSchema } from './checkStudentProgramExistance.schema';
+export type CheckStudentProgramExistanceInput = z.parse<typeof CheckStudentProgramExistanceSchema>;
+export interface CheckStudentProgramExistanceOutput {
+}
+export interface CheckStudentProgramExistanceMeta {
+}
+export declare const checkStudentProgramExistance: Action<"checkStudentProgramExistance", {
+    studentId: string;
+    programId: string;
+}, CheckStudentProgramExistanceOutput, CheckStudentProgramExistanceMeta>;
+export type CheckStudentProgramExistanceAction = typeof checkStudentProgramExistance;

package/build/actions/checkStudentProgramExistance/checkStudentProgramExistance.action.mjs

@@ -0,0 +1,63 @@
+import { Result } from '@neon.id/core';
+import { Action, useValidation, useStream } from '@neon.id/operation';
+import { guard } from '@neon.id/utils';
+import { Query } from '@neon.id/query';
+import { CheckStudentProgramExistanceSchema } from './checkStudentProgramExistance.schema.mjs';
+import { useTelemetry } from '../../providers/useTelemetry.mjs';
+
+const checkStudentProgramExistance = Action.define({
+  key: "checkStudentProgramExistance",
+  name: "Check Student Program Data",
+  type: "command",
+  category: "domain",
+  execute: async (input, stream) => {
+    guard(stream, "streamRequired");
+    const { validate } = useValidation(stream, CheckStudentProgramExistanceSchema);
+    const actions = stream.actions.data;
+    const data = validate(input);
+    return useTelemetry(stream, "checkStudentProgramExistance", {
+      userId: stream.context.identitas.userId,
+      data
+    }, async () => {
+      const { getActorId } = useStream(stream);
+      try {
+        getActorId({ throw: true });
+        console.log("data", data);
+        const studentPrograms = await actions.getMany.execute({
+          model: "neu:akademik:studentProgram",
+          query: Query.define({
+            filter: {
+              $and: [
+                { studentId: data.studentId },
+                { programId: data.programId },
+                { deletedAt: { $exists: false } }
+              ]
+            },
+            fields: {
+              id: 1
+            }
+          })
+        }, stream);
+        const isExist = studentPrograms?.value?.length > 0;
+        return Result.ok({
+          state: "checkStudentProgramExistance",
+          message: "Check Student Program Existance",
+          data: {
+            isExist
+          }
+        });
+      } catch (error) {
+        if (error?.isFailure)
+          throw error;
+        console.error(error);
+        return Result.fail({
+          state: `checkStudentProgramExistanceFailed`,
+          message: `Failed to check existance Student program.`,
+          error: error?.toString()
+        });
+      }
+    });
+  }
+});
+
+export { checkStudentProgramExistance };

package/build/actions/checkStudentProgramExistance/checkStudentProgramExistance.schema.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+const z = require('@neon.id/z');
+
+const CheckStudentProgramExistanceSchema = z.z.object({
+  studentId: z.z.string().explain({ label: "Student ID" }),
+  programId: z.z.string().explain({ label: "Program Id" })
+});
+
+exports.CheckStudentProgramExistanceSchema = CheckStudentProgramExistanceSchema;

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

@@ -0,0 +1,11 @@
+import { z } from '@neon.id/z';
+export declare const CheckStudentProgramExistanceSchema: z.ZodObject<{
+    studentId: z.ZodString;
+    programId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    studentId: string;
+    programId: string;
+}, {
+    studentId: string;
+    programId: string;
+}>;

package/build/actions/checkStudentProgramExistance/checkStudentProgramExistance.schema.mjs

@@ -0,0 +1,8 @@
+import { z } from '@neon.id/z';
+
+const CheckStudentProgramExistanceSchema = z.object({
+  studentId: z.string().explain({ label: "Student ID" }),
+  programId: z.string().explain({ label: "Program Id" })
+});
+
+export { CheckStudentProgramExistanceSchema };

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

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

package/build/actions/index.d.ts

@@ -10,3 +10,5 @@ export * from './replaceModuleAccessManyStudent';
 export * from './rasionalisasi';
 export * from './tanya';
 export * from './updateMany';
+export * from './checkProgramExistance';
+export * from './checkStudentProgramExistance';

package/build/actions/penilaian/getGradingComponentByType/getGradingComponentByType.action.cjs

@@ -0,0 +1,49 @@
+'use strict';
+
+const core = require('@neon.id/core');
+const operation = require('@neon.id/operation');
+const utils = require('@neon.id/utils');
+const getGradingComponentByType_schema = require('./getGradingComponentByType.schema.cjs');
+const useTelemetry = require('../../../providers/useTelemetry.cjs');
+const usePenilaian = require('../../../providers/penilaian/usePenilaian.cjs');
+
+const getGradingComponentByType = operation.Action.define({
+  key: "getGradingComponentByType",
+  name: "Get Grading Component By Type",
+  type: "command",
+  category: "domain",
+  execute: async (input, stream) => {
+    utils.guard(stream, "streamRequired");
+    const { validate } = operation.useValidation(stream, getGradingComponentByType_schema.GetGradingComponentByTypeSchema);
+    const data = validate(input);
+    return useTelemetry.useTelemetry(stream, "getGradingComponentByType", {
+      userId: stream?.context?.identitas?.userId,
+      data
+    }, async () => {
+      try {
+        const { getManyGradingComponent } = usePenilaian.usePenilaian(stream);
+        utils.guard(data.gradingTypeId, "gradingTypeIdRequired");
+        const { items, meta } = await getManyGradingComponent(stream, data.gradingTypeId, data.limit, data.page);
+        return core.Result.ok({
+          state: "getGradingComponentByTypeSuccess",
+          message: "getGradingComponentByType has been sucessfully executed.",
+          data: {
+            gradingComponent: items,
+            meta
+          }
+        });
+      } catch (error) {
+        if (error?.isFailure)
+          throw error;
+        console.error(error);
+        return core.Result.fail({
+          state: `getGradingComponentByTypeFailed`,
+          message: `Failed to getGradingComponentByType.`,
+          error: error?.toString()
+        });
+      }
+    });
+  }
+});
+
+exports.getGradingComponentByType = getGradingComponentByType;

package/build/actions/penilaian/getGradingComponentByType/getGradingComponentByType.action.d.ts

@@ -0,0 +1,14 @@
+import { Action } from '@neon.id/operation';
+import type { z } from '@neon.id/z';
+import { GetGradingComponentByTypeSchema } from './getGradingComponentByType.schema';
+export type getGradingComponentByTypeInput = z.parse<typeof GetGradingComponentByTypeSchema>;
+export interface getGradingComponentByTypeOutput {
+}
+export interface getGradingComponentByTypeMeta {
+}
+export declare const getGradingComponentByType: Action<"getGradingComponentByType", {
+    gradingTypeId: string;
+    limit: number;
+    page: number;
+}, getGradingComponentByTypeOutput, getGradingComponentByTypeMeta>;
+export type GetGradingComponentByTypeAction = typeof getGradingComponentByType;

package/build/actions/penilaian/getGradingComponentByType/getGradingComponentByType.action.mjs

@@ -0,0 +1,47 @@
+import { Result } from '@neon.id/core';
+import { Action, useValidation } from '@neon.id/operation';
+import { guard } from '@neon.id/utils';
+import { GetGradingComponentByTypeSchema } from './getGradingComponentByType.schema.mjs';
+import { useTelemetry } from '../../../providers/useTelemetry.mjs';
+import { usePenilaian } from '../../../providers/penilaian/usePenilaian.mjs';
+
+const getGradingComponentByType = Action.define({
+  key: "getGradingComponentByType",
+  name: "Get Grading Component By Type",
+  type: "command",
+  category: "domain",
+  execute: async (input, stream) => {
+    guard(stream, "streamRequired");
+    const { validate } = useValidation(stream, GetGradingComponentByTypeSchema);
+    const data = validate(input);
+    return useTelemetry(stream, "getGradingComponentByType", {
+      userId: stream?.context?.identitas?.userId,
+      data
+    }, async () => {
+      try {
+        const { getManyGradingComponent } = usePenilaian(stream);
+        guard(data.gradingTypeId, "gradingTypeIdRequired");
+        const { items, meta } = await getManyGradingComponent(stream, data.gradingTypeId, data.limit, data.page);
+        return Result.ok({
+          state: "getGradingComponentByTypeSuccess",
+          message: "getGradingComponentByType has been sucessfully executed.",
+          data: {
+            gradingComponent: items,
+            meta
+          }
+        });
+      } catch (error) {
+        if (error?.isFailure)
+          throw error;
+        console.error(error);
+        return Result.fail({
+          state: `getGradingComponentByTypeFailed`,
+          message: `Failed to getGradingComponentByType.`,
+          error: error?.toString()
+        });
+      }
+    });
+  }
+});
+
+export { getGradingComponentByType };

package/build/actions/penilaian/getGradingComponentByType/getGradingComponentByType.schema.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+const z = require('@neon.id/z');
+
+const GetGradingComponentByTypeSchema = z.z.object({
+  gradingTypeId: z.z.string().explain({ label: "gradingTypeId" }),
+  limit: z.z.number().default(20).explain({ label: "Limit" }),
+  page: z.z.number().default(1).explain({ label: "Page" })
+});
+
+exports.GetGradingComponentByTypeSchema = GetGradingComponentByTypeSchema;

package/build/actions/penilaian/getGradingComponentByType/getGradingComponentByType.schema.d.ts

@@ -0,0 +1,14 @@
+import { z } from '@neon.id/z';
+export declare const GetGradingComponentByTypeSchema: z.ZodObject<{
+    gradingTypeId: z.ZodString;
+    limit: z.ZodDefault<z.ZodNumber>;
+    page: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    gradingTypeId: string;
+    limit: number;
+    page: number;
+}, {
+    gradingTypeId: string;
+    limit?: number | undefined;
+    page?: number | undefined;
+}>;

package/build/actions/penilaian/getGradingComponentByType/getGradingComponentByType.schema.mjs

@@ -0,0 +1,9 @@
+import { z } from '@neon.id/z';
+
+const GetGradingComponentByTypeSchema = z.object({
+  gradingTypeId: z.string().explain({ label: "gradingTypeId" }),
+  limit: z.number().default(20).explain({ label: "Limit" }),
+  page: z.number().default(1).explain({ label: "Page" })
+});
+
+export { GetGradingComponentByTypeSchema };

package/build/actions/penilaian/getGradingComponentByType/index.d.ts

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

package/build/actions/penilaian/getGradingStudent/getGradingStudent.action.cjs

@@ -0,0 +1,63 @@
+'use strict';
+
+const core = require('@neon.id/core');
+const operation = require('@neon.id/operation');
+const utils = require('@neon.id/utils');
+const getGradingStudent_schema = require('./getGradingStudent.schema.cjs');
+const useTelemetry = require('../../../providers/useTelemetry.cjs');
+const usePenilaian = require('../../../providers/penilaian/usePenilaian.cjs');
+
+const getGradingStudent = operation.Action.define({
+  key: "getGradingStudent",
+  name: "Get Grading Student",
+  type: "command",
+  category: "domain",
+  execute: async (input, stream) => {
+    utils.guard(stream, "streamRequired");
+    const { validate } = operation.useValidation(stream, getGradingStudent_schema.GetGradingStudentSchema);
+    const data = validate(input);
+    return useTelemetry.useTelemetry(
+      stream,
+      "getGradingStudent",
+      {
+        userId: stream?.context?.identitas?.userId,
+        data
+      },
+      async () => {
+        try {
+          const { getManyGradingByStudent } = usePenilaian.usePenilaian(stream);
+          utils.guard(data.studentId, "studentIdRequired");
+          utils.guard(data.gradingTypeId, "gradingTypeIdRequired");
+          utils.guard(data.branchId, "branchIdRequired");
+          const { items, meta } = await getManyGradingByStudent(
+            stream,
+            data.studentId,
+            data.gradingTypeId,
+            data.branchId,
+            data.limit,
+            data.page
+          );
+          return core.Result.ok({
+            state: "getGradingStudentSuccess",
+            message: "getGradingStudent has been sucessfully executed.",
+            data: {
+              grading: items,
+              meta
+            }
+          });
+        } catch (error) {
+          if (error?.isFailure)
+            throw error;
+          console.error(error);
+          return core.Result.fail({
+            state: `getGradingStudentFailed`,
+            message: `Failed to getGradingStudent.`,
+            error: error?.toString()
+          });
+        }
+      }
+    );
+  }
+});
+
+exports.getGradingStudent = getGradingStudent;

package/build/actions/penilaian/getGradingStudent/getGradingStudent.action.d.ts

@@ -0,0 +1,16 @@
+import { Action } from '@neon.id/operation';
+import type { z } from '@neon.id/z';
+import { GetGradingStudentSchema } from './getGradingStudent.schema';
+export type getGradingStudentInput = z.parse<typeof GetGradingStudentSchema>;
+export interface getGradingStudentOutput {
+}
+export interface getGradingStudentMeta {
+}
+export declare const getGradingStudent: Action<"getGradingStudent", {
+    branchId: string;
+    studentId: string;
+    gradingTypeId: string;
+    limit: number;
+    page: number;
+}, getGradingStudentOutput, getGradingStudentMeta>;
+export type GetGradingStudentAction = typeof getGradingStudent;

package/build/actions/penilaian/getGradingStudent/getGradingStudent.action.mjs

@@ -0,0 +1,61 @@
+import { Result } from '@neon.id/core';
+import { Action, useValidation } from '@neon.id/operation';
+import { guard } from '@neon.id/utils';
+import { GetGradingStudentSchema } from './getGradingStudent.schema.mjs';
+import { useTelemetry } from '../../../providers/useTelemetry.mjs';
+import { usePenilaian } from '../../../providers/penilaian/usePenilaian.mjs';
+
+const getGradingStudent = Action.define({
+  key: "getGradingStudent",
+  name: "Get Grading Student",
+  type: "command",
+  category: "domain",
+  execute: async (input, stream) => {
+    guard(stream, "streamRequired");
+    const { validate } = useValidation(stream, GetGradingStudentSchema);
+    const data = validate(input);
+    return useTelemetry(
+      stream,
+      "getGradingStudent",
+      {
+        userId: stream?.context?.identitas?.userId,
+        data
+      },
+      async () => {
+        try {
+          const { getManyGradingByStudent } = usePenilaian(stream);
+          guard(data.studentId, "studentIdRequired");
+          guard(data.gradingTypeId, "gradingTypeIdRequired");
+          guard(data.branchId, "branchIdRequired");
+          const { items, meta } = await getManyGradingByStudent(
+            stream,
+            data.studentId,
+            data.gradingTypeId,
+            data.branchId,
+            data.limit,
+            data.page
+          );
+          return Result.ok({
+            state: "getGradingStudentSuccess",
+            message: "getGradingStudent has been sucessfully executed.",
+            data: {
+              grading: items,
+              meta
+            }
+          });
+        } catch (error) {
+          if (error?.isFailure)
+            throw error;
+          console.error(error);
+          return Result.fail({
+            state: `getGradingStudentFailed`,
+            message: `Failed to getGradingStudent.`,
+            error: error?.toString()
+          });
+        }
+      }
+    );
+  }
+});
+
+export { getGradingStudent };