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 { CapabilitiesConstraintObjectUI} 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     GREATER_OR_EQUAL: 'greater_or_equal',
  82     LESS_OR_EQUAL: 'less_or_equal'
  83 };
  84
  85 // tslint:disable-next-line:max-classes-per-file
  86 class I18nTexts {
  87     static removeDirectiveModalTitle: string;
  88     static removeDirectiveModalText: string;
  89     static updateDirectiveModalTitle: string;
  90     static updateDirectiveModalText: string;
  91     static modalApprove: string;
  92     static modalCancel: string;
  93     static modalCreate: string;
  94     static modalSave: string;
  95     static modalDelete: string;
  96     static addNodeFilterTxt: string;
  97     static updateNodeFilterTxt: string;
  98     static deleteNodeFilterTxt: string;
  99     static deleteNodeFilterMsg: string;
 100     static validateCapabilitiesTxt: string
 101     static validateCapabilitiesMsg: string
 102     static validateNodePropertiesTxt: string
 103     static validateNodePropertiesMsg: string
 104
 105     public static translateTexts(translateService) {
 106             I18nTexts.removeDirectiveModalTitle = translateService.translate('DIRECTIVES_AND_NODE_FILTER_REMOVE_TITLE');
 107             I18nTexts.removeDirectiveModalText = translateService.translate('DIRECTIVES_AND_NODE_FILTER_REMOVE_TEXT');
 108             I18nTexts.updateDirectiveModalTitle = translateService.translate('DIRECTIVES_AND_NODE_FILTER_UPDATE_TITLE');
 109             I18nTexts.updateDirectiveModalText = translateService.translate('DIRECTIVES_AND_NODE_FILTER_UPDATE_TEXT');
 110             I18nTexts.modalApprove = translateService.translate('MODAL_APPROVE');
 111             I18nTexts.modalCancel = translateService.translate('MODAL_CANCEL');
 112             I18nTexts.modalCreate = translateService.translate('MODAL_CREATE');
 113             I18nTexts.modalSave = translateService.translate('MODAL_SAVE');
 114             I18nTexts.modalDelete = translateService.translate('MODAL_DELETE');
 115             I18nTexts.addNodeFilterTxt = translateService.translate('DIRECTIVES_AND_NODE_FILTER_ADD_NODE_FILTER');
 116             I18nTexts.updateNodeFilterTxt = translateService.translate('DIRECTIVES_AND_NODE_FILTER_UPDATE_NODE_FILTER');
 117             I18nTexts.deleteNodeFilterTxt = translateService.translate('DIRECTIVES_AND_NODE_FILTER_DELETE_NODE_FILTER');
 118             I18nTexts.deleteNodeFilterMsg = translateService.translate('DIRECTIVES_AND_NODE_FILTER_DELETE_NODE_FILTER_MSG');
 119             I18nTexts.validateCapabilitiesTxt = translateService.translate('VALIDATE_CAPABILITIES_TXT');
 120             I18nTexts.validateCapabilitiesMsg = translateService.translate('VALIDATE_CAPABILITIES_MSG');
 121             I18nTexts.validateNodePropertiesTxt = translateService.translate('VALIDATE_NODE_PROPERTIES_TXT');
 122             I18nTexts.validateNodePropertiesMsg = translateService.translate('VALIDATE_NODE_PROPERTIES_MSG');
 123     }
 124 }
 125
 126 // tslint:disable-next-line:max-classes-per-file
 127 @Component({
 128     selector: 'service-dependencies',
 129     templateUrl: './service-dependencies.component.html',
 130     styleUrls: ['service-dependencies.component.less'],
 131     providers: [ModalService, TranslateService]
 132 })
 133
 134 export class ServiceDependenciesComponent {
 135     modalInstance: ComponentRef<ModalComponent>;
 136     isDependent: boolean;
 137     isLoading: boolean;
 138     parentServiceInputs: InputBEModel[] = [];
 139     parentServiceProperties: PropertyBEModel[] = [];
 140     constraintProperties: ConstraintObject[] = [];
 141     constraintCapabilities: CapabilitiesConstraintObjectUI[] = [];
 142     operatorTypes: any[];
 143     capabilities: string = ToscaFilterConstraintType.CAPABILITIES;
 144     properties: string = ToscaFilterConstraintType.PROPERTIES;
 145     private componentInstancesConstraints: ConstraintObject[] = [];
 146     isEditable: boolean;
 147
 148     @Input() readonly: boolean;
 149     @Input() compositeService: ComponentMetadata;
 150     @Input() currentServiceInstance: ComponentInstance;
 151     @Input() selectedInstanceSiblings: ServiceInstanceObject[];
 152     @Input() selectedInstanceConstraints: ConstraintObject[] = [];
 153     @Input() selectedInstanceProperties: PropertyBEModel[] = [];
 154     @Output() updateRulesListEvent: EventEmitter<ConstraintObject[]> = new EventEmitter<ConstraintObject[]>();
 155     @Output() updateNodeFilterProperties: EventEmitter<ConstraintObject[]> = new EventEmitter<ConstraintObject[]>();
 156     @Output() updateNodeFilterCapabilities: EventEmitter<CapabilitiesConstraintObjectUI[]> = new EventEmitter<CapabilitiesConstraintObjectUI[]>();
 157     @Output() loadRulesListEvent:EventEmitter<any> = new EventEmitter();
 158     @Output() dependencyStatus = new EventEmitter<boolean>();
 159
 160     @Input() componentInstanceCapabilitiesMap: Map<string, PropertyModel[]>;
 161
 162     constructor(private topologyTemplateService: TopologyTemplateService, private modalServiceNg2: ModalService, private translateService: TranslateService) {
 163     }
 164
 165     ngOnInit() {
 166         this.isLoading = false;
 167         this.operatorTypes = [
 168             {label: '>', value: OPERATOR_TYPES.GREATER_THAN},
 169             {label: '<', value: OPERATOR_TYPES.LESS_THAN},
 170             {label: '=', value: OPERATOR_TYPES.EQUAL},
 171             {label: '>=', value: OPERATOR_TYPES.GREATER_OR_EQUAL},
 172             {label: '<=', value: OPERATOR_TYPES.LESS_OR_EQUAL}
 173         ];
 174         this.topologyTemplateService.getComponentInputsWithProperties(this.compositeService.componentType, this.compositeService.uniqueId)
 175         .subscribe((result: ComponentGenericResponse) => {
 176             this.parentServiceInputs = result.inputs;
 177             this.parentServiceProperties = result.properties;
 178         });
 179         this.loadNodeFilter();
 180         this.translateService.languageChangedObservable.subscribe((lang) => {
 181             I18nTexts.translateTexts(this.translateService);
 182         });
 183     }
 184
 185     ngOnChanges(changes) {
 186         if (changes.currentServiceInstance) {
 187             this.currentServiceInstance = changes.currentServiceInstance.currentValue;
 188             this.isDependent = this.currentServiceInstance.isDependent();
 189         }
 190         if (changes.selectedInstanceConstraints && changes.selectedInstanceConstraints.currentValue !== changes.selectedInstanceConstraints.previousValue) {
 191             this.selectedInstanceConstraints = changes.selectedInstanceConstraints.currentValue;
 192             this.loadNodeFilter();
 193         }
 194     }
 195
 196     private getActualDirectiveValue = (): string[] => {
 197         return this.currentServiceInstance.directives.length > 0 ? this.currentServiceInstance.directives : [];
 198     }
 199
 200     public openRemoveDependencyModal = (): ComponentRef<ModalComponent> => {
 201         const actionButton: ButtonModel = new ButtonModel(I18nTexts.modalApprove, 'blue', this.onUncheckDependency);
 202         const cancelButton: ButtonModel = new ButtonModel(I18nTexts.modalCancel, 'grey', this.onCloseRemoveDependencyModal);
 203         const modalModel: ModalModel = new ModalModel('sm', I18nTexts.removeDirectiveModalTitle,
 204             I18nTexts.removeDirectiveModalText, [actionButton, cancelButton]);
 205         this.loadNodeFilter();
 206         return this.modalServiceNg2.createCustomModal(modalModel);
 207     }
 208
 209     public openUpdateDependencyModal = (): ComponentRef<ModalComponent> => {
 210         const actionButton: ButtonModel = new ButtonModel(I18nTexts.modalApprove, 'blue', this.onUncheckDependency);
 211         const cancelButton: ButtonModel = new ButtonModel(I18nTexts.modalCancel, 'grey', this.onCloseRemoveDependencyModal);
 212         const modalModel: ModalModel = new ModalModel('sm', I18nTexts.updateDirectiveModalTitle,
 213             I18nTexts.updateDirectiveModalText, [actionButton, cancelButton]);
 214         return this.modalServiceNg2.createCustomModal(modalModel);
 215     }
 216
 217     private loadNodeFilter = (): void => {
 218         this.topologyTemplateService.getServiceFilterConstraints(this.compositeService.componentType, this.compositeService.uniqueId).subscribe((response) => {
 219             if (response.nodeFilterforNode && response.nodeFilterforNode[this.currentServiceInstance.uniqueId]) {
 220                 this.componentInstancesConstraints = response.nodeFilterforNode;
 221                 const nodeFilterPropertiesResponse: ConstraintObject[] = response.nodeFilterforNode[this.currentServiceInstance.uniqueId].properties;
 222                 this.constraintProperties = nodeFilterPropertiesResponse;
 223                 const nodeFilterCapabilitiesResponse: CapabilitiesConstraintObjectUI[] = response.nodeFilterforNode[this.currentServiceInstance.uniqueId].capabilities;
 224                 this.constraintCapabilities = nodeFilterCapabilitiesResponse;
 225             }
 226         });
 227     }
 228
 229     onUncheckDependency = () => {
 230         this.modalServiceNg2.closeCurrentModal();
 231         this.isLoading = true;
 232         const isDepOrig = this.isDependent;
 233         const rulesListOrig = this.componentInstancesConstraints;
 234         this.currentServiceInstance.unmarkAsDependent(this.getActualDirectiveValue());
 235         this.updateComponentInstance(isDepOrig, rulesListOrig);
 236     }
 237
 238     onCloseRemoveDependencyModal = () => {
 239         this.isDependent = true;
 240         this.modalServiceNg2.closeCurrentModal();
 241     }
 242
 243     onAddDirectives(directives: string[]) {
 244         this.isEditable = false;
 245         this.setDirectiveValue(directives);
 246         const rulesListOrig = this.componentInstancesConstraints;
 247         this.constraintProperties = [];
 248         this.constraintCapabilities = [];
 249         this.loadNodeFilter();
 250         this.updateComponentInstance(this.isDependent, rulesListOrig);
 251     }
 252
 253     private onRemoveDirective() {
 254         this.openRemoveDependencyModal().instance.open();
 255         this.constraintProperties = [];
 256         this.constraintCapabilities = [];
 257     }
 258
 259     private onEditDirectives() {
 260         this.isEditable = true;
 261     }
 262
 263     private setDirectiveValue(newDirectiveValues: string[]) {
 264         this.currentServiceInstance.setDirectiveValue(newDirectiveValues);
 265     }
 266
 267     updateComponentInstance(isDependentOrigVal: boolean, rulesListOrig: ConstraintObject[]) {
 268         this.isLoading = true;
 269         this.topologyTemplateService.updateComponentInstance(this.compositeService.uniqueId,
 270                                                              this.compositeService.componentType,
 271                                                              this.currentServiceInstance)
 272                                                              .subscribe((updatedServiceIns: ComponentInstance) => {
 273             this.currentServiceInstance = new ComponentInstance(updatedServiceIns);
 274             this.isDependent = this.currentServiceInstance.isDependent();
 275             this.dependencyStatus.emit(this.isDependent);
 276             if (this.isDependent) {
 277                 this.loadRulesListEvent.emit();
 278             }
 279             this.isLoading = false;
 280         }, (err) => {
 281             this.isDependent = isDependentOrigVal;
 282             this.componentInstancesConstraints = rulesListOrig;
 283             this.isLoading = false;
 284             console.log('An error has occurred.');
 285         });
 286     }
 287
 288     onAddNodeFilter = () => {
 289         if (!this.selectedInstanceProperties) {
 290             this.modalServiceNg2.openAlertModal(I18nTexts.validateNodePropertiesTxt, I18nTexts.validateNodePropertiesMsg);
 291         } else {
 292             const cancelButton: ButtonModel = new ButtonModel(I18nTexts.modalCancel, 'outline white', this.modalServiceNg2.closeCurrentModal);
 293             const saveButton: ButtonModel = new ButtonModel(I18nTexts.modalCreate, 'blue', () => this.createNodeFilter(this.properties), this.getDisabled);
 294             const modalModel: ModalModel = new ModalModel('l', I18nTexts.addNodeFilterTxt, '', [saveButton, cancelButton], 'standard');
 295             this.modalInstance = this.modalServiceNg2.createCustomModal(modalModel);
 296             this.modalServiceNg2.addDynamicContentToModal(
 297                 this.modalInstance,
 298                 ServiceDependenciesEditorComponent,
 299                 {
 300                     currentServiceName: this.currentServiceInstance.name,
 301                     operatorTypes: this.operatorTypes,
 302                     compositeServiceName: this.compositeService.name,
 303                     parentServiceInputs: this.parentServiceInputs,
 304                     parentServiceProperties: this.parentServiceProperties,
 305                     selectedInstanceProperties: this.selectedInstanceProperties,
 306                     selectedInstanceSiblings: this.selectedInstanceSiblings
 307                 }
 308             );
 309             this.modalInstance.instance.open();
 310         }
 311     }
 312
 313     onAddNodeFilterCapabilities = () => {
 314         if (this.componentInstanceCapabilitiesMap.size == 0) {
 315             this.modalServiceNg2.openAlertModal(I18nTexts.validateCapabilitiesTxt, I18nTexts.validateCapabilitiesMsg);
 316         } else {
 317             const cancelButton: ButtonModel = new ButtonModel(I18nTexts.modalCancel, 'outline white', this.modalServiceNg2.closeCurrentModal);
 318             const saveButton: ButtonModel = new ButtonModel(I18nTexts.modalCreate, 'blue', () => this.createNodeFilterCapabilities(this.capabilities), this.getDisabled);
 319             const modalModel: ModalModel = new ModalModel('l', I18nTexts.addNodeFilterTxt, '', [saveButton, cancelButton], 'standard');
 320             this.modalInstance = this.modalServiceNg2.createCustomModal(modalModel);
 321             this.modalServiceNg2.addDynamicContentToModal(
 322                 this.modalInstance,
 323                 CapabilitiesFilterPropertiesEditorComponent,
 324                 {
 325                     currentServiceName: this.currentServiceInstance.name,
 326                     operatorTypes: this.operatorTypes,
 327                     compositeServiceName: this.compositeService.name,
 328                     parentServiceInputs: this.parentServiceInputs,
 329                     selectedInstanceProperties: this.selectedInstanceProperties,
 330                     selectedInstanceSiblings: this.selectedInstanceSiblings,
 331                     componentInstanceCapabilitiesMap: this.componentInstanceCapabilitiesMap
 332                 }
 333             );
 334             this.modalInstance.instance.open();
 335         }
 336     }
 337
 338     createNodeFilter = (constraintType: string) => {
 339         this.isLoading = true;
 340         this.topologyTemplateService.createServiceFilterConstraints(
 341             this.compositeService.uniqueId,
 342             this.currentServiceInstance.uniqueId,
 343             new ConstraintObject(this.modalInstance.instance.dynamicContent.instance.currentRule),
 344             this.compositeService.componentType,
 345             constraintType
 346         ).subscribe( (response) => {
 347             this.emitEventOnChanges(constraintType, response);
 348             this.isLoading = false;
 349         }, (err) => {
 350             this.isLoading = false;
 351         });
 352         this.modalServiceNg2.closeCurrentModal();
 353     }
 354
 355     createNodeFilterCapabilities = (constraintType: string) => {
 356         this.isLoading = true;
 357         this.topologyTemplateService.createServiceFilterCapabilitiesConstraints(
 358             this.compositeService.uniqueId,
 359             this.currentServiceInstance.uniqueId,
 360             new CapabilitiesConstraintObjectUI(this.modalInstance.instance.dynamicContent.instance.currentRule),
 361             this.compositeService.componentType,
 362             constraintType
 363         ).subscribe( (response) => {
 364             this.emitEventOnChanges(constraintType, response);
 365             this.isLoading = false;
 366         }, (err) => {
 367             this.isLoading = false;
 368         });
 369         this.modalServiceNg2.closeCurrentModal();
 370     }
 371
 372     onSelectNodeFilterCapability(constraintType: string, index: number) {
 373         const cancelButton: ButtonModel = new ButtonModel(I18nTexts.modalCancel, 'outline white', this.modalServiceNg2.closeCurrentModal);
 374         const saveButton: ButtonModel = new ButtonModel(I18nTexts.modalSave, 'blue', () => this.updateNodeFilterCapability(constraintType, index), this.getDisabled);
 375         const modalModel: ModalModel = new ModalModel('l', I18nTexts.updateNodeFilterTxt, '', [saveButton, cancelButton], 'standard');
 376         this.modalInstance = this.modalServiceNg2.createCustomModal(modalModel);
 377
 378         this.modalServiceNg2.addDynamicContentToModal(
 379             this.modalInstance,
 380             CapabilitiesFilterPropertiesEditorComponent,
 381             {
 382                 serviceRuleIndex: index,
 383                 serviceRules: _.map(this.constraintCapabilities, (rule) => new CapabilitiesConstraintObjectUI(rule)),
 384                 currentServiceName: this.currentServiceInstance.name,
 385                 operatorTypes: this.operatorTypes,
 386                 compositeServiceName: this.compositeService.name,
 387                 parentServiceInputs: this.parentServiceInputs,
 388                 selectedInstanceProperties: this.selectedInstanceProperties,
 389                 selectedInstanceSiblings: this.selectedInstanceSiblings,
 390                 componentInstanceCapabilitiesMap: this.componentInstanceCapabilitiesMap
 391             }
 392         );
 393         this.modalInstance.instance.open();
 394     }
 395
 396     onSelectNodeFilter(constraintType: string, index: number) {
 397         const cancelButton: ButtonModel = new ButtonModel(I18nTexts.modalCancel, 'outline white', this.modalServiceNg2.closeCurrentModal);
 398         const saveButton: ButtonModel = new ButtonModel(I18nTexts.modalSave, 'blue', () => this.updateNodeFilter(constraintType, index), this.getDisabled);
 399         const modalModel: ModalModel = new ModalModel('l', I18nTexts.updateNodeFilterTxt, '', [saveButton, cancelButton], 'standard');
 400         this.modalInstance = this.modalServiceNg2.createCustomModal(modalModel);
 401         this.modalServiceNg2.addDynamicContentToModal(
 402             this.modalInstance,
 403             ServiceDependenciesEditorComponent,
 404             {
 405                 serviceRuleIndex: index,
 406                 serviceRules: _.map(this.constraintProperties, (rule) => new ConstraintObjectUI(rule)),
 407                 currentServiceName: this.currentServiceInstance.name,
 408                 operatorTypes: this.operatorTypes,
 409                 compositeServiceName: this.compositeService.name,
 410                 parentServiceInputs: this.parentServiceInputs,
 411                 parentServiceProperties: this.parentServiceProperties,
 412                 selectedInstanceProperties: this.selectedInstanceProperties,
 413                 selectedInstanceSiblings: this.selectedInstanceSiblings
 414             }
 415         );
 416         this.modalInstance.instance.open();
 417     }
 418
 419     getDisabled = (): boolean =>  {
 420         return !this.modalInstance.instance.dynamicContent.instance.checkFormValidForSubmit();
 421     }
 422
 423     updateNodeFilter = (constraintType: string, index: number) => {
 424         this.isLoading = true;
 425         this.topologyTemplateService.updateServiceFilterConstraints(
 426             this.compositeService.uniqueId,
 427             this.currentServiceInstance.uniqueId,
 428             new ConstraintObject(this.modalInstance.instance.dynamicContent.instance.currentRule),
 429             this.compositeService.componentType,
 430             constraintType,
 431             index
 432         ).subscribe((response) => {
 433             this.emitEventOnChanges(constraintType, response);
 434             this.isLoading = false;
 435         }, (err) => {
 436             this.isLoading = false;
 437         });
 438         this.modalServiceNg2.closeCurrentModal();
 439     }
 440
 441     updateNodeFilterCapability= (constraintType: string, index: number) => {
 442         this.isLoading = true;
 443         this.topologyTemplateService.updateServiceFilterCapabilitiesConstraint(
 444             this.compositeService.uniqueId,
 445             this.currentServiceInstance.uniqueId,
 446             new CapabilitiesConstraintObjectUI(this.modalInstance.instance.dynamicContent.instance.currentRule),
 447             this.compositeService.componentType,
 448             constraintType,
 449             index
 450         ).subscribe((response) => {
 451             this.emitEventOnChanges(constraintType, response);
 452             this.isLoading = false;
 453         }, (err) => {
 454             this.isLoading = false;
 455         });
 456         this.modalServiceNg2.closeCurrentModal();
 457     }
 458
 459     getSymbol(constraintOperator) {
 460         switch (constraintOperator) {
 461             case OPERATOR_TYPES.LESS_THAN: return '<';
 462             case OPERATOR_TYPES.EQUAL: return '=';
 463             case OPERATOR_TYPES.GREATER_THAN: return '>';
 464             case OPERATOR_TYPES.GREATER_OR_EQUAL: return '>=';
 465             case OPERATOR_TYPES.LESS_OR_EQUAL: return '<=';
 466         }
 467     }
 468
 469     onDeleteNodeFilter = (constraintType: string, index: number) => {
 470         this.isLoading = true;
 471         this.topologyTemplateService.deleteServiceFilterConstraints(
 472             this.compositeService.uniqueId,
 473             this.currentServiceInstance.uniqueId,
 474             index,
 475             this.compositeService.componentType,
 476             constraintType
 477         ).subscribe( (response) => {
 478             this.emitEventOnChanges(constraintType, response);
 479             this.isLoading = false;
 480         }, (err) => {
 481             this.isLoading = false;
 482         });
 483         this.modalServiceNg2.closeCurrentModal();
 484     }
 485
 486     private emitEventOnChanges(constraintType: string, response) {
 487         if (this.properties === constraintType) {
 488             this.updateNodeFilterProperties.emit(response.properties);
 489             this.constraintProperties = response.properties;
 490         } else {
 491             this.updateNodeFilterCapabilities.emit(response.capabilities);
 492             this.constraintCapabilities = response.capabilities;
 493         }
 494     }
 495
 496     openDeleteModal = (constraintType: string, index: number) => {
 497         this.modalServiceNg2.createActionModal(I18nTexts.deleteNodeFilterTxt, I18nTexts.deleteNodeFilterMsg,
 498             I18nTexts.modalDelete, () => this.onDeleteNodeFilter(constraintType, index), I18nTexts.modalCancel).instance.open();
 499     }
 500
 501 }