@eo-sdk/client 10.0.0-beta.2 → 10.0.0-beta.4

package/esm2020/app/eo-framework/object-form/object-form-helper.service.mjs

@@ -1,17 +1,75 @@
+import { DatePipe } from '@angular/common';
 import { Injectable } from '@angular/core';
+import { Validators } from '@angular/forms';
+import { RangeValue, SearchService, Utils } from '@eo-sdk/core';
+import { forkJoin, of } from 'rxjs';
+import { debounceTime, tap } from 'rxjs/operators';
 import { FormValidation } from './object-form/form-validation/form-validation';
-import { ObjectFormControlWrapper } from './object-form/object-form-control-wrapper';
 import { ObjectFormControl } from './object-form/object-form-control';
-import { RangeValue } from '@eo-sdk/core';
-import { DatePipe } from '@angular/common';
+import { ObjectFormControlWrapper } from './object-form/object-form-control-wrapper';
+import { ObjectFormGroup } from './object-form/object-form-group.model';
+import { ObjectFormScriptingScope } from './object-form/object-form-script/object-form-scripting-scope';
 import * as i0 from "@angular/core";
 import * as i1 from "@eo-sdk/core";
+import * as i2 from "../../eo-framework-core/references/reference.service";
+import * as i3 from "../../eo-framework-core/api/plugins.service";
 export class ObjectFormHelperService {
-    constructor(logger, systemService) {
+    constructor(logger, referenceService, searchService, pluginService, systemService) {
         this.logger = logger;
+        this.referenceService = referenceService;
+        this.searchService = searchService;
+        this.pluginService = pluginService;
         this.systemService = systemService;
         this.datePipe = new DatePipe('en');
     }
+    /**
+     * Generates a reactive form based on a form model that may also include form scripts.
+     * @param formOptions `ObjectFormOptions` defining the form
+     * @param formScriptService Instance of a `ObjectFormScriptService`. This service is supposed to be
+     * scoped to the component rendering the form (providers array in component decorator).
+     * @param isInnerTableForm whether or not the form is part of another form (as is with table edit forms)
+     * @returns An `FormGenResult` object
+     */
+    buildReactiveForm(formOptions, formScriptService, isInnerTableForm) {
+        const _scope = {
+            gCount: 0,
+            formOptions,
+            isInnerTableForm,
+            initialValidators: {},
+            formGenResult: {
+                formControls: {},
+                formModel: {},
+                controlValueSubscriptions: [],
+                scriptingScope: undefined,
+                scriptModel: {},
+                form: null
+            }
+        };
+        const formModel = this._dataToForm(_scope, formOptions.formModel, formOptions.data);
+        _scope.formGenResult.formModel = formModel;
+        if (!formModel)
+            return;
+        // if a script is available, we'll init the form scripting for the
+        // current form
+        let scriptingScope;
+        if (_scope.isInnerTableForm || (formModel.script && formModel.script.length > 0)) {
+            this.logger.debug('adding form scripting scope');
+            scriptingScope = new ObjectFormScriptingScope(formModel.situation, this._getScriptingModelChanged(_scope), this.pluginService.getApi(), _scope.isInnerTableForm);
+            scriptingScope.objectId = formOptions.objectId;
+        }
+        _scope.formGenResult.scriptingScope = scriptingScope;
+        let form = new ObjectFormGroup({});
+        if (formModel.elements[0] && formModel.elements[0].elements) {
+            this._addFormControl(_scope, form, formModel.elements[0], 'core');
+        }
+        if (formModel.elements[1] && formModel.elements[1].elements) {
+            this._addFormControl(_scope, form, formModel.elements[1], 'data');
+        }
+        _scope.formGenResult.form = form;
+        this._initValidators(_scope.formGenResult.form, _scope);
+        this._initScriptingScope(_scope, formScriptService);
+        return _scope.formGenResult;
+    }
     /**
      * Converts a form element object to an ObjectFormControlWrapper which then can be used to
      * render a from control. Result can be used as input for FormElementComponent.
@@ -167,10 +225,451 @@ export class ObjectFormHelperService {
         }
         return value;
     }
+    // Functions involved in building an object form
+    /**
+     * Recursive method adding a new UntypedFormControl (group or control) to a parent form group
+     *
+     * @param parentGroup - the parent group to add the control to
+     * @param formElement - the enaio form model element to create the child control from
+     * @param [useName] - use this name instead of the one from the model
+     */
+    _addFormControl(scope, parentGroup, formElement, useName) {
+        let ctrl;
+        let name;
+        // add a form group
+        if (formElement.type === 'o2mGroup' || formElement.type === 'o2mGroupStack') {
+            // do not add groups that are empty
+            if (!formElement.elements || formElement.elements.length === 0) {
+                this.logger.error('Found empty form group', formElement);
+                return;
+            }
+            ctrl = new ObjectFormGroup({});
+            ctrl._eoFormGroup = {
+                label: formElement.label,
+                //layoutgroup: formElement.layoutgroup,
+                layout: formElement.layout,
+                type: formElement.type
+            };
+            if (useName === 'core' || useName === 'data') {
+                ctrl._eoFormGroup.label = useName;
+            }
+            for (let e of formElement.elements) {
+                this._addFormControl(scope, ctrl, e);
+            }
+            name = useName || 'fg' + scope.gCount++;
+        }
+        else {
+            // add form control
+            // To be able to integrate recursive form controls into the main form,
+            // we have to wrap them in a form group
+            ctrl = new ObjectFormControlWrapper({});
+            ctrl._eoFormControlWrapper = {
+                // the name of the wrapped UntypedFormControl
+                controlName: formElement.name,
+                situation: scope.formOptions.formModel.situation
+            };
+            if (scope.formOptions.formModel.situation === 'SEARCH' && formElement.value === null) {
+                formElement.isNotSetValue = true;
+            }
+            // do not set a reference as the form controls value
+            // otherwise we could not reset the form
+            let value;
+            if (Array.isArray(formElement.value)) {
+                // copy by value for arrays of objects (e.g. table data)
+                value = [];
+                formElement.value.forEach((o) => {
+                    value.push(Utils.formDataParse(Utils.formDataStringify(o)));
+                });
+            }
+            else {
+                value = formElement.value;
+            }
+            // for codesystem elements add entries if not yet provided
+            if (formElement.type === 'CODESYSTEM' && !formElement.codesystem.entries) {
+                formElement.codesystem = this.systemService.getCodesystem(formElement.codesystem.id);
+            }
+            // create the actual form control
+            let controlDisabled = scope.formOptions.disabled || !!formElement.readonly;
+            let formControl = new ObjectFormControl({
+                value: value,
+                disabled: controlDisabled
+            });
+            formElement.readonly = controlDisabled;
+            formControl._eoFormElement = formElement;
+            scope.formGenResult.formControls[formElement.name] = formControl;
+            if (formElement.type === 'CODESYSTEM' || (formElement.type === 'STRING' && formElement.classification === 'selector')) {
+                formControl._eoFormElement.applyFilter = (func) => {
+                    formControl._eoFormElement.filterFunction = func;
+                };
+                formControl._eoFormElement.applyDisablingFilter = (func) => {
+                    formControl._eoFormElement.disablingFilterFunction = func;
+                };
+            }
+            if (formElement.type === 'STRING' && formElement.classification === 'selector') {
+                formControl._eoFormElement.setList = (listObject) => {
+                    formControl._eoFormElement.list = listObject;
+                };
+            }
+            if (formElement.type === 'ORGANIZATION') {
+                formControl._eoFormElement.setFilter = (filterObject) => {
+                    formControl._eoFormElement.filter = filterObject;
+                };
+            }
+            if (formElement.type === 'TABLE') {
+                formControl._eoFormElement.object = scope.formOptions.object;
+            }
+            if (formElement.type === 'REFERENCE') {
+                formControl._eoFormElement.setQueryFilters = (queryFiltersObject, objectTypes) => {
+                    formControl._eoFormElement.queryFilters = queryFiltersObject;
+                    formControl._eoFormElement.objectTypesFilter = objectTypes;
+                };
+            }
+            if (scope.formOptions.formModel.situation === 'SEARCH') {
+                // in search situation even readonly fields should be editable ...
+                formControl._eoFormElement.readonly = false;
+                // ... and required makes no sense here
+                formControl._eoFormElement.required = false;
+            }
+            // remove empty descriptions
+            let desc = formControl._eoFormElement.description;
+            if (desc && desc.trim().length === 0) {
+                formControl._eoFormElement.description = null;
+            }
+            // add the form element to the script model that will be injected into
+            // the forms scripting scope later on
+            scope.formGenResult.scriptModel[formElement.name] = formControl._eoFormElement;
+            // apply change listener to the form control, that will trigger
+            // the form elements onChange listener
+            let controlWatch = ctrl.valueChanges.pipe(debounceTime(formElement.type === 'TABLE' ? 0 : 500));
+            controlWatch.subscribe((v) => {
+                if (formControl._eoFormElement.type === 'REFERENCE') {
+                    this._getDataMeta(formControl._eoFormElement, v[formControl._eoFormElement.name]).subscribe(m => {
+                        if (m) {
+                            formControl._eoFormElement.dataMeta = formControl._eoFormElement.multiselect ? m : m[0];
+                        }
+                        else {
+                            delete formControl._eoFormElement.dataMeta;
+                        }
+                    });
+                }
+                if (scope.formGenResult.scriptingScope) {
+                    scope.formGenResult.scriptingScope.modelChanged(v);
+                }
+            });
+            scope.formGenResult.controlValueSubscriptions.push(controlWatch);
+            ctrl.addControl(formElement.name, formControl);
+            name = 'fg_' + formElement.name;
+        }
+        parentGroup.addControl(name, ctrl);
+    }
+    /**
+     * Merge data into a form model.
+     *
+     * @param model - form model
+     * @param data - data object or array of SearchFilter objects in case of a search form
+     */
+    _dataToForm(scope, model, data) {
+        if (model && data) {
+            this._setElementValues(scope, model.elements, data);
+        }
+        return model;
+    }
+    // recursive method for adding values to model elements
+    _setElementValues(scope, elements, data) {
+        elements.forEach(element => {
+            if (this._hasValue(data, element)) {
+                element.value = this._getValue(scope, data, element);
+                if (element.value) {
+                    // add meta data for some of the types
+                    this._fetchMetaData(scope, data, element);
+                }
+            }
+            else {
+                delete element.value;
+            }
+            if (element.type !== 'TABLE' && element.elements && element.elements.length > 0) {
+                this._setElementValues(scope, element.elements, data);
+            }
+        });
+    }
+    // in some cases required meta data may not be available on the element itself
+    // so they have to be fetched and added to the element for the form to be able
+    // to render the element correctly
+    _fetchMetaData(scope, data, element) {
+        if (scope.formOptions.formModel.situation === 'SEARCH') {
+            // todo: how to fetch meta data in search situation
+        }
+        else {
+            if (element.type === 'ORGANIZATION' && data[element.name + '_meta']) {
+                element.dataMeta = data[element.name + '_meta'];
+            }
+            else if (element.type === 'CODESYSTEM' && data[element.name + '_meta']) {
+                element.dataMeta = data[element.name + '_meta'];
+                element.defaultrepresentation = data[element.name + '_meta'].defaultrepresentation;
+            }
+            else if (element.type === 'REFERENCE' && data[element.name + '_meta']) {
+                element.dataMeta = data[element.name + '_meta'];
+            }
+        }
+    }
+    _getDataMeta(formElement, newValue) {
+        if (newValue) {
+            switch (formElement.type) {
+                case 'ORGANIZATION': {
+                    return this.systemService.getOrganizationObject(newValue);
+                }
+                case 'REFERENCE': {
+                    return this.referenceService.fetchIDReferenceMetaData(Array.isArray(newValue) ? newValue : [newValue]);
+                }
+                case 'CODESYSTEM': {
+                    return of(this.systemService.getCodesystem(formElement.codesystem.id).entries.find((entry) => {
+                        return entry.defaultrepresentation === newValue;
+                    }));
+                }
+            }
+        }
+        return of(null);
+    }
+    _hasValue(data, element) {
+        // differ between array of SearchFilters and a form data object
+        if (Array.isArray(data)) {
+            if (element.type === 'TABLE') {
+                return !!(data.find((filter) => filter.property.startsWith(element.qname)));
+            }
+            else {
+                return !!(data.find((filter) => filter.property === element.qname));
+            }
+        }
+        else {
+            return data.hasOwnProperty(element.name);
+        }
+    }
+    _getValue(scope, data, element) {
+        let value;
+        if (scope.formOptions.formModel.situation === 'SEARCH') {
+            if (scope.isInnerTableForm) {
+                if (element.type === 'DATETIME' || element.type === 'NUMBER') {
+                    value = SearchService.toRangeValue(data[element.name]);
+                }
+                else {
+                    value = data[element.name];
+                }
+            }
+            else if (element.type === 'TABLE') {
+                value = this.searchService.tableFiltersToElementValue(this._getTableFilters(data, element.qname), element.elements);
+            }
+            else {
+                const filter = data.find(f => f.property === element.qname);
+                value = this.searchService.filterToElementValue(filter, element.type);
+            }
+        }
+        else {
+            if (element.type === 'DATETIME' && data[element.name]) {
+                value = new Date(`${data[element.name]}${element.withtime ? '' : 'T00:00:00'}`);
+            }
+            else {
+                value = data[element.name];
+            }
+        }
+        return value;
+    }
+    _getTableFilters(filters, propertyName) {
+        return filters.filter(f => f.property.startsWith(propertyName + '.'));
+    }
+    _initValidators(formControl, scope) {
+        if (formControl) {
+            for (let key in formControl.controls) {
+                const control = formControl.controls[key];
+                if (control.controls) {
+                    this._initValidators(control, scope);
+                }
+                else {
+                    scope.initialValidators[control._eoFormElement.name] = control.validator;
+                    control.setValidators(Validators.compose(this._getValidators(scope, control._eoFormElement).concat([scope.initialValidators[control._eoFormElement.name]])));
+                    control.updateValueAndValidity();
+                }
+            }
+        }
+    }
+    /**
+    * Build validators for the given form element to be attached to
+    * a reactive formControl.
+    *
+    * @param formElement - form element object
+    */
+    _getValidators(scope, formElement) {
+        let elmValidators = FormValidation.getValidators(formElement, scope.formOptions.formModel.situation);
+        // add custom validator for script enabled forms
+        if (scope.formGenResult.scriptingScope) {
+            elmValidators.push(FormValidation.customScriptingValidation);
+        }
+        return elmValidators;
+    }
+    _initScriptingScope(scope, formScriptService) {
+        let { data, actions, objects, context } = (scope.formOptions || {});
+        if (scope.formGenResult.scriptingScope) {
+            scope.formGenResult.scriptingScope.setModel(scope.formGenResult.scriptModel);
+            /** provide access to actions (used inside of BPM-Forms) */
+            scope.formGenResult.scriptingScope.actions = actions;
+            /** provide access to additional objects (used for example in BPM-Start-Forms to
+             * add data of DMS-Objects to start the process for)
+             */
+            scope.formGenResult.scriptingScope.objects = objects;
+            scope.formGenResult.scriptingScope.context = context;
+            /** provide readonly access to initial form data (which may also contain values that
+             * are not rendered as form elements (invisible values))
+             */
+            scope.formGenResult.scriptingScope.data = data;
+            /** by default, scripting scopes are applied to forms. But table elements create their own scope
+             * for editing rows. Being one of those inner forms should not run the form script again, but
+             * instead just provide the observing abilities of the scripting scope.
+             */
+            if (!scope.formOptions.disabled && !scope.isInnerTableForm && scope.formGenResult.formModel) {
+                const scriptName = scope.formGenResult.formModel.name + '_' + scope.formGenResult.formModel.situation;
+                this.logger.debug('executing form script ' + scriptName);
+                formScriptService.runFormScript(scope.formGenResult.scriptingScope, scope.formGenResult.formModel.script, scriptName);
+            }
+        }
+    }
+    /**
+       * This method will be called each time the script changes its internal model.
+       * It is used to transfer the script changes to the actual form model.
+       *
+       * To ensure the right context, we define an instance method as callback for the scripting scope
+       * @see: https://blog.johnnyreilly.com/2014/04/typescript-instance-methods.html
+       *
+       * @param formControlName
+       * @param change
+       */
+    _getScriptingModelChanged(scope) {
+        return (formControlName, change) => {
+            // find the target control
+            let fc = scope.formGenResult.formControls[formControlName];
+            if (fc) {
+                // change only allowed properties
+                switch (change.name) {
+                    case 'value': {
+                        if (Array.isArray(change.newValue)) {
+                            this._processArrayValueChange(fc, change);
+                        }
+                        else {
+                            fc._eoFormElement.value = change.newValue;
+                            if (fc.value !== change.newValue) {
+                                fc.patchValue(change.newValue);
+                                fc.updateValueAndValidity();
+                                fc.markAsDirty();
+                            }
+                        }
+                        scope.formGenResult.form.markAsDirty();
+                        break;
+                    }
+                    case 'required': {
+                        if (fc._eoFormElement.required !== change.newValue) {
+                            fc._eoFormElement.required = change.newValue;
+                            // apply new validators
+                            // @see: https://scotch.io/tutorials/how-to-implement-conditional-validation-in-angular-2-model-driven-forms
+                            fc.setValidators(Validators.compose(this._getValidators(scope, fc._eoFormElement).concat([scope.initialValidators[fc._eoFormElement.name]])));
+                            // need to mark form control as touched because otherwise form validation will not show
+                            // error messages
+                            fc.markAsTouched();
+                            fc.updateValueAndValidity();
+                        }
+                        break;
+                    }
+                    case 'readonly': {
+                        fc._eoFormElement.readonly = change.newValue;
+                        if (change.newValue === true) {
+                            fc.disable();
+                        }
+                        else {
+                            fc.enable();
+                        }
+                        break;
+                    }
+                    case 'error': {
+                        if (JSON.stringify(fc._eoFormElement.error) !== JSON.stringify(change.newValue)) {
+                            fc._eoFormElement.error = change.newValue;
+                            fc.markAsTouched();
+                            fc.updateValueAndValidity();
+                        }
+                        break;
+                    }
+                    // new onrowedit function was applied by the script
+                    case 'onrowedit': {
+                        fc._eoFormElement.onrowedit = change.newValue;
+                        break;
+                    }
+                    // new onchange function was applied by the script
+                    case 'onchange': {
+                        fc._eoFormElement.onchange = change.newValue;
+                        break;
+                    }
+                    // new contextId was applied by the script
+                    case 'contextId': {
+                        fc._eoFormElement.contextId = change.newValue;
+                        break;
+                    }
+                }
+            }
+        };
+    }
+    _processArrayValueChange(fc, change) {
+        const newVal = change.newValue;
+        const targetType = fc._eoFormElement.type;
+        // for some types we have to ensure that meta data are provided as well
+        switch (targetType) {
+            case 'ORGANIZATION': {
+                this._getDataMeta(fc._eoFormElement, newVal).subscribe(m => {
+                    fc._eoFormElement.dataMeta = m;
+                });
+                break;
+            }
+            case 'CODESYSTEM': {
+                if (!fc._eoFormElement.codesystem.entries) {
+                    fc._eoFormElement.codesystem = this.systemService.getCodesystem(fc._eoFormElement.codesystem.id);
+                }
+                break;
+            }
+            case 'TABLE': {
+                const dataToBeProcessed = {};
+                fc._eoFormElement.elements.forEach(e => {
+                    if (e.type === 'ORGANIZATION' || e.type === 'CODESYSTEM') {
+                        dataToBeProcessed[e.name] = e;
+                    }
+                });
+                if (Object.keys(dataToBeProcessed).length) {
+                    let obs = [];
+                    newVal.forEach(rowData => {
+                        Object.keys(rowData).forEach(key => {
+                            if (dataToBeProcessed[key]) {
+                                obs.push(this._getDataMeta(dataToBeProcessed[key], rowData[key]).pipe(tap(m => {
+                                    if (m) {
+                                        rowData[key + '_meta'] = m;
+                                    }
+                                    else {
+                                        delete rowData[key + '_meta'];
+                                    }
+                                })));
+                            }
+                        });
+                    });
+                    forkJoin(obs).subscribe(() => this._updateArrayValue(fc, newVal));
+                }
+                break;
+            }
+        }
+        this._updateArrayValue(fc, newVal);
+    }
+    _updateArrayValue(fc, newValue) {
+        fc._eoFormElement.value = [].concat(newValue);
+        fc.patchValue([].concat(newValue));
+        fc.updateValueAndValidity();
+        fc.markAsDirty();
+    }
 }
-ObjectFormHelperService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: ObjectFormHelperService, deps: [{ token: i1.Logger }, { token: i1.SystemService }], target: i0.ɵɵFactoryTarget.Injectable });
+ObjectFormHelperService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: ObjectFormHelperService, deps: [{ token: i1.Logger }, { token: i2.ReferenceService }, { token: i1.SearchService }, { token: i3.PluginsService }, { token: i1.SystemService }], target: i0.ɵɵFactoryTarget.Injectable });
 ObjectFormHelperService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: ObjectFormHelperService });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: ObjectFormHelperService, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: i1.Logger }, { type: i1.SystemService }]; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"object-form-helper.service.js","sourceRoot":"","sources":["../../../../../../../src/app/eo-framework/object-form/object-form-helper.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable} from '@angular/core';\nimport {FormValidation} from './object-form/form-validation/form-validation';\nimport {ObjectFormControlWrapper} from './object-form/object-form-control-wrapper';\nimport {ObjectFormControl} from './object-form/object-form-control';\nimport {ObjectFormGroup} from './object-form/object-form-group.model';\nimport {Logger, SystemService, RangeValue} from '@eo-sdk/core';\nimport {ObjectFormModel} from './object-form/object-form.model';\nimport {DatePipe} from '@angular/common';\n\n@Injectable()\nexport class ObjectFormHelperService {\n\n  private datePipe = new DatePipe('en');\n\n  constructor(private logger: Logger, private systemService: SystemService) {\n  }\n\n  /**\n   * Converts a form element object to an ObjectFormControlWrapper which then can be used to\n   * render a from control. Result can be used as input for FormElementComponent.\n   *\n   * @param element - the element object or a json string\n   * @param situation - optional property to set up a form situation for the control (default is EDIT)\n   * @return the converted ObjectFormControlWrapper or null in case of an error\n   */\n  elementToFormControl(element: any, situation?: string): ObjectFormControlWrapper {\n\n    let formElement;\n    if (typeof element === 'string') {\n      try {\n        formElement = JSON.parse(element);\n      } catch (e) {\n        this.logger.error('Unable to parse form element from json ', formElement);\n      }\n    } else {\n      formElement = element;\n    }\n\n    if (!formElement) {\n      return null;\n    }\n\n    // Create the ObjectFormControlWrapper\n    let wrapper = new ObjectFormControlWrapper({});\n    let formSituation = situation ? situation : 'EDIT';\n\n    wrapper._eoFormControlWrapper = {\n      controlName: formElement.name,\n      situation: formSituation\n    };\n\n    // for codesystem elements add entries if not yet provided\n    if (formElement.type === 'CODESYSTEM' && (!formElement.codesystem || !formElement.codesystem.entries)) {\n      formElement.codesystem = this.systemService.getCodesystem(formElement.codesystem.id);\n    }\n    // create the actual form control\n    let controlDisabled = !!formElement.readonly;\n    let formControl = new ObjectFormControl({\n      value: formElement.value,\n      disabled: controlDisabled\n    }, FormValidation.getValidators(formElement, formSituation));\n\n    // Form elements in SEARCH situation may arrive with a value set to NULL (explicit search for\n    // fields that are NOT set). In that case we need to prepare the form control\n    if (formSituation === 'SEARCH' && formElement.value === null) {\n      formElement.isNotSetValue = true;\n    }\n\n    formControl._eoFormElement = formElement;\n    wrapper.addControl(formElement.name, formControl);\n\n    return wrapper;\n  }\n\n  /**\n   * Extract data from an object form based on situation.\n   *\n   * @param form - form to extract data from\n   * @param situation - form situation\n   * @param [initialData] - optional form data to match the current values against\n   * This is required for editig indexdata (EDIT situation), because we have to compare new values\n   * against the initial values. If a property that is contained in the forms initial data is removed\n   * (e.g. set to null) then we have to set this null value, because otherwise the server would\n   * ignore the changes.\n   * @param isTableRowEditForm Flag indicating that the provided form is an inline form used by\n   * a forms table element for editing rows. Those need a special handling.\n   * @return extracted data as object\n   */\n  extractFormData(form: ObjectFormGroup, situation: string, initialData?: any, isTableRowEditForm?: boolean) {\n    let extractedData = {};\n    this.getElementValues(extractedData, form, situation || 'EDIT', initialData, isTableRowEditForm);\n    return extractedData;\n  }\n\n  // Recursive method to get the values from each form control.\n  private getElementValues(data: any, formControl: ObjectFormModel, situation: string, initialData?: any, isTableRowEditForm?: boolean) {\n\n    if (!formControl || !formControl.controls) {\n      return;\n    }\n\n    if (formControl instanceof ObjectFormControlWrapper) {\n\n      const fc: any = formControl.controls[formControl._eoFormControlWrapper.controlName];\n\n      if (fc._eoFormElement.isNotSetValue === true) {\n        // form elements may explicitly set to have NULL value (e.g. from Search form if values are requested that have no values)\n        if (isTableRowEditForm) {\n          this.setDataValue(fc._eoFormElement.name, null, data, fc._eoFormElement, isTableRowEditForm);\n        } else {\n          this.setDataValue(fc._eoFormElement.qname, null, data, fc._eoFormElement, isTableRowEditForm);\n        }\n\n      } else if (fc.value !== undefined) {\n        let val = fc.value;\n\n        // make sure that meta data are also up to date\n        if (fc._eoFormElement.type === 'CODESYSTEM') {\n          const cs = this.systemService.getCodesystem(fc._eoFormElement.codesystem.id);\n          fc._eoFormElement.dataMeta = cs.entries.find(e => e.data === val);\n        }\n\n        switch (situation) {\n          case 'SEARCH': {\n            if (val !== null) {\n              // row editing forms use the name instead of the qname because otherwise the\n              // tables grid isn't able to map the fields\n              if (!isTableRowEditForm) {\n                this.setDataValue(fc._eoFormElement.qname, val, data, fc._eoFormElement, isTableRowEditForm)\n              } else {\n                this.setDataValue(fc._eoFormElement.name, val, data, fc._eoFormElement, isTableRowEditForm)\n              }\n            }\n            break;\n          }\n          case 'CREATE': {\n            // also add NULL values (override existing defaultvalues)\n            this.setDataValue(fc._eoFormElement.name, val, data, fc._eoFormElement, isTableRowEditForm)\n            break;\n          }\n          case 'EDIT': {\n            // in edit situation we have to compare new values against the initial values\n            // If a property that is contained in the forms initial data is removed (e.g. set to null)\n            // then we have to set this null value, because otherwise the server will ignore the changes\n            if (val !== null || (initialData && initialData[fc._eoFormElement.name] !== undefined)) {\n              // data[fc._eoFormElement.name] = val;\n              this.setDataValue(fc._eoFormElement.name, val, data, fc._eoFormElement, isTableRowEditForm)\n            }\n            break;\n          }\n        }\n      }\n    } else {\n      Object.keys(formControl.controls)\n        .forEach(controlKey => {\n          let formControlKeyed = <ObjectFormGroup>formControl.controls[controlKey];\n          this.getElementValues(data, formControlKeyed, situation, initialData, isTableRowEditForm);\n        });\n    }\n  }\n\n  private setDataValue(key, value, data, formElement, isTableRowEditForm) {\n    data[key] = this.formatValue(value, formElement);\n\n    if (isTableRowEditForm && formElement.dataMeta) {\n      // inner tables need to set up the meta data as well\n      data[key + '_meta'] = formElement.dataMeta;\n    }\n  }\n\n  formatValue(value, formElement) {\n    if (formElement.type === 'DATETIME' && !formElement.withtime) {\n      if (typeof value === 'string' || value instanceof Date) {\n        return this.datePipe.transform(value, 'yyyy-MM-dd');\n      } else if (value instanceof RangeValue) {\n        return new RangeValue(\n          value.operator,\n          value.firstValue && this.datePipe.transform(value.firstValue, 'yyyy-MM-dd'),\n          value.secondValue && this.datePipe.transform(value.secondValue, 'yyyy-MM-dd')\n        );\n      }\n    }\n\n    if (formElement.type === 'TABLE') {\n      (formElement.elements || []).forEach(el => {\n        (value || []).forEach(v => v[el.name] = this.formatValue(v[el.name], el));\n      });\n    }\n    return value;\n  }\n\n}\n"]}
+        }], ctorParameters: function () { return [{ type: i1.Logger }, { type: i2.ReferenceService }, { type: i1.SearchService }, { type: i3.PluginsService }, { type: i1.SystemService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"object-form-helper.service.js","sourceRoot":"","sources":["../../../../../../../src/app/eo-framework/object-form/object-form-helper.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { DatePipe } from '@angular/common';\nimport { Injectable } from '@angular/core';\nimport { ValidatorFn, Validators } from '@angular/forms';\nimport { Logger, RangeValue, SearchFilter, SearchService, SystemService, Utils } from '@eo-sdk/core';\nimport { forkJoin, Observable, of, Subscription } from 'rxjs';\nimport { debounceTime, tap } from 'rxjs/operators';\n\nimport { PluginsService } from '../../eo-framework-core/api/plugins.service';\nimport { ReferenceService } from '../../eo-framework-core/references/reference.service';\nimport { ObjectFormOptions } from './object-form-options.interface';\nimport { FormValidation } from './object-form/form-validation/form-validation';\nimport { ObjectFormControl } from './object-form/object-form-control';\nimport { ObjectFormControlWrapper } from './object-form/object-form-control-wrapper';\nimport { ObjectFormGroup } from './object-form/object-form-group.model';\nimport { ObjectFormScriptService } from './object-form/object-form-script/object-form-script.service';\nimport { ObjectFormScriptingScope } from './object-form/object-form-script/object-form-scripting-scope';\nimport { ObjectFormModel } from './object-form/object-form.model';\n\nexport interface FormGenScope {\n  gCount: number;\n  formOptions: ObjectFormOptions;\n  isInnerTableForm: boolean;\n  initialValidators: {[name: string]: ValidatorFn | null};\n  formGenResult: FormGenResult;\n}\nexport interface FormGenResult {\n  // Form controls generated from the model as 'Quick access object'\n  // Form elements name is key and the value is the form control itself\n  formControls: {[name: string]: ObjectFormControl};\n  formModel: any,\n  // Subscriptions to value changes of the generated form controls\n  // You should always unsubscribe from all of them when consuming \n  // component is destroyed\n  controlValueSubscriptions: Subscription[];\n  scriptingScope: ObjectFormScriptingScope;\n  scriptModel: {[name: string]: any};\n  form: ObjectFormGroup;\n}\n\n@Injectable()\nexport class ObjectFormHelperService {\n\n  private datePipe = new DatePipe('en');\n\n  constructor(private logger: Logger,\n    private referenceService: ReferenceService,\n    private searchService: SearchService,\n    private pluginService: PluginsService,\n    private systemService: SystemService) {\n  }\n\n/**\n * Generates a reactive form based on a form model that may also include form scripts. \n * @param formOptions `ObjectFormOptions` defining the form\n * @param formScriptService Instance of a `ObjectFormScriptService`. This service is supposed to be \n * scoped to the component rendering the form (providers array in component decorator).\n * @param isInnerTableForm whether or not the form is part of another form (as is with table edit forms)\n * @returns An `FormGenResult` object \n */\n  buildReactiveForm(formOptions: ObjectFormOptions, formScriptService: ObjectFormScriptService, isInnerTableForm?: boolean): FormGenResult {\n\n    const _scope: FormGenScope = {\n      gCount: 0,\n      formOptions,\n      isInnerTableForm,\n      initialValidators: {},\n      formGenResult: {\n        formControls: {},\n        formModel: {},\n        controlValueSubscriptions: [],\n        scriptingScope: undefined,\n        scriptModel: {},\n        form: null\n      }\n    }\n\n    const formModel = this._dataToForm(_scope, formOptions.formModel, formOptions.data);\n    _scope.formGenResult.formModel = formModel;\n    if (!formModel) return;\n\n    // if a script is available, we'll init the form scripting for the\n    // current form\n    let scriptingScope: ObjectFormScriptingScope;\n    if (_scope.isInnerTableForm || (formModel.script && formModel.script.length > 0)) {\n      this.logger.debug('adding form scripting scope');\n      scriptingScope = new ObjectFormScriptingScope(\n        formModel.situation,\n        this._getScriptingModelChanged(_scope),\n        this.pluginService.getApi(),\n        _scope.isInnerTableForm\n      );\n      scriptingScope.objectId = formOptions.objectId;\n    }\n    _scope.formGenResult.scriptingScope = scriptingScope;\n\n\n    let form = new ObjectFormGroup({});\n    if (formModel.elements[0] && formModel.elements[0].elements) {\n      this._addFormControl(_scope, form, formModel.elements[0], 'core');\n    }\n    if (formModel.elements[1] && formModel.elements[1].elements) {\n      this._addFormControl(_scope, form, formModel.elements[1], 'data');\n    }\n    _scope.formGenResult.form = form;\n    this._initValidators(_scope.formGenResult.form, _scope);\n    this._initScriptingScope(_scope, formScriptService);\n    return _scope.formGenResult;\n  }\n\n  \n  \n  /**\n   * Converts a form element object to an ObjectFormControlWrapper which then can be used to\n   * render a from control. Result can be used as input for FormElementComponent.\n   *\n   * @param element - the element object or a json string\n   * @param situation - optional property to set up a form situation for the control (default is EDIT)\n   * @return the converted ObjectFormControlWrapper or null in case of an error\n   */\n  elementToFormControl(element: any, situation?: string): ObjectFormControlWrapper {\n\n    let formElement;\n    if (typeof element === 'string') {\n      try {\n        formElement = JSON.parse(element);\n      } catch (e) {\n        this.logger.error('Unable to parse form element from json ', formElement);\n      }\n    } else {\n      formElement = element;\n    }\n\n    if (!formElement) {\n      return null;\n    }\n\n    // Create the ObjectFormControlWrapper\n    let wrapper = new ObjectFormControlWrapper({});\n    let formSituation = situation ? situation : 'EDIT';\n\n    wrapper._eoFormControlWrapper = {\n      controlName: formElement.name,\n      situation: formSituation\n    };\n\n    // for codesystem elements add entries if not yet provided\n    if (formElement.type === 'CODESYSTEM' && (!formElement.codesystem || !formElement.codesystem.entries)) {\n      formElement.codesystem = this.systemService.getCodesystem(formElement.codesystem.id);\n    }\n    // create the actual form control\n    let controlDisabled = !!formElement.readonly;\n    let formControl = new ObjectFormControl({\n      value: formElement.value,\n      disabled: controlDisabled\n    }, FormValidation.getValidators(formElement, formSituation));\n\n    // Form elements in SEARCH situation may arrive with a value set to NULL (explicit search for\n    // fields that are NOT set). In that case we need to prepare the form control\n    if (formSituation === 'SEARCH' && formElement.value === null) {\n      formElement.isNotSetValue = true;\n    }\n\n    formControl._eoFormElement = formElement;\n    wrapper.addControl(formElement.name, formControl);\n\n    return wrapper;\n  }\n\n  /**\n   * Extract data from an object form based on situation.\n   *\n   * @param form - form to extract data from\n   * @param situation - form situation\n   * @param [initialData] - optional form data to match the current values against\n   * This is required for editig indexdata (EDIT situation), because we have to compare new values\n   * against the initial values. If a property that is contained in the forms initial data is removed\n   * (e.g. set to null) then we have to set this null value, because otherwise the server would\n   * ignore the changes.\n   * @param isTableRowEditForm Flag indicating that the provided form is an inline form used by\n   * a forms table element for editing rows. Those need a special handling.\n   * @return extracted data as object\n   */\n  extractFormData(form: ObjectFormGroup, situation: string, initialData?: any, isTableRowEditForm?: boolean) {\n    let extractedData = {};\n    this.getElementValues(extractedData, form, situation || 'EDIT', initialData, isTableRowEditForm);\n    return extractedData;\n  }\n\n  // Recursive method to get the values from each form control.\n  private getElementValues(data: any, formControl: ObjectFormModel, situation: string, initialData?: any, isTableRowEditForm?: boolean) {\n\n    if (!formControl || !formControl.controls) {\n      return;\n    }\n\n    if (formControl instanceof ObjectFormControlWrapper) {\n\n      const fc: any = formControl.controls[formControl._eoFormControlWrapper.controlName];\n\n      if (fc._eoFormElement.isNotSetValue === true) {\n        // form elements may explicitly set to have NULL value (e.g. from Search form if values are requested that have no values)\n        if (isTableRowEditForm) {\n          this.setDataValue(fc._eoFormElement.name, null, data, fc._eoFormElement, isTableRowEditForm);\n        } else {\n          this.setDataValue(fc._eoFormElement.qname, null, data, fc._eoFormElement, isTableRowEditForm);\n        }\n\n      } else if (fc.value !== undefined) {\n        let val = fc.value;\n\n        // make sure that meta data are also up to date\n        if (fc._eoFormElement.type === 'CODESYSTEM') {\n          const cs = this.systemService.getCodesystem(fc._eoFormElement.codesystem.id);\n          fc._eoFormElement.dataMeta = cs.entries.find(e => e.data === val);\n        }\n\n        switch (situation) {\n          case 'SEARCH': {\n            if (val !== null) {\n              // row editing forms use the name instead of the qname because otherwise the\n              // tables grid isn't able to map the fields\n              if (!isTableRowEditForm) {\n                this.setDataValue(fc._eoFormElement.qname, val, data, fc._eoFormElement, isTableRowEditForm)\n              } else {\n                this.setDataValue(fc._eoFormElement.name, val, data, fc._eoFormElement, isTableRowEditForm)\n              }\n            }\n            break;\n          }\n          case 'CREATE': {\n            // also add NULL values (override existing defaultvalues)\n            this.setDataValue(fc._eoFormElement.name, val, data, fc._eoFormElement, isTableRowEditForm)\n            break;\n          }\n          case 'EDIT': {\n            // in edit situation we have to compare new values against the initial values\n            // If a property that is contained in the forms initial data is removed (e.g. set to null)\n            // then we have to set this null value, because otherwise the server will ignore the changes\n            if (val !== null || (initialData && initialData[fc._eoFormElement.name] !== undefined)) {\n              // data[fc._eoFormElement.name] = val;\n              this.setDataValue(fc._eoFormElement.name, val, data, fc._eoFormElement, isTableRowEditForm)\n            }\n            break;\n          }\n        }\n      }\n    } else {\n      Object.keys(formControl.controls)\n        .forEach(controlKey => {\n          let formControlKeyed = <ObjectFormGroup>formControl.controls[controlKey];\n          this.getElementValues(data, formControlKeyed, situation, initialData, isTableRowEditForm);\n        });\n    }\n  }\n\n  private setDataValue(key, value, data, formElement, isTableRowEditForm) {\n    data[key] = this.formatValue(value, formElement);\n\n    if (isTableRowEditForm && formElement.dataMeta) {\n      // inner tables need to set up the meta data as well\n      data[key + '_meta'] = formElement.dataMeta;\n    }\n  }\n\n  formatValue(value, formElement) {\n    if (formElement.type === 'DATETIME' && !formElement.withtime) {\n      if (typeof value === 'string' || value instanceof Date) {\n        return this.datePipe.transform(value, 'yyyy-MM-dd');\n      } else if (value instanceof RangeValue) {\n        return new RangeValue(\n          value.operator,\n          value.firstValue && this.datePipe.transform(value.firstValue, 'yyyy-MM-dd'),\n          value.secondValue && this.datePipe.transform(value.secondValue, 'yyyy-MM-dd')\n        );\n      }\n    }\n\n    if (formElement.type === 'TABLE') {\n      (formElement.elements || []).forEach(el => {\n        (value || []).forEach(v => v[el.name] = this.formatValue(v[el.name], el));\n      });\n    }\n    return value;\n  }\n\n\n  // Functions involved in building an object form\n\n  /**\n   * Recursive method adding a new UntypedFormControl (group or control) to a parent form group\n   *\n   * @param parentGroup - the parent group to add the control to\n   * @param formElement - the enaio form model element to create the child control from\n   * @param [useName] - use this name instead of the one from the model\n   */\n  private _addFormControl(scope: FormGenScope, parentGroup: ObjectFormGroup, formElement: any, useName?: string) {\n\n    let ctrl;\n    let name;\n\n    // add a form group\n    if (formElement.type === 'o2mGroup' || formElement.type === 'o2mGroupStack') {\n\n      // do not add groups that are empty\n      if (!formElement.elements || formElement.elements.length === 0) {\n        this.logger.error('Found empty form group', formElement);\n        return;\n      }\n\n      ctrl = new ObjectFormGroup({});\n      ctrl._eoFormGroup = {\n        label: formElement.label,\n        //layoutgroup: formElement.layoutgroup,\n        layout: formElement.layout,\n        type: formElement.type\n      };\n\n      if (useName === 'core' || useName === 'data') {\n        ctrl._eoFormGroup.label = useName;\n      }\n\n      for (let e of formElement.elements) {\n        this._addFormControl(scope, ctrl, e);\n      }\n      name = useName || 'fg' + scope.gCount++;\n    } else {\n      // add form control\n      // To be able to integrate recursive form controls into the main form,\n      // we have to wrap them in a form group\n      ctrl = new ObjectFormControlWrapper({});\n      ctrl._eoFormControlWrapper = {\n        // the name of the wrapped UntypedFormControl\n        controlName: formElement.name,\n        situation: scope.formOptions.formModel.situation\n      };\n      if (scope.formOptions.formModel.situation === 'SEARCH' && formElement.value === null) {\n        formElement.isNotSetValue = true;\n      }\n      // do not set a reference as the form controls value\n      // otherwise we could not reset the form\n      let value: any;\n      if (Array.isArray(formElement.value)) {\n        // copy by value for arrays of objects (e.g. table data)\n        value = [];\n        formElement.value.forEach((o) => {\n          value.push(Utils.formDataParse(Utils.formDataStringify(o)));\n        });\n      } else {\n        value = formElement.value;\n      }\n\n      // for codesystem elements add entries if not yet provided\n      if (formElement.type === 'CODESYSTEM' && !formElement.codesystem.entries) {\n        formElement.codesystem = this.systemService.getCodesystem(formElement.codesystem.id);\n      }\n\n      // create the actual form control\n      let controlDisabled = scope.formOptions.disabled || !!formElement.readonly;\n      let formControl = new ObjectFormControl({\n        value: value,\n        disabled: controlDisabled\n      });\n\n      formElement.readonly = controlDisabled;\n\n      formControl._eoFormElement = formElement;\n      scope.formGenResult.formControls[formElement.name] = formControl;\n\n      if (formElement.type === 'CODESYSTEM' || (formElement.type === 'STRING' && formElement.classification === 'selector')) {\n        formControl._eoFormElement.applyFilter = (func: Function) => {\n          formControl._eoFormElement.filterFunction = func;\n        };\n        formControl._eoFormElement.applyDisablingFilter = (func: Function) => {\n          formControl._eoFormElement.disablingFilterFunction = func;\n        };\n      }\n\n      if (formElement.type === 'STRING' && formElement.classification === 'selector') {\n        formControl._eoFormElement.setList = (listObject: any) => {\n          formControl._eoFormElement.list = listObject;\n        };\n      }\n\n      if (formElement.type === 'ORGANIZATION') {\n        formControl._eoFormElement.setFilter = (filterObject: any) => {\n          formControl._eoFormElement.filter = filterObject;\n        };\n      }\n\n      if (formElement.type === 'TABLE') {\n        formControl._eoFormElement.object = scope.formOptions.object;\n      }\n\n      if (formElement.type === 'REFERENCE') {\n        formControl._eoFormElement.setQueryFilters = (queryFiltersObject: {[fieldQname: string]: {o: string, v1: any, v2: any}}, objectTypes?: string[]) => {\n          formControl._eoFormElement.queryFilters = queryFiltersObject;\n          formControl._eoFormElement.objectTypesFilter = objectTypes;\n        };\n      }\n\n      if (scope.formOptions.formModel.situation === 'SEARCH') {\n        // in search situation even readonly fields should be editable ...\n        formControl._eoFormElement.readonly = false;\n        // ... and required makes no sense here\n        formControl._eoFormElement.required = false;\n      }\n\n      // remove empty descriptions\n      let desc = formControl._eoFormElement.description;\n      if (desc && desc.trim().length === 0) {\n        formControl._eoFormElement.description = null;\n      }\n\n      // add the form element to the script model that will be injected into\n      // the forms scripting scope later on\n      scope.formGenResult.scriptModel[formElement.name] = formControl._eoFormElement;\n\n      // apply change listener to the form control, that will trigger\n      // the form elements onChange listener\n      let controlWatch = ctrl.valueChanges.pipe(debounceTime(formElement.type === 'TABLE' ? 0 : 500));\n      controlWatch.subscribe((v) => {\n        if (formControl._eoFormElement.type === 'REFERENCE') {\n          this._getDataMeta(formControl._eoFormElement, v[formControl._eoFormElement.name]).subscribe(m => {\n            if (m) {\n              formControl._eoFormElement.dataMeta = formControl._eoFormElement.multiselect ? m : m[0];\n            } else {\n              delete formControl._eoFormElement.dataMeta;\n            }\n          });\n        }\n        if (scope.formGenResult.scriptingScope) {\n          scope.formGenResult.scriptingScope.modelChanged(v);\n        }\n      });\n      scope.formGenResult.controlValueSubscriptions.push(controlWatch);\n\n      ctrl.addControl(formElement.name, formControl);\n      name = 'fg_' + formElement.name;\n    }\n    parentGroup.addControl(name, ctrl);\n  }\n\n  /**\n   * Merge data into a form model.\n   *\n   * @param model - form model\n   * @param data - data object or array of SearchFilter objects in case of a search form\n   */\n  private _dataToForm(scope: FormGenScope, model: any, data: any) {\n    if (model && data) {\n      this._setElementValues(scope, model.elements, data);\n    }\n    return model;\n  }\n\n  // recursive method for adding values to model elements\n  private _setElementValues(scope: FormGenScope, elements, data) {\n\n    elements.forEach(element => {\n      if (this._hasValue(data, element)) {\n\n        element.value = this._getValue(scope, data, element);\n        if (element.value) {\n          // add meta data for some of the types\n          this._fetchMetaData(scope, data, element);\n        }\n      } else {\n        delete element.value;\n      }\n      if (element.type !== 'TABLE' && element.elements && element.elements.length > 0) {\n        this._setElementValues(scope, element.elements, data);\n      }\n    });\n  }\n\n  // in some cases required meta data may not be available on the element itself\n  // so they have to be fetched and added to the element for the form to be able\n  // to render the element correctly\n  private _fetchMetaData(scope: FormGenScope, data, element) {\n\n    if (scope.formOptions.formModel.situation === 'SEARCH') {\n      // todo: how to fetch meta data in search situation\n    } else {\n      if (element.type === 'ORGANIZATION' && data[element.name + '_meta']) {\n        element.dataMeta = data[element.name + '_meta'];\n      } else if (element.type === 'CODESYSTEM' && data[element.name + '_meta']) {\n        element.dataMeta = data[element.name + '_meta'];\n        element.defaultrepresentation = data[element.name + '_meta'].defaultrepresentation;\n      } else if (element.type === 'REFERENCE' && data[element.name + '_meta']) {\n        element.dataMeta = data[element.name + '_meta'];\n      }\n    }\n  }\n\n  private _getDataMeta(formElement: any, newValue: any): Observable<any> {\n\n    if (newValue) {\n      switch (formElement.type) {\n        case 'ORGANIZATION': {\n          return this.systemService.getOrganizationObject(newValue);\n        }\n        case 'REFERENCE': {\n          return this.referenceService.fetchIDReferenceMetaData(Array.isArray(newValue) ? newValue : [newValue]);\n        }\n        case 'CODESYSTEM': {\n          return of(this.systemService.getCodesystem(formElement.codesystem.id).entries.find((entry) => {\n            return entry.defaultrepresentation === newValue;\n          }));\n        }\n      }\n    }\n    return of(null);\n  }\n\n  private _hasValue(data, element) {\n\n    // differ between array of SearchFilters and a form data object\n    if (Array.isArray(data)) {\n      if (element.type === 'TABLE') {\n        return !!(data.find((filter) => filter.property.startsWith(element.qname)));\n      } else {\n        return !!(data.find((filter) => filter.property === element.qname));\n      }\n    } else {\n      return data.hasOwnProperty(element.name);\n    }\n  }\n\n  private _getValue(scope: FormGenScope, data, element) {\n\n    let value;\n    if (scope.formOptions.formModel.situation === 'SEARCH') {\n      if (scope.isInnerTableForm) {\n        if (element.type === 'DATETIME' || element.type === 'NUMBER') {\n          value = SearchService.toRangeValue(data[element.name]);\n        } else {\n          value = data[element.name];\n        }\n      } else if (element.type === 'TABLE') {\n        value = this.searchService.tableFiltersToElementValue(this._getTableFilters(data, element.qname), element.elements);\n      } else {\n        const filter = data.find(f => f.property === element.qname);\n        value = this.searchService.filterToElementValue(filter, element.type);\n      }\n    } else {\n\n      if (element.type === 'DATETIME' && data[element.name]) {\n        value = new Date(`${data[element.name]}${element.withtime ? '' : 'T00:00:00'}`);\n      } else {\n        value = data[element.name];\n      }\n    }\n    return value;\n  }\n\n  private _getTableFilters(filters: SearchFilter[], propertyName: string): SearchFilter[] {\n    return filters.filter(f => f.property.startsWith(propertyName + '.'));\n  }\n\n  private _initValidators(formControl: ObjectFormGroup, scope: FormGenScope) {\n    if (formControl) {\n      for (let key in formControl.controls) {\n        const control = formControl.controls[key] as any;\n        if (control.controls) {\n          this._initValidators(control, scope);\n        } else {\n          scope.initialValidators[control._eoFormElement.name] = control.validator;\n          control.setValidators(Validators.compose(\n            this._getValidators(scope, control._eoFormElement).concat(\n              [scope.initialValidators[control._eoFormElement.name]])\n          ));\n          control.updateValueAndValidity();\n        }\n      }\n    }\n  }\n\n  /**\n  * Build validators for the given form element to be attached to\n  * a reactive formControl.\n  *\n  * @param formElement - form element object\n  */\n  private _getValidators(scope: FormGenScope, formElement: any): ValidatorFn[] {\n    let elmValidators = FormValidation.getValidators(formElement, scope.formOptions.formModel.situation);\n    // add custom validator for script enabled forms\n    if (scope.formGenResult.scriptingScope) {\n      elmValidators.push(FormValidation.customScriptingValidation);\n    }\n\n    return elmValidators;\n  }\n\n  private _initScriptingScope(scope: FormGenScope, formScriptService: ObjectFormScriptService) {\n    let {data, actions, objects, context} = <ObjectFormOptions>(scope.formOptions || {});\n\n    if (scope.formGenResult.scriptingScope) {\n      scope.formGenResult.scriptingScope.setModel(scope.formGenResult.scriptModel);\n      /** provide access to actions (used inside of BPM-Forms) */\n      scope.formGenResult.scriptingScope.actions = actions;\n      /** provide access to additional objects (used for example in BPM-Start-Forms to\n       * add data of DMS-Objects to start the process for)\n       */\n      scope.formGenResult.scriptingScope.objects = objects;\n      scope.formGenResult.scriptingScope.context = context;\n      /** provide readonly access to initial form data (which may also contain values that\n       * are not rendered as form elements (invisible values))\n       */\n      scope.formGenResult.scriptingScope.data = data;\n\n      /** by default, scripting scopes are applied to forms. But table elements create their own scope\n       * for editing rows. Being one of those inner forms should not run the form script again, but\n       * instead just provide the observing abilities of the scripting scope.\n       */\n      if (!scope.formOptions.disabled && !scope.isInnerTableForm && scope.formGenResult.formModel) {\n        const scriptName = scope.formGenResult.formModel.name + '_' + scope.formGenResult.formModel.situation;\n        this.logger.debug('executing form script ' + scriptName);\n        formScriptService.runFormScript(\n          scope.formGenResult.scriptingScope,\n          scope.formGenResult.formModel.script,\n          scriptName\n        );\n      }\n    }\n  }\n\n  /**\n     * This method will be called each time the script changes its internal model.\n     * It is used to transfer the script changes to the actual form model.\n     *\n     * To ensure the right context, we define an instance method as callback for the scripting scope\n     * @see: https://blog.johnnyreilly.com/2014/04/typescript-instance-methods.html\n     *\n     * @param formControlName\n     * @param change\n     */\n\n  private _getScriptingModelChanged(scope: FormGenScope): Function {\n    return (formControlName, change) => {\n\n      // find the target control\n      let fc: ObjectFormControl = scope.formGenResult.formControls[formControlName] as ObjectFormControl;\n      if (fc) {\n\n        // change only allowed properties\n        switch (change.name) {\n          case 'value': {\n            if (Array.isArray(change.newValue)) {\n              this._processArrayValueChange(fc, change);\n            } else {\n              fc._eoFormElement.value = change.newValue;\n              if (fc.value !== change.newValue) {\n                fc.patchValue(change.newValue);\n                fc.updateValueAndValidity();\n                fc.markAsDirty();\n              }\n            }\n            scope.formGenResult.form.markAsDirty();\n            break;\n          }\n          case 'required': {\n            if (fc._eoFormElement.required !== change.newValue) {\n              fc._eoFormElement.required = change.newValue;\n              // apply new validators\n              // @see: https://scotch.io/tutorials/how-to-implement-conditional-validation-in-angular-2-model-driven-forms\n              fc.setValidators(Validators.compose(this._getValidators(scope, fc._eoFormElement).concat([scope.initialValidators[fc._eoFormElement.name]])));\n              // need to mark form control as touched because otherwise form validation will not show\n              // error messages\n              fc.markAsTouched();\n              fc.updateValueAndValidity();\n            }\n            break;\n          }\n          case 'readonly': {\n            fc._eoFormElement.readonly = change.newValue;\n            if (change.newValue === true) {\n              fc.disable();\n            } else {\n              fc.enable();\n            }\n            break;\n          }\n          case 'error': {\n            if (JSON.stringify(fc._eoFormElement.error) !== JSON.stringify(change.newValue)) {\n              fc._eoFormElement.error = change.newValue;\n              fc.markAsTouched();\n              fc.updateValueAndValidity();\n            }\n            break;\n          }\n          // new onrowedit function was applied by the script\n          case 'onrowedit': {\n            fc._eoFormElement.onrowedit = change.newValue;\n            break;\n          }\n          // new onchange function was applied by the script\n          case 'onchange': {\n            fc._eoFormElement.onchange = change.newValue;\n            break;\n          }\n          // new contextId was applied by the script\n          case 'contextId': {\n            fc._eoFormElement.contextId = change.newValue;\n            break;\n          }\n        }\n      }\n    }\n  }\n\n  private _processArrayValueChange(fc, change) {\n    const newVal = change.newValue;\n    const targetType = fc._eoFormElement.type;\n    // for some types we have to ensure that meta data are provided as well\n    switch (targetType) {\n      case 'ORGANIZATION': {\n        this._getDataMeta(fc._eoFormElement, newVal).subscribe(m => {\n          fc._eoFormElement.dataMeta = m;\n        });\n        break;\n      }\n      case 'CODESYSTEM': {\n        if (!fc._eoFormElement.codesystem.entries) {\n          fc._eoFormElement.codesystem = this.systemService.getCodesystem(fc._eoFormElement.codesystem.id);\n        }\n        break;\n      }\n      case 'TABLE': {\n        const dataToBeProcessed = {};\n        fc._eoFormElement.elements.forEach(e => {\n          if (e.type === 'ORGANIZATION' || e.type === 'CODESYSTEM') {\n            dataToBeProcessed[e.name] = e;\n          }\n        });\n        if (Object.keys(dataToBeProcessed).length) {\n          let obs = [];\n          newVal.forEach(rowData => {\n            Object.keys(rowData).forEach(key => {\n              if (dataToBeProcessed[key]) {\n                obs.push(this._getDataMeta(dataToBeProcessed[key], rowData[key]).pipe(\n                  tap(m => {\n                    if (m) {\n                      rowData[key + '_meta'] = m;\n                    } else {\n                      delete rowData[key + '_meta'];\n                    }\n                  })\n                ));\n              }\n            });\n          });\n          forkJoin(obs).subscribe(() => this._updateArrayValue(fc, newVal));\n        }\n        break;\n      }\n    }\n    this._updateArrayValue(fc, newVal);\n  }\n\n  private _updateArrayValue(fc, newValue) {\n    fc._eoFormElement.value = [].concat(newValue);\n    fc.patchValue([].concat(newValue));\n    fc.updateValueAndValidity();\n    fc.markAsDirty();\n  }\n}\n"]}