@openinc/parse-server-opendash 4.1.7 → 4.2.0

package/dist/features/openservice/serviceTickets/alarmActions/service/ensureAlarmTicketAction.js

@@ -0,0 +1,127 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureAlarmTicketAction = ensureAlarmTicketAction;
+const node_1 = __importDefault(require("parse/node"));
+const index_js_1 = require("../../../../../types/index.js");
+const AlarmTicketTypes_js_1 = require("../types/AlarmTicketTypes.js");
+/**
+ * Make "create a ticket" selectable in the alarm dialog.
+ *
+ * Alarm actions are **data**, not code: `OD3_AlarmAction` rows that the
+ * monitoring adapter loads into the frontend, where the chosen row's
+ * `formFields` are rendered as the action's settings form (see
+ * `plugins/monitoring/src/components/AlarmCreate.tsx`). There is no plugin-side
+ * `registerAlarmAction`, so the row is seeded here — find-or-create by `topic`,
+ * like the other open.SERVICE bootstraps.
+ *
+ * The row is **global** (no tenant): the action makes sense for every tenant,
+ * and the tenant of a fired alarm is established by its secret, not by this
+ * row.
+ *
+ * ⚠️ `type` / `target` / `payload` are the executor's half of the contract —
+ * the component that evaluates alarms lives outside this server. The values
+ * below assume a webhook-style executor that POSTs `payload` (placeholders
+ * filled from the alarm) to `target`. If the executor expects something else,
+ * this row is where it is corrected; the receiving endpoint accepts any caller
+ * that brings the secret.
+ */
+async function ensureAlarmTicketAction() {
+    const existing = await new node_1.default.Query(index_js_1.AlarmAction)
+        .equalTo("topic", AlarmTicketTypes_js_1.ALARM_TICKET_ACTION_ID)
+        .first({ useMasterKey: true });
+    if (existing)
+        return;
+    const action = new index_js_1.AlarmAction();
+    action.set("label", "Ticket erstellen (open.SERVICE)");
+    action.set("type", "webhook");
+    action.set("topic", AlarmTicketTypes_js_1.ALARM_TICKET_ACTION_ID);
+    action.set("target", "/parse/functions/openinc-openservice-alarm-create-ticket");
+    action.set("templateType", "json");
+    action.set("payload", JSON.stringify({
+        secret: "{{secret}}",
+        event: {
+            alarmId: "{{alarm.id}}",
+            name: "{{alarm.name}}",
+            item_id: "{{item.id}}",
+            item_source: "{{item.source}}",
+            item_dimension: "{{item.dimension}}",
+            value: "{{value}}",
+            condition: "{{condition}}",
+            firedAt: "{{timestamp}}",
+        },
+        params: "{{action}}",
+    }));
+    // Every value type can breach a rule, so every type may raise a ticket.
+    action.set("supportedTypes", [
+        "Number",
+        "String",
+        "Boolean",
+        "Geo",
+        "Object",
+    ]);
+    action.set("formFields", FORM_FIELDS);
+    await action.save(null, { useMasterKey: true });
+    console.log(`[AlarmTicket] Registered alarm action "${AlarmTicketTypes_js_1.ALARM_TICKET_ACTION_ID}"`);
+}
+/**
+ * What the person configuring an alarm gets to fill in.
+ *
+ * Field types are the ones `FormGenerator` (in `@opendash/core`) understands;
+ * `select.parse` renders an object picker for a Parse class. Keys match
+ * `AlarmTicketParams` — the executor hands the form's values back to us as
+ * `params`.
+ *
+ * The machine is a plain picker rather than something derived from the sensor,
+ * because nothing in the data model links the two. Whoever sets the alarm up
+ * knows which machine it watches; guessing it later is worse than asking now.
+ */
+const FORM_FIELDS = [
+    {
+        key: "title",
+        label: "Titel des Tickets",
+        type: "input",
+        hint: "Platzhalter: {{alarm}}, {{sensor}}, {{value}}. Leer = Name des Alarms.",
+    },
+    {
+        key: "description",
+        label: "Notiz",
+        type: "textarea",
+        hint: "Wird dem Ticket vorangestellt; Sensor, Wert, Regel und Zeitpunkt kommen automatisch dazu.",
+    },
+    {
+        key: "equipmentId",
+        label: "Maschine",
+        type: "select.parse",
+        settings: {
+            className: "OD3_Service_Equipment",
+            displayField: "label",
+            mode: "single",
+        },
+        hint: "Ohne Angabe wird über die Quellen-Tags der Maschine geraten — oder das Ticket bleibt ohne Maschine.",
+    },
+    {
+        key: "projectId",
+        label: "Projekt",
+        type: "select.parse",
+        settings: {
+            className: "OD3_Service_Project",
+            displayField: "label",
+            mode: "single",
+        },
+    },
+    {
+        key: "priority",
+        label: "Priorität",
+        type: "input.number",
+    },
+    {
+        key: "duplicate",
+        label: "Bei jedem Auslösen ein neues Ticket",
+        type: "switch",
+        defaultValue: false,
+        hint: "Aus (Standard): solange das Ticket offen ist, entsteht kein zweites.",
+    },
+];

package/dist/features/openservice/serviceTickets/alarmActions/types/AlarmTicketTypes.d.ts

@@ -0,0 +1,80 @@
+/**
+ * The alarm action "create a ticket".
+ *
+ * An open.DASH alarm watches a sensor value against a rule; when the rule
+ * breaks, its configured **action** runs. The actions are rows in
+ * `OD3_AlarmAction` (loaded into the frontend by the monitoring adapter), and
+ * the executor — the component that evaluates alarms, outside this server —
+ * carries them out. This module is the receiving end: it turns one fired alarm
+ * into an `OD3_Service_Ticket`.
+ */
+/** Id of the action row, and the marker in a ticket's `origin`. */
+export declare const ALARM_TICKET_ACTION_ID = "openservice-create-ticket";
+/**
+ * Config key of the shared secret an executor authenticates with.
+ *
+ * One row per tenant: `key` = this, `value` = the secret, `tenant` = the
+ * tenant's pointer. The secret is what tells us **which tenant** a call belongs
+ * to — an alarm executor is not trusted to name it. Without a row, the endpoint
+ * only answers to the master key.
+ */
+export declare const ALARM_TICKET_SECRET_CONFIG_KEY = "OPENSERVICE_ALARM_TICKET_SECRET";
+/** Status category a fresh ticket lands in — mirrors the ticket plugin's port. */
+export declare const DEFAULT_STATUS_CATEGORY = "inbox";
+/** Categories in which a ticket counts as finished (mirrors core's `DONE_CATEGORIES`). */
+export declare const DONE_STATUS_CATEGORIES: string[];
+/**
+ * What the executor reports about the alarm that fired.
+ *
+ * Field names follow `OD3_Alarm` so a payload can be assembled from the alarm
+ * row without renaming: `item_id` / `item_source` / `item_dimension` identify
+ * the sensor, the rest is context for the ticket text. Everything is optional
+ * except that *something* must identify the alarm — see `alarmKey`.
+ */
+export interface AlarmEvent {
+    /** `OD3_Alarm.objectId`, if the executor knows it. */
+    alarmId?: string;
+    /** The alarm's name, used in the ticket title when no template is given. */
+    name?: string;
+    /** Sensor id, e.g. `cnc04.spindle`. */
+    item_id?: string;
+    /** Source (site/tenant hierarchy) the sensor belongs to. */
+    item_source?: string;
+    /** Which dimension of the sensor tripped. */
+    item_dimension?: number;
+    /** The value that broke the rule. */
+    value?: number | string | boolean;
+    /** Human-readable rule, e.g. `> 80`. */
+    condition?: string;
+    /** When it fired (ISO). Defaults to now. */
+    firedAt?: string;
+}
+/**
+ * What the person configuring the alarm filled into the action's form
+ * (`OD3_AlarmAction.formFields`).
+ */
+export interface AlarmTicketParams {
+    /** Ticket title; `{{alarm}}`, `{{sensor}}` and `{{value}}` are replaced. */
+    title?: string;
+    /** Prepended to the generated alarm details. */
+    description?: string;
+    /**
+     * Machine the ticket belongs to.
+     *
+     * Set explicitly when configuring the alarm — that is the reliable way,
+     * because nothing in the data model links a sensor to a machine. Without it,
+     * `Equipment.sourceTags` is tried (see `resolveEquipment`).
+     */
+    equipmentId?: string;
+    projectId?: string;
+    priority?: number;
+    assignedUserIds?: string[];
+    assignedRoleIds?: string[];
+    tagIds?: string[];
+    /**
+     * Reopen behaviour. `false` (default) keeps **one open ticket per alarm**: a
+     * flapping sensor does not produce a hundred tickets, and closing the ticket
+     * arms the alarm again. `true` creates one per firing.
+     */
+    duplicate?: boolean;
+}

package/dist/features/openservice/serviceTickets/alarmActions/types/AlarmTicketTypes.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * The alarm action "create a ticket".
+ *
+ * An open.DASH alarm watches a sensor value against a rule; when the rule
+ * breaks, its configured **action** runs. The actions are rows in
+ * `OD3_AlarmAction` (loaded into the frontend by the monitoring adapter), and
+ * the executor — the component that evaluates alarms, outside this server —
+ * carries them out. This module is the receiving end: it turns one fired alarm
+ * into an `OD3_Service_Ticket`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DONE_STATUS_CATEGORIES = exports.DEFAULT_STATUS_CATEGORY = exports.ALARM_TICKET_SECRET_CONFIG_KEY = exports.ALARM_TICKET_ACTION_ID = void 0;
+/** Id of the action row, and the marker in a ticket's `origin`. */
+exports.ALARM_TICKET_ACTION_ID = "openservice-create-ticket";
+/**
+ * Config key of the shared secret an executor authenticates with.
+ *
+ * One row per tenant: `key` = this, `value` = the secret, `tenant` = the
+ * tenant's pointer. The secret is what tells us **which tenant** a call belongs
+ * to — an alarm executor is not trusted to name it. Without a row, the endpoint
+ * only answers to the master key.
+ */
+exports.ALARM_TICKET_SECRET_CONFIG_KEY = "OPENSERVICE_ALARM_TICKET_SECRET";
+/** Status category a fresh ticket lands in — mirrors the ticket plugin's port. */
+exports.DEFAULT_STATUS_CATEGORY = "inbox";
+/** Categories in which a ticket counts as finished (mirrors core's `DONE_CATEGORIES`). */
+exports.DONE_STATUS_CATEGORIES = ["done", "cancelled"];

package/dist/functions/openinc-openservice-alarm-create-ticket.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Raise an open.SERVICE ticket for a fired alarm.
+ *
+ * The receiving end of the `openservice-create-ticket` alarm action: an alarm
+ * watches a sensor, the rule breaks, and whatever executes alarm actions calls
+ * this with the alarm's data and the settings someone filled into the action's
+ * form.
+ *
+ * **Authentication** — one of:
+ *
+ * - the **master key** (server-to-server inside the stack), then `tenantId`
+ *   must be given;
+ * - a **shared secret** matching an `OPENSERVICE_ALARM_TICKET_SECRET` config
+ *   row, which also establishes the tenant. An external executor is not
+ *   trusted to name a tenant, so the secret does it.
+ *
+ * A logged-in user is deliberately *not* enough: this is a machine endpoint,
+ * and a browser session should not be able to fabricate alarm tickets.
+ *
+ * Params: `{ event, params?, secret?, tenantId? }`.
+ * Returns `{ ticketId, created, origin, equipmentId? }` — `created: false`
+ * means an open ticket for this alarm already existed (see
+ * `createAlarmTicket`).
+ */
+export declare function init(name: string): Promise<void>;

package/dist/functions/openinc-openservice-alarm-create-ticket.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = init;
+const node_1 = __importDefault(require("parse/node"));
+const index_js_1 = require("../features/openservice/serviceTickets/alarmActions/index.js");
+const index_js_2 = require("../types/index.js");
+/**
+ * Raise an open.SERVICE ticket for a fired alarm.
+ *
+ * The receiving end of the `openservice-create-ticket` alarm action: an alarm
+ * watches a sensor, the rule breaks, and whatever executes alarm actions calls
+ * this with the alarm's data and the settings someone filled into the action's
+ * form.
+ *
+ * **Authentication** — one of:
+ *
+ * - the **master key** (server-to-server inside the stack), then `tenantId`
+ *   must be given;
+ * - a **shared secret** matching an `OPENSERVICE_ALARM_TICKET_SECRET` config
+ *   row, which also establishes the tenant. An external executor is not
+ *   trusted to name a tenant, so the secret does it.
+ *
+ * A logged-in user is deliberately *not* enough: this is a machine endpoint,
+ * and a browser session should not be able to fabricate alarm tickets.
+ *
+ * Params: `{ event, params?, secret?, tenantId? }`.
+ * Returns `{ ticketId, created, origin, equipmentId? }` — `created: false`
+ * means an open ticket for this alarm already existed (see
+ * `createAlarmTicket`).
+ */
+async function init(name) {
+    node_1.default.Cloud.define(name, async (request) => {
+        const { event, params, secret, tenantId } = request.params;
+        if (!event || typeof event !== "object") {
+            throw new node_1.default.Error(node_1.default.Error.INVALID_QUERY, `${name} needs an "event" object describing the alarm`);
+        }
+        const tenant = request.master
+            ? await tenantById(tenantId)
+            : await (0, index_js_1.tenantForSecret)(typeof secret === "string" ? secret : "");
+        if (!tenant) {
+            // Same answer for "wrong secret" and "no such tenant": a caller
+            // guessing secrets learns nothing from the difference.
+            throw new node_1.default.Error(node_1.default.Error.OPERATION_FORBIDDEN, `${name}: unknown tenant or invalid secret`);
+        }
+        const result = await (0, index_js_1.createAlarmTicket)(tenant, event, params ?? {});
+        console.log(`[${name}] ${result.created ? "created" : "reused"} ticket ` +
+            `${result.ticketId} for ${result.origin}` +
+            (result.equipmentId ? ` (machine ${result.equipmentId})` : ""));
+        return result;
+    }, 
+    // No `requireUser`: the callers are machines, authenticated above.
+    {});
+}
+async function tenantById(tenantId) {
+    if (!tenantId)
+        return undefined;
+    return ((await new node_1.default.Query(index_js_2.Tenant)
+        .equalTo("objectId", tenantId)
+        .first({ useMasterKey: true })) ?? undefined);
+}

package/dist/functions/openinc-openservice-notify-contacts.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Mail the external contacts of a maintenance notification rule.
+ *
+ * **Why this lives here.** The scheduler evaluates the plans' notification
+ * rules (`OD3_Service_Schedule.notifications`), but it has no mail transport —
+ * that belongs to this server, which owns `Core_Email` and the SMTP config.
+ * Users are reached through `OD3_Notification` (the hook there sends mail and
+ * web push); contacts have no account, so they are reached directly.
+ *
+ * **Master key only.** A browser session must not be able to mail arbitrary
+ * contacts with arbitrary text.
+ *
+ * Params: `contactIds`, `subject`, `body`, plus `scheduleId` / `ruleId` /
+ * `occurrence` for the log line. Returns `{ sent, skipped, withoutEmail }`.
+ */
+export declare function init(name: string): Promise<void>;

package/dist/functions/openinc-openservice-notify-contacts.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = init;
+const node_1 = __importDefault(require("parse/node"));
+const index_js_1 = require("../features/notifications/index.js");
+const index_js_2 = require("../types/index.js");
+/** How far back a duplicate is looked for (see `alreadySent`). */
+const DEDUP_WINDOW_DAYS = 30;
+/**
+ * Mail the external contacts of a maintenance notification rule.
+ *
+ * **Why this lives here.** The scheduler evaluates the plans' notification
+ * rules (`OD3_Service_Schedule.notifications`), but it has no mail transport —
+ * that belongs to this server, which owns `Core_Email` and the SMTP config.
+ * Users are reached through `OD3_Notification` (the hook there sends mail and
+ * web push); contacts have no account, so they are reached directly.
+ *
+ * **Master key only.** A browser session must not be able to mail arbitrary
+ * contacts with arbitrary text.
+ *
+ * Params: `contactIds`, `subject`, `body`, plus `scheduleId` / `ruleId` /
+ * `occurrence` for the log line. Returns `{ sent, skipped, withoutEmail }`.
+ */
+async function init(name) {
+    node_1.default.Cloud.define(name, async (request) => {
+        if (!request.master) {
+            throw new node_1.default.Error(node_1.default.Error.OPERATION_FORBIDDEN, `${name} requires the master key`);
+        }
+        const { contactIds, subject, body, scheduleId, ruleId, occurrence } = request.params;
+        if (!contactIds?.length || !subject || !body) {
+            throw new node_1.default.Error(node_1.default.Error.INVALID_QUERY, `${name} needs contactIds, subject and body`);
+        }
+        const contacts = await new node_1.default.Query(index_js_2.Contact)
+            .containedIn("objectId", contactIds)
+            .find({ useMasterKey: true });
+        let sent = 0;
+        let skipped = 0;
+        let withoutEmail = 0;
+        for (const contact of contacts) {
+            const to = contact.get("email");
+            if (!to) {
+                withoutEmail++;
+                continue;
+            }
+            if (await alreadySent(to, body)) {
+                skipped++;
+                continue;
+            }
+            await (0, index_js_1.sendSimpleEmail)(to, subject, body);
+            sent++;
+        }
+        console.log(`[${name}] plan ${scheduleId} rule ${ruleId} occurrence ${occurrence}: ` +
+            `sent ${sent}, skipped ${skipped}, without email ${withoutEmail}`);
+        return { sent, skipped, withoutEmail };
+    }, 
+    // No `requireUser`: this is a machine-to-machine call from the scheduler.
+    {});
+}
+/**
+ * Whether this exact message already went to this address recently.
+ *
+ * The idempotency key is the **message body**, because it already identifies
+ * the occurrence (it carries plan, description and the due date) and because
+ * `Core_Email` has no free column to put a marker in. That makes a restart
+ * inside the same tick harmless, while a genuinely different occurrence — a
+ * different date in the text — still goes out.
+ */
+async function alreadySent(to, body) {
+    const since = new Date(Date.now() - DEDUP_WINDOW_DAYS * 24 * 3600 * 1000);
+    // Dot access into the `payload` Object column: Mongo resolves it, but the
+    // generated class type only knows top-level columns — hence the untyped
+    // query handle.
+    const query = new node_1.default.Query(index_js_2.Core_Email);
+    query.equalTo("payload.to", to);
+    query.equalTo("payload.text", body);
+    query.greaterThan("createdAt", since);
+    const existing = await query.first({ useMasterKey: true });
+    return !!existing;
+}

package/dist/functions/openinc-openservice-schedule-calendar-sync.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Push maintenance plans into the tenant's Outlook calendar, on request.
+ *
+ * Normally nobody needs this: saving a plan syncs it (the `Service_Schedule`
+ * afterSave hook). It exists for the plans that already existed when a tenant
+ * switched the calendar connection on — they have never been written to the
+ * calendar, and nothing about them is going to change just to trigger it.
+ *
+ * **Authorization is the plan's own ACL**: the plans are loaded with the
+ * caller's session token, so this can only sync what the caller may read. A
+ * plan they cannot see comes back as "not found", like everywhere else.
+ *
+ * Params: `scheduleIds`. Returns `{ synced, failed }`.
+ */
+export declare function init(name: string): Promise<void>;

package/dist/functions/openinc-openservice-schedule-calendar-sync.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = init;
+const node_1 = __importDefault(require("parse/node"));
+const index_js_1 = require("../features/openservice/serviceSchedules/calendarSync/index.js");
+const index_js_2 = require("../types/index.js");
+/** No more than this many plans per call — each one is a Graph round trip. */
+const MAX_PLANS = 50;
+/**
+ * Push maintenance plans into the tenant's Outlook calendar, on request.
+ *
+ * Normally nobody needs this: saving a plan syncs it (the `Service_Schedule`
+ * afterSave hook). It exists for the plans that already existed when a tenant
+ * switched the calendar connection on — they have never been written to the
+ * calendar, and nothing about them is going to change just to trigger it.
+ *
+ * **Authorization is the plan's own ACL**: the plans are loaded with the
+ * caller's session token, so this can only sync what the caller may read. A
+ * plan they cannot see comes back as "not found", like everywhere else.
+ *
+ * Params: `scheduleIds`. Returns `{ synced, failed }`.
+ */
+async function init(name) {
+    node_1.default.Cloud.define(name, async (request) => {
+        const { scheduleIds } = request.params;
+        if (!Array.isArray(scheduleIds) || scheduleIds.length === 0) {
+            throw new node_1.default.Error(node_1.default.Error.INVALID_QUERY, `${name} needs scheduleIds`);
+        }
+        if (scheduleIds.length > MAX_PLANS) {
+            throw new node_1.default.Error(node_1.default.Error.INVALID_QUERY, `${name} accepts at most ${MAX_PLANS} plans per call`);
+        }
+        const plans = await new node_1.default.Query(index_js_2.Service_Schedule)
+            .containedIn("objectId", scheduleIds)
+            .include("equipment")
+            .limit(MAX_PLANS)
+            .find({ sessionToken: request.user?.getSessionToken() ?? undefined });
+        let synced = 0;
+        const failed = [];
+        for (const plan of plans) {
+            try {
+                // Master key from here on: writing the calendar and the meta entry is
+                // the server's business, not something the caller needs rights for.
+                await (0, index_js_1.syncPlanToCalendar)(plan);
+                synced++;
+            }
+            catch (error) {
+                console.error(`[${name}] Plan ${plan.id} failed:`, error);
+                failed.push(plan.id);
+            }
+        }
+        return {
+            synced,
+            failed,
+            notFound: scheduleIds.filter((id) => !plans.some((plan) => plan.id === id)),
+        };
+    }, { requireUser: true });
+}

package/dist/hooks/Service_Schedule.js

@@ -1,10 +1,15 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.init = init;
+const node_1 = __importDefault(require("parse/node"));
 const index_js_1 = require("../features/schema/index.js");
-const index_js_2 = require("../types/index.js");
+const index_js_2 = require("../features/openservice/serviceSchedules/calendarSync/index.js");
+const index_js_3 = require("../types/index.js");
 async function init() {
-    (0, index_js_1.beforeSaveHook)(index_js_2.Service_Schedule, async (request) => {
+    (0, index_js_1.beforeSaveHook)(index_js_3.Service_Schedule, async (request) => {
         const { object, original, user } = request;
         await (0, index_js_1.defaultHandler)(request);
         // `allowCustomACL` keeps an ACL set by the client instead of resetting it on
@@ -17,8 +22,71 @@ async function init() {
         await (0, index_js_1.defaultAclHandler)(request, { allowCustomACL: true });
         // TODO
     });
-    (0, index_js_1.afterSaveHook)(index_js_2.Service_Schedule, async (request) => {
-        const { object, original, user } = request;
-        // TODO
+    (0, index_js_1.afterSaveHook)(index_js_3.Service_Schedule, async (request) => {
+        const { object, original, context } = request;
+        // A change that came *from* the calendar must not be written back to it:
+        // that would create a new version there, which the delta feed reports as a
+        // foreign change, which we would import again — an endless echo. The
+        // poller marks its own writes with this flag.
+        if (context?.[index_js_2.CALENDAR_SYNC_CONTEXT_FLAG])
+            return;
+        // Seed data belongs to a demo tenant, not in anybody's calendar.
+        if (object.get("seed"))
+            return;
+        if (!original || calendarRelevantChange(object, original)) {
+            // Deliberately not awaited: the calendar is a downstream system, and a
+            // Graph round trip (token + write) would otherwise be part of every save
+            // the user waits for. Failures are logged, and the next relevant save
+            // retries — as does the delta poller from the other side.
+            (0, index_js_2.syncPlanToCalendar)(object).catch((error) => {
+                console.error(`[ServiceCalendarSync] Plan ${object.id} could not be synced:`, error);
+            });
+        }
+    });
+    (0, index_js_1.beforeDeleteHook)(index_js_3.Service_Schedule, async (request) => {
+        const { object } = request;
+        // A protocol points at the plan it documents. Destroying the plan leaves
+        // that pointer dangling and the protocol — the record that the work
+        // happened — unreachable. Retiring a plan is done by setting `deletedAt`
+        // (archiving); the whole frontend already does that, including the admin
+        // table, which offers "archive" instead of "delete".
+        //
+        // A plan without any execution carries no history, so removing it stays
+        // allowed — that keeps mistakenly created plans cleanable.
+        const executions = await new node_1.default.Query(index_js_3.Service_Schedule_Execution)
+            .equalTo("schedule", object)
+            .count({ useMasterKey: true });
+        if (executions > 0) {
+            throw new node_1.default.Error(node_1.default.Error.OPERATION_FORBIDDEN, `Cannot delete maintenance schedule: ${executions} execution(s) document it. Set "deletedAt" to archive it instead.`);
+        }
     });
 }
+/**
+ * Whether a saved plan changed anything the calendar shows.
+ *
+ * Plans are saved for many reasons that mean nothing to Outlook (an execution
+ * counter, an ACL, a tag). Only these fields reach the appointment — and
+ * `active` / `deletedAt` because retiring a plan removes it from the calendar.
+ */
+function calendarRelevantChange(object, original) {
+    if (object.get("title") !== original.get("title") ||
+        object.get("active") !== original.get("active") ||
+        dateValue(object.get("deletedAt")) !== dateValue(original.get("deletedAt"))) {
+        return true;
+    }
+    const equipmentChanged = object.get("equipment")?.id !==
+        original.get("equipment")?.id;
+    if (equipmentChanged)
+        return true;
+    // JSON columns: compared by value, because a save always hands us new object
+    // identities even when nothing inside them moved.
+    return (!sameJson(object.get("cadence"), original.get("cadence")) ||
+        !sameJson(object.get("notifications"), original.get("notifications")) ||
+        !sameJson(object.get("steps"), original.get("steps")));
+}
+function dateValue(value) {
+    return value ? value.getTime() : undefined;
+}
+function sameJson(a, b) {
+    return JSON.stringify(a ?? null) === JSON.stringify(b ?? null);
+}

package/dist/types/Service_Schedule.d.ts

@@ -12,6 +12,7 @@ export interface Service_ScheduleAttributes {
     assignedRoles: Parse.Relation<Service_Schedule, _Role>;
     cadence: any;
     cadenceExceptions?: any[] | undefined;
+    color?: string | undefined;
     coversTasks: any[];
     deletedAt?: Date | undefined;
     equipment?: Service_Equipment | undefined;
@@ -19,6 +20,7 @@ export interface Service_ScheduleAttributes {
     escalationRoles: Parse.Relation<Service_Schedule, _Role>;
     graceDays?: number | undefined;
     leadDays?: number | undefined;
+    notifications?: any[] | undefined;
     pausedUntil?: Date | undefined;
     seed?: boolean | undefined;
     serviceProviders?: any[] | undefined;
@@ -38,6 +40,8 @@ export declare class Service_Schedule extends Parse.Object<Service_ScheduleAttri
     set cadence(value: any);
     get cadenceExceptions(): any[] | undefined;
     set cadenceExceptions(value: any[] | undefined);
+    get color(): string | undefined;
+    set color(value: string | undefined);
     get coversTasks(): any[];
     set coversTasks(value: any[]);
     get deletedAt(): Date | undefined;
@@ -51,6 +55,8 @@ export declare class Service_Schedule extends Parse.Object<Service_ScheduleAttri
     set graceDays(value: number | undefined);
     get leadDays(): number | undefined;
     set leadDays(value: number | undefined);
+    get notifications(): any[] | undefined;
+    set notifications(value: any[] | undefined);
     get pausedUntil(): Date | undefined;
     set pausedUntil(value: Date | undefined);
     get seed(): boolean | undefined;

package/dist/types/Service_Schedule.js

@@ -37,6 +37,12 @@ class Service_Schedule extends node_1.default.Object {
     set cadenceExceptions(value) {
         super.set("cadenceExceptions", value);
     }
+    get color() {
+        return super.get("color");
+    }
+    set color(value) {
+        super.set("color", value);
+    }
     get coversTasks() {
         return super.get("coversTasks");
     }
@@ -76,6 +82,12 @@ class Service_Schedule extends node_1.default.Object {
     set leadDays(value) {
         super.set("leadDays", value);
     }
+    get notifications() {
+        return super.get("notifications");
+    }
+    set notifications(value) {
+        super.set("notifications", value);
+    }
     get pausedUntil() {
         return super.get("pausedUntil");
     }