@openinc/parse-server-opendash 3.24.6 → 3.25.0

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

@@ -0,0 +1,11 @@
+import { GraphEventResponse } from "../types/Event";
+export type ScheduleCronTimestamp = {
+    startData: Date;
+    endData?: Date;
+    number: number;
+    unit: "days" | "weeks" | "months";
+};
+export declare function eventToSchedule(event: GraphEventResponse): {
+    timestamp: ScheduleCronTimestamp;
+    schedule_type: "timestamp";
+} | undefined;

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

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventToSchedule = eventToSchedule;
+function eventToSchedule(event) {
+    const recurrence = event?.recurrence;
+    if (!recurrence)
+        return undefined;
+    const pattern = recurrence.pattern;
+    const range = recurrence.range;
+    if (!pattern || !range || !pattern.type)
+        return undefined;
+    let unit;
+    switch (pattern.type) {
+        case "daily":
+            unit = "days";
+            break;
+        case "weekly":
+            unit = "weeks";
+            break;
+        case "absoluteMonthly":
+        case "relativeMonthly":
+            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);
+    }
+    // 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 (event.end?.dateTime) {
+        endData = new Date(event.end.dateTime);
+    }
+    if (!startData)
+        return undefined;
+    return {
+        schedule_type: "timestamp",
+        timestamp: {
+            startData,
+            endData,
+            number: interval,
+            unit,
+        },
+    };
+}

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

@@ -0,0 +1,3 @@
+import { Maintenance_Schedule } from "../../../../../types";
+import { GraphEvent } from "../types/Event";
+export declare function scheduleToEvent(schedule: Maintenance_Schedule): Promise<GraphEvent | undefined>;

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

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scheduleToEvent = scheduleToEvent;
+async function scheduleToEvent(schedule) {
+    console.log("Converting Schedule to Event...");
+    try {
+        await schedule.fetchWithInclude("template");
+    }
+    catch (error) {
+        console.error("Error fetching template:", error);
+    }
+    const template = schedule.get("template");
+    const templateCron = template?.get("cron");
+    const scheduleCron = schedule.get("cron");
+    const start = scheduleCron?.timestamp?.startDate ?? templateCron?.timestamp?.startDate;
+    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.");
+        return;
+    }
+    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,
+    };
+    // 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",
+            "Tuesday",
+            "Wednesday",
+            "Thursday",
+            "Friday",
+            "Saturday",
+        ];
+        pattern.daysOfWeek = [dayNames[start.getUTCDay()]];
+        pattern.firstDayOfWeek = "Monday";
+    }
+    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: {
+                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) {
+            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);
+        }
+    }
+    console.log("Schedule converted to Event:", event);
+    return event;
+}

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

@@ -0,0 +1,34 @@
+import { GraphEvent, GraphEventResponse } from "../types/Event";
+/**
+ * Manager for calendar operations via Microsoft Graph API
+ */
+export declare class CalendarManager {
+    isValid: boolean;
+    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
+     */
+    deleteEvent(eventId: string): Promise<boolean | undefined>;
+    /**
+     * Fetch all events in calendar
+     * @returns the list of events
+     */
+    fetchEvents(): Promise<{
+        value: GraphEventResponse[];
+    } | undefined>;
+}

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

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CalendarManager = void 0;
+const tenantID = process.env.MICROSOFT_TENANT_ID;
+const clientID = process.env.MICROSOFT_CLIENT_ID;
+const clientSecret = process.env.MICROSOFT_CLIENT_SECRET;
+const userMail = process.env.MICROSOFT_USER_EMAIL;
+/**
+ * Manager for calendar operations via Microsoft Graph API
+ */
+class CalendarManager {
+    constructor() {
+        this.isValid = !!(tenantID && clientID && clientSecret && userMail);
+    }
+    async getAccess() {
+        if (!this.isValid)
+            return null;
+        console.log("Getting access token...");
+        try {
+            const params = new URLSearchParams();
+            params.append("client_id", clientID);
+            params.append("client_secret", 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`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/x-www-form-urlencoded",
+                },
+                body: params.toString(),
+            });
+            const data = await response.json();
+            console.log("Access token fetched successfully:", data);
+            return data;
+        }
+        catch (error) {
+            console.error("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)
+            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`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${accessData.access_token}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(event),
+        });
+        const data = (await res.json());
+        console.log("Event creation response:", data);
+        return data;
+    }
+    /**
+     * 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}`, {
+            method: "PATCH",
+            headers: {
+                Authorization: `Bearer ${accessData.access_token}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(event),
+        });
+        const data = await res.json();
+        console.log("Event update response:", data);
+        return data;
+    }
+    /**
+     * 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}`, {
+            method: "DELETE",
+            headers: {
+                Authorization: `Bearer ${accessData.access_token}`,
+            },
+        });
+        console.log("Event deletion response:", res);
+        return res.ok;
+    }
+    /**
+     * Fetch all events in calendar
+     * @returns the list of events
+     */
+    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`, {
+            method: "GET",
+            headers: {
+                Authorization: `Bearer ${accessData.access_token}`,
+            },
+        });
+        const data = await res.json();
+        console.log("Calendar events:", data);
+        return data;
+    }
+}
+exports.CalendarManager = CalendarManager;

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

@@ -0,0 +1,9 @@
+/**
+ * The Return-Type of Microsoft
+ */
+export type Access = {
+    token_type: "Bearer";
+    expires_in: number;
+    ext_expires_in: number;
+    access_token: string;
+};

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

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

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

@@ -0,0 +1,150 @@
+export type DateTimeTimeZone = {
+    dateTime: string;
+    timeZone: string;
+};
+export type EmailAddress = {
+    name?: string;
+    address: string;
+};
+export type Attendee = {
+    type?: "required" | "optional" | "resource";
+    emailAddress: EmailAddress;
+};
+export type ItemBody = {
+    contentType?: "Text" | "HTML";
+    content?: string;
+};
+export type LocationAddress = {
+    street?: string;
+    city?: string;
+    state?: string;
+    countryOrRegion?: string;
+    postalCode?: string;
+};
+export type Location = {
+    displayName?: string;
+    locationEmailAddress?: string;
+    locationUri?: string;
+    address?: LocationAddress;
+    locationType?: string;
+    uniqueId?: string;
+};
+export type RecurrencePattern = {
+    type: "daily" | "weekly" | "absoluteMonthly" | "relativeMonthly" | "absoluteYearly" | "relativeYearly";
+    interval?: number;
+    daysOfWeek?: Array<"Sunday" | "Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday" | "Saturday">;
+    firstDayOfWeek?: "Sunday" | "Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday" | "Saturday";
+    month?: number;
+    index?: "first" | "second" | "third" | "fourth" | "last";
+};
+export type RecurrenceRange = {
+    type: "noEnd";
+    startDate: string;
+} | {
+    type: "endDate";
+    startDate: string;
+    endDate: string;
+} | {
+    type: "numbered";
+    startDate: string;
+    numberOfOccurrences: number;
+};
+export type Recurrence = {
+    pattern: RecurrencePattern;
+    range: RecurrenceRange;
+};
+/**
+ * Graph Event type for creating/updating events
+ */
+export type GraphEvent = {
+    subject?: string;
+    body?: ItemBody;
+    start: DateTimeTimeZone;
+    end: DateTimeTimeZone;
+    location?: Location;
+    attendees?: Attendee[];
+    isAllDay?: boolean;
+    recurrence?: Recurrence;
+    sensitivity?: "normal" | "personal" | "private" | "confidential";
+    showAs?: "free" | "tentative" | "busy" | "oof" | "workingElsewhere" | "unknown";
+    importance?: "low" | "normal" | "high";
+    allowNewTimeProposals?: boolean;
+    reminderMinutesBeforeStart?: number;
+    isReminderOn?: boolean;
+    categories?: string[];
+    transactionId?: string;
+    onlineMeetingProvider?: "unknown" | "skypeForBusiness" | "skypeForConsumer" | "teamsForBusiness";
+    onlineMeeting?: {
+        joinUrl?: string;
+    };
+};
+export type GraphEventResponse = {
+    "@odata.context"?: string;
+    "@odata.etag"?: string;
+    id: string;
+    createdDateTime?: string;
+    lastModifiedDateTime?: string;
+    changeKey?: string;
+    categories?: string[];
+    transactionId?: string | null;
+    originalStartTimeZone?: string;
+    originalEndTimeZone?: string;
+    iCalUId?: string;
+    uid?: string;
+    reminderMinutesBeforeStart?: number;
+    isReminderOn?: boolean;
+    hasAttachments?: boolean;
+    subject?: string;
+    bodyPreview?: string;
+    importance?: "low" | "normal" | "high";
+    sensitivity?: "normal" | "personal" | "private" | "confidential";
+    isAllDay?: boolean;
+    isCancelled?: boolean;
+    isOrganizer?: boolean;
+    responseRequested?: boolean;
+    seriesMasterId?: string | null;
+    showAs?: "free" | "tentative" | "busy" | "oof" | "workingElsewhere" | "unknown";
+    type?: string;
+    webLink?: string;
+    onlineMeetingUrl?: string | null;
+    isOnlineMeeting?: boolean;
+    onlineMeetingProvider?: "unknown" | "skypeForBusiness" | "skypeForConsumer" | "teamsForBusiness" | string;
+    allowNewTimeProposals?: boolean;
+    occurrenceId?: string | null;
+    isDraft?: boolean;
+    hideAttendees?: boolean;
+    responseStatus?: {
+        response?: string;
+        time?: string;
+    };
+    body?: {
+        contentType?: string;
+        content?: string;
+    };
+    start: DateTimeTimeZone;
+    end: DateTimeTimeZone;
+    location?: {
+        displayName?: string;
+        locationType?: string;
+        uniqueId?: string;
+        uniqueIdType?: string;
+        locationEmailAddress?: string;
+        address?: LocationAddress;
+    } | null;
+    locations?: Array<{
+        displayName?: string;
+        locationType?: string;
+        uniqueId?: string;
+        uniqueIdType?: string;
+        locationEmailAddress?: string;
+        address?: LocationAddress;
+    }>;
+    recurrence?: Recurrence | null;
+    attendees?: Attendee[];
+    organizer?: {
+        emailAddress: EmailAddress;
+    };
+    onlineMeeting?: {
+        joinUrl?: string;
+    } | null;
+};

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

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

package/dist/hooks/Maintenance_Schedule.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.init = init;
 const __1 = require("..");
+const scheduleToEvent_1 = require("../features/openservice/schedules/calendarSync/functions/scheduleToEvent");
+const CalendarManager_1 = require("../features/openservice/schedules/calendarSync/service/CalendarManager");
 const types_1 = require("../types");
 async function init() {
     (0, __1.beforeSaveHook)(types_1.Maintenance_Schedule, async (request) => {
@@ -10,12 +12,19 @@ async function init() {
         await (0, __1.defaultAclHandler)(request);
     });
     (0, __1.afterSaveHook)(types_1.Maintenance_Schedule, async (request) => {
-        const { object, original, user } = request;
-        if (!original)
+        const { object, original, user, master } = request;
+        if (!original) {
             await addToTemplateSources(object);
+            if (!master) {
+                await addToCalendar(object);
+            }
+        }
+        if (original && !master) {
+            await updateCalendarEvent(object);
+        }
     });
     (0, __1.beforeDeleteHook)(types_1.Maintenance_Schedule, async (request) => {
-        const { object, original, user } = request;
+        const { object, original, user, master } = request;
         const scheduleFetched = await object?.fetchWithInclude(["template", "source"], {
             useMasterKey: true,
         });
@@ -24,6 +33,10 @@ async function init() {
         if (source)
             template?.relation("sources").remove(source);
         await template?.save(null, { useMasterKey: true });
+        // Delete associated calendar event
+        if (object.get("meta")?.calendarEventId) {
+            await new CalendarManager_1.CalendarManager().deleteEvent(object.get("meta")?.calendarEventId);
+        }
     });
 }
 async function addToTemplateSources(schedule) {
@@ -39,3 +52,38 @@ async function addToTemplateSources(schedule) {
     template.relation("sources").add(schedule.source);
     await template.save(null, { useMasterKey: true });
 }
+async function updateCalendarEvent(schedule) {
+    const event = await (0, scheduleToEvent_1.scheduleToEvent)(schedule);
+    if (!event)
+        return;
+    const calendarManager = new CalendarManager_1.CalendarManager();
+    const meta = schedule.get("meta") || {};
+    const calendarEventId = meta.calendarEventId;
+    if (calendarEventId) {
+        console.log("Updating schedule in calendar...");
+        await calendarManager.updateEvent(calendarEventId, event);
+    }
+    else {
+        await addToCalendar(schedule);
+    }
+}
+/**
+ * Add schedule as event to calendar when first created
+ * @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 createdEvent = await calendarManager.createEvent(event);
+    if (createdEvent && createdEvent.id) {
+        const existingMeta = schedule.get("meta") || {};
+        schedule.set("meta", {
+            ...existingMeta,
+            calendarEventId: createdEvent.id,
+        });
+        await schedule.save(null, { useMasterKey: true });
+    }
+}

package/dist/types/Maintenance_Schedule.d.ts

@@ -1,33 +1,31 @@
-import type { Contact } from "./Contact";
 import type { Maintenance_Schedule_Execution } from "./Maintenance_Schedule_Execution";
-import type { Source } from "./Source";
 import type { Maintenance_Schedule_Step } from "./Maintenance_Schedule_Step";
 import type { Maintenance_Schedule_Template } from "./Maintenance_Schedule_Template";
+import type { Source } from "./Source";
 import type { Tenant } from "./Tenant";
 export interface Maintenance_ScheduleAttributes {
     id: string;
     objectId: string;
     createdAt: Date;
     updatedAt: Date;
-    color?: string | undefined;
-    contacts: Parse.Relation<Maintenance_Schedule, Contact>;
-    cron?: any | undefined;
-    description?: string | undefined;
+    color?: string;
+    cron?: any;
+    description?: string;
     enabled: boolean;
-    lastExecution?: Maintenance_Schedule_Execution | undefined;
-    notifyBeforeDue?: any | undefined;
+    lastExecution?: Maintenance_Schedule_Execution;
+    meta?: any;
+    notifyBeforeDue?: any;
     source: Source;
     steps: Parse.Relation<Maintenance_Schedule, Maintenance_Schedule_Step>;
-    template?: Maintenance_Schedule_Template | undefined;
-    tenant?: Tenant | undefined;
-    title?: string | undefined;
+    template?: Maintenance_Schedule_Template;
+    tenant?: Tenant;
+    title?: string;
 }
 export declare class Maintenance_Schedule extends Parse.Object<Maintenance_ScheduleAttributes> {
     static className: string;
     constructor(data?: Partial<Maintenance_ScheduleAttributes>);
     get color(): string | undefined;
     set color(value: string | undefined);
-    get contacts(): Parse.Relation<Maintenance_Schedule, Contact>;
     get cron(): any | undefined;
     set cron(value: any | undefined);
     get description(): string | undefined;
@@ -36,6 +34,8 @@ export declare class Maintenance_Schedule extends Parse.Object<Maintenance_Sched
     set enabled(value: boolean);
     get lastExecution(): Maintenance_Schedule_Execution | undefined;
     set lastExecution(value: Maintenance_Schedule_Execution | undefined);
+    get meta(): any | undefined;
+    set meta(value: any | undefined);
     get notifyBeforeDue(): any | undefined;
     set notifyBeforeDue(value: any | undefined);
     get source(): Source;

package/dist/types/Maintenance_Schedule.js

@@ -11,9 +11,6 @@ class Maintenance_Schedule extends Parse.Object {
     set color(value) {
         super.set("color", value);
     }
-    get contacts() {
-        return super.relation("contacts");
-    }
     get cron() {
         return super.get("cron");
     }
@@ -38,6 +35,12 @@ class Maintenance_Schedule extends Parse.Object {
     set lastExecution(value) {
         super.set("lastExecution", value);
     }
+    get meta() {
+        return super.get("meta");
+    }
+    set meta(value) {
+        super.set("meta", value);
+    }
     get notifyBeforeDue() {
         return super.get("notifyBeforeDue");
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openinc/parse-server-opendash",
-  "version": "3.24.6",
+  "version": "3.25.0",
   "description": "Parse Server Cloud Code for open.INC Stack.",
   "packageManager": "pnpm@10.19.0",
   "keywords": [

package/schema/Maintenance_Schedule.json

@@ -22,6 +22,10 @@
       "targetClass": "{{PREFIX}}Maintenance_Schedule_Execution",
       "required": false
     },
+    "meta": {
+      "type": "Object",
+      "required": false
+    },
     "notifyBeforeDue": {
       "type": "Object",
       "required": false