catalog-ui/src/app/ng2/components/logic/service-dependencies/service-dependencies.component.ts

   1 /*!
   2  * Copyright © 2016-2018 European Support Limited
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
  13  * or implied. See the License for the specific language governing
  14  * permissions and limitations under the License.
  15  */
  16 import {Component, ComponentRef, EventEmitter, Input, Output} from '@angular/core';
  17 import {
  18     ButtonModel,
  19     ComponentInstance,
  20     InputBEModel,
  21     ModalModel,
  22     PropertyBEModel,
  23     PropertyModel,
  24 } from 'app/models';
  25 import { ModalComponent } from 'app/ng2/components/ui/modal/modal.component';
  26 import { ServiceDependenciesEditorComponent } from 'app/ng2/pages/service-dependencies-editor/service-dependencies-editor.component';
  27 import { ModalService } from 'app/ng2/services/modal.service';
  28 import { ComponentGenericResponse } from 'app/ng2/services/responses/component-generic-response';
  29 import { TranslateService } from 'app/ng2/shared/translator/translate.service';
  30 import { ComponentMetadata } from '../../../../models/component-metadata';
  31 import { ServiceInstanceObject } from '../../../../models/service-instance-properties-and-interfaces';
  32 import { TopologyTemplateService } from '../../../services/component-services/topology-template.service';
  33 import {CapabilitiesFilterPropertiesEditorComponent} from "../../../pages/composition/capabilities-filter-properties-editor/capabilities-filter-properties-editor.component";
  34 import {CapabilitiesConstraintObject} from "../capabilities-constraint/capabilities-constraint.component";
  35 import {ToscaFilterConstraintType} from "../../../../models/tosca-filter-constraint-type.enum";
  36
  37 export class ConstraintObject {
  38     servicePropertyName: string;
  39     constraintOperator: string;
  40     sourceType: string;
  41     sourceName: string;
  42     value: string;
  43
  44     constructor(input?: any) {
  45         if (input) {
  46             this.servicePropertyName = input.servicePropertyName;
  47             this.constraintOperator = input.constraintOperator;
  48             this.sourceType = input.sourceType;
  49             this.sourceName = input.sourceName;
  50             this.value = input.value;
  51         }
  52     }
  53 }
  54
  55 // tslint:disable-next-line:max-classes-per-file
  56 export class ConstraintObjectUI extends ConstraintObject{
  57     isValidValue: boolean;
  58
  59     constructor(input?: any) {
  60         super(input);
  61         if (input) {
  62             this.isValidValue = input.isValidValue ? input.isValidValue : input.value !== '';
  63         }
  64     }
  65
  66     public updateValidity(isValidValue: boolean) {
  67         this.isValidValue = isValidValue;
  68     }
  69
  70     public isValidRule(isStatic) {
  71         const isValidValue = isStatic ? this.isValidValue : true;
  72         return this.servicePropertyName != null && this.servicePropertyName !== ''
  73             && this.value != null && this.value !== '' && isValidValue;
  74     }
  75 }
  76
  77 export const OPERATOR_TYPES = {
  78     EQUAL: 'equal',
  79     GREATER_THAN: 'greater_than',
  80     LESS_THAN: 'less_than'
  81 };
  82
  83 // tslint:disable-next-line:max-classes-per-file
  84 class I18nTexts {
  85     static removeDirectiveModalTitle: string;
  86     static removeDirectiveModalText: string;
  87     static updateDirectiveModalTitle: string;
  88     static updateDirectiveModalText: string;
  89     static modalApprove: string;
  90     static modalCancel: string;
  91     static modalCreate: string;
  92     static modalSave: string;
  93     static modalDelete: string;
  94     static addNodeFilterTxt: string;
  95     static updateNodeFilterTxt: string;
  96     static deleteNodeFilterTxt: string;
  97     static deleteNodeFilterMsg: string;
  98     static validateCapabilitiesTxt: string
  99     static validateCapabilitiesMsg: string
 100     static validateNodePropertiesTxt: string
 101     static validateNodePropertiesMsg: string
 102
 103     public static translateTexts(translateService) {
 104             I18nTexts.removeDirectiveModalTitle = translateService.translate('DIRECTIVES_AND_NODE_FILTER_REMOVE_TITLE');
 105             I18nTexts.removeDirectiveModalText = translateService.translate('DIRECTIVES_AND_NODE_FILTER_REMOVE_TEXT');
 106             I18nTexts.updateDirectiveModalTitle = translateService.translate('DIRECTIVES_AND_NODE_FILTER_UPDATE_TITLE');
 107             I18nTexts.updateDirectiveModalText = translateService.translate('DIRECTIVES_AND_NODE_FILTER_UPDATE_TEXT');
 108             I18nTexts.modalApprove = translateService.translate('MODAL_APPROVE');
 109             I18nTexts.modalCancel = translateService.translate('MODAL_CANCEL');
 110             I18nTexts.modalCreate = translateService.translate('MODAL_CREATE');
 111             I18nTexts.modalSave = translateService.translate('MODAL_SAVE');
 112             I18nTexts.modalDelete = translateService.translate('MODAL_DELETE');
 113             I18nTexts.addNodeFilterTxt = translateService.translate('DIRECTIVES_AND_NODE_FILTER_ADD_NODE_FILTER');
 114             I18nTexts.updateNodeFilterTxt = translateService.translate('DIRECTIVES_AND_NODE_FILTER_UPDATE_NODE_FILTER');
 115             I18nTexts.deleteNodeFilterTxt = translateService.translate('DIRECTIVES_AND_NODE_FILTER_DELETE_NODE_FILTER');
 116             I18nTexts.deleteNodeFilterMsg = translateService.translate('DIRECTIVES_AND_NODE_FILTER_DELETE_NODE_FILTER_MSG');
 117             I18nTexts.validateCapabilitiesTxt = translateService.translate('VALIDATE_CAPABILITIES_TXT');
 118             I18nTexts.validateCapabilitiesMsg = translateService.translate('VALIDATE_CAPABILITIES_MSG');
 119             I18nTexts.validateNodePropertiesTxt = translateService.translate('VALIDATE_NODE_PROPERTIES_TXT');
 120             I18nTexts.validateNodePropertiesMsg = translateService.translate('VALIDATE_NODE_PROPERTIES_MSG');
 121     }
 122 }
 123
 124 // tslint:disable-next-line:max-classes-per-file
 125 @Component({
 126     selector: 'service-dependencies',
 127     templateUrl: './service-dependencies.component.html',
 128     styleUrls: ['service-dependencies.component.less'],
 129     providers: [ModalService, TranslateService]
 130 })
 131
 132 export class ServiceDependenciesComponent {
 133     modalInstance: ComponentRef<ModalComponent>;
 134     isDependent: boolean;
 135     isLoading: boolean;
 136     parentServiceInputs: InputBEModel[] = [];
 137     parentServiceProperties: PropertyBEModel[] = [];
 138     constraintProperties: ConstraintObject[] = [];
 139     constraintCapabilities: CapabilitiesConstraintObject[] = [];
 140     operatorTypes: any[];
 141     capabilities: string = ToscaFilterConstraintType.CAPABILITIES;
 142     properties: string = ToscaFilterConstraintType.PROPERTIES;
 143     private componentInstancesConstraints: ConstraintObject[] = [];
 144     isEditable: boolean;
 145
 146     @Input() readonly: boolean;
 147     @Input() compositeService: ComponentMetadata;
 148     @Input() currentServiceInstance: ComponentInstance;
 149     @Input() selectedInstanceSiblings: ServiceInstanceObject[];
 150     @Input() selectedInstanceConstraints: ConstraintObject[] = [];
 151     @Input() selectedInstanceProperties: PropertyBEModel[] = [];
 152     @Output() updateRulesListEvent: EventEmitter<ConstraintObject[]> = new EventEmitter<ConstraintObject[]>();
 153     @Output() updateNodeFilterProperties: EventEmitter<ConstraintObject[]> = new EventEmitter<ConstraintObject[]>();
 154     @Output() updateNodeFilterCapabilities: EventEmitter<CapabilitiesConstraintObject[]> = new EventEmitter<CapabilitiesConstraintObject[]>();
 155     @Output() loadRulesListEvent:EventEmitter<any> = new EventEmitter();
 156     @Output() dependencyStatus = new EventEmitter<boolean>();
 157
 158     @Input() componentInstanceCapabilitiesMap: Map<string, PropertyModel[]>;
 159
 160     constructor(private topologyTemplateService: TopologyTemplateService, private modalServiceNg2: ModalService, private translateService: TranslateService) {
 161     }
 162
 163     ngOnInit() {
 164         this.isLoading = false;
 165         this.operatorTypes = [
 166             {label: '>', value: OPERATOR_TYPES.GREATER_THAN},
 167             {label: '<', value: OPERATOR_TYPES.LESS_THAN},
 168             {label: '=', value: OPERATOR_TYPES.EQUAL}
 169         ];
 170         this.topologyTemplateService.getComponentInputsWithProperties(this.compositeService.componentType, this.compositeService.uniqueId)
 171         .subscribe((result: ComponentGenericResponse) => {
 172             this.parentServiceInputs = result.inputs;
 173             this.parentServiceProperties = result.properties;
 174         });
 175         this.loadNodeFilter();
 176         this.translateService.languageChangedObservable.subscribe((lang) => {
 177             I18nTexts.translateTexts(this.translateService);
 178         });
 179     }
 180
 181     ngOnChanges(changes) {
 182         if (changes.currentServiceInstance) {
 183             this.currentServiceInstance = changes.currentServiceInstance.currentValue;
 184             this.isDependent = this.currentServiceInstance.isDependent();
 185         }
 186         if (changes.selectedInstanceConstraints && changes.selectedInstanceConstraints.currentValue !== changes.selectedInstanceConstraints.previousValue) {
 187             this.selectedInstanceConstraints = changes.selectedInstanceConstraints.currentValue;
 188             this.loadNodeFilter();
 189         }
 190     }
 191
 192     private getActualDirectiveValue = (): string[] => {
 193         return this.currentServiceInstance.directives.length > 0 ? this.currentServiceInstance.directives : [];
 194     }
 195
 196     public openRemoveDependencyModal = (): ComponentRef<ModalComponent> => {
 197         const actionButton: ButtonModel = new ButtonModel(I18nTexts.modalApprove, 'blue', this.onUncheckDependency);
 198         const cancelButton: ButtonModel = new ButtonModel(I18nTexts.modalCancel, 'grey', this.onCloseRemoveDependencyModal);
 199         const modalModel: ModalModel = new ModalModel('sm', I18nTexts.removeDirectiveModalTitle,
 200             I18nTexts.removeDirectiveModalText, [actionButton, cancelButton]);
 201         this.loadNodeFilter();
 202         return this.modalServiceNg2.createCustomModal(modalModel);
 203     }
 204
 205     public openUpdateDependencyModal = (): ComponentRef<ModalComponent> => {
 206         const actionButton: ButtonModel = new ButtonModel(I18nTexts.modalApprove, 'blue', this.onUncheckDependency);
 207         const cancelButton: ButtonModel = new ButtonModel(I18nTexts.modalCancel, 'grey', this.onCloseRemoveDependencyModal);
 208         const modalModel: ModalModel = new ModalModel('sm', I18nTexts.updateDirectiveModalTitle,
 209             I18nTexts.updateDirectiveModalText, [actionButton, cancelButton]);
 210         return this.modalServiceNg2.createCustomModal(modalModel);
 211     }
 212
 213     private loadNodeFilter = (): void => {
 214         this.topologyTemplateService.getServiceFilterConstraints(this.compositeService.componentType, this.compositeService.uniqueId).subscribe((response) => {
 215             if (response.nodeFilterforNode && response.nodeFilterforNode[this.currentServiceInstance.uniqueId]) {
 216                 this.componentInstancesConstraints = response.nodeFilterforNode;
 217                 const nodeFilterPropertiesResponse: ConstraintObject[] = response.nodeFilterforNode[this.currentServiceInstance.uniqueId].properties;
 218                 this.constraintProperties = nodeFilterPropertiesResponse;
 219                 const nodeFilterCapabilitiesResponse: CapabilitiesConstraintObject[] = response.nodeFilterforNode[this.currentServiceInstance.uniqueId].capabilities;
 220                 this.constraintCapabilities = nodeFilterCapabilitiesResponse;
 221             }
 222         });
 223     }
 224
 225     onUncheckDependency = () => {
 226         this.modalServiceNg2.closeCurrentModal();
 227         this.isLoading = true;
 228         const isDepOrig = this.isDependent;
 229         const rulesListOrig = this.componentInstancesConstraints;
 230         this.currentServiceInstance.unmarkAsDependent(this.getActualDirectiveValue());
 231         this.updateComponentInstance(isDepOrig, rulesListOrig);
 232     }
 233
 234     onCloseRemoveDependencyModal = () => {
 235         this.isDependent = true;
 236         this.modalServiceNg2.closeCurrentModal();
 237     }
 238
 239     onAddDirectives(directives: string[]) {
 240         this.isEditable = false;
 241         this.setDirectiveValue(directives);
 242         const rulesListOrig = this.componentInstancesConstraints;
 243         this.constraintProperties = [];
 244         this.constraintCapabilities = [];
 245         this.updateComponentInstance(this.isDependent, rulesListOrig);
 246     }
 247
 248     private onRemoveDirective() {
 249         this.openRemoveDependencyModal().instance.open();
 250         this.constraintProperties = [];
 251         this.constraintCapabilities = [];
 252     }
 253
 254     private onEditDirectives() {
 255         this.isEditable = true;
 256     }
 257
 258     private setDirectiveValue(newDirectiveValues: string[]) {
 259         this.currentServiceInstance.setDirectiveValue(newDirectiveValues);
 260     }
 261
 262     updateComponentInstance(isDependentOrigVal: boolean, rulesListOrig: ConstraintObject[]) {
 263         this.isLoading = true;
 264         this.topologyTemplateService.updateComponentInstance(this.compositeService.uniqueId,
 265                                                              this.compositeService.componentType,
 266                                                              this.currentServiceInstance)
 267                                                              .subscribe((updatedServiceIns: ComponentInstance) => {
 268             this.currentServiceInstance = new ComponentInstance(updatedServiceIns);
 269             this.isDependent = this.currentServiceInstance.isDependent();
 270             this.dependencyStatus.emit(this.isDependent);
 271             if (this.isDependent) {
 272                 this.loadRulesListEvent.emit();
 273             }
 274             this.isLoading = false;
 275         }, (err) => {
 276             this.isDependent = isDependentOrigVal;
 277             this.componentInstancesConstraints = rulesListOrig;
 278             this.isLoading = false;
 279             console.log('An error has occurred.');
 280         });
 281     }
 282
 283     onAddNodeFilter = () => {
 284         if (!this.selectedInstanceProperties) {
 285             this.modalServiceNg2.openAlertModal(I18nTexts.validateNodePropertiesTxt, I18nTexts.validateNodePropertiesMsg);
 286         } else {
 287             const cancelButton: ButtonModel = new ButtonModel(I18nTexts.modalCancel, 'outline white', this.modalServiceNg2.closeCurrentModal);
 288             const saveButton: ButtonModel = new ButtonModel(I18nTexts.modalCreate, 'blue', () => this.createNodeFilter(this.properties), this.getDisabled);
 289             const modalModel: ModalModel = new ModalModel('l', I18nTexts.addNodeFilterTxt, '', [saveButton, cancelButton], 'standard');
 290             this.modalInstance = this.modalServiceNg2.createCustomModal(modalModel);
 291             this.modalServiceNg2.addDynamicContentToModal(
 292                 this.modalInstance,
 293                 ServiceDependenciesEditorComponent,
 294                 {
 295                     currentServiceName: this.currentServiceInstance.name,
 296                     operatorTypes: this.operatorTypes,
 297                     compositeServiceName: this.compositeService.name,
 298                     parentServiceInputs: this.parentServiceInputs,
 299                     parentServiceProperties: this.parentServiceProperties,
 300                     selectedInstanceProperties: this.selectedInstanceProperties,
 301                     selectedInstanceSiblings: this.selectedInstanceSiblings
 302                 }
 303             );
 304             this.modalInstance.instance.open();
 305         }
 306     }
 307
 308     onAddNodeFilterCapabilities = () => {
 309         if (this.componentInstanceCapabilitiesMap.size == 0) {
 310             this.modalServiceNg2.openAlertModal(I18nTexts.validateCapabilitiesTxt, I18nTexts.validateCapabilitiesMsg);
 311         } else {
 312             const cancelButton: ButtonModel = new ButtonModel(I18nTexts.modalCancel, 'outline white', this.modalServiceNg2.closeCurrentModal);
 313             const saveButton: ButtonModel = new ButtonModel(I18nTexts.modalCreate, 'blue', () => this.createNodeFilterCapabilities(this.capabilities), this.getDisabled);
 314             const modalModel: ModalModel = new ModalModel('l', I18nTexts.addNodeFilterTxt, '', [saveButton, cancelButton], 'standard');
 315             this.modalInstance = this.modalServiceNg2.createCustomModal(modalModel);
 316             this.modalServiceNg2.addDynamicContentToModal(
 317                 this.modalInstance,
 318                 CapabilitiesFilterPropertiesEditorComponent,
 319                 {
 320                     currentServiceName: this.currentServiceInstance.name,
 321                     operatorTypes: this.operatorTypes,
 322                     compositeServiceName: this.compositeService.name,
 323                     parentServiceInputs: this.parentServiceInputs,
 324                     selectedInstanceProperties: this.selectedInstanceProperties,
 325                     selectedInstanceSiblings: this.selectedInstanceSiblings,
 326                     componentInstanceCapabilitiesMap: this.componentInstanceCapabilitiesMap
 327                 }
 328             );
 329             this.modalInstance.instance.open();
 330         }
 331     }
 332
 333     createNodeFilter = (constraintType: string) => {
 334         this.isLoading = true;
 335         this.topologyTemplateService.createServiceFilterConstraints(
 336             this.compositeService.uniqueId,
 337             this.currentServiceInstance.uniqueId,
 338             new ConstraintObject(this.modalInstance.instance.dynamicContent.instance.currentRule),
 339             this.compositeService.componentType,
 340             constraintType
 341         ).subscribe( (response) => {
 342             this.emitEventOnChanges(constraintType, response);
 343             this.isLoading = false;
 344         }, (err) => {
 345             this.isLoading = false;
 346         });
 347         this.modalServiceNg2.closeCurrentModal();
 348     }
 349
 350     createNodeFilterCapabilities = (constraintType: string) => {
 351         this.isLoading = true;
 352         this.topologyTemplateService.createServiceFilterCapabilitiesConstraints(
 353             this.compositeService.uniqueId,
 354             this.currentServiceInstance.uniqueId,
 355             new CapabilitiesConstraintObject(this.modalInstance.instance.dynamicContent.instance.currentRule),
 356             this.compositeService.componentType,
 357             constraintType
 358         ).subscribe( (response) => {
 359             this.emitEventOnChanges(constraintType, response);
 360             this.isLoading = false;
 361         }, (err) => {
 362             this.isLoading = false;
 363         });
 364         this.modalServiceNg2.closeCurrentModal();
 365     }
 366
 367     onSelectNodeFilterCapability(constraintType: string, index: number) {
 368         const cancelButton: ButtonModel = new ButtonModel(I18nTexts.modalCancel, 'outline white', this.modalServiceNg2.closeCurrentModal);
 369         const saveButton: ButtonModel = new ButtonModel(I18nTexts.modalSave, 'blue', () => this.updateNodeFilterCapability(constraintType, index), this.getDisabled);
 370         const modalModel: ModalModel = new ModalModel('l', I18nTexts.updateNodeFilterTxt, '', [saveButton, cancelButton], 'standard');
 371         this.modalInstance = this.modalServiceNg2.createCustomModal(modalModel);
 372
 373         this.modalServiceNg2.addDynamicContentToModal(
 374             this.modalInstance,
 375             CapabilitiesFilterPropertiesEditorComponent,
 376             {
 377                 serviceRuleIndex: index,
 378                 serviceRules: _.map(this.constraintCapabilities, (rule) => new CapabilitiesConstraintObject(rule)),
 379                 currentServiceName: this.currentServiceInstance.name,
 380                 operatorTypes: this.operatorTypes,
 381                 compositeServiceName: this.compositeService.name,
 382                 parentServiceInputs: this.parentServiceInputs,
 383                 selectedInstanceProperties: this.selectedInstanceProperties,
 384                 selectedInstanceSiblings: this.selectedInstanceSiblings,
 385                 componentInstanceCapabilitiesMap: this.componentInstanceCapabilitiesMap
 386             }
 387         );
 388         this.modalInstance.instance.open();
 389     }
 390
 391     onSelectNodeFilter(constraintType: string, index: number) {
 392         const cancelButton: ButtonModel = new ButtonModel(I18nTexts.modalCancel, 'outline white', this.modalServiceNg2.closeCurrentModal);
 393         const saveButton: ButtonModel = new ButtonModel(I18nTexts.modalSave, 'blue', () => this.updateNodeFilter(constraintType, index), this.getDisabled);
 394         const modalModel: ModalModel = new ModalModel('l', I18nTexts.updateNodeFilterTxt, '', [saveButton, cancelButton], 'standard');
 395         this.modalInstance = this.modalServiceNg2.createCustomModal(modalModel);
 396         this.modalServiceNg2.addDynamicContentToModal(
 397             this.modalInstance,
 398             ServiceDependenciesEditorComponent,
 399             {
 400                 serviceRuleIndex: index,
 401                 serviceRules: _.map(this.constraintProperties, (rule) => new ConstraintObjectUI(rule)),
 402                 currentServiceName: this.currentServiceInstance.name,
 403                 operatorTypes: this.operatorTypes,
 404                 compositeServiceName: this.compositeService.name,
 405                 parentServiceInputs: this.parentServiceInputs,
 406                 parentServiceProperties: this.parentServiceProperties,
 407                 selectedInstanceProperties: this.selectedInstanceProperties,
 408                 selectedInstanceSiblings: this.selectedInstanceSiblings
 409             }
 410         );
 411         this.modalInstance.instance.open();
 412     }
 413
 414     getDisabled = (): boolean =>  {
 415         return !this.modalInstance.instance.dynamicContent.instance.checkFormValidForSubmit();
 416     }
 417
 418     updateNodeFilter = (constraintType: string, index: number) => {
 419         this.isLoading = true;
 420         this.topologyTemplateService.updateServiceFilterConstraints(
 421             this.compositeService.uniqueId,
 422             this.currentServiceInstance.uniqueId,
 423             new ConstraintObject(this.modalInstance.instance.dynamicContent.instance.currentRule),
 424             this.compositeService.componentType,
 425             constraintType,
 426             index
 427         ).subscribe((response) => {
 428             this.emitEventOnChanges(constraintType, response);
 429             this.isLoading = false;
 430         }, (err) => {
 431             this.isLoading = false;
 432         });
 433         this.modalServiceNg2.closeCurrentModal();
 434     }
 435
 436     updateNodeFilterCapability= (constraintType: string, index: number) => {
 437         this.isLoading = true;
 438         this.topologyTemplateService.updateServiceFilterCapabilitiesConstraint(
 439             this.compositeService.uniqueId,
 440             this.currentServiceInstance.uniqueId,
 441             new CapabilitiesConstraintObject(this.modalInstance.instance.dynamicContent.instance.currentRule),
 442             this.compositeService.componentType,
 443             constraintType,
 444             index
 445         ).subscribe((response) => {
 446             this.emitEventOnChanges(constraintType, response);
 447             this.isLoading = false;
 448         }, (err) => {
 449             this.isLoading = false;
 450         });
 451         this.modalServiceNg2.closeCurrentModal();
 452     }
 453
 454     getSymbol(constraintOperator) {
 455         switch (constraintOperator) {
 456             case OPERATOR_TYPES.LESS_THAN: return '<';
 457             case OPERATOR_TYPES.EQUAL: return '=';
 458             case OPERATOR_TYPES.GREATER_THAN: return '>';
 459         }
 460     }
 461
 462     onDeleteNodeFilter = (constraintType: string, index: number) => {
 463         this.isLoading = true;
 464         this.topologyTemplateService.deleteServiceFilterConstraints(
 465             this.compositeService.uniqueId,
 466             this.currentServiceInstance.uniqueId,
 467             index,
 468             this.compositeService.componentType,
 469             constraintType
 470         ).subscribe( (response) => {
 471             this.emitEventOnChanges(constraintType, response);
 472             this.isLoading = false;
 473         }, (err) => {
 474             this.isLoading = false;
 475         });
 476         this.modalServiceNg2.closeCurrentModal();
 477     }
 478
 479     private emitEventOnChanges(constraintType: string, response) {
 480         if (this.properties === constraintType) {
 481             this.updateNodeFilterProperties.emit(response.properties);
 482             this.constraintProperties = response.properties;
 483         } else {
 484             this.updateNodeFilterCapabilities.emit(response.capabilities);
 485             this.constraintCapabilities = response.capabilities;
 486         }
 487     }
 488
 489     openDeleteModal = (constraintType: string, index: number) => {
 490         this.modalServiceNg2.createActionModal(I18nTexts.deleteNodeFilterTxt, I18nTexts.deleteNodeFilterMsg,
 491             I18nTexts.modalDelete, () => this.onDeleteNodeFilter(constraintType, index), I18nTexts.modalCancel).instance.open();
 492     }
 493
 494 }