ru.coon 2.8.65 → 3.0.2

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

@@ -0,0 +1,226 @@
+Ext.define('Coon.report.plugin.grid.addFilterConditionPlugin.AdvancedSearchPanelController', {
+    extend: 'Ext.app.ViewController',
+    alias: 'controller.AdvancedSearchPanelController',
+    mixins: ['Coon.report.plugin.grid.addFilterConditionPlugin.FilterConfigMixin'],
+
+    /**
+     * @param {Object} filters
+     * @param {Object} newFilterConfig
+     */
+    doInit(filters, newFilterConfig) {
+        if (!Ext.isObject(filters)) {
+            return;
+        }
+        // console.log('filters', filters);
+        this.filters = filters;
+        this.newFilterConfig = newFilterConfig;
+        this.cellValue = newFilterConfig.value;
+        this.createItems(this.createConfig());
+    },
+
+    createConfig() {
+        const currentColumnDataIndex = this.newFilterConfig.currentColumnDataIndex;
+        const currentFilter = Object.values(this.filters).find((conf) => conf.dataIndex === currentColumnDataIndex);
+        const activeFilters = Object.values(this.filters);
+
+        if (!currentFilter && currentColumnDataIndex && this.newFilterConfig.isCurrentColumnFilterable) {
+            const newFilterCfg = this.newFilterCfg(currentColumnDataIndex, true, this.newFilterConfig.useCombo);
+            this.filters[currentColumnDataIndex] = newFilterCfg;
+            activeFilters.push(newFilterCfg);
+        }
+
+        activeFilters.forEach((filter) => {
+            this.addFilterProperties(filter);
+        });
+
+        return activeFilters;
+    },
+
+    newFilterCfg(dataIndex, isCurrent, useCombo) {
+        const gridColumn = this.getGridColumn(dataIndex);
+        return {
+            isCurrent,
+            columnName: gridColumn.text,
+            columnGroup: gridColumn.columnGroup,
+            dataIndex,
+            type: gridColumn.filter || 'string',
+            operator: 'eq',
+            useCombo,
+        };
+    },
+
+    createItems(filters) {
+        this.clearItems();
+        if (!Array.isArray(filters)) {
+            return;
+        }
+
+        filters.forEach(function(filter) {
+            this.createItem(filter);
+        }, this);
+    },
+
+    createItem(filter) {
+        const comp = Ext.create({xtype: 'FilterItem', filter});
+        comp.on('fieldsadded', function(fields) {
+            fields.forEach(function(field) {
+                field.on('change', this.validateFilters, this);
+            }, this);
+        }, this);
+        this.getView().insert(0, comp);
+        this.getView().fireEvent('addremovefilter');
+        comp.on('beforedestroy', this.onRemoveFilter, this);
+        comp.on('destroy', this.validateFilters, this);
+    },
+
+    validateFilters() {
+        let isFiltersValid = true;
+        this.getView().items.each((item) => {
+            if ((!item.destroyed || !item.destroying) && !item.isValid()) {
+                isFiltersValid = false;
+            }
+        });
+        this.getViewModel().set('isFiltersValid', isFiltersValid);
+    },
+
+    clearItems() {
+        this.getView().removeAll();
+    },
+
+    onAddNewFilterClick() {
+        const panel = Ext.widget('SelectColumnPanel', {});
+        panel.on('selectColumn', this.addFilter, this);
+        Ext.widget('WindowWrap', {
+            maximizable: false,
+            resizable: false,
+            autoShow: true,
+            closeAction: 'close',
+            width: 600,
+            height: 720,
+            items: panel,
+        });
+        const filtersKeys = Object.keys(this.filters);
+        const filterAllVisible = this.getView().filterAllVisible;
+        const filterOptions = this.getView().filterOptions;
+        const reportColumns = this.getGridColumns().filter(function(el) {
+            return !filtersKeys.includes(el.dataIndex) && (filterAllVisible || filterOptions[el.dataIndex]);
+        }, this);
+        const treeData = this.getTreeData(reportColumns);
+        panel.getStore().setRoot(treeData);
+    },
+
+    getTreeData(data) {
+        data = Ext.clone(data);
+        const treeData = {
+            expanded: true,
+            children: [],
+        };
+        /**
+         * @param node
+         * @param {Array} groupHeader
+         */
+        const addTreeNode = function(node, groupHeader, column) {
+            const nodeText= groupHeader.shift();
+            let found = node.find((el) => el.text === nodeText);
+            if (!found) {
+                found = {
+                    text: nodeText,
+                    expanded: true,
+                    children: [],
+                    leaf: false,
+                };
+                node.push(found);
+            }
+            if (groupHeader.length) {
+                addTreeNode(found.children, groupHeader, column);
+            } else {
+                found.children.push({
+                    text: column.text,
+                    columnGroup: column.columnGroup,
+                    id: column.dataIndex,
+                    leaf: true,
+                });
+            }
+        };
+        data.forEach((column) => {
+            const groupHeader = column.groupHeader;
+            if (Array.isArray(groupHeader) && groupHeader.length) {
+                addTreeNode(treeData.children, groupHeader, column);
+            } else {
+                treeData.children.push({
+                    text: column.text,
+                    id: column.dataIndex,
+                    leaf: true,
+                });
+            }
+        });
+        return treeData;
+    },
+
+    closeHandler() {
+        this.getView().fireEvent('close');
+    },
+
+    filterHandler() {
+        this.applyHandler();
+        this.closeHandler();
+    },
+
+    applyHandler() {
+        this.fireFilterConfig();
+    },
+
+    fireFilterConfig() {
+        const filters = this.getFilters().map((rec) => {
+            return {
+                dataIndex: rec.dataIndex,
+                operator: rec.type === 'list' ? 'in': rec.operator,
+                value: rec.operator === 'between' ?
+                    [rec.fromValue, rec.toValue].map(this.prepareValue):
+                    this.prepareValue(rec.fromValue),
+            };
+        });
+        this.getView().fireEvent('addfilters', filters);
+    },
+
+    getFilters() {
+        const filters = [];
+        this.getView().items.each(function(filterPanel) {
+            const filter = filterPanel.getFilter();
+            filters.push(filter);
+        });
+
+        return filters;
+    },
+
+    /**
+     * Удалили панель фильтрации
+     * @param {Coon.report.plugin.grid.addFilterConditionPlugin.FilterItem} filterPanel
+     */
+    onRemoveFilter: function(filterPanel) {
+        Coon.log.debug('onRemoveFilter', filterPanel);
+        const filter = filterPanel.getViewModel().get('filter');
+        const dataIndex = filter.dataIndex;
+        delete this.filters[dataIndex];
+        this.getView().fireEvent('addremovefilter');
+    },
+
+    addFilter(recordData) {
+        Coon.log.debug('addFilter', recordData);
+        const dataIndex = recordData.dataIndex;
+        if (dataIndex) {
+            const filter = this.newFilterCfg(dataIndex);
+            this.addFilterProperties(filter);
+            Coon.log.debug('newFilterData', filter);
+            this.filters[dataIndex] = filter;
+            this.createItem(filter);
+        }
+    },
+
+    isCurrent(dataIndex) {
+        const found = Object.values(this.filters).find((filter) => {
+            return filter.dataIndex === dataIndex && filter.isCurrent;
+        });
+        return !!found;
+    },
+});

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

@@ -0,0 +1,138 @@
+Ext.define('Coon.report.plugin.grid.addFilterConditionPlugin.FilterConfigMixin', {
+
+    addFilterProperties(filter) {
+        const isCurrent = this.isCurrent(filter.dataIndex);
+        const defaultFilterValueConfig = this.getDefaultFilterValue(filter, isCurrent);
+        if (Array.isArray(filter.value) && filter.operator==='between') {
+            const betweenValues = filter.value;
+            filter.fromValue = betweenValues[0];
+            filter.toValue = betweenValues[1];
+        } else {
+            filter.fromValue = Ext.isEmpty(filter.value) && filter.operator !== 'notfilled' ? defaultFilterValueConfig.value: filter.value;
+            filter.toValue = undefined;
+        }
+        const columnConf = this.report.serviceMap.getColumnData(filter.dataIndex);
+
+        const column = this.getGridColumn(filter.dataIndex);
+        filter.columnName = column.text;
+        filter.columnGroup = column.columnGroup;
+        if (columnConf) {
+            if (filter.type==='list' || (filter.type==='string' && filter.useCombo)) {
+                const uniqSet = columnConf ? columnConf.data: [];
+                const listData = [...uniqSet].filter((value) => !Ext.isEmpty(value)).map((value) => ({
+                    value,
+                }));
+                Ext.apply(filter, {listData});
+            }
+            Ext.apply(filter, this.getExtremum(filter.type, columnConf));
+        }
+        if (filter.type==='boolean') {
+            const booleanLabels = column && column.booleanLabels;
+            if (booleanLabels) {
+                Ext.apply(filter, {booleanLabels});
+            }
+        }
+    },
+
+    defaultOperator: {
+        string: 'eq',
+        numeric: 'eq',
+        date: 'eq',
+        boolean: 'eq',
+        list: 'in',
+    },
+    /**
+     * Значение по умолчанию для фильтра
+     * @param {string} filter - тип фильтра
+     * @param {boolean} isByCellClicked - был клик по конкретной колонке
+     */
+    getDefaultFilterValue(filter, isByCellClicked) {
+        let value;
+        const columnConf = this.report.serviceMap.getColumnData(filter.dataIndex);
+        const extremum = this.getExtremum(filter.type, columnConf);
+        const extremumValue = isByCellClicked ? this.cellValue: extremum && extremum.minValue;
+
+        switch (filter.type) {
+        case 'boolean':
+            value = Ext.isBoolean(this.cellValue) ? this.cellValue: true;
+            break;
+        case 'list':
+            value = [this.cellValue];
+            break;
+        case 'numeric':
+        case 'date':
+            value = extremumValue;
+            break;
+        case 'string':
+            value = isByCellClicked ? this.cellValue: undefined;
+            break;
+        }
+        return {
+            value,
+            operator: Ext.isEmpty(value) ? 'notfilled': this.defaultOperator[filter.type],
+        };
+    },
+
+    getGridColumns() {
+        if (!this.gridColumns) {
+            this.gridColumns = this.getView().reportGrid.getVisibleColumns()
+                .filter((column) => column.dataIndex /* && !column.isXType('checkcolumn')*/)
+                .map((column) => {
+                    const isBooleancolumn = column.isXType('booleancolumn');
+                    const groupHeader = Ext.isString(column.columnGroup) && Ext.util.Format.stripTags(column.columnGroup).split(';');
+                    return {
+                        groupHeader: groupHeader,
+                        columnGroup: column.columnGroup,
+                        dataIndex: column.dataIndex,
+                        text: this.prepareText(column.text) || column.dataIndex,
+                        filter: column.filter.type,
+                        booleanLabels: isBooleancolumn ? {trueText: column.trueText, falseText: column.falseText} :{},
+                    };
+                });
+        }
+        return this.gridColumns;
+    },
+
+    getGridColumn(dataIndex) {
+        if (!dataIndex) {
+            return false;
+        }
+        return this.getGridColumns().find((column) => column.dataIndex === dataIndex);
+    },
+
+    prepareText(str) {
+        if (!Ext.isString(str)) {
+            return str;
+        }
+        const replaced = str.replace(/<br\s*\/?>/gi, ' ');
+        return Ext.util.Format.stripTags(replaced);
+    },
+
+    getExtremum(filterType, columnConf) {
+        if (Ext.isObject(columnConf) && columnConf.isExtremum) {
+            if (filterType==='date') {
+                const format = Coon.format.date;
+                const minValue = columnConf.data.get('min'); // milliseconds
+                const maxValue = columnConf.data.get('max'); // milliseconds
+                return {
+                    minValue: new Date(minValue),
+                    minValueText: Ext.Date.format(new Date(minValue), format),
+                    maxValue: new Date(maxValue),
+                    maxValueText: Ext.Date.format(new Date(maxValue), format),
+                };
+            } else {
+                return {
+                    minValue: columnConf.data.get('min'),
+                    maxValue: columnConf.data.get('max'),
+                };
+            }
+        } else {
+            return {};
+        }
+    },
+
+    prepareValue(value) {
+        const checkIsDate = Ext.Date.parse(value, Coon.format.dateTimeInternal);
+        return checkIsDate ? checkIsDate: value;
+    },
+});

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

@@ -0,0 +1,223 @@
+Ext.define('Coon.report.plugin.grid.addFilterConditionPlugin.FilterFieldFactory', {
+
+    getFields(type, options) {
+        if (!Ext.isObject(options)) {
+            options = {};
+        }
+        switch (type) {
+        case 'string':
+            return this.getStringFields(options);
+        case 'date':
+            return this.getDateFields();
+        case 'boolean':
+            return this.getBooleanFields(options.booleanLabels);
+        case 'numeric':
+            return this.getNumericFields();
+        case 'list':
+            return this.getListFields(options.listData);
+        }
+    },
+
+    getListFields(data) {
+        return Ext.create({
+            xtype: 'tagfield',
+            cls: 'simple-report-tag',
+            // growMax: 150,
+            grow: false,
+            fieldLabel: 'Значение',
+            displayField: 'value',
+            valueField: 'value',
+            // filterPickList: true,
+            queryMode: 'local',
+            store: {
+                fields: ['value'],
+                data,
+            },
+            bind: {
+                value: '{filter.fromValue}',
+            },
+            triggers: {
+                clear: Ext.apply({}, {weight: -1}, this.getClearTrigger()),
+            },
+            listeners: {
+                change: (field, value) => {
+                    if (Array.isArray(value) && !value.length) {
+                        value = false;
+                    }
+                    field.triggers.clear.setHidden(!value);
+                },
+                beforequery: (e) => {
+                    e.forceAll = false;
+                    const len = e.query.length;
+                    e.query = new RegExp('.*' + Ext.String.escapeRegex(e.query) + '.*', 'i');
+                    e.query.length = len;
+                    return true;
+                },
+            },
+        });
+    },
+    getBooleanFields(labels) {
+        labels = labels || {};
+        return {
+            xtype: 'container',
+            items: {
+                xtype: 'radiogroup',
+                layout: {
+                    type: 'hbox',
+                },
+                simpleValue: true,
+                items: [
+                    {boxLabel: labels.trueText || 'Да', name: 'condition', inputValue: true},
+                    {boxLabel: labels.falseText || 'Нет', name: 'condition', inputValue: false, margin: '0 0 0 15'}
+                ],
+                bind: {
+                    value: '{filter.fromValue}',
+                },
+            },
+            maxWidth: 550,
+        };
+    },
+    getNumericFields() {
+        const numberDefaultConfig = {
+            xtype: 'numberfield',
+            fieldLabel: 'Значение ',
+            allowDecimals: true,
+            hideTrigger: true,
+            decimalSeparator: Coon.Function.getDecimalSeparator(),
+            triggers: {
+                clear: this.getClearTrigger(),
+            },
+            listeners: {
+                change: (field, value) => {
+                    let hide = true;
+                    if (Ext.isNumber(value)) {
+                        hide = false;
+                    }
+                    field.triggers.clear.setHidden(hide);
+                },
+            },
+        };
+        return [
+            Ext.apply({}, {
+                bind: {
+                    fieldLabel: 'мин. {filter.minValue}',
+                    value: '{filter.fromValue}',
+                    minValue: '{filter.minValue}',
+                },
+            }, numberDefaultConfig),
+            Ext.apply({}, {
+                bind: {
+                    fieldLabel: 'макс. {filter.maxValue}',
+                    value: '{filter.toValue}',
+                    maxValue: '{filter.maxValue}',
+                    disabled: '{valueToDisabled}',
+                },
+            }, numberDefaultConfig)
+        ];
+    },
+    getStringFields(options) {
+        if (options.useCombo) {
+            return [Ext.create({
+                xtype: 'BaseComboBox',
+                flex: 1,
+                fieldLabel: 'Значение',
+                forceSelection: true,
+                bind: {
+                    value: '{filter.fromValue}',
+                },
+                triggers: {
+                    clear: Ext.apply({}, {weight: -1}, this.getClearTrigger()),
+                },
+                displayField: 'value',
+                valueField: 'value',
+                listeners: {
+                    change: (field, value) => {
+                        field.triggers.clear.setHidden(!value);
+                    },
+                    beforequery: (e) => {
+                        e.forceAll = false;
+                        const len = e.query.length;
+                        e.query = new RegExp('.*' + Ext.String.escapeRegex(e.query) + '.*', 'i');
+                        e.query.length = len;
+                        return true;
+                    },
+                },
+                store: {
+                    fields: ['value'],
+                    data: options.listData,
+                },
+            })];
+        } else {
+            const stringDefaultConfig = {
+                xtype: 'textfield',
+                reference: 'filterValueField',
+                fieldLabel: 'Значение',
+                flex: 1,
+                triggers: {
+                    clear: this.getClearTrigger(),
+                },
+                listeners: {
+                    change: (field, value) => {
+                        field.triggers.clear.setHidden(!value);
+                    },
+                },
+                formatText: '',
+                bind: {
+                    fieldLabel: 'Значение',
+                    value: '{filter.fromValue}',
+                    disabled: '{notfilledDisabled}',
+                },
+            };
+
+            return [stringDefaultConfig];
+        }
+    },
+    getDateFields() {
+        const dateDefaultConfig = {
+            xtype: 'datefield',
+            fieldLabel: 'Дата',
+            triggers: {
+                clear: Ext.apply({}, {weight: -1}, this.getClearTrigger()),
+            },
+            listeners: {
+                change: (field, value) => {
+                    field.triggers.clear.setHidden(!value);
+                },
+            },
+            formatText: '',
+        };
+        return [
+            Ext.apply({}, {
+                fieldLabel: 'От',
+                bind: {
+                    fieldLabel: 'От (мин. {filter.minValueText})',
+                    value: '{filter.fromValue}',
+                    maxValue: '{filter.maxValue}',
+                    minValue: '{filter.minValue}',
+                },
+            }, dateDefaultConfig),
+            Ext.apply({}, {
+                fieldLabel: 'До',
+                bind: {
+                    fieldLabel: 'До (макс. {filter.maxValueText})',
+                    value: '{filter.toValue}',
+                    maxValue: '{filter.maxValue}',
+                    minValue: '{filter.minValue}',
+                    disabled: '{valueToDisabled}',
+                },
+            }, dateDefaultConfig)
+        ];
+    },
+
+    getClearTrigger() {
+        return {
+            cls: 'svg-icon svg-icon-cancel-small',
+            tooltip: 'Очистить поле',
+            hidden: true,
+            hideOnReadOnly: true,
+            handler: function() {
+                this.setValue(null);
+            },
+        };
+    },
+});