Support for concat TOSCA function

Adds support for the concat TOSCA function in an instance property.
Refactors the TOSCA function structure so it can be more generic to
support other functions in the future.

Change-Id: I338e4138d26afe21779da57c4eeb3f2d486c20a9
Issue-ID: SDC-4095
Signed-off-by: andre.schmid <andre.schmid@est.tech>

1 files changed, 140 insertions, 0 deletions

diff --git a/catalog-ui/src/app/ng2/pages/properties-assignment/tosca-function/tosca-concat-function/tosca-concat-function.component.ts b/catalog-ui/src/app/ng2/pages/properties-assignment/tosca-function/tosca-concat-function/tosca-concat-function.component.ts
new file mode 100644
index 0000000000..d808c284a8
--- /dev/null
+++ b/catalog-ui/src/app/ng2/pages/properties-assignment/tosca-function/tosca-concat-function/tosca-concat-function.component.ts
@@ -0,0 +1,140 @@
+import {Component, EventEmitter, Input, OnInit, Output} from '@angular/core';
+import {FormArray, FormControl, FormGroup, Validators} from "@angular/forms";
+import {ToscaConcatFunction} from "../../../../../models/tosca-concat-function";
+import {ToscaFunctionParameter} from "../../../../../models/tosca-function-parameter";
+import {ToscaStringParameter} from "../../../../../models/tosca-string-parameter";
+import {ToscaFunctionType} from "../../../../../models/tosca-function-type.enum";
+import {PropertyBEModel} from "../../../../../models/properties-inputs/property-be-model";
+import {PROPERTY_TYPES} from "../../../../../utils/constants";
+import {InstanceFeDetails} from "../../../../../models/instance-fe-details";
+import {ToscaFunctionValidationEvent} from "../tosca-function.component";
+
+@Component({
+    selector: 'app-tosca-concat-function',
+    templateUrl: './tosca-concat-function.component.html',
+    styleUrls: ['./tosca-concat-function.component.less']
+})
+export class ToscaConcatFunctionComponent implements OnInit {
+
+    @Input() toscaConcatFunction: ToscaConcatFunction;
+    @Input() componentInstanceMap: Map<string, InstanceFeDetails> = new Map<string, InstanceFeDetails>();
+    @Output() onValidFunction: EventEmitter<ToscaConcatFunction> = new EventEmitter<ToscaConcatFunction>();
+    @Output() onValidityChange: EventEmitter<ToscaConcatFunctionValidationEvent> = new EventEmitter<ToscaConcatFunctionValidationEvent>();
+
+    concatParameterFormArray: FormArray = new FormArray([], Validators.minLength(2));
+    formGroup: FormGroup = new FormGroup(
+        {
+            'concatParameterList': this.concatParameterFormArray
+        }
+    );
+
+    parameters: ToscaFunctionParameter[] = [];
+    propertyInputList: Array<PropertyBEModel> = [];
+
+    stringProperty: PropertyBEModel
+
+    STRING_FUNCTION_TYPE = ToscaFunctionType.STRING
+
+    constructor() {
+        this.stringProperty = new PropertyBEModel();
+        this.stringProperty.type = PROPERTY_TYPES.STRING
+    }
+
+    ngOnInit() {
+        this.initForm();
+    }
+
+    private initForm() {
+        this.formGroup.valueChanges.subscribe(() => {
+            this.onValidityChange.emit({
+                isValid: this.formGroup.valid,
+                toscaConcatFunction: this.formGroup.valid ? this.buildConcatFunctionFromForm() : undefined
+            })
+            if (this.formGroup.valid) {
+                this.onValidFunction.emit(this.buildConcatFunctionFromForm());
+            }
+        });
+        if (!this.toscaConcatFunction) {
+            return;
+        }
+
+        if (this.toscaConcatFunction.parameters) {
+            this.parameters = Array.from(this.toscaConcatFunction.parameters);
+            for (const parameter of this.parameters) {
+                if (parameter.type !== PROPERTY_TYPES.STRING) {
+                    this.propertyInputList.push(this.createStringProperty(parameter));
+                    this.concatParameterFormArray.push(
+                        new FormControl(parameter, [Validators.required, Validators.minLength(1)])
+                    );
+                } else {
+                    this.propertyInputList.push(undefined);
+                    this.concatParameterFormArray.push(
+                        new FormControl(parameter.value, [Validators.required, Validators.minLength(1)])
+                    );
+                }
+            }
+        }
+    }
+
+    private buildConcatFunctionFromForm(): ToscaConcatFunction {
+        const toscaConcatFunction1 = new ToscaConcatFunction();
+        this.concatParameterFormArray.controls.forEach(control => {
+            const value = control.value;
+            if (typeof value === 'string') {
+                const stringParameter = new ToscaStringParameter();
+                stringParameter.value = value;
+                toscaConcatFunction1.parameters.push(stringParameter);
+            } else {
+                toscaConcatFunction1.parameters.push(control.value);
+            }
+        });
+
+        return toscaConcatFunction1;
+    }
+
+    addFunction() {
+        this.propertyInputList.push(this.createStringProperty());
+        this.parameters.push({} as ToscaFunctionParameter);
+        this.concatParameterFormArray.push(
+            new FormControl(undefined, [Validators.required, Validators.minLength(1)])
+        );
+    }
+
+    addStringParameter() {
+        this.parameters.push({
+            type: ToscaFunctionType.STRING,
+            value: ''
+        });
+        this.propertyInputList.push(undefined);
+        this.concatParameterFormArray.push(
+            new FormControl('', [Validators.required, Validators.minLength(1)])
+        );
+    }
+
+    removeParameter(position) {
+        this.propertyInputList.splice(position, 1);
+        this.parameters.splice(position, 1);
+        this.concatParameterFormArray.removeAt(position);
+    }
+
+    createStringProperty(toscaFunctionParameter?: ToscaFunctionParameter) {
+        const property = new PropertyBEModel();
+        property.type = PROPERTY_TYPES.STRING;
+        property.toscaFunction = toscaFunctionParameter ? toscaFunctionParameter : undefined;
+        property.value = toscaFunctionParameter ? toscaFunctionParameter.value : undefined;
+        return property;
+    }
+
+    onFunctionValidityChange(event: ToscaFunctionValidationEvent, index: number) {
+        if (event.isValid && event.toscaFunction) {
+            this.concatParameterFormArray.controls[index].setValue(event.toscaFunction)
+        } else {
+            this.concatParameterFormArray.controls[index].setValue(undefined);
+        }
+    }
+}
+
+export interface ToscaConcatFunctionValidationEvent {
+    isValid: boolean,
+    toscaConcatFunction: ToscaConcatFunction,
+}