@hmcts/ccd-case-ui-toolkit 7.2.27 → 7.2.28

package/esm2022/lib/shared/components/palette/query-management/services/query-management.service.mjs

@@ -0,0 +1,179 @@
+import { Injectable } from '@angular/core';
+import { Router } from '@angular/router';
+import { QueryCreateContext } from '../models';
+import { SessionStorageService } from '../../../../services';
+import { USER_DETAILS } from '../../../../utils';
+import { QueryManagementUtils } from '../utils/query-management.utils';
+import { CASE_QUERIES_COLLECTION_ID, FIELD_TYPE_COMPLEX, DISPLAY_CONTEXT_READONLY, QM_SELECT_FIRST_COLLECTION, QM_COLLECTION_PROMPT, CIVIL_JURISDICTION } from '../constants/query-management.constants';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "../../../../services";
+export class QueryManagementService {
+    router;
+    sessionStorageService;
+    caseQueriesCollections;
+    fieldId;
+    constructor(router, sessionStorageService) {
+        this.router = router;
+        this.sessionStorageService = sessionStorageService;
+    }
+    generateCaseQueriesCollectionData(formGroup, queryCreateContext, queryItem, messageId // Get the message ID from route params (if present)
+    ) {
+        let currentUserDetails;
+        try {
+            currentUserDetails = JSON.parse(this.sessionStorageService.getItem(USER_DETAILS));
+        }
+        catch (e) {
+            console.error('Could not parse USER_DETAILS from session storage:', e);
+            currentUserDetails = {};
+        }
+        const caseMessage = queryCreateContext === QueryCreateContext.NEW_QUERY
+            ? QueryManagementUtils.getNewQueryData(formGroup, currentUserDetails)
+            : QueryManagementUtils.getRespondOrFollowupQueryData(formGroup, queryItem, currentUserDetails);
+        const isNewQuery = queryCreateContext === QueryCreateContext.NEW_QUERY; // Check if this is a new query
+        // Check if the field ID has been set dynamically
+        if (!this.fieldId) {
+            console.error('Error: Field ID for CaseQueriesCollection not found. Cannot proceed with data generation.');
+            this.router.navigate(['/', 'service-down']);
+            throw new Error('Field ID for CaseQueriesCollection not found. Aborting query data generation.');
+        }
+        // Initialize new query data structure
+        const newQueryData = {};
+        if (this.caseQueriesCollections?.length) {
+            let matchedCollection;
+            // If it's not a new query, try to find the existing collection with the message ID
+            if (!isNewQuery && messageId) {
+                matchedCollection = this.caseQueriesCollections.find((collection) => collection.caseMessages.some((message) => message.value.id === messageId));
+            }
+            if (matchedCollection) {
+                // Append the new case message to the matched collection's caseMessages
+                matchedCollection.caseMessages.push({
+                    id: null,
+                    value: caseMessage
+                });
+                // Add the matched collection to newQueryData
+                newQueryData[this.fieldId] = {
+                    ...matchedCollection, // Keep existing data intact
+                    caseMessages: [...matchedCollection.caseMessages] // Append the updated messages array
+                };
+            }
+            else {
+                // Use partyName from the first collection (assumption: all share the same party)
+                const originalPartyName = this.caseQueriesCollections?.[0]?.partyName ?? currentUserDetails?.name;
+                // If no collection matches, or it's a new query
+                newQueryData[this.fieldId] = {
+                    partyName: originalPartyName,
+                    roleOnCase: '', // Not returned by CCD
+                    caseMessages: [
+                        {
+                            id: null,
+                            value: caseMessage
+                        }
+                    ]
+                };
+                // If caseQueriesCollections is not empty, append its data
+                newQueryData[this.fieldId].caseMessages.push(...this.caseQueriesCollections.flatMap((collection) => collection.caseMessages));
+            }
+        }
+        else {
+            // If there are no existing collections, create a new one (e.g., for new queries)
+            newQueryData[this.fieldId] = {
+                partyName: currentUserDetails?.name || `${currentUserDetails?.forename} ${currentUserDetails?.surname}`, // Not returned by CCD
+                roleOnCase: '', // Not returned by CCD
+                caseMessages: [
+                    {
+                        id: null,
+                        value: caseMessage
+                    }
+                ]
+            };
+        }
+        return newQueryData;
+    }
+    setCaseQueriesCollectionData(eventData, queryCreateContext, caseDetails, messageId) {
+        const resolvedFieldId = this.resolveFieldId(eventData, queryCreateContext, caseDetails, messageId);
+        if (!resolvedFieldId) {
+            console.error('Failed to resolve fieldId for CaseQueriesCollection. Cannot proceed.');
+            return;
+        }
+        this.fieldId = resolvedFieldId;
+        this.caseQueriesCollections = eventData.case_fields.reduce((acc, field) => {
+            if (field.id === this.fieldId) {
+                const extracted = QueryManagementUtils.extractCaseQueriesFromCaseField(field);
+                if (extracted && typeof extracted === 'object') {
+                    acc.push(extracted);
+                }
+            }
+            return acc;
+        }, []);
+    }
+    resolveFieldId(eventData, queryCreateContext, caseDetails, messageId) {
+        // Step 1: Filter candidate fields (must be editable CaseQueriesCollection fields)
+        const candidateFields = eventData?.case_fields?.filter((field) => field.field_type.id === CASE_QUERIES_COLLECTION_ID &&
+            field.field_type.type === FIELD_TYPE_COMPLEX &&
+            field.display_context !== DISPLAY_CONTEXT_READONLY);
+        if (!candidateFields?.length) {
+            console.warn('No editable CaseQueriesCollection fields found.');
+            return null;
+        }
+        const numberOfCollections = candidateFields.length;
+        const jurisdictionId = caseDetails?.case_type?.jurisdiction?.id ?? '';
+        // Step 2: If messageId is present, try to locate the field containing that message
+        if (messageId) {
+            const fieldByMessage = candidateFields.find((field) => field?.value?.caseMessages?.some((msg) => msg?.value?.id === messageId));
+            if (fieldByMessage) {
+                return fieldByMessage.id; // Found the matching field by message ID
+            }
+        }
+        // Step 3: Handle new queries
+        if (queryCreateContext === QueryCreateContext.NEW_QUERY) {
+            // If there's only one collection, use it
+            if (numberOfCollections === 1) {
+                return candidateFields[0].id;
+            }
+            // For multiple collections, use jurisdiction-based resolution strategy
+            if (this.getCollectionSelectionMethod(jurisdictionId) === QM_SELECT_FIRST_COLLECTION) {
+                // Choose the one with the lowest order from the first wizard page
+                const firstOrdered = this.getCaseQueriesCollectionFieldOrderFromWizardPages(eventData);
+                if (firstOrdered) {
+                    return firstOrdered.id;
+                }
+            }
+            else {
+                console.error(`Error: Multiple CaseQueriesCollections are not supported yet for the ${jurisdictionId} jurisdiction`);
+                return null;
+            }
+        }
+        // Step 4: Fallback — if none of the above succeeded
+        console.warn('Could not determine fieldId for context:', queryCreateContext);
+        return null;
+    }
+    getCaseQueriesCollectionFieldOrderFromWizardPages(eventData) {
+        const candidateFields = eventData?.case_fields?.filter((field) => field.field_type.id === CASE_QUERIES_COLLECTION_ID &&
+            field.field_type.type === FIELD_TYPE_COMPLEX &&
+            field.display_context !== DISPLAY_CONTEXT_READONLY);
+        if (!candidateFields?.length) {
+            return undefined;
+        }
+        const firstPageFields = eventData?.wizard_pages?.[0]?.wizard_page_fields;
+        if (!firstPageFields) {
+            return undefined;
+        }
+        return candidateFields
+            .map((field) => {
+            const wizardField = firstPageFields.find((f) => f.case_field_id === field.id);
+            return { field, order: wizardField?.order ?? Number.MAX_SAFE_INTEGER };
+        })
+            .sort((a, b) => a.order - b.order)[0]?.field;
+    }
+    getCollectionSelectionMethod(jurisdiction) {
+        return jurisdiction.toUpperCase() === CIVIL_JURISDICTION ? QM_SELECT_FIRST_COLLECTION : QM_COLLECTION_PROMPT;
+    }
+    static ɵfac = function QueryManagementService_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || QueryManagementService)(i0.ɵɵinject(i1.Router), i0.ɵɵinject(i2.SessionStorageService)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: QueryManagementService, factory: QueryManagementService.ɵfac, providedIn: 'root' });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(QueryManagementService, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], () => [{ type: i1.Router }, { type: i2.SessionStorageService }], null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query-management.service.js","sourceRoot":"","sources":["../../../../../../../../../projects/ccd-case-ui-toolkit/src/lib/shared/components/palette/query-management/services/query-management.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Router } from '@angular/router';\nimport { CaseField, CaseEventTrigger, CaseView } from '../../../../../../lib/shared/domain';\nimport { QmCaseQueriesCollection, QueryCreateContext, QueryListItem, CaseQueriesCollection } from '../models';\nimport { SessionStorageService } from '../../../../services';\nimport { USER_DETAILS } from '../../../../utils';\nimport { QueryManagementUtils } from '../utils/query-management.utils';\nimport {\n  CASE_QUERIES_COLLECTION_ID,\n  FIELD_TYPE_COMPLEX,\n  DISPLAY_CONTEXT_READONLY,\n  QM_SELECT_FIRST_COLLECTION,\n  QM_COLLECTION_PROMPT,\n  CIVIL_JURISDICTION\n} from '../constants/query-management.constants';\nimport { FormGroup } from '@angular/forms';\n\n@Injectable({ providedIn: 'root' })\n\nexport class QueryManagementService {\n  public caseQueriesCollections: CaseQueriesCollection[];\n  public fieldId: string;\n\n  constructor(\n    private readonly router: Router,\n    private readonly sessionStorageService: SessionStorageService\n  ) {}\n\n  public generateCaseQueriesCollectionData(\n    formGroup: FormGroup,\n    queryCreateContext: QueryCreateContext,\n    queryItem: QueryListItem,\n    messageId?: string // Get the message ID from route params (if present)\n  ): QmCaseQueriesCollection {\n    let currentUserDetails;\n\n    try {\n      currentUserDetails = JSON.parse(this.sessionStorageService.getItem(USER_DETAILS));\n    } catch (e) {\n      console.error('Could not parse USER_DETAILS from session storage:', e);\n      currentUserDetails = {};\n    }\n    const caseMessage = queryCreateContext === QueryCreateContext.NEW_QUERY\n      ? QueryManagementUtils.getNewQueryData(formGroup, currentUserDetails)\n      : QueryManagementUtils.getRespondOrFollowupQueryData(formGroup, queryItem, currentUserDetails);\n\n    const isNewQuery = queryCreateContext === QueryCreateContext.NEW_QUERY; // Check if this is a new query\n\n    // Check if the field ID has been set dynamically\n    if (!this.fieldId) {\n      console.error('Error: Field ID for CaseQueriesCollection not found. Cannot proceed with data generation.');\n      this.router.navigate(['/', 'service-down']);\n      throw new Error('Field ID for CaseQueriesCollection not found. Aborting query data generation.');\n    }\n\n    // Initialize new query data structure\n    const newQueryData: QmCaseQueriesCollection = {};\n\n    if (this.caseQueriesCollections?.length) {\n      let matchedCollection;\n\n      // If it's not a new query, try to find the existing collection with the message ID\n      if (!isNewQuery && messageId) {\n        matchedCollection = this.caseQueriesCollections.find((collection) =>\n          collection.caseMessages.some((message) => message.value.id === messageId)\n        );\n      }\n\n      if (matchedCollection) {\n        // Append the new case message to the matched collection's caseMessages\n        matchedCollection.caseMessages.push({\n          id: null,\n          value: caseMessage\n        });\n\n        // Add the matched collection to newQueryData\n        newQueryData[this.fieldId] = {\n          ...matchedCollection, // Keep existing data intact\n          caseMessages: [...matchedCollection.caseMessages] // Append the updated messages array\n        };\n      } else {\n        // Use partyName from the first collection (assumption: all share the same party)\n        const originalPartyName = this.caseQueriesCollections?.[0]?.partyName ?? currentUserDetails?.name;\n\n        // If no collection matches, or it's a new query\n        newQueryData[this.fieldId] = {\n          partyName: originalPartyName,\n          roleOnCase: '', // Not returned by CCD\n          caseMessages: [\n            {\n              id: null,\n              value: caseMessage\n            }\n          ]\n        };\n\n        // If caseQueriesCollections is not empty, append its data\n        newQueryData[this.fieldId].caseMessages.push(\n          ...this.caseQueriesCollections.flatMap((collection) => collection.caseMessages)\n        );\n      }\n    } else {\n      // If there are no existing collections, create a new one (e.g., for new queries)\n      newQueryData[this.fieldId] = {\n        partyName: currentUserDetails?.name || `${currentUserDetails?.forename} ${currentUserDetails?.surname}`, // Not returned by CCD\n        roleOnCase: '', // Not returned by CCD\n        caseMessages: [\n          {\n            id: null,\n            value: caseMessage\n          }\n        ]\n      };\n    }\n    return newQueryData;\n  }\n\n  public setCaseQueriesCollectionData(\n    eventData: CaseEventTrigger,\n    queryCreateContext: QueryCreateContext,\n    caseDetails: CaseView,\n    messageId?: string\n  ): void {\n    const resolvedFieldId = this.resolveFieldId(eventData, queryCreateContext, caseDetails, messageId);\n\n    if (!resolvedFieldId) {\n      console.error('Failed to resolve fieldId for CaseQueriesCollection. Cannot proceed.');\n      return;\n    }\n\n    this.fieldId = resolvedFieldId;\n\n    this.caseQueriesCollections = eventData.case_fields.reduce((acc, field) => {\n      if (field.id === this.fieldId) {\n        const extracted = QueryManagementUtils.extractCaseQueriesFromCaseField(field);\n        if (extracted && typeof extracted === 'object') {\n          acc.push(extracted);\n        }\n      }\n      return acc;\n    }, []);\n  }\n\n  private resolveFieldId(\n    eventData: CaseEventTrigger,\n    queryCreateContext: QueryCreateContext,\n    caseDetails: CaseView,\n    messageId?: string\n  ): string | null {\n  // Step 1: Filter candidate fields (must be editable CaseQueriesCollection fields)\n    const candidateFields = eventData?.case_fields?.filter(\n      (field) =>\n        field.field_type.id === CASE_QUERIES_COLLECTION_ID &&\n      field.field_type.type === FIELD_TYPE_COMPLEX &&\n      field.display_context !== DISPLAY_CONTEXT_READONLY\n    );\n\n    if (!candidateFields?.length) {\n      console.warn('No editable CaseQueriesCollection fields found.');\n      return null;\n    }\n\n    const numberOfCollections = candidateFields.length;\n    const jurisdictionId = caseDetails?.case_type?.jurisdiction?.id ?? '';\n\n    // Step 2: If messageId is present, try to locate the field containing that message\n    if (messageId) {\n      const fieldByMessage = candidateFields.find((field) =>\n        field?.value?.caseMessages?.some((msg) => msg?.value?.id === messageId)\n      );\n      if (fieldByMessage) {\n        return fieldByMessage.id; // Found the matching field by message ID\n      }\n    }\n\n    // Step 3: Handle new queries\n    if (queryCreateContext === QueryCreateContext.NEW_QUERY) {\n    // If there's only one collection, use it\n      if (numberOfCollections === 1) {\n        return candidateFields[0].id;\n      }\n\n      // For multiple collections, use jurisdiction-based resolution strategy\n      if (this.getCollectionSelectionMethod(jurisdictionId) === QM_SELECT_FIRST_COLLECTION) {\n      // Choose the one with the lowest order from the first wizard page\n        const firstOrdered = this.getCaseQueriesCollectionFieldOrderFromWizardPages(eventData);\n        if (firstOrdered) {\n          return firstOrdered.id;\n        }\n      } else {\n        console.error(`Error: Multiple CaseQueriesCollections are not supported yet for the ${jurisdictionId} jurisdiction`);\n        return null;\n      }\n    }\n\n    // Step 4: Fallback — if none of the above succeeded\n    console.warn('Could not determine fieldId for context:', queryCreateContext);\n    return null;\n  }\n\n  private getCaseQueriesCollectionFieldOrderFromWizardPages(eventData: CaseEventTrigger): CaseField | undefined {\n    const candidateFields = eventData?.case_fields?.filter(\n      (field) =>\n        field.field_type.id === CASE_QUERIES_COLLECTION_ID &&\n        field.field_type.type === FIELD_TYPE_COMPLEX &&\n        field.display_context !== DISPLAY_CONTEXT_READONLY\n    );\n\n    if (!candidateFields?.length) {\n      return undefined;\n    }\n\n    const firstPageFields = eventData?.wizard_pages?.[0]?.wizard_page_fields;\n\n    if (!firstPageFields) {\n      return undefined;\n    }\n\n    return candidateFields\n      .map((field) => {\n        const wizardField = firstPageFields.find((f) => f.case_field_id === field.id);\n        return { field, order: wizardField?.order ?? Number.MAX_SAFE_INTEGER };\n      })\n      .sort((a, b) => a.order - b.order)[0]?.field;\n  }\n\n  private getCollectionSelectionMethod(jurisdiction: string): string {\n    return jurisdiction.toUpperCase() === CIVIL_JURISDICTION ? QM_SELECT_FIRST_COLLECTION : QM_COLLECTION_PROMPT;\n  }\n}\n\n"]}