ru.coon 2.8.65 → 3.0.2

package/src/uielement/plugin/configPanel/UnifiedButtonToolbarPluginConfigPanelFormEditor.js

@@ -1,39 +1,39 @@
 Ext.define('Coon.uielement.plugin.configPanel.UnifiedButtonToolbarPluginConfigPanelFormEditor', {
-    extend: 'Ext.panel.Panel',
+    extend: 'Coon.uielement.plugin.configPanel.UiCPPluginFormPanel',
+    requires: ['Coon.uielement.plugin.configPanel.UiCPPluginFormPanel'],
     alias: 'widget.UnifiedButtonToolbarPluginConfigPanelFormEditor',
     description: 'Добавляет стандартный тулбар',
     viewModel: {
         data: {
             saveHandlerName: '',
             prepareBeanHandlerName: '',
+            getHashDataHandlerName: '',
             validateBeanHandlerName: '',
             dock: 'bottom',
             checkChangesOnSave: true,
+            needReloadEventOnSave: false,
         },
     },
-    layout: {
-        type: 'vbox',
-        align: 'stretch',
-    },
     items: [
         {
-            xtype: 'pluginDescriptionLabel',
+            xtype: 'SearchByPropCombo',
+            fieldLabel: 'Обработчик подготовки данных для сохранения (необходим синхронный метод)',
             bind: {
-                value: '{description}',
+                value: '{prepareBeanHandlerName}',
             },
         },
         {
             xtype: 'SearchByPropCombo',
-            fieldLabel: 'Обработчик валидации данных',
+            fieldLabel: 'Обработчик получения данных для генерации хеша (необходим синхронный метод)',
             bind: {
-                value: '{validateBeanHandlerName}',
+                value: '{getHashDataHandlerName}',
             },
         },
         {
             xtype: 'SearchByPropCombo',
-            fieldLabel: 'Обработчик подготовки данных для сохранения',
+            fieldLabel: 'Обработчик валидации данных (необходим синхронный метод)',
             bind: {
-                value: '{prepareBeanHandlerName}',
+                value: '{validateBeanHandlerName}',
             },
         },
         {
@@ -75,14 +75,16 @@ Ext.define('Coon.uielement.plugin.configPanel.UnifiedButtonToolbarPluginConfigPa
             bind: {
                 value: '{checkChangesOnSave}',
             },
+        },
+        {
+            xtype: 'checkbox',
+            boxLabel: 'Срабатывание события needReload при сохранении данных.',
+            bind: {
+                value: '{needReloadEventOnSave}',
+            },
         }
     ],
-    getData: function() {
-        return this.getConfiguration();
-    },
-    setData: function(data) {
-        data && this.doInit(data);
-    },
+
     doInit: function(config) {
         this.getViewModel().set('description', this.description);
         for (const parameterName in config) {
@@ -95,7 +97,15 @@ Ext.define('Coon.uielement.plugin.configPanel.UnifiedButtonToolbarPluginConfigPa
     getConfiguration: function() {
         const result = {};
         const vm = this.getViewModel();
-        ['saveHandlerName', 'prepareBeanHandlerName', 'validateBeanHandlerName', 'dock', 'checkChangesOnSave'].forEach((el) => {
+        [
+            'saveHandlerName',
+            'prepareBeanHandlerName',
+            'validateBeanHandlerName',
+            'dock',
+            'checkChangesOnSave',
+            'getHashDataHandlerName',
+            'needReloadEventOnSave'
+        ].forEach((el) => {
             if (typeof vm.get(el) !== 'undefined') {
                 result[el] = vm.get(el);
             }

package/src/userSettings.js

@@ -4,6 +4,7 @@ Ext.define('Coon.userSettings', {
     requires: [
         'Coon.common.component.settings.modules.settingClosePageConfirmation',
         'Coon.common.component.settings.modules.settingwindowHolder',
+        'Coon.common.component.settings.modules.settingReportCalculator',
         'Coon.common.component.settings.stores.userSettingsStoreService'
     ],
 

package/src/util/ContextManager.js

@@ -0,0 +1,109 @@
+Ext.define('Coon.util.ContextManager', {
+    singleton: true,
+
+    contextMap: new Map(),
+
+    isDeleted: Symbol('isDeleted'),
+
+    generateKey(uniqueContext) {
+        if (typeof uniqueContext === 'string') {
+            return uniqueContext;
+        }
+        return Coon.util.generateHashFromObj(uniqueContext, {algorithm: 'md5'});
+    },
+
+    createContext(parentKey = null, componentContext, uniqueContext) {
+        uniqueContext = uniqueContext || componentContext;
+        const key = this.generateKey(uniqueContext);
+        const сontext = {
+            key,
+            parentKey,
+            componentContext,
+            children: [],
+            timestamp: Date.now(),
+        };
+
+        this.contextMap.set(key, сontext);
+
+        if (parentKey) {
+            const parentContext = this.contextMap.get(parentKey);
+            if (parentContext) {
+                parentContext.children.push(key);
+            } else {
+                Coon.log.error(`Parent context with key ${parentKey} not found!`);
+            }
+        }
+
+        return key;
+    },
+
+    getContext(key) {
+        return this.contextMap.get(key);
+    },
+
+    removeContext(key) {
+        const context = this.getContext(key);
+        if (context.children.length) {
+            context.children.forEach((childKey) => {
+                this.updateContext(childKey, (ctx) => {
+                    ctx.parentKey = this.isDeleted;
+                    return ctx;
+                });
+            });
+        }
+        if (this.isRootContext(key)) {
+            return;
+        }
+        this.updateContext(context.parentKey, (ctx) => {
+            ctx.children = ctx.children.filter((childKey) => childKey !== key);
+            return ctx;
+        });
+        this.contextMap.delete(key);
+    },
+
+    updateContext(key, handler) {
+        const context = this.contextMap.get(key);
+        if (typeof handler === 'function') {
+            this.contextMap.set(handler(context));
+        }
+    },
+
+    updateComponentContext(key, componentContext) {
+        const context = this.contextMap.get(key);
+        context.componentContext = componentContext;
+        this.contextMap.set(context);
+    },
+
+    isRootContext(key) {
+        const {parentKey} = this.getContext(key) || {};
+        return parentKey === null && parentKey !== this.isDeleted;
+    },
+
+    getParentContext(childKey) {
+        if (this.isRootContext(childKey)) {
+            return null;
+        }
+        const child = this.getContext(childKey);
+        return child && child.parentKey !== this.isDeleted ? this.getContext(child.parentKey) : null;
+    },
+
+    buildContextChain(startKey) {
+        const chain = [];
+        let currentKey = startKey;
+        while (currentKey !== null) {
+            const context = this.contextMap.get(currentKey);
+            if (!context) {
+                break;
+            }
+            chain.unshift(context);
+            currentKey = context.parentKey;
+        }
+        return chain;
+    },
+
+    getChildContexts(parentKey) {
+        return Array.from(this.contextMap.values()).filter(
+            ({parentKey: ctxParentKey}) => ctxParentKey === parentKey
+        );
+    },
+});

package/src/util.js

@@ -343,11 +343,9 @@ Ext.define('Coon.util', {
 
     safeDecodeURI(source) {
         if (!typeof source == 'string') {
-            // Coon.log.debug('safeDecodeURI.not string', typeof source);
             return source;
         }
         let decoded = decodeURIComponent(source);
-        // Coon.log.debug('safeDecodeURI.decoded', {source, decoded});
         decoded = decoded === source ? source : decoded;
         try {
             return JSON.parse(decoded);
@@ -356,15 +354,10 @@ Ext.define('Coon.util', {
         }
     },
 
-    filterMap(arr, fnIterator, checkForNoNEmpty) {
-        if (typeof checkForNoNEmpty !== 'function') {
-            checkForNoNEmpty = function(v) {
-                return !!v;
-            };
-        }
+    filterMap(arr, iterator, checkForNoNEmpty = (v) => !!v) {
         const acc = [];
         for (const el of arr) {
-            const result = fnIterator(el);
+            const result = iterator(el);
             if (checkForNoNEmpty(result)) {
                 acc.push(result);
             }
@@ -630,9 +623,82 @@ Ext.define('Coon.util', {
      * @returns {boolean}
      */
     objectsIsEqual(obj1 = {}, obj2 = {}) {
+        obj1 = Coon.util.convertExtObject(obj1);
+        obj2 = Coon.util.convertExtObject(obj2);
         return Coon.util.generateHashFromObj(obj1) === Coon.util.generateHashFromObj(obj2);
     },
 
+    /**
+     * deep call handler for each object property value
+     * filter if  handler result is not null or undefined
+     * @param {Object} src
+     * @param {Function} handler, arguments: value[Any], property name[String]
+     * @returns Object
+     */
+    deepObjectFilter(src, handler, options = {cureCircular: true}) {
+        let obj = src;
+        if (options.cureCircular) {
+            obj = Coon.util.markCircularLinks(src);
+        }
+        return Object.fromEntries(
+            Coon.util.filterMap(Object.entries(obj), ([k, v]) => {
+                if (Ext.isObject(v)) {
+                    v = Coon.util.deepObjectFilter(v, handler);
+                }
+                v = handler(v, k);
+                return Coon.util.isNotNullOrUndefined(v) && [k, v];
+            })
+        );
+    },
+
+    isNullOrUndefined(src) {
+        return Coon.util.isTypeIn(src, ['null', 'undefined']);
+    },
+
+    isNotNullOrUndefined(src) {
+        return !Coon.util.isTypeIn(src, ['null', 'undefined']);
+    },
+
+    getInstanceIdProperties(instance) {
+        if (instance.id ||
+                instance.xtype ||
+                instance.ptype ||
+                instance.$className ||
+                Ext.isObject(instance.initialConfig)
+        ) {
+            return Object.assign(
+                {},
+                Coon.util.mapObject(instance, [
+                    'id',
+                    'xtype',
+                    'ptype',
+                    '$className',
+                    {
+                        from: 'config',
+                        convert: Coon.util.convertExtObject,
+                    },
+                    {
+                        from: 'initialConfig',
+                        convert: Coon.util.convertExtObject,
+                    }
+                ])
+            );
+        } else {
+            return {};
+        }
+    },
+
+    convertExtObject(src) {
+        return Coon.util.deepObjectFilter(
+            Coon.util.markCircularLinks(src),
+            (value) => {
+                if (Ext.isObject(value) && value.isInstance) {
+                    return Coon.util.getInstanceIdProperties(value);
+                }
+                return value;
+            });
+    },
+
     /**
      * bind methods from one component to another
      * @param {Array} methods array of method names
@@ -694,16 +760,18 @@ Ext.define('Coon.util', {
             return data;
         }
         const markerValue = '__linkedObj';
-        const linkMap = new WeakSet();
-        const converter = (data) => {
+        const linkSet = new WeakSet();
+        const linkMap = new WeakMap();
+        const converter = (data, key) => {
             const acc = {};
             if (Ext.isObject(data)) {
-                if (linkMap.has(data)) {
+                if (linkSet.has(data)) {
                     return markerValue;
                 }
-                linkMap.add(data);
+                linkSet.add(data);
+                key && linkMap.set(data, key);
                 Object.entries(data).forEach(([key, val]) => {
-                    acc[key] = converter(val);
+                    acc[key] = converter(val, key);
                 });
                 return acc;
             }
@@ -712,6 +780,19 @@ Ext.define('Coon.util', {
             }
             return data;
         };
-        return converter(data);
+        const result = converter(data);
+        return result;
+    },
+
+    createObjFromTpl(src, tpl) {
+        if (!Ext.isObject(src) || !Ext.isObject(tpl)) {
+            return src;
+        }
+        const keys = Object.keys(tpl);
+        return Object.fromEntries(
+            Object.entries(src).filter(([key, _]) => {
+                return keys.includes(key);
+            })
+        );
     },
 });

package/src/version.js

@@ -1,4 +1,4 @@
 Ext.define('Coon.version', {
     singleton: true,
-    number: '2.8.65',
+    number: '3.0.2',
 });

package/src/app/viewPort/CenterViewController.js

@@ -1,158 +0,0 @@
-Ext.define('Coon.app.viewPort.CenterViewController', {
-    extend: 'Ext.app.ViewController',
-    alias: 'controller.CenterViewController',
-    requires: ['Coon.util', 'Coon.Function'],
-    cache: new Map(),
-    privates: {
-        paramsToObject(params) {
-            const entries = [];
-            if (Array.isArray(params) && params.length > 1) {
-                for (let i = 0; i < Math.floor(params.length / 2); i++) {
-                    entries.push([params[i * 2], params[i * 2 + 1]]);
-                }
-            }
-            return entries.length ? Object.fromEntries(entries) : null;
-        },
-        triggerPlugin(pluginId, target) {
-            if (target && Array.isArray(target.plugins)) {
-                const triggerPlugin = target.plugins.find((p) => p.pluginId === pluginId);
-                if (triggerPlugin && typeof triggerPlugin.handler === 'function') {
-                    triggerPlugin.handler.call(triggerPlugin);
-                }
-            }
-        },
-        onActivateComponent(params, cmp) {
-            if (cmp.xtype === 'ReportPanel') {
-                if (params) {
-                    cmp.updateFilterDefaults(params);
-                    if (params.plugin) {
-                        if (!cmp.grid) {
-                            cmp.on('gridReady', (reportPanel) => {
-                                this.triggerPlugin(params.plugin, reportPanel.grid);
-                            });
-                        } else {
-                            this.triggerPlugin(params.plugin, cmp.grid);
-                        }
-                    }
-                }
-            }
-        },
-
-        onRenderEditor(editor, id) {
-            const c = editor.getController();
-            typeof c.doInit === 'function' && c.doInit.call(c, id);
-        },
-    },
-    async create(id, type = 'panel', params = [], useCache = true) {
-        const cacheKey = useCache && JSON.stringify({id, type, params});
-        let config;
-        if (!id) {
-            return config;
-        }
-        if (cacheKey) {
-            const cached = this.cache.get(cacheKey);
-            if (cached) {
-                return cached;
-            }
-        }
-        const paramsObject = this.paramsToObject(params);
-        const filterDefaults =
-            (paramsObject && Object.assign(paramsObject, {doFilter: true})) || {};
-        switch (String(type).toUpperCase()) {
-        case 'REPORT':
-            config = {
-                xtype: 'ReportPanel',
-                reportID: id,
-                filterDefaults,
-                listeners: {
-                    'router:activate': this.onActivateComponent.bind(
-                        this,
-                        paramsObject
-                    ),
-                },
-            };
-            break;
-        case 'PANEL':
-            try {
-                config = await Coon.util.promisifyCmd(
-                    'Coon.uielement.command.GetUIElementCommand',
-                    id
-                );
-                if (typeof config === 'object') {
-                    if (typeof config.propertyData === 'string') {
-                        config.propertyData = JSON5.parse(
-                            config.propertyData,
-                            (key, value) => {
-                                if (value === 'true') {
-                                    return true;
-                                }
-                                if (value === 'false') {
-                                    return false;
-                                }
-                                return value;
-                            }
-                        );
-                    }
-                    config = Object.assign(
-                        {xtype: config.xtype, itemId: id},
-                        config.propertyData
-                    );
-                    if (config.xtype === 'ReportPanel') {
-                        Object.assign(config, {
-                            filterDefaults,
-                            listeners: {
-                                'router:activate': this.onActivateComponent.bind(
-                                    this,
-                                    paramsObject
-                                ),
-                            },
-                        });
-                    } else if (config.xtype === 'UiCustomPanel') {
-                        Object.assign(config, {
-                            listeners: {
-                                'router:activate': this.onActivateComponent.bind(
-                                    this,
-                                    paramsObject
-                                ),
-                                'afterrender': (panel) =>
-                                    Coon.Function.executeComponentDoInit(panel, paramsObject),
-                            },
-                        });
-                    } else {
-                        Object.assign(config, {
-                            listeners: {
-                                'afterrender': (panel) =>
-                                    Coon.Function.executeComponentDoInit(panel, paramsObject),
-                            },
-                        });
-                    }
-                }
-            } catch (e) {
-                Coon.log.error(e.message);
-            }
-            break;
-        case 'EDIT-REPORT':
-            config = {
-                _preferFullScreen: true,
-                _allowRedirect: false,
-                xtype: 'ReportFormEditPanel',
-                listeners: {
-                    'afterrender': (panel) => this.onRenderEditor.call(this, panel, id),
-                },
-            };
-            break;
-        case 'EDIT-PANEL':
-            config = {
-                _preferFullScreen: true,
-                _allowRedirect: false,
-                xtype: 'UiCustomPanelEditor',
-                listeners: {
-                    'afterrender': (panel) => this.onRenderEditor.call(this, panel, id),
-                },
-            };
-            break;
-        }
-        cacheKey && this.cache.set(cacheKey, config);
-        return config;
-    },
-});