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 } from 'app/models';
  24 import { ModalComponent } from 'app/ng2/components/ui/modal/modal.component';
  25 import { ServiceDependenciesEditorComponent } from 'app/ng2/pages/service-dependencies-editor/service-dependencies-editor.component';
  26 import { ModalService } from 'app/ng2/services/modal.service';
  27 import { ComponentGenericResponse } from 'app/ng2/services/responses/component-generic-response';
  28 import { TranslateService } from 'app/ng2/shared/translator/translate.service';
  29 import { ComponentMetadata } from '../../../../models/component-metadata';
  30 import { ServiceInstanceObject } from '../../../../models/service-instance-properties-and-interfaces';
  31 import { TopologyTemplateService } from '../../../services/component-services/topology-template.service';
  32 import {DirectivesEnum, DirectiveValue} from "./directive-option";
  33
  34 export class ConstraintObject {
  35     servicePropertyName: string;
  36     constraintOperator: string;
  37     sourceType: string;
  38     sourceName: string;
  39     value: string;
  40
  41     constructor(input?: any) {
  42         if (input) {
  43             this.servicePropertyName = input.servicePropertyName;
  44             this.constraintOperator = input.constraintOperator;
  45             this.sourceType = input.sourceType;
  46             this.sourceName = input.sourceName;
  47             this.value = input.value;
  48         }
  49     }
  50 }
  51
  52 // tslint:disable-next-line:max-classes-per-file
  53 export class ConstraintObjectUI extends ConstraintObject{
  54     isValidValue: boolean;
  55
  56     constructor(input?: any) {
  57         super(input);
  58         if (input) {
  59             this.isValidValue = input.isValidValue ? input.isValidValue : input.value !== '';
  60         }
  61     }
  62
  63     public updateValidity(isValidValue: boolean) {
  64         this.isValidValue = isValidValue;
  65     }
  66
  67     public isValidRule(isStatic) {
  68         const isValidValue = isStatic ? this.isValidValue : true;
  69         return this.servicePropertyName != null && this.servicePropertyName !== ''
  70             && this.value != null && this.value !== '' && isValidValue;
  71     }
  72 }
  73
  74 export const OPERATOR_TYPES = {
  75     EQUAL: 'equal',
  76     GREATER_THAN: 'greater_than',
  77     LESS_THAN: 'less_than'
  78 };
  79
  80 // tslint:disable-next-line:max-classes-per-file
  81 class I18nTexts {
  82     static removeDirectiveModalTitle: string;
  83     static removeDirectiveModalText: string;
  84     static updateDirectiveModalTitle: string;
  85     static updateDirectiveModalText: string;
  86     static modalApprove: string;
  87     static modalCancel: string;
  88     static modalCreate: string;
  89     static modalSave: string;
  90     static modalDelete: string;
  91     static addNodeFilterTxt: string;
  92     static updateNodeFilterTxt: string;
  93     static deleteNodeFilterTxt: string;
  94     static deleteNodeFilterMsg: string;
  95
  96     public static translateTexts(translateService) {
  97             I18nTexts.removeDirectiveModalTitle = translateService.translate('DIRECTIVES_AND_NODE_FILTER_REMOVE_TITLE');
  98             I18nTexts.removeDirectiveModalText = translateService.translate('DIRECTIVES_AND_NODE_FILTER_REMOVE_TEXT');
  99             I18nTexts.updateDirectiveModalTitle = translateService.translate('DIRECTIVES_AND_NODE_FILTER_UPDATE_TITLE');
 100             I18nTexts.updateDirectiveModalText = translateService.translate('DIRECTIVES_AND_NODE_FILTER_UPDATE_TEXT');
 101             I18nTexts.modalApprove = translateService.translate('MODAL_APPROVE');
 102             I18nTexts.modalCancel = translateService.translate('MODAL_CANCEL');
 103             I18nTexts.modalCreate = translateService.translate('MODAL_CREATE');
 104             I18nTexts.modalSave = translateService.translate('MODAL_SAVE');
 105             I18nTexts.modalDelete = translateService.translate('MODAL_DELETE');
 106             I18nTexts.addNodeFilterTxt = translateService.translate('DIRECTIVES_AND_NODE_FILTER_ADD_NODE_FILTER');
 107             I18nTexts.updateNodeFilterTxt = translateService.translate('DIRECTIVES_AND_NODE_FILTER_UPDATE_NODE_FILTER');
 108             I18nTexts.deleteNodeFilterTxt = translateService.translate('DIRECTIVES_AND_NODE_FILTER_DELETE_NODE_FILTER');
 109             I18nTexts.deleteNodeFilterMsg = translateService.translate('DIRECTIVES_AND_NODE_FILTER_DELETE_NODE_FILTER_MSG');
 110     }
 111 }
 112
 113 // tslint:disable-next-line:max-classes-per-file
 114 @Component({
 115     selector: 'service-dependencies',
 116     templateUrl: './service-dependencies.component.html',
 117     styleUrls: ['service-dependencies.component.less'],
 118     providers: [ModalService, TranslateService]
 119 })
 120
 121 export class ServiceDependenciesComponent {
 122     modalInstance: ComponentRef<ModalComponent>;
 123     isDependent: boolean;
 124     isLoading: boolean;
 125     parentServiceInputs: InputBEModel[] = [];
 126     rulesList: ConstraintObject[] = [];
 127     operatorTypes: any[];
 128
 129     @Input() readonly: boolean;
 130     @Input() compositeService: ComponentMetadata;
 131     @Input() currentServiceInstance: ComponentInstance;
 132     @Input() selectedInstanceSiblings: ServiceInstanceObject[];
 133     @Input() selectedInstanceConstraints: ConstraintObject[] = [];
 134     @Input() selectedInstanceProperties: PropertyBEModel[] = [];
 135     @Input() directiveValues: any = DirectiveValue;
 136     @Output() updateRulesListEvent: EventEmitter<ConstraintObject[]> = new EventEmitter<ConstraintObject[]>();
 137     @Output() loadRulesListEvent:EventEmitter<any> = new EventEmitter();
 138     @Output() dependencyStatus = new EventEmitter<boolean>();
 139
 140     constructor(private topologyTemplateService: TopologyTemplateService, private modalServiceNg2: ModalService, private translateService: TranslateService) {
 141     }
 142
 143     ngOnInit() {
 144         this.isLoading = false;
 145         this.operatorTypes = [
 146             {label: '>', value: OPERATOR_TYPES.GREATER_THAN},
 147             {label: '<', value: OPERATOR_TYPES.LESS_THAN},
 148             {label: '=', value: OPERATOR_TYPES.EQUAL}
 149         ];
 150         this.topologyTemplateService.getComponentInputsWithProperties(this.compositeService.componentType, this.compositeService.uniqueId).subscribe((result: ComponentGenericResponse) => {
 151             this.parentServiceInputs = result.inputs;
 152         });
 153         this.loadRules();
 154         this.translateService.languageChangedObservable.subscribe((lang) => {
 155             I18nTexts.translateTexts(this.translateService);
 156         });
 157     }
 158
 159     ngOnChanges(changes) {
 160         if (changes.currentServiceInstance) {
 161             this.currentServiceInstance = changes.currentServiceInstance.currentValue;
 162             this.isDependent = this.currentServiceInstance.isDependent();
 163         }
 164         if (changes.selectedInstanceConstraints && changes.selectedInstanceConstraints.currentValue !== changes.selectedInstanceConstraints.previousValue) {
 165             this.selectedInstanceConstraints = changes.selectedInstanceConstraints.currentValue;
 166             this.loadRules();
 167         }
 168     }
 169
 170     private getActualDirectiveValue = (): string => {
 171         return this.currentServiceInstance.directives.length > 0 ? this.currentServiceInstance.directives[0] : "";
 172     }
 173
 174     private isServiceProxy = (): boolean => {
 175         return this.currentServiceInstance.isServiceProxy();
 176     }
 177
 178     public openRemoveDependencyModal = (): ComponentRef<ModalComponent> => {
 179         const actionButton: ButtonModel = new ButtonModel(I18nTexts.modalApprove, 'blue', this.onUncheckDependency);
 180         const cancelButton: ButtonModel = new ButtonModel(I18nTexts.modalCancel, 'grey', this.onCloseRemoveDependencyModal);
 181         const modalModel: ModalModel = new ModalModel('sm', I18nTexts.removeDirectiveModalTitle,
 182             I18nTexts.removeDirectiveModalText, [actionButton, cancelButton]);
 183         return this.modalServiceNg2.createCustomModal(modalModel);
 184     }
 185
 186     public openUpdateDependencyModal = (): ComponentRef<ModalComponent> => {
 187         const actionButton: ButtonModel = new ButtonModel(I18nTexts.modalApprove, 'blue', this.onUncheckDependency);
 188         const cancelButton: ButtonModel = new ButtonModel(I18nTexts.modalCancel, 'grey', this.onCloseRemoveDependencyModal);
 189         const modalModel: ModalModel = new ModalModel('sm', I18nTexts.updateDirectiveModalTitle,
 190             I18nTexts.updateDirectiveModalText, [actionButton, cancelButton]);
 191         return this.modalServiceNg2.createCustomModal(modalModel);
 192     }
 193
 194     loadRules() {
 195         this.rulesList = this.selectedInstanceConstraints && this.selectedInstanceConstraints.map((co: ConstraintObject) => ({
 196                 servicePropertyName: co.servicePropertyName,
 197                 constraintOperator: co.constraintOperator,
 198                 sourceType: co.sourceType,
 199                 sourceName: co.sourceName !== 'SELF' ? co.sourceName : this.compositeService.name,
 200                 value: co.value,
 201             }));
 202     }
 203
 204     onUncheckDependency = () => {
 205         this.modalServiceNg2.closeCurrentModal();
 206         this.isLoading = true;
 207         const isDepOrig = this.isDependent;
 208         const rulesListOrig = this.rulesList;
 209         this.currentServiceInstance.unmarkAsDependent(this.getActualDirectiveValue());
 210         this.updateComponentInstance(isDepOrig, rulesListOrig);
 211     }
 212
 213     onCloseRemoveDependencyModal = () => {
 214         this.isDependent = true;
 215         this.modalServiceNg2.closeCurrentModal();
 216     }
 217
 218     onOptionsSelected(event: any) {
 219         const newDirectiveValue = event.target.value;
 220         if (newDirectiveValue.toLowerCase() !== this.getActualDirectiveValue()) {
 221             const rulesListOrig = this.rulesList;
 222             this.setDirectiveValue(newDirectiveValue);
 223             this.rulesList = [];
 224             this.updateComponentInstance(this.isDependent, rulesListOrig);
 225         }
 226     }
 227
 228     private onRemoveDirective() {
 229         this.openRemoveDependencyModal().instance.open();
 230         this.rulesList = [];
 231     }
 232
 233     private setDirectiveValue(newDirectiveValue: string) {
 234         if (this.isDependent) {
 235             this.openUpdateDependencyModal().instance.open();
 236         }
 237         if (DirectivesEnum.SELECT == newDirectiveValue.toLowerCase() ||
 238             DirectivesEnum.SELECTABLE == newDirectiveValue.toLowerCase()) {
 239             this.currentServiceInstance.markAsSelect();
 240         } else {
 241             this.currentServiceInstance.markAsSubstitute();
 242         }
 243     }
 244
 245     updateComponentInstance(isDependentOrigVal: boolean, rulesListOrig: ConstraintObject[]) {
 246         this.isLoading = true;
 247         this.topologyTemplateService.updateComponentInstance(this.compositeService.uniqueId,
 248                                                              this.compositeService.componentType,
 249                                                              this.currentServiceInstance)
 250                                                              .subscribe((updatedServiceIns: ComponentInstance) => {
 251             this.currentServiceInstance = new ComponentInstance(updatedServiceIns);
 252             this.isDependent = this.currentServiceInstance.isDependent();
 253             this.dependencyStatus.emit(this.isDependent);
 254             if (this.isDependent) {
 255                 this.loadRulesListEvent.emit();
 256             }
 257             this.isLoading = false;
 258         }, (err) => {
 259             this.isDependent = isDependentOrigVal;
 260             this.rulesList = rulesListOrig;
 261             this.isLoading = false;
 262             console.log('An error has occurred.');
 263         });
 264     }
 265
 266     onAddRule() {
 267         const cancelButton: ButtonModel = new ButtonModel(I18nTexts.modalCancel, 'outline white', this.modalServiceNg2.closeCurrentModal);
 268         const saveButton: ButtonModel = new ButtonModel(I18nTexts.modalCreate, 'blue', this.createRule, this.getDisabled);
 269         const modalModel: ModalModel = new ModalModel('l', I18nTexts.addNodeFilterTxt, '', [saveButton, cancelButton], 'standard');
 270         this.modalInstance = this.modalServiceNg2.createCustomModal(modalModel);
 271         this.modalServiceNg2.addDynamicContentToModal(
 272             this.modalInstance,
 273             ServiceDependenciesEditorComponent,
 274             {
 275                 currentServiceName: this.currentServiceInstance.name,
 276                 operatorTypes: this.operatorTypes,
 277                 compositeServiceName: this.compositeService.name,
 278                 parentServiceInputs: this.parentServiceInputs,
 279                 selectedInstanceProperties: this.selectedInstanceProperties,
 280                 selectedInstanceSiblings: this.selectedInstanceSiblings
 281             }
 282         );
 283         this.modalInstance.instance.open();
 284     }
 285
 286     onSelectRule(index: number) {
 287         const cancelButton: ButtonModel = new ButtonModel(I18nTexts.modalCancel, 'outline white', this.modalServiceNg2.closeCurrentModal);
 288         const saveButton: ButtonModel = new ButtonModel(I18nTexts.modalSave, 'blue', () => this.updateRules(), this.getDisabled);
 289         const modalModel: ModalModel = new ModalModel('l', I18nTexts.updateNodeFilterTxt, '', [saveButton, cancelButton], 'standard');
 290         this.modalInstance = this.modalServiceNg2.createCustomModal(modalModel);
 291         this.modalServiceNg2.addDynamicContentToModal(
 292             this.modalInstance,
 293             ServiceDependenciesEditorComponent,
 294             {
 295                 serviceRuleIndex: index,
 296                 serviceRules: _.map(this.rulesList, (rule) => new ConstraintObjectUI(rule)),
 297                 currentServiceName: this.currentServiceInstance.name,
 298                 operatorTypes: this.operatorTypes,
 299                 compositeServiceName: this.compositeService.name,
 300                 parentServiceInputs: this.parentServiceInputs,
 301                 selectedInstanceProperties: this.selectedInstanceProperties,
 302                 selectedInstanceSiblings: this.selectedInstanceSiblings
 303             }
 304         );
 305         this.modalInstance.instance.open();
 306     }
 307
 308     getDisabled = (): boolean =>  {
 309         return !this.modalInstance.instance.dynamicContent.instance.checkFormValidForSubmit();
 310     }
 311
 312     createRule  = (): void => {
 313         const newRuleToCreate: ConstraintObject = new ConstraintObject(this.modalInstance.instance.dynamicContent.instance.currentRule);
 314         this.isLoading = true;
 315         this.topologyTemplateService.createServiceFilterConstraints(
 316             this.compositeService.uniqueId,
 317             this.currentServiceInstance.uniqueId,
 318             newRuleToCreate,
 319             this.compositeService.componentType
 320         ).subscribe( (response) => {
 321             this.updateRulesListEvent.emit(response.properties);
 322             this.isLoading = false;
 323         }, (err) => {
 324             this.isLoading = false;
 325         });
 326         this.modalServiceNg2.closeCurrentModal();
 327     }
 328
 329     updateRules = (): void => {
 330         const allRulesToUpdate: ConstraintObject[] = this.modalInstance.instance.dynamicContent.instance.serviceRulesList.map((rule) => new ConstraintObject(rule));
 331         this.isLoading = true;
 332         this.topologyTemplateService.updateServiceFilterConstraints(
 333             this.compositeService.uniqueId,
 334             this.currentServiceInstance.uniqueId,
 335             allRulesToUpdate,
 336             this.compositeService.componentType
 337         ).subscribe((response) => {
 338             this.updateRulesListEvent.emit(response.properties);
 339             this.isLoading = false;
 340         }, (err) => {
 341             this.isLoading = false;
 342         });
 343         this.modalServiceNg2.closeCurrentModal();
 344     }
 345
 346     getSymbol(constraintOperator) {
 347         switch (constraintOperator) {
 348             case OPERATOR_TYPES.LESS_THAN: return '<';
 349             case OPERATOR_TYPES.EQUAL: return '=';
 350             case OPERATOR_TYPES.GREATER_THAN: return '>';
 351         }
 352     }
 353
 354     onDeleteRule = (index: number) => {
 355         this.isLoading = true;
 356         this.topologyTemplateService.deleteServiceFilterConstraints(
 357             this.compositeService.uniqueId,
 358             this.currentServiceInstance.uniqueId,
 359             index,
 360             this.compositeService.componentType
 361         ).subscribe( (response) => {
 362             this.updateRulesListEvent.emit(response.properties);
 363             this.isLoading = false;
 364         }, (err) => {
 365             this.isLoading = false;
 366         });
 367         this.modalServiceNg2.closeCurrentModal();
 368     }
 369
 370     openDeleteModal = (index: number) => {
 371         this.modalServiceNg2.createActionModal(I18nTexts.deleteNodeFilterTxt, I18nTexts.deleteNodeFilterMsg,
 372             I18nTexts.modalDelete, () => this.onDeleteRule(index), I18nTexts.modalCancel).instance.open();
 373     }
 374
 375 }