ru.coon 2.8.65 → 3.0.2

package/src/report/component/ReportFieldMap.js

@@ -0,0 +1,274 @@
+/**
+ * Словарь уникальных значений полей репорта
+ *
+ * Условия сбора данных:
+ *    Строковые данные:
+ *        в словарь собираются уникальные значения поля, до тех пор пока не достигнут максимум (maxMapSize),
+ *        после чего в зависимости от флага clearMapAfterOverflow он может быть очищен.
+ *    Числовые данные и даты:
+ *        в словарь собираются минимум и максимум данного поля.
+ *
+ * Определение истинного типа данных полей, с динамическим типом.
+ *      Параметры поля с динамическим типом данных:
+ *          dynamicTypeDetect - поле имеет динамический тип данных
+ *          autoNormalizeSort - автоматическая нормализованная сортировка
+ */
+Ext.define('Coon.report.component.ReportFieldMap', {
+    fields: undefined,
+    extremumDataTypes: ['DATETIME', 'TIME', 'DATE', 'MONEY', 'DECIMAL', 'INTEGER'],
+
+    config: {
+        maxMapSize: 500,
+        clearMapAfterOverflow: false,
+        collectOnlyVisible: true,
+    },
+    maps: undefined,
+    dynamicTypeFields: undefined,
+
+    constructor(config) {
+        this.maps = new Map();
+        this.dynamicTypeFields = {};
+        Ext.apply(this, config);
+        if (Ext.isObject(this.rawConfig)) {
+            Ext.apply(this, Coon.util.createObjFromTpl(this.config, this.rawConfig));
+        }
+        this.configureMaps(this.fields);
+    },
+
+    /** Создание конфига для словаря уникальных значений
+     * @param fields
+     */
+    configureMaps(fields) {
+        fields.forEach((field) => {
+            const fieldProps = Coon.Function.convertAdvancedProperties(field.properties);
+            const fieldMapConfig = fieldProps.fieldMapConfig;
+            const dynamicTypeDetect = (fieldMapConfig && fieldMapConfig.dynamicTypeDetect) || false;
+            const autoNormalizeSort = (fieldMapConfig && fieldMapConfig.autoNormalizeSort) || false;
+            dynamicTypeDetect && this.prepareDataForDynamicTypeCheck(field.reportFieldCd, {autoNormalizeSort});
+            if (
+                (!fieldMapConfig || (fieldMapConfig && fieldMapConfig.enabled)) &&
+                (!this.collectOnlyVisible || (this.collectOnlyVisible && field.visibleSwitch))
+            ) {
+                const isExtremum = this.extremumDataTypes.includes(field.reportFieldTypeLookup);
+                const config = {
+                    maxMapSize: this.maxMapSize,
+                    data: this.prepareData(isExtremum),
+                    clearMapAfterOverflow: this.clearMapAfterOverflow,
+                    isExtremum: isExtremum,
+                    isFull: false,
+                    isFalsyValues: false,
+                };
+                Ext.apply(config, fieldMapConfig);
+                this.maps.set(field.reportFieldCd, config);
+            }
+        });
+    },
+
+    /**
+     * Подготовка данных для анализа полей, все данные которого могут иметь динамический тип.
+     * @param originName - имя поля
+     */
+    prepareDataForDynamicTypeCheck(originName, config) {
+        this.dynamicTypeFields[originName] = {
+            originName: originName,
+            convertedFieldName: this.getDynamicTypeFieldName(originName),
+            data: [],
+            allValuesOneType: true,
+        };
+        Ext.apply(this.dynamicTypeFields[originName], config);
+    },
+
+    /**
+     * @param {boolean} isExtremum
+     * @returns {Map|Set}
+     */
+    prepareData(isExtremum) {
+        return isExtremum? new Map().set('min').set('max') : new Set();
+    },
+
+    /**
+     * Сброс данных
+     */
+    clearData() {
+        this.maps.forEach((map, fieldName) => {
+            map.data = this.prepareData(map.isExtremum);
+            map.isFull = false;
+            map.isFalsyValues = false;
+            map.dynamicTypeDetect && this.clearDynamicTypeField(fieldName);
+        });
+    },
+
+    /**
+     * Сброс данных дублирующего поля, хранящее информацию об анализе данных оригинального поля,
+     * у которого все данные могут иметь динамический тип.
+     * @param fieldName - имя оригинального поля, чьи данные будут анализироваться.
+     */
+    clearDynamicTypeField(fieldName) {
+        Object.keys(this.dynamicTypeFields).forEach((key) => {
+            this.dynamicTypeFields[key].data = [];
+            this.dynamicTypeFields[key].allValuesOneType = true;
+        });
+    },
+
+    /**
+     * Функция convert для дополнительного поля. Функция заполняет уникальные значения и вычисляет мин и макс.
+     */
+    getConvert() {
+        return function(_, record) {
+            this.maps.forEach((map, key) => {
+                const recordValue = record.get(key);
+
+                if (map.dynamicTypeDetect && this.dynamicTypeFields[key].allValuesOneType) {
+                    this.checkValueDynamicType(recordValue, key, record);
+                }
+
+                if ((map.data.size === map.maxMapSize) || map.isFull) {
+                    map.isFull = true;
+                    if (map.clearMapAfterOverflow) {
+                        map.data.clear();
+                    }
+                } else {
+                    if (recordValue === null || recordValue === undefined) {
+                        map.isFalsyValues = true;
+                    }
+                    if (map.isExtremum) {
+                        const min = map.data.get('min');
+                        const max = map.data.get('max');
+
+                        map.data.set('min', this.getExtremumValue(min, recordValue, Math.min));
+                        map.data.set('max', this.getExtremumValue(max, recordValue, Math.max));
+                    } else {
+                        map.data.add(recordValue);
+                    }
+                }
+            });
+        }.bind(this);
+    },
+
+    /**
+     * Имя дублирующего поля, хранящего информацию об оригинальном поле, данные которого могут иметь динамический тип.
+     * @param originName - имя оригинального поля, чьи данные будут анализироваться.
+     * @returns {string} - имя дублирующего поля, с результатом анализа данных.
+     */
+    getDynamicTypeFieldName(originName) {
+        return `_${originName}_convert`;
+    },
+
+    /**
+     * Возвращает поля, данные которого могут иметь динамический тип.
+     * @returns {*}
+     */
+    getDynamicTypeFields() {
+        return this.dynamicTypeFields;
+    },
+
+    /**
+     * Возвращает функцию sorterFn, нормализующую сортировку.
+     * Если у всех данных поля одинаковый тип, для сравнения импользуются значения после конвертации,
+     * в противном случае используются оригинальные значения.
+     * @param originalFieldName
+     * @returns {any}
+     */
+    getNormalizeSorterFn(originalFieldName) {
+        const convertedFieldName = this.dynamicTypeFields[originalFieldName].convertedFieldName;
+        return function(record1, record2) {
+            const allValuesOneType = this.dynamicTypeFields[originalFieldName].allValuesOneType;
+            const value1 = allValuesOneType ? record1.get(convertedFieldName) : record1.get(originalFieldName);
+            const value2 = allValuesOneType ? record2.get(convertedFieldName) : record2.get(originalFieldName);
+            return value1 > value2 ? 1 : (value1 === value2) ? 0 : -1;
+        }.bind(this);
+    },
+
+    /**
+     * Проверка данных поля, все данные которого могут иметь динамический тип.
+     * @param recordValue - значение поля
+     * @param colName - имя оригинального поля
+     * @param record
+     */
+    checkValueDynamicType(recordValue, colName, record) {
+        let convertedValue = recordValue;
+        if (typeof convertedValue === 'string') {
+            convertedValue = Ext.String.trim(convertedValue).replaceAll(',', '.');
+            convertedValue = Ext.Number.parseFloat(convertedValue);
+            if (convertedValue === null) {
+                this.dynamicTypeFields[colName].allValuesOneType = false;
+            } else {
+                this.dynamicTypeFields[colName].data.push(convertedValue || undefined);
+            }
+        }
+        const convertFieldName = this.getDynamicTypeFieldName(colName);
+        record.set(convertFieldName, (convertedValue || undefined));
+    },
+
+    /**
+     * Map всех словарей уникальных значений.
+     * Ключами являются идентификаторы полей.
+     * Значения - объекты вида:
+     * {
+     *      isExtremum - Если тип поля относится к extremumDataTypes
+     *      Если тип поля относится к extremumDataTypes (isExtremum=true), то в data содержатся минимальное и максимальное значения данных поля
+     *      ! Для данных типа Date содержится число (результат функции getTime)
+     *      data: {
+     *          min,
+     *          max
+     *      },
+     *      Иначе data содержит Set из уникальных значений данных по колонке
+     *      data: Set,
+     *      clearMapAfterOverflow - флаг очистки в случае переполнения
+     *      isFalsyValues признак присутствия в наборе значений поля null или undefined
+     *      isFull - признак достижения maxMapSize - максимального количества сохраненных уникальных значений
+     *      maxMapSize - максимального количества сохраненных уникальных значений
+     * }
+     * @returns {*} undefined | Map
+     */
+    getMaps() {
+        return this.maps;
+    },
+
+    getColumnData(reportFieldCd) {
+        if (!reportFieldCd) {
+            return false;
+        }
+        const fieldData = this.getMaps().get(reportFieldCd);
+        if (!fieldData) {
+            return false;
+        }
+        return fieldData;
+    },
+
+    getExtremum(reportFieldCd) {
+        return this.getColumnData(reportFieldCd) && this.getColumnData(reportFieldCd).isExtremum && this.getColumnData(reportFieldCd).data;
+    },
+
+    /**
+     * Валидация value для Math.min() или Math.max()
+     * @param value
+     * @returns {boolean}
+     */
+    validateExtremumValue(value) {
+        return (!isNaN(Number(value)) && (value !== null));
+    },
+
+    /**
+     * Получение минимального или максимального значения из двух
+     * @param a
+     * @param b
+     * @param mathFunc функция стравнения (Math.min | Math.max)
+     * @returns {undefined} одно из чисел или undefined если сравнение невозможно
+     */
+    getExtremumValue(a, b, mathFunc) {
+        let result;
+        const validateA = this.validateExtremumValue(a);
+        const validateB = this.validateExtremumValue(b);
+        if (validateA && validateB) {
+            result = mathFunc.call(this, a, b);
+        } else if (validateB) {
+            result = b;
+        } else if (validateA) {
+            result = a;
+        } else {
+            result = undefined;
+        }
+        return result;
+    },
+});

package/src/report/component/ReportPanel.js

@@ -20,6 +20,7 @@ Ext.define('Coon.report.component.ReportPanel', {
         'Coon.report.column.HintColumn',
         'Coon.report.component.reportpanel.ReportGrid',
         'Coon.report.component.reportpanel.FilterPanel',
+        'Coon.report.component.ReportFieldMap',
         'Coon.report.model.*',
         'Coon.report.model.CharacteristicBeanFields',
         'Coon.report.plugin.form.EnterConfirmFormPlugin',
@@ -56,6 +57,7 @@ Ext.define('Coon.report.component.ReportPanel', {
         enableAutoSize: true,
         enableSummaryFeature: false,
         enableGroupingFeature: false,
+        disableFieldMap: false,
         toggleFilterPanel: false,
         startCollapsed: false,
         enableTextSelection: false,
@@ -76,6 +78,10 @@ Ext.define('Coon.report.component.ReportPanel', {
     locals: {
         plugins: new Map(),
     },
+    /**
+     * @property {Coon.report.component.ReportFieldMap}
+     */
+    serviceMap: undefined,
 
     statics: {
         getColumnsConfig: function(reportBeanFields, gridConfig) {
@@ -353,7 +359,13 @@ Ext.define('Coon.report.component.ReportPanel', {
 
         this.layout = 'card';
 
-        this.northPanel = Ext.widget('NorthPanel', {
+        this._visibleFieldsMap = new Map();
+
+        // для совместимости со старым кодом.
+        this.dockedItems = [].concat(this.dockedItems || []);
+
+        this.dockedItems.push({
+            xtype: 'NorthPanel',
             hideFilterPanel: this.hideFilterPanel,
             hideFilterButtons: this.hideFilterButtons,
             findButtonConfig: this.findButtonConfig || {},
@@ -365,7 +377,23 @@ Ext.define('Coon.report.component.ReportPanel', {
             header: false,
         });
 
-        this._visibleFieldsMap = new Map();
+        this.items = [
+            Ext.apply(this.centerProperties, {
+                xtype: 'panel',
+                itemId: 'centerPanel',
+                region: 'center',
+                minHeight: 100,
+                layout: 'fit',
+                cls: 'buttonsCenterFilterPanel',
+            })
+        ];
+
+        this.callParent();
+
+        this.centerPanel = this.down('panel#centerPanel');
+        this.northPanel = this.down('NorthPanel');
+        this.filterContainer = this.northPanel.filterContainer;
+
         this.northPanel.on('hide', function() {
             this.query('[validate][isReportFilterField][hidden=false]').forEach((field) => {
                 this._visibleFieldsMap.set(field, field.hidden);
@@ -380,25 +408,6 @@ Ext.define('Coon.report.component.ReportPanel', {
             });
         }, this);
 
-        // для совместимости со старым кодом.
-        this.filterContainer = this.northPanel.filterContainer;
-        this.centerPanel = Ext.widget('panel', Ext.apply(this.centerProperties, {
-            region: 'center',
-            minHeight: 100,
-            layout: 'fit',
-            cls: 'buttonsCenterFilterPanel',
-        }));
-        this.dockedItems = [].concat(this.dockedItems || []);
-
-
-        this.dockedItems.push(this.northPanel);
-
-        this.items = [
-            this.centerPanel
-        ];
-
-        this.callParent();
-
         if (this.reportID) {
             this.reportId = this.reportID;
         }
@@ -758,7 +767,8 @@ Ext.define('Coon.report.component.ReportPanel', {
             return acc;
         }, new Map());
 
-        Ext.merge(this, Coon.Function.convertAdvancedProperties(reportFormBean[ns.$properties]));
+        const configProperties = Coon.Function.convertAdvancedProperties(reportFormBean[ns.$properties]);
+        Ext.merge(this, configProperties, {configProperties});
         if (this.getToggleFilterPanel() && !this.hideFilterPanel) {
             this.addTool({
                 iconCls: 'x-fa fa-eye-slash',
@@ -872,18 +882,34 @@ Ext.define('Coon.report.component.ReportPanel', {
             }
         }
     },
+
+    mixPlugins(gridPlugins, basicPlugins) {
+        const plugins = [];
+        basicPlugins.forEach((plugin) => {
+            const found = gridPlugins.find((item) => plugin.ptype === item.ptype);
+            if (!found) {
+                plugins.push(plugin);
+            }
+        });
+        plugins.push(...gridPlugins);
+        return plugins;
+    },
+
     createGrid: function(reportBean) {
         const ns = Coon.report.model.ReportBeanFields;
-        const plugins = Ext.Array.merge(
-            [{ptype: 'GridContextPlugin'},
-                {ptype: 'GridContextMenu'},
-                {ptype: 'gridexporter'}],
-            this.getPluginConfigByType(
-                'GRID_PLUGIN',
-                'p',
-                reportBean[ns.$plugins]
-            )
+        const gridPlugins = this.getPluginConfigByType(
+            'GRID_PLUGIN',
+            'p',
+            reportBean[ns.$plugins]
         );
+
+        const plugins = this.mixPlugins(gridPlugins, [
+            {ptype: 'GridContextPlugin'},
+            {ptype: 'GridContextMenu'},
+            {ptype: 'gridexporter'},
+            {ptype: 'AddFilterConditionPlugin'},
+            {ptype: 'CalculatorPlugin'}
+        ]);
         plugins.sort(this.raiseUpGroupButton);
 
         const gridConfig = {
@@ -914,29 +940,32 @@ Ext.define('Coon.report.component.ReportPanel', {
 
         const defaultGridConfig = Coon.report.component.ReportPanel.getColumnsConfig(reportBean[ns.$fields], gridConfig);
 
+        const fieldMapConfig = Coon.Function.convertAdvancedProperties(reportBean[ns.$properties]).fieldMapConfig || {};
+        if (!this.disableFieldMap && !fieldMapConfig.disabled) {
+            this.serviceMap = new Coon.report.component.ReportFieldMap({
+                maxMapSize: 100,
+                fields: reportBean.fields,
+                rawConfig: fieldMapConfig,
+            });
+            defaultGridConfig.fields.push({
+                convert: this.serviceMap.getConvert(),
+            });
+            this.northPanel.on('filterhandlerevent', this.serviceMap.clearData, this.serviceMap);
+        }
+
         const widget = Ext.widget(
             this.getIsTree() ? 'ReportTree' : 'ReportGrid',
             Ext.apply(defaultGridConfig, this.gridProperties, {reportId: reportBean[ns.$reportId]})
         );
 
         if (widget.contextMenu) {
-            const copyButton = new Ext.menu.Item({
-                text: 'Копировать',
-                handler: this.onCopyCellClick.bind(widget.contextMenu),
-            });
-            widget.contextMenu.add(copyButton);
-            widget.contextMenu.on('requestMenuItems', (params) => {
-                copyButton.setHidden(!params.td);
-            }, this);
+            const copyButton = Ext.widget('CopyCellValueMenuItem');
+            widget.contextMenu.addCopyButton(copyButton);
         }
         widget.on('buttonIsAdded', this.sortButtons, this);
         return widget;
     },
-    onCopyCellClick() {
-        if (this.context && this.context.td) {
-            Coon.util.copyToClipboard(this.context.td.innerText);
-        }
-    },
+
     sortButtons: function(params) {
         if (params.bar.items.length === 1) {
             return;

package/src/report/component/ReportPanel.scss

@@ -13,7 +13,7 @@
     background-color: #f6f6f6;
   }
 
-  .x-panel-header-default {
+  /*.x-panel-header-default {
     padding: 6px 16px;
     background-color: #f6f6f6;
     font-size: 17px;
@@ -21,7 +21,7 @@
       color: #3e4752;
     }
 
-  }
+  }*/
 
   .x-toolbar-default{
     background-color: #ffffff;

package/src/report/component/ReportTagLookup.js

@@ -43,10 +43,12 @@ Ext.define('Coon.report.component.ReportTagLookup', {
             // Количество страниц
             count: 0,
         },
+        autoSortDynamicData: false,
     },
 
     initComponent: function() {
         this.callParent();
+        this.autoSortDynamicData && this.prepareForNormalizedSortDynamicData();
         // clear trigger
         if (this.resettable) {
             this.setTriggers(Object.assign({
@@ -70,6 +72,32 @@ Ext.define('Coon.report.component.ReportTagLookup', {
         }
     },
 
+    /**
+     * Подготовка к автоматической нормализованнной сортировке данных,
+     * где displayField имеет динамический тип данных.
+     */
+    prepareForNormalizedSortDynamicData() {
+        this.serviceMap = Ext.create('Coon.report.component.ReportFieldMap', {
+            fields: [
+                {
+                    reportFieldCd: this.displayField,
+                    properties: {
+                        fieldMapConfig: {
+                            enabled: true,
+                            dynamicTypeDetect: true,
+                            autoNormalizeSort: true,
+                        },
+                    },
+                }
+            ],
+            clearMapAfterOverflow: false,
+            collectOnlyVisible: false,
+        });
+        this.getStore().getModel().addFields([{
+            convert: this.serviceMap.getConvert(),
+        }]);
+    },
+
     onClearInput: function() {
         this.resetPageControl();
         this.loadLocalPage(1);
@@ -218,18 +246,19 @@ Ext.define('Coon.report.component.ReportTagLookup', {
         data = this.checkDangerousAmount(data);
 
         // исходные данные для возможности фильтрации
-        this.initialData = data;
+        this.initialData = this.autoSortDynamicData ? this.getNormalizedSortedStoreData(data) : data;
         this.isLoaded = true;
 
         // размер данных больше одной страницы
         if (data.length > this.pageControl.pageSize) {
             this.isPagingEnabled = true;
-            this.unpagedData = data;
+            this.unpagedData = this.autoSortDynamicData ? this.getNormalizedSortedStoreData(data) : data;
             this.configurePagination();
             this.loadPage(1);
         } else {
             this.isPagingEnabled = false;
             this.store.loadData(data);
+            this.autoSortDynamicData && this.setStoreNormalizeSort();
         }
 
         this.store.fireEvent('load', this.store, this.store.getRange(), true);
@@ -243,6 +272,34 @@ Ext.define('Coon.report.component.ReportTagLookup', {
         }
     },
 
+    /**
+     * Возвращает данные Store после их нормализованной сортировки.
+     * @param data
+     * @returns {*}
+     */
+    getNormalizedSortedStoreData(data) {
+        this.store.loadData(data);
+        this.setStoreNormalizeSort();
+        return this.store.getData().items.map((item) => item.getData());
+    },
+
+    /**
+     * Применяет нормализованную сортировку к Store.
+     * Сортировка происходит относительно displayField, чьи данные могут иметь динамический тип.
+     */
+    setStoreNormalizeSort() {
+        const normalizedSortFields = this.serviceMap.getDynamicTypeFields();
+        if (!Ext.Object.isEmpty(normalizedSortFields)) {
+            const autoSortField = Object.values(normalizedSortFields).find((value) => value.autoNormalizeSort);
+            if (!autoSortField) {
+                return;
+            }
+            this.getStore().setSorters({
+                sorterFn: this.serviceMap.getNormalizeSorterFn(autoSortField.originName),
+            });
+        }
+    },
+
     setValue(value) {
         Coon.log.debug('setValue', value);
         if (value && Array.isArray(value) && value.length) {