1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
|
import { Injectable } from '@angular/core';
import { DataTypeModel, PropertyFEModel, PropertyBEModel, InstanceBePropertiesMap, InstanceFePropertiesMap, SchemaProperty, DerivedFEProperty, DerivedFEPropertyMap, DerivedPropertyType, InputFEModel} from "app/models";
import { DataTypeService } from "app/ng2/services/data-type.service";
import { PROPERTY_TYPES } from "app/utils";
import { UUID } from "angular2-uuid";
@Injectable()
export class PropertiesUtils {
constructor(private dataTypeService:DataTypeService) {}
/**
* Entry point when getting properties from server
* Returning InstanceFePropertiesMap
*/
public convertPropertiesMapToFEAndCreateChildren = (instancePropertiesMap:InstanceBePropertiesMap): InstanceFePropertiesMap => {
let instanceFePropertiesMap:InstanceFePropertiesMap = new InstanceFePropertiesMap();
angular.forEach(instancePropertiesMap, (properties:Array<PropertyBEModel>, instanceName:string) => {
instanceFePropertiesMap[instanceName] = this.convertPropertiesToFEAndCreateChildren(properties);
});
return instanceFePropertiesMap;
}
/**
* Convert the properties Array<PropertyBEModel> to Array<PropertyFEModel>
*/
private convertPropertiesToFEAndCreateChildren = (properties: Array<PropertyBEModel>): Array<PropertyFEModel> => {
let propertyFeArray: Array<PropertyFEModel> = [];
_.forEach(properties, (property: PropertyBEModel, index: number) => {
//console.log("=======" + property.name + "========");
if(!this.dataTypeService.getDataTypeByTypeName(property.type)){ // if type not exist in data types remove property from list
console.log("ERROR: missing type " + property.type + " in dataTypes , of property ",property);
return;
}
let propertyFe:PropertyFEModel = new PropertyFEModel(property);
if (propertyFe.isDataType) { //prop is not simple, list, or map. Need to create children.
let tempProps: Array<DerivedFEProperty> = [];
let dataTypeObj: DataTypeModel = this.dataTypeService.getDataTypeByTypeName(propertyFe.type);
this.dataTypeService.getDerivedDataTypeProperties(dataTypeObj, tempProps, propertyFe.name);
propertyFe.flattenedChildren = tempProps;
propertyFe.expandedChildPropertyId = propertyFe.name;
this.initValueObjectRef(propertyFe);
}
propertyFeArray.push(propertyFe);
});
return propertyFeArray;
//TODO: need to look at schema to create the nested properties for the following cases:
// 1 - when value is populated for a complex type (list or map)
// 2 - when adding new entries to a complex type (eg. adding a new entry to a list of AddressRequirements)
}
public initValueObjectRef = (property: PropertyFEModel): void => {
//console.log("Property " + property.name + " has value: " + property.value);
if (!property.isDataType || 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
property.value = property.value || property.defaultValue;
} else if (property.value){ //we have a complex property with a value. Lets parse property.value and populate our flattened children with those values
this.assignValuesRecursively(JSON.parse(property.value), property.flattenedChildren, property.name);
}
}
public assignValuesRecursively = (valueJSON: any, derivedPropArray: Array<DerivedFEProperty>, propName: string) => {
if (valueJSON && Object.keys(valueJSON)) {
Object.keys(valueJSON).forEach(valueKey => {
let childProp: DerivedFEProperty = derivedPropArray.find(prop => prop.propertiesName == propName + "#" + valueKey);
if (!childProp) return;
if (childProp.isDeclared || (childProp.derivedDataType != DerivedPropertyType.COMPLEX && !_.isEmpty(valueJSON[valueKey]))) {
childProp.value = (typeof valueJSON[valueKey] === 'object')? JSON.stringify(valueJSON[valueKey]) : valueJSON[valueKey];
} else {
this.assignValuesRecursively(valueJSON[valueKey], derivedPropArray, childProp.propertiesName)
}
});
}
}
}
|
