* ============LICENSE_END=========================================================
*/
-import {Component, Input} from '@angular/core';
-import {ComponentMetadata, DataTypeModel, PropertyBEModel} from 'app/models';
+import {Component, EventEmitter, Input, OnChanges, OnInit, Output, SimpleChanges} from '@angular/core';
+import {ComponentMetadata, PropertyBEModel, PropertyDeclareAPIModel, DerivedFEProperty} from 'app/models';
import {TopologyTemplateService} from "../../../services/component-services/topology-template.service";
import {WorkspaceService} from "../../workspace/workspace.service";
-import {PropertiesService} from "../../../services/properties.service";
-import {PROPERTY_DATA} from "../../../../utils/constants";
-import {DataTypeService} from "../../../services/data-type.service";
import {ToscaGetFunctionType} from "../../../../models/tosca-get-function-type";
-import {TranslateService} from "../../../shared/translator/translate.service";
-import {ComponentGenericResponse} from '../../../services/responses/component-generic-response';
-import {Observable} from 'rxjs/Observable';
+import {InstanceFeDetails} from "../../../../models/instance-fe-details";
+import {ToscaGetFunction} from "../../../../models/tosca-get-function";
+import {FormControl, FormGroup, Validators} from "@angular/forms";
+import {ToscaFunctionType} from "../../../../models/tosca-function-type.enum";
+import {ToscaGetFunctionValidationEvent} from "./tosca-get-function/tosca-get-function.component";
+import {ToscaFunction} from "../../../../models/tosca-function";
+import {ToscaConcatFunctionValidationEvent} from "./tosca-concat-function/tosca-concat-function.component";
+import {ToscaCustomFunctionValidationEvent} from "./tosca-custom-function/tosca-custom-function.component";
+import {PROPERTY_TYPES} from "../../../../utils/constants";
+import {YamlFunctionValidationEvent} from "./yaml-function/yaml-function.component";
+import {ToscaConcatFunction} from "../../../../models/tosca-concat-function";
+import {ToscaCustomFunction} from "../../../../models/tosca-custom-function";
+import {YamlFunction} from "../../../../models/yaml-function";
+import {CustomToscaFunction} from "../../../../models/default-custom-functions";
@Component({
selector: 'tosca-function',
templateUrl: './tosca-function.component.html',
styleUrls: ['./tosca-function.component.less'],
})
-export class ToscaFunctionComponent {
+export class ToscaFunctionComponent implements OnInit, OnChanges {
@Input() property: PropertyBEModel;
+ @Input() overridingType: PROPERTY_TYPES;
+ @Input() inToscaFunction: ToscaFunction;
+ @Input() componentInstanceMap: Map<string, InstanceFeDetails> = new Map<string, InstanceFeDetails>();
+ @Input() customToscaFunctions: Array<CustomToscaFunction> = [];
+ @Input() allowClear: boolean = true;
+ @Input() compositionMap: boolean = false;
+ @Input() compositionMapKey: string = "";
+ @Output() onValidFunction: EventEmitter<ToscaGetFunction> = new EventEmitter<ToscaGetFunction>();
+ @Output() onValidityChange: EventEmitter<ToscaFunctionValidationEvent> = new EventEmitter<ToscaFunctionValidationEvent>();
+
+ toscaFunctionForm: FormControl = new FormControl(undefined, [Validators.required]);
+ toscaFunctionTypeForm: FormControl = new FormControl(undefined, Validators.required);
+ formGroup: FormGroup = new FormGroup({
+ 'toscaFunction': this.toscaFunctionForm,
+ 'toscaFunctionType': this.toscaFunctionTypeForm,
+ });
- selectToscaFunction;
- selectedProperty: PropertyDropdownValue;
isLoading: boolean = false;
- propertyDropdownList: Array<PropertyDropdownValue> = [];
+ toscaFunction: ToscaFunction;
toscaFunctions: Array<string> = [];
- dropdownValuesLabel: string;
- dropDownErrorMsg: string;
+ toscaCustomFunctions: Array<String> = [];
+ private isInitialized: boolean = false;
private componentMetadata: ComponentMetadata;
constructor(private topologyTemplateService: TopologyTemplateService,
- private workspaceService: WorkspaceService,
- private propertiesService: PropertiesService,
- private dataTypeService: DataTypeService,
- private translateService: TranslateService) {
+ private workspaceService: WorkspaceService) {
}
- ngOnInit() {
+ ngOnInit(): void {
this.componentMetadata = this.workspaceService.metadata;
+ this.toscaFunction = this.inToscaFunction ? this.inToscaFunction : this.property.toscaFunction ? this.property.toscaFunction : undefined;
this.loadToscaFunctions();
+ this.formGroup.valueChanges.subscribe(() => {
+ if (!this.isInitialized) {
+ return;
+ }
+ this.emitValidityChange();
+ if (this.formGroup.valid) {
+ this.onValidFunction.emit(this.toscaFunctionForm.value);
+ }
+ });
+ this.initToscaFunction();
+ this.emitValidityChange();
+ this.isInitialized = true;
}
- private loadToscaFunctions(): void {
- this.toscaFunctions.push(ToscaGetFunctionType.GET_INPUT.toLowerCase());
- this.toscaFunctions.push(ToscaGetFunctionType.GET_PROPERTY.toLowerCase());
+ ngOnChanges(changes: SimpleChanges): void {
+ if (changes.property) {
+ this.resetForm();
+ this.toscaFunction = this.inToscaFunction ? this.inToscaFunction : this.property.toscaFunction ? this.property.toscaFunction : undefined;
+ this.initToscaFunction();
+ this.loadToscaFunctions();
+ this.emitValidityChange();
+ }
}
- onToscaFunctionChange(): void {
- this.loadDropdownValueLabel();
- this.loadDropdownValues();
+ private validate(): boolean {
+ return (!this.toscaFunctionForm.value && !this.toscaFunctionTypeForm.value) || this.formGroup.valid;
}
- private loadDropdownValueLabel(): void {
- if (!this.selectToscaFunction) {
+ private initToscaFunction(): void {
+ if (this.compositionMap && this.property.subPropertyToscaFunctions) {
+ let keyToFind = [this.compositionMapKey];
+ let subPropertyToscaFunction = this.property.subPropertyToscaFunctions.find(subPropertyToscaFunction => this.areEqual(subPropertyToscaFunction.subPropertyPath, keyToFind));
+
+ if (subPropertyToscaFunction){
+ this.toscaFunction = subPropertyToscaFunction.toscaFunction;
+ this.toscaFunctionForm.setValue(this.toscaFunction);
+ this.toscaFunctionTypeForm.setValue(this.toscaFunction.type);
+ }
+ return;
+ }
+ if (this.property instanceof PropertyDeclareAPIModel && this.property.subPropertyToscaFunctions && (<PropertyDeclareAPIModel> this.property).propertiesName){
+ let propertiesPath = (<PropertyDeclareAPIModel> this.property).propertiesName.split("#");
+ if (propertiesPath.length > 1){
+ let keyToFind = (<DerivedFEProperty>this.property.input).toscaPath;
+ let subPropertyToscaFunction = this.property.subPropertyToscaFunctions.find(subPropertyToscaFunction => this.areEqual(subPropertyToscaFunction.subPropertyPath, keyToFind.length > 0 ? keyToFind : propertiesPath.slice(1)));
+
+ if (subPropertyToscaFunction){
+ this.toscaFunction = subPropertyToscaFunction.toscaFunction;
+ this.toscaFunctionForm.setValue(this.toscaFunction);
+ this.toscaFunctionTypeForm.setValue(this.toscaFunction.type);
+ }
+ return;
+ }
+ }
+ if (!this.property.isToscaFunction()) {
return;
}
- if (this.isGetInputSelected()) {
- this.dropdownValuesLabel = this.translateService.translate('INPUT_DROPDOWN_LABEL');
- } else if (this.isGetPropertySelected()) {
- this.dropdownValuesLabel = this.translateService.translate('TOSCA_FUNCTION_PROPERTY_DROPDOWN_LABEL');
+
+ this.toscaFunctionForm.setValue(this.inToscaFunction ? this.inToscaFunction : this.property.toscaFunction);
+ let type = this.property.toscaFunction.type;
+ if (type == ToscaFunctionType.CUSTOM) {
+ let name = (this.property.toscaFunction as ToscaCustomFunction).name;
+ let customToscaFunc = this.customToscaFunctions.find(custToscFunc => _.isEqual(custToscFunc.name, name))
+ if (customToscaFunc) {
+ this.toscaFunctionTypeForm.setValue(name);
+ } else {
+ this.toscaFunctionTypeForm.setValue("other");
+ }
+ } else {
+ this.toscaFunctionTypeForm.setValue(this.inToscaFunction ? this.inToscaFunction.type : type);
}
}
- private loadDropdownValues(): void {
- if (!this.selectToscaFunction) {
- return;
- }
- this.resetDropDown();
- this.loadPropertiesInDropdown();
+ private areEqual(array1: string[], array2: string[]): boolean {
+ return array1.length === array2.length && array1.every(function(value, index) { return value === array2[index]})
}
- private resetDropDown() {
- this.dropDownErrorMsg = undefined;
- this.propertyDropdownList = [];
+ private loadToscaFunctions(): void {
+ this.toscaFunctions = [];
+ this.toscaFunctions.push(ToscaFunctionType.GET_ATTRIBUTE);
+ this.toscaFunctions.push(ToscaFunctionType.GET_INPUT);
+ this.toscaFunctions.push(ToscaFunctionType.GET_PROPERTY);
+ if ((this.property.type === PROPERTY_TYPES.STRING || this.property.type === PROPERTY_TYPES.ANY) && this.overridingType === undefined) {
+ this.toscaFunctions.push(ToscaFunctionType.CONCAT);
+ }
+ this.loadCustomToscaFunctions();
}
- private loadPropertiesInDropdown() {
- this.startLoading();
- let propertiesObservable: Observable<ComponentGenericResponse>
- if (this.isGetInputSelected()) {
- propertiesObservable = this.topologyTemplateService.getComponentInputsValues(this.componentMetadata.componentType, this.componentMetadata.uniqueId);
- } else if (this.isGetPropertySelected()) {
- propertiesObservable = this.topologyTemplateService.findAllComponentProperties(this.componentMetadata.componentType, this.componentMetadata.uniqueId);
+ private loadCustomToscaFunctions(): void {
+ if (!this.customToscaFunctions.find(custToscFunc => _.isEqual(custToscFunc.name, "other"))) {
+ let other = new CustomToscaFunction();
+ other.name = "other";
+ other.type = ToscaFunctionType.CUSTOM;
+ this.customToscaFunctions.push(other);
}
- propertiesObservable
- .subscribe( (response: ComponentGenericResponse) => {
- let properties: PropertyBEModel[] = this.isGetInputSelected() ? response.inputs : response.properties;
- if (!properties || properties.length === 0) {
- const msgCode = this.isGetInputSelected() ? 'TOSCA_FUNCTION_NO_INPUT_FOUND' : 'TOSCA_FUNCTION_NO_PROPERTY_FOUND';
- this.dropDownErrorMsg = this.translateService.translate(msgCode, {type: this.property.type});
- return;
- }
- this.addPropertiesToDropdown(properties);
- if (this.propertyDropdownList.length == 0) {
- const msgCode = this.isGetInputSelected() ? 'TOSCA_FUNCTION_NO_INPUT_FOUND' : 'TOSCA_FUNCTION_NO_PROPERTY_FOUND';
- this.dropDownErrorMsg = this.translateService.translate(msgCode, {type: this.property.type});
- }
- }, (error) => {
- console.error('An error occurred while loading properties.', error);
- }, () => {
- this.stopLoading();
- });
- }
-
- private addPropertyToDropdown(propertyDropdownValue: PropertyDropdownValue) {
- this.propertyDropdownList.push(propertyDropdownValue);
- this.propertyDropdownList.sort((a, b) => a.propertyLabel.localeCompare(b.propertyLabel));
- }
-
- private addPropertiesToDropdown(properties: PropertyBEModel[]) {
- for (const property of properties) {
- if (this.property.type === property.type) {
- this.addPropertyToDropdown({
- propertyName: property.name,
- propertyId: property.uniqueId,
- propertyLabel: property.name,
- toscaFunction: this.selectToscaFunction,
- propertyPath: [property.name]
- });
- } else if (this.isComplexType(property.type)) {
- this.fillPropertyDropdownWithMatchingChildProperties(property);
- }
+ this.toscaCustomFunctions = [];
+ for (let func of this.customToscaFunctions) {
+ this.toscaCustomFunctions.push(func.name);
}
}
- private fillPropertyDropdownWithMatchingChildProperties(inputProperty: PropertyBEModel, parentPropertyList: Array<PropertyBEModel> = []) {
- const dataTypeFound: DataTypeModel = this.dataTypeService.getDataTypeByModelAndTypeName(this.componentMetadata.model, inputProperty.type);
- if (!dataTypeFound || !dataTypeFound.properties) {
- return;
+ getCustomToscaFunction(): CustomToscaFunction {
+ let funcName = this.formGroup.get('toscaFunctionType').value;
+ return this.customToscaFunctions.find(custToscFunc => _.isEqual(custToscFunc.name, funcName));
+ }
+
+ getCustomFunctionName():string {
+ let toscaFunctionType: CustomToscaFunction = this.getCustomToscaFunction();
+ let name = toscaFunctionType.name;
+ return name == 'other' ? '' : name;
+ }
+
+ getCustomFunctionType():string {
+ let toscaFunctionType: CustomToscaFunction = this.getCustomToscaFunction();
+ return toscaFunctionType.type;
+ }
+
+ isDefaultCustomFunction(): boolean {
+ let toscaFunctionType: CustomToscaFunction = this.getCustomToscaFunction();
+ if (toscaFunctionType.name === "other") {
+ return false;
}
- parentPropertyList.push(inputProperty);
- dataTypeFound.properties.forEach(dataTypeProperty => {
- if (dataTypeProperty.type === this.property.type) {
- this.addPropertyToDropdown({
- propertyName: dataTypeProperty.name,
- propertyId: parentPropertyList[0].uniqueId,
- propertyLabel: parentPropertyList.map(property => property.name).join('->') + '->' + dataTypeProperty.name,
- toscaFunction: this.selectToscaFunction,
- propertyPath: [...parentPropertyList.map(property => property.name), dataTypeProperty.name]
- });
- } else if (PROPERTY_DATA.SIMPLE_TYPES.indexOf(dataTypeProperty.type) === -1) {
- this.fillPropertyDropdownWithMatchingChildProperties(dataTypeProperty, [...parentPropertyList])
- }
- });
+ return this.customToscaFunctions.filter(e => e.name === toscaFunctionType.name).length > 0;
}
- private isGetPropertySelected() {
- return this.selectToscaFunction === ToscaGetFunctionType.GET_PROPERTY.toLowerCase();
+ private resetForm(): void {
+ this.formGroup.reset();
+ this.toscaFunction = undefined;
}
- private isGetInputSelected() {
- return this.selectToscaFunction === ToscaGetFunctionType.GET_INPUT.toLowerCase();
+ private isGetPropertySelected(): boolean {
+ return this.formGroup.get('toscaFunctionType').value === ToscaGetFunctionType.GET_PROPERTY;
}
- private isComplexType(propertyType: string) {
- return PROPERTY_DATA.SIMPLE_TYPES.indexOf(propertyType) === -1;
+ private isGetAttributeSelected(): boolean {
+ return this.formGroup.get('toscaFunctionType').value === ToscaGetFunctionType.GET_ATTRIBUTE;
}
- private stopLoading() {
- this.isLoading = false;
+ private isGetInputSelected(): boolean {
+ return this.formGroup.get('toscaFunctionType').value === ToscaGetFunctionType.GET_INPUT;
}
- private startLoading() {
- this.isLoading = true;
+ isConcatSelected(): boolean {
+ return this.formGroup.get('toscaFunctionType').value === ToscaFunctionType.CONCAT;
}
- showDropdown(): boolean {
- return this.selectToscaFunction && !this.isLoading && !this.dropDownErrorMsg;
+ isCustomSelected(): boolean {
+ let toscaFunctionType: CustomToscaFunction = this.getCustomToscaFunction();
+ return toscaFunctionType && (toscaFunctionType.type === ToscaFunctionType.CUSTOM || toscaFunctionType.type === ToscaFunctionType.GET_INPUT);
}
-}
+ isGetFunctionSelected(): boolean {
+ return this.isGetInputSelected() || this.isGetPropertySelected() || this.isGetAttributeSelected();
+ }
+
+ isYamlFunctionSelected(): boolean {
+ return this.formGroup.get('toscaFunctionType').value === ToscaFunctionType.YAML;
+ }
+
+ onClearValues(): void {
+ this.resetForm();
+ }
+
+ showClearButton(): boolean {
+ return this.allowClear && this.toscaFunctionTypeForm.value;
+ }
+
+ onConcatFunctionValidityChange(validationEvent: ToscaConcatFunctionValidationEvent): void {
+ if (validationEvent.isValid) {
+ this.toscaFunctionForm.setValue(validationEvent.toscaConcatFunction);
+ } else {
+ this.toscaFunctionForm.setValue(undefined);
+ }
+ }
+
+ onCustomFunctionValidityChange(validationEvent: ToscaCustomFunctionValidationEvent): void {
+ if (validationEvent.isValid) {
+ this.toscaFunctionForm.setValue(validationEvent.toscaCustomFunction);
+ } else {
+ this.toscaFunctionForm.setValue(undefined);
+ }
+ }
+
+ onGetFunctionValidityChange(validationEvent: ToscaGetFunctionValidationEvent): void {
+ if (validationEvent.isValid) {
+ this.toscaFunctionForm.setValue(validationEvent.toscaGetFunction);
+ } else {
+ this.toscaFunctionForm.setValue(undefined);
+ }
+ }
-export interface PropertyDropdownValue {
- propertyName: string;
- propertyId: string;
- propertyLabel: string;
- toscaFunction: ToscaGetFunctionType;
- propertyPath: Array<string>;
+ onYamlFunctionValidityChange(validationEvent: YamlFunctionValidationEvent): void {
+ if (validationEvent.isValid) {
+ this.toscaFunctionForm.setValue(validationEvent.value);
+ } else {
+ this.toscaFunctionForm.setValue(undefined);
+ }
+ }
+
+ onFunctionTypeChange(): void {
+ this.toscaFunction = undefined;
+ this.toscaFunctionForm.reset();
+ }
+
+ private emitValidityChange(): void {
+ const isValid: boolean = this.validate();
+ this.onValidityChange.emit({
+ isValid: isValid,
+ toscaFunction: isValid ? this.buildFunctionFromForm() : undefined
+ });
+ }
+
+ private buildFunctionFromForm(): ToscaFunction {
+ if (!this.toscaFunctionTypeForm.value) {
+ return undefined;
+ }
+ if (this.isConcatSelected()) {
+ return new ToscaConcatFunction(this.toscaFunctionForm.value);
+ }
+ if (this.isCustomSelected()) {
+ return new ToscaCustomFunction(this.toscaFunctionForm.value);
+ }
+ if (this.isGetFunctionSelected()) {
+ return new ToscaGetFunction(this.toscaFunctionForm.value);
+ }
+ if (this.isYamlFunctionSelected()) {
+ return new YamlFunction(this.toscaFunctionForm.value);
+ }
+
+ console.error(`Function ${this.toscaFunctionTypeForm.value} not supported`);
+ }
}
+
+export class ToscaFunctionValidationEvent {
+ isValid: boolean;
+ toscaFunction: ToscaFunction;
+}
\ No newline at end of file
Code Review / sdc.git / blobdiff