@sunbird-cb/tree-hierarchy 0.0.1-cbrelease-4.8.26

package/esm2022/lib/components/create-term-from-framework/create-term-from-framework.component.mjs

@@ -0,0 +1,823 @@
+import { Component, Inject } from '@angular/core';
+import { Validators } from '@angular/forms';
+import { MAT_LEGACY_DIALOG_DATA as MAT_DIALOG_DATA } from '@angular/material/legacy-dialog';
+import { labels } from '../../labels/strings';
+import * as appConstants from '../../constants/app-constant';
+import _ from 'lodash';
+import { ConforamtionPopupComponent } from '../conforamtion-popup/conforamtion-popup.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/legacy-dialog";
+import * as i2 from "../../services/framework.service";
+import * as i3 from "@angular/forms";
+import * as i4 from "@angular/material/legacy-snack-bar";
+import * as i5 from "@angular/common";
+import * as i6 from "@angular/material/core";
+import * as i7 from "@angular/material/button";
+import * as i8 from "@angular/material/chips";
+import * as i9 from "@angular/material/dialog";
+import * as i10 from "@angular/material/expansion";
+import * as i11 from "@angular/material/icon";
+import * as i12 from "@angular/material/input";
+import * as i13 from "@angular/material/form-field";
+import * as i14 from "@angular/material/menu";
+import * as i15 from "@angular/material/progress-spinner";
+import * as i16 from "@angular/material/radio";
+import * as i17 from "@angular/material/select";
+export class CreateTermFromFrameworkComponent {
+    constructor(dialogRef, data, dialog, frameWorkService, fb, _snackBar) {
+        this.dialogRef = dialogRef;
+        this.data = data;
+        this.dialog = dialog;
+        this.frameWorkService = frameWorkService;
+        this.fb = fb;
+        this._snackBar = _snackBar;
+        this.app_strings = labels;
+        this.selectedTerm = {};
+        this.selectedTermArray = [];
+        this.isTermExist = false;
+        this.disableCreate = false;
+        this.disableMultiCreate = false;
+        this.disableUpdate = false;
+        this.kcmList = new Map();
+        this.allCompetency = [];
+        this.allCompetencyTheme = [];
+        this.filteredallCompetencyTheme = [];
+        this.allCompetencySubtheme = [];
+        this.filteredallCompetencySubTheme = [];
+    }
+    ngOnInit() {
+        this.environment = this.frameWorkService.getEnviroment();
+        this.getComptencyData();
+        this.kcmConfigData = this.frameWorkService.getConfigByFrameWorkId(this.environment.kcmFrameworkName);
+        this.competencyForm = this.fb.group({
+            compArea: ['', Validators.required],
+            compThemeFields: this.fb.array([this.createCompThemeFields()])
+        });
+    }
+    getComptencyData() {
+        this.frameWorkService.getFrameworkRead(this.environment.kcmFrameworkName).subscribe((data) => {
+            if (data.categories) {
+                this.formateData(data, this.environment.kcmFrameworkName);
+                this.selectedCardCompThemeData = '';
+                if (this.data && this.data.selectedParentTerms) {
+                    this.data.selectedParentTerms.forEach((ele) => {
+                        if (ele.category === "competency") {
+                            this.selectedCardCompThemeData = ele;
+                            let option = this.selectedCardCompThemeData.additionalProperties.competencyArea;
+                            this.onSelectionArea(option);
+                        }
+                    });
+                }
+            }
+        }, ((_err) => {
+            this._snackBar.open(`KCM Framework read failed.`);
+        }));
+    }
+    formateData(response, frameworkId) {
+        (response.categories).forEach((a) => {
+            if (a.code !== undefined) {
+                this.kcmList.set(a.code, {
+                    code: a.code,
+                    identifier: a.identifier,
+                    index: a.index,
+                    name: a.name,
+                    description: a.description,
+                    config: this.frameWorkService.getConfigOfCategoryConfigByFrameWorkId(a.code, frameworkId),
+                    children: (a.terms || []).map((c) => {
+                        const associations = c.associations || [];
+                        if (associations.length > 0) {
+                            Object.assign(c, { children: associations });
+                        }
+                        return c;
+                    })
+                });
+            }
+        });
+        this.kcmList.forEach((a) => {
+            if (a.code === _.get(this.kcmConfigData, 'config[0].category')) {
+                this.competencyArea = a;
+            }
+        });
+    }
+    createCompThemeFields() {
+        return this.fb.group({
+            competencyTheme: ['', [Validators.required]],
+            competencySubTheme: ['', [Validators.required]]
+        });
+    }
+    getCreateName(data) {
+        let popUpCategory = data.cardColInfo ? data.cardColInfo.name : data.columnInfo.name;
+        switch (popUpCategory) {
+            case 'Designation':
+                return `Create Competency Mapping`;
+            case 'Sub Theme':
+                if (data.openMode === 'view') {
+                    return `View Competency ${popUpCategory}`;
+                }
+                return `Add Competency ${popUpCategory}`;
+            case 'Competency':
+                if (data.openMode === 'edit') {
+                    return `Edit Competency Theme`;
+                }
+                else if (data.openMode === 'view') {
+                    return `View Competency Theme`;
+                }
+                return `Create Competency Mapping`;
+            default: return '';
+        }
+    }
+    clearSelectedThemes(option) {
+        if (this.isThemeSelected) {
+            this.openConforamtionPopup(option);
+        }
+        else {
+            this.onSelectionArea(option);
+        }
+    }
+    get isThemeSelected() {
+        let hasValue = false;
+        if (this.competencyForm) {
+            const compThemeFields = this.competencyForm.get('compThemeFields');
+            if (compThemeFields) {
+                compThemeFields.controls.forEach((element) => {
+                    if (element.get('competencyTheme')?.value || element.get('competencySubTheme')?.value) {
+                        hasValue = true;
+                    }
+                });
+            }
+        }
+        return hasValue;
+    }
+    openConforamtionPopup(option) {
+        const dialogData = {
+            dialogType: 'warning',
+            descriptions: [
+                {
+                    header: 'Are you sure you want to alter the competency area?',
+                    headerClass: 'flex items-center justify-center text-blue textBold',
+                    messages: [
+                        {
+                            msgClass: '',
+                            msg: `This action will result in the loss of your currently added data`,
+                        },
+                    ],
+                },
+            ],
+            footerClass: 'items-center justify-center',
+            buttons: [
+                {
+                    btnText: 'Cancel',
+                    btnClass: 'btn-outline',
+                    response: false,
+                },
+                {
+                    btnText: 'Confirm',
+                    btnClass: 'btn-full-success',
+                    response: true,
+                },
+            ],
+        };
+        const dialogRef = this.dialog.open(ConforamtionPopupComponent, {
+            data: dialogData,
+            autoFocus: false,
+            width: '600px',
+            maxWidth: '80vw',
+            maxHeight: '90vh',
+            disableClose: true,
+        });
+        dialogRef.afterClosed().subscribe((res) => {
+            if (res) {
+                this.onSelectionArea(option);
+            }
+            else {
+                const compAreaControl = this.competencyForm.get('compArea');
+                if (compAreaControl) {
+                    compAreaControl.setValue(this.seletedCompetencyArea);
+                    compAreaControl.updateValueAndValidity();
+                }
+            }
+        });
+    }
+    onSelectionArea(option) {
+        this.competencyForm.reset();
+        while (this.compThemeFields.length !== 0) {
+            this.compThemeFields.removeAt(0);
+        }
+        this.compThemeFields.push(this.createCompThemeFields());
+        if ('theme' === this.kcmConfigData.config[1].category) {
+            this.seletedCompetencyArea = option;
+            const compAreaControl = this.competencyForm.get('compArea');
+            if (compAreaControl) {
+                compAreaControl.patchValue(option);
+                compAreaControl.updateValueAndValidity();
+            }
+            this.filteredallCompetencyTheme = [];
+            this.allCompetencyTheme = [];
+            if (option && option.children && option.children.length) {
+                let themeValue = this.kcmList.get(this.kcmConfigData.config[1].category);
+                option.children.forEach((ele) => {
+                    if (ele.category === 'theme') {
+                        let result = themeValue.children.findIndex((themeData) => {
+                            if (ele.refId === themeData.refId) {
+                                return themeData.children && themeData.children.length;
+                            }
+                        });
+                        if (result >= 0) {
+                            this.allCompetencyTheme.push(ele);
+                            this.filteredallCompetencyTheme.push(ele);
+                        }
+                    }
+                });
+            }
+            else {
+                if (this.competencyArea && this.competencyArea.children) {
+                    this.competencyArea.children.forEach((element) => {
+                        if (element.code === option.code) {
+                            this.seletedCompetencyArea = option;
+                            if (element.children && element.children.length) {
+                                element.children.forEach((ele) => {
+                                    if (ele.category === 'theme') {
+                                        this.allCompetencyTheme.push(ele);
+                                        this.filteredallCompetencyTheme.push(ele);
+                                        if (this.selectedCardCompThemeData.refId.toLowerCase() === ele.refId.toLowerCase()) {
+                                            let formArray = this.competencyForm.get('compThemeFields');
+                                            formArray.at(0).get('competencyTheme').patchValue(ele);
+                                            formArray.at(0).get('competencyTheme').updateValueAndValidity();
+                                            const compAreaControl = this.competencyForm.get('compArea');
+                                            if (compAreaControl) {
+                                                compAreaControl.patchValue(option);
+                                                compAreaControl.updateValueAndValidity();
+                                            }
+                                        }
+                                    }
+                                });
+                            }
+                        }
+                    });
+                }
+            }
+        }
+    }
+    addCompetencyTheme() {
+        if (this.data.mode === 'multi-create') {
+            this.compThemeFields.insert(0, this.createCompThemeFields());
+        }
+    }
+    removeCompFields(index) {
+        if (this.data.mode === 'multi-create') {
+            this.compThemeFields.removeAt(index);
+        }
+    }
+    OnThemeSelection(event, _indexValue, optionData) {
+        const selectedTheme = event.source.value;
+        this.kcmList.forEach((ele) => {
+            if (selectedTheme.category === ele.code) {
+                if (ele.children && ele.children.length) {
+                    ele.children.forEach((themeChild) => {
+                        if (themeChild.identifier === selectedTheme.identifier) {
+                            if (themeChild.children && themeChild.children.length) {
+                                optionData['children'] = themeChild.children;
+                                this.filteredallCompetencySubTheme = themeChild.children;
+                                let matchedData = [];
+                                if (this.data.childrenData && this.data.childrenData.category === "subtheme") {
+                                    matchedData = _.intersectionBy(themeChild.children, [this.data.childrenData], 'refId');
+                                }
+                                else {
+                                    matchedData = _.intersectionBy(themeChild.children, this.selectedCardCompThemeData.children, 'refId');
+                                }
+                                let formArray = this.competencyForm.get('compThemeFields');
+                                const competencySubThemeControl = formArray.at(_indexValue).get('competencySubTheme');
+                                if (competencySubThemeControl) {
+                                    competencySubThemeControl.patchValue(matchedData);
+                                    competencySubThemeControl.updateValueAndValidity();
+                                }
+                            }
+                        }
+                    });
+                }
+            }
+        });
+    }
+    onTermRemove(termData, indexValue) {
+        let formArray = this.competencyForm.get('compThemeFields');
+        const compThemeControl = formArray.at(indexValue).get('competencySubTheme');
+        if (compThemeControl) {
+            const themes = compThemeControl.value;
+            if (themes) {
+                const index = themes.indexOf(termData);
+                if (index >= 0) {
+                    themes.splice(index, 1);
+                    compThemeControl.setValue(themes);
+                }
+            }
+        }
+    }
+    OnSubThemeSelection(_event, _indexValue, _option) {
+    }
+    async multiCreate(form, _data) {
+        this.disableMultiCreate = true;
+        let counterSubTheme = 0;
+        let parentCategory = {};
+        let createdTerms = [];
+        let createdSubTheme = [];
+        if (form.valid) {
+            const themeFields = form && form.value && form.value.compThemeFields;
+            if (themeFields && themeFields.length) {
+                let localCompArea = { ...this.seletedCompetencyArea };
+                if (localCompArea.children && localCompArea.children.length) {
+                    delete localCompArea.children;
+                }
+                if (localCompArea.associations && localCompArea.associations.length) {
+                    delete localCompArea.associations;
+                }
+                for (let [index, objVal] of themeFields.entries()) {
+                    parentCategory = {};
+                    if (objVal['competencyTheme']) {
+                        createdTerms = [];
+                        let value = objVal['competencyTheme'];
+                        const term = {
+                            code: this.frameWorkService.getUuid(),
+                            name: value.name,
+                            description: value.description,
+                            category: this.data.columnInfo.code,
+                            status: appConstants.LIVE,
+                            refId: value.refId || '',
+                            refType: value.refType || '',
+                            parents: [
+                                { identifier: `${this.data.frameworkId.toLowerCase()}_${this.data.columnInfo.code}` }
+                            ],
+                            additionalProperties: {
+                                competencyArea: localCompArea,
+                                timeStamp: new Date().getTime()
+                            }
+                        };
+                        const requestBody = {
+                            request: {
+                                term: term
+                            }
+                        };
+                        await this.frameWorkService.createTerm(this.data.frameworkId, this.data.columnInfo.code, requestBody).toPromise().then(async (res) => {
+                            requestBody.request.term['identifier'] = res.result.node_id[0];
+                            this.frameWorkService.selectionList.delete('competency');
+                            parentCategory = requestBody.request.term;
+                            createdTerms.push(requestBody.request.term);
+                            const parentColumn = this.frameWorkService.getPreviousCategory(this.data.columnInfo.code);
+                            let parentCol = this.frameWorkService.selectionList.get(parentColumn.code);
+                            await this.updateTermAssociationsMultiV2(createdTerms, parentCol);
+                            let data = {
+                                "selected": false,
+                                "category": parentColumn.code,
+                                "cardSubType": "minimal",
+                                "isViewOnly": false,
+                                "index": parentColumn.index,
+                                "columnInfo": this.data.cardColInfo
+                            };
+                            const responseData12 = {
+                                res: { term: [this.selectedTerm], created: true, multi: true },
+                                index: this.data.columnInfo.index,
+                                data: data,
+                                type: 'multi-create'
+                            };
+                            this.frameWorkService.updateAfterAddOrEditSubject(responseData12);
+                        });
+                    }
+                    if (objVal['competencySubTheme']) {
+                        this.frameWorkService.selectionList.set(this.data.columnInfo.code, parentCategory);
+                        let value = objVal['competencySubTheme'];
+                        if (value && value.length) {
+                            counterSubTheme = 0;
+                            createdSubTheme = [];
+                            for (let ele of value) {
+                                const term = {
+                                    code: this.frameWorkService.getUuid(),
+                                    name: ele.name,
+                                    description: ele.description,
+                                    category: this.data.nextColInfo.code,
+                                    status: appConstants.LIVE,
+                                    refId: ele.refId || '',
+                                    refType: ele.refType || '',
+                                    parents: [
+                                        { identifier: `${this.data.frameworkId.toLowerCase()}_${this.data.nextColInfo.code}` }
+                                    ],
+                                    additionalProperties: {
+                                        timeStamp: new Date().getTime()
+                                    }
+                                };
+                                const requestBody = {
+                                    request: {
+                                        term: term
+                                    }
+                                };
+                                let responseData = await this.crateTerm(this.data.frameworkId, this.data.nextColInfo.code, requestBody);
+                                requestBody.request.term['identifier'] = responseData.result.node_id[0];
+                                createdSubTheme.push(requestBody.request.term);
+                                counterSubTheme++;
+                                if ((counterSubTheme === objVal['competencySubTheme'].length)) {
+                                    const parentColumnConfigData = this.frameWorkService.getPreviousCategory(this.data.nextColInfo.code);
+                                    let parentCol = this.frameWorkService.selectionList.get(parentColumnConfigData.code);
+                                    await this.updateTermAssociationsMultiV2(createdSubTheme, parentCol, index, themeFields.length);
+                                    if (index === themeFields.length - 1) {
+                                        this.frameWorkService.selectionList.delete('competency');
+                                        this.dialogClose({ term: this.selectedTermArray, created: true, multi: false, callUpdate: false });
+                                        this.disableMultiCreate = false;
+                                        this._snackBar.open(`Competency Mapping created successfully.`);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    async crateTerm(frameworkId, colCode, requestBody) {
+        return new Promise(async (resolve) => {
+            this.frameWorkService.createTerm(frameworkId, colCode, requestBody).subscribe((res) => {
+                resolve(res);
+            }, ((_err) => {
+                this._snackBar.open(`Create Term failed.`);
+            }));
+        });
+    }
+    async updateTermAssociationsMultiV2(createdTerms, parentSelectedTerm, _runningIndex, _themFieldsLength) {
+        if (createdTerms && createdTerms.length) {
+            this.selectedTermArray = [];
+            let createdTermsIdentifiers = [];
+            this.selectedTermArray = createdTerms;
+            this.selectedTerm = createdTerms[createdTerms.length - 1];
+            for (let createdTerm of createdTerms) {
+                createdTermsIdentifiers.push({ identifier: createdTerm.identifier });
+            }
+            let associations = [];
+            let counter = 0;
+            if (!parentSelectedTerm) {
+                for (const [value] of this.frameWorkService.selectionList) {
+                    const parent = value;
+                    counter++;
+                    associations = parent.children ? parent.children.map((c) => {
+                        return c.identifier ? { identifier: c.identifier } : null;
+                    }) : [];
+                    associations = [...associations, ...createdTermsIdentifiers];
+                    this.isTermExist = false;
+                    const reguestBody = {
+                        request: {
+                            term: {
+                                ...(associations && associations.length) ? { associations: [...associations] } : null,
+                            }
+                        }
+                    };
+                    await this.callUpdateAssociationsV2(counter, parent, reguestBody);
+                }
+            }
+            else {
+                const parent = parentSelectedTerm;
+                associations = parent.children ? parent.children.map((c) => {
+                    return c.identifier ? { identifier: c.identifier } : null;
+                }) : [];
+                associations = [...associations, ...createdTermsIdentifiers];
+                this.isTermExist = false;
+                const reguestBody = {
+                    request: {
+                        term: {
+                            ...(associations && associations.length) ? { associations: [...associations] } : null,
+                        }
+                    }
+                };
+                return await this.callUpdateAssociationsV2(counter, parent, reguestBody);
+                this.disableMultiCreate = false;
+            }
+        }
+    }
+    async updateTermAssociationsMulti(createdTerms) {
+        if (createdTerms && createdTerms.length) {
+            for (let createdTerm of createdTerms) {
+                this.selectedTerm = createdTerm;
+                let associations = [];
+                let temp;
+                let counter = 0;
+                for (const [value] of this.frameWorkService.selectionList) {
+                    const parent = value;
+                    counter++;
+                    temp = parent.children ? parent.children.filter((child) => child.identifier === this.selectedTerm.identifier) : null;
+                    associations = parent.children ? parent.children.map((c) => {
+                        return c.identifier ? { identifier: c.identifier } : null;
+                    }) : [];
+                    if (temp && temp.length) {
+                        this.isTermExist = true;
+                        return;
+                    }
+                    else {
+                        associations.push({ identifier: this.selectedTerm.identifier });
+                        this.isTermExist = false;
+                        const reguestBody = {
+                            request: {
+                                term: {
+                                    ...(associations && associations.length) ? { associations: [...associations] } : null,
+                                }
+                            }
+                        };
+                        await this.callUpdateAssociations(counter, parent, reguestBody);
+                    }
+                }
+            }
+        }
+    }
+    async callUpdateAssociationsV2(counter, parent, reguestBody) {
+        return new Promise(async (resolve) => {
+            this.frameWorkService.updateTerm(this.data.frameworkId, parent.category, parent.code, reguestBody).subscribe(async () => {
+                parent['children'] = parent && parent.children ? [...parent.children, ...this.selectedTermArray] : this.selectedTermArray;
+                let listData = this.frameWorkService.list.get(this.data.columnInfo.code);
+                let differenceData = [];
+                if (listData && listData.children && listData.children.length) {
+                    differenceData = _.differenceBy(this.selectedTermArray, listData.children, 'identifier');
+                }
+                else {
+                    differenceData = this.selectedTermArray;
+                }
+                listData['associations'] = listData && listData.associations ? [...listData.associations, ...differenceData] : differenceData;
+                listData['children'] = listData && listData.children ? [...listData.children, ...differenceData] : differenceData;
+                this.frameWorkService.selectionList.forEach((selectedData) => {
+                    let listData = this.frameWorkService.list.get(selectedData.category);
+                    if (listData && listData.children && listData.children.length) {
+                        this.updateLocalList(listData, parent, this.selectedTermArray);
+                    }
+                });
+                if (counter === this.frameWorkService.selectionList.size) {
+                    this.disableUpdate = false;
+                    let returnValue = true;
+                    resolve(true);
+                    await returnValue;
+                }
+                else {
+                    let returnValue = true;
+                    resolve(true);
+                    await returnValue;
+                }
+            }, (_err) => {
+                console.error(`Edit ${this.data.columnInfo.name} failed, please try again later`);
+                this._snackBar.open(`Term Association failed.`);
+                this.disableMultiCreate = false;
+            });
+        });
+    }
+    async callUpdateAssociations(counter, parent, reguestBody) {
+        return new Promise(async (resolve) => {
+            this.frameWorkService.updateTerm(this.data.frameworkId, parent.category, parent.code, reguestBody).subscribe(async () => {
+                if (counter === this.frameWorkService.selectionList.size) {
+                    const found = parent.children ? parent.children.find((c) => c.identifier === this.selectedTerm.identifier) : false;
+                    if (!found) {
+                        parent.children ? parent.children.push(this.selectedTerm) : parent['children'] = [this.selectedTerm];
+                    }
+                    this.disableUpdate = false;
+                    let returnValue = true;
+                    resolve(true);
+                    await returnValue;
+                }
+                else {
+                    let returnValue = true;
+                    resolve(true);
+                    await returnValue;
+                }
+            }, (_err) => {
+                console.error(`Edit ${this.data.columnInfo.name} failed, please try again later`);
+            });
+        });
+    }
+    updateTermData(form, data) {
+        this.disableUpdate = true;
+        const formData = {
+            ...form.value
+        };
+        const updateData = {
+            formData,
+            updateTermData: data.childrenData
+        };
+        this.updateTermAssociations(updateData);
+    }
+    updateTermAssociations(updateData) {
+        let associations = [];
+        let temp;
+        let counter = 0;
+        this.frameWorkService.selectionList.forEach((parent) => {
+            counter++;
+            temp = parent.children ? parent.children.filter((child) => child.identifier === this.selectedTerm.identifier) : null;
+            associations = parent.children ? parent.children.map((c) => {
+                return c.identifier ? { identifier: c.identifier } : null;
+            }) : [];
+            if (temp && temp.length) {
+                this.isTermExist = true;
+                return;
+            }
+            else {
+                if (this.selectedTerm && this.selectedTerm.identifier) {
+                    associations.push({ identifier: this.selectedTerm.identifier });
+                }
+                this.isTermExist = false;
+                const reguestBody = {
+                    request: {
+                        term: {
+                            ...(updateData && updateData.formData && updateData.updateTermData.code === parent.code) ? { ...updateData.formData } : null,
+                            ...(associations && associations.length) ? { associations: [...associations] } : null,
+                        }
+                    }
+                };
+                this.frameWorkService.updateTerm(this.data.frameworkId, parent.category, parent.code, reguestBody).subscribe(() => {
+                    if (counter === this.frameWorkService.selectionList.size) {
+                        const value = (this.selectedTerm && this.selectedTerm.identifier) ? this.selectedTerm : (updateData) ? { ...updateData.updateTermData, ...updateData.formData } : {};
+                        this.disableUpdate = false;
+                        this.dialogClose({ term: { ...value }, created: true });
+                    }
+                }, (_err) => {
+                    console.error(`Edit ${this.data.columnInfo.name} failed, please try again later`);
+                    this._snackBar.open(`Term Association failed.`);
+                    this.disableMultiCreate = false;
+                });
+            }
+        });
+    }
+    dialogClose(term) {
+        this.frameWorkService.publishFramework().subscribe(() => {
+            this.disableMultiCreate = false;
+            this.dialogRef.close(term);
+        }, (_err) => {
+            this.disableMultiCreate = false;
+            this.dialogRef.close(term);
+            this._snackBar.open(`Publish  failed.`);
+        });
+    }
+    async multiCreateSubTheme(_form, data) {
+        this.disableMultiCreate = true;
+        let formArray = this.competencyForm.get('compThemeFields');
+        let selectedFormData = formArray.at(0).get('competencySubTheme').value;
+        let previousSubThemeData = data.childrenData.children;
+        let newlyAdded = [];
+        let removedExisting = [];
+        let createdSubTheme = [];
+        let counterSubTheme = 0;
+        newlyAdded = _.differenceBy(selectedFormData, previousSubThemeData, 'refId');
+        removedExisting = _.differenceBy(previousSubThemeData, selectedFormData, 'refId');
+        if (newlyAdded && newlyAdded.length) {
+            for (let val of newlyAdded) {
+                const term = {
+                    code: this.frameWorkService.getUuid(),
+                    name: val.name,
+                    description: val.description,
+                    category: this.data.columnInfo.code,
+                    status: appConstants.LIVE,
+                    refId: val.refId,
+                    refType: val.refType,
+                    parents: [
+                        { identifier: `${this.data.frameworkId.toLowerCase()}_${this.data.columnInfo.code}` }
+                    ],
+                    additionalProperties: {
+                        timeStamp: new Date().getTime()
+                    }
+                };
+                const requestBody = {
+                    request: {
+                        term: term
+                    }
+                };
+                const parentColumnConfigData = this.frameWorkService.getPreviousCategory(this.data.columnInfo.code);
+                let parentCol = this.frameWorkService.selectionList.get(parentColumnConfigData.code);
+                let responseData = await this.crateTerm(this.data.frameworkId, this.data.columnInfo.code, requestBody);
+                requestBody.request.term['identifier'] = responseData.result.node_id[0];
+                createdSubTheme.push(requestBody.request.term);
+                counterSubTheme++;
+                if (counterSubTheme === newlyAdded.length) {
+                    await this.updateTermAssociationsMultiV2(createdSubTheme, parentCol);
+                    this.frameWorkService.updateFrameworkList(this.data.columnInfo.code, parentCol, createdSubTheme, 'create');
+                    if (!(removedExisting && removedExisting.length)) {
+                        this.dialogClose({ term: this.selectedTermArray, created: true, multi: true, callUpdate: false });
+                        this.disableMultiCreate = false;
+                        this._snackBar.open(`Competency theme updated successfully.`);
+                    }
+                }
+            }
+        }
+        if (removedExisting && removedExisting.length) {
+            let removedTermsCollection = [];
+            for (let removedTerm of removedExisting) {
+                removedTermsCollection.push(removedTerm.code);
+            }
+            let subThemeRequest = {
+                "request": {
+                    "contentIds": removedTermsCollection
+                }
+            };
+            await this.frameWorkService.retireMultipleTerm(this.data.frameworkId, this.data.columnInfo.code, subThemeRequest).toPromise().then(async () => {
+                const parentColumnConfigData = this.frameWorkService.getPreviousCategory(this.data.columnInfo.code);
+                let parentCol = this.frameWorkService.selectionList.get(parentColumnConfigData.code);
+                const sectionListchildrenList = _.differenceWith(parentCol.children, removedExisting, (a, b) => a.identifier === b.identifier);
+                const sectionListAssociationList = _.differenceWith(parentCol.associations, removedExisting, (a, b) => a.identifier === b.identifier);
+                parentCol['children'] = sectionListchildrenList;
+                parentCol['associations'] = sectionListAssociationList;
+                this.frameWorkService.updateFrameworkList(this.data.columnInfo.code, parentCol, removedExisting, 'delete');
+                this.dialogClose({ term: [], created: true, multi: true, callUpdate: false });
+                this.frameWorkService.currentSelection.next({ type: parentColumnConfigData.code, data: parentCol, cardRef: parentCol.cardRef });
+                this.disableMultiCreate = false;
+                this._snackBar.open(`Competency theme updated successfully.`);
+            });
+        }
+        this.disableMultiCreate = false;
+    }
+    onDisableTheme(option) {
+        const parentColumnConfigData = this.frameWorkService.getPreviousCategory(this.data.columnInfo.code);
+        let parentCol = this.frameWorkService.selectionList.get(parentColumnConfigData.code);
+        let result = -1;
+        if (parentCol && parentCol.children && parentCol.children.length) {
+            result = parentCol.children.findIndex((ele) => {
+                if ((ele.refType === 'theme') && (this.seletedCompetencyArea.code === ele.additionalProperties.competencyArea.code)) {
+                    return ele.refId === option.refId;
+                }
+                return false;
+            });
+        }
+        if (result < 0) {
+            let formArray = this.competencyForm.get('compThemeFields');
+            result = formArray.value.findIndex((formEle) => {
+                if (formEle.competencyTheme && formEle.competencyTheme.refId) {
+                    return formEle.competencyTheme.refId === option.refId;
+                }
+                return false;
+            });
+        }
+        return result >= 0 ? true : false;
+    }
+    updateLocalList(item, parent, selectedTermArray, updateType) {
+        if (item && item.children && item.children.length) {
+            if (updateType === 'delete') {
+                item.children.forEach((itmData) => {
+                    if (itmData.identifier === parent.identifier) {
+                        const associationList = _.differenceWith(itmData.associations, selectedTermArray, (a, b) => a.identifier === b.identifier);
+                        const childrenList = _.differenceWith(itmData.children, selectedTermArray, (a, b) => a.identifier === b.identifier);
+                        itmData['associations'] = associationList;
+                        itmData['children'] = childrenList;
+                    }
+                    if (itmData.children) {
+                        this.updateLocalList(itmData, parent, selectedTermArray, updateType);
+                    }
+                });
+            }
+            else {
+                item.children.forEach((itmData) => {
+                    if (itmData.identifier === parent.identifier) {
+                        let differenceData = [];
+                        if (itmData && itmData.children && itmData.children.length) {
+                            differenceData = _.differenceBy(selectedTermArray, itmData.children, 'identifier');
+                        }
+                        else {
+                            differenceData = selectedTermArray;
+                        }
+                        itmData['associations'] = itmData && itmData.associations ? [...itmData.associations, ...differenceData] : differenceData;
+                        itmData['children'] = itmData && itmData.children ? [...itmData.children, ...differenceData] : differenceData;
+                    }
+                    if (itmData.children) {
+                        this.updateLocalList(itmData, parent, selectedTermArray);
+                    }
+                });
+            }
+        }
+    }
+    deleteTheme() {
+        this.disableMultiCreate = true;
+        const cardData = this.data.childrenData;
+        let removedListTerm = [];
+        removedListTerm.push(cardData.code);
+        let subThemeRequest = {
+            "request": {
+                "contentIds": removedListTerm
+            }
+        };
+        this.frameWorkService.retireMultipleTerm(this.frameWorkService.frameworkId, cardData.category, subThemeRequest).toPromise().then(async () => {
+            let removedExisting = [cardData];
+            const parentColumnConfigData = this.frameWorkService.getPreviousCategory(cardData.category);
+            let parentCol = this.frameWorkService.selectionList.get(parentColumnConfigData.code);
+            const sectionListchildrenList = _.differenceWith(parentCol.children, removedExisting, (a, b) => a.identifier === b.identifier);
+            const sectionListAssociationList = _.differenceWith(parentCol.associations, removedExisting, (a, b) => a.identifier === b.identifier);
+            parentCol['children'] = sectionListchildrenList;
+            parentCol['associations'] = sectionListAssociationList;
+            this.frameWorkService.updateFrameworkList(cardData.category, parentCol, removedExisting, 'delete');
+            this.frameWorkService.currentSelection.next({ type: parentColumnConfigData.code, data: parentCol, cardRef: parentCol.cardRef });
+            this.dialogClose({});
+            this.disableMultiCreate = false;
+            this._snackBar.open(`Competency theme deleted successfully.`);
+        }, ((_err) => {
+            this.disableMultiCreate = false;
+            this._snackBar.open(`Competency theme delete failed.`);
+        }));
+    }
+    get compThemeFields() {
+        return this.competencyForm.get('compThemeFields');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CreateTermFromFrameworkComponent, deps: [{ token: i1.MatLegacyDialogRef }, { token: MAT_DIALOG_DATA }, { token: i1.MatLegacyDialog }, { token: i2.FrameworkService }, { token: i3.UntypedFormBuilder }, { token: i4.MatLegacySnackBar }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CreateTermFromFrameworkComponent, selector: "lib-create-term-from-framework", ngImport: i0, template: "\n<div class=\"\">\n    <ng-container *ngIf=\"disableMultiCreate\">\n        <div class=\"flex flex-col flex-1 w-100 absolute loader-bg items-center pt-5 text-center\">\n          <mat-spinner class=\"display-inline-block mb-5\" [diameter]=\"50\" [strokeWidth]=\"3\"></mat-spinner>\n          <!-- <p>{{loaderMsg}}</p> -->\n        </div>\n      </ng-container>\n      <div class=\"dialogNew\">\n        <div class=\"flex items-center justify-between\">\n            <ng-container [ngTemplateOutlet]=\"modalTitle\"></ng-container>\n            <button type=\"button\" mat-icon-button i18n-aria-label aria-label=\"action items\"\n            [matMenuTriggerFor]=\"cardMenu\" [matMenuTriggerData]=\"{'data':data}\" class=\"action-btn\">\n            <mat-icon>more_vert</mat-icon>\n            </button>\n        </div>\n        <div class=\"flex gap-4\">\n            <ng-container *ngFor=\"let term of data?.selectedParentTerms\">\n                <ng-container *ngIf=\"term.category !== 'competency'\">\n                    <div class=\"flex-1 flex-col\">\n                        <label for=\"name\" class=\"margin-remove-bottom form-label\" aria-label=\"First name label\">\n                            {{frameWorkService.getConfig(term.category).labelName}}\n                        </label>\n                        <mat-form-field appearance=\"outline\" class=\"flex-1\">\n                            <input matInput name=\"name\" id=\"name\" #name placeholder=\"{{app_strings.name}}\"\n                                [value]=\"term.name\" disabled>\n                        </mat-form-field>\n                    </div>\n                </ng-container>\n            </ng-container>\n        </div>\n        <div class=\"row-divider\"></div>\n        <ng-container *ngIf=\"competencyForm\">\n            <form [formGroup]=\"competencyForm\">\n                <div class=\"title-text\">\n                    <label for=\"name\" class=\"margin-remove-bottom form-label required\" aria-label=\"First name labe \">\n                        {{'Select Area'}}\n                    </label>\n                    <div class=\"mt-5\">\n                        <mat-radio-group class=\"competency-group\" aria-label=\"Select an option\" formControlName=\"compArea\">\n                            <mat-radio-button  [disabled]=\"data?.columnInfo?.code === 'subtheme' || data.openMode ==='view'\" class=\"learning-section\" [ngClass]=\"{'active-btn':item?.code === seletedCompetencyArea?.code}\"\n                             *ngFor=\"let item of competencyArea?.children\" [value]=\"item\" [checked]=\"item?.code === seletedCompetencyArea?.code\" (change)=\"clearSelectedThemes(item)\">{{item.name}}</mat-radio-button>\n                        </mat-radio-group>\n                    </div>\n                </div>\n                <ng-container *ngIf=\"data?.mode === 'multi-create'\">\n                        <div class=\"flex flex-end mb-4\" >\n                            <ng-container *ngIf=\"data?.columnInfo?.code !== 'subtheme'\">\n                                <button type=\"button\" class=\"mat-button flex items-center create-accordion-btn\" *ngIf=\"data.mode === 'multi-create'\" (click)=\"addCompetencyTheme()\">\n                                    <mat-icon class=\"mr-2 mat-icon-custom \">add_circle_outline</mat-icon>\n                                    Add more\n                                    <!-- {{data.columnInfo.name}}  -->\n                                </button>\n                            </ng-container>\n                        </div>\n                        <mat-accordion formArrayName=\"compThemeFields\">\n                            <mat-expansion-panel *ngFor=\"let field of competencyForm?.get('compThemeFields')['controls']; let i = index; let isFirst = first\" \n                            class=\"margin-bottom-l comp-theme-fields\" [formGroupName]=\"i\" [expanded]=\"isFirst\">               \n                             <mat-expansion-panel-header>\n                                    <mat-panel-title>\n                                        {{competencyForm?.get('compThemeFields')['controls'][i]['controls']?.competencyTheme?.value?.name}} \n                                    </mat-panel-title>\n                                    <ng-container *ngIf=\"data?.columnInfo?.code !== 'subtheme'\">\n                                        <button mat-button type=\"button\" *ngIf=\"data.mode === 'multi-create'\"\n                                        (click)=\"removeCompFields(i)\">\n                                        <mat-icon class=\"mat-icon-custom \">delete</mat-icon>\n                                        </button>\n                                    </ng-container>\n                                </mat-expansion-panel-header>\n                                <div class=\"input-column\">\n                                    <div class=\"input-wrapper margin-top-s\">\n                                        <div class=\"flex gap-4 \">\n                                            <div class=\"flex-1 flex-col\">\n                                                <label for=\"name\" class=\"margin-remove-bottom form-label required\"\n                                                    aria-label=\"First name label\">\n                                                    {{data.openMode !== 'view'? 'Select Competency Theme': 'Competency Theme Name'}}\n                                                </label>\n                                                <mat-form-field appearance=\"outline\" class=\"flex-1\">\n                                                    <mat-select [disabled]=\"data?.columnInfo?.code === 'subtheme' || data.openMode ==='view'\" placeholder=\"Choose the Competency Theme\" formControlName=\"competencyTheme\">\n                                                        <ng-container >\n                                                            <ng-container >\n                                                                <mat-option *ngFor=\"let option of filteredallCompetencyTheme\"  [value]=\"option\" [disabled]=\"onDisableTheme(option) || data.openMode ==='view'\" \n                                                                (onSelectionChange)=\"OnThemeSelection($event, i, option)\"  >{{option.name}}\n                                                                <ng-container *ngIf=\"option.refId\">\n                                                                <span class=\"ml-2 ref-id\">({{option.refId}})</span>\n                                                                </ng-container>\n                                                               </mat-option>\n                                                            </ng-container>\n                                                        </ng-container>\n                                                    </mat-select>\n                                                </mat-form-field>\n                                                <mat-error *ngIf=\"isTermExist\">{{app_strings.alreadyExist}}</mat-error>\n                                            </div>\n                                        </div>\n            \n                                        <div class=\"flex-col mt-2\">\n                                            <label for=\"fname\" class=\"margin-remove-bottom form-label required\"\n                                                i18n=\"First Name label|Label which explains the user to enter first name\"\n                                                i18n-aria-label aria-label=\"First name label\">\n\n                                                {{data.openMode !== 'view'? 'Select Competency Sub-Theme': 'Competency Sub-Theme Name'}}\n                                                \n                                            </label>\n                                            <!-- <mat-form-field appearance=\"outline\" class=\"flex-1\">\n                                                <mat-select placeholder=\"Choose the Competency Theme\" formControlName=\"competencySubTheme\">\n                                                    <mat-option *ngFor=\"let option of filteredallCompetencySubTheme\" [value]=\"option\">{{option.name}}</mat-option>\n                                                </mat-select>\n                                            </mat-form-field> -->\n                                            <!-- {{competencyForm?.get('compThemeFields')['controls'][i]['controls']?.competencySubTheme?.value |json}} -->\n                                            <mat-form-field appearance=\"outline\" class=\"w-full field-height\" >\n                                                <mat-select class=\" placeholder-text\" placeholder=\"Choose the Competency Sub-Theme\"\n                                                  formControlName=\"competencySubTheme\" multiple [disabled]=\"data.openMode ==='view'\" panelClass=\"full-width-panel\">\n                                                  <!-- [ngClass]=\"{'disbaledSelect':isHideData}\" -->\n                                                  <mat-select-trigger >\n                                                    <mat-chip-listbox>\n                                                        <!-- -->\n                                                       \n                                                      <mat-chip *ngFor=\"let item of competencyForm?.get('compThemeFields')['controls'][i]['controls']?.competencySubTheme?.value\" \n                                                      (removed)=\"onTermRemove(item, i)\" [disabled]=\"data.openMode ==='view'\"\n                                                      [ngClass]=\"{'sub-theme-disable': data?.openMode ==='view'}\"  [removable]=\"data?.openMode ==='view'? false: true\">\n                                                        <span >{{ item.name }}</span>\n                                                        <mat-icon matChipRemove>cancel</mat-icon>\n                                                      </mat-chip>\n                                                    </mat-chip-listbox>\n                                                  </mat-select-trigger>\n                                                  <!-- {{competencyForm?.get('compThemeFields') |json}} -->\n                                                  <!-- <mat-optgroup>\n                                                    <mat-form-field floatLabel=\"never\">\n                                                      <input #search autocomplete=\"off\" placeholder=\"Search\" (keydown.space)=\"$event.stopPropagation()\"\n                                                        formControlName=\"competencySubTheme\" matInput>\n                                                    </mat-form-field>\n                                                  </mat-optgroup> -->\n                                                  <mat-optgroup *ngIf=\"filteredallCompetencySubTheme.length === 0\">\n                                                    <div>No results found!</div>\n                                                  </mat-optgroup>\n                                                  <!-- <mat-option *ngFor=\"let option of requestObjData.preferredProvider\" [value]=\"option.providerName\">{{option.providerName}}</mat-option> -->\n                                                  <ng-container *ngFor=\"let option of competencyForm?.get('compThemeFields')['controls'][i]['controls']?.competencyTheme?.value?.children\">\n                                                        <mat-option \n                                                        [value]=\"option\" class=\"mat-option-list\">{{option?.name}}\n                                                        <ng-container *ngIf=\"option?.refId\">\n                                                         <span class=\"ml-2 ref-id\">({{option?.refId}})</span>\n                                                        </ng-container>\n                                                     </mat-option>\n                                                  </ng-container>\n                                \n                                                </mat-select>\n                                                <!-- <mat-error *ngIf=\"requestForm.controls['providerText'].hasError('required')\">\n                                                  Please select up to five preferred providers for the request.\n                                                </mat-error> -->\n                                              </mat-form-field>\n                                        </div>\n                                    </div>\n                                </div>\n                            </mat-expansion-panel>\n                        </mat-accordion>\n                        <footer class=\"actions\">\n                            <button mat-raised-button color=\"default\" type=\"reset\"\n                                (click)=\"dialogClose('')\">{{app_strings.cancel}}</button>\n                            <ng-container *ngIf=\"data?.mode === 'create' && data.openMode !=='view'\">\n                                <button mat-raised-button color=\"primary\" type=\"submit\" cdkFocusInitial\n                                    [disabled]=\"competencyForm?.invalid\" *ngIf=\"!disableCreate\">{{app_strings.create}}</button>\n                            </ng-container>\n                            <ng-container *ngIf=\"data?.mode === 'multi-create' && data.openMode !=='view'\">\n                                <ng-container *ngIf=\"data?.columnInfo?.code !== 'subtheme'\">\n                                    <button mat-raised-button color=\"primary\" type=\"button\" cdkFocusInitial\n                                    [disabled]=\"competencyForm.invalid || disableMultiCreate\" *ngIf=\"!disableCreate\" (click)=\"multiCreate(competencyForm, data)\">\n                                    {{app_strings.create}}\n                                    </button>\n                                </ng-container>\n                                <ng-container *ngIf=\"data?.columnInfo?.code === 'subtheme'\">\n                                    <!-- <ng-container *ngIf=\"competencyForm?.get('compThemeFields')['controls'][0]['controls']?.competencySubTheme?.value?.length;else updateBtn\"> -->\n                                        <button mat-raised-button color=\"primary\" type=\"button\" cdkFocusInitial\n                                        [disabled]=\"competencyForm.invalid || disableMultiCreate\" *ngIf=\"!disableCreate\" (click)=\"multiCreateSubTheme(competencyForm, data)\">\n                                        {{app_strings.update}}\n                                        </button>\n                                    <!-- </ng-container> -->\n                                    \n                                    <!-- <ng-template #updateBtn>\n                                        <button mat-raised-button color=\"primary\" type=\"button\" cdkFocusInitial\n                                        [disabled]=\"competencyForm.invalid || disableMultiCreate\" *ngIf=\"!disableCreate\" (click)=\"multiCreateSubTheme(competencyForm, data)\">\n                                        {{app_strings.delete}}\n                                        </button>\n                                    </ng-template> -->\n                                </ng-container>\n                            </ng-container>\n                            <ng-container *ngIf=\"data?.mode === 'edit' && data.openMode !=='view'\">\n                                <button mat-raised-button color=\"primary\" type=\"button\" cdkFocusInitial\n                                    (click)=\"updateTermData(competencyForm, data)\"\n                                    [disabled]=\"competencyForm?.invalid || disableUpdate\"\n                                    *ngIf=\"!disableCreate\">{{app_strings.update}}</button>\n                            </ng-container>\n                        </footer>\n                    </ng-container>\n                </form>\n        </ng-container>\n    \n    </div>\n    \n    \n    <!-- Title of the popup -->\n    <ng-template #modalTitle>\n        <!-- <ng-container *ngIf=\"data?.mode === 'create' || data?.mode === 'multi-create'\">\n            <div class=\"dialog-title\" mat-dialog-title>{{data.columnInfo.name === 'Theme' ? app_strings.addCompetency : app_strings.createNew}} {{data.columnInfo.name}}</div>\n        </ng-container> -->\n        <!-- {{data |json}} -->\n        <ng-container *ngIf=\"data?.mode === 'create' || data?.mode === 'multi-create'\">\n            <div class=\"dialog-title\" mat-dialog-title>{{getCreateName(data)}}</div>\n        </ng-container>\n        <!-- <ng-container *ngIf=\"data?.mode === 'view'\">\n            <div class=\"dialog-title\" mat-dialog-title>View {{data.columnInfo.name}}</div>\n        </ng-container> -->\n        <ng-container *ngIf=\"data?.mode === 'edit'\">\n            <div class=\"dialog-title\" mat-dialog-title>{{app_strings.edit}} {{data.columnInfo.name}}</div>\n        </ng-container>\n    </ng-template>\n</div>\n\n\n<mat-menu #cardMenu=\"matMenu\" class=\"menu-sec\">\n    <ng-template matMenuContent let-rowData=\"data\" let-cardRef=\"cardRef\">\n        <button  (click)=\"deleteTheme()\"\n            mat-menu-item name=\"channel-analytics-button\" class=\"ws-mat-primary-text\" i18n-aria-label\n            aria-label=\"Analytics\">\n            <mat-icon>delete</mat-icon>\n            <span>Delete</span>\n        </button>\n    </ng-template>\n</mat-menu>", styles: [".gap-3{gap:1.25rem}.gap-4{gap:1.5rem}.row-divider{width:100%;border-top:1px solid rgba(0,0,0,.08);margin:1rem 0}.defaultForm{padding:16px;display:flex;gap:16px;flex-direction:column}.theme-actions{display:flex;justify-content:right;padding:1em 0;gap:16px;margin-top:30px;border-top:1px solid rgba(0,0,0,.0784313725)}.dialog .mat-dialog-title{padding:1em;margin-bottom:0;background:#00000014}.dialog .mat-form-field{padding:0;background:#fff;border-radius:2px}.dialog .mat-form-field ::ng-deep .mat-form-field-wrapper{padding-bottom:0}.dialog .mat-form-field ::ng-deep .mat-form-field-wrapper .mat-form-field-infix{padding:15px;margin-top:0;border-top:0}.dialog .mat-form-field ::ng-deep .mat-form-field-wrapper .mat-form-field-infix textarea{resize:none}.dialog .mat-form-field-disabled{background:#00000014}.dialog .actions{display:flex;flex-direction:row;justify-content:space-between;padding:0 1em 1em}.dialog .mat-error{padding:0 25px;margin-top:-10px}.dialogNew{padding:1rem}.dialogNew .mat-dialog-title{padding:1em 0;margin-bottom:0}.dialogNew .actions{display:flex;justify-content:right;padding:1em 0;gap:16px;margin-top:16px;border-top:1px solid rgba(0,0,0,.0784313725)}.dialogNew .mat-error{margin-top:-10px}.dialogNew .learning-section{padding:10px!important;border:1px solid rgba(0,0,0,.1803921569);border-radius:4px;margin-right:8px}.dialogNew .learning-section.active-btn{border:1px solid #1B4CA1!important}.learning-section.mat-radio-button .mat-radio-container .mat-radio-outer-circle{border-color:#1b4ca1!important}::ng-deep .competency-group .learning-section .mat-radio-inner-circle{background-color:#1b4ca1!important}::ng-deep .competency-group .learning-section .mat-radio-button.mat-accent .mat-radio-inner-circle{background-color:#1b4ca1!important}.dialog-title{align-items:center;display:flex}.flex{display:flex}.flex-col{display:flex;flex-direction:column}.mr-5{margin-right:1.5rem}.flex-1{flex:1 1}.margin-remove-bottom{margin-bottom:0}::ng-deep .custom-dialog-container{max-height:90vh}::ng-deep .custom-dialog-container .mat-dialog-container{padding:0;border-radius:0;background:#00000014}@media only screen and (max-width: 1024px){::ng-deep .cdk-overlay-pane{width:40%!important}}@media only screen and (max-width: 992px){::ng-deep .cdk-overlay-pane{width:45%!important}}@media only screen and (max-width: 1024px){.dialog{font-size:12px}.dialog .dialog-title{font-size:24px;height:1em}.dialog button{font-size:12px;line-height:3.5em}.dialog .mat-raised-button{padding:0 3em}}.flex-align{align-items:center;justify-content:flex-start}::ng-deep mat-form-field .mat-form-field-infix .mat-form-field-label,::ng-deep mat-form-field .mat-form-field-infix .mat-select-value{line-height:normal!important}ws-widget-btn-page-back-admin{margin-left:-270px}.max-wid{max-width:400px}::ng-deep .mat-form-field.mat-focused .mat-form-field-label{color:#333232!important}.margin-right-10{margin-right:10px!important}input::-webkit-outer-spin-button,input::-webkit-inner-spin-button{-webkit-appearance:none;margin:0}input[type=number]{-moz-appearance:textfield}::ng-deep .mat-tab-header{margin:0 3rem}.heading{color:#222}.heading.mt-10{margin-top:2.5rem!important}.img-column{flex:100px 0 0}.input-column{flex:auto}.radio-toolbar input[type=radio]{opacity:0;position:fixed;width:0}.radio-toolbar{padding:10px 0}.radio-toolbar label{display:inline-block;padding:7px 21px;font-size:14px;background:#fff 0% 0% no-repeat padding-box;border:1px solid #5F5F5F;border-radius:4px;margin:0 10px 10px 0;color:#5f5f5f;cursor:pointer;transition:all .125s ease-in-out}.radio-toolbar input[type=radio]:checked+label{background:#0074b6 0% 0% no-repeat padding-box;border-radius:6px;border-color:#0074b6;color:#fff}.radio-toolbar input[type=radio]:focus+label{background:#0074b6 0% 0% no-repeat padding-box;border-radius:6px;border-color:#0074b6;color:#fff}.mar{margin-left:30px;min-width:175px}.radio-toolbar label:hover{background:none;border-color:#0074b6;color:#0074b6}::ng-deep .mat-form-field{width:100%}::ng-deep .mat-form-field.full-width{max-width:100%}::ng-deep .mat-form-field.no-pb .mat-form-field-wrapper{padding-bottom:0}.combined-field{width:100%}.w-full-imp{width:100%!important}::ng-deep .full-width-panel{width:100%!important;min-width:300px}::ng-deep .full-width-panel .mat-option{white-space:normal}.btn-success{background-color:#0075b7!important;border-radius:4px;width:240px;box-shadow:none;margin-right:16px}.btn-success.btn-responsive{width:100%}.btn-success:disabled,.btn-success[disabled]{opacity:.6}.btn-danger{height:30px;width:30px}.color-danger{font-size:30px;height:30px;width:30px;color:#e44}::ng-deep .mat-form-field-outline{min-height:40px;background:#fff;border-radius:4px}::ng-deep .mat-form-field-outline .mat-form-field-outline-start{border:1px solid rgba(112,112,112,.4117647059);border-radius:4px 0 0 4px;min-width:8px;border-right-style:none}::ng-deep .mat-form-field-outline .mat-form-field-outline-gap{border:1px solid currentColor;border-radius:82px;border-left-style:none;border-right-style:none}::ng-deep .mat-form-field-outline .mat-form-field-outline-end{border:1px solid rgba(112,112,112,.4117647059);border-left-style:none;border-radius:0 4px 4px 0}::ng-deep .mat-form-field-outline.mat-form-field-outline-thick{min-height:40px;background:#fff;border-radius:4px}::ng-deep .mat-form-field-outline.mat-form-field-outline-thick .mat-form-field-outline-start{border-radius:4px 0 0 4px;min-width:8px;border:1px solid currentColor;border-right-style:none}::ng-deep .mat-form-field-outline.mat-form-field-outline-thick .mat-form-field-outline-gap{border-width:1px;border:1px solid currentColor;border-radius:4px;border-left-style:none;border-right-style:none}::ng-deep .mat-form-field-outline.mat-form-field-outline-thick .mat-form-field-outline-end{border-width:1px;border-radius:0 4px 4px 0;border:1px solid currentColor;border-left-style:none}::ng-deep .mat-form-field-disabled .mat-form-field-outline{background:#ebebeb!important}::ng-deep .mat-form-field-infix{padding:0;margin:0;border:none}::ng-deep .mat-form-field-flex{min-height:40px;align-items:center}::ng-deep .mat-form-field-infix{padding:0;margin:8px 0 0;border:none}.form-label{color:#222;font-size:14px;margin-bottom:.5rem;font-weight:700;font-family:Lato}.form-input{font-size:14px;font-weight:400;font-family:Lato}input.mat-input-element{color:#5f5f5f}::ng-deep .mat-radio-group{padding-bottom:1.34375em}::ng-deep .mat-chip-list-wrapper{margin:0!important}::ng-deep .mat-chip{font-weight:400;background:#f1f9ff 0% 0% no-repeat padding-box!important;border-radius:12px!important;color:#0074b6!important}::ng-deep .mat-chip:hover{filter:brightness(90%)}::ng-deep .mat-chip .mat-chip-remove{opacity:1!important;color:#0074b6!important;border-radius:50%}::ng-deeptextarea .mat-input-element{padding:8px 0}::ng-deep .mat-checkbox-checked.mat-accent .mat-checkbox-background{background:#0074b6 0% 0% no-repeat padding-box!important;border-radius:4px}::ng-deep .mat-checkbox .mat-checkbox-frame{border-radius:4px!important}::ng-deep .mat-form-field-appearance-outline .mat-select-arrow-wrapper{transform:none!important}::ng-deep .mat-tab-label-container .mat-tab-list .mat-tab-labels .mat-tab-label{font-size:18px;color:#222}::ng-deep .mat-tab-label-container .mat-tab-list .mat-tab-labels .mat-tab-label-active .mat-tab-label-content{color:#0074b6}::ng-deep .mat-tab-label-container .mat-tab-list .mat-ink-bar{height:3px;background-color:#0074b6!important}.form-control{background:#fff 0% 0% no-repeat padding-box;border:1px solid rgba(112,112,112,.4117647059);border-radius:4px;display:block}.form-control::placeholder{color:#bebebe;font-size:14px}.form-control:focus{border:2px solid #0074b6;outline:none}.input-wrapper{flex:1;display:flex;flex-wrap:wrap;flex-direction:column}::ng-deep .mat-checkbox-inner-container{height:23px!important;width:23px!important}.flex-expand{flex:1!important}.heading{font-weight:600;font-family:Montserrat;font-size:1.25rem;display:block;padding:0px 0px 1rem 0}::ng-deep .multiselect-dropdown{margin-bottom:20px}::ng-deep .multiselect-dropdown .dropdown-btn{border:1px solid #ccc!important;width:92%!important}::ng-deep .multiselect-dropdown .dropdown-list .filter-textbox input{width:90%!important}.organisation{color:#212529;font-weight:700;font-size:14px;font-family:Lato}.org-name{height:50px;border:1px solid #e2e2e2;border-radius:5px;background-color:#ebebeb;font-size:14px}.add-designation{height:25px;color:#1b4ca1!important;font-weight:500;font-size:14px;font-family:Lato;cursor:pointer}.add-designation .add-icon{color:#1b4ca1!important;height:24px;width:24px;font-size:24px}.info-icon{width:14px;height:14px;font-size:14px;color:#a7a9ae!important}.themDesignation{max-height:90vh;overflow-y:auto}.designation-panel{margin-bottom:0!important;background-color:#eef1f7!important;border:1px solid #DBE0E9;box-shadow:none!important}.designation-panel .deletDesignation{font-size:18px;width:14px;height:14px;color:#5f6063}.designation-panel .saveDesignaton{color:#fff;height:40px;width:80px;background-color:#1b4ca1;border:1px solid #1B4CA1;font-weight:700;font-size:14px;font-family:Lato}.designation-footer{padding:1rem;border-top:1px solid #efefef}.cancel{width:93px;height:40px;font-weight:700;font-size:14px;font-family:Lato;border:1px solid #eee;color:#363636}.addBtn{color:#fff!important;height:40px;width:80px;background-color:#1b4ca1!important;border:1px solid #1B4CA1;font-weight:700;font-size:14px;font-family:Lato}::ng-deep .mat-option.mat-selected:not(.mat-option-disabled){color:#000000de!important}::ng-deep .theme-igot.day-mode .mat-pseudo-checkbox-checked{background:#0074b6!important}::ng-deep .mat-select-panel .mat-option{line-height:1!important}.comp-theme-fields{background:#eef1f7!important;border:1px solid #DBE0E9!important}.create-accordion-btn{color:#1b4ca1!important;padding:0!important}.create-accordion-btn mat-icon{color:#1b4ca1}.ref-id{font-size:10px}::ng-deep .mat-select-panel{min-width:103%!important;margin-left:32px}.loader-bg{background:#ffffffcf;inset:0;transform:translate(-50% -50%);pointer-events:unset;z-index:999999;display:flex;align-items:center;justify-content:center}::ng-deep .mat-chip.mat-standard-chip.mat-chip-disabled{opacity:.8!important;cursor:none;filter:brightness(90%)}\n"], dependencies: [{ kind: "directive", type: i5.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i5.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i5.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "component", type: i6.MatOption, selector: "mat-option", exportAs: ["matOption"] }, { kind: "component", type: i6.MatOptgroup, selector: "mat-optgroup", inputs: ["disabled"], exportAs: ["matOptgroup"] }, { kind: "component", type: i7.MatButton, selector: "    button[mat-button], button[mat-raised-button], button[mat-flat-button],    button[mat-stroked-button]  ", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }, { kind: "component", type: i7.MatIconButton, selector: "button[mat-icon-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }, { kind: "component", type: i8.MatChip, selector: "mat-basic-chip, [mat-basic-chip], mat-chip, [mat-chip]", inputs: ["color", "disabled", "disableRipple", "tabIndex", "role", "id", "aria-label", "aria-description", "value", "removable", "highlighted"], outputs: ["removed", "destroyed"], exportAs: ["matChip"] }, { kind: "component", type: i8.MatChipListbox, selector: "mat-chip-listbox", inputs: ["tabIndex", "multiple", "aria-orientation", "selectable", "compareWith", "required", "hideSingleSelectionIndicator", "value"], outputs: ["change"] }, { kind: "directive", type: i8.MatChipRemove, selector: "[matChipRemove]" }, { kind: "directive", type: i9.MatDialogTitle, selector: "[mat-dialog-title], [matDialogTitle]", inputs: ["id"], exportAs: ["matDialogTitle"] }, { kind: "directive", type: i10.MatAccordion, selector: "mat-accordion", inputs: ["multi", "hideToggle", "displayMode", "togglePosition"], exportAs: ["matAccordion"] }, { kind: "component", type: i10.MatExpansionPanel, selector: "mat-expansion-panel", inputs: ["disabled", "expanded", "hideToggle", "togglePosition"], outputs: ["opened", "closed", "expandedChange", "afterExpand", "afterCollapse"], exportAs: ["matExpansionPanel"] }, { kind: "component", type: i10.MatExpansionPanelHeader, selector: "mat-expansion-panel-header", inputs: ["tabIndex", "expandedHeight", "collapsedHeight"] }, { kind: "directive", type: i10.MatExpansionPanelTitle, selector: "mat-panel-title" }, { kind: "component", type: i11.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "directive", type: i12.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly"], exportAs: ["matInput"] }, { kind: "component", type: i13.MatFormField, selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i13.MatError, selector: "mat-error, [matError]", inputs: ["id"] }, { kind: "component", type: i14.MatMenu, selector: "mat-menu", exportAs: ["matMenu"] }, { kind: "component", type: i14.MatMenuItem, selector: "[mat-menu-item]", inputs: ["disabled", "disableRipple", "role"], exportAs: ["matMenuItem"] }, { kind: "directive", type: i14.MatMenuContent, selector: "ng-template[matMenuContent]" }, { kind: "directive", type: i14.MatMenuTrigger, selector: "[mat-menu-trigger-for], [matMenuTriggerFor]", exportAs: ["matMenuTrigger"] }, { kind: "component", type: i15.MatProgressSpinner, selector: "mat-progress-spinner, mat-spinner", inputs: ["color", "mode", "value", "diameter", "strokeWidth"], exportAs: ["matProgressSpinner"] }, { kind: "directive", type: i16.MatRadioGroup, selector: "mat-radio-group", exportAs: ["matRadioGroup"] }, { kind: "component", type: i16.MatRadioButton, selector: "mat-radio-button", inputs: ["disableRipple", "tabIndex"], exportAs: ["matRadioButton"] }, { kind: "component", type: i17.MatSelect, selector: "mat-select", inputs: ["disabled", "disableRipple", "tabIndex", "panelWidth", "hideSingleSelectionIndicator"], exportAs: ["matSelect"] }, { kind: "directive", type: i17.MatSelectTrigger, selector: "mat-select-trigger" }, { kind: "directive", type: i3.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i3.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i3.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i3.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { kind: "directive", type: i3.FormGroupName, selector: "[formGroupName]", inputs: ["formGroupName"] }, { kind: "directive", type: i3.FormArrayName, selector: "[formArrayName]", inputs: ["formArrayName"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CreateTermFromFrameworkComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'lib-create-term-from-framework', template: "\n<div class=\"\">\n    <ng-container *ngIf=\"disableMultiCreate\">\n        <div class=\"flex flex-col flex-1 w-100 absolute loader-bg items-center pt-5 text-center\">\n          <mat-spinner class=\"display-inline-block mb-5\" [diameter]=\"50\" [strokeWidth]=\"3\"></mat-spinner>\n          <!-- <p>{{loaderMsg}}</p> -->\n        </div>\n      </ng-container>\n      <div class=\"dialogNew\">\n        <div class=\"flex items-center justify-between\">\n            <ng-container [ngTemplateOutlet]=\"modalTitle\"></ng-container>\n            <button type=\"button\" mat-icon-button i18n-aria-label aria-label=\"action items\"\n            [matMenuTriggerFor]=\"cardMenu\" [matMenuTriggerData]=\"{'data':data}\" class=\"action-btn\">\n            <mat-icon>more_vert</mat-icon>\n            </button>\n        </div>\n        <div class=\"flex gap-4\">\n            <ng-container *ngFor=\"let term of data?.selectedParentTerms\">\n                <ng-container *ngIf=\"term.category !== 'competency'\">\n                    <div class=\"flex-1 flex-col\">\n                        <label for=\"name\" class=\"margin-remove-bottom form-label\" aria-label=\"First name label\">\n                            {{frameWorkService.getConfig(term.category).labelName}}\n                        </label>\n                        <mat-form-field appearance=\"outline\" class=\"flex-1\">\n                            <input matInput name=\"name\" id=\"name\" #name placeholder=\"{{app_strings.name}}\"\n                                [value]=\"term.name\" disabled>\n                        </mat-form-field>\n                    </div>\n                </ng-container>\n            </ng-container>\n        </div>\n        <div class=\"row-divider\"></div>\n        <ng-container *ngIf=\"competencyForm\">\n            <form [formGroup]=\"competencyForm\">\n                <div class=\"title-text\">\n                    <label for=\"name\" class=\"margin-remove-bottom form-label required\" aria-label=\"First name labe \">\n                        {{'Select Area'}}\n                    </label>\n                    <div class=\"mt-5\">\n                        <mat-radio-group class=\"competency-group\" aria-label=\"Select an option\" formControlName=\"compArea\">\n                            <mat-radio-button  [disabled]=\"data?.columnInfo?.code === 'subtheme' || data.openMode ==='view'\" class=\"learning-section\" [ngClass]=\"{'active-btn':item?.code === seletedCompetencyArea?.code}\"\n                             *ngFor=\"let item of competencyArea?.children\" [value]=\"item\" [checked]=\"item?.code === seletedCompetencyArea?.code\" (change)=\"clearSelectedThemes(item)\">{{item.name}}</mat-radio-button>\n                        </mat-radio-group>\n                    </div>\n                </div>\n                <ng-container *ngIf=\"data?.mode === 'multi-create'\">\n                        <div class=\"flex flex-end mb-4\" >\n                            <ng-container *ngIf=\"data?.columnInfo?.code !== 'subtheme'\">\n                                <button type=\"button\" class=\"mat-button flex items-center create-accordion-btn\" *ngIf=\"data.mode === 'multi-create'\" (click)=\"addCompetencyTheme()\">\n                                    <mat-icon class=\"mr-2 mat-icon-custom \">add_circle_outline</mat-icon>\n                                    Add more\n                                    <!-- {{data.columnInfo.name}}  -->\n                                </button>\n                            </ng-container>\n                        </div>\n                        <mat-accordion formArrayName=\"compThemeFields\">\n                            <mat-expansion-panel *ngFor=\"let field of competencyForm?.get('compThemeFields')['controls']; let i = index; let isFirst = first\" \n                            class=\"margin-bottom-l comp-theme-fields\" [formGroupName]=\"i\" [expanded]=\"isFirst\">               \n                             <mat-expansion-panel-header>\n                                    <mat-panel-title>\n                                        {{competencyForm?.get('compThemeFields')['controls'][i]['controls']?.competencyTheme?.value?.name}} \n                                    </mat-panel-title>\n                                    <ng-container *ngIf=\"data?.columnInfo?.code !== 'subtheme'\">\n                                        <button mat-button type=\"button\" *ngIf=\"data.mode === 'multi-create'\"\n                                        (click)=\"removeCompFields(i)\">\n                                        <mat-icon class=\"mat-icon-custom \">delete</mat-icon>\n                                        </button>\n                                    </ng-container>\n                                </mat-expansion-panel-header>\n                                <div class=\"input-column\">\n                                    <div class=\"input-wrapper margin-top-s\">\n                                        <div class=\"flex gap-4 \">\n                                            <div class=\"flex-1 flex-col\">\n                                                <label for=\"name\" class=\"margin-remove-bottom form-label required\"\n                                                    aria-label=\"First name label\">\n                                                    {{data.openMode !== 'view'? 'Select Competency Theme': 'Competency Theme Name'}}\n                                                </label>\n                                                <mat-form-field appearance=\"outline\" class=\"flex-1\">\n                                                    <mat-select [disabled]=\"data?.columnInfo?.code === 'subtheme' || data.openMode ==='view'\" placeholder=\"Choose the Competency Theme\" formControlName=\"competencyTheme\">\n                                                        <ng-container >\n                                                            <ng-container >\n                                                                <mat-option *ngFor=\"let option of filteredallCompetencyTheme\"  [value]=\"option\" [disabled]=\"onDisableTheme(option) || data.openMode ==='view'\" \n                                                                (onSelectionChange)=\"OnThemeSelection($event, i, option)\"  >{{option.name}}\n                                                                <ng-container *ngIf=\"option.refId\">\n                                                                <span class=\"ml-2 ref-id\">({{option.refId}})</span>\n                                                                </ng-container>\n                                                               </mat-option>\n                                                            </ng-container>\n                                                        </ng-container>\n                                                    </mat-select>\n                                                </mat-form-field>\n                                                <mat-error *ngIf=\"isTermExist\">{{app_strings.alreadyExist}}</mat-error>\n                                            </div>\n                                        </div>\n            \n                                        <div class=\"flex-col mt-2\">\n                                            <label for=\"fname\" class=\"margin-remove-bottom form-label required\"\n                                                i18n=\"First Name label|Label which explains the user to enter first name\"\n                                                i18n-aria-label aria-label=\"First name label\">\n\n                                                {{data.openMode !== 'view'? 'Select Competency Sub-Theme': 'Competency Sub-Theme Name'}}\n                                                \n                                            </label>\n                                            <!-- <mat-form-field appearance=\"outline\" class=\"flex-1\">\n                                                <mat-select placeholder=\"Choose the Competency Theme\" formControlName=\"competencySubTheme\">\n                                                    <mat-option *ngFor=\"let option of filteredallCompetencySubTheme\" [value]=\"option\">{{option.name}}</mat-option>\n                                                </mat-select>\n                                            </mat-form-field> -->\n                                            <!-- {{competencyForm?.get('compThemeFields')['controls'][i]['controls']?.competencySubTheme?.value |json}} -->\n                                            <mat-form-field appearance=\"outline\" class=\"w-full field-height\" >\n                                                <mat-select class=\" placeholder-text\" placeholder=\"Choose the Competency Sub-Theme\"\n                                                  formControlName=\"competencySubTheme\" multiple [disabled]=\"data.openMode ==='view'\" panelClass=\"full-width-panel\">\n                                                  <!-- [ngClass]=\"{'disbaledSelect':isHideData}\" -->\n                                                  <mat-select-trigger >\n                                                    <mat-chip-listbox>\n                                                        <!-- -->\n                                                       \n                                                      <mat-chip *ngFor=\"let item of competencyForm?.get('compThemeFields')['controls'][i]['controls']?.competencySubTheme?.value\" \n                                                      (removed)=\"onTermRemove(item, i)\" [disabled]=\"data.openMode ==='view'\"\n                                                      [ngClass]=\"{'sub-theme-disable': data?.openMode ==='view'}\"  [removable]=\"data?.openMode ==='view'? false: true\">\n                                                        <span >{{ item.name }}</span>\n                                                        <mat-icon matChipRemove>cancel</mat-icon>\n                                                      </mat-chip>\n                                                    </mat-chip-listbox>\n                                                  </mat-select-trigger>\n                                                  <!-- {{competencyForm?.get('compThemeFields') |json}} -->\n                                                  <!-- <mat-optgroup>\n                                                    <mat-form-field floatLabel=\"never\">\n                                                      <input #search autocomplete=\"off\" placeholder=\"Search\" (keydown.space)=\"$event.stopPropagation()\"\n                                                        formControlName=\"competencySubTheme\" matInput>\n                                                    </mat-form-field>\n                                                  </mat-optgroup> -->\n                                                  <mat-optgroup *ngIf=\"filteredallCompetencySubTheme.length === 0\">\n                                                    <div>No results found!</div>\n                                                  </mat-optgroup>\n                                                  <!-- <mat-option *ngFor=\"let option of requestObjData.preferredProvider\" [value]=\"option.providerName\">{{option.providerName}}</mat-option> -->\n                                                  <ng-container *ngFor=\"let option of competencyForm?.get('compThemeFields')['controls'][i]['controls']?.competencyTheme?.value?.children\">\n                                                        <mat-option \n                                                        [value]=\"option\" class=\"mat-option-list\">{{option?.name}}\n                                                        <ng-container *ngIf=\"option?.refId\">\n                                                         <span class=\"ml-2 ref-id\">({{option?.refId}})</span>\n                                                        </ng-container>\n                                                     </mat-option>\n                                                  </ng-container>\n                                \n                                                </mat-select>\n                                                <!-- <mat-error *ngIf=\"requestForm.controls['providerText'].hasError('required')\">\n                                                  Please select up to five preferred providers for the request.\n                                                </mat-error> -->\n                                              </mat-form-field>\n                                        </div>\n                                    </div>\n                                </div>\n                            </mat-expansion-panel>\n                        </mat-accordion>\n                        <footer class=\"actions\">\n                            <button mat-raised-button color=\"default\" type=\"reset\"\n                                (click)=\"dialogClose('')\">{{app_strings.cancel}}</button>\n                            <ng-container *ngIf=\"data?.mode === 'create' && data.openMode !=='view'\">\n                                <button mat-raised-button color=\"primary\" type=\"submit\" cdkFocusInitial\n                                    [disabled]=\"competencyForm?.invalid\" *ngIf=\"!disableCreate\">{{app_strings.create}}</button>\n                            </ng-container>\n                            <ng-container *ngIf=\"data?.mode === 'multi-create' && data.openMode !=='view'\">\n                                <ng-container *ngIf=\"data?.columnInfo?.code !== 'subtheme'\">\n                                    <button mat-raised-button color=\"primary\" type=\"button\" cdkFocusInitial\n                                    [disabled]=\"competencyForm.invalid || disableMultiCreate\" *ngIf=\"!disableCreate\" (click)=\"multiCreate(competencyForm, data)\">\n                                    {{app_strings.create}}\n                                    </button>\n                                </ng-container>\n                                <ng-container *ngIf=\"data?.columnInfo?.code === 'subtheme'\">\n                                    <!-- <ng-container *ngIf=\"competencyForm?.get('compThemeFields')['controls'][0]['controls']?.competencySubTheme?.value?.length;else updateBtn\"> -->\n                                        <button mat-raised-button color=\"primary\" type=\"button\" cdkFocusInitial\n                                        [disabled]=\"competencyForm.invalid || disableMultiCreate\" *ngIf=\"!disableCreate\" (click)=\"multiCreateSubTheme(competencyForm, data)\">\n                                        {{app_strings.update}}\n                                        </button>\n                                    <!-- </ng-container> -->\n                                    \n                                    <!-- <ng-template #updateBtn>\n                                        <button mat-raised-button color=\"primary\" type=\"button\" cdkFocusInitial\n                                        [disabled]=\"competencyForm.invalid || disableMultiCreate\" *ngIf=\"!disableCreate\" (click)=\"multiCreateSubTheme(competencyForm, data)\">\n                                        {{app_strings.delete}}\n                                        </button>\n                                    </ng-template> -->\n                                </ng-container>\n                            </ng-container>\n                            <ng-container *ngIf=\"data?.mode === 'edit' && data.openMode !=='view'\">\n                                <button mat-raised-button color=\"primary\" type=\"button\" cdkFocusInitial\n                                    (click)=\"updateTermData(competencyForm, data)\"\n                                    [disabled]=\"competencyForm?.invalid || disableUpdate\"\n                                    *ngIf=\"!disableCreate\">{{app_strings.update}}</button>\n                            </ng-container>\n                        </footer>\n                    </ng-container>\n                </form>\n        </ng-container>\n    \n    </div>\n    \n    \n    <!-- Title of the popup -->\n    <ng-template #modalTitle>\n        <!-- <ng-container *ngIf=\"data?.mode === 'create' || data?.mode === 'multi-create'\">\n            <div class=\"dialog-title\" mat-dialog-title>{{data.columnInfo.name === 'Theme' ? app_strings.addCompetency : app_strings.createNew}} {{data.columnInfo.name}}</div>\n        </ng-container> -->\n        <!-- {{data |json}} -->\n        <ng-container *ngIf=\"data?.mode === 'create' || data?.mode === 'multi-create'\">\n            <div class=\"dialog-title\" mat-dialog-title>{{getCreateName(data)}}</div>\n        </ng-container>\n        <!-- <ng-container *ngIf=\"data?.mode === 'view'\">\n            <div class=\"dialog-title\" mat-dialog-title>View {{data.columnInfo.name}}</div>\n        </ng-container> -->\n        <ng-container *ngIf=\"data?.mode === 'edit'\">\n            <div class=\"dialog-title\" mat-dialog-title>{{app_strings.edit}} {{data.columnInfo.name}}</div>\n        </ng-container>\n    </ng-template>\n</div>\n\n\n<mat-menu #cardMenu=\"matMenu\" class=\"menu-sec\">\n    <ng-template matMenuContent let-rowData=\"data\" let-cardRef=\"cardRef\">\n        <button  (click)=\"deleteTheme()\"\n            mat-menu-item name=\"channel-analytics-button\" class=\"ws-mat-primary-text\" i18n-aria-label\n            aria-label=\"Analytics\">\n            <mat-icon>delete</mat-icon>\n            <span>Delete</span>\n        </button>\n    </ng-template>\n</mat-menu>", styles: [".gap-3{gap:1.25rem}.gap-4{gap:1.5rem}.row-divider{width:100%;border-top:1px solid rgba(0,0,0,.08);margin:1rem 0}.defaultForm{padding:16px;display:flex;gap:16px;flex-direction:column}.theme-actions{display:flex;justify-content:right;padding:1em 0;gap:16px;margin-top:30px;border-top:1px solid rgba(0,0,0,.0784313725)}.dialog .mat-dialog-title{padding:1em;margin-bottom:0;background:#00000014}.dialog .mat-form-field{padding:0;background:#fff;border-radius:2px}.dialog .mat-form-field ::ng-deep .mat-form-field-wrapper{padding-bottom:0}.dialog .mat-form-field ::ng-deep .mat-form-field-wrapper .mat-form-field-infix{padding:15px;margin-top:0;border-top:0}.dialog .mat-form-field ::ng-deep .mat-form-field-wrapper .mat-form-field-infix textarea{resize:none}.dialog .mat-form-field-disabled{background:#00000014}.dialog .actions{display:flex;flex-direction:row;justify-content:space-between;padding:0 1em 1em}.dialog .mat-error{padding:0 25px;margin-top:-10px}.dialogNew{padding:1rem}.dialogNew .mat-dialog-title{padding:1em 0;margin-bottom:0}.dialogNew .actions{display:flex;justify-content:right;padding:1em 0;gap:16px;margin-top:16px;border-top:1px solid rgba(0,0,0,.0784313725)}.dialogNew .mat-error{margin-top:-10px}.dialogNew .learning-section{padding:10px!important;border:1px solid rgba(0,0,0,.1803921569);border-radius:4px;margin-right:8px}.dialogNew .learning-section.active-btn{border:1px solid #1B4CA1!important}.learning-section.mat-radio-button .mat-radio-container .mat-radio-outer-circle{border-color:#1b4ca1!important}::ng-deep .competency-group .learning-section .mat-radio-inner-circle{background-color:#1b4ca1!important}::ng-deep .competency-group .learning-section .mat-radio-button.mat-accent .mat-radio-inner-circle{background-color:#1b4ca1!important}.dialog-title{align-items:center;display:flex}.flex{display:flex}.flex-col{display:flex;flex-direction:column}.mr-5{margin-right:1.5rem}.flex-1{flex:1 1}.margin-remove-bottom{margin-bottom:0}::ng-deep .custom-dialog-container{max-height:90vh}::ng-deep .custom-dialog-container .mat-dialog-container{padding:0;border-radius:0;background:#00000014}@media only screen and (max-width: 1024px){::ng-deep .cdk-overlay-pane{width:40%!important}}@media only screen and (max-width: 992px){::ng-deep .cdk-overlay-pane{width:45%!important}}@media only screen and (max-width: 1024px){.dialog{font-size:12px}.dialog .dialog-title{font-size:24px;height:1em}.dialog button{font-size:12px;line-height:3.5em}.dialog .mat-raised-button{padding:0 3em}}.flex-align{align-items:center;justify-content:flex-start}::ng-deep mat-form-field .mat-form-field-infix .mat-form-field-label,::ng-deep mat-form-field .mat-form-field-infix .mat-select-value{line-height:normal!important}ws-widget-btn-page-back-admin{margin-left:-270px}.max-wid{max-width:400px}::ng-deep .mat-form-field.mat-focused .mat-form-field-label{color:#333232!important}.margin-right-10{margin-right:10px!important}input::-webkit-outer-spin-button,input::-webkit-inner-spin-button{-webkit-appearance:none;margin:0}input[type=number]{-moz-appearance:textfield}::ng-deep .mat-tab-header{margin:0 3rem}.heading{color:#222}.heading.mt-10{margin-top:2.5rem!important}.img-column{flex:100px 0 0}.input-column{flex:auto}.radio-toolbar input[type=radio]{opacity:0;position:fixed;width:0}.radio-toolbar{padding:10px 0}.radio-toolbar label{display:inline-block;padding:7px 21px;font-size:14px;background:#fff 0% 0% no-repeat padding-box;border:1px solid #5F5F5F;border-radius:4px;margin:0 10px 10px 0;color:#5f5f5f;cursor:pointer;transition:all .125s ease-in-out}.radio-toolbar input[type=radio]:checked+label{background:#0074b6 0% 0% no-repeat padding-box;border-radius:6px;border-color:#0074b6;color:#fff}.radio-toolbar input[type=radio]:focus+label{background:#0074b6 0% 0% no-repeat padding-box;border-radius:6px;border-color:#0074b6;color:#fff}.mar{margin-left:30px;min-width:175px}.radio-toolbar label:hover{background:none;border-color:#0074b6;color:#0074b6}::ng-deep .mat-form-field{width:100%}::ng-deep .mat-form-field.full-width{max-width:100%}::ng-deep .mat-form-field.no-pb .mat-form-field-wrapper{padding-bottom:0}.combined-field{width:100%}.w-full-imp{width:100%!important}::ng-deep .full-width-panel{width:100%!important;min-width:300px}::ng-deep .full-width-panel .mat-option{white-space:normal}.btn-success{background-color:#0075b7!important;border-radius:4px;width:240px;box-shadow:none;margin-right:16px}.btn-success.btn-responsive{width:100%}.btn-success:disabled,.btn-success[disabled]{opacity:.6}.btn-danger{height:30px;width:30px}.color-danger{font-size:30px;height:30px;width:30px;color:#e44}::ng-deep .mat-form-field-outline{min-height:40px;background:#fff;border-radius:4px}::ng-deep .mat-form-field-outline .mat-form-field-outline-start{border:1px solid rgba(112,112,112,.4117647059);border-radius:4px 0 0 4px;min-width:8px;border-right-style:none}::ng-deep .mat-form-field-outline .mat-form-field-outline-gap{border:1px solid currentColor;border-radius:82px;border-left-style:none;border-right-style:none}::ng-deep .mat-form-field-outline .mat-form-field-outline-end{border:1px solid rgba(112,112,112,.4117647059);border-left-style:none;border-radius:0 4px 4px 0}::ng-deep .mat-form-field-outline.mat-form-field-outline-thick{min-height:40px;background:#fff;border-radius:4px}::ng-deep .mat-form-field-outline.mat-form-field-outline-thick .mat-form-field-outline-start{border-radius:4px 0 0 4px;min-width:8px;border:1px solid currentColor;border-right-style:none}::ng-deep .mat-form-field-outline.mat-form-field-outline-thick .mat-form-field-outline-gap{border-width:1px;border:1px solid currentColor;border-radius:4px;border-left-style:none;border-right-style:none}::ng-deep .mat-form-field-outline.mat-form-field-outline-thick .mat-form-field-outline-end{border-width:1px;border-radius:0 4px 4px 0;border:1px solid currentColor;border-left-style:none}::ng-deep .mat-form-field-disabled .mat-form-field-outline{background:#ebebeb!important}::ng-deep .mat-form-field-infix{padding:0;margin:0;border:none}::ng-deep .mat-form-field-flex{min-height:40px;align-items:center}::ng-deep .mat-form-field-infix{padding:0;margin:8px 0 0;border:none}.form-label{color:#222;font-size:14px;margin-bottom:.5rem;font-weight:700;font-family:Lato}.form-input{font-size:14px;font-weight:400;font-family:Lato}input.mat-input-element{color:#5f5f5f}::ng-deep .mat-radio-group{padding-bottom:1.34375em}::ng-deep .mat-chip-list-wrapper{margin:0!important}::ng-deep .mat-chip{font-weight:400;background:#f1f9ff 0% 0% no-repeat padding-box!important;border-radius:12px!important;color:#0074b6!important}::ng-deep .mat-chip:hover{filter:brightness(90%)}::ng-deep .mat-chip .mat-chip-remove{opacity:1!important;color:#0074b6!important;border-radius:50%}::ng-deeptextarea .mat-input-element{padding:8px 0}::ng-deep .mat-checkbox-checked.mat-accent .mat-checkbox-background{background:#0074b6 0% 0% no-repeat padding-box!important;border-radius:4px}::ng-deep .mat-checkbox .mat-checkbox-frame{border-radius:4px!important}::ng-deep .mat-form-field-appearance-outline .mat-select-arrow-wrapper{transform:none!important}::ng-deep .mat-tab-label-container .mat-tab-list .mat-tab-labels .mat-tab-label{font-size:18px;color:#222}::ng-deep .mat-tab-label-container .mat-tab-list .mat-tab-labels .mat-tab-label-active .mat-tab-label-content{color:#0074b6}::ng-deep .mat-tab-label-container .mat-tab-list .mat-ink-bar{height:3px;background-color:#0074b6!important}.form-control{background:#fff 0% 0% no-repeat padding-box;border:1px solid rgba(112,112,112,.4117647059);border-radius:4px;display:block}.form-control::placeholder{color:#bebebe;font-size:14px}.form-control:focus{border:2px solid #0074b6;outline:none}.input-wrapper{flex:1;display:flex;flex-wrap:wrap;flex-direction:column}::ng-deep .mat-checkbox-inner-container{height:23px!important;width:23px!important}.flex-expand{flex:1!important}.heading{font-weight:600;font-family:Montserrat;font-size:1.25rem;display:block;padding:0px 0px 1rem 0}::ng-deep .multiselect-dropdown{margin-bottom:20px}::ng-deep .multiselect-dropdown .dropdown-btn{border:1px solid #ccc!important;width:92%!important}::ng-deep .multiselect-dropdown .dropdown-list .filter-textbox input{width:90%!important}.organisation{color:#212529;font-weight:700;font-size:14px;font-family:Lato}.org-name{height:50px;border:1px solid #e2e2e2;border-radius:5px;background-color:#ebebeb;font-size:14px}.add-designation{height:25px;color:#1b4ca1!important;font-weight:500;font-size:14px;font-family:Lato;cursor:pointer}.add-designation .add-icon{color:#1b4ca1!important;height:24px;width:24px;font-size:24px}.info-icon{width:14px;height:14px;font-size:14px;color:#a7a9ae!important}.themDesignation{max-height:90vh;overflow-y:auto}.designation-panel{margin-bottom:0!important;background-color:#eef1f7!important;border:1px solid #DBE0E9;box-shadow:none!important}.designation-panel .deletDesignation{font-size:18px;width:14px;height:14px;color:#5f6063}.designation-panel .saveDesignaton{color:#fff;height:40px;width:80px;background-color:#1b4ca1;border:1px solid #1B4CA1;font-weight:700;font-size:14px;font-family:Lato}.designation-footer{padding:1rem;border-top:1px solid #efefef}.cancel{width:93px;height:40px;font-weight:700;font-size:14px;font-family:Lato;border:1px solid #eee;color:#363636}.addBtn{color:#fff!important;height:40px;width:80px;background-color:#1b4ca1!important;border:1px solid #1B4CA1;font-weight:700;font-size:14px;font-family:Lato}::ng-deep .mat-option.mat-selected:not(.mat-option-disabled){color:#000000de!important}::ng-deep .theme-igot.day-mode .mat-pseudo-checkbox-checked{background:#0074b6!important}::ng-deep .mat-select-panel .mat-option{line-height:1!important}.comp-theme-fields{background:#eef1f7!important;border:1px solid #DBE0E9!important}.create-accordion-btn{color:#1b4ca1!important;padding:0!important}.create-accordion-btn mat-icon{color:#1b4ca1}.ref-id{font-size:10px}::ng-deep .mat-select-panel{min-width:103%!important;margin-left:32px}.loader-bg{background:#ffffffcf;inset:0;transform:translate(-50% -50%);pointer-events:unset;z-index:999999;display:flex;align-items:center;justify-content:center}::ng-deep .mat-chip.mat-standard-chip.mat-chip-disabled{opacity:.8!important;cursor:none;filter:brightness(90%)}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.MatLegacyDialogRef }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [MAT_DIALOG_DATA]
+                }] }, { type: i1.MatLegacyDialog }, { type: i2.FrameworkService }, { type: i3.UntypedFormBuilder }, { type: i4.MatLegacySnackBar }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"create-term-from-framework.component.js","sourceRoot":"","sources":["../../../../../../../library/sunbird-cb/tree-hierarchy/src/lib/components/create-term-from-framework/create-term-from-framework.component.ts","../../../../../../../library/sunbird-cb/tree-hierarchy/src/lib/components/create-term-from-framework/create-term-from-framework.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Inject, OnInit } from '@angular/core';\nimport { UntypedFormArray, UntypedFormBuilder, UntypedFormControl, UntypedFormGroup, Validators } from '@angular/forms';\nimport { MAT_LEGACY_DIALOG_DATA as MAT_DIALOG_DATA, MatLegacyDialog as MatDialog, MatLegacyDialogRef as MatDialogRef } from '@angular/material/legacy-dialog';\nimport { MatLegacySnackBar as MatSnackBar } from '@angular/material/legacy-snack-bar';\nimport { labels } from '../../labels/strings';\nimport { FrameworkService } from '../../services/framework.service';\nimport { NSFramework } from '../../models/framework.model';\nimport * as appConstants from '../../constants/app-constant';\nimport { Card } from '../../models/variable-type.model';\n/* tslint:disable */\nimport _ from 'lodash'\n// import { resolve } from 'url';\nimport { ConforamtionPopupComponent } from '../conforamtion-popup/conforamtion-popup.component';\n/* tslint:enable */\n\n@Component({\n  selector: 'lib-create-term-from-framework',\n  templateUrl: './create-term-from-framework.component.html',\n  styleUrls: ['./create-term-from-framework.component.scss']\n})\nexport class CreateTermFromFrameworkComponent implements OnInit {\n\n  app_strings = labels;\n  environment: any\n\n  selectedTerm: Card = {};\n  selectedTermArray : any = []\n  kcmConfigData: any\n  selectedThemeData: any\n\n\n  isTermExist: boolean = false;\n  disableCreate: boolean = false;\n  disableMultiCreate: boolean = false;\n  disableUpdate: boolean = false;\n\n\n  competencyForm!: UntypedFormGroup\n\n\n  kcmList : any= new Map<string, NSFramework.IColumnView>();\n  // categoriesHash: any\n  competencyArea: any\n  selectedCardCompThemeData: any\n\n  allCompetency:any[]=[]\n  seletedCompetencyArea: any\n  allCompetencyTheme:any[]=[]\n  filteredallCompetencyTheme:any[]=[]\n  allCompetencySubtheme:any[]=[]\n  filteredallCompetencySubTheme:any[]=[]\n\n  constructor(\n    public dialogRef: MatDialogRef<CreateTermFromFrameworkComponent>,\n    @Inject(MAT_DIALOG_DATA) public data: any,\n    private dialog: MatDialog,\n    public frameWorkService: FrameworkService,\n    private fb: UntypedFormBuilder,\n    private _snackBar: MatSnackBar,\n  ) { }\n\n  ngOnInit() {\n    this.environment = this.frameWorkService.getEnviroment()\n    this.getComptencyData()\n    this.kcmConfigData = this.frameWorkService.getConfigByFrameWorkId(this.environment.kcmFrameworkName)\n    this.competencyForm = this.fb.group({\n      compArea:['',Validators.required],\n      compThemeFields: this.fb.array([this.createCompThemeFields()])\n    })\n\n  }\n\n  getComptencyData(){\n    this.frameWorkService.getFrameworkRead(this.environment.kcmFrameworkName).subscribe((data)=>{\n     if(data.categories) {\n      this.formateData(data, this.environment.kcmFrameworkName)\n      this.selectedCardCompThemeData =  ''\n      // to do: change getting selectedParentTerms to dynamic\n      if(this.data && this.data.selectedParentTerms) {\n        this.data.selectedParentTerms.forEach((ele: any) => {\n          if(ele.category === \"competency\") {\n            this.selectedCardCompThemeData = ele\n            let option = this.selectedCardCompThemeData.additionalProperties.competencyArea\n            this.onSelectionArea(option)\n          }\n        });\n      }\n      \n     }\n    },((_err: any) => {\n      this._snackBar.open(`KCM Framework read failed.`)\n    }))\n  }\n\n  formateData(response: any, frameworkId: string) {\n    (response.categories).forEach((a:any) => {\n      if(a.code !== undefined) {\n        this.kcmList.set(a.code, {\n          code: a.code,\n          identifier: a.identifier,\n          index: a.index,\n          name: a.name,\n          description: a.description,\n          config: this.frameWorkService.getConfigOfCategoryConfigByFrameWorkId(a.code, frameworkId),\n          // children: ([...a.terms, ...localData] || []).map(c => {\n          children: (a.terms || []).map((c:any) => {\n            const associations = c.associations || []\n            if (associations.length > 0) {\n              Object.assign(c, { children: associations })\n            }\n            return c\n          })\n        })\n      }\n    });\n    this.kcmList.forEach((a: any) => {\n      if(a.code === _.get(this.kcmConfigData, 'config[0].category')){\n        this.competencyArea = a\n      }\n    })\n    \n\n  }\n\n\n  createCompThemeFields():UntypedFormGroup {\n    return this.fb.group({\n      competencyTheme:['', [Validators.required]],\n      competencySubTheme:['', [Validators.required]]\n    })\n  }\n\n\n  getCreateName(data: any) {\n      let popUpCategory = data.cardColInfo ? data.cardColInfo.name : data.columnInfo.name\n      switch(popUpCategory){\n        case 'Designation':\n        return `Create Competency Mapping`;\n        case 'Sub Theme':\n          if(data.openMode === 'view') {\n            return `View Competency ${popUpCategory}`\n          }\n        return `Add Competency ${popUpCategory}`\n        case 'Competency':\n          if(data.openMode === 'edit') {\n            return `Edit Competency Theme`\n          } else if(data.openMode === 'view') {\n            return `View Competency Theme`\n          }\n          return `Create Competency Mapping`\n          default: return ''\n      }\n  }\n\n  clearSelectedThemes(option:any){\n    if(this.isThemeSelected) {\n      this.openConforamtionPopup(option)\n    } else {\n      this.onSelectionArea(option)\n    }\n  }\n\n  get isThemeSelected () {\n    let hasValue = false\n    if (this.competencyForm) {\n      const compThemeFields = this.competencyForm.get('compThemeFields') as UntypedFormArray;\n      if (compThemeFields) {\n        compThemeFields.controls.forEach((element:any) => {\n          if(element.get('competencyTheme')?.value || element.get('competencySubTheme')?.value) {\n            hasValue = true\n          }\n        });\n      }\n    }\n    return hasValue\n  }\n\n  openConforamtionPopup(option:any) {\n    const dialogData = {\n      dialogType: 'warning',\n      descriptions: [\n        {\n          header: 'Are you sure you want to alter the competency area?',\n          headerClass: 'flex items-center justify-center text-blue textBold',\n          messages: [\n            {\n              msgClass: '',\n              msg: `This action will result in the loss of your currently added data`,\n            },\n          ],\n        },\n      ],\n      footerClass: 'items-center justify-center',\n      buttons: [\n        {\n          btnText: 'Cancel',\n          btnClass: 'btn-outline',\n          response: false,\n        },\n        {\n          btnText: 'Confirm',\n          btnClass: 'btn-full-success',\n          response: true,\n        },\n      ],\n    }\n    const dialogRef = this.dialog.open(ConforamtionPopupComponent, {\n      data: dialogData,\n      autoFocus: false,\n      width: '600px',\n      maxWidth: '80vw',\n      maxHeight: '90vh',\n      disableClose: true,\n    })\n    dialogRef.afterClosed().subscribe((res: any) => {\n      if (res) {\n        this.onSelectionArea(option)\n      } else {\n        const compAreaControl = this.competencyForm.get('compArea');\n        if (compAreaControl) {\n          compAreaControl.setValue(this.seletedCompetencyArea);\n          compAreaControl.updateValueAndValidity();\n        }\n      }\n    })\n  }\n\n  onSelectionArea(option:any){\n    this.competencyForm.reset()\n    while(this.compThemeFields.length !== 0) {\n      this.compThemeFields.removeAt(0);\n    }\n    this.compThemeFields.push(this.createCompThemeFields());\n    if('theme' === this.kcmConfigData.config[1].category){\n      this.seletedCompetencyArea = option\n      const compAreaControl = this.competencyForm.get('compArea');\n      if (compAreaControl) {\n        compAreaControl.patchValue(option);\n        compAreaControl.updateValueAndValidity();\n      }\n      this.filteredallCompetencyTheme = []\n      this.allCompetencyTheme = []\n      if(option &&  option.children &&  option.children.length){\n        let themeValue = this.kcmList.get(this.kcmConfigData.config[1].category)\n        option.children.forEach((ele: any) => {\n          if(ele.category === 'theme' ) {\n              let result = themeValue.children.findIndex((themeData :any ) => {\n                if(ele.refId === themeData.refId) {\n                  return themeData.children && themeData.children.length\n                }\n              })\n              if(result >= 0){\n                this.allCompetencyTheme.push(ele)\n                this.filteredallCompetencyTheme.push(ele)\n              }\n            }\n        });\n      } else {\n        if(this.competencyArea && this.competencyArea.children) {\n          this.competencyArea.children.forEach((element:any) => {\n            if(element.code === option.code) {\n              this.seletedCompetencyArea = option\n              if(element.children && element.children.length) {\n                element.children.forEach((ele: any) => {\n                  if(ele.category === 'theme') {\n                    this.allCompetencyTheme.push(ele)\n                    this.filteredallCompetencyTheme.push(ele)\n                    // to do:  to be check based on reff id\n                    if(this.selectedCardCompThemeData.refId.toLowerCase() === ele.refId.toLowerCase()){\n                      let formArray:any = this.competencyForm.get('compThemeFields') as UntypedFormArray;\n                      formArray.at(0).get('competencyTheme').patchValue(ele)\n                      formArray.at(0).get('competencyTheme').updateValueAndValidity()\n                      const compAreaControl = this.competencyForm.get('compArea');\n                      if (compAreaControl) {\n                        compAreaControl.patchValue(option);\n                        compAreaControl.updateValueAndValidity();\n                      }\n                    }\n                  }\n                });\n              }\n            }\n          });\n        }\n      }\n      \n    }\n  }\n\n  addCompetencyTheme(){\n    if (this.data.mode === 'multi-create') {\n      this.compThemeFields.insert(0, this.createCompThemeFields());\n    }\n  }\n\n  removeCompFields(index: number) {\n    if (this.data.mode === 'multi-create') {\n      this.compThemeFields.removeAt(index);\n    }\n  }\n\n  OnThemeSelection(event: any, _indexValue: any, optionData:any) {\n    // if (event.isUserInput || this.data.openMode === 'view') {   \n    const selectedTheme = event.source.value\n    this.kcmList.forEach((ele:any) => {\n      if(selectedTheme.category === ele.code) {\n        if(ele.children && ele.children.length) {\n          ele.children.forEach((themeChild: any) => {\n            if(themeChild.identifier === selectedTheme.identifier) {\n              if(themeChild.children && themeChild.children.length) {\n                optionData['children'] = themeChild.children\n                this.filteredallCompetencySubTheme = themeChild.children \n                 // to do:  to be check based on reff id\n                 let matchedData = []\n                 if(this.data.childrenData && this.data.childrenData.category === \"subtheme\") {\n                  matchedData = _.intersectionBy(themeChild.children,[this.data.childrenData], 'refId');\n                 } else {\n                  matchedData = _.intersectionBy(themeChild.children,this.selectedCardCompThemeData.children, 'refId');\n                 }\n                  let formArray = this.competencyForm.get('compThemeFields') as UntypedFormArray;\n                  const competencySubThemeControl = formArray.at(_indexValue).get('competencySubTheme');\n                  if (competencySubThemeControl) {\n                    competencySubThemeControl.patchValue(matchedData);\n                    competencySubThemeControl.updateValueAndValidity();\n                  }\n              }\n            }\n          });\n        }\n      }\n    });\n  // }\n  }\n\n  onTermRemove(termData: any, indexValue: number) {\n    let formArray = this.competencyForm.get('compThemeFields') as UntypedFormArray;\n    const compThemeControl = formArray.at(indexValue).get('competencySubTheme') as UntypedFormControl | null\n    if (compThemeControl) {\n      const themes = compThemeControl.value\n      if (themes) {\n        const index = themes.indexOf(termData)\n        if (index >= 0) {\n          themes.splice(index, 1)\n          compThemeControl.setValue(themes)\n        }\n      }\n    }\n    \n  }\n\n  OnSubThemeSelection(_event: any, _indexValue: number, _option: any){\n    // let formArray = this.competencyForm.get('compThemeFields') as UntypedFormArray;\n    // const compThemeControl = formArray.at(indexValue).get('competencySubTheme') as UntypedFormControl | null\n    \n  }\n\n  // add form\n  async multiCreate(form: any, _data: any) {\n    this.disableMultiCreate = true\n    // let counterTheme = 0\n    let counterSubTheme = 0\n    let parentCategory = {}\n    let createdTerms:any = []\n    let createdSubTheme = []\n    if(form.valid) {\n      const themeFields = form && form.value && form.value.compThemeFields\n      if(themeFields && themeFields.length) {\n        let localCompArea = {...this.seletedCompetencyArea}\n        if(localCompArea.children && localCompArea.children.length) {\n          delete localCompArea.children\n        }\n        if(localCompArea.associations && localCompArea.associations.length) {\n          delete localCompArea.associations\n        }\n\n        // themeFields.forEach(async (objVal, themeIndex) =>\n        for(let [index, objVal] of themeFields.entries()) {\n          parentCategory = {}\n          if(objVal['competencyTheme']) {\n            createdTerms= []\n            let value = objVal['competencyTheme']\n            const term: NSFramework.ICreateTerm = {\n              code: this.frameWorkService.getUuid(),\n              name: value.name,\n              description: value.description,\n              category: this.data.columnInfo.code,\n              status: appConstants.LIVE,\n              refId: value.refId || '',\n              refType: value.refType || '',\n              // approvalStatus:appConstants.DRAFT,\n              parents: [\n                { identifier: `${this.data.frameworkId.toLowerCase()}_${this.data.columnInfo.code}` }\n              ],\n              additionalProperties: {\n                competencyArea: localCompArea,\n                timeStamp: new Date().getTime()\n              }\n            }\n            const requestBody:any = {\n              request: {\n                term: term\n              }\n            }\n            await this.frameWorkService.createTerm(this.data.frameworkId, this.data.columnInfo.code, requestBody).toPromise().then(async (res: any) => {\n              requestBody.request.term['identifier'] = res.result.node_id[0]\n              this.frameWorkService.selectionList.delete('competency')\n              parentCategory = requestBody.request.term\n              createdTerms.push(requestBody.request.term)\n              // counterTheme++\n\n              const parentColumn: any = this.frameWorkService.getPreviousCategory(this.data.columnInfo.code)\n              let parentCol: any = this.frameWorkService.selectionList.get(parentColumn.code)\n  \n              await this.updateTermAssociationsMultiV2(createdTerms,parentCol)\n              // // await this.updateTermAssociationsMulti(createdTerms)\n\n                  let data = {\n                    \"selected\": false,\n                    \"category\": parentColumn.code,\n                    \"cardSubType\": \"minimal\",\n                    \"isViewOnly\": false,\n                    \"index\": parentColumn.index,\n                    \"columnInfo\": this.data.cardColInfo\n                  }\n                  const responseData12 = {\n                    res: { term: [this.selectedTerm], created: true, multi:true },\n                    index: this.data.columnInfo.index,\n                    data: data,\n                    type: 'multi-create'\n                  }\n                  this.frameWorkService.updateAfterAddOrEditSubject(responseData12)\n\n            })\n          }\n          if(objVal['competencySubTheme']) {\n            this.frameWorkService.selectionList.set(this.data.columnInfo.code, parentCategory)\n\n            let value = objVal['competencySubTheme']\n            if(value && value.length) {\n              counterSubTheme = 0\n              createdSubTheme = []\n              // value.forEach(async (ele: any) => {\n                for(let ele of value) {\n                const term: NSFramework.ICreateTerm = {\n                  code: this.frameWorkService.getUuid(),\n                  name: ele.name,\n                  description: ele.description,\n                  category: this.data.nextColInfo.code,\n                  status: appConstants.LIVE,\n                  refId: ele.refId || '',\n                  refType: ele.refType || '',\n                  parents: [\n                    { identifier: `${this.data.frameworkId.toLowerCase()}_${this.data.nextColInfo.code}` }\n                  ],\n                  additionalProperties: {\n                    timeStamp: new Date().getTime()\n                  }\n                }\n                const requestBody:any = {\n                  request: {\n                    term: term\n                  }\n                }\n\n                 \n                let responseData: any = await this.crateTerm(this.data.frameworkId, this.data.nextColInfo.code, requestBody)\n\n                requestBody.request.term['identifier'] = responseData.result.node_id[0]\n                createdSubTheme.push(requestBody.request.term)\n                counterSubTheme++\n                if((counterSubTheme === objVal['competencySubTheme'].length)){\n                  const parentColumnConfigData:any = this.frameWorkService.getPreviousCategory(this.data.nextColInfo.code)\n                  let parentCol: any = this.frameWorkService.selectionList.get(parentColumnConfigData.code)\n      \n                  await this.updateTermAssociationsMultiV2(createdSubTheme,parentCol, index, themeFields.length)\n                  if(index === themeFields.length - 1) {\n                    this.frameWorkService.selectionList.delete('competency')\n                    this.dialogClose({ term: this.selectedTermArray, created: true, multi:false, callUpdate: false })\n                    this.disableMultiCreate = false\n                    this._snackBar.open(`Competency Mapping created successfully.`)\n                  }\n                }\n                \n              }\n            }\n          }\n          \n        }\n      }\n    }\n  }\n\n\n  async crateTerm(frameworkId: any, colCode: any, requestBody: any){\n    return new Promise(async (resolve)=>{\n      this.frameWorkService.createTerm(frameworkId, colCode, requestBody).subscribe((res: any)=>{\n        resolve(res)\n      },((_err: any) => {\n        this._snackBar.open(`Create Term failed.`)\n      }))\n    })\n  }\n\n\n\n  async updateTermAssociationsMultiV2(createdTerms: any[], parentSelectedTerm?: any, _runningIndex?: number, _themFieldsLength?: number) {\n    if(createdTerms && createdTerms.length) {\n      this.selectedTermArray = []\n      // let createdTermsCounter = 0\n      let createdTermsIdentifiers = []\n      this.selectedTermArray = createdTerms\n      this.selectedTerm = createdTerms[createdTerms.length -1]\n      for(let createdTerm of createdTerms) {\n        createdTermsIdentifiers.push({ identifier: createdTerm.identifier })\n      }\n      let associations = []\n      let counter = 0\n      if(!parentSelectedTerm) {\n        for(const [value] of this.frameWorkService.selectionList){\n          const parent:any = value\n          counter++\n          associations = parent.children ? parent.children.map((c:any) => {\n            return c.identifier ?  { identifier: c.identifier } : null\n          }) : []\n            associations = [...associations, ...createdTermsIdentifiers]\n            this.isTermExist = false\n            const reguestBody = {\n              request: {\n                term: {\n                  ...(associations && associations.length) ? {associations: [...associations]} : null,\n                }\n              }\n            }\n            await this.callUpdateAssociationsV2(counter, parent, reguestBody)\n          // createdTermsCounter++\n          // if(createdTermsCounter === this.frameWorkService.selectionList.size) {\n            // if(runningIndex === themFieldsLength - 1) {\n            \n            //     this.frameWorkService.selectionList.delete('competency')\n            //     this.dialogClose({ term: [this.selectedTerm], created: true, multi:true, callUpdate: false })\n            //     this.disableMultiCreate = false\n            \n            //     if(createdTerms[0].category === 'theme'){\n            //     this._snackBar.open(`Competency ${createdTerms[0].category} created successfully.`)\n            //     }\n            //     if(createdTerms[0].category === 'subtheme'){         \n\n            //     this._snackBar.open(`Competency ${createdTerms[0].category} created successfully.`)\n            //     }\n            // }\n          // }\n        } \n      } else {\n        const parent = parentSelectedTerm\n        associations = parent.children ? parent.children.map((c:any) => {\n          return c.identifier ?  { identifier: c.identifier } : null\n        }) : []\n          associations = [...associations, ...createdTermsIdentifiers]\n          this.isTermExist = false\n          const reguestBody = {\n            request: {\n              term: {\n                ...(associations && associations.length) ? {associations: [...associations]} : null,\n              }\n            }\n          }\n          return await this.callUpdateAssociationsV2(counter, parent, reguestBody)\n\n          // if(createdTermsCounter === this.frameWorkService.selectionList.size) {\n          \n          // }\n          // this.dialogClose({ term: [this.selectedTerm], created: true, multi:true, stopUpdate: false })\n          this.disableMultiCreate = false\n          // if(createdTerms[0].category === 'subtheme'){   \n          //   this._snackBar.open(`Competency ${createdTerms[0].category} created successfully.`)\n          // }\n      }\n    }\n  }\n\n  async updateTermAssociationsMulti(createdTerms: any[]) {\n    if(createdTerms && createdTerms.length) {\n      // let createdTermsCounter = 0\n      for(let createdTerm of createdTerms) {\n        this.selectedTerm = createdTerm\n        let associations = []\n        let temp\n        let counter = 0\n        // let localIsExist = false\n        \n        for(const [value] of this.frameWorkService.selectionList){\n          const parent:any = value\n          counter++\n          temp = parent.children ? parent.children.filter((child:any) => child.identifier === this.selectedTerm.identifier) : null\n          associations = parent.children ? parent.children.map((c:any) => {\n            return c.identifier ?  { identifier: c.identifier } : null\n          }) : []\n          if (temp && temp.length) {\n            this.isTermExist = true\n            return\n          } else {\n              associations.push({ identifier: this.selectedTerm.identifier })\n              this.isTermExist = false\n              // if(createdTermsCounter === (createdTerms.length-1)) {\n                const reguestBody = {\n                  request: {\n                    term: {\n                      ...(associations && associations.length) ? {associations: [...associations]} : null,\n                    }\n                  }\n                }\n                await this.callUpdateAssociations(counter, parent, reguestBody)\n                \n              // }\n          }\n        }\n        // createdTermsCounter++\n      }\n    }\n  }\n\n  async callUpdateAssociationsV2(counter: any, parent: any, reguestBody: any ): Promise<any>{\n    return new Promise(async (resolve) => {\n       this.frameWorkService.updateTerm(this.data.frameworkId, parent.category, parent.code, reguestBody).subscribe(async () => {\n        parent['children'] = parent && parent.children ?[...parent.children, ...this.selectedTermArray]:this.selectedTermArray\n          let listData : any = this.frameWorkService.list.get(this.data.columnInfo.code)\n          let differenceData = []\n          if(listData && listData.children && listData.children.length) {\n            differenceData  = _.differenceBy(this.selectedTermArray,listData.children, 'identifier');\n          } else {\n            differenceData = this.selectedTermArray\n          }\n          listData['associations'] = listData && listData.associations ?[...listData.associations, ...differenceData]:differenceData\n          listData['children'] = listData && listData.children ?[...listData.children, ...differenceData]:differenceData\n\n          this.frameWorkService.selectionList.forEach((selectedData: any)=> {\n            let listData : any = this.frameWorkService.list.get(selectedData.category)\n            if(listData && listData.children && listData.children.length) {\n              this.updateLocalList(listData,parent, this.selectedTermArray)\n            }\n          }) \n        // let selectedCardInfo = this.frameWorkService.selectionList.get(this.data.cardColInfo.code)\n        // this.frameWorkService.currentSelection.next({ type: selectedCardInfo.code, data:selectedCardInfo, cardRef:selectedCardInfo.cardRef, isUpdate: true})\n        if (counter === this.frameWorkService.selectionList.size) {\n          // this value is for selected term in case of create scenario, in case of edit scenario this won't be avaiable \n          // so term is set from childdata which is received from params in updateData\n          // const value = (this.selectedTerm && this.selectedTerm.identifier) ? this.selectedTerm : {}\n          \n          // const found = parent.children ? parent.children.find(c=> c.identifier === this.selectedTerm.identifier) : false\n          // if(!found) {\n\n            // parent['children'] = parent && parent.children ?[...parent.children, ...this.selectedTermArray]:this.selectedTermArray\n            // parent.children ? parent.children.push(this.selectedTerm) : parent['children'] = [this.selectedTerm]\n          // }\n          this.disableUpdate = false\n          let returnValue : any = true\n          resolve(true)\n          await returnValue\n        } else {\n          let returnValue : any = true\n          resolve(true)\n          await returnValue\n        }\n      }, (_err: any) => {\n        console.error(`Edit ${this.data.columnInfo.name} failed, please try again later`)\n        this._snackBar.open(`Term Association failed.`)\n        this.disableMultiCreate = false\n      })\n    })\n  }\n\n  async callUpdateAssociations(counter: any, parent: any, reguestBody: any ): Promise<any>{\n    return new Promise(async (resolve) => {\n       this.frameWorkService.updateTerm(this.data.frameworkId, parent.category, parent.code, reguestBody).subscribe(async () => {\n        if (counter === this.frameWorkService.selectionList.size) {\n          // this.selectedTerm['associationProperties']['approvalStatus'] = 'Draft';\n  \n          // this value is for selected term in case of create scenario, in case of edit scenario this won't be avaiable \n          // so term is set from childdata which is received from params in updateData\n          // const value = (this.selectedTerm && this.selectedTerm.identifier) ? this.selectedTerm : {}\n          const found = parent.children ? parent.children.find((c:any)=> c.identifier === this.selectedTerm.identifier) : false\n          if(!found) {\n            parent.children ? parent.children.push(this.selectedTerm) : parent['children'] = [this.selectedTerm]\n          }\n          this.disableUpdate = false\n          let returnValue : any = true\n          resolve(true)\n          await returnValue\n        } else {\n          let returnValue : any = true\n          resolve(true)\n          await returnValue\n        }\n      }, (_err: any) => {\n        console.error(`Edit ${this.data.columnInfo.name} failed, please try again later`)\n      })\n    })\n  }\n\n  updateTermData(form:any, data: any) {\n    this.disableUpdate = true\n    const formData = {\n      // use this if you need disabled field values : form.getRawValue()\n      ...form.value\n    }\n    const updateData = {\n      formData,\n      updateTermData: data.childrenData\n    }\n    this.updateTermAssociations(updateData)\n  }\n\n  updateTermAssociations(updateData?: any) {\n    let associations = []\n    let temp\n    let counter = 0\n    // let localIsExist = false\n    this.frameWorkService.selectionList.forEach((parent) => {\n      counter++\n      temp = parent.children ? parent.children.filter((child:any) => child.identifier === this.selectedTerm.identifier) : null\n      associations = parent.children ? parent.children.map((c:any) => {\n        // return { identifier: c.identifier, approvalStatus: c.associationProperties?c.associationProperties.approvalStatus: 'Draft' }\n        return c.identifier ?  { identifier: c.identifier } : null\n      }) : []\n      if (temp && temp.length) {\n        this.isTermExist = true\n        return\n      } else {\n        // associations.push({ identifier: this.selectedTerm.identifier, approvalStatus: appConstants.DRAFT })\n        if(this.selectedTerm && this.selectedTerm.identifier) {\n          associations.push({ identifier: this.selectedTerm.identifier })\n        }\n        this.isTermExist = false\n        const reguestBody = {\n          request: {\n            term: {\n              ...(updateData && updateData.formData && updateData.updateTermData.code === parent.code) ? {...updateData.formData}: null,\n              ...(associations && associations.length) ? {associations: [...associations]} : null,\n            }\n          }\n        }\n        this.frameWorkService.updateTerm(this.data.frameworkId, parent.category, parent.code, reguestBody).subscribe(() => {\n          if (counter === this.frameWorkService.selectionList.size) {\n            // this.selectedTerm['associationProperties']['approvalStatus'] = 'Draft';\n\n            // this value is for selected term in case of create scenario, in case of edit scenario this won't be avaiable \n            // so term is set from childdata which is received from params in updateData\n            const value = (this.selectedTerm && this.selectedTerm.identifier) ? this.selectedTerm : (updateData) ? {...updateData.updateTermData, ...updateData.formData} : {}\n            this.disableUpdate = false\n            this.dialogClose({ term: { ...value }, created: true })\n          }\n        }, (_err: any) => {\n          console.error(`Edit ${this.data.columnInfo.name} failed, please try again later`)\n          this._snackBar.open(`Term Association failed.`)\n          this.disableMultiCreate = false\n        })\n      }\n    })\n  }\n\n\n  dialogClose(term: any) {\n    this.frameWorkService.publishFramework().subscribe(() => {\n      this.disableMultiCreate = false\n      this.dialogRef.close(term)\n    },(_err:any)=> {\n      this.disableMultiCreate = false\n      this.dialogRef.close(term)\n      this._snackBar.open(`Publish  failed.`)\n    });\n  }\n\n\n\n\n\n  async multiCreateSubTheme(_form: any, data: any) {\n    this.disableMultiCreate = true\n    let formArray:any = this.competencyForm.get('compThemeFields') as UntypedFormArray;\n    let selectedFormData:any  = formArray.at(0).get('competencySubTheme').value\n    let previousSubThemeData = data.childrenData.children\n    let newlyAdded: any = []\n    let removedExisting:any = []\n    let createdSubTheme = []\n    let counterSubTheme = 0\n    // let counterRetireSubTheme = 0\n    \n    newlyAdded = _.differenceBy(selectedFormData, previousSubThemeData, 'refId');\n    removedExisting = _.differenceBy(previousSubThemeData, selectedFormData, 'refId');\n    if(newlyAdded && newlyAdded.length) {\n        // newlyAdded.forEach(async (val, i) =>{\n        for(let val of newlyAdded){\n          const term: NSFramework.ICreateTerm = {\n          code: this.frameWorkService.getUuid(),\n          name: val.name,\n          description: val.description,\n          category: this.data.columnInfo.code,\n          status: appConstants.LIVE,\n          refId: val.refId,\n          refType: val.refType,\n          // approvalStatus:appConstants.DRAFT,\n          parents: [\n            { identifier: `${this.data.frameworkId.toLowerCase()}_${this.data.columnInfo.code}` }\n          ],\n          additionalProperties: {\n            timeStamp: new Date().getTime()\n          }\n          }\n          const requestBody:any = {\n            request: {\n              term: term\n            }\n          }\n\n          const parentColumnConfigData:any = this.frameWorkService.getPreviousCategory(this.data.columnInfo.code)\n          let parentCol: any = this.frameWorkService.selectionList.get(parentColumnConfigData.code)\n        \n            \n          let responseData: any = await this.crateTerm(this.data.frameworkId, this.data.columnInfo.code, requestBody)\n          requestBody.request.term['identifier'] = responseData.result.node_id[0]\n          createdSubTheme.push(requestBody.request.term)\n          counterSubTheme++\n          if(counterSubTheme === newlyAdded.length){\n            await this.updateTermAssociationsMultiV2(createdSubTheme, parentCol)\n            \n            this.frameWorkService.updateFrameworkList(this.data.columnInfo.code, parentCol, createdSubTheme, 'create')\n            if(!(removedExisting && removedExisting.length)) {\n              this.dialogClose({ term: this.selectedTermArray, created: true, multi:true, callUpdate: false })\n              this.disableMultiCreate = false\n              this._snackBar.open(`Competency theme updated successfully.`)\n            }\n          }\n        }\n    }\n  \n    if(removedExisting && removedExisting.length) {\n      let removedTermsCollection = []\n      for(let removedTerm of removedExisting) {\n        removedTermsCollection.push(removedTerm.code)\n      }\n        \n        let subThemeRequest ={\n          \"request\": { \n            \"contentIds\": removedTermsCollection \n          }\n        }\n        \n        await this.frameWorkService.retireMultipleTerm(this.data.frameworkId, this.data.columnInfo.code, subThemeRequest).toPromise().then(async () => {\n\n          // counterRetireSubTheme++\n          const parentColumnConfigData:any = this.frameWorkService.getPreviousCategory(this.data.columnInfo.code)\n          let parentCol: any = this.frameWorkService.selectionList.get(parentColumnConfigData.code)\n\n          // let sectionList = this.frameWorkService.selectionList.get(parentColumnConfigData.code)\n          \n          const sectionListchildrenList: any = _.differenceWith(parentCol.children, removedExisting, (a:any, b: any) => a.identifier === b.identifier);\n          const sectionListAssociationList: any = _.differenceWith(parentCol.associations, removedExisting, (a:any, b: any) => a.identifier === b.identifier);\n         \n          parentCol['children'] = sectionListchildrenList\n          parentCol['associations'] = sectionListAssociationList\n    \n\n          this.frameWorkService.updateFrameworkList(this.data.columnInfo.code, parentCol, removedExisting, 'delete')\n\n          this.dialogClose({ term: [], created: true, multi:true, callUpdate: false })\n          this.frameWorkService.currentSelection.next({ type: parentColumnConfigData.code, data: parentCol, cardRef: parentCol.cardRef });\n          this.disableMultiCreate = false\n          this._snackBar.open(`Competency theme updated successfully.`)\n\n        })\n    }\n\n    this.disableMultiCreate = false\n  }\n\n  onDisableTheme(option: any){\n    const parentColumnConfigData:any = this.frameWorkService.getPreviousCategory(this.data.columnInfo.code)\n    let parentCol: any = this.frameWorkService.selectionList.get(parentColumnConfigData.code)\n    let result = -1\n    if(parentCol && parentCol.children && parentCol.children.length){\n      result = parentCol.children.findIndex((ele: any) => {\n        if( (ele.refType === 'theme')  && (this.seletedCompetencyArea.code === ele.additionalProperties.competencyArea.code)) {\n        return  ele.refId === option.refId\n        }\n        return false\n      })\n    }\n\n    if(result < 0){\n      let formArray = this.competencyForm.get('compThemeFields') as UntypedFormArray;\n      result = formArray.value.findIndex((formEle: any) => {\n        if(formEle.competencyTheme && formEle.competencyTheme.refId ){\n          return  formEle.competencyTheme.refId === option.refId\n        }\n        return false\n      });\n     }\n \n    // \n    \n    return result >= 0 ? true: false\n  }\n\n\n  updateLocalList(item: any, parent: any,selectedTermArray: any, updateType?:any) {\n    if(item && item.children && item.children.length) {\n      if(updateType === 'delete'){\n        item.children.forEach((itmData: any) => {\n          if(itmData.identifier === parent.identifier) {\n            // let differenceData = []\n            // if(itmData && itmData.children && itmData.children.length) {\n            //   differenceData  = _.differenceBy(itmData.children,selectedTermArray, 'identifier');\n            // } else {\n            //   differenceData = selectedTermArray\n            // }\n            // differenceData = this.selectedTermArray\n            const associationList: any = _.differenceWith(itmData.associations,selectedTermArray, (a:any, b: any) => a.identifier === b.identifier);\n            const childrenList: any = _.differenceWith(itmData.children, selectedTermArray, (a:any, b: any) => a.identifier === b.identifier);\n            itmData['associations'] = associationList\n            itmData['children'] = childrenList\n          }\n          if(itmData.children) {\n            this.updateLocalList(itmData, parent,selectedTermArray,updateType)\n          }\n        })\n      } else {\n        item.children.forEach((itmData: any) => {\n          if(itmData.identifier === parent.identifier) {\n            let differenceData = []\n            if(itmData && itmData.children && itmData.children.length) {\n              differenceData  = _.differenceBy(selectedTermArray,itmData.children, 'identifier');\n            } else {\n              differenceData = selectedTermArray\n            }\n            // differenceData = this.selectedTermArray\n            itmData['associations'] = itmData && itmData.associations ?[...itmData.associations, ...differenceData]:differenceData\n            itmData['children'] = itmData && itmData.children ?[...itmData.children, ...differenceData]:differenceData\n          }\n          if(itmData.children) {\n            this.updateLocalList(itmData, parent, selectedTermArray)\n          }\n        })\n      }\n    }\n  }\n\n  deleteTheme() {\n    this.disableMultiCreate = true\n    const cardData = this.data.childrenData\n    let removedListTerm = []\n    removedListTerm.push(cardData.code)\n    let subThemeRequest ={\n      \"request\": { \n        \"contentIds\": removedListTerm\n      }\n    }\n    \n    this.frameWorkService.retireMultipleTerm(this.frameWorkService.frameworkId, cardData.category, subThemeRequest).toPromise().then(async () => {\n      \n      let removedExisting = [cardData]\n      const parentColumnConfigData:any = this.frameWorkService.getPreviousCategory(cardData.category)\n      let parentCol: any = this.frameWorkService.selectionList.get(parentColumnConfigData.code)\n    \n      const sectionListchildrenList: any = _.differenceWith(parentCol.children, removedExisting, (a:any, b: any) => a.identifier === b.identifier);\n      const sectionListAssociationList: any = _.differenceWith(parentCol.associations, removedExisting, (a:any, b: any) => a.identifier === b.identifier);\n    \n      parentCol['children'] = sectionListchildrenList\n      parentCol['associations'] = sectionListAssociationList\n      this.frameWorkService.updateFrameworkList(cardData.category, parentCol, removedExisting, 'delete')\n      this.frameWorkService.currentSelection.next({ type: parentColumnConfigData.code, data: parentCol, cardRef: parentCol.cardRef })\n      this.dialogClose({})\n      this.disableMultiCreate = false\n      this._snackBar.open(`Competency theme deleted successfully.`)\n    },((_err: any)=> {\n      this.disableMultiCreate = false\n      this._snackBar.open(`Competency theme delete failed.`)\n    }))\n  }\n\n\n  // getter methods\n\n  get compThemeFields(): UntypedFormArray {\n    return this.competencyForm.get('compThemeFields') as UntypedFormArray;\n  }\n\n}\n","\n<div class=\"\">\n    <ng-container *ngIf=\"disableMultiCreate\">\n        <div class=\"flex flex-col flex-1 w-100 absolute loader-bg items-center pt-5 text-center\">\n          <mat-spinner class=\"display-inline-block mb-5\" [diameter]=\"50\" [strokeWidth]=\"3\"></mat-spinner>\n          <!-- <p>{{loaderMsg}}</p> -->\n        </div>\n      </ng-container>\n      <div class=\"dialogNew\">\n        <div class=\"flex items-center justify-between\">\n            <ng-container [ngTemplateOutlet]=\"modalTitle\"></ng-container>\n            <button type=\"button\" mat-icon-button i18n-aria-label aria-label=\"action items\"\n            [matMenuTriggerFor]=\"cardMenu\" [matMenuTriggerData]=\"{'data':data}\" class=\"action-btn\">\n            <mat-icon>more_vert</mat-icon>\n            </button>\n        </div>\n        <div class=\"flex gap-4\">\n            <ng-container *ngFor=\"let term of data?.selectedParentTerms\">\n                <ng-container *ngIf=\"term.category !== 'competency'\">\n                    <div class=\"flex-1 flex-col\">\n                        <label for=\"name\" class=\"margin-remove-bottom form-label\" aria-label=\"First name label\">\n                            {{frameWorkService.getConfig(term.category).labelName}}\n                        </label>\n                        <mat-form-field appearance=\"outline\" class=\"flex-1\">\n                            <input matInput name=\"name\" id=\"name\" #name placeholder=\"{{app_strings.name}}\"\n                                [value]=\"term.name\" disabled>\n                        </mat-form-field>\n                    </div>\n                </ng-container>\n            </ng-container>\n        </div>\n        <div class=\"row-divider\"></div>\n        <ng-container *ngIf=\"competencyForm\">\n            <form [formGroup]=\"competencyForm\">\n                <div class=\"title-text\">\n                    <label for=\"name\" class=\"margin-remove-bottom form-label required\" aria-label=\"First name labe \">\n                        {{'Select Area'}}\n                    </label>\n                    <div class=\"mt-5\">\n                        <mat-radio-group class=\"competency-group\" aria-label=\"Select an option\" formControlName=\"compArea\">\n                            <mat-radio-button  [disabled]=\"data?.columnInfo?.code === 'subtheme' || data.openMode ==='view'\" class=\"learning-section\" [ngClass]=\"{'active-btn':item?.code === seletedCompetencyArea?.code}\"\n                             *ngFor=\"let item of competencyArea?.children\" [value]=\"item\" [checked]=\"item?.code === seletedCompetencyArea?.code\" (change)=\"clearSelectedThemes(item)\">{{item.name}}</mat-radio-button>\n                        </mat-radio-group>\n                    </div>\n                </div>\n                <ng-container *ngIf=\"data?.mode === 'multi-create'\">\n                        <div class=\"flex flex-end mb-4\" >\n                            <ng-container *ngIf=\"data?.columnInfo?.code !== 'subtheme'\">\n                                <button type=\"button\" class=\"mat-button flex items-center create-accordion-btn\" *ngIf=\"data.mode === 'multi-create'\" (click)=\"addCompetencyTheme()\">\n                                    <mat-icon class=\"mr-2 mat-icon-custom \">add_circle_outline</mat-icon>\n                                    Add more\n                                    <!-- {{data.columnInfo.name}}  -->\n                                </button>\n                            </ng-container>\n                        </div>\n                        <mat-accordion formArrayName=\"compThemeFields\">\n                            <mat-expansion-panel *ngFor=\"let field of competencyForm?.get('compThemeFields')['controls']; let i = index; let isFirst = first\" \n                            class=\"margin-bottom-l comp-theme-fields\" [formGroupName]=\"i\" [expanded]=\"isFirst\">               \n                             <mat-expansion-panel-header>\n                                    <mat-panel-title>\n                                        {{competencyForm?.get('compThemeFields')['controls'][i]['controls']?.competencyTheme?.value?.name}} \n                                    </mat-panel-title>\n                                    <ng-container *ngIf=\"data?.columnInfo?.code !== 'subtheme'\">\n                                        <button mat-button type=\"button\" *ngIf=\"data.mode === 'multi-create'\"\n                                        (click)=\"removeCompFields(i)\">\n                                        <mat-icon class=\"mat-icon-custom \">delete</mat-icon>\n                                        </button>\n                                    </ng-container>\n                                </mat-expansion-panel-header>\n                                <div class=\"input-column\">\n                                    <div class=\"input-wrapper margin-top-s\">\n                                        <div class=\"flex gap-4 \">\n                                            <div class=\"flex-1 flex-col\">\n                                                <label for=\"name\" class=\"margin-remove-bottom form-label required\"\n                                                    aria-label=\"First name label\">\n                                                    {{data.openMode !== 'view'? 'Select Competency Theme': 'Competency Theme Name'}}\n                                                </label>\n                                                <mat-form-field appearance=\"outline\" class=\"flex-1\">\n                                                    <mat-select [disabled]=\"data?.columnInfo?.code === 'subtheme' || data.openMode ==='view'\" placeholder=\"Choose the Competency Theme\" formControlName=\"competencyTheme\">\n                                                        <ng-container >\n                                                            <ng-container >\n                                                                <mat-option *ngFor=\"let option of filteredallCompetencyTheme\"  [value]=\"option\" [disabled]=\"onDisableTheme(option) || data.openMode ==='view'\" \n                                                                (onSelectionChange)=\"OnThemeSelection($event, i, option)\"  >{{option.name}}\n                                                                <ng-container *ngIf=\"option.refId\">\n                                                                <span class=\"ml-2 ref-id\">({{option.refId}})</span>\n                                                                </ng-container>\n                                                               </mat-option>\n                                                            </ng-container>\n                                                        </ng-container>\n                                                    </mat-select>\n                                                </mat-form-field>\n                                                <mat-error *ngIf=\"isTermExist\">{{app_strings.alreadyExist}}</mat-error>\n                                            </div>\n                                        </div>\n            \n                                        <div class=\"flex-col mt-2\">\n                                            <label for=\"fname\" class=\"margin-remove-bottom form-label required\"\n                                                i18n=\"First Name label|Label which explains the user to enter first name\"\n                                                i18n-aria-label aria-label=\"First name label\">\n\n                                                {{data.openMode !== 'view'? 'Select Competency Sub-Theme': 'Competency Sub-Theme Name'}}\n                                                \n                                            </label>\n                                            <!-- <mat-form-field appearance=\"outline\" class=\"flex-1\">\n                                                <mat-select placeholder=\"Choose the Competency Theme\" formControlName=\"competencySubTheme\">\n                                                    <mat-option *ngFor=\"let option of filteredallCompetencySubTheme\" [value]=\"option\">{{option.name}}</mat-option>\n                                                </mat-select>\n                                            </mat-form-field> -->\n                                            <!-- {{competencyForm?.get('compThemeFields')['controls'][i]['controls']?.competencySubTheme?.value |json}} -->\n                                            <mat-form-field appearance=\"outline\" class=\"w-full field-height\" >\n                                                <mat-select class=\" placeholder-text\" placeholder=\"Choose the Competency Sub-Theme\"\n                                                  formControlName=\"competencySubTheme\" multiple [disabled]=\"data.openMode ==='view'\" panelClass=\"full-width-panel\">\n                                                  <!-- [ngClass]=\"{'disbaledSelect':isHideData}\" -->\n                                                  <mat-select-trigger >\n                                                    <mat-chip-listbox>\n                                                        <!-- -->\n                                                       \n                                                      <mat-chip *ngFor=\"let item of competencyForm?.get('compThemeFields')['controls'][i]['controls']?.competencySubTheme?.value\" \n                                                      (removed)=\"onTermRemove(item, i)\" [disabled]=\"data.openMode ==='view'\"\n                                                      [ngClass]=\"{'sub-theme-disable': data?.openMode ==='view'}\"  [removable]=\"data?.openMode ==='view'? false: true\">\n                                                        <span >{{ item.name }}</span>\n                                                        <mat-icon matChipRemove>cancel</mat-icon>\n                                                      </mat-chip>\n                                                    </mat-chip-listbox>\n                                                  </mat-select-trigger>\n                                                  <!-- {{competencyForm?.get('compThemeFields') |json}} -->\n                                                  <!-- <mat-optgroup>\n                                                    <mat-form-field floatLabel=\"never\">\n                                                      <input #search autocomplete=\"off\" placeholder=\"Search\" (keydown.space)=\"$event.stopPropagation()\"\n                                                        formControlName=\"competencySubTheme\" matInput>\n                                                    </mat-form-field>\n                                                  </mat-optgroup> -->\n                                                  <mat-optgroup *ngIf=\"filteredallCompetencySubTheme.length === 0\">\n                                                    <div>No results found!</div>\n                                                  </mat-optgroup>\n                                                  <!-- <mat-option *ngFor=\"let option of requestObjData.preferredProvider\" [value]=\"option.providerName\">{{option.providerName}}</mat-option> -->\n                                                  <ng-container *ngFor=\"let option of competencyForm?.get('compThemeFields')['controls'][i]['controls']?.competencyTheme?.value?.children\">\n                                                        <mat-option \n                                                        [value]=\"option\" class=\"mat-option-list\">{{option?.name}}\n                                                        <ng-container *ngIf=\"option?.refId\">\n                                                         <span class=\"ml-2 ref-id\">({{option?.refId}})</span>\n                                                        </ng-container>\n                                                     </mat-option>\n                                                  </ng-container>\n                                \n                                                </mat-select>\n                                                <!-- <mat-error *ngIf=\"requestForm.controls['providerText'].hasError('required')\">\n                                                  Please select up to five preferred providers for the request.\n                                                </mat-error> -->\n                                              </mat-form-field>\n                                        </div>\n                                    </div>\n                                </div>\n                            </mat-expansion-panel>\n                        </mat-accordion>\n                        <footer class=\"actions\">\n                            <button mat-raised-button color=\"default\" type=\"reset\"\n                                (click)=\"dialogClose('')\">{{app_strings.cancel}}</button>\n                            <ng-container *ngIf=\"data?.mode === 'create' && data.openMode !=='view'\">\n                                <button mat-raised-button color=\"primary\" type=\"submit\" cdkFocusInitial\n                                    [disabled]=\"competencyForm?.invalid\" *ngIf=\"!disableCreate\">{{app_strings.create}}</button>\n                            </ng-container>\n                            <ng-container *ngIf=\"data?.mode === 'multi-create' && data.openMode !=='view'\">\n                                <ng-container *ngIf=\"data?.columnInfo?.code !== 'subtheme'\">\n                                    <button mat-raised-button color=\"primary\" type=\"button\" cdkFocusInitial\n                                    [disabled]=\"competencyForm.invalid || disableMultiCreate\" *ngIf=\"!disableCreate\" (click)=\"multiCreate(competencyForm, data)\">\n                                    {{app_strings.create}}\n                                    </button>\n                                </ng-container>\n                                <ng-container *ngIf=\"data?.columnInfo?.code === 'subtheme'\">\n                                    <!-- <ng-container *ngIf=\"competencyForm?.get('compThemeFields')['controls'][0]['controls']?.competencySubTheme?.value?.length;else updateBtn\"> -->\n                                        <button mat-raised-button color=\"primary\" type=\"button\" cdkFocusInitial\n                                        [disabled]=\"competencyForm.invalid || disableMultiCreate\" *ngIf=\"!disableCreate\" (click)=\"multiCreateSubTheme(competencyForm, data)\">\n                                        {{app_strings.update}}\n                                        </button>\n                                    <!-- </ng-container> -->\n                                    \n                                    <!-- <ng-template #updateBtn>\n                                        <button mat-raised-button color=\"primary\" type=\"button\" cdkFocusInitial\n                                        [disabled]=\"competencyForm.invalid || disableMultiCreate\" *ngIf=\"!disableCreate\" (click)=\"multiCreateSubTheme(competencyForm, data)\">\n                                        {{app_strings.delete}}\n                                        </button>\n                                    </ng-template> -->\n                                </ng-container>\n                            </ng-container>\n                            <ng-container *ngIf=\"data?.mode === 'edit' && data.openMode !=='view'\">\n                                <button mat-raised-button color=\"primary\" type=\"button\" cdkFocusInitial\n                                    (click)=\"updateTermData(competencyForm, data)\"\n                                    [disabled]=\"competencyForm?.invalid || disableUpdate\"\n                                    *ngIf=\"!disableCreate\">{{app_strings.update}}</button>\n                            </ng-container>\n                        </footer>\n                    </ng-container>\n                </form>\n        </ng-container>\n    \n    </div>\n    \n    \n    <!-- Title of the popup -->\n    <ng-template #modalTitle>\n        <!-- <ng-container *ngIf=\"data?.mode === 'create' || data?.mode === 'multi-create'\">\n            <div class=\"dialog-title\" mat-dialog-title>{{data.columnInfo.name === 'Theme' ? app_strings.addCompetency : app_strings.createNew}} {{data.columnInfo.name}}</div>\n        </ng-container> -->\n        <!-- {{data |json}} -->\n        <ng-container *ngIf=\"data?.mode === 'create' || data?.mode === 'multi-create'\">\n            <div class=\"dialog-title\" mat-dialog-title>{{getCreateName(data)}}</div>\n        </ng-container>\n        <!-- <ng-container *ngIf=\"data?.mode === 'view'\">\n            <div class=\"dialog-title\" mat-dialog-title>View {{data.columnInfo.name}}</div>\n        </ng-container> -->\n        <ng-container *ngIf=\"data?.mode === 'edit'\">\n            <div class=\"dialog-title\" mat-dialog-title>{{app_strings.edit}} {{data.columnInfo.name}}</div>\n        </ng-container>\n    </ng-template>\n</div>\n\n\n<mat-menu #cardMenu=\"matMenu\" class=\"menu-sec\">\n    <ng-template matMenuContent let-rowData=\"data\" let-cardRef=\"cardRef\">\n        <button  (click)=\"deleteTheme()\"\n            mat-menu-item name=\"channel-analytics-button\" class=\"ws-mat-primary-text\" i18n-aria-label\n            aria-label=\"Analytics\">\n            <mat-icon>delete</mat-icon>\n            <span>Delete</span>\n        </button>\n    </ng-template>\n</mat-menu>"]}