@openinc/parse-server-opendash 3.0.8 → 3.1.0

package/dist/features/openservice/functions/assignUsersAndRoles.d.ts

@@ -0,0 +1,8 @@
+import { _User, Maintenance_Ticket } from "../../../types";
+import { FetchOptions } from "../types/FetchOptions";
+type Assignments = Array<{
+    type: "user" | "role";
+    id: string;
+}>;
+export declare function assignUsersAndRoles(ticket: Maintenance_Ticket, assignedTo: Assignments, fetchOptions: FetchOptions, assigningUser?: _User): Promise<void>;
+export {};

package/dist/features/openservice/functions/assignUsersAndRoles.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assignUsersAndRoles = assignUsersAndRoles;
+const parse_1 = require("parse");
+const openinc_openservice_save_ticket_data_1 = require("../../../functions/openinc-openservice-save-ticket-data");
+const openinc_openservice_ticket_data_1 = require("../../../functions/openinc-openservice-ticket-data");
+const types_1 = require("../../../types");
+async function assignUsersAndRoles(ticket, assignedTo, fetchOptions, assigningUser) {
+    const assignedUsers = (await ticket
+        .relation("assignedusers")
+        .query()
+        .find(fetchOptions));
+    const assignedroles = (await ticket
+        .relation("assignedroles")
+        .query()
+        .find(fetchOptions));
+    if (!hasChanged(assignedTo, assignedUsers, assignedroles))
+        return;
+    ticket.relation("assignedusers").remove(assignedUsers);
+    ticket.relation("assignedroles").remove(assignedroles);
+    const assignments = [];
+    const batchTime = new Date();
+    const ids = assignedTo.map((a) => a.id);
+    const newUsers = await new Parse.Query(parse_1.User)
+        .containedIn("objectId", ids)
+        .find(fetchOptions);
+    const newRoles = await new Parse.Query(parse_1.Role)
+        .containedIn("objectId", ids)
+        .find(fetchOptions);
+    ticket.relation("assignedusers").add(newUsers);
+    ticket.relation("assignedroles").add(newRoles);
+    await ticket.save(null, fetchOptions);
+    if (newRoles.length === 0 && newUsers.length === 0) {
+        assignments.push(new types_1.Maintenance_Ticket_Assignment({
+            ticket,
+            assignedUser: undefined,
+            assignedRole: undefined,
+            user: ticket.user,
+            tenant: ticket.tenant,
+            batchStamp: batchTime,
+        }));
+    }
+    for (const assignedTo of newUsers) {
+        assignments.push(new types_1.Maintenance_Ticket_Assignment({
+            ticket,
+            assignedUser: assignedTo,
+            tenant: ticket.get("tenant"),
+            user: ticket.get("user"),
+            batchStamp: batchTime,
+        }));
+        await new types_1.Notification({
+            data: {
+                ticketId: ticket.id,
+                translation: {
+                    ticketName: ticket.get("title"),
+                    ticketId: ticket.id,
+                    username: (0, openinc_openservice_save_ticket_data_1.getUsername)(assigningUser) ?? "System",
+                },
+            },
+            isSent: false,
+            title: "maintenance:ticket.assignuser.notification.title",
+            user: assignedTo,
+            description: "maintenance:ticket.assignuser.notification.description",
+        }).save(null, fetchOptions);
+    }
+    for (const assignedTo of newRoles) {
+        assignments.push(new types_1.Maintenance_Ticket_Assignment({
+            ticket,
+            assignedRole: assignedTo,
+            tenant: ticket.get("tenant"),
+            user: ticket.get("user"),
+            batchStamp: batchTime,
+        }));
+        const roleUsers = await assignedTo
+            .relation("users")
+            .query()
+            .find(fetchOptions);
+        for (const roleUser of roleUsers) {
+            await new types_1.Notification({
+                data: {
+                    ticketId: ticket.id,
+                    translation: {
+                        ticketName: ticket.get("title"),
+                        ticketId: ticket.id,
+                        user: ticket.get("user")?.get("username"),
+                        role: assignedTo.get("label"),
+                    },
+                },
+                isSent: false,
+                title: "maintenance:ticket.assignrole.notification.title",
+                user: roleUser,
+                description: "maintenance:ticket.assignrole.notification.description",
+            }).save(null, fetchOptions);
+        }
+    }
+    await types_1.Maintenance_Ticket_Assignment.saveAll(assignments, fetchOptions);
+    //Set ACLs for assigned users and roles on ticket
+    const acl = new Parse.ACL();
+    for (const assignedUser of newUsers) {
+        acl.setReadAccess(assignedUser, true);
+        acl.setWriteAccess(assignedUser, true);
+    }
+    // get the parent roles of the assigned roles
+    const rolesWithParents = await addParentRoles(newRoles);
+    // remove duplicates from the array
+    const distinctRolesWithParents = (0, openinc_openservice_ticket_data_1.arrayToDistinct)(rolesWithParents, (obj) => obj.id);
+    for (const assignedRole of distinctRolesWithParents) {
+        acl.setRoleReadAccess(assignedRole, true);
+        acl.setRoleWriteAccess(assignedRole, true);
+    }
+    ticket.setACL(acl);
+    await ticket.save(null, fetchOptions);
+    // SAVE ASSIGNMENT MESSAGE
+    // set the content for the message
+    let content = "maintenance:ticket.eventlist.OD3_Maintenance_Ticket_Assignment.none";
+    if (newUsers.length > 0 && newRoles.length > 0)
+        content =
+            "maintenance:ticket.eventlist.OD3_Maintenance_Ticket_Assignment.both";
+    else if (newUsers.length > 0)
+        content =
+            "maintenance:ticket.eventlist.OD3_Maintenance_Ticket_Assignment.user";
+    else if (newRoles.length > 0)
+        content =
+            "maintenance:ticket.eventlist.OD3_Maintenance_Ticket_Assignment.role";
+    await new types_1.Maintenance_Message({
+        referencedObjectId: ticket.id,
+        classname: types_1.Maintenance_Ticket.className,
+        title: "maintenance:ticket.message.assignment.changed.title",
+        content,
+        user: ticket.get("user"),
+        tenant: ticket.get("tenant"),
+        data: {
+            type: "system",
+            translation: {
+                username: (0, openinc_openservice_save_ticket_data_1.getUsername)(assigningUser),
+                userList: newUsers.map((u) => `'${u.get("username")}'`).join(", "),
+                roleList: newRoles.map((r) => `'${r.get("label")}'`).join(", "),
+                ticketName: ticket.get("title"),
+            },
+            origin: {
+                id: ticket.id,
+                classname: ticket.className,
+            },
+        },
+    }).save(null, fetchOptions);
+    await ticket.save(null, fetchOptions);
+}
+async function addParentRoles(roles) {
+    for (const role of roles) {
+        const roleQuery = new Parse.Query(parse_1.Role).equalTo("objectId", role.id);
+        const parentRoles = await new Parse.Query(parse_1.Role)
+            .matchesQuery("roles", roleQuery)
+            .find();
+        if (parentRoles.length > 0) {
+            roles.push(...(await addParentRoles(parentRoles)));
+        }
+    }
+    return roles;
+}
+function hasChanged(assignedTo, assignedUsers, assignedRoles) {
+    const assignedIds = [
+        ...assignedUsers.map((u) => u.id),
+        ...assignedRoles.map((r) => r.id),
+    ];
+    const newIds = assignedTo.map((a) => a.id);
+    return (assignedIds.length !== newIds.length ||
+        !newIds.every((id) => assignedIds.includes(id)));
+}

package/dist/features/openservice/functions/getTicketObject.d.ts

@@ -0,0 +1,4 @@
+import { _User, Maintenance_Ticket } from "../../../types";
+import { FetchOptions } from "../types/FetchOptions";
+import { SaveValues } from "../types/SaveValues";
+export declare function getTicketObject(value: SaveValues, user: _User | undefined, fetchOptions: FetchOptions): Promise<Maintenance_Ticket>;

package/dist/features/openservice/functions/getTicketObject.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTicketObject = getTicketObject;
+const types_1 = require("../../../types");
+async function getTicketObject(value, user, fetchOptions) {
+    if (value.existingTicketId) {
+        const ticket = await new Parse.Query(types_1.Maintenance_Ticket).get(value.existingTicketId, fetchOptions);
+        if (!ticket) {
+            throw new Error("Ticket not found");
+        }
+        if (value.title && ticket.get("title") !== value.title) {
+            ticket.set("title", value.title);
+            await ticket.save(null, fetchOptions);
+        }
+        return ticket;
+    }
+    return await new types_1.Maintenance_Ticket({
+        title: value.title,
+        user: user,
+        tenant: user?.get("tenant"),
+    }).save(null, fetchOptions);
+}

package/dist/features/openservice/functions/saveDowntime.d.ts

@@ -0,0 +1,3 @@
+import { Maintenance_Ticket, Maintenance_Downtime } from "../../../types";
+import { FetchOptions } from "../types/FetchOptions";
+export declare function saveDowntime(ticket: Maintenance_Ticket, value: number, fetchOptions: FetchOptions): Promise<Maintenance_Downtime>;

package/dist/features/openservice/functions/saveDowntime.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveDowntime = saveDowntime;
+const types_1 = require("../../../types");
+async function saveDowntime(ticket, value, fetchOptions) {
+    const current = await getCurrent(ticket);
+    const changed = current?.get("value") !== value;
+    if (!changed)
+        return current;
+    const downtime = new types_1.Maintenance_Downtime({
+        ticket,
+        value: value,
+        tenant: ticket.get("tenant"),
+        user: ticket.get("user"),
+    });
+    return await downtime.save(null, fetchOptions);
+}
+async function getCurrent(ticket) {
+    return await new Parse.Query(types_1.Maintenance_Downtime)
+        .descending("createdAt")
+        .equalTo("ticket", ticket)
+        .first({ useMasterKey: true });
+}

package/dist/features/openservice/functions/saveDuedate.d.ts

@@ -0,0 +1,8 @@
+import { Maintenance_Ticket, Maintenance_Duedate } from "../../../types";
+import { FetchOptions } from "../types/FetchOptions";
+type DuedateValue = {
+    start?: Date;
+    end: Date;
+};
+export declare function saveDuedate(ticket: Maintenance_Ticket, duedate: DuedateValue, fetchOptions: FetchOptions): Promise<Maintenance_Duedate | undefined>;
+export {};

package/dist/features/openservice/functions/saveDuedate.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveDuedate = saveDuedate;
+const types_1 = require("../../../types");
+async function saveDuedate(ticket, duedate, fetchOptions) {
+    const current = await getCurrent(ticket);
+    const changed = await hasChanged(current, duedate);
+    if (!changed)
+        return current;
+    const dueDate = new types_1.Maintenance_Duedate({
+        ticket,
+        end: duedate.end,
+        start: duedate.start,
+        tenant: ticket.get("tenant"),
+        user: ticket.get("user"),
+        endformat: "DD.MM.YYYY",
+        startformat: "DD.MM.YYYY",
+    });
+    await dueDate.save(null, fetchOptions);
+}
+async function getCurrent(ticket) {
+    return await new Parse.Query(types_1.Maintenance_Duedate)
+        .equalTo("ticket", ticket)
+        .descending("createdAt")
+        .first({ useMasterKey: true });
+}
+async function hasChanged(current, duedate) {
+    return (current?.get("end") !== duedate.end ||
+        current?.get("start") !== duedate.start);
+}

package/dist/features/openservice/functions/saveFrequency.d.ts

@@ -0,0 +1,3 @@
+import { Maintenance_Ticket, Maintenance_Frequency } from "../../../types";
+import { FetchOptions } from "../types/FetchOptions";
+export declare function saveFrequency(ticket: Maintenance_Ticket, value: number, fetchOptions: FetchOptions): Promise<Maintenance_Frequency>;

package/dist/features/openservice/functions/saveFrequency.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveFrequency = saveFrequency;
+const types_1 = require("../../../types");
+async function saveFrequency(ticket, value, fetchOptions) {
+    const current = await getCurrent(ticket);
+    const changed = current?.get("value") !== value;
+    if (!changed)
+        return current;
+    const frequency = new types_1.Maintenance_Frequency({
+        ticket,
+        value: value,
+        tenant: ticket.get("tenant"),
+        user: ticket.get("user"),
+    });
+    return await frequency.save(null, fetchOptions);
+}
+async function getCurrent(ticket) {
+    return await new Parse.Query(types_1.Maintenance_Frequency)
+        .descending("createdAt")
+        .equalTo("ticket", ticket)
+        .first({ useMasterKey: true });
+}

package/dist/features/openservice/functions/saveIssuecategory.d.ts

@@ -0,0 +1,4 @@
+import { Maintenance_Ticket, Maintenance_Ticket_Issuecategory } from "../../../types";
+import { FetchOptions } from "../types/FetchOptions";
+export declare function saveIssueCategory(ticket: Maintenance_Ticket, value: string, fetchOptions: FetchOptions): Promise<Maintenance_Ticket_Issuecategory>;
+export declare function saveDefaultIssueCategory(ticket: Maintenance_Ticket, fetchOptions: FetchOptions): Promise<void>;

package/dist/features/openservice/functions/saveIssuecategory.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveIssueCategory = saveIssueCategory;
+exports.saveDefaultIssueCategory = saveDefaultIssueCategory;
+const types_1 = require("../../../types");
+async function saveIssueCategory(ticket, value, fetchOptions) {
+    const current = await getCurrent(ticket);
+    const changed = current?.get("issuecategory")?.id !== value;
+    if (!changed)
+        return current;
+    const issueCategory = new types_1.Maintenance_Ticket_Issuecategory({
+        ticket,
+        issuecategory: new types_1.Maintenance_Issuecategory({ objectId: value }), // pointer
+        tenant: ticket.get("tenant"),
+        user: ticket.get("user"),
+    });
+    return await issueCategory.save(null, fetchOptions);
+}
+async function saveDefaultIssueCategory(ticket, fetchOptions) {
+    const catchAll = await new Parse.Query(types_1.Maintenance_Issuecategory)
+        .equalTo("catchall", true)
+        .first(fetchOptions);
+    if (!catchAll)
+        return;
+    const issueCategory = new types_1.Maintenance_Ticket_Issuecategory({
+        ticket,
+        issuecategory: catchAll,
+        tenant: ticket.get("tenant"),
+        user: ticket.get("user"),
+    });
+    await issueCategory.save(null, fetchOptions);
+}
+async function getCurrent(ticket) {
+    return await new Parse.Query(types_1.Maintenance_Ticket_Issuecategory)
+        .descending("createdAt")
+        .equalTo("ticket", ticket)
+        .includeAll()
+        .first({ useMasterKey: true });
+}

package/dist/features/openservice/functions/saveMaterial.d.ts

@@ -0,0 +1,4 @@
+import { Maintenance_Ticket } from "../../../types";
+import { FetchOptions } from "../types/FetchOptions";
+import { Material } from "../types/Material";
+export declare function saveMaterial(ticket: Maintenance_Ticket, material: Material[], fetchOptions: FetchOptions): Promise<void>;

package/dist/features/openservice/functions/saveMaterial.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveMaterial = saveMaterial;
+const types_1 = require("../../../types");
+async function saveMaterial(ticket, material, fetchOptions) {
+    const materialObject = new types_1.Maintenance_Ticket_Material({
+        ticket,
+        itemList: material,
+        tenant: ticket.get("tenant"),
+        user: ticket.get("user"),
+    });
+    await materialObject.save(null, fetchOptions);
+}

package/dist/features/openservice/functions/saveMedia.d.ts

@@ -0,0 +1,3 @@
+import { Maintenance_Ticket } from "../../../types";
+import { FetchOptions } from "../types/FetchOptions";
+export declare function saveMedia(ticket: Maintenance_Ticket, media: string[], fetchOptions: FetchOptions): Promise<void>;

package/dist/features/openservice/functions/saveMedia.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveMedia = saveMedia;
+const types_1 = require("../../../types");
+async function saveMedia(ticket, media, fetchOptions) {
+    const message = new types_1.Maintenance_Message({
+        referencedObjectId: ticket.id,
+        classname: types_1.Maintenance_Ticket.className,
+        data: { type: "media" },
+        tenant: ticket.get("tenant"),
+        user: ticket.get("user"),
+    });
+    message
+        .relation("media")
+        .add(media.map((m) => new types_1.Maintenance_Media({ objectId: m })));
+    await message.save(null, fetchOptions);
+}

package/dist/features/openservice/functions/saveMessage.d.ts

@@ -0,0 +1,5 @@
+import { Maintenance_Ticket } from "../../../types";
+import { FetchOptions } from "../types/FetchOptions";
+import { MessageField } from "../types/MessageData";
+import { SaveValues } from "../types/SaveValues";
+export declare function saveMessage(ticket: Maintenance_Ticket, message: MessageField, fetchOptions: FetchOptions, values: SaveValues): Promise<void>;

package/dist/features/openservice/functions/saveMessage.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveMessage = saveMessage;
+const types_1 = require("../../../types");
+async function saveMessage(ticket, message, fetchOptions, values) {
+    if (values.existingTicketId &&
+        message.title === "maintenance:ticket.update.message.title") {
+        const description = await new Parse.Query(types_1.Maintenance_Message)
+            .equalTo("referencedObjectId", ticket.id)
+            .equalTo("classname", types_1.Maintenance_Ticket.className)
+            .equalTo("title", "maintenance:ticket.create.database.subject.1")
+            .first(fetchOptions);
+        if (description) {
+            // dont do anything when description is the same
+            if (description.content === message.description)
+                return;
+            // update description
+            description.set("content", message.description);
+            await description.save(null, fetchOptions);
+            return;
+        }
+    }
+    // create new message log
+    await new types_1.Maintenance_Message({
+        content: message.description,
+        referencedObjectId: ticket.id,
+        classname: types_1.Maintenance_Ticket.className,
+        tenant: ticket.get("tenant"),
+        user: ticket.get("user"),
+        title: message.title,
+        data: {
+            origin: { id: ticket.id, classname: ticket.className }, // default
+            ...message.data,
+        },
+    }).save(null, fetchOptions);
+    // to machinelog
+    // if needed, this saves a message to the machinelog when a message is saved to the ticket
+    // this counts for user input and the ticket creation
+    // const source = values.source
+    //   ? await new Parse.Query(Source).get(values.source, fetchOptions)
+    //   : (await getTicketSource(ticket))?.get("source");
+    // if (source) {
+    //   await new Maintenance_Message({
+    //     referencedObjectId: source.id,
+    //     classname: source.className,
+    //     title: message.title,
+    //     content: message.description,
+    //     user: ticket.get("user"),
+    //     tenant: ticket.get("tenant"),
+    //     data: {
+    //       type: "system",
+    //       translation: {
+    //         username: getUsername(ticket.get("user") as _User),
+    //         old: "Nicht vorhanden",
+    //         new: ticket.get("title"),
+    //         ticketName: ticket.get("title"),
+    //       },
+    //       origin: {
+    //         id: ticket.id,
+    //         classname: ticket.className,
+    //       },
+    //       ...message.data,
+    //     } as MessageData,
+    //   }).save(null, fetchOptions);
+    // }
+}

package/dist/features/openservice/functions/savePriority.d.ts

@@ -0,0 +1,3 @@
+import { Maintenance_Priority, Maintenance_Ticket } from "../../../types";
+import { FetchOptions } from "../types/FetchOptions";
+export declare function savePriority(ticket: Maintenance_Ticket, value: number, fetchOptions: FetchOptions): Promise<Maintenance_Priority>;

package/dist/features/openservice/functions/savePriority.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.savePriority = savePriority;
+const types_1 = require("../../../types");
+async function savePriority(ticket, value, fetchOptions) {
+    const current = await getCurrent(ticket);
+    const changed = current?.get("value") !== value;
+    if (!changed)
+        return current;
+    const priority = new types_1.Maintenance_Priority({
+        ticket,
+        value: value,
+        tenant: ticket.get("tenant"),
+        user: ticket.get("user"),
+    });
+    return await priority.save(null, fetchOptions);
+}
+async function getCurrent(ticket) {
+    return await new Parse.Query(types_1.Maintenance_Priority)
+        .descending("createdAt")
+        .equalTo("ticket", ticket)
+        .first({ useMasterKey: true });
+}

package/dist/features/openservice/functions/saveProject.d.ts

@@ -0,0 +1,3 @@
+import { Maintenance_Ticket, Maintenance_Ticket_Project } from "../../../types";
+import { FetchOptions } from "../types/FetchOptions";
+export declare function saveProject(ticket: Maintenance_Ticket, project: string, fetchOptions: FetchOptions): Promise<Maintenance_Ticket_Project | undefined>;

package/dist/features/openservice/functions/saveProject.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveProject = saveProject;
+const types_1 = require("../../../types");
+async function saveProject(ticket, project, fetchOptions) {
+    const current = await getCurrent(ticket);
+    const changed = current?.get("project")?.id !== project;
+    if (!changed)
+        return current;
+    // check if ticket already has a project assigned
+    // if so, remove the ticket from the old project
+    const prevProject = await ticket.get("project")?.fetch(fetchOptions);
+    if (prevProject && prevProject.id !== project) {
+        prevProject.relation("tickets").remove(ticket);
+        prevProject.save(null, fetchOptions);
+    }
+    const projectObj = await new Parse.Query(types_1.Maintenance_Project)
+        .equalTo("objectId", project)
+        .first(fetchOptions);
+    const ticketProjectObject = new types_1.Maintenance_Ticket_Project({
+        ticket,
+        project: projectObj,
+        tenant: ticket.get("tenant"),
+        user: ticket.get("user"),
+    });
+    await ticketProjectObject.save(null, fetchOptions);
+    ticket.set("project", projectObj);
+    await ticket.save(null, fetchOptions);
+    if (projectObj) {
+        projectObj.relation("tickets").add(ticket);
+        await projectObj.save(null, fetchOptions);
+    }
+}
+async function getCurrent(ticket) {
+    return await new Parse.Query(types_1.Maintenance_Ticket_Project)
+        .descending("createdAt")
+        .equalTo("ticket", ticket)
+        .first({ useMasterKey: true });
+}

package/dist/features/openservice/functions/saveRestriction.d.ts

@@ -0,0 +1,3 @@
+import { Maintenance_Ticket, Maintenance_Restriction } from "../../../types";
+import { FetchOptions } from "../types/FetchOptions";
+export declare function saveRestriction(ticket: Maintenance_Ticket, value: number, fetchOptions: FetchOptions): Promise<Maintenance_Restriction>;

package/dist/features/openservice/functions/saveRestriction.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveRestriction = saveRestriction;
+const types_1 = require("../../../types");
+async function saveRestriction(ticket, value, fetchOptions) {
+    const current = await getCurrent(ticket);
+    const changed = current?.get("value") !== value;
+    if (!changed)
+        return current;
+    const restriction = new types_1.Maintenance_Restriction({
+        ticket,
+        value: value,
+        tenant: ticket.get("tenant"),
+        user: ticket.get("user"),
+    });
+    return await restriction.save(null, fetchOptions);
+}
+async function getCurrent(ticket) {
+    return await new Parse.Query(types_1.Maintenance_Restriction)
+        .descending("createdAt")
+        .equalTo("ticket", ticket)
+        .first({ useMasterKey: true });
+}

package/dist/features/openservice/functions/saveSource.d.ts

@@ -0,0 +1,3 @@
+import { Maintenance_Ticket, Maintenance_Ticket_Source } from "../../../types";
+import { FetchOptions } from "../types/FetchOptions";
+export declare function saveSource(ticket: Maintenance_Ticket, source: string, fetchOptions: FetchOptions): Promise<Maintenance_Ticket_Source>;

package/dist/features/openservice/functions/saveSource.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveSource = saveSource;
+const types_1 = require("../../../types");
+async function saveSource(ticket, source, fetchOptions) {
+    const current = await getCurrent(ticket);
+    const changed = current?.get("source")?.id !== source;
+    if (!changed)
+        return current;
+    const tSource = new types_1.Maintenance_Ticket_Source({
+        ticket,
+        source: new types_1.Source({ objectId: source }),
+        tenant: ticket.get("tenant"),
+        user: ticket.get("user"),
+    });
+    return await tSource.save(null, fetchOptions);
+}
+async function getCurrent(ticket) {
+    return await new Parse.Query(types_1.Maintenance_Ticket_Source)
+        .descending("createdAt")
+        .equalTo("ticket", ticket)
+        .first({ useMasterKey: true });
+}

package/dist/features/openservice/functions/saveState.d.ts

@@ -0,0 +1,4 @@
+import { Maintenance_Ticket, Maintenance_Ticket_Kanban_State, Maintenance_Ticket_Kanban_State_Current } from "../../../types";
+import { FetchOptions } from "../types/FetchOptions";
+export declare function saveState(ticket: Maintenance_Ticket, state: string, fetchOptions: FetchOptions): Promise<Maintenance_Ticket_Kanban_State | Maintenance_Ticket_Kanban_State_Current>;
+export declare function saveDefaultState(ticket: Maintenance_Ticket, fetchOptions: FetchOptions): Promise<void>;

package/dist/features/openservice/functions/saveState.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveState = saveState;
+exports.saveDefaultState = saveDefaultState;
+const types_1 = require("../../../types");
+async function saveState(ticket, state, fetchOptions) {
+    const current = await getCurrent(ticket);
+    const changed = current?.get("state")?.id !== state;
+    if (!changed)
+        return current;
+    return await new types_1.Maintenance_Ticket_Kanban_State({
+        ticket,
+        state: new types_1.Maintenance_Kanban_State({ objectId: state }), // pointer
+        tenant: ticket.get("tenant"),
+        user: ticket.get("user"),
+    }).save(null, fetchOptions);
+}
+async function saveDefaultState(ticket, fetchOptions) {
+    const newState = await new Parse.Query(types_1.Maintenance_Kanban_State)
+        .equalTo("isInbox", true)
+        .first(fetchOptions);
+    if (!newState)
+        return;
+    const state = new types_1.Maintenance_Ticket_Kanban_State({
+        ticket,
+        state: newState,
+        tenant: ticket.get("tenant"),
+        user: ticket.get("user"),
+    });
+    await state.save(null, fetchOptions);
+}
+async function getCurrent(ticket) {
+    return await new Parse.Query(types_1.Maintenance_Ticket_Kanban_State_Current)
+        .descending("createdAt")
+        .equalTo("ticket", ticket)
+        .includeAll()
+        .first({ useMasterKey: true });
+}

package/dist/features/openservice/functions/saveTicketTitle.d.ts

@@ -0,0 +1,3 @@
+import { Maintenance_Ticket } from "../../../types";
+import { FetchOptions } from "../types/FetchOptions";
+export declare function saveTicketTitle(ticket: Maintenance_Ticket, fetchOptions: FetchOptions): Promise<void>;