@openinc/parse-server-opendash 4.0.28 → 4.0.30

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

@@ -1,11 +1,17 @@
 import { GraphEventResponse } from "../types/Event.js";
 export type ScheduleCronTimestamp = {
-    startData: Date;
-    endData?: Date;
+    startDate: Date;
+    endDate?: Date;
     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,39 +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 startData;
-    if (range?.startDate) {
-        // range.startDate is YYYY-MM-DD
-        startData = new Date(range.startDate + "T00:00:00Z");
-    }
-    else if (event.start?.dateTime) {
-        startData = new Date(event.start.dateTime);
+    // 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") {
+        endDate = parseDateOnly(range.endDate);
     }
-    // For end, prefer range.endDate. If range.type === 'noEnd' leave undefined.
-    let endData;
-    if (range?.type === "endDate" && range?.endDate) {
-        endData = new Date(range.endDate + "T00:00:00Z");
+    else if (range.type === "numbered") {
+        // Compute end date from occurrence count
+        const occurrences = range.numberOfOccurrences ?? 1;
+        endDate = startDate.add((occurrences - 1) * effectiveInterval, unit);
     }
-    else if (event.end?.dateTime) {
-        endData = new Date(event.end.dateTime);
-    }
-    if (!startData)
-        return undefined;
+    // range.type === "noEnd" → endDate stays undefined
     return {
         schedule_type: "timestamp",
         timestamp: {
-            startData,
-            endData,
-            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

@@ -1,13 +1,36 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.scheduleToEvent = scheduleToEvent;
-async function scheduleToEvent(schedule) {
-    console.log("Converting Schedule to Event...");
+const dayjs_1 = __importDefault(require("dayjs"));
+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");
+        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");
@@ -16,33 +39,39 @@ async function scheduleToEvent(schedule) {
     const end = scheduleCron?.timestamp?.endDate ?? templateCron?.timestamp?.endDate;
     const interval = scheduleCron?.timestamp?.number ?? templateCron?.timestamp?.number;
     const unit = scheduleCron?.timestamp?.unit ?? templateCron?.timestamp?.unit;
-    if (!start || !end || !interval || !unit) {
-        console.log("Insufficient data to create event from schedule.");
+    if (!start || !interval || !unit) {
         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"),
-        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: end.toISOString().slice(0, 19),
-            timeZone: "UTC",
-        },
-        isAllDay: true,
+        body: { contentType: "Text", content: description ?? "" },
+        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",
@@ -57,32 +86,32 @@ 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) {
-        event.recurrence = {
-            pattern,
-            range: {
+        const range = end
+            ? {
                 type: "endDate",
                 startDate: toDateOnly(start),
                 endDate: toDateOnly(end),
-            },
-        };
-        // if event is all-day, set start/end to date-only values (Graph expects dates)
-        if (event.isAllDay) {
+            }
+            : {
+                type: "noEnd",
+                startDate: toDateOnly(start),
+            };
+        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);
-            event.end.dateTime = toDateOnly(endForEvent);
+            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,32 +3,37 @@ import { GraphEvent, GraphEventResponse } from "../types/Event.js";
  * Manager for calendar operations via Microsoft Graph API
  */
 export declare class CalendarManager {
-    isValid: boolean;
+    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<unknown>;
-    /**
-     * Delete an event from the calendar
-     * @param eventId The ID of the event to delete
-     * @returns whether the deletion was successful
-     */
+    updateEvent(eventId: string, event: Partial<GraphEvent>): Promise<GraphEventResponse | undefined>;
     deleteEvent(eventId: string): Promise<boolean | undefined>;
-    /**
-     * Fetch all events in calendar
-     * @returns the list of events
-     */
+    fetchEvent(eventId: string): Promise<GraphEventResponse | null>;
     fetchEvents(): Promise<{
         value: GraphEventResponse[];
     } | undefined>;
+    /**
+     * Fetch changed events since the last delta sync.
+     * On the first call (no deltaLink), returns all current events and a deltaLink
+     * for subsequent incremental calls.
+     * @param deltaLink token from the previous call; omit for the initial full sync
+     */
+    fetchDelta(deltaLink?: string): Promise<{
+        events: (GraphEventResponse & {
+            "@removed"?: {
+                reason: string;
+            };
+        })[];
+        deltaLink: string;
+    } | null>;
 }

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

@@ -1,27 +1,41 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CalendarManager = void 0;
-const index_js_1 = require("../../../../config/index.js");
-const tenantID = index_js_1.ConfigInstance.getInstance().get("MICROSOFT_TENANT_ID");
-const clientID = index_js_1.ConfigInstance.getInstance().get("MICROSOFT_CLIENT_ID");
-const clientSecret = index_js_1.ConfigInstance.getInstance().get("MICROSOFT_CLIENT_SECRET");
-const userMail = index_js_1.ConfigInstance.getInstance().get("MICROSOFT_USER_EMAIL");
 /**
  * Manager for calendar operations via Microsoft Graph API
  */
 class CalendarManager {
-    isValid = !!(tenantID && clientID && clientSecret && userMail);
+    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";
+        if (!this.clientID)
+            return "Missing Microsoft Client ID";
+        if (!this.clientSecret)
+            return "Missing Microsoft Client Secret";
+        if (!this.userMail)
+            return "Missing Microsoft User Email";
+        return true;
+    }
     async getAccess() {
-        if (!this.isValid)
+        if (this.isValid !== true)
             return null;
-        console.log("Getting access token...");
         try {
             const params = new URLSearchParams();
-            params.append("client_id", clientID);
-            params.append("client_secret", clientSecret);
+            params.append("client_id", this.clientID);
+            params.append("client_secret", this.clientSecret);
             params.append("scope", "https://graph.microsoft.com/.default");
             params.append("grant_type", "client_credentials");
-            const response = await fetch(`https://login.microsoftonline.com/${tenantID}/oauth2/v2.0/token`, {
+            const response = await fetch(`https://login.microsoftonline.com/${this.tenantID}/oauth2/v2.0/token`, {
                 method: "POST",
                 headers: {
                     "Content-Type": "application/x-www-form-urlencoded",
@@ -29,26 +43,27 @@ 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 (!userMail || !tenantID || !clientID || !clientSecret)
+        if (!this.userMail ||
+            !this.tenantID ||
+            !this.clientID ||
+            !this.clientSecret)
             return;
         const accessData = await this.getAccess();
         if (!accessData?.access_token)
             return;
-        const res = await fetch(`https://graph.microsoft.com/v1.0/users/${encodeURIComponent(userMail)}/events`, {
+        const res = await fetch(`https://graph.microsoft.com/v1.0/users/${encodeURIComponent(this.userMail)}/events`, {
             method: "POST",
             headers: {
                 Authorization: `Bearer ${accessData.access_token}`,
@@ -56,21 +71,17 @@ 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)
             return;
-        const res = await fetch(`https://graph.microsoft.com/v1.0/users/${encodeURIComponent(userMail)}/events/${eventId}`, {
+        const res = await fetch(`https://graph.microsoft.com/v1.0/users/${encodeURIComponent(this.userMail)}/events/${eventId}`, {
             method: "PATCH",
             headers: {
                 Authorization: `Bearer ${accessData.access_token}`,
@@ -78,46 +89,88 @@ 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)
             return;
         // on successful deletion, Microsoft Graph returns 204 No Content, so no JSON to parse
-        const res = await fetch(`https://graph.microsoft.com/v1.0/users/${encodeURIComponent(userMail)}/events/${eventId}`, {
+        const res = await fetch(`https://graph.microsoft.com/v1.0/users/${encodeURIComponent(this.userMail)}/events/${eventId}`, {
             method: "DELETE",
             headers: {
                 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;
     }
-    /**
-     * Fetch all events in calendar
-     * @returns the list of events
-     */
+    async fetchEvent(eventId) {
+        const accessData = await this.getAccess();
+        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) {
+            console.error(`[CalendarManager] Failed to fetch event ${eventId}: HTTP ${res.status}`);
+            return null;
+        }
+        return (await res.json());
+    }
     async fetchEvents() {
         const accessData = await this.getAccess();
         if (!accessData?.access_token)
             return;
-        const res = await fetch(`https://graph.microsoft.com/v1.0/users/${encodeURIComponent(userMail)}/events`, {
+        const res = await fetch(`https://graph.microsoft.com/v1.0/users/${encodeURIComponent(this.userMail)}/events`, {
             method: "GET",
             headers: {
                 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.
+     * On the first call (no deltaLink), returns all current events and a deltaLink
+     * for subsequent incremental calls.
+     * @param deltaLink token from the previous call; omit for the initial full sync
+     */
+    async fetchDelta(deltaLink) {
+        const accessData = await this.getAccess();
+        if (!accessData?.access_token)
+            return null;
+        const events = [];
+        let nextUrl = deltaLink ||
+            `https://graph.microsoft.com/v1.0/users/${encodeURIComponent(this.userMail)}/events/delta`;
+        let newDeltaLink = "";
+        while (nextUrl) {
+            const res = await fetch(nextUrl, {
+                headers: { Authorization: `Bearer ${accessData.access_token}` },
+            });
+            if (!res.ok) {
+                console.error(`[CalendarManager] fetchDelta HTTP ${res.status}:`, await res.text());
+                return null;
+            }
+            const data = (await res.json());
+            events.push(...(data.value ?? []));
+            nextUrl = data["@odata.nextLink"];
+            if (data["@odata.deltaLink"])
+                newDeltaLink = data["@odata.deltaLink"];
+        }
+        if (!newDeltaLink) {
+            console.error("[CalendarManager] fetchDelta did not return a deltaLink.");
+            return null;
+        }
+        return { events, deltaLink: newDeltaLink };
     }
 }
 exports.CalendarManager = CalendarManager;

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

@@ -0,0 +1,20 @@
+import { Config } from "../../../../../types/index.js";
+export declare class CalendarSyncPoller {
+    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)
+     */
+    start(intervalMs?: number): void;
+    stop(): void;
+    private poll;
+    private processEvent;
+    private updateScheduleFromEvent;
+    private createScheduleFromEvent;
+    private handleDeleted;
+    private loadDeltaLink;
+    private saveDeltaLink;
+}