catalog-ui/src/app/ng2/pages/properties-assignment/tosca-function/tosca-function.component.ts

   1 /*
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2021 Nordix Foundation
   4  *  ================================================================================
   5  *  Licensed under the Apache License, Version 2.0 (the "License");
   6  *  you may not use this file except in compliance with the License.
   7  *  You may obtain a copy of the License at
   8  *
   9  *        http://www.apache.org/licenses/LICENSE-2.0
  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 or implied.
  13  *  See the License for the specific language governing permissions and
  14  *  limitations under the License.
  15  *
  16  *  SPDX-License-Identifier: Apache-2.0
  17  *  ============LICENSE_END=========================================================
  18  */
  19
  20 import {Component, EventEmitter, Input, OnChanges, OnInit, Output, SimpleChanges} from '@angular/core';
  21 import {ComponentMetadata, PropertyBEModel, PropertyDeclareAPIModel, DerivedFEProperty} from 'app/models';
  22 import {TopologyTemplateService} from "../../../services/component-services/topology-template.service";
  23 import {WorkspaceService} from "../../workspace/workspace.service";
  24 import {ToscaGetFunctionType} from "../../../../models/tosca-get-function-type";
  25 import {InstanceFeDetails} from "../../../../models/instance-fe-details";
  26 import {ToscaGetFunction} from "../../../../models/tosca-get-function";
  27 import {FormControl, FormGroup, Validators} from "@angular/forms";
  28 import {ToscaFunctionType} from "../../../../models/tosca-function-type.enum";
  29 import {ToscaGetFunctionValidationEvent} from "./tosca-get-function/tosca-get-function.component";
  30 import {ToscaFunction} from "../../../../models/tosca-function";
  31 import {ToscaConcatFunctionValidationEvent} from "./tosca-concat-function/tosca-concat-function.component";
  32 import {PROPERTY_TYPES, PROPERTY_DATA} from "../../../../utils/constants";
  33 import {YamlFunctionValidationEvent} from "./yaml-function/yaml-function.component";
  34 import {ToscaConcatFunction} from "../../../../models/tosca-concat-function";
  35 import {YamlFunction} from "../../../../models/yaml-function";
  36
  37 @Component({
  38     selector: 'tosca-function',
  39     templateUrl: './tosca-function.component.html',
  40     styleUrls: ['./tosca-function.component.less'],
  41 })
  42 export class ToscaFunctionComponent implements OnInit, OnChanges {
  43
  44     @Input() property: PropertyBEModel;
  45     @Input() componentInstanceMap: Map<string, InstanceFeDetails> = new Map<string, InstanceFeDetails>();
  46     @Input() allowClear: boolean = true;
  47     @Input() compositionMap: boolean = false;
  48     @Input() compositionMapKey: string = "";
  49     @Output() onValidFunction: EventEmitter<ToscaGetFunction> = new EventEmitter<ToscaGetFunction>();
  50     @Output() onValidityChange: EventEmitter<ToscaFunctionValidationEvent> = new EventEmitter<ToscaFunctionValidationEvent>();
  51
  52     toscaFunctionForm: FormControl = new FormControl(undefined, [Validators.required]);
  53     toscaFunctionTypeForm: FormControl = new FormControl(undefined, Validators.required);
  54     formGroup: FormGroup = new FormGroup({
  55         'toscaFunction': this.toscaFunctionForm,
  56         'toscaFunctionType': this.toscaFunctionTypeForm,
  57     });
  58
  59     isLoading: boolean = false;
  60     toscaFunction: ToscaFunction;
  61     toscaFunctions: Array<string> = [];
  62
  63     private isInitialized: boolean = false;
  64     private componentMetadata: ComponentMetadata;
  65
  66     constructor(private topologyTemplateService: TopologyTemplateService,
  67                 private workspaceService: WorkspaceService) {
  68     }
  69
  70     ngOnInit(): void {
  71         this.componentMetadata = this.workspaceService.metadata;
  72         this.toscaFunction = this.property.toscaFunction ? this.property.toscaFunction : undefined;
  73         this.loadToscaFunctions();
  74         this.formGroup.valueChanges.subscribe(() => {
  75             if (!this.isInitialized) {
  76                 return;
  77             }
  78             this.emitValidityChange();
  79             if (this.formGroup.valid) {
  80                 this.onValidFunction.emit(this.toscaFunctionForm.value);
  81             }
  82         });
  83         this.initToscaFunction();
  84         this.emitValidityChange();
  85         this.isInitialized = true;
  86     }
  87
  88     ngOnChanges(changes: SimpleChanges): void {
  89         if (changes.property) {
  90             this.resetForm();
  91             this.toscaFunction = this.property.toscaFunction ? this.property.toscaFunction : undefined;
  92             this.initToscaFunction();
  93             this.loadToscaFunctions();
  94             this.emitValidityChange();
  95         }
  96     }
  97
  98     private validate(): boolean {
  99         return (!this.toscaFunctionForm.value && !this.toscaFunctionTypeForm.value) || this.formGroup.valid;
 100     }
 101
 102     private initToscaFunction(): void {
 103         if (this.compositionMap && this.property.subPropertyToscaFunctions) {
 104             let keyToFind = [this.compositionMapKey];
 105             let subPropertyToscaFunction = this.property.subPropertyToscaFunctions.find(subPropertyToscaFunction => this.areEqual(subPropertyToscaFunction.subPropertyPath, keyToFind));
 106
 107                 if (subPropertyToscaFunction){
 108                         this.toscaFunction = subPropertyToscaFunction.toscaFunction;
 109                     this.toscaFunctionForm.setValue(this.toscaFunction);
 110                     this.toscaFunctionTypeForm.setValue(this.toscaFunction.type);
 111                 }
 112                 return;
 113         }
 114             if (this.property instanceof PropertyDeclareAPIModel && this.property.subPropertyToscaFunctions && (<PropertyDeclareAPIModel> this.property).propertiesName){
 115                 let propertiesPath = (<PropertyDeclareAPIModel> this.property).propertiesName.split("#");
 116             if (propertiesPath.length > 1){
 117                 let keyToFind = [];
 118                 if (this.property.type == PROPERTY_TYPES.MAP || this.property.type == PROPERTY_TYPES.LIST) {
 119                     keyToFind.push((<DerivedFEProperty>this.property.input).mapKey);
 120                     if (PROPERTY_DATA.SIMPLE_TYPES.indexOf(this.property.schemaType) === -1) {
 121                         keyToFind.push(propertiesPath.reverse()[0]);
 122                     }
 123                 }
 124                 let subPropertyToscaFunction = this.property.subPropertyToscaFunctions.find(subPropertyToscaFunction => this.areEqual(subPropertyToscaFunction.subPropertyPath, keyToFind.length > 0 ? keyToFind : propertiesPath.slice(1)));
 125
 126                 if (subPropertyToscaFunction){
 127                         this.toscaFunction = subPropertyToscaFunction.toscaFunction;
 128                     this.toscaFunctionForm.setValue(this.toscaFunction);
 129                     this.toscaFunctionTypeForm.setValue(this.toscaFunction.type);
 130                 }
 131                 return;
 132             }
 133         }
 134
 135         if (!this.property.isToscaFunction()) {
 136             return;
 137         }
 138         this.toscaFunctionForm.setValue(this.property.toscaFunction);
 139         this.toscaFunctionTypeForm.setValue(this.property.toscaFunction.type);
 140     }
 141
 142     private areEqual(array1: string[], array2: string[]): boolean {
 143             return array1.length === array2.length && array1.every(function(value, index) { return value === array2[index]})
 144     }
 145
 146     private loadToscaFunctions(): void {
 147         this.toscaFunctions = [];
 148         this.toscaFunctions.push(ToscaFunctionType.GET_ATTRIBUTE);
 149         this.toscaFunctions.push(ToscaFunctionType.GET_INPUT);
 150         this.toscaFunctions.push(ToscaFunctionType.GET_PROPERTY);
 151         if (this.property.type === PROPERTY_TYPES.STRING) {
 152             this.toscaFunctions.push(ToscaFunctionType.CONCAT);
 153         }
 154         this.toscaFunctions.push(ToscaFunctionType.YAML);
 155     }
 156
 157     private resetForm(): void {
 158         this.formGroup.reset();
 159         this.toscaFunction = undefined;
 160     }
 161
 162     private isGetPropertySelected(): boolean {
 163         return this.formGroup.get('toscaFunctionType').value === ToscaGetFunctionType.GET_PROPERTY;
 164     }
 165
 166     private isGetAttributeSelected(): boolean {
 167         return this.formGroup.get('toscaFunctionType').value === ToscaGetFunctionType.GET_ATTRIBUTE;
 168     }
 169
 170     private isGetInputSelected(): boolean {
 171         return this.formGroup.get('toscaFunctionType').value === ToscaGetFunctionType.GET_INPUT;
 172     }
 173
 174     isConcatSelected(): boolean {
 175         return this.formGroup.get('toscaFunctionType').value === ToscaFunctionType.CONCAT;
 176     }
 177
 178     isGetFunctionSelected(): boolean {
 179         return this.isGetInputSelected() || this.isGetPropertySelected() || this.isGetAttributeSelected();
 180     }
 181
 182     isYamlFunctionSelected(): boolean {
 183         return this.formGroup.get('toscaFunctionType').value === ToscaFunctionType.YAML;
 184     }
 185
 186     onClearValues(): void {
 187         this.resetForm();
 188     }
 189
 190     showClearButton(): boolean {
 191         return this.allowClear && this.toscaFunctionTypeForm.value;
 192     }
 193
 194     onConcatFunctionValidityChange(validationEvent: ToscaConcatFunctionValidationEvent): void {
 195         if (validationEvent.isValid) {
 196             this.toscaFunctionForm.setValue(validationEvent.toscaConcatFunction);
 197         } else {
 198             this.toscaFunctionForm.setValue(undefined);
 199         }
 200     }
 201
 202     onGetFunctionValidityChange(validationEvent: ToscaGetFunctionValidationEvent): void {
 203         if (validationEvent.isValid) {
 204             this.toscaFunctionForm.setValue(validationEvent.toscaGetFunction);
 205         } else {
 206             this.toscaFunctionForm.setValue(undefined);
 207         }
 208     }
 209
 210     onYamlFunctionValidityChange(validationEvent: YamlFunctionValidationEvent): void {
 211         if (validationEvent.isValid) {
 212             this.toscaFunctionForm.setValue(validationEvent.value);
 213         } else {
 214             this.toscaFunctionForm.setValue(undefined);
 215         }
 216     }
 217
 218     onFunctionTypeChange(): void {
 219         this.toscaFunction = undefined;
 220         this.toscaFunctionForm.reset();
 221     }
 222
 223     private emitValidityChange(): void {
 224         const isValid: boolean = this.validate();
 225         this.onValidityChange.emit({
 226             isValid: isValid,
 227             toscaFunction: isValid ? this.buildFunctionFromForm() : undefined
 228         });
 229     }
 230
 231     private buildFunctionFromForm(): ToscaFunction {
 232         if (!this.toscaFunctionTypeForm.value) {
 233             return undefined;
 234         }
 235         if (this.isConcatSelected()) {
 236             return new ToscaConcatFunction(this.toscaFunctionForm.value);
 237         }
 238         if (this.isGetFunctionSelected()) {
 239             return new ToscaGetFunction(this.toscaFunctionForm.value);
 240         }
 241         if (this.isYamlFunctionSelected()) {
 242             return new YamlFunction(this.toscaFunctionForm.value);
 243         }
 244
 245         console.error(`Function ${this.toscaFunctionTypeForm.value} not supported`);
 246     }
 247 }
 248
 249 export class ToscaFunctionValidationEvent {
 250     isValid: boolean;
 251     toscaFunction: ToscaFunction;
 252 }