@ajf/material 12.1.0

package/esm2015/report-builder/report-builder-service.js

@@ -0,0 +1,1685 @@
+/**
+ * @license
+ * Copyright (C) Gnucoop soc. coop.
+ *
+ * This file is part of the Advanced JSON forms (ajf).
+ *
+ * Advanced JSON forms (ajf) is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the License,
+ * or (at your option) any later version.
+ *
+ * Advanced JSON forms (ajf) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with Advanced JSON forms (ajf).
+ * If not, see http://www.gnu.org/licenses/.
+ *
+ */
+import { AjfFieldType, AjfNodeType, flattenNodes } from '@ajf/core/forms';
+import { createFormula } from '@ajf/core/models';
+import { AjfWidgetType, createAggregation, createWidget } from '@ajf/core/reports';
+import { deepCopy } from '@ajf/core/utils';
+import { EventEmitter, Inject, Injectable, Optional } from '@angular/core';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { combineLatest, filter, map, publishReplay, refCount, scan, share, startWith } from 'rxjs/operators';
+import { AJF_REPORTS_CONFIG } from './tokens';
+/**
+ * This service contains all the logic to model the report widget.
+ *
+ * @export
+ */
+export class AjfReportBuilderService {
+    /**
+     * Creates an instance of AjfReportBuilderService.
+     *
+     * @memberOf AjfReportBuilderService
+     */
+    constructor(reportsConfig) {
+        this._customWidgetsUpdate = new Subject();
+        this._originUpdate = new Subject();
+        this._savedReportUpdate = new Subject();
+        this._jsonStack = new BehaviorSubject([]);
+        this._emptyContent = new BehaviorSubject(true);
+        this._onDraggedUpdate = new Subject();
+        this._onOverUpdate = new Subject();
+        this._fixedZoomUpdate = new Subject();
+        this._onDragEnterUpdate = new Subject();
+        this._headerWidgetsUpdate = new Subject();
+        this._contentWidgetsUpdate = new Subject();
+        this._footerWidgetsUpdate = new Subject();
+        this._colorUpdate = new Subject();
+        this._defaultColor = [
+            'rgba(0, 0, 0, 1)', 'rgba(51, 153, 255, 1)', 'rgba(153, 204, 0, 1)',
+            'rgba(255, 102, 0, 1)', 'rgba(0, 204, 204, 1)', 'rgba(204, 204, 153, 1)',
+            'rgba(255, 153, 0, 1)', 'rgba(230, 0, 0, 1)', 'rgba(255, 153, 0, 1)',
+            'rgba(255, 255, 0, 1)', 'rgba(0, 138, 0, 1)', 'rgba(0, 102, 204, 1)',
+            'rgba(153, 51, 255, 1)', 'rgba(255, 255, 255, 1)', 'rgba(250, 204, 204, 1)',
+            'rgba(255, 235, 204, 1)', 'rgba(255, 255, 204, 1)', 'rgba(204, 232, 204, 1)',
+            'rgba(204, 224, 245, 1)', 'rgba(235, 214, 255, 1)', 'rgba(187, 187, 187, 1)',
+            'rgba(240, 102, 102, 1)', 'rgba(255, 194, 102, 1)', 'rgba(255, 255, 102, 1)',
+            'rgba(102, 185, 102, 1)', 'rgba(102, 163, 224, 1)', 'rgba(194, 133, 255, 1)',
+            'rgba(136, 136, 136, 1)', 'rgba(161, 0, 0, 1)', 'rgba(178, 107, 0, 1)',
+            'rgba(178, 178, 0, 1)', 'rgba(0, 97, 0, 1)', 'rgba(0, 71, 178, 1)',
+            'rgba(107, 36, 178, 1)', 'rgba(68, 68, 68, 1)', 'rgba(92, 0, 0, 1)',
+            'rgba(102, 61, 0, 1)', 'rgba(102, 102, 0, 1)', 'rgba(0, 55, 0, 1)',
+            'rgba(0, 41, 102, 1)', 'rgba(61, 20, 102, 1)'
+        ];
+        this._currentWidgetUpdate = new BehaviorSubject(null);
+        this._formsVariablesUpdate = new BehaviorSubject(null);
+        this._conditionNamesUpdate = new BehaviorSubject(null);
+        /**
+         * this BehaviorSubject update export report.
+         *
+         * @memberOf AjfReportBuilderService
+         */
+        this._saveReport = new BehaviorSubject(null);
+        /**
+         * this BehaviorSubject contains the AjfReport.
+         *
+         * @memberOf AjfReportBuilderService
+         */
+        this._report = new BehaviorSubject(null);
+        this._reportStylesUpdate = new Subject();
+        this._reportFormsUpdate = new Subject();
+        /**
+         * dictionary for  widgetsUpdate
+         *
+         * @memberOf AjfReportBuilderService
+         */
+        this._updates = {
+            header: this._headerWidgetsUpdate,
+            content: this._contentWidgetsUpdate,
+            footer: this._footerWidgetsUpdate,
+            color: this._colorUpdate,
+            customWidgets: this._customWidgetsUpdate
+        };
+        /**
+         * event emitter that notify when wont to save report
+         *
+         * @memberOf AjfReportBuilderService
+         */
+        this._saveReportEvent = new EventEmitter();
+        this._saveFormulaTOHtml = new EventEmitter();
+        /**
+         * event emitter that notify when column width changed
+         *
+         * @memberOf AjfReportBuilderService
+         */
+        this.columnWidthChangedEmitter = new EventEmitter();
+        this._iconSets = { 'ajf-icon': [] };
+        this._lastDeletedJson = '';
+        if (reportsConfig != null) {
+            if (reportsConfig.icons != null) {
+                this._iconSets = Object.assign(Object.assign({}, this._iconSets), reportsConfig.icons);
+            }
+        }
+        this._origin = this._originUpdate.pipe(startWith('header'), share());
+        this._savedReport = this._savedReportUpdate.pipe(share());
+        this._onDragged = this._onDraggedUpdate.pipe(startWith(false), share());
+        this._onOver = this._onOverUpdate.pipe(startWith(false), share());
+        this._fixedZoom = this._fixedZoomUpdate.pipe(startWith(false), share());
+        this._onDragEnter = this._onDragEnterUpdate.pipe(share());
+        this._reportStyles = this._reportStylesUpdate
+            .pipe(scan((styles, op) => {
+            return op(styles);
+        }, {}), share(), startWith({}));
+        this._reportForms = this._reportFormsUpdate
+            .pipe(scan((forms, op) => {
+            return op(forms);
+        }, []), share(), startWith([]));
+        this._customWidgets =
+            this._customWidgetsUpdate
+                .pipe(scan((widgets, op) => {
+                return op(widgets);
+            }, []), share(), startWith([]));
+        this._formsVariables =
+            this._formsVariablesUpdate
+                .pipe(filter(s => s != null), scan((variables, op) => {
+                return op(variables);
+            }, []), publishReplay(1), refCount());
+        this._conditionNames =
+            this._conditionNamesUpdate
+                .pipe(filter(s => s != null), scan((variables, op) => {
+                return op(variables);
+            }, []), share(), startWith([]));
+        this._headerWidgets = this._headerWidgetsUpdate
+            .pipe(scan((widgets, op) => {
+            return op(widgets);
+        }, { widgets: [], styles: {} }), startWith({ widgets: [], styles: {} }), publishReplay(1), refCount());
+        this._headerStyles = this._headerWidgets.pipe(map((widgets) => {
+            return widgets != null ? widgets.styles : {};
+        }));
+        this._contentWidgets = this._contentWidgetsUpdate
+            .pipe(scan((widgets, op) => {
+            return op(widgets);
+        }, { widgets: [], styles: {} }), startWith({ widgets: [], styles: {} }), publishReplay(1), refCount());
+        this._contentStyles = this._contentWidgets.pipe(map((widgets) => {
+            return widgets != null ? widgets.styles : {};
+        }));
+        this._footerWidgets = this._footerWidgetsUpdate
+            .pipe(scan((widgets, op) => {
+            return op(widgets);
+        }, { widgets: [], styles: {} }), startWith({ widgets: [], styles: {} }), publishReplay(1), refCount());
+        this._footerStyles = this._footerWidgets.pipe(map((widgets) => {
+            return widgets != null ? widgets.styles : {};
+        }));
+        this._color = this._colorUpdate
+            .pipe(scan((color, op) => {
+            return op(color);
+        }, this._defaultColor), share(), startWith(this._defaultColor));
+        this._currentWidget = this._currentWidgetUpdate.pipe(filter(s => s != null), map(s => s), scan((widget, op) => {
+            return op(widget);
+        }, null), publishReplay(1), refCount());
+        this._reportForms
+            .pipe(filter(f => f.length != 0), map((forms) => {
+            return (_c) => {
+                return this.fillFormsVariables(forms);
+            };
+        }))
+            .subscribe(this._formsVariablesUpdate);
+        this._reportForms
+            .pipe(filter(f => f.length != 0), map((forms) => {
+            return (_c) => {
+                return this.fillFormsVariables(forms);
+            };
+        }))
+            .subscribe(this._conditionNamesUpdate);
+        const reportObs = this._report;
+        reportObs
+            .pipe(map((r) => {
+            return (_colors) => {
+                let tempColors = this._defaultColor;
+                if (r == null) {
+                    return [];
+                }
+                else {
+                    this.parseColor(r.styles, tempColors);
+                    if (r.content) {
+                        this.parseColor(r.content.styles, tempColors);
+                    }
+                    if (r.footer) {
+                        this.parseColor(r.footer.styles, tempColors);
+                    }
+                    if (r.header) {
+                        this.parseColor(r.header.styles, tempColors);
+                        for (let i = 0; i < r.header.content.length; i++) {
+                            let obj = r.header.content[i];
+                            this.parseColor(obj.styles, tempColors);
+                            if (obj.widgetType === AjfWidgetType.Layout) {
+                                let layoutObj = obj;
+                                for (let j = 0; j < layoutObj.content.length; j++) {
+                                    let columnObj = layoutObj.content[j];
+                                    this.parseColor(columnObj.styles, tempColors);
+                                    for (let z = 0; z < columnObj.content.length; z++) {
+                                        let widgetObj = columnObj.content[z];
+                                        this.parseColor(widgetObj.styles, tempColors);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                return tempColors;
+            };
+        }))
+            .subscribe(this._colorUpdate);
+        reportObs
+            .pipe(map((r) => {
+            return (_styles) => {
+                if (r == null || r.styles == null) {
+                    return {};
+                }
+                else {
+                    return r.styles;
+                }
+            };
+        }))
+            .subscribe(this._reportStylesUpdate);
+        reportObs
+            .pipe(map((r) => {
+            return (_widgets) => {
+                if (r == null || r.header == null) {
+                    return { widgets: [], styles: {} };
+                }
+                else {
+                    return {
+                        widgets: r.header.content || [],
+                        styles: r.header.styles || {}
+                    };
+                }
+            };
+        }))
+            .subscribe(this._headerWidgetsUpdate);
+        reportObs
+            .pipe(map((r) => {
+            return (_widgets) => {
+                if (r == null || r.content == null) {
+                    return { widgets: [], styles: {} };
+                }
+                else {
+                    return {
+                        widgets: r.content.content || [],
+                        styles: r.content.styles || {}
+                    };
+                }
+            };
+        }))
+            .subscribe(this._contentWidgetsUpdate);
+        reportObs
+            .pipe(map((r) => {
+            return (_widgets) => {
+                if (r == null || r.footer == null) {
+                    return { widgets: [], styles: {} };
+                }
+                else {
+                    return {
+                        widgets: r.footer.content || [],
+                        styles: r.footer.styles || {}
+                    };
+                }
+            };
+        }))
+            .subscribe(this._footerWidgetsUpdate);
+        this._saveReport.pipe(map((json) => {
+            return (_r) => {
+                if (json = null) {
+                    return {};
+                }
+                return json;
+            };
+        }));
+        this._saveReportEvent
+            .pipe(combineLatest(this.report, this.reportForms), combineLatest(this._headerWidgets.pipe(filter(w => w != null)), this._contentWidgets.pipe(filter(w => w != null)), this._footerWidgets.pipe(filter(w => w != null)), this._reportStyles.pipe(filter(w => w != null))))
+            .subscribe(r => {
+            let obj = {};
+            // const curRo = r[0][1];
+            // const forms = r[0][2] != null ? r[0][2] || []
+            //     : (curRo != null ? curRo.forms || [] : []);
+            const [hco, cco, fco] = [r[1], r[2], r[3]];
+            obj.header = { content: hco.widgets.map(w => deepCopy(w)), styles: hco.styles };
+            obj.content = { content: cco.widgets.map(w => deepCopy(w)), styles: cco.styles };
+            obj.footer = { content: fco.widgets.map(w => deepCopy(w)), styles: fco.styles };
+            obj.styles = r[4];
+            const ro = {
+                header: { content: hco.widgets, styles: hco.styles },
+                content: { content: cco.widgets, styles: cco.styles },
+                footer: { content: fco.widgets, styles: fco.styles },
+                styles: r[4]
+            };
+            this.setSaveReport(obj);
+            this._savedReportUpdate.next(ro);
+            this.pushJsonStack(JSON.stringify(obj));
+        });
+    }
+    getFormulaToHtmlEvent() {
+        return this._saveFormulaTOHtml;
+    }
+    get iconSets() {
+        return this._iconSets;
+    }
+    /**
+     *
+     *  functions
+     *
+     */
+    /**
+     * utils:
+     * remove AjfNodeGroup, AjfSlide, AjfRepeatingSlide, AjfStringField from ajfnode array
+     *
+     * @param nodes
+     *
+     * @memberOf AjfReportBuilderService
+     */
+    filterNodes(nodes) {
+        for (let i = 0; i < nodes.length; i++) {
+            const node = nodes[i];
+            if (node.nodeType === AjfNodeType.AjfNodeGroup || node.nodeType === AjfNodeType.AjfSlide ||
+                node.nodeType === AjfNodeType.AjfRepeatingSlide ||
+                (node.nodeType === AjfNodeType.AjfField &&
+                    node.fieldType === AjfFieldType.String)) {
+                nodes.splice(i, 1);
+                i--;
+            }
+        }
+        return nodes;
+    }
+    parseColor(cssStyles, colors) {
+        const styleKeys = ['background-color', 'backgroundColor', 'color'];
+        styleKeys.forEach((k) => {
+            if (cssStyles[k] && colors.indexOf(cssStyles[k]) == -1) {
+                colors.push(cssStyles[k]);
+            }
+        });
+    }
+    fillFormsVariables(forms) {
+        let variables = [];
+        for (let i = 0; i < forms.length; i++) {
+            variables[i] = { nodes: [], labels: [], names: [], types: [] };
+            if (forms[i].nodes != null && forms[i].nodes.length > 0) {
+                variables[i].nodes = this.filterNodes(flattenNodes(forms[i].nodes));
+            }
+            variables[i].labels = this.extractLabelsNodes(variables[i].nodes);
+            variables[i].names = this.extractNamesNodes(variables[i].nodes);
+            variables[i].types = this.extractTypesNodes(variables[i].nodes);
+        }
+        return variables;
+    }
+    /**
+     * utils:
+     *  the obj returned contains the label field of ajfNode
+     * @param nodes
+     *
+     * @memberOf AjfReportBuilderService
+     */
+    extractLabelsNodes(nodes) {
+        let obj = [];
+        for (let i = 0; i < nodes.length; i++) {
+            obj.push(nodes[i].label);
+        }
+        return obj;
+    }
+    extractNamesNodes(nodes) {
+        let obj = [];
+        for (let i = 0; i < nodes.length; i++) {
+            obj.push(nodes[i].name);
+        }
+        return obj;
+    }
+    extractTypesNodes(nodes) {
+        let obj = [];
+        for (let i = 0; i < nodes.length; i++) {
+            let p = nodes[i];
+            obj.push(p.fieldType);
+        }
+        return obj;
+    }
+    setOrigin(origin) {
+        this._originUpdate.next(origin);
+    }
+    /**
+     * utils:
+     * This method round the value to the decimal position
+     *
+     * @param value
+     * @param decimalpositions
+     *
+     * @memberOf AjfReportBuilderService
+     */
+    roundTo(value, decimalPositions) {
+        let i = value * Math.pow(10, decimalPositions);
+        i = Math.floor(i);
+        return i / Math.pow(10, decimalPositions);
+    }
+    /**
+     * utils:
+     * This validator check if the value is a number.
+     *
+     * @param value
+     *
+     * @memberOf AjfReportBuilderService
+     */
+    isNumber(value) {
+        return /^\d+(\.\d+)?/.test(value);
+    }
+    isNumberArray(value) {
+        for (let i = 0; i < value.length; i++) {
+            if (!this.isNumber(value[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * get _onDragged Observable
+     *
+     * @readonly
+     * @memberOf AjfReportBuilderService
+     */
+    get onDragged() {
+        return this._onDragged;
+    }
+    /**
+     * get _onOver Observable
+     *
+     * @readonly
+     * @memberOf AjfReportBuilderService
+     */
+    get onOver() {
+        return this._onOver;
+    }
+    /**
+     * get _fixedZoom Observable
+     *
+     * @readonly
+     * @memberOf AjfReportBuilderService
+     */
+    get fixedZoom() {
+        return this._fixedZoom;
+    }
+    /**
+     *  change status of _fixedZoom in true
+     *
+     *
+     * @memberOf AjfReportBuilderService
+     */
+    fixedZoomIn() {
+        this._fixedZoomUpdate.next(true);
+    }
+    /**
+     *  change status of _fixedZoom in false
+     *
+     *
+     * @memberOf AjfReportBuilderService
+     */
+    fixedZoomOut() {
+        this._fixedZoomUpdate.next(false);
+    }
+    /**
+     * get _onDragEnter observable
+     *
+     * @readonly
+     * @memberOf AjfReportBuilderService
+     */
+    get onDragEnter() {
+        return this._onDragEnter;
+    }
+    /**
+     *  update _onDragEnter with  section(header,content,footer) and index
+     *
+     * @memberOf AjfReportBuilderService
+     */
+    dragEnter(array, index) {
+        this._onDragEnterUpdate.next({ array, index });
+    }
+    /**
+     *  update _ondragged with true
+     *
+     * @memberOf AjfReportBuilderService
+     */
+    dragStarted() {
+        this._onDraggedUpdate.next(true);
+    }
+    /**
+     *  update _onDragged with false
+     *
+     * @memberOf AjfReportBuilderService
+     */
+    dragEnded() {
+        this._onDraggedUpdate.next(false);
+    }
+    /**
+     *  update _onOver with true
+     *
+     *
+     * @memberOf AjfReportBuilderService
+     */
+    overStarted() {
+        this._onOverUpdate.next(true);
+    }
+    /**
+     * update _onOver with false
+     *
+     *
+     * @memberOf AjfReportBuilderService
+     */
+    overEnded() {
+        this._onOverUpdate.next(false);
+    }
+    /**
+     *
+     *  update _onDragged with false
+     *
+     * @memberOf AjfReportBuilderService
+     */
+    dragLeave() {
+        this._onDragEnterUpdate.next({});
+    }
+    /**
+     * Get the report
+     *
+     * @readonly
+     * @memberOf AjfReportBuilderService
+     */
+    get report() {
+        return this._report;
+    }
+    /**
+     * emit save report event
+     *
+     *
+     * @memberOf AjfReportBuilderService
+     */
+    saveReport() {
+        if (this._saveReportEvent != null) {
+            this._saveReportEvent.emit();
+        }
+    }
+    saveImageFormula(formula) {
+        this._currentWidgetUpdate.next((widget) => {
+            if (widget == null) {
+                return widget;
+            }
+            const w = widget;
+            w.flag = formula;
+            w.icon = formula;
+            return w;
+        });
+    }
+    saveFormulaToHtml(htmlFormula, reference) {
+        if (this._saveFormulaTOHtml != null) {
+            const obj = { 'formula': htmlFormula, 'reference': reference };
+            this._saveFormulaTOHtml.emit(obj);
+        }
+    }
+    setEmptyContent(val) {
+        this._emptyContent.next(val);
+    }
+    pushJsonStack(json) {
+        let currentStack = this._jsonStack.getValue();
+        if (currentStack.indexOf(json) === -1 && json !== this._lastDeletedJson) {
+            currentStack.push(json);
+        }
+        this._jsonStack.next(currentStack);
+    }
+    popJsonStack() {
+        let emptyJson = '{"header":{"content":[],"styles":{}},' +
+            '"content":{"content":[],"styles":{}},"' +
+            'footer":{"content":[],"styles":{}},"styles":{}}';
+        let currentStack = this._jsonStack.getValue();
+        currentStack.pop();
+        this._lastDeletedJson = currentStack.pop();
+        if (currentStack.length <= 0) {
+            this._lastDeletedJson = '';
+            this._jsonStack.next([]);
+            this.updateCurrentWidget(null);
+            this.setEmptyContent(true);
+            return emptyJson;
+        }
+        this._jsonStack.next(currentStack);
+        return this._lastDeletedJson;
+    }
+    /**
+     * get the emitter
+     *
+     * @readonly
+     *
+     * @memberOf AjfReportBuilderService
+     */
+    get columnWidthChanged() {
+        return this.columnWidthChangedEmitter;
+    }
+    /**
+     * get _customWidgets Observable
+     *
+     * @readonly
+     * @memberOf AjfReportBuilderService
+     */
+    get customWidgets() {
+        return this._customWidgets;
+    }
+    /**
+     * Get the header widget
+     *
+     * @readonly
+     * @memberOf AjfReportBuilderService
+     */
+    get headerWidgets() {
+        return this._headerWidgets;
+    }
+    /**
+     * Get the header styles
+     *
+     * @readonly
+     * @memberOf AjfReportBuilderService
+     */
+    get headerStyles() {
+        return this._headerStyles;
+    }
+    /**
+     * Get the Content widget
+     *
+     * @readonly
+     * @memberOf AjfReportBuilderService
+     */
+    get contentWidgets() {
+        return this._contentWidgets;
+    }
+    /**
+     * Get the content styles
+     *
+     * @readonly
+     * @memberOf AjfReportBuilderService
+     */
+    get contentStyles() {
+        return this._contentStyles;
+    }
+    /**
+     * Get the footer widget
+     *
+     * @readonly
+     * @memberOf AjfReportBuilderService
+     */
+    get footerWidgets() {
+        return this._footerWidgets;
+    }
+    /**
+     * Get the footer styles
+     *
+     * @readonly
+     * @memberOf AjfReportBuilderService
+     */
+    get footerStyles() {
+        return this._footerStyles;
+    }
+    /**
+     * Get the colors of report
+     *
+     * @readonly
+     * @memberOf AjfReportBuilderService
+     */
+    get colors() {
+        return this._color;
+    }
+    get emptyContent() {
+        return this._emptyContent;
+    }
+    /**
+     *
+     * @param type
+     * @param newWidget
+     *
+     * @memberOf AjfReportBuilderService
+     */
+    updateArrayWidgets(type, newWidget) {
+        if ((type !== 'header') && (type !== 'content') && (type !== 'footer')) {
+            throw new Error('Unknown type ' + type);
+        }
+        this._updates[type].next((_widgets) => {
+            return newWidget;
+        });
+    }
+    /**
+     * get _formsVariables Observable
+     *
+     * @readonly
+     * @memberOf AjfReportBuilderService
+     */
+    get formsVariables() {
+        return this._formsVariables;
+    }
+    get conditionNames() {
+        return this._conditionNames;
+    }
+    /**
+     * Get the current widget
+     *
+     * @readonly
+     * @memberOf AjfReportBuilderService
+     */
+    get currentWidget() {
+        return this._currentWidget;
+    }
+    /**
+     * This method Update _currentWidgetUpdate with newWidget.
+     *
+     * @param newWidget
+     *
+     * @memberOf AjfReportBuilderService
+     */
+    updateCurrentWidget(newWidget) {
+        this._currentWidgetUpdate.next((_widget) => {
+            this._saveReportEvent.emit();
+            return newWidget;
+        });
+    }
+    /**
+     * Get the report
+     *
+     * @readonly
+     * @memberOf AjfReportBuilderService
+     */
+    get getSaveReport() {
+        return this._saveReport;
+    }
+    /**
+     * get _jsonSavedReport obeservable
+     *
+     * @readonly
+     * @memberOf AjfReportBuilderService
+     */
+    get reportSaved() {
+        return this._savedReport;
+    }
+    /**
+     * get _reportStyles observable
+     *
+     * @readonly
+     * @memberOf AjfReportBuilderService
+     */
+    get reportStyles() {
+        return this._reportStyles;
+    }
+    /**
+     * get _reportForms observable
+     *
+     * @readonly
+     * @memberOf AjfReportBuilderService
+     */
+    get reportForms() {
+        return this._reportForms;
+    }
+    /**
+     * get the _origin Observable
+     *
+     * @readonly
+     * @memberOf AjfReportBuilderService
+     */
+    get origin() {
+        return this._origin;
+    }
+    /**
+     * This method assigns the new width to the idx column
+     * and recalculates the width of the remaining columns of the layout.
+     * The range value are from 0,1 to 1.
+     *
+     * RULES:
+     * The min value for column is 0,1.
+     * The sum of all columns width is always 1.
+     * The method round the values.
+     * If is present only one column the width is always 1.
+     *
+     * When the new value `>` old value:
+     * the width of the remaining columns decreases.
+     * When the new value `<` old value:
+     * the width of the remaining columns increases.
+     *
+     * When values ​​are periodic, rounding assigns the gap to the current value.
+     * For example: 3 columns with 0,33 believe 1 column 0,34 and 2 columns 0,33.
+     *
+     * @param newValue
+     * @param idx
+     *
+     * @memberOf AjfReportBuilderService
+     */
+    instantColumnValue(newValue, idx) {
+        this._currentWidgetUpdate.next((widget) => {
+            if (widget == null) {
+                return widget;
+            }
+            let myObj = widget;
+            let size = myObj.columns.length;
+            let spreadValue = 0;
+            let objNum = 0;
+            let sum = 0;
+            let idxFirstNoObj = -1;
+            let add = false;
+            let foundFirstNoObj = false;
+            let re1 = new RegExp('(^[0]\.\[1-9][0-9]$)');
+            let re2 = new RegExp('(^[0]\.\[1-9]$)');
+            let re3 = new RegExp('^[1]$');
+            let oldValue = myObj.columns[idx];
+            newValue = Number(this.roundTo(newValue, 2).toFixed(2));
+            if (myObj.columns[idx] == null) {
+                throw new Error('invalid value');
+            }
+            for (let j = 0; j < size; j++) {
+                if (myObj.columns[j] === -1) {
+                    objNum++;
+                }
+            }
+            if (oldValue == -1) {
+                oldValue = 0.1;
+                objNum--;
+                newValue = Number(this.roundTo(1 / (size - objNum), 2).toFixed(2));
+                myObj.columns[idx] = 0.1;
+            }
+            else if (oldValue < 0.1) {
+                oldValue = 0.1;
+            }
+            if (newValue !== -1) {
+                if (myObj.columns.length === 1) {
+                    myObj.columns[0] = 1;
+                    return myObj;
+                }
+                if (newValue < 0.1) {
+                    newValue = 0.1;
+                }
+                else if (newValue + 0.1 * (size - objNum - 1) > 1) {
+                    newValue = 1 - (0.1 * (size - objNum - 1));
+                }
+                if ((oldValue === newValue) && (oldValue === 0.1)) {
+                    myObj.columns[idx] = newValue;
+                    return myObj;
+                }
+                if (oldValue > newValue) {
+                    add = true;
+                    spreadValue = (oldValue - newValue) / (size - objNum - 1);
+                }
+                else {
+                    add = false;
+                    spreadValue = (newValue - oldValue) / (size - objNum - 1);
+                }
+                spreadValue = Number(this.roundTo(spreadValue, 2).toFixed(2));
+                if (spreadValue < 0.01) {
+                    spreadValue = 0.1;
+                }
+            }
+            else {
+                myObj.columns[idx] = -1;
+                objNum++;
+                add = true;
+                if (myObj.columns.length == 1) {
+                    spreadValue = 1;
+                }
+                else {
+                    spreadValue = (oldValue) / (size - objNum);
+                }
+            }
+            for (let i = 0; i < size; i++) {
+                if (myObj.columns[i] !== -1) {
+                    if ((i == idx)) {
+                        myObj.columns[idx] = newValue;
+                    }
+                    else {
+                        if (add) {
+                            myObj.columns[i] += spreadValue;
+                            if ((myObj.columns[i] > 0.9) && (myObj.columns.length - objNum != 1)) {
+                                myObj.columns[i] = 0.90;
+                            }
+                        }
+                        else {
+                            myObj.columns[i] -= spreadValue;
+                            if (myObj.columns[i] < 0.1) {
+                                myObj.columns[i] = 0.10;
+                            }
+                        }
+                        myObj.columns[i] = Number(this.roundTo(myObj.columns[i], 2).toFixed(2));
+                        sum += myObj.columns[i];
+                    }
+                    sum = Number(this.roundTo(sum, 2).toFixed(2));
+                    if (foundFirstNoObj == false) {
+                        idxFirstNoObj = i;
+                        foundFirstNoObj = true;
+                    }
+                }
+            }
+            if (newValue === -1) {
+                myObj.columns[idx] = -1;
+                if (foundFirstNoObj) {
+                    myObj.columns[idxFirstNoObj] += Number(this.roundTo(1 - sum, 2).toFixed(2));
+                }
+            }
+            else {
+                myObj.columns[idx] = Number(this.roundTo(1 - sum, 2).toFixed(2));
+            }
+            for (let j = 0; j < myObj.columns.length; j++) {
+                if (myObj.columns[j] !== -1 && !re1.test(String(myObj.columns[j])) &&
+                    !re2.test(String(myObj.columns[j])) && !re3.test(String(myObj.columns[j]))) {
+                    this.instantColumnValue(0.10, j);
+                }
+            }
+            this.columnWidthChangedEmitter.emit();
+            this._saveReportEvent.emit();
+            return myObj;
+        });
+    }
+    /**
+     * This method set the imageUrl on the current AjfImageWidget.
+     *
+     * @param imageUrl
+     *
+     * @memberOf AjfReportBuilderService
+     */
+    setImageUrl(imageUrl) {
+        this._currentWidgetUpdate.next((widget) => {
+            if (widget == null) {
+                return null;
+            }
+            const myObj = widget;
+            myObj.url = createFormula({ formula: `"${imageUrl}"` });
+            return myObj;
+        });
+    }
+    setIcon(icon) {
+        this._currentWidgetUpdate.next((widget) => {
+            if (widget == null) {
+                return null;
+            }
+            const myObj = widget;
+            myObj.icon = createFormula({ formula: `"${icon}"` });
+            return myObj;
+        });
+    }
+    setFlag(value) {
+        this._currentWidgetUpdate.next((widget) => {
+            if (widget == null) {
+                return null;
+            }
+            const myObj = widget;
+            myObj.flag = createFormula({ formula: `"${value}"` });
+            return myObj;
+        });
+    }
+    saveCondition(conditionText) {
+        this._currentWidgetUpdate.next((widget) => {
+            if (widget == null) {
+                return null;
+            }
+            if (widget.visibility != null) {
+                widget.visibility.condition = conditionText;
+            }
+            return widget;
+        });
+    }
+    saveChartFormula(_label, _level, _mainIndex, _index, formulaText, aggregationType) {
+        this._currentWidgetUpdate.next((w) => {
+            if (w == null) {
+                return null;
+            }
+            const widget = w;
+            if (widget != null && widget.dataset != null) {
+                let formula = createFormula({});
+                let aggregation = createAggregation({});
+                // let obj: any;
+                formula.formula = formulaText;
+                aggregation.aggregation = aggregationType;
+                // obj = {
+                //   'formula': formula.toJson(),
+                //   'aggregation': aggregation.toJson(),
+                //   'label': label
+                // };
+                // dataset = AjfDataset.fromJson(obj);
+                // check if the row that contains main data is defined
+                /* if (widget.dataset[0] == null) {
+                  widget.dataset[0] = [];
+                }
+        
+                if (level == 0 && mainIndex == -1 && index == -1) {
+        
+                  widget.dataset[0].push(dataset);
+                } else if (level == 1 && mainIndex == -1 && index == -1) {
+        
+                  widget.dataset[widget.dataset.length] = [];
+                  widget.dataset[widget.dataset.length - 1].push(dataset);
+                } else if (index === - 1) {
+                  widget.dataset[mainIndex + 1].push(dataset);
+                } else {
+                  widget.dataset[mainIndex].splice(index, 1, dataset);
+                } */
+            }
+            return widget;
+        });
+    }
+    saveTableFormula(_label, aggregationType, formulaText, _mainIndex, _index) {
+        this._currentWidgetUpdate.next((w) => {
+            if (w == null) {
+                return null;
+            }
+            const widget = w;
+            if (widget.dataset != null) {
+                let formula = createFormula({});
+                let aggregation = createAggregation({});
+                // let dataset: AjfDataset = new AjfDataset();
+                // let rowDataset: AjfDataset[] = [];
+                // let obj: any;
+                formula.formula = formulaText;
+                aggregation.aggregation = aggregationType;
+                // obj = {
+                //   'formula': formula.toJson(),
+                //   'aggregation': aggregation.toJson(),
+                //   'label': label
+                // };
+                // dataset = AjfDataset.fromJson(obj);
+                /* if (mainIndex === - 1) {
+                  widget.dataset[widget.dataset.length] = [];
+                  widget.dataset[widget.dataset.length - 1].push(dataset);
+                } else {
+                  if (index === -1) {
+                    widget.dataset[mainIndex].push(dataset);
+                  } else {
+                    widget.dataset[mainIndex].splice(index, 1, dataset);
+                  }
+                } */
+            }
+            return widget;
+        });
+    }
+    removeTableMainData(index) {
+        this._removeFromCurrentWidgetArrayProperty('dataset', index);
+    }
+    removeData(_mainIndex, _index) {
+        this._currentWidgetUpdate.next((widget) => {
+            let myObj = widget;
+            /* if (index === -1) {
+              myObj.dataset.splice(mainIndex, 1);
+            } else {
+              myObj.dataset[mainIndex].splice(index, 1);
+            } */
+            return myObj;
+        });
+    }
+    /**
+     * update type field of AjfChartWidget current widget
+     *
+     * @param type
+     *
+     * @memberOf AjfReportBuilderService
+     */
+    setChartType(type) {
+        this._setCurrentWidgetProperty('type', type);
+    }
+    /**
+     * remove  idx element of xLabels field of AjfChartWidget current widget
+     *
+     * @param idx
+     *
+     * @memberOf AjfReportBuilderService
+     */
+    removeMainData(_idx) {
+        this._currentWidgetUpdate.next((widget) => {
+            let myObj = widget;
+            // myObj.dataset[0].splice(idx, 1);
+            return myObj;
+        });
+    }
+    removeRelatedData(_mainIdx, _idx) {
+        this._currentWidgetUpdate.next((widget) => {
+            let myObj = widget;
+            /* if (idx == -1) {
+              myObj.dataset.splice(mainIdx + 1, 1);
+            } else {
+              myObj.dataset[mainIdx + 1].splice(idx, 1);
+            } */
+            return myObj;
+        });
+    }
+    /**
+     * update backgroundColor field of AjfChartWidget current widget
+     *
+     * @param colors
+     *
+     * @memberOf AjfReportBuilderService
+     */
+    setChartBackgroundColor(colors) {
+        this._setCurrentWidgetProperty('backgroundColor', colors);
+    }
+    addChartBackgroundColor(color) {
+        this._addToCurrentWidgetArrayProperty('backgroundColor', color);
+    }
+    removeChartBackgroundColor(idx) {
+        this._removeFromCurrentWidgetArrayProperty('backgroundColor', idx);
+    }
+    /**
+     * update borderColor field of AjfChartWidget current widget
+     *
+     * @param colors
+     *
+     * @memberOf AjfReportBuilderService
+     */
+    setChartBorderColor(colors) {
+        this._setCurrentWidgetProperty('borderColor', colors);
+    }
+    setChartBorderWidth(value) {
+        this._setCurrentWidgetProperty('borderWidth', value);
+    }
+    addChartBorderColor(color) {
+        this._addToCurrentWidgetArrayProperty('borderColor', color);
+    }
+    removeChartBorderColor(idx) {
+        this._removeFromCurrentWidgetArrayProperty('borderColor', idx);
+    }
+    /**
+     * This method set the AjfReport.
+     *
+     * @param report
+     *
+     * @memberOf AjfReportBuilderService
+     */
+    setReport(report) {
+        this._report.next(report);
+    }
+    /**
+     * This method set the export report.
+     *
+     * @param report
+     *
+     * @memberOf AjfReportBuilderService
+     */
+    setSaveReport(json) {
+        this._saveReport.next(json);
+    }
+    /**
+     * This method set the font attribute on the current AjfWidget.
+     *
+     * There is a check on font-size attribute,
+     * if is no specificate the type of size font set 'pt' as default.
+     *
+     * @param label
+     * @param value
+     *
+     * @memberOf AjfReportBuilderService
+     */
+    setWidgetStyles(label, value) {
+        this._currentWidgetUpdate.next((widget) => {
+            let myObj = widget;
+            const pxStyles = ['font-size', 'height', 'width', 'border-width', 'border-radius', 'padding', 'margin'];
+            const isPxStyle = pxStyles.indexOf(label) > -1;
+            if (isPxStyle && !(value instanceof Array) && this.isNumber(value)) {
+                value += 'px';
+            }
+            else if (isPxStyle && value instanceof Array && this.isNumberArray(value)) {
+                value = `${value.join('px ')}px`;
+            }
+            myObj.styles[label] = value;
+            return myObj;
+        });
+    }
+    /**
+     * this method update the styles of origin widget array
+     *
+     * @param origin can be header content or footer
+     * @param label for example background-color
+     * @param value for example rgb(255,255,255,1)
+     *
+     * @memberOf AjfReportBuilderService
+     */
+    setSectionStyles(origin, label, value) {
+        if ((origin !== 'header') && (origin !== 'content') && (origin !== 'footer')) {
+            throw new Error('uncknow origin ' + origin);
+        }
+        this._updates[origin].next((widget) => {
+            widget.styles[label] = value;
+            widget.styles = Object.assign({}, widget.styles);
+            return widget;
+        });
+    }
+    /**
+     * this method set the style of the whole report.
+     *
+     * @param label for example background-color
+     * @param value for example rgb(255,255,255,1)
+     *
+     * @memberOf AjfReportBuilderService
+     */
+    setReportStyles(label, value) {
+        this._reportStylesUpdate.next((styles) => {
+            if (styles == null) {
+                styles = {};
+            }
+            else {
+                styles[label] = value;
+                styles = Object.assign({}, styles);
+            }
+            return styles;
+        });
+    }
+    /**
+     *  update forms
+     *
+     * @param forms
+     *
+     * @memberOf AjfReportBuilderService
+     */
+    setReportForms(forms) {
+        this._reportFormsUpdate.next((_form) => {
+            return forms || [];
+        });
+    }
+    /**
+     * update customWidgets
+     *
+     * @param widget
+     * @param [position]
+     *
+     * @memberOf AjfReportBuilderService
+     */
+    addCustomWidgets(widget, position) {
+        this._customWidgetsUpdate.next((customWidgets) => {
+            customWidgets = customWidgets || [];
+            if (position != null && position >= 0) {
+                customWidgets.splice(position, 0, widget);
+            }
+            else {
+                customWidgets.push(widget);
+            }
+            return customWidgets;
+        });
+    }
+    /**
+     * reset customWidgets
+     *
+     * @param widget
+     * @param [position]
+     *
+     * @memberOf AjfReportBuilderService
+     */
+    resetCustomWidgets() {
+        this._customWidgetsUpdate.next((customWidgets) => {
+            customWidgets.length = 0;
+            return customWidgets;
+        });
+    }
+    /**
+     * update label of widget
+     *
+     * @param label
+     * @param position
+     *
+     * @memberOf AjfReportBuilderService
+     */
+    changeLabelCustomWidget(label, position) {
+        this._customWidgetsUpdate.next((customWidgets) => {
+            customWidgets[position].type = label;
+            return customWidgets;
+        });
+    }
+    /**
+     * Add an AjfWidget on _headerWidgetsUpdate
+     *
+     * @param widget
+     * @param [position]
+     *
+     * @memberOf AjfReportBuilderService
+     */
+    addHeaderWidget(widget, position) {
+        this._addWidgetToContainer(this._headerWidgetsUpdate, widget, position);
+    }
+    /**
+     * Add an AjfWidget on _contentWidgetsUpdate
+     *
+     * @param widget
+     * @param [position]
+     *
+     * @memberOf AjfReportBuilderService
+     */
+    addContentWidget(widget, position) {
+        this._addWidgetToContainer(this._contentWidgetsUpdate, widget, position);
+    }
+    /**
+     * Add an AjfWidget on _footerWidgetsUpdate
+     *
+     * @param widget
+     * @param [position]
+     *
+     * @memberOf AjfReportBuilderService
+     */
+    addfooterWidget(widget, position) {
+        this._addWidgetToContainer(this._footerWidgetsUpdate, widget, position);
+    }
+    unfixedColumn(idx) {
+        this._currentWidgetUpdate.next((widget) => {
+            if (widget == null) {
+                return widget;
+            }
+            let myObj = widget;
+            let num = myObj.columns.length;
+            let checkSum = 0;
+            let objNum = 0;
+            let value = 1;
+            let spreadValue;
+            myObj.columns[idx] = 0;
+            for (let j = 0; j < num; j++) {
+                if (myObj.columns[j] === -1) {
+                    objNum++;
+                }
+            }
+            value = Number(this.roundTo(1 / (num - objNum), 2).toFixed(2));
+            for (let i = 0; i < num; i++) {
+                if (myObj.columns[i] !== -1) {
+                    myObj.columns[i] = value;
+                    checkSum = Number(this.roundTo(checkSum + value, 2).toFixed(2));
+                }
+            }
+            checkSum = Number(this.roundTo(checkSum, 2).toFixed(2));
+            if (checkSum > 1) {
+                spreadValue = parseFloat(this.roundTo(((checkSum - 1) % 1), 2).toFixed(2));
+                myObj.columns[idx] -= spreadValue;
+                myObj.columns[idx] = this.roundTo(myObj.columns[idx], 2);
+            }
+            else if (checkSum < 1) {
+                myObj.columns[idx] += (1 - (checkSum % 1));
+                myObj.columns[idx] = Number(this.roundTo(myObj.columns[idx], 2).toFixed(2));
+            }
+            return myObj;
+        });
+    }
+    /**
+     * Add column on the current AjfLayoutWidget.
+     *
+     * When adding a column the width of the other columns is recalculated
+     * by dividing it by the number of column
+     *
+     * @memberOf AjfReportBuilderService
+     */
+    addColumn() {
+        this._currentWidgetUpdate.next((widget) => {
+            if (widget == null) {
+                return null;
+            }
+            let myObj = widget;
+            let tempObj = [];
+            let num = myObj.columns.length + 1;
+            let checkSum = 0;
+            let objNum = 0;
+            let value = 1;
+            let tmpValue;
+            if (num > 10) {
+                throw new Error('exceed max columns');
+            }
+            for (let j = 0; j < num; j++) {
+                if (myObj.columns[j] === -1) {
+                    objNum++;
+                }
+            }
+            value = Number(this.roundTo(1 / (num - objNum), 2).toFixed(2));
+            for (let i = 0; i < num; i++) {
+                if (myObj.columns[i] === -1) {
+                    tempObj.push(-1);
+                }
+                else {
+                    tempObj.push(value);
+                    checkSum = Number(this.roundTo(checkSum + value, 2).toFixed(2));
+                }
+            }
+            checkSum = Number(this.roundTo(checkSum, 2).toFixed(2));
+            if (checkSum > 1) {
+                tmpValue = parseFloat(this.roundTo(((checkSum - 1) % 1), 2).toFixed(2));
+                tempObj[0] -= tmpValue;
+                tempObj[0] = this.roundTo(tempObj[0], 2);
+            }
+            else if (checkSum < 1) {
+                tempObj[0] += (1 - (checkSum % 1));
+                tempObj[0] = Number(this.roundTo(tempObj[0], 2).toFixed(2));
+            }
+            myObj.columns = tempObj;
+            // TODO: @trik what's value?!?
+            const columnObj = createWidget({
+                widgetType: 7,
+                // value: myObj.columns[myObj.columns.length - 1],
+            });
+            myObj.content.push(columnObj);
+            this._saveReportEvent.emit();
+            return myObj;
+        });
+    }
+    removeWidgetToColumn(column, index) {
+        column.content.splice(index, 1);
+    }
+    /**
+     * This method remove a widget on the current AjfReport.
+     *
+     * @param node
+     * the position array:
+     *
+     * header -`>` headerWidgets
+     * content -`>` contentWidgets
+     * footer -`>` footerWidgets
+     * column -`>` column of layout
+     * layoutContent -`>` content of layout
+     * obj -`>` obj of layout
+     * customWidget -`>` custom widget
+     *
+     * @param idx the position array
+     *
+     * @memberOf AjfReportBuilderService
+     */
+    remove(node, idx) {
+        switch (node) {
+            case 'header':
+            case 'content':
+            case 'footer':
+                this._updates[node].next((widgets) => {
+                    if (widgets.widgets.length === 0) {
+                        throw new Error('you can not remove from empty array');
+                    }
+                    if (widgets.widgets[idx] == null) {
+                        throw new Error('invalid index');
+                    }
+                    widgets.widgets.splice(idx, 1);
+                    this.updateCurrentWidget(null);
+                    return widgets;
+                });
+                break;
+            case 'layout':
+                this._currentWidgetUpdate.next((widget) => {
+                    if (widget == null) {
+                        return null;
+                    }
+                    const myObj = widget;
+                    if (myObj.columns.length === 1) {
+                        myObj.content[0].content.length = 0;
+                        return myObj;
+                    }
+                    if (myObj.columns[idx] == null) {
+                        throw new Error('this content is undefined');
+                    }
+                    else {
+                        let spread = myObj.columns[idx] / (myObj.columns.length - 1);
+                        if (myObj.columns.length > 1) {
+                            myObj.columns.splice(idx, 1);
+                            myObj.content.splice(idx, 1);
+                        }
+                        for (let i = 0; i < myObj.columns.length; i++) {
+                            myObj.columns[i] += spread;
+                        }
+                        this.instantColumnValue(myObj.columns[0], 0);
+                    }
+                    return myObj;
+                });
+                break;
+            case 'column':
+            case 'layoutContent':
+            case 'unfixedColumn':
+                this._currentWidgetUpdate.next((widget) => {
+                    if (widget == null) {
+                        return null;
+                    }
+                    let myObj = widget;
+                    if (node === 'column') {
+                        let clm = widget;
+                        clm.content.splice(idx, 1);
+                    }
+                    else if (node === 'layoutContent') {
+                        if (myObj.columns.length === 0) {
+                            throw new Error('the column length is 0');
+                        }
+                        if (myObj.content.length === 0) {
+                            throw new Error('can not remove any widget from empty content');
+                        }
+                        if (myObj.columns[idx] != null && myObj.content[idx] == null) {
+                            throw new Error('this content is undefined');
+                        }
+                    }
+                    else if (node === 'unfixedColumn') {
+                        if (myObj.columns[idx] !== -1) {
+                            throw new Error('the column position value  isnt -1');
+                        }
+                        this.unfixedColumn(idx);
+                    }
+                    // if (node !== 'obj') {
+                    //   let spread = myObj.columns[idx] / (myObj.columns.length - 1);
+                    //   myObj.content.splice(idx, 1);
+                    //   if (myObj.columns.length > 1) {
+                    //     myObj.columns.splice(idx, 1);
+                    //   }
+                    //   for (let i = 0; i < myObj.columns.length; i++) {
+                    //     myObj.columns[i] += spread;
+                    //   }
+                    //   this.instantColumnValue(myObj.columns[0], 0);
+                    // }
+                    return myObj;
+                });
+                break;
+            case 'customWidgets':
+                {
+                    this._updates[node].next((widgets) => {
+                        if (widgets.length === 0) {
+                            throw new Error('you can not remove from empty array');
+                        }
+                        if (widgets[idx] == null) {
+                            throw new Error('invalid index');
+                        }
+                        widgets.splice(idx, 1);
+                        return widgets;
+                    });
+                }
+                break;
+            default:
+                throw new Error('unknown node ' + node);
+        }
+    }
+    /**
+     * This method add a AjfWidget on the current AjfLayoutWidget.
+     *
+     * @param newWidget
+     * @param idx
+     *
+     * @memberOf AjfReportBuilderService
+     */
+    addToContent(newWidget, idx) {
+        this._currentWidgetUpdate.next((widget) => {
+            if (widget == null) {
+                return null;
+            }
+            let myObj = widget;
+            if (myObj.content[idx] != null) {
+                myObj.content.splice(idx, 1);
+            }
+            myObj.content.splice(idx, 0, newWidget);
+            return myObj;
+        });
+    }
+    addToColumn(event, toColumn, position) {
+        if (event.dragData && event.dragData.fromColumn != null) {
+            let fromColumn = event.dragData.fromColumn;
+            let widget = event.dragData.widget;
+            let fromIndex = event.dragData.fromIndex;
+            fromColumn.content.splice(fromIndex, 1);
+            toColumn.content.push(widget);
+        }
+        else if (event.dragData && event.dragData.arrayFrom) {
+            this.remove(event.dragData.arrayFrom, event.dragData.fromIndex);
+            toColumn.content.push(event.dragData.widget);
+        }
+        else if (event.dragData && event.dragData.json) {
+            let obj = JSON.parse(event.dragData.json);
+            let newWidget = deepCopy(obj);
+            if (position != null) {
+                toColumn.content.splice(position, 0, newWidget);
+            }
+            else {
+                toColumn.content.push(newWidget);
+            }
+        }
+        else {
+            let obj = { 'widgetType': AjfWidgetType[event.dragData] };
+            let newWidget = deepCopy(obj);
+            if (position != null) {
+                toColumn.content.splice(position, 0, newWidget);
+            }
+            else {
+                toColumn.content.push(newWidget);
+            }
+        }
+    }
+    changePositionOnColumn(event, toColumn, toIndex) {
+        let fromColumn = event.dragData.fromColumn;
+        let fromIndex = event.dragData.fromIndex;
+        let fromWidget = fromColumn.content[fromIndex];
+        let toWidget = fromColumn.content[toIndex];
+        if (fromColumn == toColumn) {
+            fromColumn.content[fromIndex] = toWidget;
+            fromColumn.content[toIndex] = fromWidget;
+        }
+        else {
+            fromColumn.content.splice(fromIndex, 1);
+            toColumn.content.splice(toIndex, 0, fromWidget);
+        }
+    }
+    /**
+     * This method add the obj on the idx position.
+     * Obj have a no specificate width and is not calculate as columns
+     *
+     * @param idx
+     *
+     * @memberOf AjfReportBuilderService
+     */
+    fixedColumn(idx) {
+        this.instantColumnValue(-1, idx);
+    }
+    changeColumn(from, to, layoutWidget) {
+        if (to < 0 || to >= layoutWidget.content.length) {
+            return;
+        }
+        if (from > layoutWidget.content.length - 1 && to > from) {
+            return;
+        }
+        let fromColumn = layoutWidget.content[from];
+        let fromColumnValue = layoutWidget.columns[from];
+        let toColumn = layoutWidget.content[to];
+        let toColumnValue = layoutWidget.columns[to];
+        layoutWidget.content[from] = toColumn;
+        layoutWidget.columns[from] = toColumnValue;
+        layoutWidget.content[to] = fromColumn;
+        layoutWidget.columns[to] = fromColumnValue;
+        this.updateCurrentWidget(layoutWidget);
+    }
+    addCustomColor(color) {
+        this._updates['color'].next((colors) => {
+            if (colors.indexOf(color) < 0) {
+                colors.push(color);
+            }
+            return colors;
+        });
+    }
+    _addWidgetToContainer(subj, widget, position) {
+        subj.next((widgets) => {
+            if (position != null && position >= 0) {
+                widgets.widgets.splice(position, 0, widget);
+            }
+            else {
+                widgets.widgets.push(widget);
+            }
+            return widgets;
+        });
+        this.updateCurrentWidget(widget);
+        this.setEmptyContent(false);
+    }
+    _setCurrentWidgetProperty(propName, value) {
+        this._currentWidgetUpdate.next((widget) => {
+            if (widget == null) {
+                return null;
+            }
+            widget[propName] = value;
+            return widget;
+        });
+    }
+    _addToCurrentWidgetArrayProperty(propName, value) {
+        this._currentWidgetUpdate.next((widget) => {
+            if (widget == null) {
+                return null;
+            }
+            const arr = widget[propName];
+            arr.push(value);
+            widget[propName] = arr;
+            return widget;
+        });
+    }
+    _removeFromCurrentWidgetArrayProperty(propName, idx) {
+        this._currentWidgetUpdate.next((widget) => {
+            widget[propName].splice(idx, 1);
+            return widget;
+        });
+    }
+}
+AjfReportBuilderService.decorators = [
+    { type: Injectable }
+];
+AjfReportBuilderService.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [AJF_REPORTS_CONFIG,] }] }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"report-builder-service.js","sourceRoot":"","sources":["../../../../../../src/material/report-builder/report-builder-service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright (C) Gnucoop soc. coop.\n *\n * This file is part of the Advanced JSON forms (ajf).\n *\n * Advanced JSON forms (ajf) is free software: you can redistribute it and/or\n * modify it under the terms of the GNU Affero General Public License as\n * published by the Free Software Foundation, either version 3 of the License,\n * or (at your option) any later version.\n *\n * Advanced JSON forms (ajf) is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero\n * General Public License for more details.\n *\n * You should have received a copy of the GNU Affero General Public License\n * along with Advanced JSON forms (ajf).\n * If not, see http://www.gnu.org/licenses/.\n *\n */\n\nimport {AjfField, AjfFieldType, AjfForm, AjfNode, AjfNodeType, flattenNodes} from '@ajf/core/forms';\nimport {AjfFormula, createFormula} from '@ajf/core/models';\nimport {\n  AjfAggregation,\n  AjfChartWidget,\n  AjfColumnWidget,\n  AjfCustomWidget,\n  AjfDataWidget,\n  AjfImageWidget,\n  AjfLayoutWidget,\n  AjfReport,\n  AjfReportContainer,\n  AjfStyles,\n  AjfTableWidget,\n  AjfTextWidget,\n  AjfWidget,\n  AjfWidgetType,\n  createAggregation,\n  createWidget\n} from '@ajf/core/reports';\nimport {deepCopy} from '@ajf/core/utils';\nimport {EventEmitter, Inject, Injectable, Optional} from '@angular/core';\nimport {BehaviorSubject, Observable, Subject} from 'rxjs';\nimport {\n  combineLatest,\n  filter,\n  map,\n  publishReplay,\n  refCount,\n  scan,\n  share,\n  startWith\n} from 'rxjs/operators';\n\nimport {AjfFormVariables, AjfReportIcons, AjfReportsConfig, AjfWidgetsContainer} from './models';\nimport {\n  AjfColorOperation,\n  AjfCustomWidgetsOperation,\n  AjfFormVariablesOperation,\n  AjfReportFormsOperation,\n  AjfStylesOperation,\n  AjfWidgetOperation,\n  AjfWidgetsOperation\n} from './operations';\nimport {AJF_REPORTS_CONFIG} from './tokens';\n\n/**\n * This service contains all the logic to model the report widget.\n *\n * @export\n */\n@Injectable()\nexport class AjfReportBuilderService {\n  /**\n   *  this Observable observe the customWidgets obj\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  private _customWidgets: Observable<AjfCustomWidget[]>;\n  private _customWidgetsUpdate: Subject<AjfCustomWidgetsOperation> =\n      new Subject<AjfCustomWidgetsOperation>();\n\n  /**\n   * this Observable observe the name of the section that contains the current widget.\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  private _origin: Observable<string>;\n  private _originUpdate: Subject<string> = new Subject<string>();\n\n  /**\n   * this Observable observe the exported json\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  private _savedReport: Observable<AjfReport>;\n  private _savedReportUpdate: Subject<AjfReport> = new Subject<AjfReport>();\n\n  private _jsonStack: BehaviorSubject<string[]> = new BehaviorSubject<string[]>([]);\n\n  private _lastDeletedJson: string|undefined;\n\n  private _emptyContent: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(true);\n\n  /**\n   *  this Observable observe if is fired drag mouse event.\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  private _onDragged: Observable<boolean>;\n  private _onDraggedUpdate: Subject<boolean> = new Subject<boolean>();\n\n\n  private _onOver: Observable<boolean>;\n  private _onOverUpdate: Subject<boolean> = new Subject<boolean>();\n\n\n  /**\n   * this Observable observe the status of permanent zoom\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  private _fixedZoom: Observable<boolean>;\n  private _fixedZoomUpdate: Subject<boolean> = new Subject<boolean>();\n\n\n  /**\n   *  this Observable observe if is fired drag mouse event.\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  private _onDragEnter: Observable<any>;\n  private _onDragEnterUpdate: Subject<any> = new Subject<any>();\n\n  /**\n   * Observe the header widget array.\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  private _headerWidgets: Observable<AjfWidgetsContainer>;\n  private _headerWidgetsUpdate: Subject<AjfWidgetsOperation> = new Subject<AjfWidgetsOperation>();\n\n  /**\n   * observe the header styles.\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  private _headerStyles: Observable<AjfStyles>;\n\n  /**\n   * Observe the content widget array\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  private _contentWidgets: Observable<AjfWidgetsContainer>;\n  private _contentWidgetsUpdate: Subject<AjfWidgetsOperation> = new Subject<AjfWidgetsOperation>();\n\n  /**\n   * this Observable observe the content styles.\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  private _contentStyles: Observable<AjfStyles>;\n\n  /**\n   * this Observable observe the footer widget array.\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  private _footerWidgets: Observable<AjfWidgetsContainer>;\n  private _footerWidgetsUpdate: Subject<AjfWidgetsOperation> = new Subject<AjfWidgetsOperation>();\n\n\n  private _color: Observable<string[]>;\n  private _colorUpdate: Subject<AjfColorOperation> = new Subject<AjfColorOperation>();\n  private _defaultColor: string[] = [\n    'rgba(0, 0, 0, 1)',       'rgba(51, 153, 255, 1)',  'rgba(153, 204, 0, 1)',\n    'rgba(255, 102, 0, 1)',   'rgba(0, 204, 204, 1)',   'rgba(204, 204, 153, 1)',\n    'rgba(255, 153, 0, 1)',   'rgba(230, 0, 0, 1)',     'rgba(255, 153, 0, 1)',\n    'rgba(255, 255, 0, 1)',   'rgba(0, 138, 0, 1)',     'rgba(0, 102, 204, 1)',\n    'rgba(153, 51, 255, 1)',  'rgba(255, 255, 255, 1)', 'rgba(250, 204, 204, 1)',\n    'rgba(255, 235, 204, 1)', 'rgba(255, 255, 204, 1)', 'rgba(204, 232, 204, 1)',\n    'rgba(204, 224, 245, 1)', 'rgba(235, 214, 255, 1)', 'rgba(187, 187, 187, 1)',\n    'rgba(240, 102, 102, 1)', 'rgba(255, 194, 102, 1)', 'rgba(255, 255, 102, 1)',\n    'rgba(102, 185, 102, 1)', 'rgba(102, 163, 224, 1)', 'rgba(194, 133, 255, 1)',\n    'rgba(136, 136, 136, 1)', 'rgba(161, 0, 0, 1)',     'rgba(178, 107, 0, 1)',\n    'rgba(178, 178, 0, 1)',   'rgba(0, 97, 0, 1)',      'rgba(0, 71, 178, 1)',\n    'rgba(107, 36, 178, 1)',  'rgba(68, 68, 68, 1)',    'rgba(92, 0, 0, 1)',\n    'rgba(102, 61, 0, 1)',    'rgba(102, 102, 0, 1)',   'rgba(0, 55, 0, 1)',\n    'rgba(0, 41, 102, 1)',    'rgba(61, 20, 102, 1)'\n  ];\n\n\n  /**\n   * this Observable observe the footer styles.\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  private _footerStyles: Observable<AjfStyles>;\n\n  /**\n   *  this Observable observe the current widget which holds the focus.\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  private _currentWidget: Observable<AjfWidget|null>;\n  private _currentWidgetUpdate: BehaviorSubject<AjfWidgetOperation|null> =\n      new BehaviorSubject<AjfWidgetOperation|null>(null);\n\n\n  /**\n   * Observe the AjfFormVariables exploit for field selecting from forms\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  private _formsVariables: Observable<AjfFormVariables[]>;\n  private _formsVariablesUpdate: BehaviorSubject<AjfFormVariablesOperation|null> =\n      new BehaviorSubject<AjfFormVariablesOperation|null>(null);\n\n  /**\n   * Observe the AjfFormVariables exploit for field selecting from forms\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  private _conditionNames: Observable<AjfFormVariables[]>;\n  private _conditionNamesUpdate: BehaviorSubject<AjfFormVariablesOperation|null> =\n      new BehaviorSubject<AjfFormVariablesOperation|null>(null);\n\n  /**\n   * this BehaviorSubject update export report.\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  private _saveReport: BehaviorSubject<any> = new BehaviorSubject<any>(null);\n\n  /**\n   * this BehaviorSubject contains the AjfReport.\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  private _report: BehaviorSubject<AjfReport|null> = new BehaviorSubject<AjfReport|null>(null);\n\n  /**\n   *  this Observable observe the styles of report.\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  private _reportStyles: Observable<AjfStyles>;\n  private _reportStylesUpdate: Subject<AjfStylesOperation> = new Subject<AjfStylesOperation>();\n\n  /**\n   * observe the forms fetched\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  private _reportForms: Observable<AjfForm[]>;\n  private _reportFormsUpdate: Subject<AjfReportFormsOperation> =\n      new Subject<AjfReportFormsOperation>();\n\n  /**\n   * dictionary for  widgetsUpdate\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  private _updates: any = {\n    header: this._headerWidgetsUpdate,\n    content: this._contentWidgetsUpdate,\n    footer: this._footerWidgetsUpdate,\n    color: this._colorUpdate,\n    customWidgets: this._customWidgetsUpdate\n  };\n\n  /**\n   * event emitter that notify when wont to save report\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  private _saveReportEvent: EventEmitter<void> = new EventEmitter<void>();\n\n  private _saveFormulaTOHtml: EventEmitter<any> = new EventEmitter<any>();\n\n  getFormulaToHtmlEvent(): Observable<string> {\n    return this._saveFormulaTOHtml as Observable<string>;\n  }\n\n  /**\n   * event emitter that notify when column width changed\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  columnWidthChangedEmitter: EventEmitter<void> = new EventEmitter<void>();\n\n  private _iconSets: AjfReportIcons = {'ajf-icon': []};\n  get iconSets(): AjfReportIcons {\n    return this._iconSets;\n  }\n\n  /**\n   * Creates an instance of AjfReportBuilderService.\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  constructor(@Optional() @Inject(AJF_REPORTS_CONFIG) reportsConfig: AjfReportsConfig) {\n    this._lastDeletedJson = '';\n\n    if (reportsConfig != null) {\n      if (reportsConfig.icons != null) {\n        this._iconSets = {...this._iconSets, ...reportsConfig.icons};\n      }\n    }\n\n    this._origin = (<Observable<string>>this._originUpdate).pipe(startWith('header'), share());\n\n    this._savedReport = (<Observable<AjfReport>>this._savedReportUpdate).pipe(share());\n\n    this._onDragged = (<Observable<boolean>>this._onDraggedUpdate).pipe(startWith(false), share());\n\n    this._onOver = (<Observable<boolean>>this._onOverUpdate).pipe(startWith(false), share());\n\n    this._fixedZoom = (<Observable<boolean>>this._fixedZoomUpdate).pipe(startWith(false), share());\n\n    this._onDragEnter = this._onDragEnterUpdate.pipe(share());\n\n    this._reportStyles = (<Observable<AjfStylesOperation>>this._reportStylesUpdate)\n                             .pipe(scan((styles: AjfStyles, op: AjfStylesOperation) => {\n                                     return op(styles);\n                                   }, <AjfStyles>{}), share(), startWith(<AjfStyles>{}));\n\n    this._reportForms = (<Observable<AjfReportFormsOperation>>this._reportFormsUpdate)\n                            .pipe(scan((forms: AjfForm[], op: AjfReportFormsOperation) => {\n                                    return op(forms);\n                                  }, []), share(), startWith([]));\n\n    this._customWidgets =\n        (<Observable<AjfCustomWidgetsOperation>>this._customWidgetsUpdate)\n            .pipe(scan((widgets: AjfCustomWidget[], op: AjfCustomWidgetsOperation) => {\n                    return op(widgets);\n                  }, []), share(), startWith([]));\n\n    this._formsVariables =\n        (<Observable<AjfFormVariablesOperation>>this._formsVariablesUpdate)\n            .pipe(\n                filter(s => s != null),\n                scan((variables: AjfFormVariables[], op: AjfFormVariablesOperation) => {\n                  return op(variables);\n                }, []), publishReplay(1), refCount());\n\n    this._conditionNames =\n        (<Observable<AjfFormVariablesOperation>>this._conditionNamesUpdate)\n            .pipe(\n                filter(s => s != null),\n                scan((variables: AjfFormVariables[], op: AjfFormVariablesOperation) => {\n                  return op(variables);\n                }, []), share(), startWith([]));\n\n    this._headerWidgets = (<Observable<AjfWidgetsOperation>>this._headerWidgetsUpdate)\n                              .pipe(\n                                  scan(\n                                      (widgets: AjfWidgetsContainer, op: AjfWidgetsOperation) => {\n                                        return op(widgets);\n                                      },\n                                      <AjfWidgetsContainer>{widgets: [], styles: {}}),\n                                  startWith(<AjfWidgetsContainer>{widgets: [], styles: {}}),\n                                  publishReplay(1), refCount());\n\n    this._headerStyles = this._headerWidgets.pipe(map((widgets: AjfWidgetsContainer) => {\n      return widgets != null ? widgets.styles : {};\n    }));\n\n    this._contentWidgets = (<Observable<AjfWidgetsOperation>>this._contentWidgetsUpdate)\n                               .pipe(\n                                   scan(\n                                       (widgets: AjfWidgetsContainer, op: AjfWidgetsOperation) => {\n                                         return op(widgets);\n                                       },\n                                       <AjfWidgetsContainer>{widgets: [], styles: {}}),\n                                   startWith(<AjfWidgetsContainer>{widgets: [], styles: {}}),\n                                   publishReplay(1), refCount());\n\n    this._contentStyles = this._contentWidgets.pipe(map((widgets: AjfWidgetsContainer) => {\n      return widgets != null ? widgets.styles : {};\n    }));\n\n    this._footerWidgets = (<Observable<AjfWidgetsOperation>>this._footerWidgetsUpdate)\n                              .pipe(\n                                  scan(\n                                      (widgets: AjfWidgetsContainer, op: AjfWidgetsOperation) => {\n                                        return op(widgets);\n                                      },\n                                      <AjfWidgetsContainer>{widgets: [], styles: {}}),\n                                  startWith(<AjfWidgetsContainer>{widgets: [], styles: {}}),\n                                  publishReplay(1), refCount());\n\n    this._footerStyles = this._footerWidgets.pipe(map((widgets: AjfWidgetsContainer) => {\n      return widgets != null ? widgets.styles : {};\n    }));\n\n    this._color = (<Observable<AjfColorOperation>>this._colorUpdate)\n                      .pipe(scan((color: string[], op: AjfColorOperation) => {\n                              return op(color);\n                            }, this._defaultColor), share(), startWith(this._defaultColor));\n\n    this._currentWidget = this._currentWidgetUpdate.pipe(\n        filter(s => s != null),\n        map(s => s!),\n        scan(\n            (widget: AjfWidget|null, op: AjfWidgetOperation) => {\n              return op(widget);\n            },\n            null as unknown as AjfWidget),\n        publishReplay(1),\n        refCount(),\n    );\n\n    this._reportForms\n        .pipe(filter(f => f.length != 0), map((forms: AjfForm[]) => {\n                return (_c: AjfFormVariables[]): AjfFormVariables[] => {\n                  return this.fillFormsVariables(forms);\n                };\n              }))\n        .subscribe(this._formsVariablesUpdate);\n\n    this._reportForms\n        .pipe(filter(f => f.length != 0), map((forms: AjfForm[]) => {\n                return (_c: AjfFormVariables[]): AjfFormVariables[] => {\n                  return this.fillFormsVariables(forms);\n                };\n              }))\n        .subscribe(this._conditionNamesUpdate);\n\n    const reportObs = this._report;\n\n    reportObs\n        .pipe(map((r: AjfReport|null) => {\n          return (_colors: string[]): string[] => {\n            let tempColors: string[] = this._defaultColor;\n            if (r == null) {\n              return [];\n            } else {\n              this.parseColor(r.styles, tempColors);\n              if (r.content) {\n                this.parseColor(r.content.styles, tempColors);\n              }\n              if (r.footer) {\n                this.parseColor(r.footer.styles, tempColors);\n              }\n              if (r.header) {\n                this.parseColor(r.header.styles, tempColors);\n                for (let i = 0; i < r.header.content.length; i++) {\n                  let obj = r.header.content[i];\n                  this.parseColor(obj.styles, tempColors);\n                  if (obj.widgetType === AjfWidgetType.Layout) {\n                    let layoutObj = obj as AjfLayoutWidget;\n                    for (let j = 0; j < layoutObj.content.length; j++) {\n                      let columnObj = layoutObj.content[j] as AjfColumnWidget;\n                      this.parseColor(columnObj.styles, tempColors);\n                      for (let z = 0; z < columnObj.content.length; z++) {\n                        let widgetObj = columnObj.content[z];\n                        this.parseColor(widgetObj.styles, tempColors);\n                      }\n                    }\n                  }\n                }\n              }\n            }\n            return <string[]>tempColors;\n          };\n        }))\n        .subscribe(this._colorUpdate);\n\n    reportObs\n        .pipe(map((r: AjfReport|null) => {\n          return (_styles: AjfStyles): AjfStyles => {\n            if (r == null || r.styles == null) {\n              return <AjfStyles>{};\n            } else {\n              return <AjfStyles>r.styles;\n            }\n          };\n        }))\n        .subscribe(this._reportStylesUpdate);\n\n    reportObs\n        .pipe(map((r: AjfReport|null) => {\n          return (_widgets: AjfWidgetsContainer): AjfWidgetsContainer => {\n            if (r == null || r.header == null) {\n              return <AjfWidgetsContainer>{widgets: [], styles: {}};\n            } else {\n              return <AjfWidgetsContainer>{\n                widgets: r.header.content || [],\n                styles: r.header.styles || {}\n              };\n            }\n          };\n        }))\n        .subscribe(this._headerWidgetsUpdate);\n\n    reportObs\n        .pipe(map((r: AjfReport|null) => {\n          return (_widgets: AjfWidgetsContainer): AjfWidgetsContainer => {\n            if (r == null || r.content == null) {\n              return <AjfWidgetsContainer>{widgets: [], styles: {}};\n            } else {\n              return <AjfWidgetsContainer>{\n                widgets: r.content.content || [],\n                styles: r.content.styles || {}\n              };\n            }\n          };\n        }))\n        .subscribe(this._contentWidgetsUpdate);\n\n    reportObs\n        .pipe(map((r: AjfReport|null) => {\n          return (_widgets: AjfWidgetsContainer): AjfWidgetsContainer => {\n            if (r == null || r.footer == null) {\n              return <AjfWidgetsContainer>{widgets: [], styles: {}};\n            } else {\n              return <AjfWidgetsContainer>{\n                widgets: r.footer.content || [],\n                styles: r.footer.styles || {}\n              };\n            }\n          };\n        }))\n        .subscribe(this._footerWidgetsUpdate);\n\n    this._saveReport.pipe(map((json: any) => {\n      return (_r: any): any => {\n        if (json = null) {\n          return {};\n        }\n        return json;\n      };\n    }));\n\n    this._saveReportEvent\n        .pipe(\n            combineLatest(this.report, this.reportForms),\n            combineLatest(\n                this._headerWidgets.pipe(filter(w => w != null)),\n                this._contentWidgets.pipe(filter(w => w != null)),\n                this._footerWidgets.pipe(filter(w => w != null)),\n                this._reportStyles.pipe(filter(w => w != null)),\n                ))\n        .subscribe(r => {\n          let obj: any = {};\n          // const curRo = r[0][1];\n          // const forms = r[0][2] != null ? r[0][2] || []\n          //     : (curRo != null ? curRo.forms || [] : []);\n\n          const [hco, cco, fco] = [r[1], r[2], r[3]] as AjfWidgetsContainer[];\n\n          obj.header = {content: hco.widgets.map(w => deepCopy(w)), styles: hco.styles} as\n              AjfReportContainer;\n          obj.content = {content: cco.widgets.map(w => deepCopy(w)), styles: cco.styles} as\n              AjfReportContainer;\n          obj.footer = {content: fco.widgets.map(w => deepCopy(w)), styles: fco.styles} as\n              AjfReportContainer;\n          obj.styles = r[4];\n\n          const ro = {\n            header: {content: hco.widgets, styles: hco.styles},\n            content: {content: cco.widgets, styles: cco.styles},\n            footer: {content: fco.widgets, styles: fco.styles},\n            styles: r[4]\n          } as AjfReport;\n\n          this.setSaveReport(obj);\n          this._savedReportUpdate.next(ro);\n          this.pushJsonStack(JSON.stringify(obj));\n        });\n  }\n\n  /**\n   *\n   *  functions\n   *\n   */\n\n  /**\n   * utils:\n   * remove AjfNodeGroup, AjfSlide, AjfRepeatingSlide, AjfStringField from ajfnode array\n   *\n   * @param nodes\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  filterNodes(nodes: AjfNode[]): AjfNode[] {\n    for (let i = 0; i < nodes.length; i++) {\n      const node = nodes[i];\n      if (node.nodeType === AjfNodeType.AjfNodeGroup || node.nodeType === AjfNodeType.AjfSlide ||\n          node.nodeType === AjfNodeType.AjfRepeatingSlide ||\n          (node.nodeType === AjfNodeType.AjfField &&\n           (node as AjfField).fieldType === AjfFieldType.String)) {\n        nodes.splice(i, 1);\n        i--;\n      }\n    }\n    return nodes;\n  }\n\n  parseColor(cssStyles: any, colors: string[]): void {\n    const styleKeys = ['background-color', 'backgroundColor', 'color'];\n    styleKeys.forEach((k) => {\n      if (cssStyles[k] && colors.indexOf(cssStyles[k]) == -1) {\n        colors.push(cssStyles[k]);\n      }\n    });\n  }\n\n  fillFormsVariables(forms: AjfForm[]) {\n    let variables: AjfFormVariables[] = [];\n    for (let i = 0; i < forms.length; i++) {\n      variables[i] = {nodes: [], labels: [], names: [], types: []};\n\n      if (forms[i].nodes != null && forms[i].nodes.length > 0) {\n        variables[i].nodes = this.filterNodes(flattenNodes(forms[i].nodes));\n      }\n      variables[i].labels = this.extractLabelsNodes(variables[i].nodes);\n      variables[i].names = this.extractNamesNodes(variables[i].nodes);\n      variables[i].types = this.extractTypesNodes(variables[i].nodes);\n    }\n    return variables;\n  }\n  /**\n   * utils:\n   *  the obj returned contains the label field of ajfNode\n   * @param nodes\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  extractLabelsNodes(nodes: AjfNode[]): any {\n    let obj: string[] = [];\n    for (let i = 0; i < nodes.length; i++) {\n      obj.push(nodes[i].label);\n    }\n    return obj;\n  }\n\n  extractNamesNodes(nodes: AjfNode[]): any {\n    let obj: string[] = [];\n    for (let i = 0; i < nodes.length; i++) {\n      obj.push(nodes[i].name);\n    }\n    return obj;\n  }\n  extractTypesNodes(nodes: AjfNode[]): any {\n    let obj: AjfFieldType[] = [];\n    for (let i = 0; i < nodes.length; i++) {\n      let p: AjfField = <AjfField>nodes[i];\n      obj.push(p.fieldType);\n    }\n    return obj;\n  }\n\n  setOrigin(origin: string): void {\n    this._originUpdate.next(origin);\n  }\n\n  /**\n   * utils:\n   * This method round the value to the decimal position\n   *\n   * @param value\n   * @param decimalpositions\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  roundTo(value: number, decimalPositions: number) {\n    let i = value * Math.pow(10, decimalPositions);\n\n    i = Math.floor(i);\n\n    return i / Math.pow(10, decimalPositions);\n  }\n\n  /**\n   * utils:\n   * This validator check if the value is a number.\n   *\n   * @param value\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  isNumber(value: any): boolean {\n    return /^\\d+(\\.\\d+)?/.test(value);\n  }\n\n  isNumberArray(value: any[]): boolean {\n    for (let i = 0; i < value.length; i++) {\n      if (!this.isNumber(value[i])) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  /**\n   * get _onDragged Observable\n   *\n   * @readonly\n   * @memberOf AjfReportBuilderService\n   */\n  get onDragged(): Observable<any> {\n    return this._onDragged;\n  }\n\n  /**\n   * get _onOver Observable\n   *\n   * @readonly\n   * @memberOf AjfReportBuilderService\n   */\n  get onOver(): Observable<any> {\n    return this._onOver;\n  }\n\n  /**\n   * get _fixedZoom Observable\n   *\n   * @readonly\n   * @memberOf AjfReportBuilderService\n   */\n  get fixedZoom(): Observable<boolean> {\n    return this._fixedZoom;\n  }\n\n  /**\n   *  change status of _fixedZoom in true\n   *\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  fixedZoomIn(): void {\n    this._fixedZoomUpdate.next(true);\n  }\n\n  /**\n   *  change status of _fixedZoom in false\n   *\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  fixedZoomOut(): void {\n    this._fixedZoomUpdate.next(false);\n  }\n\n  /**\n   * get _onDragEnter observable\n   *\n   * @readonly\n   * @memberOf AjfReportBuilderService\n   */\n  get onDragEnter(): Observable<any> {\n    return this._onDragEnter;\n  }\n\n  /**\n   *  update _onDragEnter with  section(header,content,footer) and index\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  dragEnter(array: string, index: number): void {\n    this._onDragEnterUpdate.next({array, index});\n  }\n\n  /**\n   *  update _ondragged with true\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  dragStarted(): void {\n    this._onDraggedUpdate.next(true);\n  }\n\n  /**\n   *  update _onDragged with false\n   *\n   * @memberOf AjfReportBuilderService\n   */\n\n  dragEnded(): void {\n    this._onDraggedUpdate.next(false);\n  }\n\n\n  /**\n   *  update _onOver with true\n   *\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  overStarted(): void {\n    this._onOverUpdate.next(true);\n  }\n\n\n  /**\n   * update _onOver with false\n   *\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  overEnded(): void {\n    this._onOverUpdate.next(false);\n  }\n\n  /**\n   *\n   *  update _onDragged with false\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  dragLeave(): void {\n    this._onDragEnterUpdate.next({});\n  }\n\n  /**\n   * Get the report\n   *\n   * @readonly\n   * @memberOf AjfReportBuilderService\n   */\n  get report(): Observable<AjfReport|null> {\n    return this._report as Observable<AjfReport|null>;\n  }\n\n  /**\n   * emit save report event\n   *\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  saveReport() {\n    if (this._saveReportEvent != null) {\n      this._saveReportEvent.emit();\n    }\n  }\n\n  saveImageFormula(formula: AjfFormula) {\n    this._currentWidgetUpdate.next((widget: AjfWidget|null): AjfWidget|null => {\n      if (widget == null) {\n        return widget;\n      }\n      const w = widget as AjfImageWidget;\n      w.flag = formula;\n      w.icon = formula;\n      return w;\n    });\n  }\n\n  saveFormulaToHtml(htmlFormula: string, reference: any) {\n    if (this._saveFormulaTOHtml != null) {\n      const obj = {'formula': htmlFormula, 'reference': reference};\n      this._saveFormulaTOHtml.emit(obj);\n    }\n  }\n\n  setEmptyContent(val: boolean): void {\n    this._emptyContent.next(val);\n  }\n\n\n  pushJsonStack(json: string): void {\n    let currentStack = this._jsonStack.getValue();\n\n    if (currentStack.indexOf(json) === -1 && json !== this._lastDeletedJson) {\n      currentStack.push(json);\n    }\n\n    this._jsonStack.next(currentStack);\n  }\n\n  popJsonStack(): string|undefined {\n    let emptyJson = '{\"header\":{\"content\":[],\"styles\":{}},' +\n        '\"content\":{\"content\":[],\"styles\":{}},\"' +\n        'footer\":{\"content\":[],\"styles\":{}},\"styles\":{}}';\n    let currentStack = this._jsonStack.getValue();\n    currentStack.pop();\n    this._lastDeletedJson = currentStack.pop();\n\n    if (currentStack.length <= 0) {\n      this._lastDeletedJson = '';\n      this._jsonStack.next([]);\n      this.updateCurrentWidget(null);\n      this.setEmptyContent(true);\n      return emptyJson;\n    }\n    this._jsonStack.next(currentStack);\n\n    return this._lastDeletedJson;\n  }\n\n\n  /**\n   * get the emitter\n   *\n   * @readonly\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  get columnWidthChanged() {\n    return this.columnWidthChangedEmitter;\n  }\n\n  /**\n   * get _customWidgets Observable\n   *\n   * @readonly\n   * @memberOf AjfReportBuilderService\n   */\n  get customWidgets(): Observable<AjfCustomWidget[]> {\n    return this._customWidgets;\n  }\n\n  /**\n   * Get the header widget\n   *\n   * @readonly\n   * @memberOf AjfReportBuilderService\n   */\n  get headerWidgets(): Observable<AjfWidgetsContainer> {\n    return this._headerWidgets;\n  }\n\n  /**\n   * Get the header styles\n   *\n   * @readonly\n   * @memberOf AjfReportBuilderService\n   */\n  get headerStyles(): Observable<AjfStyles> {\n    return this._headerStyles;\n  }\n\n  /**\n   * Get the Content widget\n   *\n   * @readonly\n   * @memberOf AjfReportBuilderService\n   */\n  get contentWidgets(): Observable<AjfWidgetsContainer> {\n    return this._contentWidgets;\n  }\n\n  /**\n   * Get the content styles\n   *\n   * @readonly\n   * @memberOf AjfReportBuilderService\n   */\n  get contentStyles(): Observable<AjfStyles> {\n    return this._contentStyles;\n  }\n\n  /**\n   * Get the footer widget\n   *\n   * @readonly\n   * @memberOf AjfReportBuilderService\n   */\n  get footerWidgets(): Observable<AjfWidgetsContainer> {\n    return this._footerWidgets;\n  }\n\n  /**\n   * Get the footer styles\n   *\n   * @readonly\n   * @memberOf AjfReportBuilderService\n   */\n  get footerStyles(): Observable<AjfStyles> {\n    return this._footerStyles;\n  }\n\n  /**\n   * Get the colors of report\n   *\n   * @readonly\n   * @memberOf AjfReportBuilderService\n   */\n  get colors(): Observable<string[]> {\n    return this._color;\n  }\n\n  get emptyContent(): Observable<boolean> {\n    return <Observable<boolean>>this._emptyContent;\n  }\n\n  /**\n   *\n   * @param type\n   * @param newWidget\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  updateArrayWidgets(type: string, newWidget: AjfWidgetsContainer) {\n    if ((type !== 'header') && (type !== 'content') && (type !== 'footer')) {\n      throw new Error('Unknown type ' + type);\n    }\n    this._updates[type].next((_widgets: AjfWidgetsContainer): AjfWidgetsContainer => {\n      return newWidget;\n    });\n  }\n\n  /**\n   * get _formsVariables Observable\n   *\n   * @readonly\n   * @memberOf AjfReportBuilderService\n   */\n  get formsVariables(): Observable<AjfFormVariables[]> {\n    return this._formsVariables;\n  }\n\n  get conditionNames(): Observable<AjfFormVariables[]> {\n    return this._conditionNames;\n  }\n  /**\n   * Get the current widget\n   *\n   * @readonly\n   * @memberOf AjfReportBuilderService\n   */\n  get currentWidget(): Observable<AjfWidget|null> {\n    return this._currentWidget;\n  }\n\n  /**\n   * This method Update _currentWidgetUpdate with newWidget.\n   *\n   * @param newWidget\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  updateCurrentWidget(newWidget: AjfWidget|null) {\n    this._currentWidgetUpdate.next((_widget: AjfWidget|null): AjfWidget|null => {\n      this._saveReportEvent.emit();\n      return newWidget;\n    });\n  }\n\n  /**\n   * Get the report\n   *\n   * @readonly\n   * @memberOf AjfReportBuilderService\n   */\n  get getSaveReport(): Observable<any> {\n    return this._saveReport as Observable<any>;\n  }\n\n  /**\n   * get _jsonSavedReport obeservable\n   *\n   * @readonly\n   * @memberOf AjfReportBuilderService\n   */\n  get reportSaved(): Observable<AjfReport> {\n    return this._savedReport;\n  }\n\n\n  /**\n   * get _reportStyles observable\n   *\n   * @readonly\n   * @memberOf AjfReportBuilderService\n   */\n  get reportStyles(): Observable<AjfStyles> {\n    return this._reportStyles;\n  }\n\n  /**\n   * get _reportForms observable\n   *\n   * @readonly\n   * @memberOf AjfReportBuilderService\n   */\n  get reportForms(): Observable<AjfForm[]> {\n    return this._reportForms;\n  }\n\n  /**\n   * get the _origin Observable\n   *\n   * @readonly\n   * @memberOf AjfReportBuilderService\n   */\n  get origin(): Observable<string> {\n    return this._origin;\n  }\n\n  /**\n   * This method assigns the new width to the idx column\n   * and recalculates the width of the remaining columns of the layout.\n   * The range value are from 0,1 to 1.\n   *\n   * RULES:\n   * The min value for column is 0,1.\n   * The sum of all columns width is always 1.\n   * The method round the values.\n   * If is present only one column the width is always 1.\n   *\n   * When the new value `>` old value:\n   * the width of the remaining columns decreases.\n   * When the new value `<` old value:\n   * the width of the remaining columns increases.\n   *\n   * When values ​​are periodic, rounding assigns the gap to the current value.\n   * For example: 3 columns with 0,33 believe 1 column 0,34 and 2 columns 0,33.\n   *\n   * @param newValue\n   * @param idx\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  instantColumnValue(newValue: number, idx: number) {\n    this._currentWidgetUpdate.next((widget: AjfWidget|null): AjfWidget|null => {\n      if (widget == null) {\n        return widget;\n      }\n      let myObj = <AjfLayoutWidget>widget;\n\n      let size = myObj.columns.length;\n\n      let spreadValue = 0;\n      let objNum = 0;\n      let sum = 0;\n      let idxFirstNoObj = -1;\n\n      let add = false;\n      let foundFirstNoObj = false;\n\n      let re1 = new RegExp('(^[0]\\.\\[1-9][0-9]$)');\n      let re2 = new RegExp('(^[0]\\.\\[1-9]$)');\n      let re3 = new RegExp('^[1]$');\n\n      let oldValue = myObj.columns[idx];\n\n      newValue = Number(this.roundTo(newValue, 2).toFixed(2));\n\n      if (myObj.columns[idx] == null) {\n        throw new Error('invalid value');\n      }\n\n      for (let j = 0; j < size; j++) {\n        if (myObj.columns[j] === -1) {\n          objNum++;\n        }\n      }\n\n      if (oldValue == -1) {\n        oldValue = 0.1;\n        objNum--;\n        newValue = Number(this.roundTo(1 / (size - objNum), 2).toFixed(2));\n        myObj.columns[idx] = 0.1;\n      } else if (oldValue < 0.1) {\n        oldValue = 0.1;\n      }\n\n\n      if (newValue !== -1) {\n        if (myObj.columns.length === 1) {\n          myObj.columns[0] = 1;\n          return myObj;\n        }\n\n        if (newValue < 0.1) {\n          newValue = 0.1;\n        } else if (newValue + 0.1 * (size - objNum - 1) > 1) {\n          newValue = 1 - (0.1 * (size - objNum - 1));\n        }\n\n        if ((oldValue === newValue) && (oldValue === 0.1)) {\n          myObj.columns[idx] = newValue;\n          return myObj;\n        }\n\n        if (oldValue > newValue) {\n          add = true;\n          spreadValue = (oldValue - newValue) / (size - objNum - 1);\n        } else {\n          add = false;\n          spreadValue = (newValue - oldValue) / (size - objNum - 1);\n        }\n\n        spreadValue = Number(this.roundTo(spreadValue, 2).toFixed(2));\n\n        if (spreadValue < 0.01) {\n          spreadValue = 0.1;\n        }\n\n      } else {\n        myObj.columns[idx] = -1;\n        objNum++;\n        add = true;\n        if (myObj.columns.length == 1) {\n          spreadValue = 1;\n        } else {\n          spreadValue = (oldValue) / (size - objNum);\n        }\n      }\n\n      for (let i = 0; i < size; i++) {\n        if (myObj.columns[i] !== -1) {\n          if ((i == idx)) {\n            myObj.columns[idx] = newValue;\n          } else {\n            if (add) {\n              myObj.columns[i] += spreadValue;\n              if ((myObj.columns[i] > 0.9) && (myObj.columns.length - objNum != 1)) {\n                myObj.columns[i] = 0.90;\n              }\n\n            } else {\n              myObj.columns[i] -= spreadValue;\n              if (myObj.columns[i] < 0.1) {\n                myObj.columns[i] = 0.10;\n              }\n            }\n\n            myObj.columns[i] = Number(this.roundTo(myObj.columns[i], 2).toFixed(2));\n            sum += myObj.columns[i];\n          }\n\n          sum = Number(this.roundTo(sum, 2).toFixed(2));\n\n          if (foundFirstNoObj == false) {\n            idxFirstNoObj = i;\n            foundFirstNoObj = true;\n          }\n        }\n      }\n\n      if (newValue === -1) {\n        myObj.columns[idx] = -1;\n        if (foundFirstNoObj) {\n          myObj.columns[idxFirstNoObj] += Number(this.roundTo(1 - sum, 2).toFixed(2));\n        }\n      } else {\n        myObj.columns[idx] = Number(this.roundTo(1 - sum, 2).toFixed(2));\n      }\n\n      for (let j = 0; j < myObj.columns.length; j++) {\n        if (myObj.columns[j] !== -1 && !re1.test(String(myObj.columns[j])) &&\n            !re2.test(String(myObj.columns[j])) && !re3.test(String(myObj.columns[j]))) {\n          this.instantColumnValue(0.10, j);\n        }\n      }\n      this.columnWidthChangedEmitter.emit();\n      this._saveReportEvent.emit();\n      return myObj;\n    });\n  }\n\n  /**\n   * This method set the imageUrl on the current AjfImageWidget.\n   *\n   * @param imageUrl\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  setImageUrl(imageUrl: string) {\n    this._currentWidgetUpdate.next((widget: AjfWidget|null): AjfWidget|null => {\n      if (widget == null) {\n        return null;\n      }\n      const myObj = widget as AjfImageWidget;\n      myObj.url = createFormula({formula: `\"${imageUrl}\"`});\n      return myObj;\n    });\n  }\n\n  setIcon(icon: {fontSet: string, fontIcon: string}) {\n    this._currentWidgetUpdate.next((widget: AjfWidget|null): AjfWidget|null => {\n      if (widget == null) {\n        return null;\n      }\n      const myObj = widget as AjfImageWidget;\n      myObj.icon = createFormula({formula: `\"${icon}\"`});\n      return myObj;\n    });\n  }\n\n  setFlag(value: string) {\n    this._currentWidgetUpdate.next((widget: AjfWidget|null): AjfWidget|null => {\n      if (widget == null) {\n        return null;\n      }\n      const myObj = widget as AjfImageWidget;\n      myObj.flag = createFormula({formula: `\"${value}\"`});\n      return myObj;\n    });\n  }\n\n  saveCondition(conditionText: string) {\n    this._currentWidgetUpdate.next((widget: AjfWidget|null): AjfWidget|null => {\n      if (widget == null) {\n        return null;\n      }\n      if (widget.visibility != null) {\n        widget.visibility.condition = conditionText;\n      }\n      return widget;\n    });\n  }\n\n  saveChartFormula(\n      _label: string, _level: number, _mainIndex: number, _index: number, formulaText: string,\n      aggregationType: number) {\n    this._currentWidgetUpdate.next((w: AjfWidget|null): AjfWidget|null => {\n      if (w == null) {\n        return null;\n      }\n      const widget = w as AjfChartWidget;\n      if (widget != null && widget.dataset != null) {\n        let formula: AjfFormula = createFormula({});\n        let aggregation: AjfAggregation = createAggregation({});\n        // let obj: any;\n\n        formula.formula = formulaText;\n        aggregation.aggregation = aggregationType;\n\n        // obj = {\n        //   'formula': formula.toJson(),\n        //   'aggregation': aggregation.toJson(),\n        //   'label': label\n        // };\n\n        // dataset = AjfDataset.fromJson(obj);\n        // check if the row that contains main data is defined\n        /* if (widget.dataset[0] == null) {\n          widget.dataset[0] = [];\n        }\n\n        if (level == 0 && mainIndex == -1 && index == -1) {\n\n          widget.dataset[0].push(dataset);\n        } else if (level == 1 && mainIndex == -1 && index == -1) {\n\n          widget.dataset[widget.dataset.length] = [];\n          widget.dataset[widget.dataset.length - 1].push(dataset);\n        } else if (index === - 1) {\n          widget.dataset[mainIndex + 1].push(dataset);\n        } else {\n          widget.dataset[mainIndex].splice(index, 1, dataset);\n        } */\n      }\n      return widget;\n    });\n  }\n\n  saveTableFormula(\n      _label: string, aggregationType: number, formulaText: string, _mainIndex: number,\n      _index: number) {\n    this._currentWidgetUpdate.next((w: AjfWidget|null): AjfWidget|null => {\n      if (w == null) {\n        return null;\n      }\n      const widget = w as AjfTableWidget;\n      if (widget.dataset != null) {\n        let formula: AjfFormula = createFormula({});\n        let aggregation: AjfAggregation = createAggregation({});\n        // let dataset: AjfDataset = new AjfDataset();\n        // let rowDataset: AjfDataset[] = [];\n        // let obj: any;\n\n        formula.formula = formulaText;\n        aggregation.aggregation = aggregationType;\n\n        // obj = {\n        //   'formula': formula.toJson(),\n        //   'aggregation': aggregation.toJson(),\n        //   'label': label\n        // };\n\n        // dataset = AjfDataset.fromJson(obj);\n        /* if (mainIndex === - 1) {\n          widget.dataset[widget.dataset.length] = [];\n          widget.dataset[widget.dataset.length - 1].push(dataset);\n        } else {\n          if (index === -1) {\n            widget.dataset[mainIndex].push(dataset);\n          } else {\n            widget.dataset[mainIndex].splice(index, 1, dataset);\n          }\n        } */\n      }\n      return widget;\n    });\n  }\n\n  removeTableMainData(index: number) {\n    this._removeFromCurrentWidgetArrayProperty('dataset', index);\n  }\n\n  removeData(_mainIndex: number, _index: number) {\n    this._currentWidgetUpdate.next((widget: AjfWidget|null): AjfWidget|null => {\n      let myObj = <AjfDataWidget>widget;\n\n      /* if (index === -1) {\n        myObj.dataset.splice(mainIndex, 1);\n      } else {\n        myObj.dataset[mainIndex].splice(index, 1);\n      } */\n\n      return myObj;\n    });\n  }\n\n  /**\n   * update type field of AjfChartWidget current widget\n   *\n   * @param type\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  setChartType(type: number) {\n    this._setCurrentWidgetProperty('type', type);\n  }\n\n  /**\n   * remove  idx element of xLabels field of AjfChartWidget current widget\n   *\n   * @param idx\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  removeMainData(_idx: number) {\n    this._currentWidgetUpdate.next((widget: AjfWidget|null): AjfWidget|null => {\n      let myObj = <AjfChartWidget>widget;\n      // myObj.dataset[0].splice(idx, 1);\n\n      return myObj;\n    });\n  }\n\n  removeRelatedData(_mainIdx: number, _idx: number) {\n    this._currentWidgetUpdate.next((widget: AjfWidget|null): AjfWidget|null => {\n      let myObj = <AjfChartWidget>widget;\n      /* if (idx == -1) {\n        myObj.dataset.splice(mainIdx + 1, 1);\n      } else {\n        myObj.dataset[mainIdx + 1].splice(idx, 1);\n      } */\n\n      return myObj;\n    });\n  }\n\n\n  /**\n   * update backgroundColor field of AjfChartWidget current widget\n   *\n   * @param colors\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  setChartBackgroundColor(colors: string[]) {\n    this._setCurrentWidgetProperty('backgroundColor', colors);\n  }\n\n  addChartBackgroundColor(color: string) {\n    this._addToCurrentWidgetArrayProperty('backgroundColor', color);\n  }\n\n  removeChartBackgroundColor(idx: number) {\n    this._removeFromCurrentWidgetArrayProperty('backgroundColor', idx);\n  }\n\n  /**\n   * update borderColor field of AjfChartWidget current widget\n   *\n   * @param colors\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  setChartBorderColor(colors: string[]) {\n    this._setCurrentWidgetProperty('borderColor', colors);\n  }\n\n  setChartBorderWidth(value: number) {\n    this._setCurrentWidgetProperty('borderWidth', value);\n  }\n\n  addChartBorderColor(color: string) {\n    this._addToCurrentWidgetArrayProperty('borderColor', color);\n  }\n\n  removeChartBorderColor(idx: number) {\n    this._removeFromCurrentWidgetArrayProperty('borderColor', idx);\n  }\n\n  /**\n   * This method set the AjfReport.\n   *\n   * @param report\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  setReport(report: AjfReport): void {\n    this._report.next(report);\n  }\n\n  /**\n   * This method set the export report.\n   *\n   * @param report\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  setSaveReport(json: any): void {\n    this._saveReport.next(json);\n  }\n\n  /**\n   * This method set the font attribute on the current AjfWidget.\n   *\n   * There is a check on font-size attribute,\n   * if is no specificate the type of size font set 'pt' as default.\n   *\n   * @param label\n   * @param value\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  setWidgetStyles(label: string, value: string|string[]) {\n    this._currentWidgetUpdate.next((widget: AjfWidget|null): AjfWidget|null => {\n      let myObj = <AjfTextWidget>widget;\n\n      const pxStyles =\n          ['font-size', 'height', 'width', 'border-width', 'border-radius', 'padding', 'margin'];\n      const isPxStyle = pxStyles.indexOf(label) > -1;\n      if (isPxStyle && !(value instanceof Array) && this.isNumber(value)) {\n        value += 'px';\n      } else if (isPxStyle && value instanceof Array && this.isNumberArray(value)) {\n        value = `${value.join('px ')}px`;\n      }\n\n      myObj.styles[label] = value;\n\n      return myObj;\n    });\n  }\n\n  /**\n   * this method update the styles of origin widget array\n   *\n   * @param origin can be header content or footer\n   * @param label for example background-color\n   * @param value for example rgb(255,255,255,1)\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  setSectionStyles(origin: string, label: string, value: string) {\n    if ((origin !== 'header') && (origin !== 'content') && (origin !== 'footer')) {\n      throw new Error('uncknow origin ' + origin);\n    }\n\n    this._updates[origin].next((widget: AjfWidgetsContainer): AjfWidgetsContainer => {\n      widget.styles[label] = value;\n\n      widget.styles = <AjfStyles>{...widget.styles};\n\n      return widget;\n    });\n  }\n\n  /**\n   * this method set the style of the whole report.\n   *\n   * @param label for example background-color\n   * @param value for example rgb(255,255,255,1)\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  setReportStyles(label: string, value: string) {\n    this._reportStylesUpdate.next((styles: AjfStyles): AjfStyles => {\n      if (styles == null) {\n        styles = {};\n      } else {\n        styles[label] = value;\n        styles = <AjfStyles>{...styles};\n      }\n      return styles;\n    });\n  }\n\n  /**\n   *  update forms\n   *\n   * @param forms\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  setReportForms(forms: AjfForm[]) {\n    this._reportFormsUpdate.next((_form: AjfForm[]): AjfForm[] => {\n      return forms || [];\n    });\n  }\n\n  /**\n   * update customWidgets\n   *\n   * @param widget\n   * @param [position]\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  addCustomWidgets(widget: AjfCustomWidget, position?: number) {\n    this._customWidgetsUpdate.next((customWidgets: AjfCustomWidget[]): AjfCustomWidget[] => {\n      customWidgets = customWidgets || [];\n      if (position != null && position >= 0) {\n        customWidgets.splice(position, 0, widget);\n      } else {\n        customWidgets.push(widget);\n      }\n      return customWidgets;\n    });\n  }\n\n  /**\n   * reset customWidgets\n   *\n   * @param widget\n   * @param [position]\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  resetCustomWidgets() {\n    this._customWidgetsUpdate.next((customWidgets: AjfCustomWidget[]): AjfCustomWidget[] => {\n      customWidgets.length = 0;\n      return customWidgets;\n    });\n  }\n\n  /**\n   * update label of widget\n   *\n   * @param label\n   * @param position\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  changeLabelCustomWidget(label: string, position: number) {\n    this._customWidgetsUpdate.next((customWidgets: AjfCustomWidget[]): AjfCustomWidget[] => {\n      customWidgets[position].type = label;\n      return customWidgets;\n    });\n  }\n\n  /**\n   * Add an AjfWidget on _headerWidgetsUpdate\n   *\n   * @param widget\n   * @param [position]\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  addHeaderWidget(widget: AjfWidget, position?: number) {\n    this._addWidgetToContainer(this._headerWidgetsUpdate, widget, position);\n  }\n\n  /**\n   * Add an AjfWidget on _contentWidgetsUpdate\n   *\n   * @param widget\n   * @param [position]\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  addContentWidget(widget: AjfWidget, position?: number) {\n    this._addWidgetToContainer(this._contentWidgetsUpdate, widget, position);\n  }\n\n  /**\n   * Add an AjfWidget on _footerWidgetsUpdate\n   *\n   * @param widget\n   * @param [position]\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  addfooterWidget(widget: AjfWidget, position?: number) {\n    this._addWidgetToContainer(this._footerWidgetsUpdate, widget, position);\n  }\n\n  unfixedColumn(idx: number) {\n    this._currentWidgetUpdate.next((widget: AjfWidget|null): AjfWidget|null => {\n      if (widget == null) {\n        return widget;\n      }\n      let myObj = <AjfLayoutWidget>widget;\n      let num = myObj.columns.length;\n      let checkSum = 0;\n      let objNum = 0;\n      let value = 1;\n      let spreadValue: any;\n      myObj.columns[idx] = 0;\n\n      for (let j = 0; j < num; j++) {\n        if (myObj.columns[j] === -1) {\n          objNum++;\n        }\n      }\n\n      value = Number(this.roundTo(1 / (num - objNum), 2).toFixed(2));\n\n      for (let i = 0; i < num; i++) {\n        if (myObj.columns[i] !== -1) {\n          myObj.columns[i] = value;\n          checkSum = Number(this.roundTo(checkSum + value, 2).toFixed(2));\n        }\n      }\n\n      checkSum = Number(this.roundTo(checkSum, 2).toFixed(2));\n\n      if (checkSum > 1) {\n        spreadValue = parseFloat(this.roundTo(((checkSum - 1) % 1), 2).toFixed(2));\n        myObj.columns[idx] -= spreadValue;\n        myObj.columns[idx] = this.roundTo(myObj.columns[idx], 2);\n      } else if (checkSum < 1) {\n        myObj.columns[idx] += (1 - (checkSum % 1));\n        myObj.columns[idx] = Number(this.roundTo(myObj.columns[idx], 2).toFixed(2));\n      }\n\n      return myObj;\n    });\n  }\n\n  /**\n   * Add column on the current AjfLayoutWidget.\n   *\n   * When adding a column the width of the other columns is recalculated\n   * by dividing it by the number of column\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  addColumn() {\n    this._currentWidgetUpdate.next((widget: AjfWidget|null): AjfWidget|null => {\n      if (widget == null) {\n        return null;\n      }\n      let myObj = <AjfLayoutWidget>widget;\n      let tempObj: number[] = [];\n      let num = myObj.columns.length + 1;\n      let checkSum = 0;\n      let objNum = 0;\n      let value = 1;\n      let tmpValue: any;\n\n      if (num > 10) {\n        throw new Error('exceed max columns');\n      }\n\n      for (let j = 0; j < num; j++) {\n        if (myObj.columns[j] === -1) {\n          objNum++;\n        }\n      }\n      value = Number(this.roundTo(1 / (num - objNum), 2).toFixed(2));\n\n      for (let i = 0; i < num; i++) {\n        if (myObj.columns[i] === -1) {\n          tempObj.push(-1);\n        } else {\n          tempObj.push(value);\n          checkSum = Number(this.roundTo(checkSum + value, 2).toFixed(2));\n        }\n      }\n      checkSum = Number(this.roundTo(checkSum, 2).toFixed(2));\n\n      if (checkSum > 1) {\n        tmpValue = parseFloat(this.roundTo(((checkSum - 1) % 1), 2).toFixed(2));\n        tempObj[0] -= tmpValue;\n        tempObj[0] = this.roundTo(tempObj[0], 2);\n      } else if (checkSum < 1) {\n        tempObj[0] += (1 - (checkSum % 1));\n        tempObj[0] = Number(this.roundTo(tempObj[0], 2).toFixed(2));\n      }\n\n      myObj.columns = tempObj;\n\n      // TODO: @trik what's value?!?\n      const columnObj = createWidget({\n        widgetType: 7,\n        // value: myObj.columns[myObj.columns.length - 1],\n      });\n\n      myObj.content.push(columnObj);\n      this._saveReportEvent.emit();\n      return myObj;\n    });\n  }\n\n  removeWidgetToColumn(column: AjfColumnWidget, index: number) {\n    column.content.splice(index, 1);\n  }\n\n  /**\n   * This method remove a widget on the current AjfReport.\n   *\n   * @param node\n   * the position array:\n   *\n   * header -`>` headerWidgets\n   * content -`>` contentWidgets\n   * footer -`>` footerWidgets\n   * column -`>` column of layout\n   * layoutContent -`>` content of layout\n   * obj -`>` obj of layout\n   * customWidget -`>` custom widget\n   *\n   * @param idx the position array\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  remove(node: string, idx: number) {\n    switch (node) {\n      case 'header':\n      case 'content':\n      case 'footer':\n        this._updates[node].next((widgets: AjfWidgetsContainer): AjfWidgetsContainer => {\n          if (widgets.widgets.length === 0) {\n            throw new Error('you can not remove from empty array');\n          }\n          if (widgets.widgets[idx] == null) {\n            throw new Error('invalid index');\n          }\n          widgets.widgets.splice(idx, 1);\n          this.updateCurrentWidget(null);\n          return widgets;\n        });\n        break;\n      case 'layout':\n        this._currentWidgetUpdate.next((widget: AjfWidget|null): AjfWidget|null => {\n          if (widget == null) {\n            return null;\n          }\n          const myObj = widget as AjfLayoutWidget;\n\n          if (myObj.columns.length === 1) {\n            (myObj.content[0] as AjfColumnWidget).content.length = 0;\n            return myObj;\n          }\n\n          if (myObj.columns[idx] == null) {\n            throw new Error('this content is undefined');\n          } else {\n            let spread = myObj.columns[idx] / (myObj.columns.length - 1);\n\n            if (myObj.columns.length > 1) {\n              myObj.columns.splice(idx, 1);\n              myObj.content.splice(idx, 1);\n            }\n\n            for (let i = 0; i < myObj.columns.length; i++) {\n              myObj.columns[i] += spread;\n            }\n            this.instantColumnValue(myObj.columns[0], 0);\n          }\n          return myObj;\n        });\n        break;\n      case 'column':\n      case 'layoutContent':\n      case 'unfixedColumn':\n        this._currentWidgetUpdate.next((widget: AjfWidget|null): AjfWidget|null => {\n          if (widget == null) {\n            return null;\n          }\n          let myObj = <AjfLayoutWidget>widget;\n\n          if (node === 'column') {\n            let clm = <AjfColumnWidget>widget;\n            clm.content.splice(idx, 1);\n          } else if (node === 'layoutContent') {\n            if (myObj.columns.length === 0) {\n              throw new Error('the column length is 0');\n            }\n            if (myObj.content.length === 0) {\n              throw new Error('can not remove any widget from empty content');\n            }\n            if (myObj.columns[idx] != null && myObj.content[idx] == null) {\n              throw new Error('this content is undefined');\n            }\n          } else if (node === 'unfixedColumn') {\n            if (myObj.columns[idx] !== -1) {\n              throw new Error('the column position value  isnt -1');\n            }\n            this.unfixedColumn(idx);\n          }\n          // if (node !== 'obj') {\n          //   let spread = myObj.columns[idx] / (myObj.columns.length - 1);\n          //   myObj.content.splice(idx, 1);\n          //   if (myObj.columns.length > 1) {\n          //     myObj.columns.splice(idx, 1);\n          //   }\n          //   for (let i = 0; i < myObj.columns.length; i++) {\n          //     myObj.columns[i] += spread;\n          //   }\n          //   this.instantColumnValue(myObj.columns[0], 0);\n          // }\n          return myObj;\n        });\n        break;\n      case 'customWidgets': {\n        this._updates[node].next((widgets: AjfCustomWidget[]): AjfCustomWidget[] => {\n          if (widgets.length === 0) {\n            throw new Error('you can not remove from empty array');\n          }\n          if (widgets[idx] == null) {\n            throw new Error('invalid index');\n          }\n          widgets.splice(idx, 1);\n          return widgets;\n        });\n      } break;\n      default:\n        throw new Error('unknown node ' + node);\n    }\n  }\n\n  /**\n   * This method add a AjfWidget on the current AjfLayoutWidget.\n   *\n   * @param newWidget\n   * @param idx\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  addToContent(newWidget: AjfWidget, idx: number) {\n    this._currentWidgetUpdate.next((widget: AjfWidget|null): AjfWidget|null => {\n      if (widget == null) {\n        return null;\n      }\n      let myObj = <AjfLayoutWidget>widget;\n\n      if (myObj.content[idx] != null) {\n        myObj.content.splice(idx, 1);\n      }\n      myObj.content.splice(idx, 0, newWidget);\n      return myObj;\n    });\n  }\n\n  addToColumn(event: any, toColumn: AjfColumnWidget, position?: number) {\n    if (event.dragData && event.dragData.fromColumn != null) {\n      let fromColumn: AjfColumnWidget = event.dragData.fromColumn;\n      let widget: AjfWidget = event.dragData.widget;\n      let fromIndex: number = event.dragData.fromIndex;\n\n      fromColumn.content.splice(fromIndex, 1);\n      toColumn.content.push(widget);\n\n    } else if (event.dragData && event.dragData.arrayFrom) {\n      this.remove(event.dragData.arrayFrom, event.dragData.fromIndex);\n      toColumn.content.push(event.dragData.widget);\n    } else if (event.dragData && event.dragData.json) {\n      let obj = JSON.parse(event.dragData.json);\n      let newWidget = deepCopy(obj);\n\n      if (position != null) {\n        toColumn.content.splice(position, 0, newWidget);\n      } else {\n        toColumn.content.push(newWidget);\n      }\n    } else {\n      let obj = {'widgetType': AjfWidgetType[event.dragData]};\n      let newWidget = deepCopy(obj);\n\n      if (position != null) {\n        toColumn.content.splice(position, 0, newWidget);\n      } else {\n        toColumn.content.push(newWidget);\n      }\n    }\n  }\n  changePositionOnColumn(event: any, toColumn: AjfColumnWidget, toIndex: number) {\n    let fromColumn: AjfColumnWidget = event.dragData.fromColumn;\n    let fromIndex: number = event.dragData.fromIndex;\n    let fromWidget: AjfWidget = fromColumn.content[fromIndex];\n    let toWidget: AjfWidget = fromColumn.content[toIndex];\n\n    if (fromColumn == toColumn) {\n      fromColumn.content[fromIndex] = toWidget;\n      fromColumn.content[toIndex] = fromWidget;\n    } else {\n      fromColumn.content.splice(fromIndex, 1);\n      toColumn.content.splice(toIndex, 0, fromWidget);\n    }\n  }\n\n  /**\n   * This method add the obj on the idx position.\n   * Obj have a no specificate width and is not calculate as columns\n   *\n   * @param idx\n   *\n   * @memberOf AjfReportBuilderService\n   */\n  fixedColumn(idx: number) {\n    this.instantColumnValue(-1, idx);\n  }\n\n  changeColumn(from: number, to: number, layoutWidget: AjfLayoutWidget) {\n    if (to < 0 || to >= layoutWidget.content.length) {\n      return;\n    }\n    if (from > layoutWidget.content.length - 1 && to > from) {\n      return;\n    }\n\n    let fromColumn: AjfColumnWidget = <AjfColumnWidget>layoutWidget.content[from];\n    let fromColumnValue: number = layoutWidget.columns[from];\n    let toColumn: AjfColumnWidget = <AjfColumnWidget>layoutWidget.content[to];\n    let toColumnValue: number = layoutWidget.columns[to];\n\n    layoutWidget.content[from] = toColumn;\n    layoutWidget.columns[from] = toColumnValue;\n    layoutWidget.content[to] = fromColumn;\n    layoutWidget.columns[to] = fromColumnValue;\n\n    this.updateCurrentWidget(layoutWidget);\n  }\n\n  addCustomColor(color: string) {\n    this._updates['color'].next((colors: string[]): string[] => {\n      if (colors.indexOf(color) < 0) {\n        colors.push(color);\n      }\n      return colors;\n    });\n  }\n\n  private _addWidgetToContainer(\n      subj: Subject<AjfWidgetsOperation>, widget: AjfWidget, position?: number) {\n    subj.next((widgets: AjfWidgetsContainer): AjfWidgetsContainer => {\n      if (position != null && position >= 0) {\n        widgets.widgets.splice(position, 0, widget);\n      } else {\n        widgets.widgets.push(widget);\n      }\n      return widgets;\n    });\n    this.updateCurrentWidget(widget);\n    this.setEmptyContent(false);\n  }\n\n  private _setCurrentWidgetProperty(propName: string, value: any) {\n    this._currentWidgetUpdate.next((widget: AjfWidget|null): AjfWidget|null => {\n      if (widget == null) {\n        return null;\n      }\n      (widget as any)[propName] = value;\n      return widget;\n    });\n  }\n\n  private _addToCurrentWidgetArrayProperty(propName: string, value: any) {\n    this._currentWidgetUpdate.next((widget: AjfWidget|null): AjfWidget|null => {\n      if (widget == null) {\n        return null;\n      }\n      const arr = (widget as any)[propName] as any[];\n      arr.push(value);\n      (widget as any)[propName] = arr;\n      return widget;\n    });\n  }\n\n  private _removeFromCurrentWidgetArrayProperty(propName: string, idx: number) {\n    this._currentWidgetUpdate.next((widget: AjfWidget|null): AjfWidget|null => {\n      ((widget as any)[propName] as any[]).splice(idx, 1);\n      return widget;\n    });\n  }\n}\n"]}