cedar-embeddable-editor 0.9.0

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

@@ -0,0 +1,270 @@
+import {MultiInstanceObjectInfo} from '../models/info/multi-instance-object-info.model';
+import {CedarComponent} from '../models/component/cedar-component.model';
+import {SingleElementComponent} from '../models/element/single-element-component.model';
+import {CedarTemplate} from '../models/template/cedar-template.model';
+import {MultiElementComponent} from '../models/element/multi-element-component.model';
+import {DataContext} from '../util/data-context';
+import {MultiInstanceObjectHandler} from './multi-instance-object.handler';
+import {SingleFieldComponent} from '../models/field/single-field-component.model';
+import {JsonSchema} from '../models/json-schema.model';
+import {MultiFieldComponent} from '../models/field/multi-field-component.model';
+import {FieldComponent} from '../models/component/field-component.model';
+import {InstanceExtractData} from '../models/instance-extract-data.model';
+import {CedarModel} from '../models/cedar-model.model';
+import {DataObjectUtil} from '../util/data-object-util';
+import {InputType} from '../models/input-type.model';
+
+export class DataObjectDataValueHandler {
+
+  readonly DATA_SUBOBJECT_KEY = 'dataSubObject';
+  readonly CHILD_COMPONENT_KEY = 'childComponent';
+  readonly PARENT_DATA_SUBOBJECT_KEY = 'parentDataSubObject';
+  readonly REMAINING_PATH_KEY = 'remainingPath';
+
+
+  private injectValue(target: InstanceExtractData, valueObject: object): void {
+    if (valueObject.hasOwnProperty(JsonSchema.atValue)) {
+      target[JsonSchema.atValue] = valueObject[JsonSchema.atValue];
+    } else {
+      delete target[JsonSchema.atValue];
+      target[JsonSchema.atId] = valueObject[JsonSchema.atId];
+      target[JsonSchema.rdfsLabel] = valueObject[JsonSchema.rdfsLabel];
+    }
+  }
+
+  private injectArrayValue(target: InstanceExtractData, valueArray: object[]): void {
+    (target as Array<object>).length = 0;
+    (target as Array<object>).push(...valueArray);
+  }
+
+  private injectAttributeValue(dataObject: InstanceExtractData, currentIndex: number, parentDataObject: InstanceExtractData,
+                               component: CedarComponent, valueObject: object): void {
+    const oldName = dataObject[currentIndex];
+    let newName = valueObject[JsonSchema.reservedAttributeName];
+
+    if (!newName || this.isDuplicateAttributeName(newName, dataObject, parentDataObject, currentIndex)) {
+      newName = this.getDefaultAttributeName(dataObject, parentDataObject, currentIndex);
+    }
+
+    const oldNameIndex = (dataObject as Array<string>).indexOf(oldName);
+    dataObject[currentIndex] = newName;
+    const needsDeleting = (oldName && newName !== oldName && oldNameIndex === currentIndex);
+
+    if (needsDeleting) {
+      // deleting parent old name entry
+      delete parentDataObject[oldName];
+    }
+
+    parentDataObject[newName] = valueObject[JsonSchema.reservedAttributeValue];
+
+    if (parentDataObject.hasOwnProperty(JsonSchema.atContext)) {
+      if (parentDataObject[JsonSchema.atContext].hasOwnProperty(component.name)) {
+        delete parentDataObject[JsonSchema.atContext][component.name];
+      }
+
+      let elemId = '';
+
+      if (needsDeleting) {
+        elemId = parentDataObject[JsonSchema.atContext][oldName];
+        delete parentDataObject[JsonSchema.atContext][oldName];
+      }
+
+      if (!parentDataObject[JsonSchema.atContext].hasOwnProperty(newName)) {
+        if (!elemId || elemId.length === 0) {
+          elemId = CedarModel.baseTemplateURL + '/' +
+            JsonSchema.properties + '/' + DataObjectUtil.generateGUID();
+        }
+        parentDataObject[JsonSchema.atContext][newName] = elemId;
+      }
+    }
+  }
+
+  private setDataPathValueRecursively(dataObject: InstanceExtractData, parentDataObject: InstanceExtractData, component: CedarComponent, multiInstanceObjectService: MultiInstanceObjectHandler, path: string[], valueObject: object): void {
+    if (path.length === 0) {
+      if (component instanceof SingleFieldComponent) {
+        this.injectValue(dataObject, valueObject);
+      } else {
+        const multiField = component as MultiFieldComponent;
+        const multiInstanceInfo: MultiInstanceObjectInfo = multiInstanceObjectService.getMultiInstanceInfoForComponent(multiField);
+        const currentIndex = multiInstanceInfo.currentIndex;
+
+        if (valueObject.hasOwnProperty(JsonSchema.reservedAttributeName)) {
+          this.injectAttributeValue(dataObject, currentIndex, parentDataObject, component, valueObject);
+        } else if (valueObject instanceof Array) {
+          this.injectArrayValue(dataObject, valueObject);
+        } else {
+          this.injectValue(dataObject[currentIndex], valueObject);
+        }
+      }
+    } else {
+      const downstreamObjects = this.getDownstreamObjects(dataObject, component, multiInstanceObjectService, path);
+      const dataSubObjectKey = this.DATA_SUBOBJECT_KEY;
+      const childComponentKey = this.CHILD_COMPONENT_KEY;
+      const parentDataSubObjectKey = this.PARENT_DATA_SUBOBJECT_KEY;
+      const remainingPathKey = this.REMAINING_PATH_KEY;
+      this.setDataPathValueRecursively(downstreamObjects[dataSubObjectKey], downstreamObjects[parentDataSubObjectKey],
+        downstreamObjects[childComponentKey], multiInstanceObjectService, downstreamObjects[remainingPathKey], valueObject);
+    }
+  }
+
+  private deleteAttributeValueRecursively(dataObject: InstanceExtractData, parentDataObject: InstanceExtractData,
+                                          component: CedarComponent, multiInstanceObjectService: MultiInstanceObjectHandler,
+                                          path: string[], valueObject: object): void {
+    if (path.length === 0) {
+      const name = valueObject[JsonSchema.reservedAttributeName];
+      delete parentDataObject[name];
+
+      if (parentDataObject.hasOwnProperty(JsonSchema.atContext)) {
+        delete parentDataObject[JsonSchema.atContext][name];
+      }
+    } else {
+      const downstreamObjects = this.getDownstreamObjects(dataObject, component, multiInstanceObjectService, path);
+      const dataSubObjectKey = this.DATA_SUBOBJECT_KEY;
+      const childComponentKey = this.CHILD_COMPONENT_KEY;
+      const parentDataSubObjectKey = this.PARENT_DATA_SUBOBJECT_KEY;
+      const remainingPathKey = this.REMAINING_PATH_KEY;
+      this.deleteAttributeValueRecursively(downstreamObjects[dataSubObjectKey], downstreamObjects[parentDataSubObjectKey],
+        downstreamObjects[childComponentKey], multiInstanceObjectService, downstreamObjects[remainingPathKey], valueObject);
+    }
+  }
+
+  private getDownstreamObjects(dataObject: InstanceExtractData, component: CedarComponent,
+                               multiInstanceObjectService: MultiInstanceObjectHandler, path: string[]): object {
+    const obj = {};
+    const firstPath = path[0];
+    const remainingPath = path.slice(1);
+    let childComponent: CedarComponent = null;
+    let dataSubObject = null;
+    let parentDataSubObject = null;
+
+    if (component instanceof SingleElementComponent) {
+      childComponent = (component as SingleElementComponent).getChildByName(firstPath);
+      dataSubObject = dataObject[firstPath];
+      parentDataSubObject = dataObject;
+    } else if (component instanceof CedarTemplate) {
+      childComponent = (component as CedarTemplate).getChildByName(firstPath);
+      dataSubObject = dataObject[firstPath];
+      parentDataSubObject = dataObject;
+    } else if (component instanceof MultiElementComponent) {
+      const multiElement = component as MultiElementComponent;
+      const multiInstanceInfo: MultiInstanceObjectInfo = multiInstanceObjectService.getMultiInstanceInfoForComponent(multiElement);
+      const currentIndex = multiInstanceInfo.currentIndex;
+      childComponent = multiElement.getChildByName(firstPath);
+      dataSubObject = dataObject[currentIndex][firstPath];
+      parentDataSubObject = dataObject[currentIndex];
+    }
+    const dataSubObjectKey = this.DATA_SUBOBJECT_KEY;
+    const childComponentKey = this.CHILD_COMPONENT_KEY;
+    const parentDataSubObjectKey = this.PARENT_DATA_SUBOBJECT_KEY;
+    const remainingPathKey = this.REMAINING_PATH_KEY;
+    obj[dataSubObjectKey] = dataSubObject;
+    obj[childComponentKey] = childComponent;
+    obj[parentDataSubObjectKey] = parentDataSubObject;
+    obj[remainingPathKey] = remainingPath;
+
+    return obj;
+  }
+
+  private isDuplicateAttributeName(name: string, dataObject: InstanceExtractData, parentDataObject: InstanceExtractData, currentIndex: number): boolean {
+    const ind = (dataObject as Array<string>).indexOf(name);
+
+    // completely new name, check if parent object's names conflict
+    if (ind < 0) {
+      return parentDataObject.hasOwnProperty(name);
+    }
+    // name has not changed
+    else if (ind === currentIndex) {
+      return false;
+    }
+    // name changed but already exists in a different slot
+    return true;
+  }
+
+  private getDefaultAttributeName(dataObject: InstanceExtractData, parentDataObject: InstanceExtractData, currentIndex: number): string {
+    let nameIndex = currentIndex + 1;
+    let defName = JsonSchema.reservedDefaultAttributeName + nameIndex;
+
+    while (this.isDuplicateAttributeName(defName, dataObject, parentDataObject, currentIndex) && nameIndex < 1000) {
+      nameIndex++;
+      defName = JsonSchema.reservedDefaultAttributeName + nameIndex;
+    }
+
+    return defName;
+  }
+
+  changeValue(dataContext: DataContext, component: FieldComponent, multiInstanceObjectService: MultiInstanceObjectHandler, value: string): void {
+    const path = component.path;
+    const valueObject = {};
+    if (component.basicInfo.inputType === InputType.link){
+      valueObject[JsonSchema.atId] = value;
+    } else {
+      valueObject[JsonSchema.atValue] = value;
+    }
+    this.setDataPathValueRecursively(dataContext.instanceExtractData, null, dataContext.templateRepresentation, multiInstanceObjectService, path, valueObject);
+    this.setDataPathValueRecursively(dataContext.instanceFullData, null, dataContext.templateRepresentation, multiInstanceObjectService, path, valueObject);
+  }
+
+  changeListValue(dataContext: DataContext, component: FieldComponent, multiInstanceObjectService: MultiInstanceObjectHandler, value: string[]): void {
+    const path = component.path;
+    const valueArray = [];
+
+    if (value.length === 0) {
+      value = [null];
+    }
+
+    for (const val of value) {
+      const obj = {};
+      obj[JsonSchema.atValue] = val;
+      valueArray.push(obj);
+    }
+
+    this.setDataPathValueRecursively(dataContext.instanceExtractData, null, dataContext.templateRepresentation, multiInstanceObjectService, path, valueArray);
+    this.setDataPathValueRecursively(dataContext.instanceFullData, null, dataContext.templateRepresentation, multiInstanceObjectService, path, valueArray);
+  }
+
+  changeAttributeValue(dataContext: DataContext, component: FieldComponent,
+                       multiInstanceObjectService: MultiInstanceObjectHandler, key: string, value: string): void {
+    const path = component.path;
+    const valueObject = {};
+    const obj = {};
+
+    if (value && value.length === 0) {
+      value = null;
+    }
+
+    obj[JsonSchema.atValue] = value;
+    valueObject[JsonSchema.reservedAttributeName] = key;
+    valueObject[JsonSchema.reservedAttributeValue] = obj;
+
+    this.setDataPathValueRecursively(dataContext.instanceExtractData, null, dataContext.templateRepresentation, multiInstanceObjectService, path, valueObject);
+    this.setDataPathValueRecursively(dataContext.instanceFullData, null, dataContext.templateRepresentation, multiInstanceObjectService, path, valueObject);
+  }
+
+  deleteAttributeValue(dataContext: DataContext, component: FieldComponent,
+                       multiInstanceObjectService: MultiInstanceObjectHandler, key: string): void {
+    if (!key) {
+      return;
+    }
+
+    const path = component.path;
+    const valueObject = {};
+    valueObject[JsonSchema.reservedAttributeName] = key;
+
+    this.deleteAttributeValueRecursively(dataContext.instanceExtractData, null, dataContext.templateRepresentation, multiInstanceObjectService, path, valueObject);
+    this.deleteAttributeValueRecursively(dataContext.instanceFullData, null, dataContext.templateRepresentation, multiInstanceObjectService, path, valueObject);
+  }
+
+  changeControlledValue(dataContext: DataContext, component: FieldComponent, multiInstanceObjectService: MultiInstanceObjectHandler, atId: string, prefLabel: string): void {
+    const path = component.path;
+    const valueObject = {};
+
+    if (atId) {
+      valueObject[JsonSchema.atId] = atId;
+      valueObject[JsonSchema.rdfsLabel] = prefLabel;
+    }
+
+    this.setDataPathValueRecursively(dataContext.instanceExtractData, null, dataContext.templateRepresentation, multiInstanceObjectService, path, valueObject);
+    this.setDataPathValueRecursively(dataContext.instanceFullData, null, dataContext.templateRepresentation, multiInstanceObjectService, path, valueObject);
+  }
+
+}

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

@@ -0,0 +1,145 @@
+import * as _ from 'lodash-es';
+import {MultiComponent} from '../models/component/multi-component.model';
+import {MultiInstanceObjectInfo} from '../models/info/multi-instance-object-info.model';
+import {CedarComponent} from '../models/component/cedar-component.model';
+import {SingleElementComponent} from '../models/element/single-element-component.model';
+import {CedarTemplate} from '../models/template/cedar-template.model';
+import {MultiElementComponent} from '../models/element/multi-element-component.model';
+import {DataContext} from '../util/data-context';
+import {MultiInstanceObjectHandler} from './multi-instance-object.handler';
+import {DataObjectBuilderHandler} from './data-object-builder.handler';
+import {InstanceExtractData} from '../models/instance-extract-data.model';
+import {CedarInputTemplate} from '../models/cedar-input-template.model';
+import {DataObjectBuildingMode} from '../models/enum/data-object-building-mode.model';
+import {TemplateComponent} from '../models/template/template-component.model';
+
+
+export class DataObjectStructureHandler {
+
+  public getDataPathNodeRecursively(dataObject: InstanceExtractData, component: CedarComponent, path: string[],
+                                    multiInstanceObjectService: MultiInstanceObjectHandler): object {
+    if (path.length === 0) {
+      return dataObject;
+    } else {
+      const firstPath = path[0];
+      const remainingPath = path.slice(1);
+      let childComponent: CedarComponent = null;
+      let dataSubObject = null;
+      if (component instanceof SingleElementComponent) {
+        childComponent = (component as SingleElementComponent).getChildByName(firstPath);
+        dataSubObject = dataObject[firstPath];
+      } else if (component instanceof CedarTemplate) {
+        childComponent = (component as CedarTemplate).getChildByName(firstPath);
+        dataSubObject = dataObject[firstPath];
+      } else if (component instanceof MultiElementComponent) {
+        const multiElement = component as MultiElementComponent;
+        const multiInstanceInfo: MultiInstanceObjectInfo = multiInstanceObjectService.getMultiInstanceInfoForComponent(multiElement);
+
+        if (!multiInstanceInfo) {
+          return null;
+        }
+        const currentIndex = multiInstanceInfo.currentIndex;
+        childComponent = multiElement.getChildByName(firstPath);
+        if (dataObject.hasOwnProperty(currentIndex)) {
+          dataSubObject = dataObject[currentIndex][firstPath];
+        }
+      }
+      return this.getDataPathNodeRecursively(dataSubObject, childComponent, remainingPath, multiInstanceObjectService);
+    }
+  }
+
+  public getParentDataPathNodeRecursively(dataObject: InstanceExtractData,
+                                          parentDataObject: InstanceExtractData, component: CedarComponent,
+                                          path: string[], multiInstanceObjectService: MultiInstanceObjectHandler): object {
+    if (path.length === 0) {
+      return parentDataObject;
+    } else {
+      const firstPath = path[0];
+      const remainingPath = path.slice(1);
+      let childComponent: CedarComponent = null;
+      let dataSubObject = null;
+      let parentDataSubObject = null;
+
+      if (component instanceof SingleElementComponent) {
+        childComponent = (component as SingleElementComponent).getChildByName(firstPath);
+        dataSubObject = dataObject[firstPath];
+        parentDataSubObject = dataObject;
+      } else if (component instanceof CedarTemplate) {
+        childComponent = (component as CedarTemplate).getChildByName(firstPath);
+        dataSubObject = dataObject[firstPath];
+        parentDataSubObject = dataObject;
+      } else if (component instanceof MultiElementComponent) {
+        const multiElement = component as MultiElementComponent;
+        const multiInstanceInfo: MultiInstanceObjectInfo = multiInstanceObjectService.getMultiInstanceInfoForComponent(multiElement);
+        const currentIndex = multiInstanceInfo.currentIndex;
+
+        if (currentIndex < 0) {
+          return null;
+        }
+        childComponent = multiElement.getChildByName(firstPath);
+        dataSubObject = dataObject[currentIndex][firstPath];
+        parentDataSubObject = dataObject[currentIndex];
+      }
+      return this.getParentDataPathNodeRecursively(dataSubObject, parentDataSubObject, childComponent, remainingPath, multiInstanceObjectService);
+    }
+  }
+
+  multiInstanceItemAdd(dataContext: DataContext, component: MultiComponent, multiInstanceObjectService: MultiInstanceObjectHandler): void {
+    const multiInstanceInfo: MultiInstanceObjectInfo = multiInstanceObjectService.getMultiInstanceInfoForComponent(component);
+    const instanceExtractData: object = dataContext.instanceExtractData;
+    const instanceFullData: object = dataContext.instanceFullData;
+    const templateRepresentation: TemplateComponent = dataContext.templateRepresentation;
+    const templateInput: CedarInputTemplate = dataContext.templateInput;
+    this.performItemAdd(instanceExtractData, templateRepresentation, component, multiInstanceObjectService, multiInstanceInfo, null);
+    this.performItemAdd(instanceFullData, templateRepresentation, component, multiInstanceObjectService, multiInstanceInfo, templateInput);
+  }
+
+  private performItemAdd(instanceObject: InstanceExtractData, templateRepresentation: TemplateComponent, component: MultiComponent, multiInstanceObjectService: MultiInstanceObjectHandler, multiInstanceInfo: MultiInstanceObjectInfo, templateInput: CedarInputTemplate): void {
+    const dataObject = {};
+    const cloneComponent = _.cloneDeep(component);
+    DataObjectBuilderHandler.setCurrentCountToMinRecursively(cloneComponent, component.path);
+    let subTemplate = null;
+    if (templateInput != null) {
+      const shorterPath = component.path.slice(0, component.path.length - 1);
+      subTemplate = DataObjectBuilderHandler.getSubTemplate(templateInput, shorterPath);
+    }
+    DataObjectBuilderHandler.buildRecursively(cloneComponent, dataObject, subTemplate, DataObjectBuildingMode.INCLUDE_CONTEXT);
+    const newDataObject = dataObject[component.name][0];
+    const currentNodeAny = this.getDataPathNodeRecursively(instanceObject, templateRepresentation, component.path, multiInstanceObjectService);
+    const currentNodeArray = currentNodeAny as [];
+    currentNodeArray.splice(multiInstanceInfo.currentIndex + 1, 0, newDataObject as never);
+  }
+
+  multiInstanceItemCopy(dataContext: DataContext, component: MultiComponent, multiInstanceObjectService: MultiInstanceObjectHandler): void {
+    const multiInstanceInfo: MultiInstanceObjectInfo = multiInstanceObjectService.getMultiInstanceInfoForComponent(component);
+    const instanceExtractData: object = dataContext.instanceExtractData;
+    const instanceFullData: object = dataContext.instanceFullData;
+    const templateRepresentation: TemplateComponent = dataContext.templateRepresentation;
+    this.performItemCopy(instanceExtractData, templateRepresentation, component.path, multiInstanceObjectService, multiInstanceInfo);
+    this.performItemCopy(instanceFullData, templateRepresentation, component.path, multiInstanceObjectService, multiInstanceInfo);
+  }
+
+  private performItemCopy(instanceObject: InstanceExtractData, templateRepresentation: TemplateComponent, path: string[], multiInstanceObjectService: MultiInstanceObjectHandler, multiInstanceInfo: MultiInstanceObjectInfo): void {
+    const currentNodeAny = this.getDataPathNodeRecursively(instanceObject, templateRepresentation, path, multiInstanceObjectService);
+    const currentNodeArray = currentNodeAny as [];
+    const sourceItem = currentNodeArray[multiInstanceInfo.currentIndex];
+    const cloneItem = _.cloneDeep(sourceItem as any);
+    currentNodeArray.splice(multiInstanceInfo.currentIndex + 1, 0, cloneItem as never);
+  }
+
+  multiInstanceItemDelete(dataContext: DataContext, component: MultiComponent, multiInstanceObjectService: MultiInstanceObjectHandler): void {
+    const multiInstanceInfo: MultiInstanceObjectInfo = multiInstanceObjectService.getMultiInstanceInfoForComponent(component);
+    const instanceExtractData: object = dataContext.instanceExtractData;
+    const instanceFullData: object = dataContext.instanceFullData;
+    const templateRepresentation: TemplateComponent = dataContext.templateRepresentation;
+    this.performItemDelete(instanceExtractData, templateRepresentation, component.path, multiInstanceObjectService, multiInstanceInfo);
+    this.performItemDelete(instanceFullData, templateRepresentation, component.path, multiInstanceObjectService, multiInstanceInfo);
+  }
+
+  private performItemDelete(instanceObject: InstanceExtractData, templateRepresentation: TemplateComponent, path: string[], multiInstanceObjectService: MultiInstanceObjectHandler, multiInstanceInfo: MultiInstanceObjectInfo): void {
+    const currentNodeAny = this.getDataPathNodeRecursively(instanceObject, templateRepresentation, path, multiInstanceObjectService);
+    const currentNodeArray = currentNodeAny as [];
+    currentNodeArray.splice(multiInstanceInfo.currentIndex, 1);
+  }
+
+}