2017-09-14 12:37:36 +02:00
|
|
|
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';
|
2017-09-18 18:08:15 +02:00
|
|
|
import { RadioBoxField } from '../../app/form/fields/radiobox/field-radiobox';
|
2017-11-06 11:38:58 +01:00
|
|
|
import { TextAreaField } from '../../app/form/fields/textarea/textarea';
|
2017-11-09 15:03:17 +01:00
|
|
|
import { LabelField } from '../../app/form/fields/label/label';
|
2017-09-14 12:37:36 +02:00
|
|
|
import { DataModel } from '../entities/DataModel';
|
2017-10-18 22:36:33 +02:00
|
|
|
import { Rule } from '../entities/common/rule';
|
2017-09-14 12:37:36 +02:00
|
|
|
import { GroupBase } from '../form/dynamic-form-group/group-base';
|
2017-09-21 12:02:11 +02:00
|
|
|
import { Attribute } from '../entities/model/attribute';
|
2017-09-22 13:38:53 +02:00
|
|
|
import { Param } from '../entities/model/param';
|
2017-09-28 17:05:46 +02:00
|
|
|
import { Section } from '../entities/model/section';
|
2017-10-18 22:36:33 +02:00
|
|
|
import { RestBase } from '../services/rest-base';
|
2017-09-14 12:37:36 +02:00
|
|
|
|
|
|
|
@Injectable()
|
|
|
|
export class dataModelBuilder {
|
|
|
|
|
2017-10-18 22:36:33 +02:00
|
|
|
private dataModel: DataModel;
|
|
|
|
private fields: FieldBase<any>[];
|
2017-09-18 12:18:17 +02:00
|
|
|
|
2017-10-18 22:36:33 +02:00
|
|
|
constructor(private restBase: RestBase) { }
|
2017-09-18 12:18:17 +02:00
|
|
|
|
2017-11-02 17:39:05 +01:00
|
|
|
public getDataModel(data, dataValues) {
|
2017-10-18 22:36:33 +02:00
|
|
|
|
|
|
|
if (this.dataModel != null)
|
|
|
|
return this.dataModel;
|
|
|
|
|
|
|
|
this.dataModel = new DataModel();
|
2017-10-30 15:56:50 +01:00
|
|
|
this.fields = this.buildFields(data.viewstyle.definition.root.fields.field);
|
2017-11-02 17:39:05 +01:00
|
|
|
this.dataModel.groups = this.getGroups(data.viewstyle.definition.root.fieldGroups.fieldGroup, this.fields, dataValues);
|
2017-11-09 15:03:17 +01:00
|
|
|
this.checkDuplicateInObject('order', this.dataModel.groups[13].groupFields);
|
2017-10-18 22:36:33 +02:00
|
|
|
this.dataModel.semanticAttr = new Array(new Attribute);
|
|
|
|
//this.dataModel.semanticAttr = data.dataset.profile.definition.root.fields.field;
|
2017-10-30 15:56:50 +01:00
|
|
|
this.dataModel.semanticAttr = this.getFieldsAttributes(data.definition.root.fields.field, data.ruleset.definition.root.functions.function, this.fields);
|
|
|
|
this.dataModel.sections = this.getSections(data.viewstyle.definition.root.sections.section, this.dataModel.groups);
|
2017-10-18 22:36:33 +02:00
|
|
|
this.dataModel.buildIndex();
|
|
|
|
|
|
|
|
return this.dataModel;
|
2017-09-14 12:37:36 +02:00
|
|
|
}
|
2017-10-18 22:36:33 +02:00
|
|
|
|
|
|
|
|
|
|
|
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,
|
2017-10-19 16:33:12 +02:00
|
|
|
value: false,
|
2017-10-18 22:36:33 +02:00
|
|
|
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
|
|
|
|
}]
|
|
|
|
});
|
2017-11-06 11:38:58 +01:00
|
|
|
fieldsVisible.push(newfield);
|
2017-11-07 09:04:59 +01:00
|
|
|
} else if (element.viewStyle._renderstyle == "textarea") {
|
2017-11-06 11:38:58 +01:00
|
|
|
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
|
|
|
|
});
|
|
|
|
|
2017-10-18 22:36:33 +02:00
|
|
|
fieldsVisible.push(newfield);
|
|
|
|
}
|
2017-11-09 15:03:17 +01:00
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
2017-10-18 22:36:33 +02:00
|
|
|
});
|
|
|
|
fieldsVisible.sort((a, b) => a.order - b.order);
|
|
|
|
return fieldsVisible;
|
2017-09-14 12:37:36 +02:00
|
|
|
}
|
|
|
|
|
2017-11-07 09:04:59 +01:00
|
|
|
private getGroups(fieldGroups: any, fields: any[], dataValues) {
|
2017-10-18 22:36:33 +02:00
|
|
|
let groups: GroupBase<any>[] = [];
|
2017-11-07 09:04:59 +01:00
|
|
|
|
2017-10-18 22:36:33 +02:00
|
|
|
if (fieldGroups.length > 1) {
|
|
|
|
fieldGroups.forEach(fieldGroup => { // each fiedgroup fills with its fields from json
|
|
|
|
let newfldGroup = new GroupBase();
|
|
|
|
newfldGroup.groupFields = new Array();
|
2017-09-19 17:24:31 +02:00
|
|
|
fields.forEach(field => {
|
2017-10-18 22:36:33 +02:00
|
|
|
if (fieldGroup._id == field.group) {
|
2017-11-07 09:04:59 +01:00
|
|
|
if (dataValues != "")
|
|
|
|
if (dataValues[fieldGroup._id][field.key] != undefined) // to put values in fields
|
2017-11-03 18:14:32 +01:00
|
|
|
field.value = dataValues[fieldGroup._id][field.key].value == undefined ? dataValues[fieldGroup._id][field.key] : dataValues[fieldGroup._id][field.key].value;
|
2017-09-19 17:24:31 +02:00
|
|
|
newfldGroup.groupFields.push(field);
|
2017-10-18 22:36:33 +02:00
|
|
|
} else {
|
2017-09-19 17:24:31 +02:00
|
|
|
//this.dataModel.fields.push(field);
|
|
|
|
}
|
2017-10-18 22:36:33 +02:00
|
|
|
|
2017-09-19 17:24:31 +02:00
|
|
|
});
|
|
|
|
newfldGroup.title = fieldGroup.title.__cdata;
|
|
|
|
newfldGroup.key = fieldGroup._id;
|
2017-09-28 17:05:46 +02:00
|
|
|
newfldGroup.section = fieldGroup._section;
|
2017-10-06 16:33:08 +02:00
|
|
|
newfldGroup.style = fieldGroup.visible._style;
|
|
|
|
newfldGroup.class = fieldGroup.visible._cssclass;
|
2017-11-03 18:14:32 +01:00
|
|
|
newfldGroup.page = fieldGroup._page;
|
2017-09-19 17:24:31 +02:00
|
|
|
groups.push(newfldGroup)
|
2017-10-18 22:36:33 +02:00
|
|
|
});
|
2017-09-19 17:24:31 +02:00
|
|
|
}
|
2017-10-18 22:36:33 +02:00
|
|
|
|
|
|
|
else {
|
|
|
|
let newfldGroup = new GroupBase();
|
2017-09-19 17:24:31 +02:00
|
|
|
newfldGroup.groupFields = new Array();
|
2017-09-28 17:05:46 +02:00
|
|
|
fields.forEach(field => { //for one fieldgroup, because xml to json transformation doesn't create array of one fieldfroup
|
2017-10-18 22:36:33 +02:00
|
|
|
if (fieldGroups._id == field.group) {
|
2017-09-18 12:18:17 +02:00
|
|
|
newfldGroup.groupFields.push(field);
|
2017-10-18 22:36:33 +02:00
|
|
|
} else
|
|
|
|
this.dataModel.fields.push(field);
|
2017-09-18 12:18:17 +02:00
|
|
|
});
|
2017-09-19 17:24:31 +02:00
|
|
|
newfldGroup.title = fieldGroups.title.__cdata;
|
|
|
|
newfldGroup.key = fieldGroups._id;
|
2017-09-28 17:05:46 +02:00
|
|
|
newfldGroup.section = fieldGroups._section;
|
2017-09-18 12:18:17 +02:00
|
|
|
groups.push(newfldGroup)
|
2017-11-09 15:03:17 +01:00
|
|
|
}
|
2017-09-14 12:37:36 +02:00
|
|
|
return groups;
|
|
|
|
}
|
2017-10-18 22:36:33 +02:00
|
|
|
|
|
|
|
|
|
|
|
private getFieldsAttributes(attributes: any, functions: any, fields: any[]) {
|
|
|
|
let attribute: Attribute[] = [];
|
2017-09-21 12:02:11 +02:00
|
|
|
attributes.forEach(attr => {
|
|
|
|
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;
|
2017-10-18 22:36:33 +02:00
|
|
|
newAttribute.sources = new Array();
|
2017-09-29 18:16:37 +02:00
|
|
|
newAttribute.validation = new Array();
|
|
|
|
//newAttribute.validation.push(attr.validation.rule);
|
2017-09-22 13:38:53 +02:00
|
|
|
|
2017-10-18 22:36:33 +02:00
|
|
|
if (attr.sources) {
|
2017-10-03 17:36:09 +02:00
|
|
|
newAttribute.sources.push(attr.sources.source);
|
2017-11-02 15:46:43 +01:00
|
|
|
if (attr.sources.source.length != undefined) {
|
|
|
|
for (var i = 0; i < attr.sources.source.length; i++) {
|
2017-11-09 15:03:17 +01:00
|
|
|
if (attr.sources.source[i]._type == "url") {
|
|
|
|
newAttribute.url = attr.sources.source[i].value._value;
|
2017-11-02 15:46:43 +01:00
|
|
|
break;
|
|
|
|
} else {
|
2017-10-30 15:56:50 +01:00
|
|
|
newAttribute.sources.forEach(src => {
|
2017-11-02 15:46:43 +01:00
|
|
|
|
2017-10-30 15:56:50 +01:00
|
|
|
src.params = new Array();
|
2017-11-02 15:46:43 +01:00
|
|
|
for (var i = 0, len = attr.sources.source[i].value.length; i < len; i++) {
|
2017-10-30 15:56:50 +01:00
|
|
|
let prm = new Param();
|
2017-11-02 15:46:43 +01:00
|
|
|
prm.key = attr.sources.source[i].value[i]._value;
|
|
|
|
prm.value = attr.sources.source[i].value[i]._label;
|
2017-10-30 15:56:50 +01:00
|
|
|
src.params.push(prm);
|
2017-11-02 15:46:43 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-10-30 15:56:50 +01:00
|
|
|
});
|
2017-11-02 15:46:43 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2017-10-18 22:36:33 +02:00
|
|
|
|
2017-11-09 15:03:17 +01:00
|
|
|
if (attr.sources.source._type == "url") {
|
|
|
|
newAttribute.url = attr.sources.source.value._value;
|
2017-11-02 15:46:43 +01:00
|
|
|
} else {
|
|
|
|
newAttribute.sources.forEach(src => {
|
2017-10-18 22:36:33 +02:00
|
|
|
|
2017-11-02 15:46:43 +01:00
|
|
|
src.params = new Array();
|
|
|
|
for (var i = 0, len = attr.sources.source.value.length; i < len; i++) {
|
|
|
|
let prm = new Param();
|
|
|
|
prm.key = attr.sources.source.value[i]._value;
|
|
|
|
prm.value = attr.sources.source.value[i]._label;
|
|
|
|
src.params.push(prm);
|
|
|
|
}
|
|
|
|
|
|
|
|
});
|
2017-10-18 22:36:33 +02:00
|
|
|
}
|
2017-10-03 17:36:09 +02:00
|
|
|
}
|
2017-11-07 09:04:59 +01:00
|
|
|
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;
|
|
|
|
});
|
|
|
|
}
|
2017-10-18 22:36:33 +02:00
|
|
|
|
2017-11-07 09:04:59 +01:00
|
|
|
newAttribute.validation.push(rule);
|
2017-10-03 17:36:09 +02:00
|
|
|
}
|
2017-11-07 09:04:59 +01:00
|
|
|
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;
|
|
|
|
});
|
2017-10-18 22:36:33 +02:00
|
|
|
|
2017-11-07 09:04:59 +01:00
|
|
|
}
|
2017-10-18 22:36:33 +02:00
|
|
|
|
2017-11-07 09:04:59 +01:00
|
|
|
newAttribute.validation.push(rule);
|
2017-10-03 17:36:09 +02:00
|
|
|
}
|
2017-09-29 18:16:37 +02:00
|
|
|
}
|
2017-09-22 13:38:53 +02:00
|
|
|
|
2017-09-21 12:02:11 +02:00
|
|
|
attribute.push(newAttribute);
|
2017-11-09 15:03:17 +01:00
|
|
|
if (newAttribute.url !== undefined)
|
|
|
|
fields.find(x => x.key == newAttribute.id).url = newAttribute.url;
|
2017-10-23 15:09:50 +02:00
|
|
|
fields.find(x => x.key == newAttribute.id).attributes.sources = newAttribute.sources;
|
2017-09-29 18:16:37 +02:00
|
|
|
fields.find(x => x.key == newAttribute.id).attributes.validation = newAttribute.validation;
|
2017-09-21 12:02:11 +02:00
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
return attribute;
|
|
|
|
}
|
2017-09-28 17:05:46 +02:00
|
|
|
|
2017-10-18 22:36:33 +02:00
|
|
|
private getSections(sections: any, fieldGroups: GroupBase<any>[]) {
|
|
|
|
let sects: Section[] = [];
|
2017-09-28 17:05:46 +02:00
|
|
|
|
2017-10-18 22:36:33 +02:00
|
|
|
if (sections.length) {
|
2017-09-28 17:05:46 +02:00
|
|
|
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;
|
2017-11-06 10:57:13 +01:00
|
|
|
newSection.page = section._page;
|
2017-09-28 17:05:46 +02:00
|
|
|
newSection.groupFields = new Array();
|
|
|
|
fieldGroups.forEach(fldgroup => {
|
2017-10-18 22:36:33 +02:00
|
|
|
if (fldgroup.section == newSection.id)
|
2017-09-28 17:05:46 +02:00
|
|
|
newSection.groupFields.push(fldgroup);
|
|
|
|
})
|
|
|
|
sects.push(newSection);
|
|
|
|
});
|
|
|
|
}
|
|
|
|
sects.sort((a, b) => a.ordinal - b.ordinal);
|
|
|
|
return sects;
|
|
|
|
}
|
2017-10-18 22:36:33 +02:00
|
|
|
|
|
|
|
getValuesFromEestore(url: string, fieldPath: string) {
|
|
|
|
this.restBase.proxy_get(url).subscribe((data) => {
|
|
|
|
data.data.forEach(data => {
|
|
|
|
console.log(data);
|
|
|
|
});
|
|
|
|
});
|
|
|
|
}
|
2017-11-09 15:03:17 +01:00
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2017-09-14 12:37:36 +02:00
|
|
|
}
|