381 lines
18 KiB
TypeScript
381 lines
18 KiB
TypeScript
import { Injectable } from '@angular/core';
|
|
import { DropdownField } from '../../app/form/fields/dropdown/field-dropdown';
|
|
import { FieldBase } from '../../app/form/fields/field-base';
|
|
import { TextboxField } from '../../app/form/fields/textbox/field-textbox';
|
|
import { CheckBoxField } from '../../app/form/fields/checkbox/field-checkbox';
|
|
import { RadioBoxField } from '../../app/form/fields/radiobox/field-radiobox';
|
|
import { TextAreaField } from '../../app/form/fields/textarea/textarea';
|
|
import { LabelField } from '../../app/form/fields/label/label';
|
|
import { DataModel } from '../entities/DataModel';
|
|
import { Rule } from '../entities/common/rule';
|
|
import { GroupBase } from '../form/dynamic-form-group/group-base';
|
|
import { Attribute } from '../entities/model/attribute';
|
|
import { Param } from '../entities/model/param';
|
|
import { Section } from '../entities/model/section';
|
|
import { RestBase } from '../services/rest-base';
|
|
|
|
@Injectable()
|
|
export class dataModelBuilder {
|
|
|
|
private dataModel: DataModel;
|
|
private fields: FieldBase<any>[];
|
|
|
|
constructor(private restBase: RestBase) { }
|
|
|
|
public getDataModel(data, dataValues) {
|
|
|
|
if (this.dataModel != null)
|
|
return this.dataModel;
|
|
|
|
this.dataModel = new DataModel();
|
|
this.fields = this.buildFields(data.viewstyle.definition.root.fields.field);
|
|
|
|
this.dataModel.semanticAttr = new Array(new Attribute);
|
|
this.dataModel.semanticAttr = this.getFieldsAttributes(data.definition.root.fields.fieldset, data.ruleset.definition.root.functions.function, this.fields);
|
|
this.dataModel.groups = this.getGroups(data.viewstyle.definition.root.fieldGroups.fieldGroup, this.fields, dataValues);
|
|
this.dataModel.sections = this.getSections(data.viewstyle.definition.root.sections.section, this.dataModel.groups);
|
|
this.dataModel.buildIndex();
|
|
|
|
this.checkDuplicateInObject('order', this.dataModel.groups[13].groupFields); //for future use , for composite field
|
|
|
|
return this.dataModel;
|
|
}
|
|
|
|
|
|
private buildFields(fields: any[]) {
|
|
let fieldsVisible: FieldBase<any>[] = [];
|
|
fields.forEach(element => {
|
|
if (element.viewStyle._renderstyle == "freetext") {
|
|
let newfield: FieldBase<any>;
|
|
let rule = new Rule();
|
|
newfield = new TextboxField({
|
|
label: element.title.__cdata,
|
|
key: element._id,
|
|
value: element.value,
|
|
order: element._ordinal,
|
|
rules: element.visible.rule != undefined ? element.visible.rule : rule,
|
|
visible: element._defaultVisibility,
|
|
group: element._group,
|
|
description: element.description.__cdata
|
|
});
|
|
|
|
fieldsVisible.push(newfield);
|
|
}
|
|
else if (element.viewStyle._renderstyle == "dropdown" || element.viewStyle._renderstyle == "combobox") {//to choose one of these in xml
|
|
let newfield: DropdownField;
|
|
let rule = new Rule();
|
|
newfield = new DropdownField({
|
|
label: element.title.__cdata,
|
|
key: element._id,
|
|
value: element.value,
|
|
order: element._ordinal,
|
|
rules: element.visible.rule != undefined ? element.visible.rule : rule,
|
|
visible: element._defaultVisibility,
|
|
description: element.description.__cdata,
|
|
group: element._group
|
|
});
|
|
fieldsVisible.push(newfield);
|
|
}
|
|
else if (element.viewStyle._renderstyle == "checkbox" || element.viewStyle._renderstyle == "checkBox") {
|
|
let newfield: CheckBoxField;
|
|
let rule = new Array<Rule>();
|
|
newfield = new CheckBoxField({
|
|
label: element.title.__cdata,
|
|
key: element._id,
|
|
value: false,
|
|
order: element._ordinal,
|
|
rules: element.visible.rule != undefined ? element.visible.rule : rule,
|
|
visible: element._defaultVisibility,
|
|
group: element._group,
|
|
description: element.description.__cdata,
|
|
type: "checkbox"
|
|
});
|
|
fieldsVisible.push(newfield);
|
|
}
|
|
else if (element.viewStyle._renderstyle == "booleanDesicion") {
|
|
let newfield: RadioBoxField;
|
|
let rule = new Array<Rule>();
|
|
newfield = new RadioBoxField({
|
|
label: element.title.__cdata,
|
|
key: element._id,
|
|
value: element.value,
|
|
order: element._ordinal,
|
|
rules: element.visible.rule != undefined ? element.visible.rule : rule,
|
|
visible: element._defaultVisibility,
|
|
group: element._group,
|
|
type: "radio",
|
|
description: element.description.__cdata,
|
|
answers: [
|
|
{
|
|
id: 1,
|
|
answer: "Yes",
|
|
value: true
|
|
},
|
|
{
|
|
id: 2,
|
|
answer: "No",
|
|
value: false
|
|
}]
|
|
});
|
|
fieldsVisible.push(newfield);
|
|
} else if (element.viewStyle._renderstyle == "textarea") {
|
|
let newfield: FieldBase<any>;
|
|
let rule = new Rule();
|
|
newfield = new TextAreaField({
|
|
label: element.title.__cdata,
|
|
key: element._id,
|
|
value: element.value,
|
|
order: element._ordinal,
|
|
rules: element.visible.rule != undefined ? element.visible.rule : rule,
|
|
visible: element._defaultVisibility,
|
|
group: element._group,
|
|
description: element.description.__cdata
|
|
});
|
|
|
|
fieldsVisible.push(newfield);
|
|
}
|
|
|
|
else if (element.viewStyle._renderstyle == "label") {
|
|
let newfield: FieldBase<any>;
|
|
let rule = new Rule();
|
|
newfield = new LabelField({
|
|
label: element.title.__cdata,
|
|
key: element._id,
|
|
value: element.value,
|
|
order: element._ordinal,
|
|
rules: element.visible.rule != undefined ? element.visible.rule : rule,
|
|
visible: element._defaultVisibility,
|
|
group: element._group,
|
|
description: element.description.__cdata
|
|
});
|
|
|
|
fieldsVisible.push(newfield);
|
|
}
|
|
});
|
|
fieldsVisible.sort((a, b) => a.order - b.order);
|
|
return fieldsVisible;
|
|
}
|
|
|
|
private getGroups(fieldGroups: any, fields: any[], dataValues) {
|
|
let groups: GroupBase<any>[] = [];
|
|
|
|
if (fieldGroups.length > 1) {
|
|
fieldGroups.forEach(fieldGroup => { // each fiedgroup fills with its fields from json
|
|
let newfldGroup = new GroupBase();
|
|
let compositeFields = new GroupBase();
|
|
newfldGroup.groupFields = new Array();
|
|
compositeFields.groupFields = new Array();
|
|
|
|
|
|
fields.forEach(field => {
|
|
if (fieldGroup._id == field.group) {
|
|
if (dataValues != "")//--------------------------SET VALUES---------------------------------------------------------------------------------------
|
|
if (dataValues[fieldGroup._id][field.key] != undefined) // to put values in fields
|
|
field.value = dataValues[fieldGroup._id][field.key].value == undefined ? dataValues[fieldGroup._id][field.key] : dataValues[fieldGroup._id][field.key].value;
|
|
|
|
if(field.order.toString().split(",").length > 1){//--------------Composite Fields Multiplicity --------------------------------------------------
|
|
compositeFields.groupFields.push(field);
|
|
newfldGroup.compositeFields = compositeFields;
|
|
}else
|
|
newfldGroup.groupFields.push(field);
|
|
} else {
|
|
//this.dataModel.fields.push(field);
|
|
}
|
|
if (dataValues[fieldGroup._id][field.key] != undefined){
|
|
let keys = new Array<string>();
|
|
Object.keys(dataValues[fieldGroup._id]).forEach(key=>{if(key.startsWith(field.key+"_"))keys.push(key)})
|
|
if (keys.length)
|
|
if (field.controlType == "textbox") {
|
|
let newfield: FieldBase<any>;
|
|
let rule = new Rule();
|
|
newfield = new TextboxField({
|
|
label: field.label+"_"+ 1,
|
|
key: keys[0],
|
|
value: dataValues[fieldGroup._id][keys[0]].value,
|
|
order: field.order,
|
|
rules: field.rules,
|
|
visible: field.visible,
|
|
group: field.group,
|
|
description: field.description
|
|
});debugger;
|
|
newfldGroup.groupFields.push(newfield);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
});
|
|
|
|
newfldGroup.title = fieldGroup.title.__cdata;
|
|
newfldGroup.key = fieldGroup._id;
|
|
newfldGroup.section = fieldGroup._section;
|
|
newfldGroup.style = fieldGroup.visible._style;
|
|
newfldGroup.class = fieldGroup.visible._cssclass;
|
|
newfldGroup.page = fieldGroup._page;
|
|
groups.push(newfldGroup)
|
|
});
|
|
}
|
|
|
|
else {
|
|
let newfldGroup = new GroupBase();
|
|
newfldGroup.groupFields = new Array();
|
|
fields.forEach(field => { //for one fieldgroup, because xml to json transformation doesn't create array of one fieldfroup
|
|
if (fieldGroups._id == field.group) {
|
|
newfldGroup.groupFields.push(field);
|
|
} else
|
|
this.dataModel.fields.push(field);
|
|
});
|
|
newfldGroup.title = fieldGroups.title.__cdata;
|
|
newfldGroup.key = fieldGroups._id;
|
|
newfldGroup.section = fieldGroups._section;
|
|
groups.push(newfldGroup)
|
|
}
|
|
return groups;
|
|
}
|
|
|
|
addAttributesToFields(attr, functions, fields, multiplicity){
|
|
|
|
let newAttribute = new Attribute();
|
|
newAttribute.datatype = attr._datatype;
|
|
newAttribute.defaultValue = attr.defaultValue._value;
|
|
newAttribute.id = attr._id;
|
|
newAttribute.multiplicityMax = attr.multiplicity._max;
|
|
newAttribute.multiplicityMin = attr.multiplicity._min;
|
|
newAttribute.ordinal = attr._ordinal
|
|
if (multiplicity){
|
|
fields.find(x => x.key == newAttribute.id).order = fields.find(x => x.key == newAttribute.id).order +','+ newAttribute.ordinal;
|
|
fields.find(x => x.key == newAttribute.id).multiplicity = true;
|
|
}
|
|
newAttribute.ordinal = attr._ordinal;
|
|
newAttribute.sources = new Array();
|
|
newAttribute.validation = new Array();
|
|
//newAttribute.validation.push(attr.validation.rule);
|
|
//-----------------Sources---------------------------------------------------------------
|
|
if (attr.sources) {
|
|
newAttribute.sources.push(attr.sources.source);
|
|
if (attr.sources.source.length != undefined) {
|
|
for (var i = 0; i < attr.sources.source.length; i++) {
|
|
if (attr.sources.source[i]._type == "url") {
|
|
newAttribute.url = attr.sources.source[i].value._value;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (attr.sources.source._type == "url") {
|
|
newAttribute.url = attr.sources.source.value._value;
|
|
}
|
|
}
|
|
//-----------Rules------------------------------------------------------------------------
|
|
if(attr.validation.rule != undefined)
|
|
if (attr.validation.rule.length)
|
|
for (var i = 0, len = attr.validation.rule.length; i < len; i++) {
|
|
let rule = new Rule();
|
|
rule.ruleStyle = attr.validation.rule[i]._ruleStyle;
|
|
rule.ruleType = attr.validation.rule[i]._type;
|
|
if (attr.validation.rule[i]._ruleStyle == "regex")
|
|
rule.regex = attr.validation.rule[i].__cdata;
|
|
if (attr.validation.rule[i]._ruleStyle == "customValidation") {
|
|
rule.method = attr.validation.rule[i]._method;
|
|
functions.forEach(fnc => {
|
|
if (fnc._id == rule.method)
|
|
rule.methodJs = fnc.script.__cdata;
|
|
});
|
|
}
|
|
newAttribute.validation.push(rule);
|
|
}
|
|
else {
|
|
if (attr.validation.rule) {
|
|
let rule = new Rule();
|
|
rule.ruleStyle = attr.validation.rule._ruleStyle;
|
|
rule.ruleType = attr.validation.rule._type;
|
|
if (attr.validation.rule._ruleStyle == "regex")
|
|
rule.regex = attr.validation.rule.__cdata;
|
|
if (attr.validation.rule._ruleStyle == "customValidation") {
|
|
rule.method = attr.validation.rule._method;
|
|
functions.forEach(fnc => {
|
|
if (fnc._id == rule.method)
|
|
rule.methodJs = fnc.__cdata;
|
|
});
|
|
}
|
|
newAttribute.validation.push(rule); }
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
return newAttribute;
|
|
}
|
|
|
|
private getFieldsAttributes(fieldsets: any, functions: any, fields: any[]) {
|
|
let attribute: Attribute[] = [];
|
|
let newAttribute = new Attribute();
|
|
let multiplicityParam = false;
|
|
fieldsets.forEach(fieldset => {
|
|
let multiplicityParam = false;
|
|
if (fieldset.fields.field.length){
|
|
if(fieldset.multiplicity._max >1 || fieldset.multiplicity._max == "n")
|
|
multiplicityParam = true;
|
|
fieldset.fields.field.forEach(fieldAttribute=>{
|
|
newAttribute = this.addAttributesToFields(fieldAttribute, functions, fields, multiplicityParam)
|
|
attribute.push(newAttribute);
|
|
if (newAttribute.url !== undefined)
|
|
fields.find(x => x.key == newAttribute.id).url = newAttribute.url;
|
|
fields.find(x => x.key == newAttribute.id).attributes.sources = newAttribute.sources;
|
|
fields.find(x => x.key == newAttribute.id).attributes.validation = newAttribute.validation;
|
|
})
|
|
}else{
|
|
if(fieldset.multiplicity._max >1 || fieldset.multiplicity._max == "n")
|
|
multiplicityParam = true;
|
|
newAttribute = this.addAttributesToFields(fieldset.fields.field, functions, fields, multiplicityParam)
|
|
attribute.push(newAttribute);
|
|
if (newAttribute.url !== undefined)
|
|
fields.find(x => x.key == newAttribute.id).url = newAttribute.url;
|
|
fields.find(x => x.key == newAttribute.id).attributes.sources = newAttribute.sources;
|
|
fields.find(x => x.key == newAttribute.id).attributes.validation = newAttribute.validation;
|
|
}
|
|
});
|
|
return attribute;
|
|
|
|
}
|
|
|
|
private getSections(sections: any, fieldGroups: GroupBase<any>[]) {
|
|
let sects: Section[] = [];
|
|
|
|
if (sections.length) {
|
|
sections.forEach(section => {
|
|
let newSection = new Section();
|
|
newSection.defaultVisibility = section.defaultVisibility;
|
|
newSection.description = section.description;
|
|
newSection.id = section._id;
|
|
newSection.title = section.title;
|
|
newSection.ordinal = section._ordinal;
|
|
newSection.page = section._page;
|
|
newSection.groupFields = new Array();
|
|
fieldGroups.forEach(fldgroup => {
|
|
if (fldgroup.section == newSection.id)
|
|
newSection.groupFields.push(fldgroup);
|
|
})
|
|
sects.push(newSection);
|
|
});
|
|
}
|
|
sects.sort((a, b) => a.ordinal - b.ordinal);
|
|
return sects;
|
|
}
|
|
|
|
|
|
checkDuplicateInObject(propertyName, inputArray) {
|
|
let DuplicateArray = [];
|
|
inputArray.forEach(item => {
|
|
for(var i=0; i<inputArray.length; i++){
|
|
if(item[propertyName] == inputArray[i][propertyName] && item['key'] != inputArray[i]['key']){
|
|
DuplicateArray.push(inputArray[i]);
|
|
}
|
|
}
|
|
});
|
|
console.log(DuplicateArray);
|
|
|
|
}
|
|
|
|
} |