@openinc/parse-server-opendash 3.8.0 → 3.9.1

package/dist/features/openservice/init.js

@@ -1,25 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.init = init;
-const types_1 = require("../../types");
+const initKanbanStates_1 = require("./kanbanState/initKanbanStates");
+const initMessages_1 = require("./messages/initMessages");
+const initScheduling_1 = require("./schedules/initScheduling");
+const initTicket_1 = require("./ticket/initTicket");
 async function init() {
+    console.log("Initializing open.SERVICE feature...");
+    await (0, initMessages_1.initializeMessages)();
+    await (0, initKanbanStates_1.initCurrentTicketStates)();
+    await (0, initTicket_1.updateTicketDescription)();
+    await (0, initKanbanStates_1.initEnabledFlag)();
+    await (0, initScheduling_1.initScheduling)();
+    await (0, initTicket_1.initTicketClass)();
     console.log("open.SERVICE feature initialized.");
-    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 });
-    }
 }

package/dist/features/openservice/kanbanState/initKanbanStates.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Initialize the current ticket states table. if a ticket has no entry in the current ticket states table, create one.
+ * If the ticket has no state, initialize it with the inbox state.
+ */
+export declare function initCurrentTicketStates(): Promise<void>;
+export declare function initEnabledFlag(): Promise<void>;

package/dist/features/openservice/kanbanState/initKanbanStates.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initCurrentTicketStates = initCurrentTicketStates;
+exports.initEnabledFlag = initEnabledFlag;
+const types_1 = require("../../../types");
+/**
+ * Initialize the current ticket states table. if a ticket has no entry in the current ticket states table, create one.
+ * If the ticket has no state, initialize it with the inbox state.
+ */
+async function initCurrentTicketStates() {
+    console.log("Initializing current ticket states table");
+    // Getting the tickets that have no entry in the current ticket states table (OD3_Maintenance_Ticket_Kanban_State_Current)
+    const ticketsWithoutEntry = await new Parse.Query(types_1.Maintenance_Ticket)
+        .doesNotMatchKeyInQuery("objectId", 
+    //@ts-ignore
+    "ticket.objectId", new Parse.Query(types_1.Maintenance_Ticket_Kanban_State_Current).select("ticket"))
+        .find({ useMasterKey: true });
+    // for each ticket not in the table, create an entry
+    for (const ticket of ticketsWithoutEntry) {
+        const currentTicketState = await new Parse.Query(types_1.Maintenance_Ticket_Kanban_State)
+            .includeAll()
+            .equalTo("ticket", ticket)
+            .descending("createdAt")
+            .first({ useMasterKey: true });
+        const tenant = ticket.get("tenant");
+        const user = ticket.get("user");
+        if (tenant === undefined || user === undefined) {
+            console.error("Tenant or user is undefined for ticket", ticket.id);
+            continue;
+        }
+        // if the ticket has a state, create an entry in the current ticket states table
+        if (currentTicketState) {
+            const newTicketState = new types_1.Maintenance_Ticket_Kanban_State_Current({
+                ticket: ticket,
+                ticketState: currentTicketState,
+                state: currentTicketState.get("state"),
+                tenant: tenant,
+            });
+            const acl = new Parse.ACL();
+            acl.setPublicReadAccess(false);
+            acl.setPublicWriteAccess(false);
+            acl.setRoleReadAccess("od-admin", true);
+            acl.setRoleWriteAccess("od-admin", true);
+            acl.setReadAccess(user.id, true);
+            acl.setWriteAccess(user.id, true);
+            acl.setRoleReadAccess(`od-tenant-user-${tenant.id}`, true);
+            acl.setRoleWriteAccess(`od-tenant-user-${tenant.id}`, true);
+            acl.setRoleReadAccess(`od-tenant-admin-${tenant.id}`, true);
+            acl.setRoleWriteAccess(`od-tenant-admin-${tenant.id}`, true);
+            newTicketState.setACL(acl);
+            await newTicketState.save(null, { useMasterKey: true });
+        }
+        else {
+            // if the ticket has no state, initialize it with the inbox state
+            const inboxState = await new Parse.Query(types_1.Maintenance_Kanban_State)
+                .equalTo("isInbox", true)
+                .first({ useMasterKey: true });
+            if (!inboxState)
+                continue;
+            // saving the ticket state will automatically create an entry in the current ticket states table due to the afterSave-Hook
+            const newkanbanstate = new types_1.Maintenance_Ticket_Kanban_State({
+                ticket: ticket,
+                state: inboxState,
+                tenant: tenant,
+                user: user,
+            });
+            const acl = new Parse.ACL();
+            acl.setPublicReadAccess(false);
+            acl.setPublicWriteAccess(false);
+            acl.setRoleReadAccess("od-admin", true);
+            acl.setRoleWriteAccess("od-admin", true);
+            acl.setReadAccess(user.id, true);
+            acl.setWriteAccess(user.id, true);
+            acl.setRoleReadAccess(`od-tenant-user-${tenant.id}`, true);
+            acl.setRoleWriteAccess(`od-tenant-user-${tenant.id}`, true);
+            acl.setRoleReadAccess(`od-tenant-admin-${tenant.id}`, true);
+            acl.setRoleWriteAccess(`od-tenant-admin-${tenant.id}`, true);
+            newkanbanstate.setACL(acl);
+            const savedkanbanstate = await newkanbanstate.save(null, {
+                useMasterKey: true,
+            });
+            const currentTicketState = await new Parse.Query(types_1.Maintenance_Ticket_Kanban_State_Current)
+                .equalTo("ticket", savedkanbanstate.get("ticket"))
+                .first({ useMasterKey: true });
+            // if the ticket is already in the current state table, update it
+            if (currentTicketState) {
+                currentTicketState.set("ticketState", savedkanbanstate);
+                currentTicketState.set("state", savedkanbanstate.get("state"));
+                await currentTicketState.save(null, { useMasterKey: true });
+            }
+            // if the ticket is not in the current state table, create a new entry
+            else {
+                const newTicketState = new types_1.Maintenance_Ticket_Kanban_State_Current({
+                    ticket: savedkanbanstate.get("ticket"),
+                    ticketState: savedkanbanstate,
+                    state: savedkanbanstate.get("state"),
+                    tenant: savedkanbanstate.get("tenant"),
+                });
+                await newTicketState.save(null, { useMasterKey: true });
+            }
+        }
+    }
+    console.log("Current ticket states table initialized");
+}
+async function initEnabledFlag() {
+    const objects = await new Parse.Query(types_1.Maintenance_Kanban_State)
+        .limit(1000000000)
+        .find({ useMasterKey: true });
+    const promises = objects.map((object) => {
+        object.save({ enabled: object.enabled === undefined ? true : object.enabled }, { useMasterKey: true });
+    });
+    await Promise.all(promises);
+}

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

@@ -0,0 +1,5 @@
+export declare function sanatizeMessagesDisplayAt(): Promise<void>;
+/**
+ * Initializes the messages if there are no messages in the database
+ */
+export declare function initializeMessages(): Promise<void>;

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>;