@openinc/parse-server-opendash 4.0.29 → 4.0.31

package/dist/features/openservice/schedules/calendarSync/functions/eventToSchedule.d.ts

@@ -5,7 +5,13 @@ export type ScheduleCronTimestamp = {
     number: number;
     unit: "days" | "weeks" | "months";
 };
-export declare function eventToSchedule(event: GraphEventResponse): {
-    timestamp: ScheduleCronTimestamp;
+export type NotifyBeforeDue = {
+    value: number;
+    unit: "minutes" | "hours" | "days" | "weeks";
+};
+export type EventToScheduleResult = {
     schedule_type: "timestamp";
-} | undefined;
+    timestamp: ScheduleCronTimestamp;
+    notifyBeforeDue?: NotifyBeforeDue;
+};
+export declare function eventToSchedule(event: GraphEventResponse): EventToScheduleResult | undefined;

package/dist/features/openservice/schedules/calendarSync/functions/eventToSchedule.js

@@ -1,10 +1,47 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.eventToSchedule = eventToSchedule;
+const dayjs_1 = __importDefault(require("dayjs"));
+// Parses only the date portion of an Outlook dateTime string to avoid
+// timezone misinterpretation (Outlook dateTime is local to the event's
+// timezone, not UTC).
+function parseDateOnly(dateTime) {
+    return (0, dayjs_1.default)(dateTime.slice(0, 10));
+}
+function minutesToNotifyBeforeDue(minutes) {
+    if (minutes % (60 * 24 * 7) === 0)
+        return { value: minutes / (60 * 24 * 7), unit: "weeks" };
+    if (minutes % (60 * 24) === 0)
+        return { value: minutes / (60 * 24), unit: "days" };
+    if (minutes % 60 === 0)
+        return { value: minutes / 60, unit: "hours" };
+    return { value: minutes, unit: "minutes" };
+}
 function eventToSchedule(event) {
+    const notifyBeforeDue = event.isReminderOn && typeof event.reminderMinutesBeforeStart === "number"
+        ? minutesToNotifyBeforeDue(event.reminderMinutesBeforeStart)
+        : undefined;
     const recurrence = event?.recurrence;
-    if (!recurrence)
-        return undefined;
+    // Single (non-recurring) event: treat as one-day schedule regardless of
+    // the event's time or duration — our schedules are always all-day.
+    if (!recurrence) {
+        if (!event.start?.dateTime)
+            return undefined;
+        const date = parseDateOnly(event.start.dateTime).toDate();
+        return {
+            schedule_type: "timestamp",
+            timestamp: {
+                startDate: date,
+                endDate: date,
+                number: 1,
+                unit: "days",
+            },
+            notifyBeforeDue,
+        };
+    }
     const pattern = recurrence.pattern;
     const range = recurrence.range;
     if (!pattern || !range || !pattern.type)
@@ -21,36 +58,41 @@ function eventToSchedule(event) {
         case "relativeMonthly":
             unit = "months";
             break;
+        case "absoluteYearly":
+        case "relativeYearly":
+            // Map yearly recurrence to a 12-month interval
+            unit = "months";
+            break;
         default:
-            // unsupported recurrence type
             return undefined;
     }
     const interval = typeof pattern.interval === "number" && pattern.interval > 0
         ? pattern.interval
         : 1;
-    // Prefer explicit range.startDate, fallback to event.start.dateTime
-    let startDate;
-    if (range?.startDate) {
-        // range.startDate is YYYY-MM-DD
-        startDate = new Date(range.startDate + "T00:00:00Z");
-    }
-    else if (event.start?.dateTime) {
-        startDate = new Date(event.start.dateTime);
-    }
-    // For end, prefer range.endDate. If range.type === 'noEnd' leave undefined.
+    // Yearly patterns don't carry an interval in Outlook (always 1 year)
+    const effectiveInterval = pattern.type === "absoluteYearly" || pattern.type === "relativeYearly"
+        ? 12
+        : interval;
+    // range.startDate is always YYYY-MM-DD
+    const startDate = parseDateOnly(range.startDate);
     let endDate;
-    if (range?.type === "endDate" && range?.endDate) {
-        endDate = new Date(range.endDate + "T00:00:00Z");
+    if (range.type === "endDate") {
+        endDate = parseDateOnly(range.endDate);
     }
-    if (!startDate)
-        return undefined;
+    else if (range.type === "numbered") {
+        // Compute end date from occurrence count
+        const occurrences = range.numberOfOccurrences ?? 1;
+        endDate = startDate.add((occurrences - 1) * effectiveInterval, unit);
+    }
+    // range.type === "noEnd" → endDate stays undefined
     return {
         schedule_type: "timestamp",
         timestamp: {
-            startDate,
-            endDate,
-            number: interval,
+            startDate: startDate.toDate(),
+            endDate: endDate?.toDate(),
+            number: effectiveInterval,
             unit,
         },
+        notifyBeforeDue,
     };
 }

package/dist/features/openservice/schedules/calendarSync/functions/scheduleToEvent.d.ts

@@ -1,3 +1,4 @@
 import { Maintenance_Schedule } from "../../../../../types/index.js";
+import { CalendarEventSnapshot } from "../service/calendarMetaHelper.js";
 import { GraphEvent } from "../types/Event.js";
-export declare function scheduleToEvent(schedule: Maintenance_Schedule): Promise<GraphEvent | undefined>;
+export declare function scheduleToEvent(schedule: Maintenance_Schedule, originalEvent?: CalendarEventSnapshot): Promise<GraphEvent | undefined>;

package/dist/features/openservice/schedules/calendarSync/functions/scheduleToEvent.js

@@ -5,15 +5,32 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.scheduleToEvent = scheduleToEvent;
 const dayjs_1 = __importDefault(require("dayjs"));
-async function scheduleToEvent(schedule) {
-    console.log("Converting Schedule to Event...");
+function notifyBeforeDueToMinutes(notify) {
+    switch (notify.unit) {
+        case "weeks":
+            return notify.value * 60 * 24 * 7;
+        case "days":
+            return notify.value * 60 * 24;
+        case "hours":
+            return notify.value * 60;
+        case "minutes":
+            return notify.value;
+        case "seconds":
+            return Math.round(notify.value / 60);
+        case "milliseconds":
+            return Math.round(notify.value / 60000);
+        default:
+            return notify.value;
+    }
+}
+async function scheduleToEvent(schedule, originalEvent) {
     try {
         await schedule.fetchWithInclude(["template"], {
             useMasterKey: true,
         });
     }
     catch (error) {
-        console.error("Error fetching template:", error);
+        console.error(`[scheduleToEvent] Failed to fetch template for schedule ${schedule.id}:`, error);
     }
     const template = schedule.get("template");
     const templateCron = template?.get("cron");
@@ -23,34 +40,38 @@ async function scheduleToEvent(schedule) {
     const interval = scheduleCron?.timestamp?.number ?? templateCron?.timestamp?.number;
     const unit = scheduleCron?.timestamp?.unit ?? templateCron?.timestamp?.unit;
     if (!start || !interval || !unit) {
-        console.log("Insufficient data to create event from schedule.");
         return;
     }
     const description = schedule.get("description");
+    const notifyBeforeDue = schedule.get("notifyBeforeDue");
+    // If the original Outlook event had specific times (not all-day), preserve
+    // them so we don't silently convert a timed event to all-day on update.
+    const preserveTimes = originalEvent != null && !originalEvent.isAllDay;
+    const toDateOnly = (d) => d.toISOString().slice(0, 10);
     const event = {
         subject: schedule.get("title"),
         body: { contentType: "Text", content: description ?? "" },
-        start: {
-            // for single-day/all-day events we use date-only; keep full ISO otherwise
-            dateTime: start.toISOString().slice(0, 19),
-            timeZone: "UTC",
-        },
-        end: {
-            dateTime: (0, dayjs_1.default)(start).add(1, "day").toISOString().slice(0, 19),
-            timeZone: "UTC",
-        },
-        isAllDay: true,
+        start: preserveTimes
+            ? originalEvent.start
+            : { dateTime: toDateOnly(start), timeZone: "UTC" },
+        end: preserveTimes
+            ? originalEvent.end
+            : {
+                dateTime: toDateOnly((0, dayjs_1.default)(start).add(1, "day").toDate()),
+                timeZone: "UTC",
+            },
+        isAllDay: preserveTimes ? undefined : true,
+        isReminderOn: notifyBeforeDue != null,
+        reminderMinutesBeforeStart: notifyBeforeDue
+            ? notifyBeforeDueToMinutes(notifyBeforeDue)
+            : undefined,
     };
-    // Helper to format date as YYYY-MM-DD for recurrence range
-    const toDateOnly = (d) => d.toISOString().slice(0, 10);
-    // determine pattern type and additional fields
     let pattern = { interval };
     if (unit === "days") {
         pattern.type = "daily";
     }
     else if (unit === "weeks") {
         pattern.type = "weekly";
-        // include the weekday of the start date so weekly recurrences occur on that weekday
         const dayNames = [
             "Sunday",
             "Monday",
@@ -65,11 +86,9 @@ async function scheduleToEvent(schedule) {
     }
     else if (unit === "months") {
         pattern.type = "absoluteMonthly";
-        // Graph uses dayOfMonth for absoluteMonthly
         pattern.dayOfMonth = start.getUTCDate();
     }
     else {
-        // unsupported unit -> skip recurrence
         pattern = null;
     }
     if (pattern) {
@@ -83,21 +102,16 @@ async function scheduleToEvent(schedule) {
                 type: "noEnd",
                 startDate: toDateOnly(start),
             };
-        event.recurrence = {
-            pattern,
-            range,
-        };
-        // if event is all-day, set start/end to date-only values (Graph expects dates) => always true for schedules
-        if (event.isAllDay) {
+        event.recurrence = { pattern, range };
+        // All-day events need date-only strings for start/end in the Graph payload.
+        // Timed events already have their original times set above — don't touch them.
+        if (!preserveTimes) {
             event.start.dateTime = toDateOnly(start);
-            // Graph's endDate in event object is exclusive for all-day events; keep as provided for recurrence range
-            // Set end to next day to represent an all-day event that begins and ends the same day
             const endForEvent = new Date(start);
             endForEvent.setUTCDate(endForEvent.getUTCDate() + 1);
             if (event.end)
                 event.end.dateTime = toDateOnly(endForEvent);
         }
     }
-    console.log("Schedule converted to Event:", event);
     return event;
 }

package/dist/features/openservice/schedules/calendarSync/service/CalendarManager.d.ts

@@ -3,36 +3,22 @@ import { GraphEvent, GraphEventResponse } from "../types/Event.js";
  * Manager for calendar operations via Microsoft Graph API
  */
 export declare class CalendarManager {
-    tenantID: string;
-    clientID: string;
-    clientSecret: string;
-    userMail: string;
+    tenantID?: string;
+    clientID?: string;
+    clientSecret?: string;
+    userMail?: string;
+    constructor(config: {
+        tenantId: string;
+        clientID: string;
+        clientSecret: string;
+        userMail: string;
+    });
     get isValid(): true | string;
     private getAccess;
-    /**
-     * Create a new event in the calendar
-     * @param event The event data to create
-     * @returns the created event response
-     */
     createEvent(event: GraphEvent): Promise<GraphEventResponse | undefined>;
-    /**
-     * Update an event in the calendar
-     * @param eventId The ID of the event to update
-     * @param event The updated event data
-     * @returns
-     */
     updateEvent(eventId: string, event: Partial<GraphEvent>): Promise<GraphEventResponse | undefined>;
-    /**
-     * Delete an event from the calendar
-     * @param eventId The ID of the event to delete
-     * @returns whether the deletion was successful
-     */
     deleteEvent(eventId: string): Promise<boolean | undefined>;
     fetchEvent(eventId: string): Promise<GraphEventResponse | null>;
-    /**
-     * Fetch all events in calendar
-     * @returns the list of events
-     */
     fetchEvents(): Promise<{
         value: GraphEventResponse[];
     } | undefined>;

package/dist/features/openservice/schedules/calendarSync/service/CalendarManager.js

@@ -1,19 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CalendarManager = void 0;
-const index_js_1 = require("../../../../config/index.js");
 /**
  * Manager for calendar operations via Microsoft Graph API
  */
 class CalendarManager {
-    tenantID = index_js_1.ConfigInstance.getInstance().get("MICROSOFT_TENANT_ID") ||
-        index_js_1.ConfigInstance.getInstance().get("OI_MICROSOFT_TENANT_ID");
-    clientID = index_js_1.ConfigInstance.getInstance().get("MICROSOFT_CLIENT_ID") ||
-        index_js_1.ConfigInstance.getInstance().get("OI_MICROSOFT_APP_ID");
-    clientSecret = index_js_1.ConfigInstance.getInstance().get("MICROSOFT_CLIENT_SECRET") ||
-        index_js_1.ConfigInstance.getInstance().get("OI_MICROSOFT_CLIENT_SECRET");
-    userMail = index_js_1.ConfigInstance.getInstance().get("MICROSOFT_USER_EMAIL") ||
-        index_js_1.ConfigInstance.getInstance().get("OI_MICROSOFT_USER_EMAIL");
+    tenantID;
+    clientID;
+    clientSecret;
+    userMail;
+    constructor(config) {
+        this.tenantID = config.tenantId;
+        this.clientID = config.clientID;
+        this.clientSecret = config.clientSecret;
+        this.userMail = config.userMail;
+    }
     get isValid() {
         if (!this.tenantID)
             return "Missing Microsoft Tenant ID";
@@ -28,7 +29,6 @@ class CalendarManager {
     async getAccess() {
         if (this.isValid !== true)
             return null;
-        console.log("Getting access token...");
         try {
             const params = new URLSearchParams();
             params.append("client_id", this.clientID);
@@ -43,19 +43,17 @@ class CalendarManager {
                 body: params.toString(),
             });
             const data = await response.json();
-            console.log("Access token fetched successfully:", data);
+            if (!response.ok) {
+                console.error(`[CalendarManager] Failed to obtain access token: HTTP ${response.status}`);
+                return null;
+            }
             return data;
         }
         catch (error) {
-            console.error("Error fetching access token:", error);
+            console.error("[CalendarManager] Error fetching access token:", error);
             return null;
         }
     }
-    /**
-     * Create a new event in the calendar
-     * @param event The event data to create
-     * @returns the created event response
-     */
     async createEvent(event) {
         if (!this.userMail ||
             !this.tenantID ||
@@ -73,16 +71,12 @@ class CalendarManager {
             },
             body: JSON.stringify(event),
         });
-        const data = (await res.json());
-        console.log("Event creation response:", data);
-        return data;
+        if (!res.ok) {
+            console.error(`[CalendarManager] Failed to create event: HTTP ${res.status}`);
+            return;
+        }
+        return (await res.json());
     }
-    /**
-     * Update an event in the calendar
-     * @param eventId The ID of the event to update
-     * @param event The updated event data
-     * @returns
-     */
     async updateEvent(eventId, event) {
         const accessData = await this.getAccess();
         if (!accessData?.access_token)
@@ -95,15 +89,12 @@ class CalendarManager {
             },
             body: JSON.stringify(event),
         });
-        const data = (await res.json());
-        console.log("Event update response:", data);
-        return data;
+        if (!res.ok) {
+            console.error(`[CalendarManager] Failed to update event ${eventId}: HTTP ${res.status}`);
+            return;
+        }
+        return (await res.json());
     }
-    /**
-     * Delete an event from the calendar
-     * @param eventId The ID of the event to delete
-     * @returns whether the deletion was successful
-     */
     async deleteEvent(eventId) {
         const accessData = await this.getAccess();
         if (!accessData?.access_token)
@@ -115,7 +106,9 @@ class CalendarManager {
                 Authorization: `Bearer ${accessData.access_token}`,
             },
         });
-        console.log("Event deletion response:", res);
+        if (!res.ok) {
+            console.error(`[CalendarManager] Failed to delete event ${eventId}: HTTP ${res.status}`);
+        }
         return res.ok;
     }
     async fetchEvent(eventId) {
@@ -123,14 +116,12 @@ class CalendarManager {
         if (!accessData?.access_token)
             return null;
         const res = await fetch(`https://graph.microsoft.com/v1.0/users/${encodeURIComponent(this.userMail)}/events/${eventId}`, { headers: { Authorization: `Bearer ${accessData.access_token}` } });
-        if (!res.ok)
+        if (!res.ok) {
+            console.error(`[CalendarManager] Failed to fetch event ${eventId}: HTTP ${res.status}`);
             return null;
+        }
         return (await res.json());
     }
-    /**
-     * Fetch all events in calendar
-     * @returns the list of events
-     */
     async fetchEvents() {
         const accessData = await this.getAccess();
         if (!accessData?.access_token)
@@ -141,9 +132,11 @@ class CalendarManager {
                 Authorization: `Bearer ${accessData.access_token}`,
             },
         });
-        const data = await res.json();
-        console.log("Calendar events:", data);
-        return data;
+        if (!res.ok) {
+            console.error(`[CalendarManager] Failed to fetch events: HTTP ${res.status}`);
+            return;
+        }
+        return (await res.json());
     }
     /**
      * Fetch changed events since the last delta sync.
@@ -156,7 +149,7 @@ class CalendarManager {
         if (!accessData?.access_token)
             return null;
         const events = [];
-        let nextUrl = deltaLink || // treat empty string same as missing
+        let nextUrl = deltaLink ||
             `https://graph.microsoft.com/v1.0/users/${encodeURIComponent(this.userMail)}/events/delta`;
         let newDeltaLink = "";
         while (nextUrl) {
@@ -173,9 +166,10 @@ class CalendarManager {
             if (data["@odata.deltaLink"])
                 newDeltaLink = data["@odata.deltaLink"];
         }
-        console.log("Delta fetch result:", { events, newDeltaLink });
-        if (!newDeltaLink)
+        if (!newDeltaLink) {
+            console.error("[CalendarManager] fetchDelta did not return a deltaLink.");
             return null;
+        }
         return { events, deltaLink: newDeltaLink };
     }
 }

package/dist/features/openservice/schedules/calendarSync/service/CalendarSyncPoller.d.ts

@@ -1,6 +1,9 @@
+import { Config } from "../../../../../types/index.js";
 export declare class CalendarSyncPoller {
-    private manager;
     private timer;
+    private config;
+    constructor(config: Config);
+    private get manager();
     /**
      * Start polling the Microsoft Calendar delta feed.
      * @param intervalMs polling interval in milliseconds (default: 5 minutes)

package/dist/features/openservice/schedules/calendarSync/service/CalendarSyncPoller.js

@@ -9,17 +9,28 @@ const eventToSchedule_js_1 = require("../functions/eventToSchedule.js");
 const calendarMetaHelper_js_1 = require("./calendarMetaHelper.js");
 const CalendarManager_js_1 = require("./CalendarManager.js");
 const index_js_1 = require("../../../../../types/index.js");
-const DELTA_LINK_CONFIG_KEY = "microsoftCalendarDeltaLink";
 class CalendarSyncPoller {
-    manager = new CalendarManager_js_1.CalendarManager();
     timer = null;
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    get manager() {
+        const configValues = JSON.parse(this.config.get("value"));
+        return new CalendarManager_js_1.CalendarManager({
+            tenantId: configValues.tenant_id,
+            clientID: configValues.client_id,
+            clientSecret: configValues.client_secret,
+            userMail: configValues.user_email,
+        });
+    }
     /**
      * Start polling the Microsoft Calendar delta feed.
      * @param intervalMs polling interval in milliseconds (default: 5 minutes)
      */
     start(intervalMs = 5 * 60 * 1000) {
-        if (this.manager.isValid !== true) {
-            console.log("[CalendarSyncPoller] Not started — missing Microsoft credentials.", this.manager.isValid);
+        if (this.manager?.isValid !== true) {
+            console.error(`[CalendarSyncPoller] Not started — invalid configuration: ${this.manager?.isValid}`);
             return;
         }
         this.poll().catch(console.error);
@@ -30,11 +41,10 @@ class CalendarSyncPoller {
             clearInterval(this.timer);
     }
     async poll() {
-        console.log("[CalendarSyncPoller] Polling calendar delta...");
         const deltaLink = await this.loadDeltaLink();
-        const result = await this.manager.fetchDelta(deltaLink ?? undefined);
+        const result = await this.manager?.fetchDelta(deltaLink);
         if (!result) {
-            console.log("[CalendarSyncPoller] Failed to fetch calendar delta.");
+            console.error("[CalendarSyncPoller] Failed to fetch calendar delta.");
             return;
         }
         for (const event of result.events) {
@@ -52,6 +62,10 @@ class CalendarSyncPoller {
             await this.handleDeleted(event.id);
             return;
         }
+        // Exception events are individual moved/edited occurrences of a series.
+        // The series master handles the recurrence as a whole; exceptions are noise.
+        if (event.type === "exception")
+            return;
         const metaEntry = await (0, calendarMetaHelper_js_1.findCalendarMetaByEventId)(event.id);
         if (metaEntry) {
             const storedChangeKey = metaEntry.get("values")?.microsoftCalendarChangeKey;
@@ -62,7 +76,7 @@ class CalendarSyncPoller {
         }
         else {
             // Delta responses omit most properties; fetch the full event before creating a schedule
-            const fullEvent = await this.manager.fetchEvent(event.id);
+            const fullEvent = await this.manager?.fetchEvent(event.id);
             if (!fullEvent)
                 return;
             await this.createScheduleFromEvent(fullEvent);
@@ -73,15 +87,19 @@ class CalendarSyncPoller {
         if (!scheduleId)
             return;
         // Delta responses omit most fields; fetch the full event for title/body/cron
-        const fullEvent = await this.manager.fetchEvent(event.id) ?? event;
+        const fullEvent = (await this.manager?.fetchEvent(event.id)) ?? event;
         const schedule = await new node_1.default.Query(index_js_1.Maintenance_Schedule).get(scheduleId, { useMasterKey: true });
         if (fullEvent.subject)
             schedule.set("title", fullEvent.subject);
         if (fullEvent.bodyPreview)
             schedule.set("description", fullEvent.bodyPreview);
         const cronData = (0, eventToSchedule_js_1.eventToSchedule)(fullEvent);
-        if (cronData)
-            schedule.set("cron", cronData);
+        if (cronData) {
+            const { notifyBeforeDue, ...cron } = cronData;
+            schedule.set("cron", cron);
+            if (notifyBeforeDue != null)
+                schedule.set("notifyBeforeDue", notifyBeforeDue);
+        }
         // useMasterKey prevents afterSaveHook from re-syncing back to calendar
         await schedule.save(null, { useMasterKey: true });
         if (event.changeKey) {
@@ -90,31 +108,45 @@ class CalendarSyncPoller {
     }
     async createScheduleFromEvent(event) {
         const parsed = parseEventSubject(event.subject);
-        if (!parsed) {
-            console.log(`[CalendarSyncPoller] Skipping event "${event.subject}" (${event.id}) — subject does not match expected format: '"<source>" - <title>'.`);
-            return;
+        let source;
+        const tenant = this.config.get("tenant");
+        if (parsed) {
+            source = await new node_1.default.Query(index_js_1.Source)
+                .equalTo("name", parsed.sourceName)
+                .equalTo("tenant", tenant)
+                .first({ useMasterKey: true });
         }
-        const source = await new node_1.default.Query(index_js_1.Source)
-            .equalTo("name", parsed.sourceName)
-            .first({ useMasterKey: true });
         if (!source) {
-            console.log(`[CalendarSyncPoller] Skipping event "${event.subject}" (${event.id}) — no Source found with name "${parsed.sourceName}".`);
-            return;
+            const configValues = JSON.parse(this.config.get("value"));
+            if (!configValues.default_source_id) {
+                console.error(`[CalendarSyncPoller] Skipping event ${event.id} — no source name in subject and no default_source_id configured.`);
+                return;
+            }
+            source = await new node_1.default.Query(index_js_1.Source)
+                .equalTo("objectId", configValues.default_source_id)
+                .first({ useMasterKey: true });
+            if (!source) {
+                console.error(`[CalendarSyncPoller] Skipping event ${event.id} — default source "${configValues.default_source_id}" not found.`);
+                return;
+            }
         }
         const schedule = new index_js_1.Maintenance_Schedule();
         schedule.set("title", event.subject);
         schedule.set("source", source);
         schedule.set("enabled", true);
-        schedule.set("tenant", source.get("tenant"));
+        schedule.set("tenant", tenant);
         if (event.bodyPreview)
             schedule.set("description", event.bodyPreview);
         const cronData = (0, eventToSchedule_js_1.eventToSchedule)(event);
-        if (cronData)
-            schedule.set("cron", cronData);
+        if (cronData) {
+            const { notifyBeforeDue, ...cron } = cronData;
+            schedule.set("cron", cron);
+            if (notifyBeforeDue != null)
+                schedule.set("notifyBeforeDue", notifyBeforeDue);
+        }
         // useMasterKey prevents afterSaveHook from syncing back to calendar
         await schedule.save(null, { useMasterKey: true });
-        await (0, calendarMetaHelper_js_1.saveCalendarMeta)(schedule.id, event.id, event.changeKey, source.get("tenant"), event);
-        console.log(`[CalendarSyncPoller] Created schedule "${event.subject}" for source "${parsed.sourceName}" from calendar event ${event.id}.`);
+        await (0, calendarMetaHelper_js_1.saveCalendarMeta)(schedule.id, event.id, event.changeKey, tenant, event);
     }
     async handleDeleted(eventId) {
         const metaEntry = await (0, calendarMetaHelper_js_1.findCalendarMetaByEventId)(eventId);
@@ -135,16 +167,16 @@ class CalendarSyncPoller {
         await metaEntry.destroy({ useMasterKey: true });
     }
     async loadDeltaLink() {
-        try {
-            const config = await node_1.default.Config.get({ useMasterKey: true });
-            return config.get(DELTA_LINK_CONFIG_KEY) || null;
-        }
-        catch {
-            return null;
-        }
+        this.config = await this.config.fetch({ useMasterKey: true });
+        const values = JSON.parse(this.config.get("value"));
+        return values.delta_link;
     }
     async saveDeltaLink(link) {
-        await node_1.default.Config.save({ [DELTA_LINK_CONFIG_KEY]: link }, { useMasterKey: true });
+        this.config = await this.config.fetch({ useMasterKey: true });
+        const values = JSON.parse(this.config.get("value"));
+        values.delta_link = link;
+        this.config.set("value", JSON.stringify(values));
+        await this.config.save(null, { useMasterKey: true });
     }
 }
 exports.CalendarSyncPoller = CalendarSyncPoller;

package/dist/features/openservice/schedules/calendarSync/types/ConfigValues.d.ts

@@ -0,0 +1,8 @@
+export type ConfigValues = {
+    tenant_id: string;
+    client_id: string;
+    client_secret: string;
+    user_email: string;
+    default_source_id?: string;
+    delta_link?: string;
+};

package/dist/features/openservice/schedules/calendarSync/types/ConfigValues.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/features/openservice/schedules/initSchedulesFeature.js

@@ -9,7 +9,11 @@ const index_js_1 = require("../../../types/index.js");
 const CalendarSyncPoller_js_1 = require("./calendarSync/service/CalendarSyncPoller.js");
 async function initSchedulesFeature() {
     updateFiinishedSchedules();
-    new CalendarSyncPoller_js_1.CalendarSyncPoller().start(1000 * 60);
+    const configs = await new node_1.default.Query(index_js_1.Config)
+        .equalTo("key", "OPENSERVICE_MICROSOFT_OUTLOOK_INTEGRATION")
+        .includeAll()
+        .findAll({ useMasterKey: true });
+    const pollers = configs.map((config) => new CalendarSyncPoller_js_1.CalendarSyncPoller(config).start(1000 * 60));
 }
 async function updateFiinishedSchedules() {
     const executionsToUpdate = await new node_1.default.Query(index_js_1.Maintenance_Schedule_Execution)

package/dist/hooks/Config_open_service.js

@@ -45,6 +45,8 @@ async function init() {
             //object.value can look like this: [{"label":"PSA","allowedValues":[],"required":false},{"label":"Typ","allowedValues":[],"required":false,"onlyOneAllowedValue":false},{"label":"Material","allowedValues":["@OD3_Maintenance_Item"],"required":false,"onlyOneAllowedValue":false},{"label":"Dienstleister","allowedValues":["@OD3_COMPANY","@OD3_CONTACT"],"required":false,"onlyOneAllowedValue":false}]
             //fields in Maintenance_Step can look like this: [{"value":"Handschuhe","metafield":{"label":"PSA","allowedValues":[],"required":false}},{"value":"Auffüllen","metafield":{"label":"Typ","allowedValues":[],"required":false,"onlyOneAllowedValue":false}}]
             const metafieldsconfig = JSON.parse(object.get("value"));
+            if (!Array.isArray(metafieldsconfig))
+                return;
             const [maintenanceStepQueryError, maintenanceStepQuery] = await (0, catchError_js_1.catchError)(new node_1.default.Query(index_js_2.Maintenance_Schedule_Step).find({
                 useMasterKey: true,
             }));

package/dist/hooks/Maintenance_Schedule.js

@@ -52,7 +52,7 @@ async function init() {
     });
     (0, schema_1.beforeDeleteHook)(types_1.Maintenance_Schedule, async (request) => {
         const { object } = request;
-        const scheduleFetched = await object?.fetchWithInclude(["template", "source"], {
+        const scheduleFetched = await object?.fetchWithInclude(["template", "source", "tenant"], {
             useMasterKey: true,
         });
         const template = scheduleFetched?.get("template");
@@ -64,7 +64,10 @@ async function init() {
         if (metaEntry) {
             const eventId = metaEntry.get("values")?.microsoftCalendarEventId;
             if (eventId) {
-                await new CalendarManager_1.CalendarManager().deleteEvent(eventId);
+                const calendarManager = await getScheduleCalendarManager(object);
+                if (!calendarManager)
+                    return;
+                await calendarManager.deleteEvent(eventId);
             }
             await metaEntry.destroy({ useMasterKey: true });
         }
@@ -89,14 +92,16 @@ async function addToTemplateSources(schedule) {
     await template.save(null, { useMasterKey: true });
 }
 async function updateCalendarEvent(schedule) {
-    const event = await (0, scheduleToEvent_1.scheduleToEvent)(schedule);
+    const metaEntry = await (0, calendarMetaHelper_1.findCalendarMetaForSchedule)(schedule.id);
+    const snapshot = metaEntry?.get("values")?.microsoftCalendarEvent;
+    const event = await (0, scheduleToEvent_1.scheduleToEvent)(schedule, snapshot);
     if (!event)
         return;
-    const calendarManager = new CalendarManager_1.CalendarManager();
-    const metaEntry = await (0, calendarMetaHelper_1.findCalendarMetaForSchedule)(schedule.id);
+    const calendarManager = await getScheduleCalendarManager(schedule);
+    if (!calendarManager)
+        return;
     const eventId = metaEntry?.get("values")?.microsoftCalendarEventId;
     if (eventId) {
-        console.log("Updating schedule in calendar...");
         const updatedEvent = await calendarManager.updateEvent(eventId, event);
         if (updatedEvent?.changeKey && metaEntry) {
             await (0, calendarMetaHelper_1.updateCalendarChangeKey)(metaEntry, updatedEvent.changeKey, updatedEvent);
@@ -111,13 +116,31 @@ async function updateCalendarEvent(schedule) {
  * @param schedule
  */
 async function addToCalendar(schedule) {
-    console.log("Creating new calendar event for schedule...");
     const event = await (0, scheduleToEvent_1.scheduleToEvent)(schedule);
     if (!event)
         return;
-    const calendarManager = new CalendarManager_1.CalendarManager();
+    const calendarManager = await getScheduleCalendarManager(schedule);
+    if (!calendarManager)
+        return;
     const createdEvent = await calendarManager.createEvent(event);
     if (createdEvent?.id) {
         await (0, calendarMetaHelper_1.saveCalendarMeta)(schedule.id, createdEvent.id, createdEvent.changeKey, schedule.get("tenant"), createdEvent);
     }
 }
+async function getScheduleCalendarManager(schedule) {
+    const config = await new node_1.default.Query(types_1.Config)
+        .equalTo("key", "OPENSERVICE_MICROSOFT_OUTLOOK_INTEGRATION")
+        .equalTo("tenant", schedule.get("tenant"))
+        .first({ useMasterKey: true });
+    if (!config) {
+        return;
+    }
+    const configValues = JSON.parse(config.get("value"));
+    const calendarManager = new CalendarManager_1.CalendarManager({
+        tenantId: configValues.tenant_id,
+        clientID: configValues.client_id,
+        clientSecret: configValues.client_secret,
+        userMail: configValues.user_email,
+    });
+    return calendarManager;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openinc/parse-server-opendash",
-  "version": "4.0.29",
+  "version": "4.0.31",
   "description": "Parse Server Cloud Code for open.INC Stack.",
   "packageManager": "pnpm@10.33.0",
   "keywords": [
@@ -72,14 +72,14 @@
     "dayjs": "^1.11.20",
     "dotenv": "^17.4.2",
     "fast-equals": "^6.0.0",
-    "i18next": "^26.0.6",
-    "i18next-fs-backend": "^2.6.4",
+    "i18next": "^26.0.10",
+    "i18next-fs-backend": "^2.6.5",
     "jsonwebtoken": "^9.0.3",
     "jwks-rsa": "^4.0.1",
-    "nodemailer": "^8.0.5",
+    "nodemailer": "^8.0.7",
     "nunjucks": "^3.2.4",
-    "parse": "8.5.0",
-    "parse-server": "9.8.0",
+    "parse": "^8.5.0",
+    "parse-server": "^9.8.0",
     "pdf-img-convert": "2.0.0",
     "rimraf": "^6.1.3",
     "table": "^6.9.0",