cedar-embeddable-editor 0.9.0

package/src/app/modules/shared/factory/template-representation.factory.ts

@@ -0,0 +1,323 @@
+import {JsonSchema} from '../models/json-schema.model';
+import {CedarModel} from '../models/cedar-model.model';
+import {JavascriptTypes} from '../models/javascript-types.model';
+import {CedarComponent} from '../models/component/cedar-component.model';
+import {MultiElementComponent} from '../models/element/multi-element-component.model';
+import {CedarTemplate} from '../models/template/cedar-template.model';
+import {NullTemplate} from '../models/template/null-template.model';
+import {EmptyTemplate} from '../models/template/empty-template.model';
+import {TemplateComponent} from '../models/template/template-component.model';
+import {MultiFieldComponent} from '../models/field/multi-field-component.model';
+import {SingleFieldComponent} from '../models/field/single-field-component.model';
+import {SingleElementComponent} from '../models/element/single-element-component.model';
+import {MultiComponent} from '../models/component/multi-component.model';
+import {ElementComponent} from '../models/component/element-component.model';
+import {FieldComponent} from '../models/component/field-component.model';
+import {ChoiceOption} from '../models/info/choice-option.model';
+import {CedarInputTemplate} from '../models/cedar-input-template.model';
+import {StaticFieldComponent} from '../models/static/static-field-component.model';
+import {ComponentTypeHandler} from '../handler/component-type.handler';
+import {InputType} from '../models/input-type.model';
+import {TemplateObjectUtil} from '../util/template-object-util';
+
+export class TemplateRepresentationFactory {
+
+  static create(inputTemplate: CedarInputTemplate, collapseStaticComponents: boolean): TemplateComponent {
+    if (inputTemplate === null) {
+      return new NullTemplate();
+    } else {
+      const template = new CedarTemplate();
+      TemplateRepresentationFactory.wrap(inputTemplate, inputTemplate, template, [], collapseStaticComponents);
+      TemplateRepresentationFactory.extractTemplateLabels(inputTemplate, template);
+      TemplateRepresentationFactory.extractPageBreakPages(template);
+      return template;
+    }
+  }
+
+  static extractPageBreakPages(template: CedarTemplate): void {
+    const pages = [];
+    let page = [];
+    let numPBInRow = 0;
+
+    template.children.forEach((child, index) => {
+      // encountered page-break component
+      if (child instanceof StaticFieldComponent && (child as StaticFieldComponent).basicInfo.inputType === InputType.pageBreak) {
+        if (page.length) {
+          pages.push(page);
+        }
+        // if page-break is the last component, always add an empty page
+        if (index === template.children.length - 1) {
+          pages.push([new EmptyTemplate()]);
+        } else {
+          numPBInRow++;
+        }
+        page = [];
+      } else {
+        page.push(child);
+
+        if (index === template.children.length - 1) {
+          pages.push(page);
+        }
+
+        // add empty pages corresponding to: (number of page breaks in a row - 1)
+        for (let i = 0; i < numPBInRow - 1; i++) {
+          pages.push([new EmptyTemplate()]);
+        }
+        numPBInRow = 0;
+      }
+    });
+    template.pageBreakChildren = pages;
+  }
+
+  private static isFragmentMulti(templateFragment: object): boolean {
+    const fragmentType = templateFragment[CedarModel.type];
+
+    if (fragmentType === JavascriptTypes.object) {
+      return false;
+    } else if (fragmentType === JavascriptTypes.array) {
+      return true;
+    } else {
+      throw new Error(
+        'Invalid node value of ' + CedarModel.type + '. Value found:"' + fragmentType + '". ' +
+        'Expected "' + JavascriptTypes.object + '" or "' + JavascriptTypes.array + '"!'
+      );
+    }
+  }
+
+  private static wrap(templateJsonObj: object, parentJsonObj: object, component: CedarComponent, parentPath: string[], collapseStaticComponents: boolean): void {
+    // const propertyNames: string[] = TemplateRepresentationFactory.getFilteredSchemaPropertyNames(templateJsonObj);
+    // console.log(propertyNames);
+    const propertyNames: string[] = TemplateRepresentationFactory.getOrderedPropertyNames(templateJsonObj);
+    for (const name of propertyNames) {
+      const templateFragment = templateJsonObj[JsonSchema.properties][name];
+
+      const isMulti: boolean = TemplateRepresentationFactory.isFragmentMulti(templateFragment);
+
+      const parentDataNode: object = TemplateRepresentationFactory.getDataNode(parentJsonObj);
+      const dataNode: object = TemplateRepresentationFactory.getDataNode(templateFragment);
+      const fragmentAtType = dataNode[JsonSchema.atType];
+      let r: CedarComponent = null;
+
+      const myPath: string[] = parentPath.slice();
+      myPath.push(name);
+
+      if (fragmentAtType === CedarModel.templateFieldType) {
+        if (isMulti) {
+          r = new MultiFieldComponent();
+        } else {
+          r = new SingleFieldComponent();
+        }
+
+        TemplateRepresentationFactory.extractValueConstraints(dataNode, r as FieldComponent);
+        TemplateRepresentationFactory.extractLabels(dataNode, parentDataNode, name, r as FieldComponent);
+      } else if (fragmentAtType === CedarModel.templateElementType) {
+        if (isMulti) {
+          r = new MultiElementComponent();
+        } else {
+          r = new SingleElementComponent();
+        }
+        TemplateRepresentationFactory.extractLabels(dataNode, parentDataNode, name, r as FieldComponent);
+        TemplateRepresentationFactory.wrap(dataNode, templateJsonObj, r, myPath, collapseStaticComponents);
+      } else if (fragmentAtType === CedarModel.templateStaticFieldType) {
+        r = new StaticFieldComponent();
+        TemplateRepresentationFactory.extractStaticData(dataNode, parentDataNode, name, r as StaticFieldComponent);
+      }
+
+      if (r !== null) {
+        const wrapperElement: ElementComponent = component as ElementComponent;
+        wrapperElement.children.push(r);
+        r.name = name;
+        r.path = myPath;
+      }
+
+      if (isMulti) {
+        const mr = r as MultiComponent;
+        TemplateRepresentationFactory.extractMultiInfo(templateFragment, mr);
+      }
+    }
+
+    if (collapseStaticComponents) {
+      this.collapseStaticFieldsIntoNextFieldOrElement(component);
+    }
+  }
+
+  // private static getFilteredSchemaPropertyNames(jsonObj: object): string[] {
+  //   const names: string[] = [];
+  //   if (jsonObj.hasOwnProperty(JsonSchema.properties)) {
+  //     const prMap = jsonObj[JsonSchema.properties];
+  //     if (prMap instanceof Object) {
+  //       for (const name of Object.keys(prMap)) {
+  //         if (!JsonSchema.builtInProperties.has(name)) {
+  //           names.push(name);
+  //         }
+  //       }
+  //     }
+  //   }
+  //   return names;
+  // }
+
+  private static getOrderedPropertyNames(jsonObj: object): string[] {
+    const order: string[] = [];
+    if (jsonObj.hasOwnProperty(CedarModel.ui)) {
+      const uiMap = jsonObj[CedarModel.ui];
+      if (uiMap.hasOwnProperty(CedarModel.order)) {
+        return uiMap[CedarModel.order];
+      }
+    }
+    return order;
+  }
+
+  private static getDataNode(templateFragment: object): object {
+    if (templateFragment == null) {
+      return null;
+    }
+    const isMulti: boolean = TemplateRepresentationFactory.isFragmentMulti(templateFragment);
+    if (isMulti) {
+      return templateFragment[CedarModel.items];
+    } else {
+      return templateFragment;
+    }
+  }
+
+  private static extractValueConstraints(dataNode: object, fc: FieldComponent): void {
+    fc.basicInfo.inputType = dataNode[CedarModel.ui][CedarModel.inputType];
+
+    if (dataNode[CedarModel.ui][CedarModel.inputType] === InputType.temporal) {
+      if (dataNode[CedarModel.ui].hasOwnProperty(CedarModel.timezoneEnabled)) {
+        fc.basicInfo.timezoneEnabled = dataNode[CedarModel.ui][CedarModel.timezoneEnabled];
+      }
+      if (dataNode[CedarModel.ui].hasOwnProperty(CedarModel.inputTimeFormat)) {
+        fc.basicInfo.inputTimeFormat = dataNode[CedarModel.ui][CedarModel.inputTimeFormat];
+      }
+      if (dataNode[CedarModel.ui].hasOwnProperty(CedarModel.temporalGranularity)) {
+        fc.basicInfo.temporalGranularity = dataNode[CedarModel.ui][CedarModel.temporalGranularity];
+      }
+    }
+
+    if (dataNode[CedarModel.ui].hasOwnProperty(CedarModel.temporalGranularity)) {
+      fc.basicInfo.temporalGranularity = dataNode[CedarModel.ui][CedarModel.temporalGranularity];
+    }
+
+    if (TemplateObjectUtil.hasValueConstraints(dataNode)) {
+      const vc: object = dataNode[CedarModel.valueConstraints];
+      fc.valueInfo.requiredValue = vc[CedarModel.requiredValue];
+      fc.valueInfo.defaultValue = vc[CedarModel.defaultValue];
+      fc.valueInfo.minLength = vc[CedarModel.minLength];
+      fc.valueInfo.maxLength = vc[CedarModel.maxLength];
+
+      if (vc.hasOwnProperty(CedarModel.temporalType)) {
+        fc.valueInfo.temporalType = vc[CedarModel.temporalType];
+      }
+
+      fc.numberInfo.numberType = vc[CedarModel.numberType];
+      fc.numberInfo.unitOfMeasure = vc[CedarModel.unitOfMeasure];
+      fc.numberInfo.minValue = vc[CedarModel.minValue];
+      fc.numberInfo.maxValue = vc[CedarModel.maxValue];
+      fc.numberInfo.decimalPlace = vc[CedarModel.decimalPlace];
+      fc.choiceInfo.multipleChoice = vc[CedarModel.multipleChoice];
+
+      if (vc[CedarModel.literals] !== undefined) {
+        for (const pair of vc[CedarModel.literals]) {
+          const option = new ChoiceOption();
+          option.label = pair[CedarModel.label];
+          option.selectedByDefault = pair[CedarModel.selectedByDefault];
+          fc.choiceInfo.choices.push(option);
+        }
+      }
+
+      if (TemplateObjectUtil.hasControlledInfo(dataNode)) {
+        fc.basicInfo.inputType = InputType.controlled;
+        fc.controlledInfo.ontologies = vc[CedarModel.ontologies];
+        fc.controlledInfo.valueSets = vc[CedarModel.valueSets];
+        fc.controlledInfo.classes = vc[CedarModel.classes];
+        fc.controlledInfo.branches = vc[CedarModel.branches];
+      }
+    }
+  }
+
+  private static extractLabels(dataNode: object, parentDataNode: object, name: string, fc: FieldComponent): void {
+    fc.labelInfo.preferredLabel = dataNode[CedarModel.skosPrefLabel];
+    fc.labelInfo.description = dataNode[JsonSchema.schemaDescription];
+    fc.labelInfo.label = dataNode[JsonSchema.schemaName];
+    if (parentDataNode != null) {
+      if (fc.labelInfo.description == null || fc.labelInfo.description === 'Help Text') {
+        if (parentDataNode[CedarModel.ui][CedarModel.propertyDescriptions] !== undefined) {
+          fc.labelInfo.description = parentDataNode[CedarModel.ui][CedarModel.propertyDescriptions][name];
+        }
+      }
+      if (fc.labelInfo.label == null || fc.labelInfo.label === name) {
+        if (parentDataNode[CedarModel.ui][CedarModel.propertyLabels] !== undefined) {
+          fc.labelInfo.label = parentDataNode[CedarModel.ui][CedarModel.propertyLabels][name];
+        }
+      }
+    }
+  }
+
+  private static extractMultiInfo(templateFragment: object, mr: MultiComponent): void {
+    mr.multiInfo.minItems = templateFragment[CedarModel.minItems];
+    mr.multiInfo.maxItems = templateFragment[CedarModel.maxItems];
+  }
+
+  private static extractTemplateLabels(templateJsonObj: object, template: CedarTemplate): void {
+    template.labelInfo.label = templateJsonObj[JsonSchema.schemaName];
+    template.labelInfo.description = templateJsonObj[JsonSchema.schemaDescription];
+  }
+
+  private static extractStaticData(dataNode: object, parentDataNode: object, name: string, sfc: StaticFieldComponent): void {
+    sfc.basicInfo.inputType = dataNode[CedarModel.ui][CedarModel.inputType];
+    sfc.labelInfo.preferredLabel = dataNode[CedarModel.skosPrefLabel];
+    sfc.contentInfo.content = dataNode[CedarModel.ui][CedarModel.content];
+    sfc.labelInfo.description = dataNode[JsonSchema.schemaDescription];
+    sfc.labelInfo.label = dataNode[JsonSchema.schemaName];
+    if (parentDataNode != null) {
+      if (sfc.labelInfo.description == null || sfc.labelInfo.description === 'Help Text') {
+        if (parentDataNode[CedarModel.ui][CedarModel.propertyDescriptions] !== undefined) {
+          sfc.labelInfo.description = parentDataNode[CedarModel.ui][CedarModel.propertyDescriptions][name];
+        }
+      }
+      if (sfc.labelInfo.label == null || sfc.labelInfo.label === name) {
+        if (parentDataNode[CedarModel.ui][CedarModel.propertyLabels] !== undefined) {
+          sfc.labelInfo.label = parentDataNode[CedarModel.ui][CedarModel.propertyLabels][name];
+        }
+      }
+    }
+  }
+
+  // Group RTF/image/video fields into consecutive pairs. Any pair gets combined
+  // and displayed inline wherever it's located.
+  // If the RTF/image/video field is odd (not paired with another RTF/image/video),
+  // wrap this field into the next dynamic field/element
+  private static collapseStaticFieldsIntoNextFieldOrElement(component: CedarComponent): void {
+    // re-iterate, inject static components (images) into the next dynamic components
+    // but only if they aren't paired with other like fields
+    if (ComponentTypeHandler.isContainerComponent(component)) {
+      const elementComponent = component as ElementComponent;
+      let prevChild: CedarComponent = null;
+      const newChildren: CedarComponent[] = [];
+      let isStaticPair = false;
+
+      for (let i = 0; i < elementComponent.children.length; i++) {
+        const currentChild: CedarComponent = elementComponent.children[i];
+
+        if (ComponentTypeHandler.isFieldOrElement(currentChild) &&
+            ComponentTypeHandler.isStaticContentComponent(prevChild) && !isStaticPair) {
+          currentChild.linkedStaticFieldComponent = prevChild as StaticFieldComponent;
+          newChildren.pop();
+          newChildren.push(currentChild);
+        } else {
+          newChildren.push(currentChild);
+        }
+
+        if (!isStaticPair && ComponentTypeHandler.isStaticContentComponent(currentChild) &&
+          ComponentTypeHandler.isStaticContentComponent(prevChild)) {
+          isStaticPair = true;
+        } else if (isStaticPair) {
+          isStaticPair = false;
+        }
+        prevChild = currentChild;
+      }
+      elementComponent.children = newChildren;
+    }
+  }
+
+}

package/src/app/modules/shared/handler/component-type.handler.ts

@@ -0,0 +1,51 @@
+import {CedarComponent} from '../models/component/cedar-component.model';
+import {SingleFieldComponent} from '../models/field/single-field-component.model';
+import {MultiFieldComponent} from '../models/field/multi-field-component.model';
+import {StaticFieldComponent} from '../models/static/static-field-component.model';
+import {InputType} from '../models/input-type.model';
+import {CedarTemplate} from '../models/template/cedar-template.model';
+import {SingleElementComponent} from '../models/element/single-element-component.model';
+import {MultiElementComponent} from '../models/element/multi-element-component.model';
+
+export class ComponentTypeHandler {
+
+  public static isImage(component: CedarComponent): boolean {
+    return component instanceof StaticFieldComponent && component.basicInfo.inputType === InputType.image;
+  }
+
+  static isYoutube(component: CedarComponent): boolean {
+    return component instanceof StaticFieldComponent && component.basicInfo.inputType === InputType.youtube;
+  }
+
+  public static isRichText(component: CedarComponent): boolean {
+    return component instanceof StaticFieldComponent && component.basicInfo.inputType === InputType.richText;
+  }
+
+  public static isStaticContentComponent(component: CedarComponent): boolean {
+    return this.isImage(component) || this.isYoutube(component) || this.isRichText(component);
+  }
+
+  public static isField(component: CedarComponent): boolean {
+    return component instanceof SingleFieldComponent || component instanceof MultiFieldComponent;
+  }
+
+  public static isElement(component: CedarComponent): boolean {
+    return component instanceof SingleElementComponent || component instanceof MultiElementComponent;
+  }
+
+  static isContainerComponent(component: CedarComponent): boolean {
+    return component instanceof CedarTemplate || component instanceof SingleElementComponent || component instanceof MultiElementComponent;
+  }
+
+  static isTemplate(component: CedarComponent): boolean {
+    return component instanceof CedarTemplate;
+  }
+
+  static isFieldOrElement(component: CedarComponent): boolean {
+    return this.isField(component) || this.isElement(component);
+  }
+
+  static isMulti(component: CedarComponent): boolean {
+    return component instanceof MultiFieldComponent || component instanceof MultiElementComponent;
+  }
+}

package/src/app/modules/shared/handler/data-object-builder.handler.ts

@@ -0,0 +1,159 @@
+import {TemplateComponent} from '../models/template/template-component.model';
+import {CedarComponent} from '../models/component/cedar-component.model';
+import {SingleElementComponent} from '../models/element/single-element-component.model';
+import {MultiElementComponent} from '../models/element/multi-element-component.model';
+import {CedarTemplate} from '../models/template/cedar-template.model';
+import {ElementComponent} from '../models/component/element-component.model';
+import {SingleFieldComponent} from '../models/field/single-field-component.model';
+import {MultiFieldComponent} from '../models/field/multi-field-component.model';
+import {FieldComponent} from '../models/component/field-component.model';
+import {JsonSchema} from '../models/json-schema.model';
+import * as _ from 'lodash-es';
+import {InstanceExtractData} from '../models/instance-extract-data.model';
+import {InstanceFullData} from '../models/instance-full-data.model';
+import {DataObjectUtil} from '../util/data-object-util';
+import {MultiInstanceObjectHandler} from './multi-instance-object.handler';
+import {CedarInputTemplate} from '../models/cedar-input-template.model';
+import {DataObjectBuildingMode} from '../models/enum/data-object-building-mode.model';
+
+export class DataObjectBuilderHandler {
+
+  private dataObject: object;
+  private dataObjectFull: object;
+  private templateJsonObj: object;
+  private templateRepresentation: TemplateComponent;
+  private multiInstanceObjectService: MultiInstanceObjectHandler;
+
+  static getSubTemplate(template: CedarInputTemplate, path: string[]): CedarInputTemplate {
+    if (path.length === 0) {
+      return template;
+    }
+    const firstPath = path[0];
+    const remainingPath = path.slice(1);
+    const subTemplate = DataObjectUtil.getSafeSubTemplate(template, firstPath);
+    return this.getSubTemplate(subTemplate, remainingPath);
+  }
+
+  public static buildRecursively(component: CedarComponent, dataObject: InstanceExtractData, templateJsonObj: CedarInputTemplate, buildingMode: DataObjectBuildingMode): void {
+    let ret = null;
+    if (templateJsonObj != null) {
+      DataObjectBuilderHandler.addContext(component, dataObject, templateJsonObj, buildingMode);
+    }
+    if (component instanceof SingleElementComponent || component instanceof MultiElementComponent || component instanceof CedarTemplate) {
+      const iterableComponent: ElementComponent = component as ElementComponent;
+      const targetName = iterableComponent.name;
+      if (component instanceof MultiElementComponent) {
+        const multiElement: MultiElementComponent = component as MultiElementComponent;
+        dataObject[targetName] = DataObjectUtil.getEmptyList();
+        if (multiElement.multiInfo.minItems > 0) {
+          const dummyTargetObject: object = DataObjectUtil.getEmptyObject();
+          const subTemplate = DataObjectUtil.getSafeSubTemplate(templateJsonObj, targetName);
+          for (const childComponent of iterableComponent.children) {
+            DataObjectBuilderHandler.buildRecursively(childComponent, dummyTargetObject, subTemplate, buildingMode);
+          }
+          for (let idx = 0; idx < multiElement.multiInfo.minItems; idx++) {
+            const clone = _.cloneDeep(dummyTargetObject as any);
+            dataObject[targetName].push(clone);
+          }
+        }
+      } else {
+        dataObject[targetName] = DataObjectUtil.getEmptyObject();
+        const subTemplate = DataObjectUtil.getSafeSubTemplate(templateJsonObj, targetName);
+        for (const childComponent of iterableComponent.children) {
+          DataObjectBuilderHandler.buildRecursively(childComponent, dataObject[targetName], subTemplate, buildingMode);
+        }
+      }
+      ret = dataObject[targetName];
+    }
+    if (component instanceof SingleFieldComponent || component instanceof MultiFieldComponent) {
+      const nonIterableComponent = component as FieldComponent;
+      const targetName = nonIterableComponent.name;
+      if (component instanceof MultiFieldComponent) {
+        const multiField: MultiFieldComponent = component as MultiFieldComponent;
+        dataObject[targetName] = DataObjectUtil.getEmptyList();
+        if (multiField.multiInfo.minItems > 0) {
+          const subTemplate = DataObjectUtil.getSafeSubTemplate(templateJsonObj, targetName);
+          for (let idx = 0; idx < multiField.multiInfo.minItems; idx++) {
+            dataObject[targetName].push(DataObjectUtil.getEmptyValueWrapper(subTemplate, buildingMode));
+          }
+        }
+      } else {
+        const subTemplate = DataObjectUtil.getSafeSubTemplate(templateJsonObj, targetName);
+        dataObject[targetName] = DataObjectUtil.getEmptyValueWrapper(subTemplate, buildingMode);
+      }
+      ret = dataObject[targetName];
+    }
+    return ret;
+  }
+
+  public static setCurrentCountToMinRecursively(component: CedarComponent, path: string[]): void {
+    if (path.length === 0) {
+      return;
+    }
+    const firstPath = path[0];
+    const remainingPath = path.slice(1);
+    if (component instanceof SingleElementComponent) {
+      const singleElement: SingleElementComponent = component as SingleElementComponent;
+      for (const childComponent of singleElement.children) {
+        DataObjectBuilderHandler.setCurrentCountToMinRecursively(childComponent, remainingPath);
+      }
+    } else if (component instanceof MultiElementComponent) {
+      const multiElement: MultiElementComponent = component as MultiElementComponent;
+      const min = multiElement.multiInfo.getSafeMinItems();
+      if (min === 0) {
+        multiElement.multiInfo.minItems = 1;
+      }
+      for (const childComponent of multiElement.children) {
+        DataObjectBuilderHandler.setCurrentCountToMinRecursively(childComponent, remainingPath);
+      }
+    } else if (component instanceof MultiFieldComponent) {
+      const multiField: MultiFieldComponent = component as MultiFieldComponent;
+      const min = multiField.multiInfo.getSafeMinItems();
+      if (min === 0) {
+        multiField.multiInfo.minItems = 1;
+      }
+    }
+  }
+
+  private static addContext(component: CedarComponent, dataObject: InstanceExtractData, templateJsonObj: CedarInputTemplate, buildingMode: DataObjectBuildingMode): void {
+    if (buildingMode === DataObjectBuildingMode.INCLUDE_CONTEXT) {
+      const props = templateJsonObj[JsonSchema.properties];
+      const propsContext = props[JsonSchema.atContext];
+      const propsContextProps = propsContext[JsonSchema.properties];
+      const p: object = {};
+      for (const key of Object.keys(propsContextProps)) {
+        p[key] = DataObjectUtil.convertTemplateContextNode(propsContextProps[key]);
+      }
+      dataObject[JsonSchema.atContext] = p;
+    }
+  }
+
+  injectMultiInstanceService(multiInstanceObjectService: MultiInstanceObjectHandler): void {
+    this.multiInstanceObjectService = multiInstanceObjectService;
+  }
+
+  buildNewExtractDataObject(templateRepresentation: TemplateComponent, templateJsonObj: CedarInputTemplate): InstanceExtractData {
+    this.templateJsonObj = templateJsonObj;
+    this.templateRepresentation = templateRepresentation;
+    this.dataObject = new InstanceExtractData();
+    this.buildNewByIterating(this.dataObject, templateJsonObj, DataObjectBuildingMode.EXCLUDE_CONTEXT);
+    return this.dataObject;
+  }
+
+  buildNewFullDataObject(templateRepresentation: TemplateComponent, templateJsonObj: CedarInputTemplate): InstanceFullData {
+    this.templateJsonObj = templateJsonObj;
+    this.templateRepresentation = templateRepresentation;
+    this.dataObjectFull = new InstanceFullData();
+    this.buildNewByIterating(this.dataObjectFull, templateJsonObj, DataObjectBuildingMode.INCLUDE_CONTEXT);
+    return this.dataObjectFull;
+  }
+
+  private buildNewByIterating(dataObject: InstanceExtractData, templateJsonObj: CedarInputTemplate, buildingMode: DataObjectBuildingMode): void {
+    if (this.templateRepresentation != null && this.templateRepresentation.children != null) {
+      for (const childComponent of this.templateRepresentation.children) {
+        DataObjectBuilderHandler.buildRecursively(childComponent, dataObject, templateJsonObj, buildingMode);
+      }
+    }
+  }
+
+}