Support property of type List<Map<String,String>>
[sdc.git] / catalog-ui / src / app / ng2 / pages / properties-assignment / services / properties.utils.ts
1 /*-
2  * ============LICENSE_START=======================================================
3  * SDC
4  * ================================================================================
5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
6  * ================================================================================
7  * Licensed under the Apache License, Version 2.0 (the "License");
8  * you may not use this file except in compliance with the License.
9  * You may obtain a copy of the License at
10  * 
11  *      http://www.apache.org/licenses/LICENSE-2.0
12  * 
13  * Unless required by applicable law or agreed to in writing, software
14  * distributed under the License is distributed on an "AS IS" BASIS,
15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16  * See the License for the specific language governing permissions and
17  * limitations under the License.
18  * ============LICENSE_END=========================================================
19  */
20
21 import * as _ from "lodash";
22 import { Injectable } from '@angular/core';
23 import { DataTypeModel, PropertyFEModel, PropertyBEModel, InstanceBePropertiesMap, InstanceFePropertiesMap, DerivedFEProperty,  DerivedPropertyType, InputFEModel} from "app/models";
24 import { DataTypeService } from "app/ng2/services/data-type.service";
25 import { PropertiesService } from "app/ng2/services/properties.service";
26 import { PROPERTY_TYPES, PROPERTY_DATA } from "app/utils";
27
28 @Injectable()
29 export class PropertiesUtils {
30
31     constructor(private dataTypeService:DataTypeService, private propertiesService: PropertiesService) {}
32
33     /**
34      * Entry point when getting properties from server
35      * For each instance, loop through each property, and:
36      * 1. Create flattened children
37      * 2. Check against inputs to see if any props are declared and disable them
38      * 3. Initialize valueObj (which also creates any new list/map flattened children as needed)
39      * Returns InstanceFePropertiesMap
40      */
41     public convertPropertiesMapToFEAndCreateChildren = (instancePropertiesMap:InstanceBePropertiesMap, isVF:boolean, inputs?:Array<InputFEModel>, model?:string): InstanceFePropertiesMap => {
42         let instanceFePropertiesMap:InstanceFePropertiesMap = new InstanceFePropertiesMap();
43         angular.forEach(instancePropertiesMap, (properties:Array<PropertyBEModel>, instanceId:string) => {
44             let propertyFeArray: Array<PropertyFEModel> = [];
45             _.forEach(properties, (property: PropertyBEModel) => {
46         
47                 if (this.dataTypeService.getDataTypeByModelAndTypeName(model, property.type)) { // if type not exist in data types remove property from list
48
49                     let newFEProp: PropertyFEModel = new PropertyFEModel(property); //Convert property to FE
50
51                     this.initValueObjectRef(newFEProp); //initialize valueObj AND creates flattened children
52                     propertyFeArray.push(newFEProp);
53                     newFEProp.updateExpandedChildPropertyId(newFEProp.name); //display only the first level of children
54                     this.dataTypeService.checkForCustomBehavior(newFEProp);
55
56                     if (newFEProp.isToscaGetFunction()) {
57                         return;
58                     }
59                     //if this prop (or any children) are declared, set isDeclared and disable checkbox on parents/children
60                     if (newFEProp.getInputValues && newFEProp.getInputValues.length) {
61                         newFEProp.getInputValues.forEach(propInputDetail => {
62                             let inputPath = propInputDetail.inputPath;
63                             if (!inputPath) { //TODO: this is a workaround until Marina adds inputPath
64                                 let input = inputs.find(input => input.uniqueId == propInputDetail.inputId);
65                                 if (!input) { console.log("CANNOT FIND INPUT FOR " + propInputDetail.inputId); return; }
66                                 else inputPath = input.inputPath;
67                             }
68                             if (inputPath == newFEProp.name) inputPath = undefined; // if not complex we need to remove the inputPath from FEModel so we not look for a child
69                             newFEProp.setAsDeclared(inputPath); //if a path is sent, its a child prop. this param is optional
70                             this.propertiesService.disableRelatedProperties(newFEProp, inputPath);
71                         });
72                     }
73                     if (newFEProp.getPolicyValues && newFEProp.getPolicyValues.length) {
74                         newFEProp.setAsDeclared(newFEProp.inputPath); //if a path is sent, its a child prop. this param is optional
75                         this.propertiesService.disableRelatedProperties(newFEProp, newFEProp.inputPath);
76                     }
77                 }
78             });
79             instanceFePropertiesMap[instanceId] = propertyFeArray;
80
81         });
82         return instanceFePropertiesMap;
83     }
84
85     public convertAddPropertyBAToPropertyFE = (property: PropertyBEModel): PropertyFEModel => {
86         const newFEProp: PropertyFEModel = new PropertyFEModel(property); //Convert property to FE
87         this.initValueObjectRef(newFEProp);
88         newFEProp.updateExpandedChildPropertyId(newFEProp.name); //display only the first level of children
89         this.dataTypeService.checkForCustomBehavior(newFEProp);
90         return newFEProp;
91     }
92
93     public createListOrMapChildren = (property:PropertyFEModel | DerivedFEProperty, key: string, valueObj: any): Array<DerivedFEProperty> => {
94         let newProps: Array<DerivedFEProperty> = [];
95         let parentProp = new DerivedFEProperty(property, property.propertiesName, true, key, valueObj);
96         newProps.push(parentProp);
97
98         if (!property.schema.property.isSimpleType) {
99             let additionalChildren:Array<DerivedFEProperty> = this.createFlattenedChildren(property.schema.property.type, parentProp.propertiesName);
100             this.assignFlattenedChildrenValues(parentProp.valueObj, additionalChildren, parentProp.propertiesName);
101             additionalChildren.forEach(prop => prop.canBeDeclared = false);
102             newProps.push(...additionalChildren);
103         }
104         return newProps;
105     }
106
107     /**
108      * Creates derivedFEProperties of a specified type and returns them.
109      */
110     private createFlattenedChildren = (type: string, parentName: string):Array<DerivedFEProperty> => {
111         let tempProps: Array<DerivedFEProperty> = [];
112         let dataTypeObj: DataTypeModel = this.dataTypeService.getDataTypeByTypeName(type);
113         this.dataTypeService.getDerivedDataTypeProperties(dataTypeObj, tempProps, parentName);
114         return _.sortBy(tempProps, ['propertiesName']);
115     }
116
117     /* Sets the valueObj of parent property and its children.
118     * Note: This logic is different than assignflattenedchildrenvalues - here we merge values, there we pick either the parents value, props value, or default value - without merging.
119     */
120     public initValueObjectRef = (property: PropertyFEModel): void => {
121         property.resetValueObjValidation();
122         if (property.isDeclared) { //if property is declared, it gets a simple input instead. List and map values and pseudo-children will be handled in property component
123             property.valueObj = property.value || property.defaultValue || null;  // use null for empty value object
124             if (property.valueObj && typeof property.valueObj == 'object') {
125                 property.valueObj = JSON.stringify(property.valueObj);
126             }
127         } else {
128             property.valueObj = property.getValueObj();
129             if (property.derivedDataType == DerivedPropertyType.LIST || property.derivedDataType == DerivedPropertyType.MAP) {
130                 property.flattenedChildren = [];
131                 Object.keys(property.valueObj).forEach((key) => {
132                     property.flattenedChildren.push(...this.createListOrMapChildren(property, key, property.valueObj[key]));
133                     const lastCreatedChild = property.flattenedChildren.slice(-1)[0];
134                     if (property.schemaType == PROPERTY_TYPES.MAP && property.valueObj[key]){
135                         const nestedValue:object = property.valueObj[key];
136                         Object.keys(nestedValue).forEach((keyNested) => {
137                             property.flattenedChildren.push(...this.createListOrMapChildren(lastCreatedChild, keyNested, nestedValue[keyNested]));
138                         });
139                     };
140                 });
141             } else if (property.derivedDataType === DerivedPropertyType.COMPLEX) {
142                 property.flattenedChildren = this.createFlattenedChildren(property.type, property.name);
143                 this.assignFlattenedChildrenValues(property.valueObj, property.flattenedChildren, property.name);
144                 property.flattenedChildren.forEach((childProp) => {
145                     property.childPropUpdated(childProp);
146                 });
147             }
148         }
149         property.updateValueObjOrig();
150     };
151
152     /*
153     * Loops through flattened properties array and to assign values
154     * Then, convert any neccessary strings to objects, and vis-versa
155     * For list or map property, creates new children props if valueObj has values
156     */
157     public assignFlattenedChildrenValues = (parentValueJSON: any, derivedPropArray: Array<DerivedFEProperty>, parentName: string) => {
158         if (!derivedPropArray || !parentName) return;
159         let propsToPushMap: Map<number, Array<DerivedFEProperty>> = new Map<number, Array<DerivedFEProperty>>();
160         derivedPropArray.forEach((prop, index) => {
161
162             let propNameInObj = prop.propertiesName.substring(prop.propertiesName.indexOf(parentName) + parentName.length + 1).split('#').join('.'); //extract everything after parent name
163             prop.valueObj = _.get(parentValueJSON, propNameInObj, prop.value || prop.defaultValue || null); //assign value -first value of parent if exists. If not, prop.value if not, prop.defaultvalue
164             prop.value = (prop.valueObj !== null && (typeof prop.valueObj) != 'string') ? JSON.stringify(prop.valueObj) : prop.valueObj;
165
166             if ((prop.isDeclared || prop.type == PROPERTY_TYPES.STRING || prop.type == PROPERTY_TYPES.JSON)) { //Stringify objects of items that are declared or from type string/json
167                 prop.valueObj = (prop.valueObj !== null && typeof prop.valueObj == 'object') ? JSON.stringify(prop.valueObj) : prop.valueObj;
168             } else if(prop.type == PROPERTY_TYPES.INTEGER || prop.type == PROPERTY_TYPES.FLOAT || prop.type == PROPERTY_TYPES.BOOLEAN){ //parse ints and non-string simple types
169                 prop.valueObj = (prop.valueObj !== null && typeof prop.valueObj == PROPERTY_TYPES.STRING) ? JSON.parse(prop.valueObj) : prop.valueObj;
170             } else { //parse strings that should be objects
171                 if (prop.derivedDataType == DerivedPropertyType.COMPLEX) {
172                     prop.valueObj = (prop.valueObj === null || typeof prop.valueObj != 'object') ? JSON.parse(prop.valueObj || '{}') : prop.valueObj;
173                 } else if (prop.derivedDataType == DerivedPropertyType.LIST) {
174                     prop.valueObj = (prop.valueObj === null || typeof prop.valueObj != 'object') ? JSON.parse(prop.valueObj || '[]') : prop.valueObj;
175                 } else if (prop.derivedDataType == DerivedPropertyType.MAP) {
176                     if (!prop.isChildOfListOrMap || !prop.schema.property.isSimpleType) {
177                         prop.valueObj = (prop.valueObj === null || typeof prop.valueObj != 'object') ? JSON.parse(prop.valueObj || '{}') : prop.valueObj;
178                     }
179                 }
180                 if ((prop.derivedDataType == DerivedPropertyType.LIST || prop.derivedDataType == DerivedPropertyType.MAP) && typeof prop.valueObj == 'object' && prop.valueObj !== null && Object.keys(prop.valueObj).length) {
181                     let newProps: Array<DerivedFEProperty> = [];
182                     Object.keys(prop.valueObj).forEach((key) => {
183                         newProps.push(...this.createListOrMapChildren(prop, key, prop.valueObj[key]));//create new children, assign their values, and then add to array
184                     });
185                     propsToPushMap[index + 1] = newProps;
186                 }
187             }
188
189             prop.valueObj = PropertyFEModel.cleanValueObj(prop.valueObj);
190         });
191
192         //add props after we're done looping (otherwise our loop gets messed up). Push in reverse order, so we dont mess up indexes.
193         Object.keys(propsToPushMap).reverse().forEach((indexToInsert) => {
194             derivedPropArray.splice(+indexToInsert, 0, ...propsToPushMap[indexToInsert]); //slacker parsing
195         });
196     }
197
198     public resetPropertyValue = (property: PropertyFEModel, newValue: string, nestedPath?: string): void => {
199         property.value = newValue;
200         if (nestedPath) {
201             let newProp = property.flattenedChildren.find(prop => prop.propertiesName == nestedPath);
202             newProp && this.assignFlattenedChildrenValues(JSON.parse(newValue), [newProp], property.name);
203             property.updateValueObjOrig();
204         } else {
205             this.initValueObjectRef(property);
206         }
207     }
208
209 }