@hmcts/ccd-case-ui-toolkit 7.0.35-rc1 → 7.0.36-angular-upgrade

package/esm2022/lib/shared/components/palette/case-flag/write-case-flag-field.component.mjs

@@ -0,0 +1,697 @@
+import { Component } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { ActivatedRoute } from '@angular/router';
+import { RpxTranslationService } from 'rpx-xui-translation';
+import { CaseEditDataService } from '../../../commons/case-edit-data/case-edit-data.service';
+import { FieldsUtils } from '../../../services/fields';
+import { CaseFlagStateService } from '../../case-editor/services/case-flag-state.service';
+import { AbstractFieldWriteComponent } from '../base-field/abstract-field-write.component';
+import { CaseFlagDisplayContextParameter, CaseFlagErrorMessage, CaseFlagFieldState, CaseFlagFormFields, CaseFlagStatus } from './enums';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "../../../commons/case-edit-data/case-edit-data.service";
+import * as i3 from "../../case-editor/services/case-flag-state.service";
+import * as i4 from "rpx-xui-translation";
+function WriteCaseFlagFieldComponent_div_0_div_4_Template(rf, ctx) { if (rf & 1) {
+    const _r1 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "div", 5)(1, "ul", 6)(2, "li")(3, "a", 7);
+    i0.ɵɵlistener("click", function WriteCaseFlagFieldComponent_div_0_div_4_Template_a_click_3_listener() { const errorMessage_r2 = i0.ɵɵrestoreView(_r1).$implicit; const ctx_r2 = i0.ɵɵnextContext(2); return i0.ɵɵresetView(ctx_r2.navigateToErrorElement(errorMessage_r2.fieldId)); });
+    i0.ɵɵtext(4);
+    i0.ɵɵpipe(5, "rpxTranslate");
+    i0.ɵɵelementEnd()()()();
+} if (rf & 2) {
+    const errorMessage_r2 = ctx.$implicit;
+    i0.ɵɵadvance(4);
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(5, 1, errorMessage_r2.description));
+} }
+function WriteCaseFlagFieldComponent_div_0_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div", 2)(1, "h2", 3);
+    i0.ɵɵtext(2);
+    i0.ɵɵpipe(3, "rpxTranslate");
+    i0.ɵɵelementEnd();
+    i0.ɵɵtemplate(4, WriteCaseFlagFieldComponent_div_0_div_4_Template, 6, 3, "div", 4);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r2 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(2);
+    i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(3, 2, "There is a problem"), " ");
+    i0.ɵɵadvance(2);
+    i0.ɵɵproperty("ngForOf", ctx_r2.errorMessages);
+} }
+function WriteCaseFlagFieldComponent_div_1_ng_container_2_Template(rf, ctx) { if (rf & 1) {
+    const _r4 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementContainerStart(0);
+    i0.ɵɵelementStart(1, "ccd-select-flag-location", 11);
+    i0.ɵɵlistener("caseFlagStateEmitter", function WriteCaseFlagFieldComponent_div_1_ng_container_2_Template_ccd_select_flag_location_caseFlagStateEmitter_1_listener($event) { i0.ɵɵrestoreView(_r4); const ctx_r2 = i0.ɵɵnextContext(2); return i0.ɵɵresetView(ctx_r2.onCaseFlagStateEmitted($event)); });
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementContainerEnd();
+} if (rf & 2) {
+    const ctx_r2 = i0.ɵɵnextContext(2);
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("formGroup", ctx_r2.caseFlagParentFormGroup)("flagsData", ctx_r2.flagsData)("isDisplayContextParameterExternal", ctx_r2.isDisplayContextParameterExternal);
+} }
+function WriteCaseFlagFieldComponent_div_1_ng_container_3_Template(rf, ctx) { if (rf & 1) {
+    const _r5 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementContainerStart(0);
+    i0.ɵɵelementStart(1, "ccd-select-flag-type", 12);
+    i0.ɵɵlistener("caseFlagStateEmitter", function WriteCaseFlagFieldComponent_div_1_ng_container_3_Template_ccd_select_flag_type_caseFlagStateEmitter_1_listener($event) { i0.ɵɵrestoreView(_r5); const ctx_r2 = i0.ɵɵnextContext(2); return i0.ɵɵresetView(ctx_r2.onCaseFlagStateEmitted($event)); })("flagCommentsOptionalEmitter", function WriteCaseFlagFieldComponent_div_1_ng_container_3_Template_ccd_select_flag_type_flagCommentsOptionalEmitter_1_listener($event) { i0.ɵɵrestoreView(_r5); const ctx_r2 = i0.ɵɵnextContext(2); return i0.ɵɵresetView(ctx_r2.onFlagCommentsOptionalEmitted($event)); });
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementContainerEnd();
+} if (rf & 2) {
+    const ctx_r2 = i0.ɵɵnextContext(2);
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("formGroup", ctx_r2.caseFlagParentFormGroup)("jurisdiction", ctx_r2.jurisdiction)("caseTypeId", ctx_r2.caseTypeId)("hmctsServiceId", ctx_r2.hmctsServiceId)("isDisplayContextParameterExternal", ctx_r2.isDisplayContextParameterExternal)("isDisplayContextParameter2Point1Enabled", ctx_r2.isDisplayContextParameter2Point1Enabled)("selectedFlagsLocation", ctx_r2.selectedFlagsLocation);
+} }
+function WriteCaseFlagFieldComponent_div_1_ng_container_4_Template(rf, ctx) { if (rf & 1) {
+    const _r6 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementContainerStart(0);
+    i0.ɵɵelementStart(1, "ccd-search-language-interpreter", 13);
+    i0.ɵɵlistener("caseFlagStateEmitter", function WriteCaseFlagFieldComponent_div_1_ng_container_4_Template_ccd_search_language_interpreter_caseFlagStateEmitter_1_listener($event) { i0.ɵɵrestoreView(_r6); const ctx_r2 = i0.ɵɵnextContext(2); return i0.ɵɵresetView(ctx_r2.onCaseFlagStateEmitted($event)); });
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementContainerEnd();
+} if (rf & 2) {
+    const ctx_r2 = i0.ɵɵnextContext(2);
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("formGroup", ctx_r2.caseFlagParentFormGroup)("flagType", ctx_r2.flagType);
+} }
+function WriteCaseFlagFieldComponent_div_1_ng_container_5_Template(rf, ctx) { if (rf & 1) {
+    const _r7 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementContainerStart(0);
+    i0.ɵɵelementStart(1, "ccd-add-comments", 14);
+    i0.ɵɵlistener("caseFlagStateEmitter", function WriteCaseFlagFieldComponent_div_1_ng_container_5_Template_ccd_add_comments_caseFlagStateEmitter_1_listener($event) { i0.ɵɵrestoreView(_r7); const ctx_r2 = i0.ɵɵnextContext(2); return i0.ɵɵresetView(ctx_r2.onCaseFlagStateEmitted($event)); });
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementContainerEnd();
+} if (rf & 2) {
+    const ctx_r2 = i0.ɵɵnextContext(2);
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("formGroup", ctx_r2.caseFlagParentFormGroup)("optional", ctx_r2.flagCommentsOptional)("isDisplayContextParameterExternal", ctx_r2.isDisplayContextParameterExternal)("isDisplayContextParameter2Point1Enabled", ctx_r2.isDisplayContextParameter2Point1Enabled);
+} }
+function WriteCaseFlagFieldComponent_div_1_ng_container_6_Template(rf, ctx) { if (rf & 1) {
+    const _r8 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementContainerStart(0);
+    i0.ɵɵelementStart(1, "ccd-confirm-flag-status", 15);
+    i0.ɵɵlistener("caseFlagStateEmitter", function WriteCaseFlagFieldComponent_div_1_ng_container_6_Template_ccd_confirm_flag_status_caseFlagStateEmitter_1_listener($event) { i0.ɵɵrestoreView(_r8); const ctx_r2 = i0.ɵɵnextContext(2); return i0.ɵɵresetView(ctx_r2.onCaseFlagStateEmitted($event)); });
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementContainerEnd();
+} if (rf & 2) {
+    const ctx_r2 = i0.ɵɵnextContext(2);
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("formGroup", ctx_r2.caseFlagParentFormGroup)("defaultStatus", ctx_r2.flagType.defaultStatus);
+} }
+function WriteCaseFlagFieldComponent_div_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div", 8)(1, "div", 9);
+    i0.ɵɵtemplate(2, WriteCaseFlagFieldComponent_div_1_ng_container_2_Template, 2, 3, "ng-container", 10)(3, WriteCaseFlagFieldComponent_div_1_ng_container_3_Template, 2, 7, "ng-container", 10)(4, WriteCaseFlagFieldComponent_div_1_ng_container_4_Template, 2, 2, "ng-container", 10)(5, WriteCaseFlagFieldComponent_div_1_ng_container_5_Template, 2, 4, "ng-container", 10)(6, WriteCaseFlagFieldComponent_div_1_ng_container_6_Template, 2, 2, "ng-container", 10);
+    i0.ɵɵelementEnd()();
+} if (rf & 2) {
+    const ctx_r2 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("formGroup", ctx_r2.formGroup);
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("ngSwitch", ctx_r2.fieldState);
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("ngSwitchCase", ctx_r2.caseFlagFieldState.FLAG_LOCATION);
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("ngSwitchCase", ctx_r2.caseFlagFieldState.FLAG_TYPE);
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("ngSwitchCase", ctx_r2.caseFlagFieldState.FLAG_LANGUAGE_INTERPRETER);
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("ngSwitchCase", ctx_r2.caseFlagFieldState.FLAG_COMMENTS);
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("ngSwitchCase", ctx_r2.caseFlagFieldState.FLAG_STATUS);
+} }
+function WriteCaseFlagFieldComponent_div_2_ng_container_2_Template(rf, ctx) { if (rf & 1) {
+    const _r9 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementContainerStart(0);
+    i0.ɵɵelementStart(1, "ccd-manage-case-flags", 16);
+    i0.ɵɵlistener("caseFlagStateEmitter", function WriteCaseFlagFieldComponent_div_2_ng_container_2_Template_ccd_manage_case_flags_caseFlagStateEmitter_1_listener($event) { i0.ɵɵrestoreView(_r9); const ctx_r2 = i0.ɵɵnextContext(2); return i0.ɵɵresetView(ctx_r2.onCaseFlagStateEmitted($event)); });
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementContainerEnd();
+} if (rf & 2) {
+    const ctx_r2 = i0.ɵɵnextContext(2);
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("formGroup", ctx_r2.caseFlagParentFormGroup)("flagsData", ctx_r2.flagsData)("caseTitle", ctx_r2.caseTitle)("displayContextParameter", ctx_r2.displayContextParameter);
+} }
+function WriteCaseFlagFieldComponent_div_2_ng_container_3_Template(rf, ctx) { if (rf & 1) {
+    const _r10 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementContainerStart(0);
+    i0.ɵɵelementStart(1, "ccd-update-flag", 17);
+    i0.ɵɵlistener("caseFlagStateEmitter", function WriteCaseFlagFieldComponent_div_2_ng_container_3_Template_ccd_update_flag_caseFlagStateEmitter_1_listener($event) { i0.ɵɵrestoreView(_r10); const ctx_r2 = i0.ɵɵnextContext(2); return i0.ɵɵresetView(ctx_r2.onCaseFlagStateEmitted($event)); });
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementContainerEnd();
+} if (rf & 2) {
+    const ctx_r2 = i0.ɵɵnextContext(2);
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("formGroup", ctx_r2.caseFlagParentFormGroup)("displayContextParameter", ctx_r2.displayContextParameter);
+} }
+function WriteCaseFlagFieldComponent_div_2_ng_container_4_Template(rf, ctx) { if (rf & 1) {
+    const _r11 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementContainerStart(0);
+    i0.ɵɵelementStart(1, "ccd-update-flag-add-translation-form", 18);
+    i0.ɵɵlistener("caseFlagStateEmitter", function WriteCaseFlagFieldComponent_div_2_ng_container_4_Template_ccd_update_flag_add_translation_form_caseFlagStateEmitter_1_listener($event) { i0.ɵɵrestoreView(_r11); const ctx_r2 = i0.ɵɵnextContext(2); return i0.ɵɵresetView(ctx_r2.onCaseFlagStateEmitted($event)); });
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementContainerEnd();
+} if (rf & 2) {
+    const ctx_r2 = i0.ɵɵnextContext(2);
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("formGroup", ctx_r2.caseFlagParentFormGroup);
+} }
+function WriteCaseFlagFieldComponent_div_2_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div", 8)(1, "div", 9);
+    i0.ɵɵtemplate(2, WriteCaseFlagFieldComponent_div_2_ng_container_2_Template, 2, 4, "ng-container", 10)(3, WriteCaseFlagFieldComponent_div_2_ng_container_3_Template, 2, 2, "ng-container", 10)(4, WriteCaseFlagFieldComponent_div_2_ng_container_4_Template, 2, 1, "ng-container", 10);
+    i0.ɵɵelementEnd()();
+} if (rf & 2) {
+    const ctx_r2 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("formGroup", ctx_r2.formGroup);
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("ngSwitch", ctx_r2.fieldState);
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("ngSwitchCase", ctx_r2.caseFlagFieldState.FLAG_MANAGE_CASE_FLAGS);
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("ngSwitchCase", ctx_r2.caseFlagFieldState.FLAG_UPDATE);
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("ngSwitchCase", ctx_r2.caseFlagFieldState.FLAG_UPDATE_WELSH_TRANSLATION);
+} }
+export class WriteCaseFlagFieldComponent extends AbstractFieldWriteComponent {
+    route;
+    caseEditDataService;
+    caseFlagStateService;
+    rpxTranslationService;
+    fieldState;
+    caseFlagFieldState = CaseFlagFieldState;
+    errorMessages = [];
+    flagsData;
+    selectedFlag;
+    caseFlagParentFormGroup;
+    flagCommentsOptional = false;
+    jurisdiction;
+    caseTypeId;
+    hmctsServiceId;
+    isDisplayContextParameterUpdate;
+    isDisplayContextParameterExternal;
+    isDisplayContextParameter2Point1Enabled;
+    caseTitle;
+    caseTitleSubscription;
+    displayContextParameter;
+    determinedLocation;
+    allCaseFlagStagesCompleted = false;
+    // Code for "Other" flag type as defined in Reference Data
+    otherFlagTypeCode = 'OT0001';
+    selectedManageCaseLocation = 'selectedManageCaseLocation';
+    caseNameMissing = 'Case name missing';
+    get flagType() {
+        return this.caseFlagParentFormGroup?.value.flagType;
+    }
+    get selectedFlagsLocation() {
+        return this.caseFlagParentFormGroup?.value.selectedLocation;
+    }
+    set selectedFlagsLocation(selectedLocation) {
+        if (this.caseFlagParentFormGroup) {
+            this.caseFlagParentFormGroup.value.selectedLocation = selectedLocation;
+        }
+    }
+    constructor(route, caseEditDataService, caseFlagStateService, rpxTranslationService) {
+        super();
+        this.route = route;
+        this.caseEditDataService = caseEditDataService;
+        this.caseFlagStateService = caseFlagStateService;
+        this.rpxTranslationService = rpxTranslationService;
+    }
+    ngOnInit() {
+        // If it is start of the journey or navigation from check your answers page then fieldStateToNavigate property
+        // in case flag state service will contain the field state to navigate based on create or manage journey
+        this.fieldState = this.caseFlagStateService.fieldStateToNavigate;
+        if (this.fieldState === undefined ||
+            this.fieldState === CaseFlagFieldState.FLAG_LOCATION ||
+            this.fieldState === CaseFlagFieldState.FLAG_MANAGE_CASE_FLAGS) {
+            const params = this.route.snapshot.params;
+            // Clear the form group, field state to navigate and set the page location
+            this.caseFlagStateService.resetCache(`../${params['eid']}/${params['page']}`);
+        }
+        // Reassign the form group from the case flag state service
+        this.caseFlagParentFormGroup = this.caseFlagStateService.formGroup;
+        // Clear form validation errors as a new page will be rendered based on field state
+        this.caseEditDataService.clearFormValidationErrors();
+        // Check for existing FlagLauncher control in parent and remove it - this is the only way to ensure its invalidity
+        // is set correctly at the start, when the component is reloaded and the control is re-registered. Otherwise, the
+        // validator state gets carried over
+        if (this.formGroup && this.formGroup.get(this.caseField.id)) {
+            this.formGroup.removeControl(this.caseField.id);
+        }
+        // From this point, this.formGroup refers to the FormGroup for the FlagLauncher field, not the parent FormGroup
+        this.formGroup = this.registerControl(new FormGroup({}, {
+            validators: (_) => {
+                if (!this.allCaseFlagStagesCompleted) {
+                    // Return an error to mark the FormGroup as invalid if not all Case Flag stages have been completed
+                    return { notAllCaseFlagStagesCompleted: true };
+                }
+                return null;
+            }
+        }), true);
+        // Get the case type ID from the CaseView object in the snapshot data (required for retrieving the available flag
+        // types for a case)
+        if (this.route.snapshot.data.case && this.route.snapshot.data.case.case_type) {
+            this.caseTypeId = this.route.snapshot.data.case.case_type.id;
+            // Get the jurisdiction (required for retrieving the available flag types if unable to determine using case type ID)
+            if (this.route.snapshot.data.case.case_type.jurisdiction) {
+                this.jurisdiction = this.route.snapshot.data.case.case_type.jurisdiction.id;
+            }
+        }
+        // Extract all flags-related data from the CaseEventTrigger object in the snapshot data
+        if (this.route.snapshot.data.eventTrigger) {
+            // Get the HMCTSServiceId from supplementary data, if it exists (required for retrieving the available flag types in
+            // the first instance, only falling back on case type ID or jurisdiction if it's not present)
+            if (this.route.snapshot.data.eventTrigger.supplementary_data
+                && this.route.snapshot.data.eventTrigger.supplementary_data.HMCTSServiceId) {
+                this.hmctsServiceId = this.route.snapshot.data.eventTrigger.supplementary_data.HMCTSServiceId;
+            }
+            if (this.route.snapshot.data.eventTrigger.case_fields) {
+                this.flagsData = (this.route.snapshot.data.eventTrigger.case_fields)
+                    .reduce((flags, caseField) => FieldsUtils.extractFlagsDataFromCaseField(flags, caseField, caseField.id, caseField), []);
+                // Set displayContextParameter (to be passed as an input to ManageCaseFlagsComponent for setting correct title)
+                this.displayContextParameter =
+                    this.setDisplayContextParameter(this.route.snapshot.data.eventTrigger.case_fields);
+                // Set boolean indicating the display_context_parameter is "update"
+                this.isDisplayContextParameterUpdate = this.setDisplayContextParameterUpdate(this.displayContextParameter);
+                // Set boolean indicating the display_context_parameter is "external"
+                this.isDisplayContextParameterExternal = this.setDisplayContextParameterExternal(this.displayContextParameter);
+                // Set boolean indicating the display_context_parameter is Case Flags v2.1 enabled
+                this.isDisplayContextParameter2Point1Enabled = this.setDisplayContextParameter2Point1Enabled(this.displayContextParameter);
+                // Set starting field state if fieldState not the right value
+                if (!this.fieldState) {
+                    this.fieldState = this.isDisplayContextParameterUpdate ? CaseFlagFieldState.FLAG_MANAGE_CASE_FLAGS : CaseFlagFieldState.FLAG_LOCATION;
+                }
+                // Get case title, to be used by child components
+                this.caseTitleSubscription = this.caseEditDataService.caseTitle$.subscribe({
+                    next: title => {
+                        this.caseTitle = title?.length > 0 ? title : this.caseNameMissing;
+                    }
+                });
+            }
+        }
+    }
+    setDisplayContextParameterUpdate(displayContextParameter) {
+        return displayContextParameter === CaseFlagDisplayContextParameter.UPDATE ||
+            displayContextParameter === CaseFlagDisplayContextParameter.UPDATE_EXTERNAL ||
+            displayContextParameter === CaseFlagDisplayContextParameter.UPDATE_2_POINT_1;
+    }
+    setDisplayContextParameterExternal(displayContextParameter) {
+        return displayContextParameter === CaseFlagDisplayContextParameter.CREATE_EXTERNAL ||
+            displayContextParameter === CaseFlagDisplayContextParameter.UPDATE_EXTERNAL;
+    }
+    setDisplayContextParameter2Point1Enabled(displayContextParameter) {
+        return displayContextParameter === CaseFlagDisplayContextParameter.CREATE_2_POINT_1 ||
+            displayContextParameter === CaseFlagDisplayContextParameter.UPDATE_2_POINT_1;
+    }
+    onCaseFlagStateEmitted(caseFlagState) {
+        this.caseEditDataService.clearFormValidationErrors();
+        this.errorMessages = caseFlagState.errorMessages;
+        this.selectedFlag = caseFlagState.selectedFlag;
+        // Validation succeeded; proceed to next state or final review stage ("Check your answers")
+        if (this.errorMessages.length === 0) {
+            if (this.canMoveToFinalReviewStage(caseFlagState)) {
+                this.moveToFinalReviewStage();
+                // Don't move to next state if current state is CaseFlagFieldState.FLAG_TYPE and the flag type is a parent - this
+                // means the user needs to select from the next set of flag types before they can move on
+            }
+            else if (!caseFlagState.isParentFlagType) {
+                // Proceed to next state
+                this.proceedToNextState();
+            }
+        }
+    }
+    canMoveToFinalReviewStage(caseFlagState) {
+        // If the journey is request support or manage support
+        // and the current state is either CaseFlagFieldState.FLAG_COMMENTS or CaseFlagFieldState.FLAG_UPDATE
+        // then move to final review stage
+        if (this.isDisplayContextParameterExternal) {
+            return caseFlagState.currentCaseFlagFieldState === CaseFlagFieldState.FLAG_COMMENTS ||
+                caseFlagState.currentCaseFlagFieldState === CaseFlagFieldState.FLAG_UPDATE;
+        }
+        // If the current state is one of:
+        // * CaseFlagFieldState.FLAG_STATUS AND Case Flags v2.1 is enabled
+        // * CaseFlagFieldState.FLAG_COMMENTS AND Case Flags v2.1 is not enabled
+        // * CaseFlagFieldState.FLAG_UPDATE and Welsh translation checkbox is not selected
+        // * CaseFlagFieldState.FLAG_UPDATE_WELSH_TRANSLATION
+        // then move to final review stage
+        return (caseFlagState.currentCaseFlagFieldState ===
+            CaseFlagFieldState.FLAG_STATUS && this.isDisplayContextParameter2Point1Enabled) ||
+            (caseFlagState.currentCaseFlagFieldState ===
+                CaseFlagFieldState.FLAG_COMMENTS && !this.isDisplayContextParameter2Point1Enabled) ||
+            (caseFlagState.currentCaseFlagFieldState === CaseFlagFieldState.FLAG_UPDATE &&
+                !this.caseFlagParentFormGroup.get(CaseFlagFormFields.IS_WELSH_TRANSLATION_NEEDED)?.value) ||
+            caseFlagState.currentCaseFlagFieldState === CaseFlagFieldState.FLAG_UPDATE_WELSH_TRANSLATION;
+    }
+    proceedToNextState() {
+        if (!this.isAtFinalState()) {
+            // Skip the "language interpreter" state if current state is CaseFlagFieldState.FLAG_TYPE and the flag type doesn't
+            // have a "list of values" - currently, this is present only for those flag types that require language interpreter
+            // selection
+            if (this.fieldState === CaseFlagFieldState.FLAG_TYPE && !this.flagType?.listOfValues) {
+                this.fieldState = CaseFlagFieldState.FLAG_COMMENTS;
+            }
+            else {
+                this.fieldState++;
+            }
+        }
+    }
+    setFlagsCaseFieldValue() {
+        // tslint:disable-next-line: switch-default
+        switch (this.fieldState) {
+            case CaseFlagFieldState.FLAG_STATUS:
+                this.addFlagToCollection();
+                break;
+            case CaseFlagFieldState.FLAG_COMMENTS:
+                if (this.isDisplayContextParameterExternal || !this.isDisplayContextParameter2Point1Enabled) {
+                    this.addFlagToCollection();
+                }
+                break;
+            case this.manageFlagFinalState:
+                this.updateFlagInCollection();
+                break;
+        }
+    }
+    addFlagToCollection() {
+        // Ensure no more than one new flag is being added at a time, by iterating through each Flags case field and removing
+        // any previous entry from the details array where that entry has no id (hence it is new - and there should be only
+        // one such entry). (This scenario occurs if the user repeats the Case Flag creation journey by using the "Change"
+        // link and selects either the same flag location as before or a different one.)
+        this.flagsData.forEach(instance => {
+            // Use the pathToFlagsFormGroup property for each Flags case field to drill down to the correct part of the
+            // CaseField value to remove the new value from
+            let value = instance.caseField?.value;
+            const pathToValue = instance.pathToFlagsFormGroup;
+            // Root-level Flags CaseFields don't have a dot-delimited path - just the CaseField ID itself - so don't drill down
+            if (pathToValue.indexOf('.') > -1) {
+                pathToValue.slice(pathToValue.indexOf('.') + 1).split('.').forEach(part => value = value[part]);
+            }
+            if (value?.details?.length > 0) {
+                const indexOfNewFlagDetail = value.details.findIndex(element => !element.hasOwnProperty('id'));
+                if (indexOfNewFlagDetail > -1) {
+                    value.details.splice(indexOfNewFlagDetail, 1);
+                }
+            }
+        });
+        const formValues = this.caseFlagParentFormGroup?.value;
+        // Determine the correct location - internal or external - for the new flag. If returned as undefined, this
+        // indicates a configuration error with the external `Flags` object instance
+        this.determinedLocation =
+            this.determineLocationForFlag(!this.isDisplayContextParameterExternal, this.selectedFlagsLocation, formValues);
+        // Do not mutate this.selectedFlagsLocation; if this.selectedFlagsLocation becomes undefined,
+        // determineLocationForFlag() will no longer do anything when called with it - and the appropriate error message will
+        // not be redisplayed if the user clicks "Next" again on the "Add comments" page, after the error is first shown
+        if (this.determinedLocation) {
+            const path = this.determinedLocation.pathToFlagsFormGroup;
+            const flagDataRef = this.flagsData.find(item => item.pathToFlagsFormGroup === path);
+            let flagsCaseFieldValue = flagDataRef.caseField?.value;
+            // Use the pathToFlagsFormGroup property from the selected flag location to drill down to the correct part of the
+            // CaseField value to apply changes to
+            // Root-level Flags CaseFields don't have a dot-delimited path - just the CaseField ID itself - so don't drill down
+            if (path.indexOf('.') > -1) {
+                path.slice(path.indexOf('.') + 1).split('.').forEach(part => flagsCaseFieldValue = flagsCaseFieldValue[part]);
+            }
+            // If the CaseField for the selected flags location has no value, set it to an empty object so it can be populated
+            // with flag details
+            if (!flagsCaseFieldValue) {
+                flagDataRef.caseField.value = {};
+                flagsCaseFieldValue = flagDataRef.caseField.value;
+            }
+            // Create a details array if one does not exist
+            if (!flagsCaseFieldValue.hasOwnProperty('details')) {
+                flagsCaseFieldValue.details = [];
+            }
+            // Populate new FlagDetail instance and add to the Flags data within the CaseField instance of the selected flag
+            // location
+            flagsCaseFieldValue.details.push({ value: this.populateNewFlagDetailInstance() });
+        }
+    }
+    /**
+     * Determines the correct location (i.e. either the internal or external instance of a `Flags` object) for a new flag,
+     * according to the following:
+     *
+     * * Whether the user is internal or external (no effect for external users because they can access only the external
+     * instance)
+     * * The existence of two `Flags` objects - one internal, one external - linked by the same `groupId`;
+     * * For flags of type "Other", whether "only visible to HMCTS staff" has been selected or not ("Other" defaults to
+     * externally visible);
+     * * For all other flag types, the value of the `externallyAvailable` attribute.
+     *
+     * If the user is internal then the new flag should be assigned to the external `Flags` instance if:
+     * * Such an instance exists, AND
+     * * The flag type is "Other" and "only visible to HMCTS staff" was not selected, OR
+     * * The flag type is not "Other" and `externallyAvailable` is `true`.
+     *
+     * @param isInternalUser Whether the current user is internal or not
+     * @param selectedFlagsLocation The currently selected location for the new flag
+     * @param formValues All the values from the `caseFlagParentFormGroup`
+     * @returns The correctly determined location: either the internal or external location (if one exists) where a groupId
+     * is present; the original location otherwise. **Note:** If the external location is returned as undefined, this
+     * indicates a configuration error
+     */
+    determineLocationForFlag(isInternalUser, selectedFlagsLocation, formValues) {
+        if (isInternalUser && selectedFlagsLocation?.flags?.groupId) {
+            if ((formValues?.flagType?.flagCode === this.otherFlagTypeCode && !formValues?.flagIsVisibleInternallyOnly) ||
+                (formValues?.flagType?.flagCode !== this.otherFlagTypeCode && formValues?.flagType?.externallyAvailable)) {
+                // If necessary, find the corresponding flags object with the same groupId and external visibility (should be
+                // only one unless misconfigured)
+                const location = selectedFlagsLocation.flags.visibility?.toLowerCase() === 'external'
+                    ? selectedFlagsLocation
+                    : this.flagsData.filter((f) => f.flags?.groupId === selectedFlagsLocation.flags.groupId &&
+                        f.flags?.visibility?.toLowerCase() === 'external')?.[0];
+                // If location is not truthy, set an error message and make caseFlagParentFormGroup invalid to prevent
+                // navigation to the summary page (by not triggering the submit event)
+                if (!location) {
+                    this.errorMessages.push({
+                        title: '',
+                        description: CaseFlagErrorMessage.NO_EXTERNAL_FLAGS_COLLECTION
+                    });
+                    this.caseFlagParentFormGroup.setErrors({
+                        noExternalCollection: true
+                    });
+                }
+                return location;
+            }
+            else {
+                // If necessary, find the corresponding flags object with the same groupId and internal visibility (should be
+                // only one unless misconfigured); assumed to be internal if visibility attribute is null or undefined
+                const location = selectedFlagsLocation.flags.visibility?.toLowerCase() !== 'external'
+                    ? selectedFlagsLocation
+                    : this.flagsData.filter((f) => f.flags?.groupId === selectedFlagsLocation.flags.groupId &&
+                        f.flags?.visibility?.toLowerCase() !== 'external')?.[0];
+                // If location is not truthy, set an error message and make caseFlagParentFormGroup invalid to prevent
+                // navigation to the summary page (by not triggering the submit event)
+                if (!location) {
+                    this.errorMessages.push({
+                        title: '',
+                        description: CaseFlagErrorMessage.NO_INTERNAL_FLAGS_COLLECTION
+                    });
+                    this.caseFlagParentFormGroup.setErrors({
+                        noInternalCollection: true
+                    });
+                }
+                return location;
+            }
+        }
+        return selectedFlagsLocation;
+    }
+    updateFlagInCollection() {
+        // Ensure no more than one flag is being updated at a time, by iterating through each Flags case field and resetting
+        // the description, comments, status, and date/time modified (if present) for each entry in the details array, with
+        // original values from the corresponding formatted_value property. (This scenario occurs if the user repeats the
+        // Manage Case Flag journey by using the "Change" link and selects a different flag to update.)
+        this.flagsData.forEach(instance => {
+            // Use the pathToFlagsFormGroup property for each Flags case field to drill down to the correct part of the
+            // CaseField value for which to restore the original values
+            let value = instance.caseField?.value;
+            let formattedValue = instance.caseField?.formatted_value;
+            const pathToValue = instance.pathToFlagsFormGroup;
+            // Root-level Flags CaseFields don't have a dot-delimited path - just the CaseField ID itself - so don't drill down
+            if (pathToValue.indexOf('.') > -1) {
+                pathToValue.slice(pathToValue.indexOf('.') + 1).split('.').forEach(part => {
+                    value = value[part];
+                    if (formattedValue && FieldsUtils.isNonEmptyObject(formattedValue)) {
+                        formattedValue = formattedValue[part];
+                    }
+                });
+            }
+            if (value?.details?.length > 0 && formattedValue && FieldsUtils.isNonEmptyObject(formattedValue)) {
+                value.details.forEach(flagDetail => {
+                    const originalFlagDetail = formattedValue.details?.find(detail => detail.id === flagDetail.id);
+                    if (originalFlagDetail) {
+                        flagDetail.value.otherDescription = originalFlagDetail.value?.otherDescription || null;
+                        flagDetail.value.otherDescription_cy = originalFlagDetail.value?.otherDescription_cy || null;
+                        flagDetail.value.flagComment = originalFlagDetail.value?.flagComment || null;
+                        flagDetail.value.flagComment_cy = originalFlagDetail.value?.flagComment_cy || null;
+                        flagDetail.value.flagUpdateComment = originalFlagDetail.value?.flagUpdateComment || null;
+                        flagDetail.value.status = originalFlagDetail.value?.status;
+                        flagDetail.value.dateTimeModified = originalFlagDetail.value?.dateTimeModified || null;
+                    }
+                });
+            }
+        });
+        if (!this.selectedFlag) {
+            this.selectedFlag = this.formGroup.get(this.selectedManageCaseLocation).value;
+        }
+        let flagsCaseFieldValue = this.selectedFlag.caseField?.value;
+        // Use the pathToFlagsFormGroup property from the selected flag location to drill down to the correct part of the
+        // CaseField value to apply changes to
+        const path = this.selectedFlag.pathToFlagsFormGroup;
+        // Root-level Flags CaseFields don't have a dot-delimited path - just the CaseField ID itself - so don't drill down
+        if (path.indexOf('.') > -1) {
+            path.slice(path.indexOf('.') + 1).split('.').forEach(part => flagsCaseFieldValue = flagsCaseFieldValue[part]);
+        }
+        if (flagsCaseFieldValue) {
+            const flagDetailToUpdate = flagsCaseFieldValue.details?.find(detail => detail.id === this.selectedFlag.flagDetailDisplay?.flagDetail?.id);
+            if (flagDetailToUpdate) {
+                // Cache the *original* status of the flag before it is modified. This is needed if the user changes the flag status
+                // then decides to return to any part of the flag update journey. The ManageCaseFlagsComponent and UpdateFlagComponent
+                // should refer to a flag's original status, not the one set via the UI because this hasn't been persisted yet
+                this.selectedFlag.originalStatus = flagDetailToUpdate.value?.status;
+                // Update description fields only if flag type is "Other" (flag code OT0001); these fields apply only to that flag type
+                // If their FormControls don't exist, it means these fields weren't visited as part of the "Update Flag" journey, so do
+                // *not* update their values (otherwise they will become undefined)
+                if (flagDetailToUpdate.value?.flagCode === this.otherFlagTypeCode) {
+                    if (this.caseFlagParentFormGroup.get(CaseFlagFormFields.OTHER_FLAG_DESCRIPTION)) {
+                        flagDetailToUpdate.value.otherDescription = this.caseFlagParentFormGroup.get(CaseFlagFormFields.OTHER_FLAG_DESCRIPTION).value;
+                    }
+                    if (this.caseFlagParentFormGroup.get(CaseFlagFormFields.OTHER_FLAG_DESCRIPTION_WELSH)) {
+                        flagDetailToUpdate.value.otherDescription_cy = this.caseFlagParentFormGroup.get(CaseFlagFormFields.OTHER_FLAG_DESCRIPTION_WELSH).value;
+                    }
+                }
+                // Ensure that any comments entered with language set to Welsh do not end up in the English comments field
+                if (this.rpxTranslationService.language !== 'cy') {
+                    flagDetailToUpdate.value.flagComment = this.caseFlagParentFormGroup.get(CaseFlagFormFields.COMMENTS)?.value;
+                }
+                // Populate from the *English* comments field if:
+                // * The Welsh comments field has no value (Welsh comments field acquires a value only when an HMCTS internal user has
+                // gone through the "add translation" step for Manage Case Flags), AND
+                // * The language is set to Welsh
+                // If the FormControl doesn't exist, it means this field wasn't visited as part of the "Update Flag" journey, so do
+                // *not* update its value (otherwise it will be overridden) - unless the user is external AND working in Welsh
+                if (this.caseFlagParentFormGroup.get(CaseFlagFormFields.COMMENTS_WELSH) || this.rpxTranslationService.language === 'cy') {
+                    flagDetailToUpdate.value.flagComment_cy = this.caseFlagParentFormGroup.get(CaseFlagFormFields.COMMENTS_WELSH)?.value
+                        ? this.caseFlagParentFormGroup.get(CaseFlagFormFields.COMMENTS_WELSH)?.value
+                        : this.rpxTranslationService.language === 'cy'
+                            ? this.caseFlagParentFormGroup.get(CaseFlagFormFields.COMMENTS)?.value
+                            : null;
+                }
+                flagDetailToUpdate.value.flagUpdateComment = this.caseFlagParentFormGroup.get(CaseFlagFormFields.STATUS_CHANGE_REASON)?.value;
+                flagDetailToUpdate.value.status = CaseFlagStatus[this.caseFlagParentFormGroup.get(CaseFlagFormFields.STATUS)?.value];
+                flagDetailToUpdate.value.dateTimeModified = new Date().toISOString();
+            }
+        }
+    }
+    isAtFinalState() {
+        return this.isDisplayContextParameterUpdate
+            ? this.fieldState === this.manageFlagFinalState
+            : !this.isDisplayContextParameter2Point1Enabled
+                ? this.fieldState === CaseFlagFieldState.FLAG_COMMENTS
+                : this.fieldState === CaseFlagFieldState.FLAG_STATUS;
+    }
+    navigateToErrorElement(elementId) {
+        if (elementId) {
+            const htmlElement = document.getElementById(elementId);
+            if (htmlElement) {
+                htmlElement.scrollIntoView({ behavior: 'smooth', block: 'center' });
+                htmlElement.focus();
+            }
+        }
+    }
+    onFlagCommentsOptionalEmitted(_) {
+        this.flagCommentsOptional = true;
+    }
+    populateNewFlagDetailInstance() {
+        const langSearchTerm = this.caseFlagParentFormGroup?.value['languageSearchTerm'];
+        const manualLangEntry = this.caseFlagParentFormGroup?.value['manualLanguageEntry'];
+        const flagType = this.caseFlagParentFormGroup?.value['flagType'];
+        const otherDesc = this.caseFlagParentFormGroup?.value['otherDescription'];
+        const formValues = this.caseFlagParentFormGroup?.value;
+        return {
+            name: this.flagType?.name,
+            name_cy: flagType?.name_cy,
+            // Currently, subTypeValue, subTypeValue_cy and subTypeKey are applicable only to language flag types
+            subTypeValue: langSearchTerm && this.rpxTranslationService.language === 'en'
+                ? langSearchTerm.value
+                : manualLangEntry && this.rpxTranslationService.language === 'en'
+                    ? manualLangEntry
+                    : null,
+            subTypeValue_cy: langSearchTerm && this.rpxTranslationService.language === 'cy'
+                ? langSearchTerm?.value_cy
+                : manualLangEntry && this.rpxTranslationService.language === 'cy'
+                    ? manualLangEntry
+                    : null,
+            // For user-entered (i.e. non-Reference Data) languages, there is no key
+            subTypeKey: langSearchTerm
+                ? langSearchTerm.key
+                : null,
+            otherDescription: flagType?.flagCode === this.otherFlagTypeCode &&
+                otherDesc && this.rpxTranslationService.language === 'en'
+                ? otherDesc
+                : null,
+            otherDescription_cy: flagType?.flagCode === this.otherFlagTypeCode &&
+                otherDesc && this.rpxTranslationService.language === 'cy'
+                ? otherDesc
+                : null,
+            flagComment: this.rpxTranslationService.language === 'en'
+                ? formValues?.flagComments
+                : null,
+            flagComment_cy: this.rpxTranslationService.language === 'cy'
+                ? formValues?.flagComments
+                : null,
+            flagUpdateComment: formValues?.statusReason,
+            dateTimeCreated: new Date().toISOString(),
+            path: flagType?.Path &&
+                flagType?.Path.map(pathValue => Object.assign({ id: null, value: pathValue })),
+            hearingRelevant: flagType?.hearingRelevant ? 'Yes' : 'No',
+            flagCode: flagType?.flagCode,
+            // Status should be set to whatever the default is for this flag type, if flag is being created by an external
+            // user, otherwise it should be set to "Active" if Case Flags v2.1 is NOT enabled, or the selected status if it is
+            status: this.isDisplayContextParameterExternal
+                ? flagType?.defaultStatus
+                : !this.isDisplayContextParameter2Point1Enabled
+                    ? CaseFlagStatus.ACTIVE
+                    : CaseFlagStatus[formValues?.selectedStatus],
+            availableExternally: flagType?.externallyAvailable ? 'Yes' : 'No'
+        };
+    }
+    moveToFinalReviewStage() {
+        this.setFlagsCaseFieldValue();
+        // Check that no errors have been set on caseFlagParentFormGroup (by determineLocationForFlag()); prevent moving to
+        // final review stage if errors exist
+        if (!this.caseFlagParentFormGroup.errors) {
+            // Clear the "notAllCaseFlagStagesCompleted" error
+            this.allCaseFlagStagesCompleted = true;
+            this.formGroup.updateValueAndValidity();
+            this.caseEditDataService.setTriggerSubmitEvent(true);
+            // Update this.selectedFlagsLocation with the correctly determined location, so the correct value is available to
+            // ReadCaseFlagFieldComponent when it initialises the Case Flag Summary page
+            this.selectedFlagsLocation = this.determinedLocation;
+        }
+    }
+    ngOnDestroy() {
+        // Reset the fieldstateToNavigate as the write journey completes at this point
+        this.caseFlagStateService.fieldStateToNavigate = undefined;
+        this.caseTitleSubscription?.unsubscribe();
+    }
+    get manageFlagFinalState() {
+        return this.caseFlagParentFormGroup.get(CaseFlagFormFields.IS_WELSH_TRANSLATION_NEEDED)?.value
+            ? CaseFlagFieldState.FLAG_UPDATE_WELSH_TRANSLATION : CaseFlagFieldState.FLAG_UPDATE;
+    }
+    setDisplayContextParameter(caseFields) {
+        return caseFields.find(caseField => FieldsUtils.isCaseFieldOfType(caseField, ['FlagLauncher']))?.display_context_parameter;
+    }
+    static ɵfac = function WriteCaseFlagFieldComponent_Factory(t) { return new (t || WriteCaseFlagFieldComponent)(i0.ɵɵdirectiveInject(i1.ActivatedRoute), i0.ɵɵdirectiveInject(i2.CaseEditDataService), i0.ɵɵdirectiveInject(i3.CaseFlagStateService), i0.ɵɵdirectiveInject(i4.RpxTranslationService)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: WriteCaseFlagFieldComponent, selectors: [["ccd-write-case-flag-field"]], features: [i0.ɵɵInheritDefinitionFeature], decls: 3, vars: 3, consts: [["class", "govuk-error-summary", "aria-labelledby", "error-summary-title", "role", "alert", "tabindex", "-1", "data-module", "govuk-error-summary", 4, "ngIf"], ["class", "form-group", 3, "formGroup", 4, "ngIf"], ["aria-labelledby", "error-summary-title", "role", "alert", "tabindex", "-1", "data-module", "govuk-error-summary", 1, "govuk-error-summary"], ["id", "error-summary-title", 1, "govuk-error-summary__title"], ["class", "govuk-error-summary__body", 4, "ngFor", "ngForOf"], [1, "govuk-error-summary__body"], [1, "govuk-list", "govuk-error-summary__list"], [1, "validation-error", 3, "click"], [1, "form-group", 3, "formGroup"], [1, "govuk-form-group", 3, "ngSwitch"], [4, "ngSwitchCase"], [3, "caseFlagStateEmitter", "formGroup", "flagsData", "isDisplayContextParameterExternal"], [3, "caseFlagStateEmitter", "flagCommentsOptionalEmitter", "formGroup", "jurisdiction", "caseTypeId", "hmctsServiceId", "isDisplayContextParameterExternal", "isDisplayContextParameter2Point1Enabled", "selectedFlagsLocation"], [3, "caseFlagStateEmitter", "formGroup", "flagType"], [3, "caseFlagStateEmitter", "formGroup", "optional", "isDisplayContextParameterExternal", "isDisplayContextParameter2Point1Enabled"], [3, "caseFlagStateEmitter", "formGroup", "defaultStatus"], [3, "caseFlagStateEmitter", "formGroup", "flagsData", "caseTitle", "displayContextParameter"], [3, "caseFlagStateEmitter", "formGroup", "displayContextParameter"], [3, "caseFlagStateEmitter", "formGroup"]], template: function WriteCaseFlagFieldComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵtemplate(0, WriteCaseFlagFieldComponent_div_0_Template, 5, 4, "div", 0)(1, WriteCaseFlagFieldComponent_div_1_Template, 7, 7, "div", 1)(2, WriteCaseFlagFieldComponent_div_2_Template, 5, 5, "div", 1);
+        } if (rf & 2) {
+            i0.ɵɵproperty("ngIf", ctx.errorMessages.length > 0);
+            i0.ɵɵadvance();
+            i0.ɵɵproperty("ngIf", !ctx.isDisplayContextParameterUpdate);
+            i0.ɵɵadvance();
+            i0.ɵɵproperty("ngIf", ctx.isDisplayContextParameterUpdate);
+        } }, styles: [".validation-error[_ngcontent-%COMP%]{cursor:pointer;text-decoration:underline;color:#d4351c}"] });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(WriteCaseFlagFieldComponent, [{
+        type: Component,
+        args: [{ selector: 'ccd-write-case-flag-field', template: "<!-- Error message summary -->\n<div *ngIf=\"errorMessages.length > 0\" class=\"govuk-error-summary\" aria-labelledby=\"error-summary-title\" role=\"alert\" tabindex=\"-1\" data-module=\"govuk-error-summary\">\n  <h2 class=\"govuk-error-summary__title\" id=\"error-summary-title\">\n    {{'There is a problem' | rpxTranslate}}\n  </h2>\n  <div *ngFor=\"let errorMessage of errorMessages\" class=\"govuk-error-summary__body\">\n    <ul class=\"govuk-list govuk-error-summary__list\">\n      <li>\n        <a (click)=\"navigateToErrorElement(errorMessage.fieldId)\" class=\"validation-error\">{{errorMessage.description | rpxTranslate}}</a>\n      </li>\n    </ul>\n  </div>\n</div>\n<div *ngIf=\"!isDisplayContextParameterUpdate\" class=\"form-group\" [formGroup]=\"formGroup\">\n  <div class=\"govuk-form-group\" [ngSwitch]=\"fieldState\">\n    <ng-container *ngSwitchCase=\"caseFlagFieldState.FLAG_LOCATION\">\n      <ccd-select-flag-location\n        [formGroup]=\"caseFlagParentFormGroup\" [flagsData]=\"flagsData\"\n        (caseFlagStateEmitter)=\"onCaseFlagStateEmitted($event)\"\n        [isDisplayContextParameterExternal]=\"isDisplayContextParameterExternal\"\n      ></ccd-select-flag-location>\n    </ng-container>\n    <ng-container *ngSwitchCase=\"caseFlagFieldState.FLAG_TYPE\">\n      <ccd-select-flag-type [formGroup]=\"caseFlagParentFormGroup\" [jurisdiction]=\"jurisdiction\" [caseTypeId]=\"caseTypeId\"\n        [hmctsServiceId]=\"hmctsServiceId\" [isDisplayContextParameterExternal]=\"isDisplayContextParameterExternal\"\n        [isDisplayContextParameter2Point1Enabled]=\"isDisplayContextParameter2Point1Enabled\"\n        [selectedFlagsLocation]=\"selectedFlagsLocation\"\n        (caseFlagStateEmitter)=\"onCaseFlagStateEmitted($event)\"\n        (flagCommentsOptionalEmitter)=\"onFlagCommentsOptionalEmitted($event)\"></ccd-select-flag-type>\n    </ng-container>\n    <ng-container *ngSwitchCase=\"caseFlagFieldState.FLAG_LANGUAGE_INTERPRETER\">\n      <ccd-search-language-interpreter [formGroup]=\"caseFlagParentFormGroup\"\n        [flagType]=\"flagType\"\n        (caseFlagStateEmitter)=\"onCaseFlagStateEmitted($event)\">\n      </ccd-search-language-interpreter>\n    </ng-container>\n    <ng-container *ngSwitchCase=\"caseFlagFieldState.FLAG_COMMENTS\">\n      <ccd-add-comments [formGroup]=\"caseFlagParentFormGroup\" [optional]=\"flagCommentsOptional\"\n        (caseFlagStateEmitter)=\"onCaseFlagStateEmitted($event)\"\n        [isDisplayContextParameterExternal]=\"isDisplayContextParameterExternal\"\n        [isDisplayContextParameter2Point1Enabled]=\"isDisplayContextParameter2Point1Enabled\">\n      </ccd-add-comments>\n    </ng-container>\n    <ng-container *ngSwitchCase=\"caseFlagFieldState.FLAG_STATUS\">\n      <ccd-confirm-flag-status [formGroup]=\"caseFlagParentFormGroup\" [defaultStatus]=\"flagType.defaultStatus\"\n        (caseFlagStateEmitter)=\"onCaseFlagStateEmitted($event)\"></ccd-confirm-flag-status>\n    </ng-container>\n  </div>\n</div>\n<div *ngIf=\"isDisplayContextParameterUpdate\" class=\"form-group\" [formGroup]=\"formGroup\">\n  <div class=\"govuk-form-group\" [ngSwitch]=\"fieldState\">\n    <ng-container *ngSwitchCase=\"caseFlagFieldState.FLAG_MANAGE_CASE_FLAGS\">\n      <ccd-manage-case-flags [formGroup]=\"caseFlagParentFormGroup\" [flagsData]=\"flagsData\" [caseTitle]=\"caseTitle\"\n        [displayContextParameter]=\"displayContextParameter\"\n        (caseFlagStateEmitter)=\"onCaseFlagStateEmitted($event)\"></ccd-manage-case-flags>\n    </ng-container>\n    <ng-container *ngSwitchCase=\"caseFlagFieldState.FLAG_UPDATE\">\n      <ccd-update-flag [formGroup]=\"caseFlagParentFormGroup\"\n        [displayContextParameter]=\"displayContextParameter\"\n        (caseFlagStateEmitter)=\"onCaseFlagStateEmitted($event)\"></ccd-update-flag>\n    </ng-container>\n    <ng-container *ngSwitchCase=\"caseFlagFieldState.FLAG_UPDATE_WELSH_TRANSLATION\">\n      <ccd-update-flag-add-translation-form\n        [formGroup]=\"caseFlagParentFormGroup\"\n        (caseFlagStateEmitter)=\"onCaseFlagStateEmitted($event)\"\n      ></ccd-update-flag-add-translation-form>\n    </ng-container>\n  </div>\n</div>\n", styles: [".validation-error{cursor:pointer;text-decoration:underline;color:#d4351c}\n"] }]
+    }], () => [{ type: i1.ActivatedRoute }, { type: i2.CaseEditDataService }, { type: i3.CaseFlagStateService }, { type: i4.RpxTranslationService }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(WriteCaseFlagFieldComponent, { className: "WriteCaseFlagFieldComponent", filePath: "lib/shared/components/palette/case-flag/write-case-flag-field.component.ts", lineNumber: 20 }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"write-case-flag-field.component.js","sourceRoot":"","sources":["../../../../../../../../projects/ccd-case-ui-toolkit/src/lib/shared/components/palette/case-flag/write-case-flag-field.component.ts","../../../../../../../../projects/ccd-case-ui-toolkit/src/lib/shared/components/palette/case-flag/write-case-flag-field.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, OnDestroy, OnInit } from '@angular/core';\nimport { AbstractControl, FormGroup } from '@angular/forms';\nimport { ActivatedRoute } from '@angular/router';\nimport { RpxTranslationService } from 'rpx-xui-translation';\nimport { Subscription } from 'rxjs';\nimport { CaseEditDataService } from '../../../commons/case-edit-data/case-edit-data.service';\nimport { CaseField, ErrorMessage } from '../../../domain';\nimport { FlagType } from '../../../domain/case-flag';\nimport { FieldsUtils } from '../../../services/fields';\nimport { CaseFlagStateService } from '../../case-editor/services/case-flag-state.service';\nimport { AbstractFieldWriteComponent } from '../base-field/abstract-field-write.component';\nimport { CaseFlagState, FlagDetail, FlagDetailDisplayWithFormGroupPath, FlagsWithFormGroupPath } from './domain';\nimport { CaseFlagDisplayContextParameter, CaseFlagErrorMessage, CaseFlagFieldState, CaseFlagFormFields, CaseFlagStatus } from './enums';\n\n@Component({\n  selector: 'ccd-write-case-flag-field',\n  templateUrl: './write-case-flag-field.component.html',\n  styleUrls: ['./write-case-flag-field.component.scss']\n})\nexport class WriteCaseFlagFieldComponent extends AbstractFieldWriteComponent implements OnInit, OnDestroy {\n  public fieldState: number;\n  public caseFlagFieldState = CaseFlagFieldState;\n  public errorMessages: ErrorMessage[] = [];\n  public flagsData: FlagsWithFormGroupPath[];\n  public selectedFlag: FlagDetailDisplayWithFormGroupPath;\n  public caseFlagParentFormGroup: FormGroup;\n  public flagCommentsOptional = false;\n  public jurisdiction: string;\n  public caseTypeId: string;\n  public hmctsServiceId: string;\n  public isDisplayContextParameterUpdate: boolean;\n  public isDisplayContextParameterExternal: boolean;\n  public isDisplayContextParameter2Point1Enabled: boolean;\n  public caseTitle: string;\n  public caseTitleSubscription: Subscription;\n  public displayContextParameter: string;\n  public determinedLocation: FlagsWithFormGroupPath;\n  private allCaseFlagStagesCompleted = false;\n  // Code for \"Other\" flag type as defined in Reference Data\n  private readonly otherFlagTypeCode = 'OT0001';\n  private readonly selectedManageCaseLocation = 'selectedManageCaseLocation';\n  public readonly caseNameMissing = 'Case name missing';\n\n  public get flagType(): FlagType | null {\n    return this.caseFlagParentFormGroup?.value.flagType;\n  }\n\n  public get selectedFlagsLocation(): FlagsWithFormGroupPath | null {\n    return this.caseFlagParentFormGroup?.value.selectedLocation;\n  }\n\n  public set selectedFlagsLocation(selectedLocation: FlagsWithFormGroupPath | null) {\n    if (this.caseFlagParentFormGroup) {\n      this.caseFlagParentFormGroup.value.selectedLocation = selectedLocation;\n    }\n  }\n\n  constructor(\n    private readonly route: ActivatedRoute,\n    private readonly caseEditDataService: CaseEditDataService,\n    private readonly caseFlagStateService: CaseFlagStateService,\n    private readonly rpxTranslationService: RpxTranslationService\n  ) {\n    super();\n  }\n\n  public ngOnInit(): void {\n    // If it is start of the journey or navigation from check your answers page then fieldStateToNavigate property\n    // in case flag state service will contain the field state to navigate based on create or manage journey\n    this.fieldState = this.caseFlagStateService.fieldStateToNavigate;\n    if (this.fieldState === undefined ||\n        this.fieldState === CaseFlagFieldState.FLAG_LOCATION ||\n        this.fieldState === CaseFlagFieldState.FLAG_MANAGE_CASE_FLAGS) {\n      const params = this.route.snapshot.params;\n      // Clear the form group, field state to navigate and set the page location\n      this.caseFlagStateService.resetCache(`../${params['eid']}/${params['page']}`);\n    }\n    // Reassign the form group from the case flag state service\n    this.caseFlagParentFormGroup = this.caseFlagStateService.formGroup;\n    // Clear form validation errors as a new page will be rendered based on field state\n    this.caseEditDataService.clearFormValidationErrors();\n    // Check for existing FlagLauncher control in parent and remove it - this is the only way to ensure its invalidity\n    // is set correctly at the start, when the component is reloaded and the control is re-registered. Otherwise, the\n    // validator state gets carried over\n    if (this.formGroup && this.formGroup.get(this.caseField.id)) {\n      this.formGroup.removeControl(this.caseField.id);\n    }\n    // From this point, this.formGroup refers to the FormGroup for the FlagLauncher field, not the parent FormGroup\n    this.formGroup = this.registerControl(new FormGroup({}, {\n      validators: (_: AbstractControl): { [key: string]: boolean } | null => {\n        if (!this.allCaseFlagStagesCompleted) {\n          // Return an error to mark the FormGroup as invalid if not all Case Flag stages have been completed\n          return { notAllCaseFlagStagesCompleted: true };\n        }\n        return null;\n      }\n    }), true) as FormGroup;\n\n    // Get the case type ID from the CaseView object in the snapshot data (required for retrieving the available flag\n    // types for a case)\n    if (this.route.snapshot.data.case && this.route.snapshot.data.case.case_type) {\n      this.caseTypeId = this.route.snapshot.data.case.case_type.id;\n      // Get the jurisdiction (required for retrieving the available flag types if unable to determine using case type ID)\n      if (this.route.snapshot.data.case.case_type.jurisdiction) {\n        this.jurisdiction = this.route.snapshot.data.case.case_type.jurisdiction.id;\n      }\n    }\n    // Extract all flags-related data from the CaseEventTrigger object in the snapshot data\n    if (this.route.snapshot.data.eventTrigger) {\n      // Get the HMCTSServiceId from supplementary data, if it exists (required for retrieving the available flag types in\n      // the first instance, only falling back on case type ID or jurisdiction if it's not present)\n      if (this.route.snapshot.data.eventTrigger.supplementary_data\n        && this.route.snapshot.data.eventTrigger.supplementary_data.HMCTSServiceId) {\n        this.hmctsServiceId = this.route.snapshot.data.eventTrigger.supplementary_data.HMCTSServiceId;\n      }\n\n      if (this.route.snapshot.data.eventTrigger.case_fields) {\n        this.flagsData = ((this.route.snapshot.data.eventTrigger.case_fields) as CaseField[])\n          .reduce((flags, caseField) => FieldsUtils.extractFlagsDataFromCaseField(flags, caseField, caseField.id, caseField), []);\n\n        // Set displayContextParameter (to be passed as an input to ManageCaseFlagsComponent for setting correct title)\n        this.displayContextParameter =\n          this.setDisplayContextParameter(this.route.snapshot.data.eventTrigger.case_fields as CaseField[]);\n\n        // Set boolean indicating the display_context_parameter is \"update\"\n        this.isDisplayContextParameterUpdate = this.setDisplayContextParameterUpdate(this.displayContextParameter);\n\n        // Set boolean indicating the display_context_parameter is \"external\"\n        this.isDisplayContextParameterExternal = this.setDisplayContextParameterExternal(this.displayContextParameter);\n\n        // Set boolean indicating the display_context_parameter is Case Flags v2.1 enabled\n        this.isDisplayContextParameter2Point1Enabled = this.setDisplayContextParameter2Point1Enabled(this.displayContextParameter);\n\n        // Set starting field state if fieldState not the right value\n        if (!this.fieldState) {\n          this.fieldState = this.isDisplayContextParameterUpdate ? CaseFlagFieldState.FLAG_MANAGE_CASE_FLAGS : CaseFlagFieldState.FLAG_LOCATION;\n        }\n\n        // Get case title, to be used by child components\n        this.caseTitleSubscription = this.caseEditDataService.caseTitle$.subscribe({\n          next: title => {\n            this.caseTitle = title?.length > 0 ? title : this.caseNameMissing;\n          }\n        });\n      }\n    }\n  }\n\n  public setDisplayContextParameterUpdate(displayContextParameter: string): boolean {\n    return displayContextParameter === CaseFlagDisplayContextParameter.UPDATE ||\n      displayContextParameter === CaseFlagDisplayContextParameter.UPDATE_EXTERNAL ||\n      displayContextParameter === CaseFlagDisplayContextParameter.UPDATE_2_POINT_1;\n  }\n\n  public setDisplayContextParameterExternal(displayContextParameter: string): boolean {\n    return displayContextParameter === CaseFlagDisplayContextParameter.CREATE_EXTERNAL ||\n      displayContextParameter === CaseFlagDisplayContextParameter.UPDATE_EXTERNAL;\n  }\n\n  public setDisplayContextParameter2Point1Enabled(displayContextParameter: string): boolean {\n    return displayContextParameter === CaseFlagDisplayContextParameter.CREATE_2_POINT_1 ||\n      displayContextParameter === CaseFlagDisplayContextParameter.UPDATE_2_POINT_1;\n  }\n\n  public onCaseFlagStateEmitted(caseFlagState: CaseFlagState): void {\n    this.caseEditDataService.clearFormValidationErrors();\n\n    this.errorMessages = caseFlagState.errorMessages;\n    this.selectedFlag = caseFlagState.selectedFlag;\n\n    // Validation succeeded; proceed to next state or final review stage (\"Check your answers\")\n    if (this.errorMessages.length === 0) {\n      if (this.canMoveToFinalReviewStage(caseFlagState)) {\n        this.moveToFinalReviewStage();\n        // Don't move to next state if current state is CaseFlagFieldState.FLAG_TYPE and the flag type is a parent - this\n        // means the user needs to select from the next set of flag types before they can move on\n      } else if (!caseFlagState.isParentFlagType) {\n        // Proceed to next state\n        this.proceedToNextState();\n      }\n    }\n  }\n\n  public canMoveToFinalReviewStage(caseFlagState: CaseFlagState): boolean {\n    // If the journey is request support or manage support\n    // and the current state is either CaseFlagFieldState.FLAG_COMMENTS or CaseFlagFieldState.FLAG_UPDATE\n    // then move to final review stage\n    if (this.isDisplayContextParameterExternal) {\n      return caseFlagState.currentCaseFlagFieldState === CaseFlagFieldState.FLAG_COMMENTS ||\n        caseFlagState.currentCaseFlagFieldState === CaseFlagFieldState.FLAG_UPDATE;\n    }\n    // If the current state is one of:\n    // * CaseFlagFieldState.FLAG_STATUS AND Case Flags v2.1 is enabled\n    // * CaseFlagFieldState.FLAG_COMMENTS AND Case Flags v2.1 is not enabled\n    // * CaseFlagFieldState.FLAG_UPDATE and Welsh translation checkbox is not selected\n    // * CaseFlagFieldState.FLAG_UPDATE_WELSH_TRANSLATION\n    // then move to final review stage\n    return (caseFlagState.currentCaseFlagFieldState ===\n      CaseFlagFieldState.FLAG_STATUS && this.isDisplayContextParameter2Point1Enabled) ||\n      (caseFlagState.currentCaseFlagFieldState ===\n        CaseFlagFieldState.FLAG_COMMENTS && !this.isDisplayContextParameter2Point1Enabled) ||\n      (caseFlagState.currentCaseFlagFieldState === CaseFlagFieldState.FLAG_UPDATE &&\n        !this.caseFlagParentFormGroup.get(CaseFlagFormFields.IS_WELSH_TRANSLATION_NEEDED)?.value) ||\n      caseFlagState.currentCaseFlagFieldState === CaseFlagFieldState.FLAG_UPDATE_WELSH_TRANSLATION;\n  }\n\n  public proceedToNextState(): void {\n    if (!this.isAtFinalState()) {\n      // Skip the \"language interpreter\" state if current state is CaseFlagFieldState.FLAG_TYPE and the flag type doesn't\n      // have a \"list of values\" - currently, this is present only for those flag types that require language interpreter\n      // selection\n      if (this.fieldState === CaseFlagFieldState.FLAG_TYPE && !this.flagType?.listOfValues) {\n        this.fieldState = CaseFlagFieldState.FLAG_COMMENTS;\n      } else {\n        this.fieldState++;\n      }\n    }\n  }\n\n  public setFlagsCaseFieldValue(): void {\n    // tslint:disable-next-line: switch-default\n    switch (this.fieldState) {\n      case CaseFlagFieldState.FLAG_STATUS:\n        this.addFlagToCollection();\n        break;\n      case CaseFlagFieldState.FLAG_COMMENTS:\n        if (this.isDisplayContextParameterExternal || !this.isDisplayContextParameter2Point1Enabled) {\n          this.addFlagToCollection();\n        }\n        break;\n      case this.manageFlagFinalState:\n        this.updateFlagInCollection();\n        break;\n    }\n  }\n\n  public addFlagToCollection(): void {\n    // Ensure no more than one new flag is being added at a time, by iterating through each Flags case field and removing\n    // any previous entry from the details array where that entry has no id (hence it is new - and there should be only\n    // one such entry). (This scenario occurs if the user repeats the Case Flag creation journey by using the \"Change\"\n    // link and selects either the same flag location as before or a different one.)\n    this.flagsData.forEach(instance => {\n      // Use the pathToFlagsFormGroup property for each Flags case field to drill down to the correct part of the\n      // CaseField value to remove the new value from\n      let value = instance.caseField?.value;\n      const pathToValue = instance.pathToFlagsFormGroup;\n      // Root-level Flags CaseFields don't have a dot-delimited path - just the CaseField ID itself - so don't drill down\n      if (pathToValue.indexOf('.') > -1) {\n        pathToValue.slice(pathToValue.indexOf('.') + 1).split('.').forEach(part => value = value[part]);\n      }\n      if (value?.details?.length > 0) {\n        const indexOfNewFlagDetail = value.details.findIndex(element => !element.hasOwnProperty('id'));\n        if (indexOfNewFlagDetail > -1) {\n          value.details.splice(indexOfNewFlagDetail, 1);\n        }\n      }\n    });\n\n    const formValues = this.caseFlagParentFormGroup?.value;\n    // Determine the correct location - internal or external - for the new flag. If returned as undefined, this\n    // indicates a configuration error with the external `Flags` object instance\n    this.determinedLocation =\n      this.determineLocationForFlag(!this.isDisplayContextParameterExternal, this.selectedFlagsLocation, formValues);\n    // Do not mutate this.selectedFlagsLocation; if this.selectedFlagsLocation becomes undefined,\n    // determineLocationForFlag() will no longer do anything when called with it - and the appropriate error message will\n    // not be redisplayed if the user clicks \"Next\" again on the \"Add comments\" page, after the error is first shown\n\n    if (this.determinedLocation) {\n      const path = this.determinedLocation.pathToFlagsFormGroup;\n      const flagDataRef = this.flagsData.find(item => item.pathToFlagsFormGroup === path);\n      let flagsCaseFieldValue = flagDataRef.caseField?.value;\n      // Use the pathToFlagsFormGroup property from the selected flag location to drill down to the correct part of the\n      // CaseField value to apply changes to\n      // Root-level Flags CaseFields don't have a dot-delimited path - just the CaseField ID itself - so don't drill down\n      if (path.indexOf('.') > -1) {\n        path.slice(path.indexOf('.') + 1).split('.').forEach(part => flagsCaseFieldValue = flagsCaseFieldValue[part]);\n      }\n      // If the CaseField for the selected flags location has no value, set it to an empty object so it can be populated\n      // with flag details\n      if (!flagsCaseFieldValue) {\n        flagDataRef.caseField.value = {};\n        flagsCaseFieldValue = flagDataRef.caseField.value;\n      }\n      // Create a details array if one does not exist\n      if (!flagsCaseFieldValue.hasOwnProperty('details')) {\n        flagsCaseFieldValue.details = [];\n      }\n      // Populate new FlagDetail instance and add to the Flags data within the CaseField instance of the selected flag\n      // location\n      flagsCaseFieldValue.details.push({value: this.populateNewFlagDetailInstance()});\n    }\n  }\n\n  /**\n   * Determines the correct location (i.e. either the internal or external instance of a `Flags` object) for a new flag,\n   * according to the following:\n   *\n   * * Whether the user is internal or external (no effect for external users because they can access only the external\n   * instance)\n   * * The existence of two `Flags` objects - one internal, one external - linked by the same `groupId`;\n   * * For flags of type \"Other\", whether \"only visible to HMCTS staff\" has been selected or not (\"Other\" defaults to\n   * externally visible);\n   * * For all other flag types, the value of the `externallyAvailable` attribute.\n   *\n   * If the user is internal then the new flag should be assigned to the external `Flags` instance if:\n   * * Such an instance exists, AND\n   * * The flag type is \"Other\" and \"only visible to HMCTS staff\" was not selected, OR\n   * * The flag type is not \"Other\" and `externallyAvailable` is `true`.\n   *\n   * @param isInternalUser Whether the current user is internal or not\n   * @param selectedFlagsLocation The currently selected location for the new flag\n   * @param formValues All the values from the `caseFlagParentFormGroup`\n   * @returns The correctly determined location: either the internal or external location (if one exists) where a groupId\n   * is present; the original location otherwise. **Note:** If the external location is returned as undefined, this\n   * indicates a configuration error\n   */\n  public determineLocationForFlag(isInternalUser: boolean, selectedFlagsLocation: FlagsWithFormGroupPath,\n    formValues: any): FlagsWithFormGroupPath {\n      if (isInternalUser && selectedFlagsLocation?.flags?.groupId) {\n        if ((formValues?.flagType?.flagCode === this.otherFlagTypeCode && !formValues?.flagIsVisibleInternallyOnly) ||\n          (formValues?.flagType?.flagCode !== this.otherFlagTypeCode && formValues?.flagType?.externallyAvailable)) {\n            // If necessary, find the corresponding flags object with the same groupId and external visibility (should be\n            // only one unless misconfigured)\n            const location = selectedFlagsLocation.flags.visibility?.toLowerCase() === 'external'\n              ? selectedFlagsLocation\n              : this.flagsData.filter(\n                (f) => f.flags?.groupId === selectedFlagsLocation.flags.groupId &&\n                f.flags?.visibility?.toLowerCase() === 'external')?.[0];\n            // If location is not truthy, set an error message and make caseFlagParentFormGroup invalid to prevent\n            // navigation to the summary page (by not triggering the submit event)\n            if (!location) {\n              this.errorMessages.push({\n                title: '',\n                description: CaseFlagErrorMessage.NO_EXTERNAL_FLAGS_COLLECTION\n              });\n              this.caseFlagParentFormGroup.setErrors({\n                noExternalCollection: true\n              });\n            }\n            return location;\n        } else {\n          // If necessary, find the corresponding flags object with the same groupId and internal visibility (should be\n          // only one unless misconfigured); assumed to be internal if visibility attribute is null or undefined\n          const location = selectedFlagsLocation.flags.visibility?.toLowerCase() !== 'external'\n            ? selectedFlagsLocation\n            : this.flagsData.filter(\n              (f) => f.flags?.groupId === selectedFlagsLocation.flags.groupId &&\n              f.flags?.visibility?.toLowerCase() !== 'external')?.[0];\n          // If location is not truthy, set an error message and make caseFlagParentFormGroup invalid to prevent\n          // navigation to the summary page (by not triggering the submit event)\n          if (!location) {\n            this.errorMessages.push({\n              title: '',\n              description: CaseFlagErrorMessage.NO_INTERNAL_FLAGS_COLLECTION\n            });\n            this.caseFlagParentFormGroup.setErrors({\n              noInternalCollection: true\n            });\n          }\n          return location;\n        }\n      }\n      return selectedFlagsLocation;\n  }\n\n  public updateFlagInCollection(): void {\n    // Ensure no more than one flag is being updated at a time, by iterating through each Flags case field and resetting\n    // the description, comments, status, and date/time modified (if present) for each entry in the details array, with\n    // original values from the corresponding formatted_value property. (This scenario occurs if the user repeats the\n    // Manage Case Flag journey by using the \"Change\" link and selects a different flag to update.)\n    this.flagsData.forEach(instance => {\n      // Use the pathToFlagsFormGroup property for each Flags case field to drill down to the correct part of the\n      // CaseField value for which to restore the original values\n      let value = instance.caseField?.value;\n      let formattedValue = instance.caseField?.formatted_value;\n      const pathToValue = instance.pathToFlagsFormGroup;\n      // Root-level Flags CaseFields don't have a dot-delimited path - just the CaseField ID itself - so don't drill down\n      if (pathToValue.indexOf('.') > -1) {\n        pathToValue.slice(pathToValue.indexOf('.') + 1).split('.').forEach(part => {\n          value = value[part];\n          if (formattedValue && FieldsUtils.isNonEmptyObject(formattedValue)) {\n            formattedValue = formattedValue[part];\n          }\n        });\n      }\n      if (value?.details?.length > 0 && formattedValue && FieldsUtils.isNonEmptyObject(formattedValue)) {\n        value.details.forEach(flagDetail => {\n          const originalFlagDetail = formattedValue.details?.find(detail => detail.id === flagDetail.id);\n          if (originalFlagDetail) {\n            flagDetail.value.otherDescription = originalFlagDetail.value?.otherDescription || null;\n            flagDetail.value.otherDescription_cy = originalFlagDetail.value?.otherDescription_cy || null;\n            flagDetail.value.flagComment = originalFlagDetail.value?.flagComment || null;\n            flagDetail.value.flagComment_cy = originalFlagDetail.value?.flagComment_cy || null;\n            flagDetail.value.flagUpdateComment = originalFlagDetail.value?.flagUpdateComment || null;\n            flagDetail.value.status = originalFlagDetail.value?.status;\n            flagDetail.value.dateTimeModified = originalFlagDetail.value?.dateTimeModified || null;\n          }\n        });\n      }\n    });\n    if (!this.selectedFlag) {\n      this.selectedFlag = this.formGroup.get(this.selectedManageCaseLocation).value as FlagDetailDisplayWithFormGroupPath;\n    }\n    let flagsCaseFieldValue = this.selectedFlag.caseField?.value;\n    // Use the pathToFlagsFormGroup property from the selected flag location to drill down to the correct part of the\n    // CaseField value to apply changes to\n    const path = this.selectedFlag.pathToFlagsFormGroup;\n    // Root-level Flags CaseFields don't have a dot-delimited path - just the CaseField ID itself - so don't drill down\n    if (path.indexOf('.') > -1) {\n      path.slice(path.indexOf('.') + 1).split('.').forEach(part => flagsCaseFieldValue = flagsCaseFieldValue[part]);\n    }\n    if (flagsCaseFieldValue) {\n      const flagDetailToUpdate = flagsCaseFieldValue.details?.find(\n        detail => detail.id === this.selectedFlag.flagDetailDisplay?.flagDetail?.id);\n      if (flagDetailToUpdate) {\n        // Cache the *original* status of the flag before it is modified. This is needed if the user changes the flag status\n        // then decides to return to any part of the flag update journey. The ManageCaseFlagsComponent and UpdateFlagComponent\n        // should refer to a flag's original status, not the one set via the UI because this hasn't been persisted yet\n        this.selectedFlag.originalStatus = flagDetailToUpdate.value?.status;\n        // Update description fields only if flag type is \"Other\" (flag code OT0001); these fields apply only to that flag type\n        // If their FormControls don't exist, it means these fields weren't visited as part of the \"Update Flag\" journey, so do\n        // *not* update their values (otherwise they will become undefined)\n        if (flagDetailToUpdate.value?.flagCode === this.otherFlagTypeCode) {\n          if (this.caseFlagParentFormGroup.get(CaseFlagFormFields.OTHER_FLAG_DESCRIPTION)) {\n            flagDetailToUpdate.value.otherDescription = this.caseFlagParentFormGroup.get(\n              CaseFlagFormFields.OTHER_FLAG_DESCRIPTION).value;\n          }\n          if (this.caseFlagParentFormGroup.get(CaseFlagFormFields.OTHER_FLAG_DESCRIPTION_WELSH)) {\n            flagDetailToUpdate.value.otherDescription_cy = this.caseFlagParentFormGroup.get(\n              CaseFlagFormFields.OTHER_FLAG_DESCRIPTION_WELSH).value;\n          }\n        }\n        // Ensure that any comments entered with language set to Welsh do not end up in the English comments field\n        if (this.rpxTranslationService.language !== 'cy') {\n          flagDetailToUpdate.value.flagComment = this.caseFlagParentFormGroup.get(CaseFlagFormFields.COMMENTS)?.value;\n        }\n        // Populate from the *English* comments field if:\n        // * The Welsh comments field has no value (Welsh comments field acquires a value only when an HMCTS internal user has\n        // gone through the \"add translation\" step for Manage Case Flags), AND\n        // * The language is set to Welsh\n        // If the FormControl doesn't exist, it means this field wasn't visited as part of the \"Update Flag\" journey, so do\n        // *not* update its value (otherwise it will be overridden) - unless the user is external AND working in Welsh\n        if (this.caseFlagParentFormGroup.get(CaseFlagFormFields.COMMENTS_WELSH) || this.rpxTranslationService.language === 'cy') {\n          flagDetailToUpdate.value.flagComment_cy = this.caseFlagParentFormGroup.get(CaseFlagFormFields.COMMENTS_WELSH)?.value\n          ? this.caseFlagParentFormGroup.get(CaseFlagFormFields.COMMENTS_WELSH)?.value\n          : this.rpxTranslationService.language === 'cy'\n            ? this.caseFlagParentFormGroup.get(CaseFlagFormFields.COMMENTS)?.value\n            : null;\n        }\n        flagDetailToUpdate.value.flagUpdateComment = this.caseFlagParentFormGroup.get(CaseFlagFormFields.STATUS_CHANGE_REASON)?.value;\n        flagDetailToUpdate.value.status = CaseFlagStatus[this.caseFlagParentFormGroup.get(CaseFlagFormFields.STATUS)?.value];\n        flagDetailToUpdate.value.dateTimeModified = new Date().toISOString();\n      }\n    }\n  }\n\n  public isAtFinalState(): boolean {\n    return this.isDisplayContextParameterUpdate\n      ? this.fieldState === this.manageFlagFinalState\n      : !this.isDisplayContextParameter2Point1Enabled\n        ? this.fieldState === CaseFlagFieldState.FLAG_COMMENTS\n        : this.fieldState === CaseFlagFieldState.FLAG_STATUS;\n  }\n\n  public navigateToErrorElement(elementId: string): void {\n    if (elementId) {\n      const htmlElement = document.getElementById(elementId);\n      if (htmlElement) {\n        htmlElement.scrollIntoView({ behavior: 'smooth', block: 'center' });\n        htmlElement.focus();\n      }\n    }\n  }\n\n  public onFlagCommentsOptionalEmitted(_: any): void {\n    this.flagCommentsOptional = true;\n  }\n\n  public populateNewFlagDetailInstance(): FlagDetail {\n    const langSearchTerm = this.caseFlagParentFormGroup?.value['languageSearchTerm'];\n    const manualLangEntry = this.caseFlagParentFormGroup?.value['manualLanguageEntry'];\n    const flagType = this.caseFlagParentFormGroup?.value['flagType'];\n    const otherDesc = this.caseFlagParentFormGroup?.value['otherDescription'];\n    const formValues = this.caseFlagParentFormGroup?.value;\n    return {\n      name: this.flagType?.name,\n      name_cy: flagType?.name_cy,\n      // Currently, subTypeValue, subTypeValue_cy and subTypeKey are applicable only to language flag types\n      subTypeValue: langSearchTerm && this.rpxTranslationService.language === 'en'\n        ? langSearchTerm.value\n        : manualLangEntry && this.rpxTranslationService.language === 'en'\n          ? manualLangEntry\n          : null,\n      subTypeValue_cy: langSearchTerm && this.rpxTranslationService.language === 'cy'\n      ? langSearchTerm?.value_cy\n      : manualLangEntry && this.rpxTranslationService.language === 'cy'\n        ? manualLangEntry\n        : null,\n      // For user-entered (i.e. non-Reference Data) languages, there is no key\n      subTypeKey: langSearchTerm\n        ? langSearchTerm.key\n        : null,\n      otherDescription: flagType?.flagCode === this.otherFlagTypeCode &&\n        otherDesc && this.rpxTranslationService.language === 'en'\n        ? otherDesc\n          : null,\n      otherDescription_cy: flagType?.flagCode === this.otherFlagTypeCode &&\n        otherDesc && this.rpxTranslationService.language === 'cy'\n        ? otherDesc\n        : null,\n      flagComment: this.rpxTranslationService.language === 'en'\n        ? formValues?.flagComments\n        : null,\n      flagComment_cy: this.rpxTranslationService.language === 'cy'\n        ? formValues?.flagComments\n        : null,\n      flagUpdateComment: formValues?.statusReason,\n      dateTimeCreated: new Date().toISOString(),\n      path: flagType?.Path &&\n        flagType?.Path.map(pathValue => Object.assign({ id: null, value: pathValue })),\n      hearingRelevant: flagType?.hearingRelevant ? 'Yes' : 'No',\n      flagCode: flagType?.flagCode,\n      // Status should be set to whatever the default is for this flag type, if flag is being created by an external\n      // user, otherwise it should be set to \"Active\" if Case Flags v2.1 is NOT enabled, or the selected status if it is\n      status: this.isDisplayContextParameterExternal\n        ? flagType?.defaultStatus\n        : !this.isDisplayContextParameter2Point1Enabled\n          ? CaseFlagStatus.ACTIVE\n          : CaseFlagStatus[formValues?.selectedStatus],\n      availableExternally: flagType?.externallyAvailable ? 'Yes' : 'No'\n    } as FlagDetail;\n  }\n\n  public moveToFinalReviewStage(): void {\n    this.setFlagsCaseFieldValue();\n    // Check that no errors have been set on caseFlagParentFormGroup (by determineLocationForFlag()); prevent moving to\n    // final review stage if errors exist\n    if (!this.caseFlagParentFormGroup.errors) {\n      // Clear the \"notAllCaseFlagStagesCompleted\" error\n      this.allCaseFlagStagesCompleted = true;\n      this.formGroup.updateValueAndValidity();\n      this.caseEditDataService.setTriggerSubmitEvent(true);\n      // Update this.selectedFlagsLocation with the correctly determined location, so the correct value is available to\n      // ReadCaseFlagFieldComponent when it initialises the Case Flag Summary page\n      this.selectedFlagsLocation = this.determinedLocation;\n    }\n  }\n\n  public ngOnDestroy(): void {\n    // Reset the fieldstateToNavigate as the write journey completes at this point\n    this.caseFlagStateService.fieldStateToNavigate = undefined;\n    this.caseTitleSubscription?.unsubscribe();\n  }\n\n  public get manageFlagFinalState() {\n    return this.caseFlagParentFormGroup.get(CaseFlagFormFields.IS_WELSH_TRANSLATION_NEEDED)?.value\n    ? CaseFlagFieldState.FLAG_UPDATE_WELSH_TRANSLATION : CaseFlagFieldState.FLAG_UPDATE;\n  }\n\n  public setDisplayContextParameter(caseFields: CaseField[]): string {\n    return caseFields.find(caseField => FieldsUtils.isCaseFieldOfType(caseField, ['FlagLauncher']))?.display_context_parameter;\n  }\n}\n","<!-- Error message summary -->\n<div *ngIf=\"errorMessages.length > 0\" class=\"govuk-error-summary\" aria-labelledby=\"error-summary-title\" role=\"alert\" tabindex=\"-1\" data-module=\"govuk-error-summary\">\n  <h2 class=\"govuk-error-summary__title\" id=\"error-summary-title\">\n    {{'There is a problem' | rpxTranslate}}\n  </h2>\n  <div *ngFor=\"let errorMessage of errorMessages\" class=\"govuk-error-summary__body\">\n    <ul class=\"govuk-list govuk-error-summary__list\">\n      <li>\n        <a (click)=\"navigateToErrorElement(errorMessage.fieldId)\" class=\"validation-error\">{{errorMessage.description | rpxTranslate}}</a>\n      </li>\n    </ul>\n  </div>\n</div>\n<div *ngIf=\"!isDisplayContextParameterUpdate\" class=\"form-group\" [formGroup]=\"formGroup\">\n  <div class=\"govuk-form-group\" [ngSwitch]=\"fieldState\">\n    <ng-container *ngSwitchCase=\"caseFlagFieldState.FLAG_LOCATION\">\n      <ccd-select-flag-location\n        [formGroup]=\"caseFlagParentFormGroup\" [flagsData]=\"flagsData\"\n        (caseFlagStateEmitter)=\"onCaseFlagStateEmitted($event)\"\n        [isDisplayContextParameterExternal]=\"isDisplayContextParameterExternal\"\n      ></ccd-select-flag-location>\n    </ng-container>\n    <ng-container *ngSwitchCase=\"caseFlagFieldState.FLAG_TYPE\">\n      <ccd-select-flag-type [formGroup]=\"caseFlagParentFormGroup\" [jurisdiction]=\"jurisdiction\" [caseTypeId]=\"caseTypeId\"\n        [hmctsServiceId]=\"hmctsServiceId\" [isDisplayContextParameterExternal]=\"isDisplayContextParameterExternal\"\n        [isDisplayContextParameter2Point1Enabled]=\"isDisplayContextParameter2Point1Enabled\"\n        [selectedFlagsLocation]=\"selectedFlagsLocation\"\n        (caseFlagStateEmitter)=\"onCaseFlagStateEmitted($event)\"\n        (flagCommentsOptionalEmitter)=\"onFlagCommentsOptionalEmitted($event)\"></ccd-select-flag-type>\n    </ng-container>\n    <ng-container *ngSwitchCase=\"caseFlagFieldState.FLAG_LANGUAGE_INTERPRETER\">\n      <ccd-search-language-interpreter [formGroup]=\"caseFlagParentFormGroup\"\n        [flagType]=\"flagType\"\n        (caseFlagStateEmitter)=\"onCaseFlagStateEmitted($event)\">\n      </ccd-search-language-interpreter>\n    </ng-container>\n    <ng-container *ngSwitchCase=\"caseFlagFieldState.FLAG_COMMENTS\">\n      <ccd-add-comments [formGroup]=\"caseFlagParentFormGroup\" [optional]=\"flagCommentsOptional\"\n        (caseFlagStateEmitter)=\"onCaseFlagStateEmitted($event)\"\n        [isDisplayContextParameterExternal]=\"isDisplayContextParameterExternal\"\n        [isDisplayContextParameter2Point1Enabled]=\"isDisplayContextParameter2Point1Enabled\">\n      </ccd-add-comments>\n    </ng-container>\n    <ng-container *ngSwitchCase=\"caseFlagFieldState.FLAG_STATUS\">\n      <ccd-confirm-flag-status [formGroup]=\"caseFlagParentFormGroup\" [defaultStatus]=\"flagType.defaultStatus\"\n        (caseFlagStateEmitter)=\"onCaseFlagStateEmitted($event)\"></ccd-confirm-flag-status>\n    </ng-container>\n  </div>\n</div>\n<div *ngIf=\"isDisplayContextParameterUpdate\" class=\"form-group\" [formGroup]=\"formGroup\">\n  <div class=\"govuk-form-group\" [ngSwitch]=\"fieldState\">\n    <ng-container *ngSwitchCase=\"caseFlagFieldState.FLAG_MANAGE_CASE_FLAGS\">\n      <ccd-manage-case-flags [formGroup]=\"caseFlagParentFormGroup\" [flagsData]=\"flagsData\" [caseTitle]=\"caseTitle\"\n        [displayContextParameter]=\"displayContextParameter\"\n        (caseFlagStateEmitter)=\"onCaseFlagStateEmitted($event)\"></ccd-manage-case-flags>\n    </ng-container>\n    <ng-container *ngSwitchCase=\"caseFlagFieldState.FLAG_UPDATE\">\n      <ccd-update-flag [formGroup]=\"caseFlagParentFormGroup\"\n        [displayContextParameter]=\"displayContextParameter\"\n        (caseFlagStateEmitter)=\"onCaseFlagStateEmitted($event)\"></ccd-update-flag>\n    </ng-container>\n    <ng-container *ngSwitchCase=\"caseFlagFieldState.FLAG_UPDATE_WELSH_TRANSLATION\">\n      <ccd-update-flag-add-translation-form\n        [formGroup]=\"caseFlagParentFormGroup\"\n        (caseFlagStateEmitter)=\"onCaseFlagStateEmitted($event)\"\n      ></ccd-update-flag-add-translation-form>\n    </ng-container>\n  </div>\n</div>\n"]}