ru.coon 2.8.65 → 3.0.2

package/src/report/plugin/grid/CalculatorPlugin.js

@@ -0,0 +1,90 @@
+Ext.define('Coon.report.plugin.grid.CalculatorPlugin', {
+    extend: 'Ext.AbstractPlugin',
+    alias: 'plugin.CalculatorPlugin',
+    uses: [],
+    requires: [
+        'Ext.grid.Panel'
+    ],
+
+    init: function(grid) {
+        this.grid = grid;
+        grid.on('added', function(grid) {
+            this.contextMenu = grid.contextMenu;
+            this.calculatorButtons = Ext.widget('ReportCalculatorMenuItem', {
+                contextIndependent: true,
+                order: 1000,
+            });
+            this.calculatorButtons.on({
+                openCalculator: this.openCalculator,
+                setMemory: this.setCalcOperation,
+                subtractMemory: this.setCalcOperation,
+                addMemory: this.setCalcOperation,
+                scope: this,
+            });
+            this.contextMenu.addCalcMenuItem(this.calculatorButtons);
+        }, this);
+        grid.contextMenu.on('requestMenuItems', this.onShowMenu, this);
+    },
+
+    onShowMenu({record, cellIndex}) {
+        const showReportCalculator = Coon.setup.get('showReportCalculator');
+        this.calculatorButtons.setHidden(!showReportCalculator);
+        const columns = this.grid.getColumns();
+        const column = columns.length && columns[cellIndex];
+        let isVisibleMemoryButtons = false;
+        if (column) {
+            this.column = column;
+            this.columnValue = record.get(column.dataIndex);
+            isVisibleMemoryButtons = this.canBeingNumber(this.columnValue)!==false;
+        }
+        if (showReportCalculator) {
+            this.calculatorButtons.setHiddenMemoryButtons(!isVisibleMemoryButtons);
+        }
+    },
+
+    canBeingNumber(cellValue) {
+        if (typeof cellValue === 'number' && !isNaN(cellValue)) {
+            return cellValue;
+        }
+        if (!cellValue) {
+            return false;
+        }
+        if (Ext.isString(cellValue)) {
+            const numb = Number(cellValue.replace(',', '.').replaceAll(' ', ''));
+            if (numb || numb === 0) {
+                return numb;
+            } else {
+                return false;
+            }
+        } else {
+            return false;
+        }
+    },
+    setCalcOperation(text) {
+        const vm = Coon.report.component.calculator.ReportCalculatorPanel.getViewModel();
+        const cellValue = Ext.isString(this.columnValue) ? Number(this.columnValue.replace(',', '.').replaceAll(' ', '')):
+            this.columnValue;
+        const memory = vm.get('memory') || 0;
+        switch (text) {
+        case 'M=':
+            vm.set('memory', cellValue);
+            break;
+        case 'M+':
+            vm.set('memory', window.Decimal(memory).plus(window.Decimal(cellValue)));
+            break;
+        case 'M-':
+            vm.set('memory', window.Decimal(memory).minus(window.Decimal(cellValue)));
+            break;
+        }
+        this.closeMenu();
+    },
+
+    openCalculator() {
+        Coon.report.component.calculator.ReportCalculatorPanel.open();
+        this.closeMenu();
+    },
+
+    closeMenu() {
+        this.contextMenu.hide();
+    },
+});

package/src/report/plugin/grid/GridContextMenu.js

@@ -15,21 +15,21 @@ Ext.define('Coon.report.plugin.grid.GridContextMenu', {
             return;
         }
         this.grid = component;
-        this.grid.getView().on({
+        this.grid.on({
             cellcontextmenu: {
                 fn: this.cellContextMenuHandler,
                 scope: this,
             },
             containercontextmenu: {
                 fn: function(view, event) {
-                    this.showContextMenu({event, view});
+                    this.showContextMenu({event, view, hasContext: false});
                     event.preventDefault();
                 },
                 scope: this,
             },
         });
 
-        this.grid.contextMenu = Ext.create('Coon.common.tree.BaseContextMenu', {items: this.items});
+        this.grid.contextMenu = Ext.widget('ReportContextMenu', {items: this.items});
         this.grid.contextMenu.on('show', this.displacementContextMenu, this);
         this.grid.contextMenu.on('hide', this.restoreCellQtip, this);
         this.grid.getSelectionModel().on('selectionchange', this.updateContext, this);
@@ -49,8 +49,10 @@ Ext.define('Coon.report.plugin.grid.GridContextMenu', {
             return;
         }
         const cell = this.grid.getView().getCell(contextMenu.record, column);
-        this.qtipSpan = cell.querySelector('[data-qtip]');
-        this.qtipSpan && this.qtipSpan.removeAttribute('data-qtip');
+        if (cell) {
+            this.qtipSpan = cell.querySelector('[data-qtip]');
+            this.qtipSpan && this.qtipSpan.removeAttribute('data-qtip');
+        }
 
         // contextMenu.alignTo(cell, 'tl-bl');
 
@@ -86,17 +88,17 @@ Ext.define('Coon.report.plugin.grid.GridContextMenu', {
     cellContextMenuHandler: function(view, td, cellIndex, record, tr, rowIndex, event) {
         this.grid.getSelectionModel().select(rowIndex);
         if (record) {
-            this.showContextMenu({view, td, cellIndex, record, tr, rowIndex, event});
+            this.showContextMenu({view, td, cellIndex, record, tr, rowIndex, event, hasContext: true});
         }
-        return false;
     },
 
-    showContextMenu: function({view, td, cellIndex, record, tr, rowIndex, event}) {
+    showContextMenu: function(options) {
+        const {view, td, cellIndex, record, tr, rowIndex, event, hasContext} = options;
         const contextMenu = this.grid.contextMenu;
         if (record) {
             contextMenu.record = record;
         }
-        contextMenu.context = {view, td, cellIndex, record, tr, rowIndex, event},
+        contextMenu.context = {view, td, cellIndex, record, tr, rowIndex, event, hasContext};
         cellIndex && (contextMenu.cellIndex = cellIndex);
         const store = this.grid.getStore();
         let params;
@@ -106,7 +108,7 @@ Ext.define('Coon.report.plugin.grid.GridContextMenu', {
             params = store.lastOptions && store.lastOptions.params;
         }
         contextMenu.params = params && params.parameterList && Coon.Function.convertProperties(Ext.decode(params.parameterList));
-        contextMenu.fireEvent('requestMenuItems', {view, td, cellIndex, record, tr, rowIndex, event});
+        contextMenu.fireEvent('requestMenuItems', options);
         const showMenu = contextMenu.items &&
             contextMenu.items.getRange().find((item) => !item.hidden);
         if (showMenu) {

package/src/report/plugin/grid/GridRowCountPlugin.js

@@ -25,7 +25,6 @@ Ext.define('Coon.report.plugin.grid.GridRowCountPlugin', {
             datachanged: this.recalculate,
             selectionchange: this.recalculate,
             updatecheckedrecords: this.recalculate,
-            // mixedrowselectionchange: this.recalculate,
             scope: this,
         });
     },

package/src/report/plugin/grid/GridToolbarButtonPlugin.js

@@ -188,15 +188,24 @@ Ext.define('Coon.report.plugin.grid.GridToolbarButtonPlugin', {
     },
 
     addToContextMenuHandler: function(config) {
+        if (!this.component) {
+            return;
+        }
         const menu = this.component.contextMenu;
+        const contextMenuItemsAdded = this.component.contextMenuItemsAdded;
         if (this.buttonUI && !config['ui']) {
             config['ui'] = this.buttonUI;
         }
-        menu && menu.add(new Ext.menu.Item({
+        if (menu && !contextMenuItemsAdded) {
+            this.component.contextMenuItemsAdded = true;
+        }
+        menu && menu.addPluginButton(new Ext.menu.Item({
+            sortSequence: this.sortSequence,
             text: this.buttonText,
             iconCls: this.buttonIconCls,
             ui: this.buttonUI,
-            isValid: Ext.bind(() => !this.computeState().disabled, this),
+            isItemDisabled: Ext.bind(() => this.computeState().disabled, this),
+            isItemHidden: Ext.bind(() => this.computeState().hidden, this),
             handler: Ext.Function.createSequence(Ext.bind(this.handler, this), function() {
                 menu.hide();
             }),

package/src/report/plugin/grid/OpenCustomPanelButtonPlugin.js

@@ -4,7 +4,8 @@ Ext.define('Coon.report.plugin.grid.OpenCustomPanelButtonPlugin', {
     uses: [],
     requires: [
         'Coon.setup',
-        'Coon.eventBus'
+        'Coon.eventBus',
+        'Coon.util.ContextManager'
     ],
     alternateClassName: [
         'Sigma.common.grid.plugin.OpenCustomPanelButtonPlugin',
@@ -34,6 +35,8 @@ Ext.define('Coon.report.plugin.grid.OpenCustomPanelButtonPlugin', {
         sendDataOnSelect: false,
         createChangeSelectionButton: false,
 
+        openInWindow: false,
+
         displacedView: undefined,
         centerView: undefined,
         previousView: undefined,
@@ -66,37 +69,37 @@ Ext.define('Coon.report.plugin.grid.OpenCustomPanelButtonPlugin', {
         }
         if (Ext.isEmpty(this.effectiveXTypeObject.effectiveXType) && !this.effectiveXTypeObject.deferred) {
             Ext.Msg.alert('Сообщение системы', 'Для плагина OpenCustomPanelButtonPlugin не определен тип панели (xtype) для открытия');
-        } else {
-            if (this.xtypeSelector === 'UI_LIST') {
-                if (!this.getUIElement()) {
-                    Coon.log.log('UIElement не указан');
+            return;
+        }
+        if (this.xtypeSelector === 'UI_LIST') {
+            if (!this.getUIElement()) {
+                Coon.log.log('UIElement не указан');
+                return;
+            }
+            const command = Ext.create('command.GetUIElementCommand');
+            command.on('complete', function(uIElementBean) {
+                if (!uIElementBean || !uIElementBean.xtype) {
+                    Coon.log.error('UIElement dont exist or invalid');
                     return;
                 }
-                const command = Ext.create('command.GetUIElementCommand');
-                command.on('complete', function(uIElementBean) {
-                    if (!uIElementBean || !uIElementBean.xtype) {
-                        Coon.log.error('UIElement dont exist or invalid');
-                        return;
-                    }
-                    const exists = Ext.ClassManager.getByAlias('widget.' + uIElementBean.xtype);
-                    if (!exists) {
-                        Coon.log.log(uIElementBean.xtype + ' does not exist');
-                        return;
-                    }
-                    this.effectiveXTypeObject.effectiveXType = uIElementBean.xtype;
-                    this.effectiveXTypeObject.properties =
+                const exists = Ext.ClassManager.getByAlias('widget.' + uIElementBean.xtype);
+                if (!exists) {
+                    Coon.log.log(uIElementBean.xtype + ' does not exist');
+                    return;
+                }
+                this.effectiveXTypeObject.effectiveXType = uIElementBean.xtype;
+                this.effectiveXTypeObject.properties =
                         this.effectiveXTypeObject.effectiveXType === 'UiCustomPanel' ?
                             JSON5.parse(uIElementBean.propertyData) :
                             (
                                 Ext.decode(uIElementBean.propertyData) ||
                                 Coon.Function.convertAdvancedProperties(uIElementBean.properties)
                             );
-                    this.component.getContextManager().executeFunction(Ext.bind(this.openPanel, this), this.parameters);
-                }, this);
-                command.execute(this.getUIElement());
-            } else {
                 this.component.getContextManager().executeFunction(Ext.bind(this.openPanel, this), this.parameters);
-            }
+            }, this);
+            command.execute(this.getUIElement());
+        } else {
+            this.component.getContextManager().executeFunction(Ext.bind(this.openPanel, this), this.parameters);
         }
     },
 
@@ -127,13 +130,94 @@ Ext.define('Coon.report.plugin.grid.OpenCustomPanelButtonPlugin', {
         }
     },
 
+    getCenterView() {
+        if (!this.centerView) {
+            this.centerView = this.centerView || this.component.up('centerview');
+        }
+        return this.centerView;
+    },
+
+    hasInCenterView(componentContextId) {
+        return !!this.centerView.findComponent(componentContextId);
+    },
+
+    isCenterViewMode() {
+        this.displacedMode = !this.openInWindow;
+        return this.displacedMode &&
+            !this.isInWindow() &&
+            !this.oldFrame &&
+            !this.openInReport;
+    },
+
+    buildContext(properties, params) {
+        const ctx = {
+            record: this.getCmp().selection && this.getCmp().selection.getData(),
+            records: typeof this.getCmp().getSelection === 'function' && this.getCmp().getSelection().map((el) => el.getData()),
+        };
+        const parent = this.getCmp().up('[componentContextId]');
+        if (parent && parent.componentContextId) {
+            const uniqueContext = Object.assign(
+                {},
+                params,
+                {
+                    uiElementCd: properties.uiElementCd,
+                    xtype: properties.xtype,
+                }
+            );
+
+            properties.ctxMgr = Coon.util.ContextManager;
+            properties.componentContextId = properties.ctxMgr.createContext(
+                parent.componentContextId,
+                Object.assign(ctx, uniqueContext),
+                uniqueContext
+            );
+        };
+    },
+
+    configureCustomPanel(params) {
+        const properties = this.prepareProperties(
+            this.getCmp().up('ReportPanel') ||
+            this.getCmp()
+        );
+        properties.xtype = 'UiCustomPanel';
+        return properties;
+    },
+
     openPanel: function(params) {
         const xtype = this.oldFrame ? 'uxiframe' : this.effectiveXTypeObject.effectiveXType;
         if (!xtype) {
             return;
         }
+
+        if (xtype === 'UiCustomPanel') {
+            this.configureCustomPanel(params);
+        }
+
         const ownerComponent = this.getOwnerComponent();
         const properties = this.prepareProperties(ownerComponent);
+        properties.xtype = xtype;
+
+        const componentContextId = Coon.util.ContextManager.generateKey(
+            Object.assign(
+                {},
+                params,
+                {
+                    uiElementCd: properties.uiElementCd,
+                    xtype,
+                }
+            )
+        );
+
+        if (this.isCenterViewMode() && !this.getCenterView()) {
+            Coon.log.error('couldn\'t find parent  component "centerview"');
+            return;
+        }
+
+        if (this.isCenterViewMode() && this.hasInCenterView(componentContextId)) {
+            this.centerView.setActiveComponent({componentContextId});
+            return;
+        }
+
         const windowProperties = this.prepareWindowProperties(properties, xtype, ownerComponent);
 
         if (xtype === 'ReportPanel' || xtype === 'DynamicReportForm' || /.*FormPanel.*/.test(xtype)) {
@@ -148,8 +232,22 @@ Ext.define('Coon.report.plugin.grid.OpenCustomPanelButtonPlugin', {
             source: 'OpenCustomPanelButtonPlugin',
             params: params,
         };
-        const panel = Ext.widget(xtype, properties);
-        Coon.log.debug('OCPB.openPanel', xtype, properties.uiElementCd, {properties, params, panel});
+
+
+        properties.componentContextId = componentContextId;
+        properties.componentConfig = {
+            parentComponent: this.getCmp(),
+            context: Object.assign(
+                {},
+                params,
+                {
+                    uiElementCd: properties.uiElementCd,
+                }
+            ),
+        };
+
+        this.buildContext(properties, params);
+        const panel = Ext.create(properties);
         let parentWidget = panel;
 
         Coon.eventBus.emit(
@@ -158,18 +256,10 @@ Ext.define('Coon.report.plugin.grid.OpenCustomPanelButtonPlugin', {
             params
         );
 
-        if ((this.displacedMode || Coon.setup.get('overrides.displacedMode')) && !this.isInWindow() && !this.oldFrame) {
+        if (this.isCenterViewMode()) {
+            this.centerView.setActiveComponent(panel);
             Coon.Function.executeComponentDoInit(panel, params);
-            this.displacedView = panel;
-            this.changeViewInCentralComponent();
-            panel.on('close', function() {
-                this.displacedView.removeListener('displace', this.doDisplace, this);
-                this.previousView.removeListener('beforeactivate', this.preventActive, this);
-                this.changeViewInCentralComponent(true);
-                this.displacedView = undefined;
-                this.previousView = undefined;
-                this.centerView = undefined;
-            }, this);
+            panel.setClosable(true);
             panel.on('afterlayout', function(panel) {
                 panel.focus();
             }, this, {single: true});
@@ -199,21 +289,7 @@ Ext.define('Coon.report.plugin.grid.OpenCustomPanelButtonPlugin', {
                 };
             Ext.apply(defaultWindowConfig, windowProperties);
 
-            const canHold = Coon.userSettings.get('windowHolder') || Coon.setup.get('overrides.windowHolderMode');
-            const uniqueID = canHold &&
-                    Coon.util.generateHashFromObj(
-                        Object.assign(params, {uiElementCd: properties.uiElementCd}),
-                        {algorithm: 'md5'}
-                    ) ||
-                    Ext.id();
-
-            if (canHold && Coon.nav.windowHolder.checkHoldedWindow({uniqueID})) {
-                return;
-            }
-
             const openWindow = Ext.widget('WindowWrap', Ext.applyIf({
-                canHold,
-                uniqueID,
                 items: panel,
             }, Ext.apply({}, windowProperties || {}, defaultWindowConfig || {})));
 
@@ -312,45 +388,6 @@ Ext.define('Coon.report.plugin.grid.OpenCustomPanelButtonPlugin', {
         }
     },
 
-    changeViewInCentralComponent: function(revert) {
-        this.centerView = this.centerView || this.component.up('centerview');
-        if (this.centerView) {
-            if (revert) {
-                if (this.previousView) {
-                    this.centerView.setActiveItem(this.previousView);
-                }
-                if (this.displacedView) {
-                    this.centerView.remove(this.displacedView, 'detach');
-                }
-            } else {
-                const displacerComponent = this.centerView.getComponent(this.displacedView.getXType());
-                if (!displacerComponent) {
-                    this.centerView.add(this.displacedView);
-                }
-                this.previousView = this.centerView.getLayout().getActiveItem();
-
-                if (this.displacedView) {
-                    this.centerView.setActiveItem(this.displacedView);
-                    this.previousView.on('beforeactivate', this.preventActive, this);
-                    this.displacedView.on('displace', this.doDisplace, this, this.displacedView);
-                }
-            }
-        } else {
-            Coon.log.log('couldn\'t find parent  component "centerview"');
-        }
-    },
-
-    doDisplace: function(displacer) {
-        this.centerView.setActiveItem(displacer);
-    },
-
-    preventActive: function(viewToActive, viewIsActive) {
-        if (this.displacedView && (this.displacedView !== this.previousView)) {
-            this.displacedView.fireEvent('displace');
-        }
-        return !(this.previousView.getXType() === viewToActive.getXType());
-    },
-
     isInWindow() {
         return Ext.isDefined(this.component.up('window'));
     },

package/src/report/plugin/grid/ReportCharacteristicBindPlugin.js

@@ -302,16 +302,18 @@ Ext.define('Coon.report.plugin.grid.ReportCharacteristicBindPlugin', {
     },
 
     beforeselectHandler(selectionModel, newRecord) {
-        const callbackFn = function() {
-            this.fireEvent('needReload', this.updateParentReport);
-            selectionModel.view.setSelection(newRecord);
+        const callbackFn = () => {
+            this.grid.fireEvent('needReload', this.updateParentReport);
+            this.grid.on('load', function() {
+                selectionModel.select(newRecord);
+            }, this, {single: true});
         };
 
         if (Object.keys(this.initialCharData).length === 0) {
             return true;
         }
         if (!this.deepEquals(this.initialCharData, this.chars.getFullList(), {exclude: [this.ns.$valueDescription]})) {
-            Ext.Msg.prompt({
+            Ext.Msg.show({
                 title: 'Сообщение системы',
                 msg: 'Характеристики не были сохранены. Сохранить?',
                 buttons: Ext.Msg.YESNO,

package/src/report/plugin/grid/ReportColumnStatePlugin.js

@@ -64,10 +64,17 @@ Ext.define('Coon.report.plugin.grid.ReportColumnStatePlugin', {
     },
 
     applySavedState() {
+        if (this.getCmp().destroyed || !this.getCmp().rendered) {
+            return;
+        }
         const savedState = localStorage.getItem('reportsState');
         const columns = this.grid.getColumns();
         const columnHeader = this.grid.headerCt;
 
+        if (!Array.isArray(columns)) {
+            return;
+        }
+
         if (savedState) {
             let deserializedState; let currentReportState;
             try {
@@ -82,13 +89,18 @@ Ext.define('Coon.report.plugin.grid.ReportColumnStatePlugin', {
                 const stateMap = new Map();
                 currentReportState.forEach((e) => stateMap.set(e.columnId, e));
 
-                columns.forEach((column, i) => {
-                    if (column.hidden) {
+                columns.forEach((column) => {
+                    if (column.isHidden()) {
                         return;
                     }
                     const state = stateMap.get(column.dataIndex);
                     if (state) {
-                        column.setHidden(state.hidden);
+                        if (!column.up().getMenu().child('#columnItem')) {
+                            return;
+                        }
+                        if (state.hidden && column.isHideable() && !column.isHidden()) {
+                            column.setVisible(false);
+                        }
                         column.setWidth(state.width ? state.width : 100);
                         columnHeader.moveBefore(column, columnHeader.getComponent(state.position));
                     }

package/src/report/plugin/grid/SetSingleParameterPlugin.js

@@ -41,7 +41,7 @@ Ext.define('Coon.report.plugin.grid.SetSingleParameterPlugin', {
                         filterValue = filterValue === filter.checkedValue ? true : false;
                     }
 
-                    if (this.separateAction.getValue() === filterValue) {
+                    if (!this.separateAction || this.separateAction.getValue() === filterValue) {
                         return;
                     }
 

package/src/report/plugin/grid/ToolbarButtonPlugin.js

@@ -82,7 +82,7 @@ Ext.define('Coon.report.plugin.grid.ToolbarButtonPlugin', {
         if (this.buttonUI && !config['ui']) {
             config['ui'] = this.buttonUI;
         }
-        menu && menu.add(new Ext.menu.Item({
+        menu && menu.addPluginButton(new Ext.menu.Item({
             text: this.buttonText,
             iconCls: this.buttonIconCls,
             ui: this.buttonUI,

package/src/report/plugin/grid/addFilterConditionPlugin/AdvancedSearchPanel.js

@@ -0,0 +1,55 @@
+Ext.define('Coon.report.plugin.grid.addFilterConditionPlugin.AdvancedSearchPanel', {
+    extend: 'Ext.panel.Panel',
+    maxHeight: 500,
+    scrollable: true,
+    alias: 'widget.AdvancedSearchPanel',
+    controller: 'AdvancedSearchPanelController',
+    title: 'Расширенный поиск',
+    viewModel: {
+        data: {
+            filter: {},
+            isFiltersValid: true,
+        },
+    },
+    config: {
+        reportGrid: undefined,
+    },
+    layout: {
+        type: 'vbox', align: 'stretch',
+    },
+    padding: '4 0 0 0',
+
+    items: [
+    ],
+
+    buttons: [
+        {
+            text: 'Добавить',
+            ui: 'green-button',
+            handler: 'onAddNewFilterClick',
+        },
+        '->',
+        {
+            text: 'Поиск',
+            ui: 'orange-button',
+            handler: 'filterHandler',
+            bind: {
+                disabled: '{!isFiltersValid}',
+            },
+        },
+        {
+            text: 'Применить',
+            ui: 'green-button',
+            handler: 'applyHandler',
+            bind: {
+                disabled: '{!isFiltersValid}',
+            },
+        }
+    ],
+
+    updateReportGrid(grid) {
+        if (grid) {
+            this.getController().report = grid.up('ReportPanel');
+        }
+    },
+});