@acorex-platform/module-maintenance-management-client 2.0.0-next.1 → 2.0.0-next.10

package/fesm2022/acorex-platform-module-maintenance-management-client-open-work-order-checklist-form.command-BWzoBPoP.mjs

@@ -0,0 +1,597 @@
+import { AXToastService } from '@acorex/components/toast';
+import { AXTranslationService } from '@acorex/core/translation';
+import { AXPSessionService } from '@acorex-platform/framework-client/auth';
+import { AXPEntityService } from '@acorex-platform/framework-client/layout/entity';
+import { AXPCommandService } from '@acorex-platform/framework-client/runtime';
+import * as i0 from '@angular/core';
+import { inject, Injectable } from '@angular/core';
+import { get, defaultTo, isString } from 'lodash';
+import { RootConfig, resolveChecklistId, readIntervalChecklistId, pickCanonicalChecklistRow, AXM_INTERVAL_CHECKLIST_QUESTIONNAIRE_ID, AXM_INTERVAL_CHECKLIST_CASE_ID, AXM_INTERVAL_CHECKLIST_SESSION_ID, isWorkOrderChecklistOccurrence, AXM_INTERVAL_CHECKLIST_CLAIM, resolveIntervalChecklistViewerMode } from '@acorex-platform/module-maintenance-management-client/contracts';
+import { W as WORK_ORDER_CHECKLIST_ASSET_PREFILL_KEYS } from './acorex-platform-module-maintenance-management-client-acorex-platform-module-maintenance-management-client-DFQ1G-hG.mjs';
+import { r as resolveStartWorkOrderFlowIds, p as persistIntervalTaskCard } from './acorex-platform-module-maintenance-management-client-start-work-order-flow-id.util-CuUi8LBT.mjs';
+
+//#region ---- Imports ----
+//#endregion
+//#region ---- Types ----
+const FILL_ASSESSMENT_COMMAND = 'AssessmentManagement.AssessmentCase:Fill';
+const VIEW_ANSWERS_COMMAND = 'AssessmentManagement.AssessmentSession:ViewAnswers';
+const ASSESSMENT_MODULE = 'AssessmentManagement';
+const ASSESSMENT_CASE = 'AssessmentCase';
+const ASSESSMENT_SESSION = 'AssessmentSession';
+const WORK_ORDER_SUBJECT_TYPE = `${RootConfig.module.name}.${RootConfig.entities.workOrder.name}`;
+const CLAIM_TTL_MS = 15_000;
+//#endregion
+/**
+ * Opens the interval work-order checklist in the assessment viewer.
+ * In Progress creates one AssessmentCase and AssessmentSession, then reuses them and keeps the form editable.
+ * Completed opens that same session with ViewAnswers and does not create, save, or change the card.
+ * The task-board card stays active.
+ */
+class OpenWorkOrderChecklistFormCommand {
+    constructor() {
+        //#region ---- Services & Dependencies ----
+        this.entityService = inject(AXPEntityService);
+        this.commandService = inject(AXPCommandService);
+        this.sessionService = inject(AXPSessionService);
+        this.toastService = inject(AXToastService);
+        this.translationService = inject(AXTranslationService);
+    }
+    //#endregion
+    //#region ---- Command Implementation ----
+    async execute(input) {
+        const ids = resolveStartWorkOrderFlowIds(input);
+        const workOrderId = ids.workOrderId;
+        if (!workOrderId) {
+            return this.fail('Work order id is required.');
+        }
+        const workOrder = await this.loadWorkOrder(workOrderId);
+        if (!workOrder) {
+            return this.fail('Work order not found.');
+        }
+        const currentUserId = this.resolveText(this.sessionService.user?.id);
+        const assigneeUserId = await this.resolveAssigneeUserId(this.resolveText(workOrder.assignedToId));
+        if (!currentUserId || !assigneeUserId || currentUserId !== assigneeUserId) {
+            return this.failKey('@maintenance-management:work-orders.messages.checklist-assignee-only');
+        }
+        const instanceId = ids.sourceInstanceId;
+        if (!instanceId) {
+            return this.fail('Workflow instance id is required.');
+        }
+        const instance = await this.readWorkflowInstance(instanceId);
+        if (!instance) {
+            return this.fail('Workflow instance not found.');
+        }
+        const viewerMode = this.resolveViewerMode(workOrder, instance, ids.sourceBookmarkId, workOrderId);
+        const completed = viewerMode === 'readonly';
+        if (viewerMode === 'unavailable') {
+            return this.failKey('@maintenance-management:work-orders.messages.checklist-requires-in-progress');
+        }
+        const requestedChecklist = resolveChecklistId(get(input, 'checklist')) || resolveChecklistId(get(input, 'options.checklist'));
+        const questionnaireId = readIntervalChecklistId(instance, requestedChecklist);
+        if (!questionnaireId) {
+            return this.failKey('@maintenance-management:work-orders.messages.checklist-missing');
+        }
+        const questionnaire = await this.entityService
+            .withEntity(ASSESSMENT_MODULE, 'Questionnaire')
+            .data()
+            .byKey(questionnaireId);
+        if (!questionnaire) {
+            return this.failKey('@maintenance-management:work-orders.messages.checklist-missing');
+        }
+        try {
+            if (!completed) {
+                await persistIntervalTaskCard(this.entityService, {
+                    instanceId,
+                    workOrderId,
+                    sourceBookmarkId: ids.sourceBookmarkId,
+                    mode: 'in-progress',
+                    assigneeUserId,
+                });
+            }
+            const occurrence = completed
+                ? await this.findExistingOccurrence(instanceId, workOrderId, questionnaireId)
+                : await this.ensureOccurrence({
+                    instanceId,
+                    bookmarkId: ids.sourceBookmarkId,
+                    workOrderId,
+                    workOrderNo: this.resolveText(workOrder.workOrderNo),
+                    questionnaireId,
+                    responderId: currentUserId,
+                });
+            if (!occurrence) {
+                return this.failKey('@maintenance-management:work-orders.messages.checklist-occurrence-invalid');
+            }
+            const validated = await this.loadValidatedOccurrence(occurrence, workOrderId, questionnaireId);
+            if (!validated) {
+                return this.failKey('@maintenance-management:work-orders.messages.checklist-occurrence-invalid');
+            }
+            if (completed) {
+                const viewed = await this.commandService.execute(VIEW_ANSWERS_COMMAND, {
+                    caseId: validated.caseId,
+                    sessionId: validated.sessionId,
+                });
+                return viewed ?? { success: false, message: { text: 'Checklist form could not be opened.' } };
+            }
+            const result = await this.commandService.execute(FILL_ASSESSMENT_COMMAND, {
+                caseId: validated.caseId,
+                sessionId: validated.sessionId,
+                showAs: 'popup',
+                responderId: currentUserId,
+                role: 'responder',
+                allowEditSubmitted: true,
+                readonlyAnswerKeys: [...WORK_ORDER_CHECKLIST_ASSET_PREFILL_KEYS],
+            });
+            return result ?? { success: false, message: { text: 'Checklist form could not be opened.' } };
+        }
+        catch (error) {
+            const message = error instanceof Error
+                ? error.message
+                : await this.translationService.translateAsync('@general:messages.generic.error.description');
+            console.error('[OpenWorkOrderChecklistFormCommand]', error);
+            return this.fail(message);
+        }
+    }
+    //#endregion
+    //#region ---- Occurrence ----
+    /**
+     * Reuses stored or work-order-linked case/session ids.
+     * A claim on the workflow instance stops a second click from creating another pair.
+     */
+    async ensureOccurrence(input, attempt = 0) {
+        const existing = await this.findExistingOccurrence(input.instanceId, input.workOrderId, input.questionnaireId);
+        if (existing) {
+            await this.persistOccurrenceIds(input.instanceId, input.bookmarkId, input.workOrderId, input.questionnaireId, existing);
+            return existing;
+        }
+        if (attempt > 4) {
+            throw new Error('Checklist form could not be opened.');
+        }
+        const token = crypto.randomUUID();
+        const owned = await this.tryClaim(input.instanceId, {
+            token,
+            at: new Date().toISOString(),
+            workOrderId: input.workOrderId,
+            questionnaireId: input.questionnaireId,
+        });
+        if (!owned) {
+            const waited = await this.waitForOccurrence(input.instanceId, input.workOrderId, input.questionnaireId);
+            if (waited) {
+                await this.persistOccurrenceIds(input.instanceId, input.bookmarkId, input.workOrderId, input.questionnaireId, waited);
+                return waited;
+            }
+            return this.ensureOccurrence(input, attempt + 1);
+        }
+        let created = null;
+        try {
+            const chosen = await this.createOrReuseOccurrence(input);
+            created = chosen.created;
+            if (created && created.caseId === chosen.ids.caseId && created.sessionId !== chosen.ids.sessionId) {
+                try {
+                    await this.deleteEmptySession(created.sessionId);
+                }
+                catch (error) {
+                    console.warn('[OpenWorkOrderChecklistFormCommand] unused checklist session was kept', error);
+                }
+            }
+            else if (created && created.caseId !== chosen.ids.caseId) {
+                try {
+                    await this.deleteEmptyOccurrence(created);
+                }
+                catch (error) {
+                    console.warn('[OpenWorkOrderChecklistFormCommand] unused checklist duplicate was kept', error);
+                }
+            }
+            await this.persistOccurrenceIds(input.instanceId, input.bookmarkId, input.workOrderId, input.questionnaireId, chosen.ids);
+            return chosen.ids;
+        }
+        finally {
+            await this.clearClaim(input.instanceId, token);
+        }
+    }
+    /**
+     * Attaches a session to the earliest case for this work order and questionnaire.
+     * A new case is created only when that pair does not exist yet.
+     */
+    async createOrReuseOccurrence(input) {
+        const caseId = await this.findCanonicalCaseId(input.workOrderId, input.questionnaireId);
+        if (caseId) {
+            const existingSessionId = await this.findSessionIdForCase(caseId);
+            if (existingSessionId) {
+                return { ids: { caseId, sessionId: existingSessionId }, created: null };
+            }
+            const sessionId = await this.createSession(caseId, input.responderId);
+            const canonicalSessionId = (await this.findSessionIdForCase(caseId)) || sessionId;
+            return {
+                ids: { caseId, sessionId: canonicalSessionId },
+                created: canonicalSessionId === sessionId
+                    ? null
+                    : { caseId, sessionId },
+            };
+        }
+        const created = await this.createOccurrence(input);
+        const canonicalCaseId = (await this.findCanonicalCaseId(input.workOrderId, input.questionnaireId)) || created.caseId;
+        if (canonicalCaseId === created.caseId) {
+            return { ids: created, created: null };
+        }
+        const existingSessionId = await this.findSessionIdForCase(canonicalCaseId);
+        const sessionId = existingSessionId || (await this.createSession(canonicalCaseId, input.responderId));
+        return {
+            ids: { caseId: canonicalCaseId, sessionId },
+            created,
+        };
+    }
+    async findExistingOccurrence(instanceId, workOrderId, questionnaireId) {
+        const stored = await this.readStoredOccurrence(instanceId, workOrderId, questionnaireId);
+        if (stored) {
+            return stored;
+        }
+        const caseId = await this.findCanonicalCaseId(workOrderId, questionnaireId);
+        if (!caseId) {
+            return null;
+        }
+        const sessionId = await this.findSessionIdForCase(caseId);
+        if (!sessionId) {
+            return null;
+        }
+        return { caseId, sessionId };
+    }
+    async findCanonicalCaseId(workOrderId, questionnaireId) {
+        const page = await this.entityService.withEntity(ASSESSMENT_MODULE, ASSESSMENT_CASE).data().query({
+            skip: 0,
+            take: 50,
+            filter: {
+                logic: 'and',
+                filters: [{ field: 'subjectRef.id', operator: { type: 'equal' }, value: workOrderId }],
+            },
+        });
+        const rows = defaultTo(get(page, 'items'), []).filter((row) => this.caseMatchesWorkOrderChecklist(row, workOrderId, questionnaireId));
+        return this.resolveText(pickCanonicalChecklistRow(rows)?.['id']);
+    }
+    async readStoredOccurrence(instanceId, workOrderId, questionnaireId) {
+        const instance = await this.readWorkflowInstance(instanceId);
+        const properties = this.readProperties(instance);
+        const storedQuestionnaire = resolveChecklistId(properties[AXM_INTERVAL_CHECKLIST_QUESTIONNAIRE_ID]);
+        if (storedQuestionnaire && storedQuestionnaire !== questionnaireId) {
+            return null;
+        }
+        const caseId = this.resolveText(properties[AXM_INTERVAL_CHECKLIST_CASE_ID]);
+        const sessionId = this.resolveText(properties[AXM_INTERVAL_CHECKLIST_SESSION_ID]);
+        if (!caseId || !sessionId) {
+            return null;
+        }
+        return (await this.loadValidatedOccurrence({ caseId, sessionId }, workOrderId, questionnaireId)) ?? null;
+    }
+    async loadValidatedOccurrence(ids, workOrderId, questionnaireId) {
+        const assessmentCase = this.asRecord(await this.entityService.withEntity(ASSESSMENT_MODULE, ASSESSMENT_CASE).data().byKey(ids.caseId));
+        const session = this.asRecord(await this.entityService.withEntity(ASSESSMENT_MODULE, ASSESSMENT_SESSION).data().byKey(ids.sessionId));
+        if (!isWorkOrderChecklistOccurrence({
+            assessmentCase,
+            session,
+            workOrderId,
+            questionnaireId,
+            subjectType: WORK_ORDER_SUBJECT_TYPE,
+        })) {
+            return null;
+        }
+        return { caseId: ids.caseId, sessionId: ids.sessionId };
+    }
+    caseMatchesWorkOrderChecklist(row, workOrderId, questionnaireId) {
+        const subject = this.asRecord(row['subjectRef']);
+        return (this.resolveText(row['questionnaireId']) === questionnaireId &&
+            this.resolveText(subject?.['type']) === WORK_ORDER_SUBJECT_TYPE &&
+            this.resolveText(subject?.['id']) === workOrderId);
+    }
+    /** Sessions are located by case id. Questionnaire id is never the lookup key. */
+    async findSessionIdForCase(caseId) {
+        const page = await this.entityService.withEntity(ASSESSMENT_MODULE, ASSESSMENT_SESSION).data().query({
+            skip: 0,
+            take: 20,
+            filter: {
+                logic: 'and',
+                filters: [{ field: 'caseId', operator: { type: 'equal' }, value: caseId }],
+            },
+        });
+        const rows = defaultTo(get(page, 'items'), []);
+        const session = pickCanonicalChecklistRow(rows);
+        return this.resolveText(session?.['id']);
+    }
+    async createOccurrence(input) {
+        const caseKey = await this.entityService
+            .withEntity(ASSESSMENT_MODULE, ASSESSMENT_CASE)
+            .data()
+            .create({
+            questionnaireId: input.questionnaireId,
+            title: input.workOrderNo ? `${input.workOrderNo} — checklist` : 'Checklist',
+            subjectRef: {
+                type: WORK_ORDER_SUBJECT_TYPE,
+                id: input.workOrderId,
+                title: input.workOrderNo,
+            },
+            statusId: 'active',
+        });
+        const caseId = this.resolveCreatedId(caseKey);
+        if (!caseId) {
+            throw new Error('Checklist case could not be created.');
+        }
+        const sessionId = await this.createSession(caseId, input.responderId);
+        return { caseId, sessionId };
+    }
+    async createSession(caseId, responderId) {
+        const now = new Date();
+        const sessionKey = await this.entityService
+            .withEntity(ASSESSMENT_MODULE, ASSESSMENT_SESSION)
+            .data()
+            .create({
+            caseId,
+            responderId,
+            role: 'responder',
+            answers: {},
+            progressPercentage: 0,
+            answeredQuestionsCount: 0,
+            lastSavedAt: now,
+            startedAt: now,
+            statusId: 'not-started',
+        });
+        const sessionId = this.resolveCreatedId(sessionKey);
+        if (!sessionId) {
+            throw new Error('Checklist session could not be created.');
+        }
+        return sessionId;
+    }
+    async deleteEmptySession(sessionId) {
+        const session = this.asRecord(await this.entityService.withEntity(ASSESSMENT_MODULE, ASSESSMENT_SESSION).data().byKey(sessionId));
+        const answers = this.asRecord(session?.['answers']) ?? {};
+        if (Object.keys(answers).length > 0) {
+            return;
+        }
+        await this.entityService.withEntity(ASSESSMENT_MODULE, ASSESSMENT_SESSION).data().delete(sessionId);
+    }
+    async deleteEmptyOccurrence(ids) {
+        const session = this.asRecord(await this.entityService.withEntity(ASSESSMENT_MODULE, ASSESSMENT_SESSION).data().byKey(ids.sessionId));
+        const answers = this.asRecord(session?.['answers']) ?? {};
+        if (Object.keys(answers).length > 0) {
+            return;
+        }
+        await this.entityService.withEntity(ASSESSMENT_MODULE, ASSESSMENT_SESSION).data().delete(ids.sessionId);
+        await this.entityService.withEntity(ASSESSMENT_MODULE, ASSESSMENT_CASE).data().delete(ids.caseId);
+    }
+    //#endregion
+    //#region ---- Claim & persistence ----
+    async tryClaim(instanceId, claim) {
+        const instance = await this.readWorkflowInstance(instanceId);
+        const current = this.readClaim(this.readProperties(instance));
+        if (current &&
+            current.token !== claim.token &&
+            current.workOrderId === claim.workOrderId &&
+            current.questionnaireId === claim.questionnaireId &&
+            !this.isClaimStale(current)) {
+            return false;
+        }
+        await this.patchProperties(instanceId, { [AXM_INTERVAL_CHECKLIST_CLAIM]: claim });
+        const reread = this.readClaim(this.readProperties(await this.readWorkflowInstance(instanceId)));
+        return reread?.token === claim.token;
+    }
+    async clearClaim(instanceId, token) {
+        const instance = await this.readWorkflowInstance(instanceId);
+        const current = this.readClaim(this.readProperties(instance));
+        if (!current || current.token !== token) {
+            return;
+        }
+        await this.patchProperties(instanceId, { [AXM_INTERVAL_CHECKLIST_CLAIM]: null });
+    }
+    async waitForOccurrence(instanceId, workOrderId, questionnaireId) {
+        for (let attempt = 0; attempt < 20; attempt += 1) {
+            const found = await this.findExistingOccurrence(instanceId, workOrderId, questionnaireId);
+            if (found) {
+                return found;
+            }
+            const claim = this.readClaim(this.readProperties(await this.readWorkflowInstance(instanceId)));
+            if (!claim || this.isClaimStale(claim)) {
+                return null;
+            }
+            await this.delay(250);
+        }
+        return null;
+    }
+    isClaimStale(claim) {
+        const at = Date.parse(claim.at);
+        return Number.isNaN(at) || Date.now() - at > CLAIM_TTL_MS;
+    }
+    async persistOccurrenceIds(instanceId, bookmarkId, workOrderId, questionnaireId, ids) {
+        await this.patchProperties(instanceId, {
+            [AXM_INTERVAL_CHECKLIST_CASE_ID]: ids.caseId,
+            [AXM_INTERVAL_CHECKLIST_SESSION_ID]: ids.sessionId,
+            [AXM_INTERVAL_CHECKLIST_QUESTIONNAIRE_ID]: questionnaireId,
+        }, (bookmark) => {
+            const payload = this.readBookmarkPayload(bookmark);
+            if (!payload) {
+                return bookmark;
+            }
+            const context = this.asRecord(payload['context']) ?? {};
+            if (bookmarkId && this.resolveText(bookmark['id']) !== bookmarkId) {
+                return bookmark;
+            }
+            if (!bookmarkId && this.resolveText(context['workOrderId']) !== workOrderId) {
+                return bookmark;
+            }
+            payload['context'] = {
+                ...context,
+                workOrderId,
+                checklist: questionnaireId,
+                [AXM_INTERVAL_CHECKLIST_CASE_ID]: ids.caseId,
+                [AXM_INTERVAL_CHECKLIST_SESSION_ID]: ids.sessionId,
+                [AXM_INTERVAL_CHECKLIST_QUESTIONNAIRE_ID]: questionnaireId,
+            };
+            return { ...bookmark, payload, payloadJson: JSON.stringify(payload) };
+        });
+    }
+    async patchProperties(instanceId, propertyPatch, mapBookmark) {
+        const instance = await this.readWorkflowInstance(instanceId);
+        if (!instance) {
+            throw new Error('Workflow instance not found.');
+        }
+        const workflowInstance = this.asRecord(instance['workflowInstance']);
+        if (!workflowInstance) {
+            throw new Error('Workflow instance payload is missing.');
+        }
+        const workflowState = { ...(this.asRecord(workflowInstance['workflowState']) ?? {}) };
+        const properties = { ...(this.asRecord(workflowState['properties']) ?? {}), ...propertyPatch };
+        workflowState['properties'] = properties;
+        const bookmarks = this.readBookmarks(instance).map((bookmark) => (mapBookmark ? mapBookmark(bookmark) : bookmark));
+        await this.entityService
+            .withEntity('WorkflowManagement', 'WorkflowInstance')
+            .data()
+            .update(instanceId, {
+            workflowInstance: {
+                ...workflowInstance,
+                workflowState,
+                bookmarks,
+            },
+        });
+    }
+    //#endregion
+    //#region ---- Helpers ----
+    /**
+     * Work-order status wins. A completed card bookmark is used when the stored status is not a plain string.
+     */
+    resolveViewerMode(workOrder, instance, bookmarkId, workOrderId) {
+        const record = workOrder;
+        const fromWorkOrder = resolveIntervalChecklistViewerMode(record['statusId'] ?? record['status']);
+        if (fromWorkOrder !== 'unavailable') {
+            return fromWorkOrder;
+        }
+        return resolveIntervalChecklistViewerMode(this.readCardStatus(instance, bookmarkId, workOrderId));
+    }
+    readCardStatus(instance, bookmarkId, workOrderId) {
+        for (const bookmark of this.readBookmarks(instance)) {
+            if (bookmark['isConsumed'] === true || bookmark['consumed'] === true) {
+                continue;
+            }
+            const payload = this.readBookmarkPayload(bookmark);
+            const context = this.asRecord(payload?.['context']);
+            const bookmarkMatches = bookmarkId
+                ? this.resolveText(bookmark['id']) === bookmarkId
+                : this.resolveText(context?.['workOrderId']) === workOrderId;
+            if (!bookmarkMatches) {
+                continue;
+            }
+            return context?.['statusId'];
+        }
+        return undefined;
+    }
+    async loadWorkOrder(workOrderId) {
+        const loaded = await this.entityService
+            .withEntity(RootConfig.module.name, RootConfig.entities.workOrder.name)
+            .data()
+            .byKey(workOrderId);
+        return loaded ?? null;
+    }
+    async resolveAssigneeUserId(personId) {
+        if (!personId) {
+            return '';
+        }
+        const page = await this.entityService
+            .withEntity('HumanCapitalManagement', 'Employee')
+            .data()
+            .query({
+            skip: 0,
+            take: 1,
+            filter: {
+                logic: 'and',
+                filters: [{ field: 'personId', operator: { type: 'equal' }, value: personId }],
+            },
+        });
+        const employee = defaultTo(get(page, 'items[0]'), null);
+        return this.resolveText(employee?.userId);
+    }
+    async readWorkflowInstance(instanceId) {
+        const loaded = await this.entityService.withEntity('WorkflowManagement', 'WorkflowInstance').data().byKey(instanceId);
+        return this.asRecord(loaded);
+    }
+    readProperties(instance) {
+        const workflowInstance = this.asRecord(instance?.['workflowInstance']);
+        const workflowState = this.asRecord(workflowInstance?.['workflowState']);
+        return this.asRecord(workflowState?.['properties']) ?? {};
+    }
+    readClaim(properties) {
+        const claim = this.asRecord(properties[AXM_INTERVAL_CHECKLIST_CLAIM]);
+        const token = this.resolveText(claim?.['token']);
+        const at = this.resolveText(claim?.['at']);
+        const workOrderId = this.resolveText(claim?.['workOrderId']);
+        const questionnaireId = this.resolveText(claim?.['questionnaireId']);
+        if (!claim || !token || !at || !workOrderId || !questionnaireId) {
+            return null;
+        }
+        return { token, at, workOrderId, questionnaireId };
+    }
+    readBookmarks(instance) {
+        const workflowInstance = this.asRecord(instance?.['workflowInstance']);
+        const bookmarks = workflowInstance?.['bookmarks'];
+        if (!Array.isArray(bookmarks)) {
+            return [];
+        }
+        return bookmarks
+            .map((bookmark) => this.asRecord(bookmark))
+            .filter((bookmark) => !!bookmark);
+    }
+    readBookmarkPayload(bookmark) {
+        const payload = this.asRecord(bookmark['payload']);
+        if (payload) {
+            return { ...payload };
+        }
+        const payloadJson = bookmark['payloadJson'];
+        if (typeof payloadJson !== 'string' || !payloadJson.trim()) {
+            return null;
+        }
+        try {
+            return this.asRecord(JSON.parse(payloadJson));
+        }
+        catch {
+            return null;
+        }
+    }
+    resolveCreatedId(created) {
+        if (typeof created === 'string') {
+            return created.trim();
+        }
+        return this.resolveText(get(created, 'id'));
+    }
+    resolveText(value) {
+        if (!isString(value)) {
+            return '';
+        }
+        return value.trim();
+    }
+    asRecord(value) {
+        if (value != null && typeof value === 'object' && !Array.isArray(value)) {
+            return value;
+        }
+        return null;
+    }
+    delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    async failKey(key) {
+        const text = await this.translationService.translateAsync(key);
+        return this.fail(text);
+    }
+    async fail(text) {
+        this.toastService.show({
+            color: 'warning',
+            title: await this.translationService.translateAsync('@general:messages.generic.warning.title'),
+            content: text,
+            closeButton: true,
+            timeOut: 8000,
+        });
+        return { success: false, message: { text } };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: OpenWorkOrderChecklistFormCommand, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: OpenWorkOrderChecklistFormCommand, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: OpenWorkOrderChecklistFormCommand, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+export { OpenWorkOrderChecklistFormCommand };
+//# sourceMappingURL=acorex-platform-module-maintenance-management-client-open-work-order-checklist-form.command-BWzoBPoP.mjs.map