@openinc/parse-server-opendash 3.7.0 → 3.9.0

package/dist/features/openservice/messages/initMessages.js

@@ -0,0 +1,455 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanatizeMessagesDisplayAt = sanatizeMessagesDisplayAt;
+exports.initializeMessages = initializeMessages;
+const openinc_openservice_save_ticket_data_1 = require("../../../functions/openinc-openservice-save-ticket-data");
+const Maintenance_Ticket_Material_1 = require("../../../hooks/Maintenance_Ticket_Material");
+const types_1 = require("../../../types");
+const OpenserviceTranslationKeys_1 = require("../types/OpenserviceTranslationKeys");
+async function sanatizeMessagesDisplayAt() {
+    await new Parse.Query(types_1.Maintenance_Message).each(async (message) => {
+        if (!message.get("displayAt")) {
+            message.set("displayAt", message.get("createdAt"));
+            await message.save(null, { useMasterKey: true });
+        }
+    }, { useMasterKey: true });
+}
+/**
+ * Initializes the messages if there are no messages in the database
+ */
+async function initializeMessages() {
+    const count = await new Parse.Query(types_1.Maintenance_Message)
+        // we only handle system messages, not user messages
+        // @ts-ignore
+        .equalTo("data.type", "system")
+        .count({
+        useMasterKey: true,
+    });
+    if (count !== 0)
+        return;
+    console.log("Initializing maintenance messages");
+    await convertTicketDataToMessages();
+    await convertScheduleExecutionToMessage();
+    await sanatizeMessagesDisplayAt();
+    console.log("Initializing messages is finished");
+}
+async function convertTicketDataToMessages() {
+    // we get all ticket sources and convert them to messages
+    // important for the machinelog is, that all other ticket data should be converted to messages
+    // pointing to the source that was assigned to the ticket at that time
+    const ticketSources = await new Parse.Query(types_1.Maintenance_Ticket_Source)
+        .limit(1000000)
+        .includeAll()
+        .ascending("createdAt")
+        .find({ useMasterKey: true });
+    // we create the sources as messages and save them
+    // we also create a time frame for the sources in wich that source was assigned to the ticket
+    const timeMap = convertSourcesToTimeMap(ticketSources);
+    // we handle source different than the other data
+    // we need to create a message for the source that was assigned to the ticket and already fetched the sources here
+    await convertSourcesToMessages(ticketSources);
+    await ticketStateToMessage(timeMap);
+    await ticketIssuecategoryToMessage(timeMap);
+    await ticketPriorityToMessage(timeMap);
+    await ticketRestrictionToMessage(timeMap);
+    await ticketDowntimeToMessage(timeMap);
+    await ticketFrequencyToMessage(timeMap);
+    await ticketDuedateToMessage(timeMap);
+    await ticketTitleToMessage(timeMap);
+    await ticketMaterialToMessage(timeMap);
+    await ticketProjectToMessage(timeMap);
+}
+async function convertToMessage(config) {
+    const entries = await new Parse.Query(config.className)
+        .limit(1000000)
+        .includeAll()
+        .ascending("createdAt")
+        .find({ useMasterKey: true });
+    const messages = [];
+    for (const index in entries) {
+        const entry = entries[index];
+        const previous = entries[Number.parseInt(index) - 1];
+        // check if ticket entry is valid, might be corrupted
+        if (!config.isValueValid(entry) ||
+            !entry.get("ticket") ||
+            (previous && (!config.isValueValid(previous) || !previous.get("ticket"))))
+            continue;
+        const source = getSourceForTime(config.timeMap, entry.get("ticket").id, entry.get("createdAt"));
+        const message = new types_1.Maintenance_Message({
+            title: config.ticketTranslation.TITLE,
+            content: config.ticketTranslation.CONTENT,
+            referencedObjectId: entry.get("ticket").id,
+            classname: entry.get("ticket").className,
+            displayAt: entry.get("createdAt"),
+            data: {
+                type: "system",
+                origin: {
+                    id: entry.id,
+                    classname: entry.className,
+                },
+                translation: {
+                    username: (0, openinc_openservice_save_ticket_data_1.getUsername)(entry.get("user")),
+                    ticketName: entry.get("ticket").get("title"),
+                    ...config.getTranslationData(entry, previous),
+                },
+            },
+            user: entry.get("user"),
+            tenant: entry.get("tenant"),
+        });
+        messages.push(message);
+        if (source) {
+            const machinelogMessage = new types_1.Maintenance_Message({
+                title: config.machinelogTranslation.TITLE,
+                content: config.machinelogTranslation.CONTENT,
+                referencedObjectId: source.id,
+                classname: source.className,
+                displayAt: entry.get("createdAt"),
+                data: {
+                    type: "system",
+                    origin: {
+                        id: entry.get("ticket").id,
+                        classname: entry.get("ticket").className,
+                    },
+                    translation: {
+                        username: (0, openinc_openservice_save_ticket_data_1.getUsername)(entry.get("user")),
+                        ticketName: entry.get("ticket").get("title"),
+                        ...config.getTranslationData(entry),
+                    },
+                },
+                user: entry.get("user"),
+                tenant: entry.get("tenant"),
+            });
+            messages.push(machinelogMessage);
+        }
+    }
+    await types_1.Maintenance_Message.saveAll(messages, { useMasterKey: true });
+}
+/**
+ * Creates a time map from the given ticket sources wich maps the ticket id to the different sources and their createdAt dates
+ * @param ticketSources the ticket sources from wich the time map sould be created
+ * @returns a map with the ticket id as key and the different sources and their createdAt dates as value
+ */
+function convertSourcesToTimeMap(ticketSources) {
+    // we create a map with the ticket id as key and the different createdAt dates as value
+    const timeFrameMap = new Map();
+    for (const ticketSource of ticketSources) {
+        const ticketId = ticketSource.get("ticket").id;
+        if (!timeFrameMap.has(ticketId)) {
+            timeFrameMap.set(ticketId, [
+                {
+                    source: ticketSource.get("source"),
+                    date: ticketSource.get("createdAt"),
+                },
+            ]);
+        }
+        else {
+            timeFrameMap.get(ticketId).push({
+                source: ticketSource.get("source"),
+                date: ticketSource.get("createdAt"),
+            });
+        }
+    }
+    return timeFrameMap;
+}
+/**
+ * Returns the source that was assigned to the ticket with the given ID at the given time
+ * @param timeMap the time map that should be used
+ * @param ticketId id of the ticket
+ * @param time the date for which the source should be returned
+ * @returns the source that was assigned to the ticket at the given time
+ */
+function getSourceForTime(timeMap, ticketId, time) {
+    const ticketTimes = timeMap.get(ticketId);
+    if (!ticketTimes)
+        return null;
+    let currentSource = null;
+    // the sources are sorted by date, so we can just iterate over them and take the last one that is smaller than the given time
+    for (const ticketTime of ticketTimes) {
+        if (ticketTime.date <= time)
+            currentSource = ticketTime.source;
+        else
+            break; // we can break here because the sources are sorted by date
+    }
+    return currentSource;
+}
+async function convertSourcesToMessages(ticketSources) {
+    const messages = [];
+    for (const index in ticketSources) {
+        const ticketSource = ticketSources[index];
+        const previous = ticketSources[Number.parseInt(index) - 1];
+        // save ticket message
+        const ticketMessage = new types_1.Maintenance_Message({
+            title: OpenserviceTranslationKeys_1.OpenserviceMessageTranslationKeys.TICKETLOG.SOURCE.TITLE,
+            content: OpenserviceTranslationKeys_1.OpenserviceMessageTranslationKeys.TICKETLOG.SOURCE.CONTENT,
+            referencedObjectId: ticketSource.get("ticket").id,
+            classname: ticketSource.get("ticket").className,
+            displayAt: ticketSource.get("createdAt"),
+            data: {
+                type: "system",
+                origin: {
+                    id: ticketSource.id,
+                    classname: ticketSource.className,
+                },
+                translation: {
+                    old: previous?.get("source")?.get("name") ?? "Nicht vorhanden",
+                    new: ticketSource.get("source")?.get("name") ?? "Nicht vorhanden",
+                    username: (0, openinc_openservice_save_ticket_data_1.getUsername)(ticketSource.get("user")),
+                    ticketName: ticketSource.get("ticket").get("title"),
+                },
+            },
+            user: ticketSource.get("user"),
+            tenant: ticketSource.get("tenant"),
+        });
+        messages.push(ticketMessage);
+        // save machinelog message
+        const machinelogMessage = new types_1.Maintenance_Message({
+            title: OpenserviceTranslationKeys_1.OpenserviceMessageTranslationKeys.MACHINELOG.SOURCE.TITLE,
+            content: OpenserviceTranslationKeys_1.OpenserviceMessageTranslationKeys.MACHINELOG.SOURCE.CONTENT,
+            referencedObjectId: ticketSource.get("source").id,
+            classname: ticketSource.get("source").className,
+            displayAt: ticketSource.get("createdAt"),
+            data: {
+                type: "system",
+                origin: {
+                    id: ticketSource.get("ticket").id,
+                    classname: ticketSource.get("ticket").className,
+                },
+                translation: {
+                    old: previous?.get("source")?.get("name") ?? "Nicht vorhanden",
+                    new: ticketSource.get("source")?.get("name") ?? "Nicht vorhanden",
+                    username: (0, openinc_openservice_save_ticket_data_1.getUsername)(ticketSource.get("user")),
+                    ticketName: ticketSource.get("ticket").get("title"),
+                },
+            },
+            user: ticketSource.get("user"),
+            tenant: ticketSource.get("tenant"),
+        });
+        messages.push(machinelogMessage);
+        // save also a message for the source that was assigned to the ticket
+        if (previous) {
+            const previousSourceMessage = new types_1.Maintenance_Message({
+                title: OpenserviceTranslationKeys_1.OpenserviceMessageTranslationKeys.MACHINELOG.SOURCE.TITLE,
+                content: OpenserviceTranslationKeys_1.OpenserviceMessageTranslationKeys.MACHINELOG.SOURCE.CONTENT,
+                referencedObjectId: previous.get("source").id,
+                classname: previous.get("source").className,
+                displayAt: ticketSource.get("createdAt"),
+                data: {
+                    type: "system",
+                    origin: {
+                        id: ticketSource.get("ticket").id,
+                        classname: ticketSource.get("ticket").className,
+                    },
+                    translation: {
+                        old: previous.get("source").get("name") ?? "Nicht vorhanden",
+                        new: ticketSource.get("source")?.get("name") ?? "Nicht vorhanden",
+                        username: (0, openinc_openservice_save_ticket_data_1.getUsername)(ticketSource.get("user")),
+                        ticketName: ticketSource.get("ticket").get("title"),
+                    },
+                },
+                user: ticketSource.get("user"),
+                tenant: ticketSource.get("tenant"),
+            });
+            messages.push(previousSourceMessage);
+        }
+    }
+    await types_1.Maintenance_Message.saveAll(messages, { useMasterKey: true });
+}
+async function ticketStateToMessage(timeMap) {
+    console.log("Creating ticket state messages");
+    await convertToMessage({
+        className: types_1.Maintenance_Ticket_Kanban_State.className,
+        timeMap: timeMap,
+        ticketTranslation: OpenserviceTranslationKeys_1.OpenserviceMessageTranslationKeys.TICKETLOG.KANBANSTATE,
+        machinelogTranslation: OpenserviceTranslationKeys_1.OpenserviceMessageTranslationKeys.MACHINELOG.KANBANSTATE,
+        getTranslationData: (entry, prev) => {
+            return {
+                old: prev?.get("state")?.get("label") ?? "Nicht vorhanden",
+                new: entry.get("state")?.get("label") ?? "Nicht vorhanden",
+            };
+        },
+        isValueValid: (entry) => !!entry.get("state"),
+    });
+}
+async function ticketMaterialToMessage(timeMap) {
+    console.log("Creating ticket material messages");
+    await convertToMessage({
+        className: types_1.Maintenance_Ticket_Material.className,
+        timeMap: timeMap,
+        ticketTranslation: OpenserviceTranslationKeys_1.OpenserviceMessageTranslationKeys.TICKETLOG.MATERIAL,
+        machinelogTranslation: OpenserviceTranslationKeys_1.OpenserviceMessageTranslationKeys.MACHINELOG.MATERIAL,
+        getTranslationData: (entry, prev) => {
+            return {
+                old: (0, Maintenance_Ticket_Material_1.ticketMaterialItemListToString)(prev?.get("itemList")) ??
+                    "Nicht vorhanden",
+                new: (0, Maintenance_Ticket_Material_1.ticketMaterialItemListToString)(entry?.get("itemList")) ?? "Nicht vorhanden",
+            };
+        },
+        isValueValid: (entry) => !!entry.get("ticket"),
+    });
+}
+async function ticketIssuecategoryToMessage(timeMap) {
+    console.log("Creating ticket issue messages");
+    await convertToMessage({
+        className: types_1.Maintenance_Ticket_Issuecategory.className,
+        timeMap: timeMap,
+        ticketTranslation: OpenserviceTranslationKeys_1.OpenserviceMessageTranslationKeys.TICKETLOG.ISSUECATEGORY,
+        machinelogTranslation: OpenserviceTranslationKeys_1.OpenserviceMessageTranslationKeys.MACHINELOG.ISSUECATEGORY,
+        getTranslationData: (entry, prev) => {
+            return {
+                old: prev?.get("issuecategory")?.get("name") ?? "Nicht vorhanden",
+                new: entry.get("issuecategory")?.get("name") ?? "Nicht vorhanden",
+            };
+        },
+        isValueValid: (entry) => !!entry.get("issuecategory"),
+    });
+}
+async function ticketPriorityToMessage(timeMap) {
+    console.log("Creating ticket priority messages");
+    await convertToMessage({
+        className: types_1.Maintenance_Priority.className,
+        timeMap: timeMap,
+        ticketTranslation: OpenserviceTranslationKeys_1.OpenserviceMessageTranslationKeys.TICKETLOG.PRIORITY,
+        machinelogTranslation: OpenserviceTranslationKeys_1.OpenserviceMessageTranslationKeys.MACHINELOG.PRIORITY,
+        getTranslationData: (entry, prev) => {
+            return {
+                old: prev?.get("value") ?? "Nicht vorhanden",
+                new: entry.get("value") ?? "Nicht vorhanden",
+            };
+        },
+        isValueValid: (entry) => entry.get("value") !== undefined,
+    });
+}
+async function ticketRestrictionToMessage(timeMap) {
+    console.log("Creating ticket restriction messages");
+    await convertToMessage({
+        className: types_1.Maintenance_Restriction.className,
+        timeMap: timeMap,
+        ticketTranslation: OpenserviceTranslationKeys_1.OpenserviceMessageTranslationKeys.TICKETLOG.RESTRICTION,
+        machinelogTranslation: OpenserviceTranslationKeys_1.OpenserviceMessageTranslationKeys.MACHINELOG.RESTRICTION,
+        getTranslationData: (entry, prev) => {
+            return {
+                old: prev?.get("value") ?? "Nicht vorhanden",
+                new: entry.get("value") ?? "Nicht vorhanden",
+            };
+        },
+        isValueValid: (entry) => entry.get("value") !== undefined,
+    });
+}
+async function ticketDowntimeToMessage(timeMap) {
+    console.log("Creating ticket downtime messages");
+    await convertToMessage({
+        className: types_1.Maintenance_Downtime.className,
+        timeMap: timeMap,
+        ticketTranslation: OpenserviceTranslationKeys_1.OpenserviceMessageTranslationKeys.TICKETLOG.DOWNTIME,
+        machinelogTranslation: OpenserviceTranslationKeys_1.OpenserviceMessageTranslationKeys.MACHINELOG.DOWNTIME,
+        getTranslationData: (entry, prev) => {
+            return {
+                old: prev?.get("value") ?? "Nicht vorhanden",
+                new: entry.get("value") ?? "Nicht vorhanden",
+            };
+        },
+        isValueValid: (entry) => entry.get("value") !== undefined,
+    });
+}
+async function ticketFrequencyToMessage(timeMap) {
+    console.log("Creating ticket frequency messages");
+    await convertToMessage({
+        className: types_1.Maintenance_Frequency.className,
+        timeMap: timeMap,
+        ticketTranslation: OpenserviceTranslationKeys_1.OpenserviceMessageTranslationKeys.TICKETLOG.FREQUENCY,
+        machinelogTranslation: OpenserviceTranslationKeys_1.OpenserviceMessageTranslationKeys.MACHINELOG.FREQUENCY,
+        getTranslationData: (entry, prev) => {
+            return {
+                old: prev?.get("value") ?? "Nicht vorhanden",
+                new: entry.get("value") ?? "Nicht vorhanden",
+            };
+        },
+        isValueValid: (entry) => entry.get("value") !== undefined,
+    });
+}
+async function ticketDuedateToMessage(timeMap) {
+    console.log("Creating ticket duedate messages");
+    await convertToMessage({
+        className: types_1.Maintenance_Duedate.className,
+        timeMap: timeMap,
+        ticketTranslation: OpenserviceTranslationKeys_1.OpenserviceMessageTranslationKeys.TICKETLOG.DUEDATE,
+        machinelogTranslation: OpenserviceTranslationKeys_1.OpenserviceMessageTranslationKeys.MACHINELOG.DUEDATE,
+        getTranslationData: (entry, prev) => {
+            return {
+                oldstart: prev?.get("start")?.toLocaleDateString("de-DE") ?? "Nicht vorhanden",
+                oldend: prev?.get("end")?.toLocaleDateString("de-DE") ?? "Nicht vorhanden",
+                newstart: entry.get("start")?.toLocaleDateString("de-DE") ?? "Nicht vorhanden",
+                newend: entry.get("end")?.toLocaleDateString("de-DE") ?? "Nicht vorhanden",
+            };
+        },
+        isValueValid: (entry) => entry.get("end") !== undefined,
+    });
+}
+async function ticketTitleToMessage(timeMap) {
+    console.log("Creating ticket title messages");
+    await convertToMessage({
+        className: types_1.Maintenance_Ticket_Title.className,
+        timeMap: timeMap,
+        ticketTranslation: OpenserviceTranslationKeys_1.OpenserviceMessageTranslationKeys.TICKETLOG.TITLE,
+        machinelogTranslation: OpenserviceTranslationKeys_1.OpenserviceMessageTranslationKeys.MACHINELOG.TITLE,
+        getTranslationData: (entry, prev) => {
+            return {
+                old: prev?.get("title") ?? "Nicht vorhanden",
+                new: entry.get("title") ?? "Nicht vorhanden",
+            };
+        },
+        isValueValid: (entry) => !!entry.get("title"),
+    });
+}
+async function ticketProjectToMessage(timeMap) {
+    console.log("Creating ticket project messages");
+    await convertToMessage({
+        className: types_1.Maintenance_Ticket_Project.className,
+        timeMap: timeMap,
+        ticketTranslation: OpenserviceTranslationKeys_1.OpenserviceMessageTranslationKeys.TICKETLOG.PROJECT,
+        machinelogTranslation: OpenserviceTranslationKeys_1.OpenserviceMessageTranslationKeys.MACHINELOG.PROJECT,
+        getTranslationData: (entry, prev) => {
+            return {
+                old: prev?.get("project")?.get("name") ?? "Nicht vorhanden",
+                new: entry.get("project")?.get("name") ?? "Nicht vorhanden",
+            };
+        },
+        isValueValid: (entry) => !!entry.get("ticket"),
+    });
+}
+async function convertScheduleExecutionToMessage() {
+    console.log("Creating schedule execution messages");
+    const executions = await new Parse.Query(types_1.Maintenance_Schedule_Execution)
+        .limit(1000000)
+        .includeAll()
+        .find({ useMasterKey: true });
+    const messages = [];
+    for (const execution of executions) {
+        const source = execution.get("source");
+        if (!source)
+            continue;
+        const message = new types_1.Maintenance_Message({
+            title: OpenserviceTranslationKeys_1.OpenserviceMessageTranslationKeys.MACHINELOG.SCHEDULEEXECUTION.TITLE,
+            content: OpenserviceTranslationKeys_1.OpenserviceMessageTranslationKeys.MACHINELOG.SCHEDULEEXECUTION.CONTENT,
+            referencedObjectId: source.id,
+            classname: source.className,
+            displayAt: execution.get("finishedAt") ?? execution.get("createdAt"),
+            data: {
+                type: "system",
+                origin: {
+                    id: execution.id,
+                    classname: execution.className,
+                },
+                translation: {
+                    title: execution.get("title"),
+                    description: execution.get("description"),
+                    username: (0, openinc_openservice_save_ticket_data_1.getUsername)(execution.get("user")),
+                },
+            },
+            user: execution.get("user"),
+            tenant: execution.get("tenant"),
+        });
+        messages.push(message);
+    }
+    await types_1.Maintenance_Message.saveAll(messages, { useMasterKey: true });
+}

package/dist/features/openservice/messages/removeLatestMessage.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Removes the latest message. as context the title and content are used (should be translation strings)
+ * @param entry the entry to remove the message for
+ * @param title translation string for the title
+ * @param content translation string for the content
+ */
+export declare function removeLatestMessage(entry: Parse.Object, title: string, content: string): Promise<boolean>;

package/dist/features/openservice/messages/removeLatestMessage.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeLatestMessage = removeLatestMessage;
+const types_1 = require("../../../types");
+/**
+ * Removes the latest message. as context the title and content are used (should be translation strings)
+ * @param entry the entry to remove the message for
+ * @param title translation string for the title
+ * @param content translation string for the content
+ */
+async function removeLatestMessage(entry, title, content) {
+    const message = await new Parse.Query(types_1.Maintenance_Message)
+        .descending("createdAt")
+        .equalTo("referencedObjectId", entry.get("ticket")?.id)
+        .equalTo("classname", entry.get("ticket")?.className)
+        .equalTo("title", title)
+        .equalTo("content", content)
+        .first({ useMasterKey: true });
+    if (message) {
+        await message.destroy({ useMasterKey: true });
+        return true;
+    }
+    return false;
+}

package/dist/features/openservice/schedules/initScheduling.d.ts

@@ -0,0 +1,6 @@
+import { Maintenance_Schedule_Template } from "../../../types";
+/**
+ * This function is called upon initialization and uses bree to schedule all jobs.
+ */
+export declare function initScheduling(): Promise<void>;
+export declare function addJobToBree(query: Maintenance_Schedule_Template[]): Promise<void>;

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

@@ -0,0 +1,123 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initScheduling = initScheduling;
+exports.addJobToBree = addJobToBree;
+const path_1 = __importDefault(require("path"));
+const catchError_1 = require("../../../helper/catchError");
+const types_1 = require("../../../types");
+const cron_1 = __importDefault(require("../../cron"));
+/**
+ * This function is called upon initialization and uses bree to schedule all jobs.
+ */
+async function initScheduling() {
+    console.log("Init scheduling Maintenance_Schedule_Template jobs");
+    //Get all Maintenance_Schedule_Template objects
+    const [queryError, query] = await (0, catchError_1.catchError)(new Parse.Query(types_1.Maintenance_Schedule_Template).find({
+        useMasterKey: true,
+    }));
+    //Create an new bree object for all Maintenance_Schedule_Template objects that have cron.is_one_time = false
+    if (queryError) {
+        console.error("Error while querying Maintenance_Schedule_Template objects", queryError);
+        return;
+    }
+    await addJobToBree(query);
+}
+async function addJobToBree(query) {
+    for (const schedule of query) {
+        const cron = schedule.get("cron");
+        const notifyBeforeDue = schedule.get("notifyBeforeDue");
+        // If the notifyBeforeDue field is set, we will schedule a job to run before the due date
+        if (notifyBeforeDue && notifyBeforeDue.value > 0) {
+            // Calculate the offset from the start date
+            const startdate = cron_1.default.calculateOffsetToExecution(schedule.get("cron").run_startdate, notifyBeforeDue);
+            //Add a job to bree to run at the calculated date
+            const newjob = {
+                name: cron_1.default.constructJobName(schedule.id, "Maintenance_Schedule_Notification_Before_Due"),
+                path: path_1.default.join(__dirname, "..", "jobs", "open_service_notifyBeforeSchedule.js"),
+                date: startdate,
+                interval: cron.is_one_time
+                    ? 0
+                    : cron_1.default.createHumanReadableFormat(cron.run_cron),
+                hasSeconds: true,
+                worker: {
+                    workerData: {
+                        scheduleId: schedule.id,
+                        ParseAppId: Parse.applicationId,
+                        ParseJSKey: Parse.javaScriptKey,
+                        ParseMasterKey: Parse.masterKey,
+                        ParseServerURL: Parse.serverURL,
+                    },
+                },
+            };
+            await cron_1.default.addJob(newjob);
+        }
+        try {
+            let newjob = undefined;
+            if (cron.is_one_time === false) {
+                if (cron.scheduletype === "human") {
+                    newjob = {
+                        name: cron_1.default.constructJobName(schedule.id, "Maintenance_Schedule"),
+                        date: cron.run_startdate,
+                        path: path_1.default.join(__dirname, "..", "jobs", "open_service_notifyOnSchedule.js"),
+                        interval: cron_1.default.createHumanReadableFormat(cron.run_cron),
+                        hasSeconds: true,
+                        worker: {
+                            workerData: {
+                                scheduleId: schedule.id,
+                                ParseAppId: Parse.applicationId,
+                                ParseJSKey: Parse.javaScriptKey,
+                                ParseMasterKey: Parse.masterKey,
+                                ParseServerURL: Parse.serverURL,
+                            },
+                        },
+                    };
+                }
+                else if (cron.scheduletype === "quartz") {
+                    newjob = {
+                        name: cron_1.default.constructJobName(schedule.id, "Maintenance_Schedule"),
+                        cron: cron.run_cron,
+                        path: path_1.default.join(__dirname, "..", "jobs", "open_service_notifyOnSchedule.js"),
+                        timeout: 0,
+                        interval: 0,
+                        hasSeconds: true,
+                        worker: {
+                            workerData: {
+                                scheduleId: schedule.id,
+                                ParseAppId: Parse.applicationId,
+                                ParseJSKey: Parse.javaScriptKey,
+                                ParseMasterKey: Parse.masterKey,
+                                ParseServerURL: Parse.serverURL,
+                            },
+                        },
+                    };
+                }
+            }
+            else {
+                // If the job is a one time job, we will schedule it to run once
+                newjob = {
+                    name: cron_1.default.constructJobName(schedule.id, "Maintenance_Schedule"),
+                    date: cron.run_startdate,
+                    path: path_1.default.join(__dirname, "..", "jobs", "open_service_notifyOnSchedule.js"),
+                    interval: 0,
+                    hasSeconds: true,
+                    worker: {
+                        workerData: {
+                            scheduleId: schedule.id,
+                            ParseAppId: Parse.applicationId,
+                            ParseJSKey: Parse.javaScriptKey,
+                            ParseMasterKey: Parse.masterKey,
+                            ParseServerURL: Parse.serverURL,
+                        },
+                    },
+                };
+            }
+            await cron_1.default.addJob(newjob);
+        }
+        catch (error) {
+            console.warn(`Error while adding job for schedule ${schedule.id}`, error);
+        }
+    }
+}

package/dist/features/openservice/ticket/initTicket.d.ts

@@ -0,0 +1,2 @@
+export declare function updateTicketDescription(): Promise<void>;
+export declare function initTicketClass(): Promise<void>;

package/dist/features/openservice/ticket/initTicket.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateTicketDescription = updateTicketDescription;
+exports.initTicketClass = initTicketClass;
+const catchError_1 = require("../../../helper/catchError");
+const types_1 = require("../../../types");
+async function updateTicketDescription() {
+    while (true) {
+        const query = new Parse.Query(types_1.Maintenance_Ticket).doesNotExist("description");
+        query.limit(1000);
+        const tickets = await query.find({ useMasterKey: true });
+        if (tickets.length === 0)
+            break;
+        const allCreationMessages = await new Parse.Query(types_1.Maintenance_Message)
+            .equalTo("classname", types_1.Maintenance_Ticket.className)
+            .equalTo("title", "maintenance:ticket.create.database.subject.1")
+            .containedIn("referencedObjectId", tickets.map((ticket) => ticket.id))
+            .limit(1000000)
+            .find({ useMasterKey: true });
+        for (const ticket of tickets) {
+            const foundMessage = allCreationMessages.find((message) => message.get("referencedObjectId") === ticket.id);
+            ticket.set("description", foundMessage?.get("content") ?? " ");
+        }
+        await Parse.Object.saveAll(tickets, { useMasterKey: true });
+    }
+}
+async function initTicketClass() {
+    // Query all of Maintenance_Ticket and find all of Maintenance_Priority sort by createdAt in descending order
+    // get the objectid of the first object in the array and save it in the latestPriority field of the Maintenance_Ticket object
+    console.log("Maintenance_Ticket init: Check and save latestPriority");
+    const [ticketError, ticketResults] = await (0, catchError_1.catchError)(new Parse.Query(types_1.Maintenance_Ticket).each(async (ticket) => {
+        if (!ticket.get("latestPriorityValue")) {
+            const [priorityError, priorityResult] = await (0, catchError_1.catchError)(new Parse.Query(types_1.Maintenance_Priority)
+                .equalTo("ticket", ticket)
+                .descending("createdAt")
+                .first({ useMasterKey: true }));
+            if (priorityError) {
+                console.error("Maintenance_Priority error", priorityError);
+                return;
+            }
+            if (priorityResult === undefined) {
+                console.log("Maintenance_Ticket init: Check and save latestPriority: No priority found for ticket", ticket.id);
+                return;
+            }
+            ticket.set("latestPriorityValue", priorityResult.get("value"));
+            await ticket.save(null, { useMasterKey: true });
+        }
+    }, { useMasterKey: true }));
+    console.log("Maintenance_Ticket init: Check and save latestPriority done");
+}