@openinc/parse-server-opendash 4.1.8 → 4.2.1

package/dist/features/openservice/init.js

@@ -5,6 +5,8 @@ const initIssuecategory_js_1 = require("./issuecategory/initIssuecategory.js");
 const initKanbanStates_js_1 = require("./kanbanState/initKanbanStates.js");
 const initMessages_js_1 = require("./messages/initMessages.js");
 const initSchedulesFeature_js_1 = require("./schedules/initSchedulesFeature.js");
+const initServiceSchedulesFeature_js_1 = require("./serviceSchedules/initServiceSchedulesFeature.js");
+const index_js_1 = require("./serviceTickets/alarmActions/index.js");
 const checkStatus_js_1 = require("./schedules/mappings/checkStatus.js");
 const reassignScheduleExecutions_js_1 = require("./schedules/mappings/reassignScheduleExecutions.js");
 const initTicket_js_1 = require("./ticket/initTicket.js");
@@ -20,5 +22,7 @@ async function init() {
     await (0, reassignScheduleExecutions_js_1.reassignScheduleExecutions)();
     await (0, checkStatus_js_1.checkStatus)();
     await (0, initSchedulesFeature_js_1.initSchedulesFeature)();
+    await (0, initServiceSchedulesFeature_js_1.initServiceSchedulesFeature)();
+    await (0, index_js_1.ensureAlarmTicketAction)();
     console.log("open.SERVICE feature initialized.");
 }

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

@@ -35,6 +35,8 @@ export type RecurrencePattern = {
     daysOfWeek?: Array<"Sunday" | "Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday" | "Saturday">;
     firstDayOfWeek?: "Sunday" | "Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday" | "Saturday";
     month?: number;
+    /** Day of the month for `absoluteMonthly` / `absoluteYearly` patterns. */
+    dayOfMonth?: number;
     index?: "first" | "second" | "third" | "fourth" | "last";
 };
 export type RecurrenceRange = {

package/dist/features/openservice/serviceSchedules/acl/assignmentAcl.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Marks a save this module made itself, so the `afterSave` that follows it does
+ * not start over. Without it every ACL write would trigger another pass — the
+ * second one is a no-op and would stop, but the round trip is pure waste.
+ */
+export declare const ASSIGNMENT_ACL_CONTEXT_FLAG = "fromAssignmentAcl";
+/** Which relations grant read access on this class. */
+export interface AssignmentAclOptions {
+    /** Relation of `_Role`s that may read the record. */
+    roleRelations: string[];
+    /** Relation of `_User`s that may read the record. */
+    userRelations?: string[];
+}
+/**
+ * Who may see a maintenance plan (or a template): its creator, the roles and
+ * users assigned to it, and the administrators — nobody else.
+ *
+ * **Why this is rebuilt rather than amended.** Un-assigning somebody has to take
+ * their access away again, and an ACL carries no record of *why* a grant is
+ * there. Adding grants on every save would therefore be a one-way door: a role
+ * removed from the plan would keep reading it forever. The ACL is derived from
+ * the assignments instead, so it always says exactly what the assignments say.
+ *
+ * `od-admin` and `od-tenant-admin-<tenant>` are re-added by `defaultAclHandler`
+ * on the save that follows, so an assignment can never lock administrators out.
+ *
+ * Runs in `afterSave`, not `beforeSave`: relations are only queryable once the
+ * pending add/remove operations have been applied, which happens on save.
+ */
+export declare function syncAssignmentAcl(object: Parse.Object, options: AssignmentAclOptions): Promise<void>;

package/dist/features/openservice/serviceSchedules/acl/assignmentAcl.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ASSIGNMENT_ACL_CONTEXT_FLAG = void 0;
+exports.syncAssignmentAcl = syncAssignmentAcl;
+const node_1 = __importDefault(require("parse/node"));
+/**
+ * Marks a save this module made itself, so the `afterSave` that follows it does
+ * not start over. Without it every ACL write would trigger another pass — the
+ * second one is a no-op and would stop, but the round trip is pure waste.
+ */
+exports.ASSIGNMENT_ACL_CONTEXT_FLAG = "fromAssignmentAcl";
+/**
+ * Who may see a maintenance plan (or a template): its creator, the roles and
+ * users assigned to it, and the administrators — nobody else.
+ *
+ * **Why this is rebuilt rather than amended.** Un-assigning somebody has to take
+ * their access away again, and an ACL carries no record of *why* a grant is
+ * there. Adding grants on every save would therefore be a one-way door: a role
+ * removed from the plan would keep reading it forever. The ACL is derived from
+ * the assignments instead, so it always says exactly what the assignments say.
+ *
+ * `od-admin` and `od-tenant-admin-<tenant>` are re-added by `defaultAclHandler`
+ * on the save that follows, so an assignment can never lock administrators out.
+ *
+ * Runs in `afterSave`, not `beforeSave`: relations are only queryable once the
+ * pending add/remove operations have been applied, which happens on save.
+ */
+async function syncAssignmentAcl(object, options) {
+    const acl = new node_1.default.ACL();
+    // Administrators. Mirrors `defaultAclHandler` so the ACL is already complete
+    // when it is written, rather than only after the next save.
+    acl.setRoleReadAccess("od-admin", true);
+    acl.setRoleWriteAccess("od-admin", true);
+    const tenant = object.get("tenant");
+    if (tenant) {
+        acl.setRoleReadAccess(`od-tenant-admin-${tenant.id}`, true);
+        acl.setRoleWriteAccess(`od-tenant-admin-${tenant.id}`, true);
+    }
+    // The creator keeps write — the record is theirs.
+    const creator = object.get("user");
+    if (creator?.id) {
+        acl.setReadAccess(creator.id, true);
+        acl.setWriteAccess(creator.id, true);
+    }
+    for (const relation of options.roleRelations) {
+        for (const role of await readRelation(object, relation)) {
+            const name = role.get("name");
+            // Roles are addressed by name in an ACL, not by id.
+            if (name)
+                acl.setRoleReadAccess(name, true);
+        }
+    }
+    for (const relation of options.userRelations ?? []) {
+        for (const user of await readRelation(object, relation)) {
+            if (user.id)
+                acl.setReadAccess(user.id, true);
+        }
+    }
+    if (sameAcl(object.getACL(), acl))
+        return;
+    object.setACL(acl);
+    await object.save(null, {
+        useMasterKey: true,
+        context: { [exports.ASSIGNMENT_ACL_CONTEXT_FLAG]: true },
+    });
+}
+/** The members of a relation, or an empty list when it has none. */
+async function readRelation(object, field) {
+    try {
+        return await object.relation(field).query().find({ useMasterKey: true });
+    }
+    catch {
+        // A relation that was never written has no backing table yet.
+        return [];
+    }
+}
+/** Whether two ACLs grant exactly the same thing. */
+function sameAcl(current, next) {
+    if (!current)
+        return false;
+    return JSON.stringify(current.toJSON()) === JSON.stringify(next.toJSON());
+}

package/dist/features/openservice/serviceSchedules/acl/index.d.ts

@@ -0,0 +1 @@
+export { ASSIGNMENT_ACL_CONTEXT_FLAG, syncAssignmentAcl, type AssignmentAclOptions, } from "./assignmentAcl.js";

package/dist/features/openservice/serviceSchedules/acl/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncAssignmentAcl = exports.ASSIGNMENT_ACL_CONTEXT_FLAG = void 0;
+var assignmentAcl_js_1 = require("./assignmentAcl.js");
+Object.defineProperty(exports, "ASSIGNMENT_ACL_CONTEXT_FLAG", { enumerable: true, get: function () { return assignmentAcl_js_1.ASSIGNMENT_ACL_CONTEXT_FLAG; } });
+Object.defineProperty(exports, "syncAssignmentAcl", { enumerable: true, get: function () { return assignmentAcl_js_1.syncAssignmentAcl; } });

package/dist/features/openservice/serviceSchedules/calendarSync/functions/eventToPlan.d.ts

@@ -0,0 +1,50 @@
+import type { GraphEventResponse } from "../../../schedules/calendarSync/types/Event.js";
+import type { ServiceCadence, ServiceNotificationRule } from "../types/ServiceSyncTypes.js";
+/**
+ * The rule id the sync owns.
+ *
+ * An Outlook reminder becomes one notification rule on the plan, and it always
+ * gets **this** id: the sync may replace or remove its own rule on every
+ * inbound change, and must never touch the rules a user wrote in the plan
+ * editor. A stable id also keeps the scheduler's dedup key
+ * (`{scheduleId, ruleId, occurrence}`) stable, so re-syncing an unchanged event
+ * does not notify twice.
+ */
+export declare const OUTLOOK_REMINDER_RULE_ID = "outlook-reminder";
+/** What an Outlook event says about a maintenance plan. */
+export type PlanFieldsFromEvent = {
+    /** Plan title — the subject, minus the machine prefix if there was one. */
+    title: string;
+    /** Machine name from the subject convention, if the subject used it. */
+    equipmentName?: string;
+    cadence: ServiceCadence;
+    /** The event's note, kept as the description of the plan's first step. */
+    description?: string;
+    /** The event's reminder, as the sync's own notification rule. */
+    notification?: ServiceNotificationRule;
+};
+/**
+ * Read a calendar event as maintenance plan fields.
+ *
+ * Pure — resolving the machine and writing the plan is the poller's job.
+ * Returns `undefined` for an event without a usable start, which is the one
+ * thing a plan cannot do without.
+ */
+export declare function eventToPlanFields(event: GraphEventResponse): PlanFieldsFromEvent | undefined;
+/**
+ * Split `"Flex 1" - Ölwechsel` into machine and title.
+ *
+ * Same convention as v1 (separator `" - "`, quotes optional), where the prefix
+ * named a `Maintenance_Source`; in v2 it names the machine. Unlike v1 the
+ * prefix is *removed* from the title — the machine is a field of its own here,
+ * and repeating it in the title is what made v1's plan lists unreadable.
+ */
+export declare function parseSubject(subject: string | undefined): {
+    equipmentName?: string;
+    title: string;
+};
+/**
+ * Put the sync's rule into a plan's rule list, replacing an older one of its
+ * own and leaving every user-written rule untouched.
+ */
+export declare function mergeReminderRule(existing: ServiceNotificationRule[] | undefined, rule: ServiceNotificationRule | undefined): ServiceNotificationRule[];

package/dist/features/openservice/serviceSchedules/calendarSync/functions/eventToPlan.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OUTLOOK_REMINDER_RULE_ID = void 0;
+exports.eventToPlanFields = eventToPlanFields;
+exports.parseSubject = parseSubject;
+exports.mergeReminderRule = mergeReminderRule;
+const outlookRecurrence_js_1 = require("./outlookRecurrence.js");
+/**
+ * The rule id the sync owns.
+ *
+ * An Outlook reminder becomes one notification rule on the plan, and it always
+ * gets **this** id: the sync may replace or remove its own rule on every
+ * inbound change, and must never touch the rules a user wrote in the plan
+ * editor. A stable id also keeps the scheduler's dedup key
+ * (`{scheduleId, ruleId, occurrence}`) stable, so re-syncing an unchanged event
+ * does not notify twice.
+ */
+exports.OUTLOOK_REMINDER_RULE_ID = "outlook-reminder";
+/**
+ * Read a calendar event as maintenance plan fields.
+ *
+ * Pure — resolving the machine and writing the plan is the poller's job.
+ * Returns `undefined` for an event without a usable start, which is the one
+ * thing a plan cannot do without.
+ */
+function eventToPlanFields(event) {
+    const start = eventStart(event);
+    if (!start)
+        return undefined;
+    const { equipmentName, title } = parseSubject(event.subject);
+    return {
+        title: title || "Outlook",
+        equipmentName,
+        cadence: (0, outlookRecurrence_js_1.eventToCadence)(start, event.recurrence ?? undefined),
+        description: event.bodyPreview?.trim() || undefined,
+        notification: reminderToRule(event),
+    };
+}
+/**
+ * The start of the series as an absolute instant.
+ *
+ * Graph returns `dateTime` in the time zone named next to it, and this server
+ * asks for none — so in practice it is UTC and the time of day survives, which
+ * matters because the plan's `dtstart` is what the frontend shows. If the event
+ * ever arrives in another zone, the day is kept and the time falls back to
+ * midnight rather than being shifted by a guess.
+ */
+function eventStart(event) {
+    const raw = event.start?.dateTime;
+    if (!raw)
+        return undefined;
+    const zone = event.start?.timeZone;
+    if (!zone || /^utc$/i.test(zone)) {
+        // Graph omits the offset; the trailing fraction can be 7 digits long.
+        const normalized = raw.endsWith("Z") ? raw : `${raw.slice(0, 23)}Z`;
+        const parsed = new Date(normalized);
+        if (!Number.isNaN(parsed.getTime()))
+            return parsed;
+    }
+    const dateOnly = new Date(`${raw.slice(0, 10)}T00:00:00.000Z`);
+    return Number.isNaN(dateOnly.getTime()) ? undefined : dateOnly;
+}
+/**
+ * Split `"Flex 1" - Ölwechsel` into machine and title.
+ *
+ * Same convention as v1 (separator `" - "`, quotes optional), where the prefix
+ * named a `Maintenance_Source`; in v2 it names the machine. Unlike v1 the
+ * prefix is *removed* from the title — the machine is a field of its own here,
+ * and repeating it in the title is what made v1's plan lists unreadable.
+ */
+function parseSubject(subject) {
+    const value = (subject ?? "").trim();
+    const separator = value.indexOf(" - ");
+    if (separator === -1)
+        return { title: value };
+    const prefix = value
+        .slice(0, separator)
+        .trim()
+        .replace(/^"(.*)"$/, "$1")
+        .trim();
+    const rest = value.slice(separator + 3).trim();
+    if (!prefix || !rest)
+        return { title: value };
+    return { equipmentName: prefix, title: rest };
+}
+/**
+ * An Outlook reminder as a notification rule.
+ *
+ * Outlook counts minutes, a plan counts days — a maintenance date is a day, not
+ * a minute. Anything under a day therefore becomes "on the due date" instead of
+ * being rounded up to a day early.
+ */
+function reminderToRule(event) {
+    if (!event.isReminderOn)
+        return undefined;
+    const minutes = event.reminderMinutesBeforeStart;
+    if (typeof minutes !== "number" || minutes < 0)
+        return undefined;
+    const offsetDays = Math.floor(minutes / (60 * 24));
+    return {
+        id: exports.OUTLOOK_REMINDER_RULE_ID,
+        trigger: offsetDays > 0 ? "before" : "due",
+        ...(offsetDays > 0 ? { offsetDays } : {}),
+        assignedRoles: true,
+        serviceProviders: true,
+    };
+}
+/**
+ * Put the sync's rule into a plan's rule list, replacing an older one of its
+ * own and leaving every user-written rule untouched.
+ */
+function mergeReminderRule(existing, rule) {
+    const others = (existing ?? []).filter((entry) => entry.id !== exports.OUTLOOK_REMINDER_RULE_ID);
+    return rule ? [...others, rule] : others;
+}

package/dist/features/openservice/serviceSchedules/calendarSync/functions/outlookRecurrence.d.ts

@@ -0,0 +1,59 @@
+import type { Recurrence } from "../../../schedules/calendarSync/types/Event.js";
+import type { ServiceCadence } from "../types/ServiceSyncTypes.js";
+/** A recurrence rule taken apart into its parts. */
+export type RRuleParts = {
+    freq?: "DAILY" | "WEEKLY" | "MONTHLY" | "YEARLY";
+    interval?: number;
+    byday?: string[];
+    bymonthday?: number[];
+    bymonth?: number[];
+    count?: number;
+    wkst?: string;
+    /**
+     * "The nth of the matching days" — `BYDAY=MO,TU,WE,TH,FR;BYSETPOS=-1` is
+     * "last workday of the month".
+     *
+     * Outlook has no equivalent: its `relativeMonthly` pattern takes *one*
+     * weekday and a position. With a single weekday the two agree (that is the
+     * ordinal `BYDAY` form); with several, the rule cannot be expressed — see
+     * {@link calendarUnsupportedReason}.
+     */
+    bysetpos?: number;
+};
+/**
+ * Read an RRULE string into its parts.
+ *
+ * Tolerant on purpose: an unknown key is dropped rather than throwing, because
+ * a rule that came from Outlook, from the editor, or from a hand-written import
+ * all end up here, and a single unexpected part must not stop a sync.
+ */
+export declare function parseRRule(rrule: string | undefined): RRuleParts;
+/** Write the parts back into an RRULE string, in the canonical part order. */
+export declare function buildRRule(parts: RRuleParts): string;
+/**
+ * An Outlook event's timing, as a v2 cadence.
+ *
+ * A non-recurring event becomes a one-off — the same shape the frontend's
+ * `oneOffCadence()` produces (`FREQ=DAILY;INTERVAL=1;COUNT=1`), so a plan
+ * created from a single Outlook appointment is indistinguishable from one
+ * created by hand.
+ */
+export declare function eventToCadence(start: Date, recurrence?: Recurrence): ServiceCadence;
+/**
+ * Why this cadence cannot be written to a calendar — `undefined` when it can.
+ *
+ * Outlook's recurrence vocabulary is a **subset** of RFC 5545, and the gap is
+ * not cosmetic: a rule we cannot express would have to be approximated, and an
+ * approximated maintenance date in someone's calendar is worse than no entry
+ * at all. The sync therefore leaves such plans alone instead of guessing (see
+ * `syncPlanToCalendar`).
+ */
+export declare function calendarUnsupportedReason(cadence: ServiceCadence | undefined): string | undefined;
+/**
+ * A v2 cadence as an Outlook recurrence — `undefined` for a one-off, which
+ * Graph expects as an event without a `recurrence` at all.
+ *
+ * `startDate` of the range is always the series start: Graph rejects a
+ * recurrence whose range starts on a different day than the event.
+ */
+export declare function cadenceToRecurrence(cadence: ServiceCadence | undefined, start: Date): Recurrence | undefined;