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 = (<DerivedFEProperty>this.property.input).toscaPath;
 118                 let subPropertyToscaFunction = this.property.subPropertyToscaFunctions.find(subPropertyToscaFunction => this.areEqual(subPropertyToscaFunction.subPropertyPath, keyToFind.length > 0 ? keyToFind : propertiesPath.slice(1)));
 119
 120                 if (subPropertyToscaFunction){
 121                         this.toscaFunction = subPropertyToscaFunction.toscaFunction;
 122                     this.toscaFunctionForm.setValue(this.toscaFunction);
 123                     this.toscaFunctionTypeForm.setValue(this.toscaFunction.type);
 124                 }
 125                 return;
 126             }
 127         }
 128
 129         if (!this.property.isToscaFunction()) {
 130             return;
 131         }
 132         this.toscaFunctionForm.setValue(this.property.toscaFunction);
 133         this.toscaFunctionTypeForm.setValue(this.property.toscaFunction.type);
 134     }
 135
 136     private areEqual(array1: string[], array2: string[]): boolean {
 137             return array1.length === array2.length && array1.every(function(value, index) { return value === array2[index]})
 138     }
 139
 140     private loadToscaFunctions(): void {
 141         this.toscaFunctions = [];
 142         this.toscaFunctions.push(ToscaFunctionType.GET_ATTRIBUTE);
 143         this.toscaFunctions.push(ToscaFunctionType.GET_INPUT);
 144         this.toscaFunctions.push(ToscaFunctionType.GET_PROPERTY);
 145         if (this.property.type === PROPERTY_TYPES.STRING) {
 146             this.toscaFunctions.push(ToscaFunctionType.CONCAT);
 147         }
 148         this.toscaFunctions.push(ToscaFunctionType.YAML);
 149     }
 150
 151     private resetForm(): void {
 152         this.formGroup.reset();
 153         this.toscaFunction = undefined;
 154     }
 155
 156     private isGetPropertySelected(): boolean {
 157         return this.formGroup.get('toscaFunctionType').value === ToscaGetFunctionType.GET_PROPERTY;
 158     }
 159
 160     private isGetAttributeSelected(): boolean {
 161         return this.formGroup.get('toscaFunctionType').value === ToscaGetFunctionType.GET_ATTRIBUTE;
 162     }
 163
 164     private isGetInputSelected(): boolean {
 165         return this.formGroup.get('toscaFunctionType').value === ToscaGetFunctionType.GET_INPUT;
 166     }
 167
 168     isConcatSelected(): boolean {
 169         return this.formGroup.get('toscaFunctionType').value === ToscaFunctionType.CONCAT;
 170     }
 171
 172     isGetFunctionSelected(): boolean {
 173         return this.isGetInputSelected() || this.isGetPropertySelected() || this.isGetAttributeSelected();
 174     }
 175
 176     isYamlFunctionSelected(): boolean {
 177         return this.formGroup.get('toscaFunctionType').value === ToscaFunctionType.YAML;
 178     }
 179
 180     onClearValues(): void {
 181         this.resetForm();
 182     }
 183
 184     showClearButton(): boolean {
 185         return this.allowClear && this.toscaFunctionTypeForm.value;
 186     }
 187
 188     onConcatFunctionValidityChange(validationEvent: ToscaConcatFunctionValidationEvent): void {
 189         if (validationEvent.isValid) {
 190             this.toscaFunctionForm.setValue(validationEvent.toscaConcatFunction);
 191         } else {
 192             this.toscaFunctionForm.setValue(undefined);
 193         }
 194     }
 195
 196     onGetFunctionValidityChange(validationEvent: ToscaGetFunctionValidationEvent): void {
 197         if (validationEvent.isValid) {
 198             this.toscaFunctionForm.setValue(validationEvent.toscaGetFunction);
 199         } else {
 200             this.toscaFunctionForm.setValue(undefined);
 201         }
 202     }
 203
 204     onYamlFunctionValidityChange(validationEvent: YamlFunctionValidationEvent): void {
 205         if (validationEvent.isValid) {
 206             this.toscaFunctionForm.setValue(validationEvent.value);
 207         } else {
 208             this.toscaFunctionForm.setValue(undefined);
 209         }
 210     }
 211
 212     onFunctionTypeChange(): void {
 213         this.toscaFunction = undefined;
 214         this.toscaFunctionForm.reset();
 215     }
 216
 217     private emitValidityChange(): void {
 218         const isValid: boolean = this.validate();
 219         this.onValidityChange.emit({
 220             isValid: isValid,
 221             toscaFunction: isValid ? this.buildFunctionFromForm() : undefined
 222         });
 223     }
 224
 225     private buildFunctionFromForm(): ToscaFunction {
 226         if (!this.toscaFunctionTypeForm.value) {
 227             return undefined;
 228         }
 229         if (this.isConcatSelected()) {
 230             return new ToscaConcatFunction(this.toscaFunctionForm.value);
 231         }
 232         if (this.isGetFunctionSelected()) {
 233             return new ToscaGetFunction(this.toscaFunctionForm.value);
 234         }
 235         if (this.isYamlFunctionSelected()) {
 236             return new YamlFunction(this.toscaFunctionForm.value);
 237         }
 238
 239         console.error(`Function ${this.toscaFunctionTypeForm.value} not supported`);
 240     }
 241 }
 242
 243 export class ToscaFunctionValidationEvent {
 244     isValid: boolean;
 245     toscaFunction: ToscaFunction;
 246 }