ru.coon 2.8.65 → 3.0.2

package/src/report/component/reportpanel/FormFieldFocusPlugin.js

@@ -0,0 +1,157 @@
+/**
+ * Плагин нормализует поведение переноса фокуса с поля на поле в FilterPanel по нажатию TAB и SHIFT+TAB.
+ * Включает на полях формы свойство enableKeyEvents.
+ */
+Ext.define('Coon.report.component.reportpanel.FormFieldFocusPlugin', {
+    extend: 'Ext.AbstractPlugin',
+    alias: 'plugin.FormFieldFocusPlugin',
+    id: 'FormFieldFocusPlugin',
+    // Установить фокус по умолчанию на первое поле
+    defaultFocusFirstField: true,
+    // Установить фокус на это поле.
+    defaultFocusField: undefined,
+    // Отключение плагина можно сделать путем установки свойства репорта formFieldFocusPluginConfig
+    disabled: false,
+
+    constructor: function(config) {
+        Ext.apply(this, config || {});
+        this.callParent([config]);
+    },
+
+    init: function(formPanel) {
+        if (this.disabled) {
+            Coon.log.debug('FormFieldFocusPlugin disabled!');
+            return;
+        }
+        this.fields = Coon.Function.getFormFields(formPanel);
+        if (!this.fields.length) {
+            return;
+        }
+
+        this.getCmp().on('afterrender', function() {
+            this.preprocessFields();
+            this.setFocus();
+            const centerView = this.getCmp().up('centerview');
+            if (centerView) {
+                const container = centerView.getLayout().getActiveItem();
+                container.on('activate', this.restoreFocus, this);
+            }
+        }, this);
+        formPanel.addCls('panel-with-form-field-focus-plugin');
+    },
+
+    getAvailableFields() {
+        return this.fields.filter((field) => this.isFieldFocusable(field));
+    },
+
+    getFields() {
+        return this.fields;
+    },
+
+    buildFieldFocusIds() {
+        this.getFields().forEach((field, idx) => {
+            this.clearFieldFocusId(field);
+        });
+        this.getAvailableFields().forEach((field, idx) => {
+            this.setFieldFocusId(field, idx);
+        });
+    },
+
+    setFieldFocusId(field, idx) {
+        const fieldsCount = this.getAvailableFields().length;
+        field.prevFocusId = idx === 0 ? fieldsCount - 1 : idx - 1;
+        field.focusId = idx;
+        field.nextFocusId = idx === fieldsCount - 1 ? 0 : idx + 1;
+    },
+
+    clearFieldFocusId(field) {
+        field.prevFocusId = undefined;
+        field.focusId = undefined;
+        field.nextFocusId = undefined;
+    },
+
+    preprocessFields() {
+        this.buildFieldFocusIds();
+        this.getFields()
+            .forEach((field, idx) => {
+                if (field.defaultFocus) {
+                    this.defaultFocusField = field;
+                }
+                field.enableKeyEvents = true;
+                field.on({
+                    specialkey: this.onSpecialkeyPress,
+                    focus: function(f) {
+                        this.setLastFocus(f.focusId);
+                    }.bind(this),
+                    show: this.buildFieldFocusIds,
+                    hide: this.buildFieldFocusIds,
+                    enable: this.buildFieldFocusIds,
+                    disable: this.buildFieldFocusIds,
+                    scope: this,
+                });
+            });
+    },
+
+    setFocus() {
+        const visibleFields = this.getAvailableFields();
+        if (!visibleFields.length) {
+            return;
+        }
+        if (this.defaultFocusFirstField) {
+            let fieldForFocus = this.defaultFocusField;
+            if (!fieldForFocus && this.defaultFocusFirstField) {
+                if (this.isFieldFocusable(visibleFields[0])) {
+                    fieldForFocus = visibleFields[0].focus(false, 100);
+                } else {
+                    fieldForFocus = this.getNextField(visibleFields[0]);
+                }
+            }
+            if (fieldForFocus && this.isFieldFocusable(fieldForFocus)) {
+                fieldForFocus.focus(false, 100);
+            }
+        }
+    },
+
+    restoreFocus() {
+        const lastFocusedField = this.getLastFocusedField();
+        if (lastFocusedField) {
+            lastFocusedField.focus(false, 100);
+        }
+    },
+
+    getFieldByFocusId(focusId) {
+        return this.getCmp().down(`[focusId=${focusId}]`);
+    },
+
+    getNextField(field) {
+        return this.getFieldByFocusId(field.nextFocusId);
+    },
+
+    getPrevField(field) {
+        return this.getFieldByFocusId(field.prevFocusId);
+    },
+
+    setLastFocus(focusId) {
+        this.lastFocusId = focusId;
+    },
+
+    getLastFocusedField() {
+        const field = this.getFieldByFocusId(this.lastFocusId);
+        return this.isFieldFocusable(field) && field;
+    },
+
+    onSpecialkeyPress: function(field, e) {
+        const shiftKey = e.shiftKey;
+        if (e.keyCode === e.TAB) {
+            e.stopEvent();
+            const nextFocusField = shiftKey ? this.getPrevField(field) : this.getNextField(field);
+            if (nextFocusField) {
+                nextFocusField.focus(false, 100);
+            }
+        }
+    },
+
+    isFieldFocusable(field) {
+        return field && !field.isHidden() && !field.isDisabled() && !field.readOnly && field.focusable;
+    },
+});

package/src/report/component/reportpanel/FormFieldFocusPlugin.scss

@@ -0,0 +1,14 @@
+$focus-background-color: rgba(254, 249, 233, 1) !default;
+.panel-with-form-field-focus-plugin {
+    .x-field:has(*:focus) {
+        background-color: $focus-background-color;
+        background-clip: content-box;
+
+        .x-form-item-body {
+        background-color: $focus-background-color;
+        }
+    }
+    .x-form-cb-wrap-inner:has(*:focus)    {
+        background-color: $focus-background-color;
+    }
+}

package/src/report/component/reportpanel/NorthPanel.js

@@ -31,7 +31,7 @@ Ext.define('Coon.report.component.report.NorthPanel', {
                 cls: 'x-unselectable btn-toggle',
                 style: {
                     backgroundColor: 'transparent!important',
-                    marginRight: '20px',
+                    marginRight: '8px',
                 },
                 scale: 'small',
                 hidden: true,
@@ -97,7 +97,7 @@ Ext.define('Coon.report.component.report.NorthPanel', {
             },
             cls: 'buttonsContainer',
             defaults: {
-                margin: '0 16 0 0',
+                margin: '0 8px 0 0',
                 xtype: 'button',
             },
             items: [
@@ -137,17 +137,12 @@ Ext.define('Coon.report.component.report.NorthPanel', {
             }
         ];
 
-        /**
-         * Только при добавлении компонента в ReportPanel можно получить ссылку на родителя
-         */
-        this.on('added', function() {
-            this.reportPanel = this.findParentByType('ReportPanel') || this.findParentByType('ReportFilterForm');
-            this.searchButton.handler = this.reportPanel ? Ext.bind(this.reportPanel.filterHandler, this.reportPanel) : Ext.emptyFn;
-            this.clearButton.handler = Ext.bind(function() {
-                this.clearFilter();
-                this.clearData();
-            }, this.reportPanel);
-        }, this);
+        this.reportPanel = this.up('ReportPanel,ReportFilterForm');
+        this.searchButton.handler = this.reportPanel ? Ext.bind(this.reportPanel.filterHandler, this.reportPanel) : Ext.emptyFn;
+        this.clearButton.handler = Ext.bind(function() {
+            this.clearFilter();
+            this.clearData();
+        }, this.reportPanel);
 
         this.callParent();
     },
@@ -166,21 +161,25 @@ Ext.define('Coon.report.component.report.NorthPanel', {
     },
 
     configureFilterPanel: function(reportFormBean) {
-        const ns = Coon.report.model.ReportBeanFields;
-        const properties = Coon.Function.convertAdvancedProperties(reportFormBean[ns.$properties]) || {};
+        const report = this.up('ReportPanel');
+        const properties = report && report.configProperties ||
+            Coon.Function.convertAdvancedProperties(reportFormBean.properties) || {};
         Ext.merge(this, properties);
         this.filterPlugins.push({
             ptype: 'EnterConfirmFormPlugin',
             confirmHandler: this.reportPanel ? Ext.bind(this.reportPanel.filterHandler, this.reportPanel) : Ext.emptyFn,
         });
+        this.filterPlugins.push(Ext.apply({
+            ptype: 'FormFieldFocusPlugin',
+        }, properties.formFieldFocusPluginConfig || {}, {defaultFocusFirstField: true}));
 
         const [enableHighlightingRequiredFields, hiddenLegend] = this.hasPropertiesFilterPanel(reportFormBean.plugins, properties);
         this.hiddenLegend = !!hiddenLegend;
         this.enableHighlightingRequiredFields = enableHighlightingRequiredFields;
         const filterPanel = Ext.widget('FilterPanel', {
-            configurationList: reportFormBean[ns.$parameters],
+            configurationList: reportFormBean.parameters,
             itemsOnRow: properties['filterItemsOnRow'] || 2,
-            enableHighlightingRequiredFields: enableHighlightingRequiredFields,
+            enableHighlightingRequiredFields,
             plugins: this.filterPlugins,
         });
         this.filterPanel = filterPanel;

package/src/report/component/reportpanel/NorthPanel.scss

@@ -14,7 +14,7 @@
         min-height: 0px !important;
     }
     .UiCFCell{
-        margin: 0px 2px !important;
+       margin: 0 4px 0 0 !important;
     }
 
   @include sigma-button-small-ui(

package/src/report/component/reportpanel/ReportContextMenu.js

@@ -0,0 +1,219 @@
+/**
+ * Компонент контекстного меню репорта
+ * Меню содержит несколько групп. Порядок следования групп определен в конфигурации меню.
+ * Для каждой группы реализован вспомогательный метод для добавления в группу пункта меню.
+ * При первом отображении пункты меню сортируются единожды и при необходимости добавляются горизонтальные разделители между группами.
+ * У группы pluginbuttons в основном меню есть ограничение на 5 (maxMenuGroupItems) видимых пунктов меню. Если у этой группы появляется 6-й видимый
+ * пункт меню, то создается подменю с пунктами, которые не поместились в основное меню.
+ */
+Ext.define('Coon.report.component.reportpanel.ReportContextMenu', {
+    extend: 'Ext.menu.Menu',
+    alias: 'widget.ReportContextMenu',
+    uses: [],
+    requires: [],
+    orderOfGroups: {
+        // Кнопка "Копировать" CopyCellValueMenuItem
+        copy: {
+            order: 1, // порядковый номер группы
+            hidden: false, // видимость группы
+            separator: true, // наличие разделителя после группы
+        },
+        // AddFilterConditionPlugin
+        advancedsearch: {order: 2, hidden: false, separator: true},
+        // CalculatorPlugin
+        calc: {order: 4, hidden: false, separator: true},
+        // GridToolbarButtonPlugin
+        pluginbuttons: {order: 3, hidden: false, separator: true},
+    },
+    sorted: false,
+    maxMenuGroupItems: 2,
+
+    initComponent() {
+        this.callParent(arguments);
+        this.on({
+            beforehide: 'onBeforeHideMenu',
+            scope: this,
+        });
+    },
+
+    onBeforeHideMenu() {
+        this.unfoldReportPluginButtons();
+    },
+
+    addToAdvancedSearch(item) {
+        this.addMenuItem('advancedsearch', item);
+    },
+
+    addCalcMenuItem(item) {
+        this.addMenuItem('calc', item);
+    },
+
+    addPluginButton(item) {
+        this.addMenuItem('pluginbuttons', item);
+    },
+
+    addCopyButton(item) {
+        this.addMenuItem('copy', item);
+    },
+
+    addMenuItem(group, item) {
+        if (!Ext.isString(group) || !Object.keys(this.orderOfGroups).includes(group)) {
+            return Coon.log.warn('Пункт меню не добавлен. Ошибочная группа: ', group);
+        }
+        item.group = group;
+        this.add(item);
+    },
+
+    sortFn(a, b) {
+        if (!a.group) {
+            a.group = 0;
+        }
+        if (!b.group) {
+            b.group = 0;
+        }
+        const orderA = this.orderOfGroups[a.group] && this.orderOfGroups[a.group].order;
+        const orderB = this.orderOfGroups[b.group] && this.orderOfGroups[b.group].order;
+        let ord; let sortsequenceA; let sortsequenceB;
+        if (a.group==='pluginbuttons' && b.group==='pluginbuttons') {
+            sortsequenceA = a.config.sortSequence;
+            sortsequenceB = b.config.sortSequence;
+            ord = (sortsequenceA > sortsequenceB) ? 1 : ((sortsequenceB > sortsequenceA) ? -1 : 0);
+        }
+        const groupSort = (orderA > orderB) ? 1 : ((orderB > orderA) ? -1 : 0);
+        if (Ext.isDefined(ord) && groupSort===0) {
+            return ord;
+        }
+        return groupSort;
+    },
+
+    isItemHidden(item) {
+        if (Ext.isFunction(item.isValid)) {
+            return !item.isValid();
+        } else if (Ext.isFunction(item.isItemHidden)) {
+            return item.isItemHidden();
+        } else {
+            return false;
+        }
+    },
+
+    isItemDisabled(item) {
+        if (Ext.isFunction(item.isItemDisabled)) {
+            return item.isItemDisabled();
+        } else {
+            return false;
+        }
+    },
+
+    hasGroupVisibleItems(group) {
+        return this.items.findBy(function(item) {
+            return item.xtype!=='menuseparator' && item.group === group && !item.isHidden();
+        }, this);
+    },
+
+    processItems() {
+        if (!this.items) {
+            return;
+        }
+        if (!this.sorted) {
+            this.sortAndSeparate();
+        }
+        this.items.each(function(item) {
+            if (item.xtype !== 'menuseparator') {
+                const group = item.group;
+                const groupHidden = this.orderOfGroups[group].hidden;
+                const isItemHidden = groupHidden || this.isItemHidden(item);
+                item.setHidden(isItemHidden);
+                !isItemHidden && (item.setDisabled(this.isItemDisabled(item)));
+            } else {
+                item.setVisible(!!this.hasGroupVisibleItems(item.group));
+            }
+        }, this);
+        this.foldReportPluginButtons();
+    },
+
+    foldReportPluginButtons() {
+        let i = 0;
+        this.lastUnfoldedItem = undefined;
+        this.items.each(function(item) {
+            if (item.group==='pluginbuttons' && item.xtype!=='menuseparator' && !this.isItemHidden(item)) {
+                i++;
+                if (i > this.maxMenuGroupItems) {
+                    this.foldItem(item, this.lastUnfoldedItem);
+                } else {
+                    this.lastUnfoldedItem = item;
+                }
+            }
+        }, this);
+    },
+
+    foldItem(item, after) {
+        if (!this.submenu) {
+            this.submenu = new Ext.menu.Item({text: 'Другие пункты меню', group: 'pluginbuttons', menu: {items: []}});
+            this.add(this.submenu);
+            this.moveAfter(this.submenu, after);
+        }
+        this.moveBetweenMenus(this, this.submenu.menu, item);
+    },
+
+    /**
+     * Перенос пункта меню из одного меню в другое.
+     * @param {Ext.menu.Menu} fromMenu
+     * @param {Ext.menu.Menu} toMenu
+     * @param item
+     * @param after поместить после этого пункта меню
+     */
+    moveBetweenMenus(fromMenu, toMenu, item, after) {
+        if (!item) {
+            return;
+        }
+        fromMenu.remove(item, {destroy: false});
+        toMenu.add(item);
+        if (after) {
+            toMenu.moveAfter(item, after);
+        }
+    },
+
+    /**
+     * Перенос при необходимости пунктов из подменю в основное меню
+     */
+    unfoldReportPluginButtons() {
+        if (this.submenu && this.submenu.menu.items.getCount() > 0) {
+            this.submenu.menu.items.getRange().reverse().forEach(function(item) {
+                this.moveBetweenMenus(this.submenu.menu, this, item, this.lastUnfoldedItem);
+            }, this);
+        }
+        this.remove(this.submenu);
+        this.submenu = undefined;
+    },
+
+    /**
+     * Сортировка и добавление разделителей
+     */
+    sortAndSeparate() {
+        this.items.sortBy(this.sortFn.bind(this));
+        this.sorted = true;
+        let curGroup;
+        let increment = 0;
+        this.items.each(function(item, index) {
+            if (item.group !== curGroup && curGroup) {
+                this.addSeparator(index + increment, curGroup);
+                increment++;
+            }
+            curGroup = item.group;
+        }, this);
+    },
+
+    addSeparator(index, group) {
+        this.insert(index, {xtype: 'menuseparator', group});
+    },
+
+    show(xy) {
+        if (Ext.isArray(xy)) {
+            this.processItems();
+            this.showAt(xy);
+        } else {
+            this.callParent(arguments);
+        }
+    },
+
+});

package/src/report/component/reportpanel/ReportGrid.js

@@ -24,6 +24,7 @@ Ext.define('Coon.report.component.reportpanel.ReportGrid', {
         checkedRecords: [],
     },
     url: '/ReportFormData/get',
+    contextMenuItemsAdded: false,
 
     initComponent: function() {
         this.store = Ext.create('Coon.report.component.reportpanel.ReportStore', {

package/src/report/component/reportpanel/ReportGrid.scss

@@ -49,4 +49,8 @@
       font-size: 16px !important
     }
   }
+  // Класс для визуального обозначения колонки, по которой есть локальный фильтр
+  .x-grid-cell.filtered-cell {
+    //background-color: #fff6e8;
+  }
 }

package/src/report/component/settings/field/ReportFormFieldsGrid.js

@@ -63,14 +63,14 @@ Ext.define('Coon.report.component.settings.field.ReportFormFieldsGrid', {
                 xtype: 'button',
                 ui: 'blue-text-button-border',
                 text: 'Добавить',
-                id: 'addField',
+                itemId: 'addField',
                 handler: 'addHandler',
             },
             {
                 xtype: 'button',
                 ui: 'blue-text-button-border',
                 text: 'Добавить группу',
-                id: 'addGroup',
+                itemId: 'addGroup',
                 handler: 'addGroupHandler',
             },
             {

package/src/report/component/settings/field/ReportFormFieldsGridController.js

@@ -61,7 +61,7 @@ Ext.define('Coon.report.component.settings.ReportFormFieldsGridController', {
 
     addHandler: function(button) {
         const view = this.getView();
-        const parent = button.id === 'addField' ? view.getStore().getRoot() : view.getSelectionModel().getSelection()[0];
+        const parent = button.itemId === 'addField' ? view.getStore().getRoot() : view.getSelectionModel().getSelection()[0];
         parent.appendChild({
             isNew: true,
             properties: [],
@@ -98,7 +98,7 @@ Ext.define('Coon.report.component.settings.ReportFormFieldsGridController', {
                 {
                     text: 'Сохранить',
                     handler: function() {
-                        const parent = button.id === 'addGroup' ? view.getStore().getRoot() : view.getSelectionModel().getSelection()[0];
+                        const parent = button.itemId === 'addGroup' ? view.getStore().getRoot() : view.getSelectionModel().getSelection()[0];
                         parent.appendChild({
                             isNew: true,
                             groupName: win.down('textfield').getValue(),

package/src/report/component/settings/property/ReportPropertiesPanelController.js

@@ -119,7 +119,7 @@ Ext.define('Coon.report.component.settings.property.ReportPropertiesPanelControl
         const editor = this.getPropertyValueEditor(record);
         if (editor && typeof editor.setValue === 'function') {
             this.lookup('propertyValueContainer').add(editor);
-            editor.setBind({value: '{propertyGrid.selection.value}'});
+            editor.setBind({value: '{propertyGrid.selection.value || propertyGrid.selection.defaultVal}'});
         } else {
             Coon.log.debug('HASN`T EDITOR', record.getData(), editor);
         }

package/src/report/component/settings/property/ReportPropertyDictionary.js

@@ -193,6 +193,13 @@ Ext.define('Coon.report.component.settings.property.ReportPropertyDictionary', {
                     leaf: true,
                     singleValue: true,
                     description: 'Свойство даёт возможность скрывать/показывать признак обязательности заполнения полей.',
+                },
+                {
+                    id: 'formFieldFocusPluginConfig',
+                    leaf: true,
+                    defaultVal: '{disabled: false, defaultFocusFirstField: true}',
+                    description: 'Свойства, передаваемые плагину formFieldFocusPlugin, используемому в фильтр панели репорта ',
+                    propertyValueType: 'object',
                 }
             ],
         },

package/src/report/plugin/configPanel/AddFilterConditionPluginConfigPanel.js

@@ -122,13 +122,36 @@ Ext.define('Coon.report.plugin.configPanel.AddFilterConditionPluginConfigPanel',
             ],
         });
 
+        this.filterAllVisibleField = this.getFilterAllVisibleCheckbox();
+        this.filterAllVisibleField.on('change', this.onAllVisibleChange, this);
+
         return [
+            this.filterAllVisibleField,
             this.addToContextMenu,
             this.filterField,
             this.grid
         ];
     },
 
+    getFilterAllVisibleCheckbox() {
+        const checked = true;
+        this.toggleFilterableColumn(!checked);
+        return Ext.create('Ext.form.field.Checkbox', {
+            boxLabel: 'Есть возможность фильтровать все видимые колонки',
+            name: 'filterAllVisible',
+            inputValue: true,
+            checked,
+        });
+    },
+
+    onAllVisibleChange(checkbox, value) {
+        this.toggleFilterableColumn(!value);
+    },
+
+    toggleFilterableColumn(visible) {
+        this.grid.getColumnModel().findColumnByDataIndex('byCellValueFilterable').setVisible(visible);
+    },
+
     filter: function(_, value) {
         const store = this.grid.getStore();
         store.clearFilter();
@@ -180,16 +203,16 @@ Ext.define('Coon.report.plugin.configPanel.AddFilterConditionPluginConfigPanel',
     },
 
     getConfiguration() {
-        return {
-            filterOptions: JSON.stringify(this.grid.getStore().getRange().reduce(
-                function(acc, current) {
-                    if (current.get('byCellValueFilterable')) {
-                        acc[current.get('reportFieldCd')] = current.get('byCellValueFilterable');
-                    }
-                    return acc;
-                },
-                {}
-            )),
-        };
+        const config = this.callParent();
+        config['filterOptions'] = JSON.stringify(this.grid.getStore().getRange().reduce(
+            function(acc, current) {
+                if (current.get('byCellValueFilterable')) {
+                    acc[current.get('reportFieldCd')] = current.get('byCellValueFilterable');
+                }
+                return acc;
+            },
+            {}
+        ));
+        return config;
     },
 });

package/src/report/plugin/configPanel/GridFiltersPluginConfigPanelFiltersGrid.js

@@ -93,9 +93,10 @@ Ext.define('Coon.report.plugin.configPanel.GridFiltersPluginConfigPanelFiltersGr
     },
 
     addHandler: function() {
-        this.getStore().add(Ext.create('Coon.report.model.ComboValueWrapper'));
+        const record = this.getStore().insert(0, {})[0];
         const editor = this.findPlugin('cellediting');
-        editor.startEditByPosition({row: this.getStore().getCount() - 1, column: 0});
+        const rowIndex = this.getStore().indexOf(record);
+        editor.startEditByPosition({row: rowIndex, column: 0});
     },
 
     deleteHandler: function() {