@neutron.co.id/pendidikan-operation 1.27.6 → 1.27.8

package/build/actions/index.d.ts

@@ -6,6 +6,7 @@ export * from './penilaian';
 export * from './prepareExperience';
 export * from './replaceModuleAccess';
 export * from './refreshModuleAccess';
+export * from './replaceModuleAccessManyStudent';
 export * from './rasionalisasi';
 export * from './tanya';
 export * from './updateMany';

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

@@ -12,3 +12,5 @@ export * from './setAksesModulSiswaDiClassGroup';
 export * from './setTravelWageSessions';
 export * from './action.customSaveOneClassSession';
 export * from './syncClassGroups';
+export * from './sendClassConsultationNotification';
+export * from './sendClassSessionNotification';

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

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

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

@@ -0,0 +1,110 @@
+'use strict';
+
+const operation = require('@neon.id/operation');
+const core = require('@neon.id/core');
+const ofetch = require('ofetch');
+const query = require('@neon.id/query');
+const sendClassConsultationNotification_schema = require('./sendClassConsultationNotification.schema.cjs');
+
+const sendClassConsultationNotification = operation.Action.define({
+  key: "sendClassConsultationNotification",
+  name: "Send ClassConsultation Notification",
+  type: "command",
+  category: "domain",
+  execute: async (input, stream) => {
+    const config = stream?.context?.config;
+    const { validate } = operation.useValidation(stream, sendClassConsultationNotification_schema.SendClassConsultationNotificationSchema);
+    const data = validate(input);
+    if (!config?.novuApi?.url || !config?.novuApi?.token) {
+      console.warn("Novu API not configured, skipping notification");
+      return core.Result.ok({
+        state: "emailsSent",
+        message: "Novu not configured",
+        data: { sentCount: 0, transactionIds: [] }
+      });
+    }
+    try {
+      const classConsultation = await stream?.actions.data.getOne.execute({
+        model: "neu:jadwal:classConsultation",
+        id: data.classConsultationId,
+        query: query.Query.define({
+          fields: {
+            id: 1,
+            title: 1,
+            subtitle: 1,
+            startedAt: 1,
+            endedAt: 1,
+            subject: { name: 1 },
+            students: { userId: 1, user: { name: 1, email: 1 } },
+            topics: { name: 1 }
+          }
+        })
+      }, stream);
+      if (!classConsultation?.payload?.data) {
+        console.warn(`ClassConsultation ${data.classConsultationId} not found`);
+        return core.Result.ok({
+          state: "emailsSent",
+          message: "ClassConsultation not found",
+          data: { sentCount: 0, transactionIds: [] }
+        });
+      }
+      const consultation = classConsultation.payload.data;
+      const transactionIds = [];
+      let sentCount = 0;
+      for (const student of consultation.students || []) {
+        if (!student.userId)
+          continue;
+        try {
+          const response = await ofetch.ofetch(`${config.novuApi.url}/v1/events/trigger`, {
+            method: "POST",
+            headers: {
+              "Authorization": `ApiKey ${config.novuApi.token}`,
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+              name: "consultation-created",
+              to: {
+                // subscriberId: student.userId,
+                subscriberId: "test-user-id",
+                email: student.user?.email || "",
+                firstName: student.user?.name || "Student",
+                lastName: ""
+              },
+              payload: {
+                // consultationId: consultation.id,
+                // title: consultation.title || 'Consultation',
+                subject: consultation.subject?.name || "Subject"
+                // topics: topicsList,
+                // teacherNames,
+                // date: DateUtil.formatTz(consultation.startedAt, { pattern: 'yyyy-MM-dd' }),
+                // startTime: DateUtil.formatTz(consultation.startedAt, { pattern: 'HH:mm' }),
+                // endTime: DateUtil.formatTz(consultation.endedAt, { pattern: 'HH:mm' }),
+                // branch: consultation.branch?.name || 'Branch',
+                // url: consultationUrl,
+              }
+            })
+          });
+          if (response?.data?.transactionId)
+            transactionIds.push(response.data.transactionId);
+          sentCount++;
+        } catch (error) {
+          console.error(`Failed to send consultation notification to student ${student.userId}:`, error);
+        }
+      }
+      return core.Result.ok({
+        state: "emailsSent",
+        message: `Sent ${sentCount} notification emails`,
+        data: { sentCount, transactionIds }
+      });
+    } catch (error) {
+      console.error("Failed to send consultation notifications:", error);
+      return core.Result.ok({
+        state: "emailsSent",
+        message: "Failed to send notifications",
+        data: { sentCount: 0, transactionIds: [] }
+      });
+    }
+  }
+});
+
+exports.sendClassConsultationNotification = sendClassConsultationNotification;

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

@@ -0,0 +1,5 @@
+import { Action } from '@neon.id/operation';
+import { type SendClassConsultationNotificationMeta, type SendClassConsultationNotificationOutput } from './sendClassConsultationNotification.schema';
+export declare const sendClassConsultationNotification: Action<"sendClassConsultationNotification", {
+    classConsultationId: string;
+}, SendClassConsultationNotificationOutput, SendClassConsultationNotificationMeta>;

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

@@ -0,0 +1,108 @@
+import { Action, useValidation } from '@neon.id/operation';
+import { Result } from '@neon.id/core';
+import { ofetch } from 'ofetch';
+import { Query } from '@neon.id/query';
+import { SendClassConsultationNotificationSchema } from './sendClassConsultationNotification.schema.mjs';
+
+const sendClassConsultationNotification = Action.define({
+  key: "sendClassConsultationNotification",
+  name: "Send ClassConsultation Notification",
+  type: "command",
+  category: "domain",
+  execute: async (input, stream) => {
+    const config = stream?.context?.config;
+    const { validate } = useValidation(stream, SendClassConsultationNotificationSchema);
+    const data = validate(input);
+    if (!config?.novuApi?.url || !config?.novuApi?.token) {
+      console.warn("Novu API not configured, skipping notification");
+      return Result.ok({
+        state: "emailsSent",
+        message: "Novu not configured",
+        data: { sentCount: 0, transactionIds: [] }
+      });
+    }
+    try {
+      const classConsultation = await stream?.actions.data.getOne.execute({
+        model: "neu:jadwal:classConsultation",
+        id: data.classConsultationId,
+        query: Query.define({
+          fields: {
+            id: 1,
+            title: 1,
+            subtitle: 1,
+            startedAt: 1,
+            endedAt: 1,
+            subject: { name: 1 },
+            students: { userId: 1, user: { name: 1, email: 1 } },
+            topics: { name: 1 }
+          }
+        })
+      }, stream);
+      if (!classConsultation?.payload?.data) {
+        console.warn(`ClassConsultation ${data.classConsultationId} not found`);
+        return Result.ok({
+          state: "emailsSent",
+          message: "ClassConsultation not found",
+          data: { sentCount: 0, transactionIds: [] }
+        });
+      }
+      const consultation = classConsultation.payload.data;
+      const transactionIds = [];
+      let sentCount = 0;
+      for (const student of consultation.students || []) {
+        if (!student.userId)
+          continue;
+        try {
+          const response = await ofetch(`${config.novuApi.url}/v1/events/trigger`, {
+            method: "POST",
+            headers: {
+              "Authorization": `ApiKey ${config.novuApi.token}`,
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+              name: "consultation-created",
+              to: {
+                // subscriberId: student.userId,
+                subscriberId: "test-user-id",
+                email: student.user?.email || "",
+                firstName: student.user?.name || "Student",
+                lastName: ""
+              },
+              payload: {
+                // consultationId: consultation.id,
+                // title: consultation.title || 'Consultation',
+                subject: consultation.subject?.name || "Subject"
+                // topics: topicsList,
+                // teacherNames,
+                // date: DateUtil.formatTz(consultation.startedAt, { pattern: 'yyyy-MM-dd' }),
+                // startTime: DateUtil.formatTz(consultation.startedAt, { pattern: 'HH:mm' }),
+                // endTime: DateUtil.formatTz(consultation.endedAt, { pattern: 'HH:mm' }),
+                // branch: consultation.branch?.name || 'Branch',
+                // url: consultationUrl,
+              }
+            })
+          });
+          if (response?.data?.transactionId)
+            transactionIds.push(response.data.transactionId);
+          sentCount++;
+        } catch (error) {
+          console.error(`Failed to send consultation notification to student ${student.userId}:`, error);
+        }
+      }
+      return Result.ok({
+        state: "emailsSent",
+        message: `Sent ${sentCount} notification emails`,
+        data: { sentCount, transactionIds }
+      });
+    } catch (error) {
+      console.error("Failed to send consultation notifications:", error);
+      return Result.ok({
+        state: "emailsSent",
+        message: "Failed to send notifications",
+        data: { sentCount: 0, transactionIds: [] }
+      });
+    }
+  }
+});
+
+export { sendClassConsultationNotification };

package/build/actions/jadwal/sendClassConsultationNotification/sendClassConsultationNotification.schema.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+const z = require('@neon.id/z');
+
+const SendClassConsultationNotificationSchema = z.z.object({
+  classConsultationId: z.z.objectId().explain({
+    label: "Class Consultation ID",
+    description: "The ID of the consultation to send notifications for"
+  })
+});
+
+exports.SendClassConsultationNotificationSchema = SendClassConsultationNotificationSchema;

package/build/actions/jadwal/sendClassConsultationNotification/sendClassConsultationNotification.schema.d.ts

@@ -0,0 +1,15 @@
+import { z } from '@neon.id/z';
+export declare const SendClassConsultationNotificationSchema: z.ZodObject<{
+    classConsultationId: z.ZodEffects<z.ZodString, string, string>;
+}, "strip", z.ZodTypeAny, {
+    classConsultationId: string;
+}, {
+    classConsultationId: string;
+}>;
+export type SendClassConsultationNotificationInput = z.parse<typeof SendClassConsultationNotificationSchema>;
+export interface SendClassConsultationNotificationOutput {
+}
+export interface SendClassConsultationNotificationMeta {
+    input: SendClassConsultationNotificationInput;
+    output: SendClassConsultationNotificationOutput;
+}

package/build/actions/jadwal/sendClassConsultationNotification/sendClassConsultationNotification.schema.mjs

@@ -0,0 +1,10 @@
+import { z } from '@neon.id/z';
+
+const SendClassConsultationNotificationSchema = z.object({
+  classConsultationId: z.objectId().explain({
+    label: "Class Consultation ID",
+    description: "The ID of the consultation to send notifications for"
+  })
+});
+
+export { SendClassConsultationNotificationSchema };

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

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

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

@@ -0,0 +1,217 @@
+'use strict';
+
+const operation = require('@neon.id/operation');
+const ofetch = require('ofetch');
+const core = require('@neon.id/core');
+const date = require('@neon.id/utils/date');
+const query = require('@neon.id/query');
+const sendClassSessionNotification_schema = require('./sendClassSessionNotification.schema.cjs');
+
+async function resolveEmail(dbs, userId) {
+  if (!userId)
+    return null;
+  try {
+    const dbIdentitas = dbs["neo-identitas"].models["neo:identitas:identifier"];
+    const identifier = await dbIdentitas.findOne({ userId });
+    return identifier?.email || identifier?.profile?.email || (identifier?.provider === "email" ? identifier?.value : null) || null;
+  } catch (error) {
+    console.error(`Failed to resolve email for userId ${userId}:`, error);
+    return null;
+  }
+}
+const sendClassSessionNotification = operation.Action.define({
+  key: "sendClassSessionNotification",
+  name: "Send ClassSession Notification",
+  type: "command",
+  category: "domain",
+  execute: async (input, stream) => {
+    const config = stream?.context?.config;
+    const { validate } = operation.useValidation(stream, sendClassSessionNotification_schema.SendClassSessionNotificationSchema);
+    const data = validate(input);
+    const dbs = stream?.core.dbs;
+    if (!config?.novuApi?.url || !config?.novuApi?.token) {
+      console.warn("Novu API not configured, skipping notification");
+      return core.Result.ok({
+        state: "emailsSent",
+        message: "Novu not configured",
+        data: { sentCount: 0, transactionIds: [] }
+      });
+    }
+    try {
+      const classSession = await stream?.actions.data.getOne.execute({
+        model: "neu:jadwal:classSession",
+        id: data.classSessionId,
+        query: query.Query.define({
+          fields: {
+            id: 1,
+            title: 1,
+            subtitle: 1,
+            startedAt: 1,
+            endedAt: 1,
+            type: 1,
+            locationType: 1,
+            link: 1,
+            password: 1,
+            building: { name: 1 },
+            room: { name: 1 },
+            branches: { name: 1 },
+            subjects: { name: 1 },
+            teachers: { userId: 1, user: { name: 1, email: 1 } },
+            groups: {
+              name: 1,
+              studentGroups: {
+                student: { userId: 1, user: { name: 1, email: 1 } }
+              }
+            },
+            classSessionPurpose: { name: 1 },
+            stage: { name: 1 }
+          }
+        })
+      }, stream);
+      if (!classSession?.payload.data) {
+        console.warn(`ClassSession ${data.classSessionId} not found`);
+        return core.Result.ok({
+          state: "emailsSent",
+          message: "ClassSession not found",
+          data: { sentCount: 0, transactionIds: [] }
+        });
+      }
+      const session = classSession.payload.data;
+      const transactionIds = [];
+      let sentCount = 0;
+      const teacherNames = session.teachers?.map((t) => t.user?.name || "Unknown").join(", ") || "No teachers assigned";
+      const subjectsList = session.subjects?.map((s) => s.name).join(", ") || "No subjects specified";
+      const groupNames = session.groups?.map((g) => g.name).join(", ") || "No groups";
+      const sessionUrl = `${config?.appFluffyUrl || config?.appFrontendUrl || ""}/sessions/${session.id}`;
+      let locationText = "";
+      if (session.locationType === "building" && session.building && session.room)
+        locationText = `${session.building.name} - ${session.room.name}`;
+      else if (session.locationType === "link")
+        locationText = "Online (see link below)";
+      else if (session.locationType === "school")
+        locationText = "At School";
+      else
+        locationText = session.locationType || "Location TBD";
+      const students = [];
+      for (const group of session.groups || []) {
+        for (const studentGroup of group.studentGroups || []) {
+          if (studentGroup.student)
+            students.push(studentGroup.student);
+        }
+      }
+      const uniqueStudents = students.filter(
+        (student, index, self) => index === self.findIndex((s) => s.userId === student.userId)
+      );
+      for (const student of uniqueStudents) {
+        if (!student.userId)
+          continue;
+        const email = await resolveEmail(dbs, student.userId);
+        if (!email) {
+          console.warn(`No email found for student userId: ${student.userId}`);
+          continue;
+        }
+        try {
+          const response = await ofetch.ofetch(`${config.novuApi.url}/v1/events/trigger`, {
+            method: "POST",
+            headers: {
+              "Authorization": `ApiKey ${config.novuApi.token}`,
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+              name: "session-created",
+              to: {
+                subscriberId: student.userId,
+                email,
+                firstName: student.user?.name || "Student",
+                lastName: ""
+              },
+              payload: {
+                sessionId: session.id,
+                title: session.title || "Class Session",
+                subtitle: session.subtitle || "",
+                subjects: subjectsList,
+                teacherNames,
+                date: date.DateUtil.formatTz(session.startedAt, { pattern: "yyyy-MM-dd" }),
+                startTime: date.DateUtil.formatTz(session.startedAt, { pattern: "HH:mm" }),
+                endTime: date.DateUtil.formatTz(session.endedAt, { pattern: "HH:mm" }),
+                type: session.type || "offline",
+                location: locationText,
+                link: session.link || "",
+                password: session.password || "",
+                purpose: session.classSessionPurpose?.name || "",
+                url: sessionUrl
+              }
+            })
+          });
+          if (response?.data?.transactionId)
+            transactionIds.push(response.data.transactionId);
+          sentCount++;
+        } catch (error) {
+          console.error(`Failed to send session notification to student ${student.userId}:`, error);
+        }
+      }
+      const studentCount = uniqueStudents.length;
+      for (const teacher of session.teachers || []) {
+        if (!teacher.userId)
+          continue;
+        const email = await resolveEmail(dbs, teacher.userId);
+        if (!email) {
+          console.warn(`No email found for teacher userId: ${teacher.userId}`);
+          continue;
+        }
+        try {
+          await ofetch.ofetch(`${config.novuApi.url}/v1/events/trigger`, {
+            method: "POST",
+            headers: {
+              "Authorization": `ApiKey ${config.novuApi.token}`,
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+              name: "session-created-teacher",
+              to: {
+                subscriberId: teacher.userId,
+                email,
+                firstName: teacher.user?.name || "Teacher",
+                lastName: ""
+              },
+              payload: {
+                sessionId: session.id,
+                title: session.title || "Class Session",
+                subtitle: session.subtitle || "",
+                subjects: subjectsList,
+                studentCount,
+                groupNames,
+                date: date.DateUtil.formatTz(session.startedAt, { pattern: "yyyy-MM-dd" }),
+                startTime: date.DateUtil.formatTz(session.startedAt, { pattern: "HH:mm" }),
+                endTime: date.DateUtil.formatTz(session.endedAt, { pattern: "HH:mm" }),
+                type: session.type || "offline",
+                location: locationText,
+                link: session.link || "",
+                password: session.password || "",
+                purpose: session.classSessionPurpose?.name || "",
+                url: sessionUrl
+              }
+            })
+          });
+          sentCount++;
+        } catch (error) {
+          console.error(`Failed to send session notification to teacher ${teacher.userId}:`, error);
+        }
+      }
+      return core.Result.ok({
+        state: "emailsSent",
+        message: `Sent ${sentCount} notification emails`,
+        data: { sentCount, transactionIds }
+      });
+    } catch (error) {
+      console.error("Failed to send session notifications:", error);
+      return core.Result.ok({
+        state: "emailsSent",
+        message: "Failed to send notifications",
+        data: { sentCount: 0, transactionIds: [] }
+      });
+    }
+  }
+});
+
+exports.sendClassSessionNotification = sendClassSessionNotification;

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

@@ -0,0 +1,5 @@
+import { Action } from '@neon.id/operation';
+import { type SendClassSessionNotificationMeta, type SendClassSessionNotificationOutput } from './sendClassSessionNotification.schema';
+export declare const sendClassSessionNotification: Action<"sendClassSessionNotification", {
+    classSessionId: string;
+}, SendClassSessionNotificationOutput, SendClassSessionNotificationMeta>;