argos/dmp-frontend/src/app/services/dataModelBuilder.service.ts

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 { DataModel } from '../entities/DataModel';
import {Rule} from '../entities/common/rule';
import { GroupBase } from '../form/dynamic-form-group/group-base';

@Injectable()
export class dataModelBuilder {

   private dataModel : DataModel;
   private fields : FieldBase<any>[];

   public getDataModel(data){ 
      
      if(this.dataModel != null)
        return this.dataModel;

      let fldGroup = data.dataset.profile.viewstyle.definition.root.fieldGroups.fieldGroup;//one fieldgroup
      this.dataModel = new DataModel();
      //this.dataModel.fields = this.getFieldVisibility(data.dataset.profile.viewstyle.definition.root.fields.field);
      this.fields = this.buildFields(data.dataset.profile.viewstyle.definition.root.fields.field);
      this.dataModel.groups = this.getGroups(data.dataset.profile.viewstyle.definition.root.fieldGroups.fieldGroup, fldGroup, this.fields);
                            //this.getDummyGroups();
                                
      return this.dataModel;
    }
  
  
    private buildFields(fields:any[]) {
        console.log(fields);
        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: 'DMP1',
                            required: true,
                            order:element._ordinal,
                            rules: element.visible.rule != undefined ?  element.visible.rule: rule,
                            visible: element._defaultVisibility,
                            group : element._group
                        });
                            
                        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: 'DMP1',
                            required: true,
                            order:element._ordinal,
                            rules: element.visible.rule != undefined ?  element.visible.rule: rule,
                            visible: element._defaultVisibility,
                            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: true,
                            required: true,
                            order:element._ordinal,
                            rules: element.visible.rule != undefined ?  element.visible.rule: rule,
                            visible: element._defaultVisibility,
                            group : element._group, 
                            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: true,
                            required: true,
                            order:element._ordinal,
                            rules: element.visible.rule != undefined ?  element.visible.rule: rule,
                            visible: element._defaultVisibility,
                            group : element._group, 
                            type: "radio",
                            answers: [
                                {
                                    id: 1,
                                    answer: "Yes"
                                },
                                {
                                    id: 2,
                                    answer: "No"
                                }]                  
                        });
                        fieldsVisible.push(newfield);
                }                
            });
            fieldsVisible.sort((a, b) => a.order - b.order);
            return  fieldsVisible;
    }

    private getGroups(fieldGroups:any[], fldGroup, fields:any[]){
        let groups :GroupBase<any>[] =[];
        let  newfldGroup = new GroupBase();
        newfldGroup.groupFields = new Array();
        if(fieldGroups.length>1)
            fieldGroups.forEach(fieldGroup =>{         
            fields.forEach(field => {
                if(fieldGroup._id == field.group){
                    newfldGroup.groupFields.push(field);
                }else
                    this.dataModel.fields.push(field);
            });
            newfldGroup.title = fieldGroup.title.__cdata;
            newfldGroup.key = fldGroup._id;
            groups.push(newfldGroup)
            });
        else{
            fields.forEach(field => {                
                if(fldGroup._id == field.group){
                    newfldGroup.groupFields.push(field);
                }else
                this.dataModel.fields.push(field);
            });
            newfldGroup.title = fldGroup.title.__cdata;
            newfldGroup.key = fldGroup._id;
            groups.push(newfldGroup)
        }
        return groups;
    }
  

     private getDummyGroups(){
      
       let groups :GroupBase<any>[] =[];
      
      
       let group: GroupBase<any>;
       group = new GroupBase<any>({
         key: "adfgadfsg",
         title: "GroupA",
         rules: new Array(),
         groupFields: new Array(),
         value: "value",
         visible: true,
         order: 1
         //,
         //controlType: "none"
       });
      
      
       let newfield1:FieldBase <any>;
       newfield1 = new TextboxField({
               key:"tf1-455",
               label: "Field from group1",
               value: 'this is a groupfield',
               required: true,
               ordinal:1
           });
       group.groupFields.push(newfield1);
      
       let newfield2:FieldBase <any>;
       newfield2 = new TextboxField({
               key:"tf1-443",
               label: "Another field from group1",
               value: 'this is a groupfield',
               required: true,
               ordinal:2
           });
       group.groupFields.push(newfield2);
      
       groups.push(group);
      

       return groups;
      
     }
 
  
}