ru.coon 2.6.8 → 2.6.9

package/src/uielement/component/UiCPVisualEditor.scss

@@ -0,0 +1,108 @@
+.UiCPVisualEditor {
+  .x-grid-cell-inner .x-btn {
+    padding: 0;
+  }
+
+  .widget-box {
+    border: 2px solid #e0e0e0;
+    margin: 10px 20px;
+    padding: 7px;
+    border-radius: 10px;
+  }
+
+  /*-------------*/
+  .borders {
+    margin: 0 3px 15px 3px !important;
+    box-shadow: 0 1px 6px 0 rgba(86, 112, 163, 0.2);
+  }
+
+  .borders > .x-panel-bodyWrap > .x-panel-body {
+    border: 1px solid #e0e0e0 !important;
+    border-radius: 0 0 5px 5px;
+    margin-top: -1px;
+  }
+
+  .no-header-panel .x-panel-bodyWrap > .x-panel-body {
+    border: 1px solid #e0e0e0 !important;
+    border-radius: 5px;
+    margin-top: 0;
+  }
+
+  .borders .x-panel-header {
+    border-radius: 5px 5px 0 0;
+    height: auto;
+  }
+
+  .draggable-element {
+    width: 100px;
+    height: 100px;
+    background-color: #e0e0e0;
+  }
+
+
+  .btn i {
+    color: #FFF;
+    font-style: normal;
+  }
+
+
+  .icon {
+    font-size: 18px;
+    display: block;
+    text-align: center;
+    margin-top: 6px;
+  }
+
+
+  .btn {
+    &:hover {
+      background-color: rgba(61, 103, 128, 1) !important;
+    }
+
+    width: 30px;
+    height: 30px;
+    background-color: rgba(61, 103, 128, 0.7);
+    border-radius: 18px;
+    cursor: pointer;
+    z-index: 999;
+  }
+
+  .center-btn {
+    position: absolute;
+    left: 50%;
+    top: 50%;
+    margin: -12px 0 0 -11px;
+  }
+
+  .right-top-btn {
+    position: absolute;
+    right: 0;
+    top: 0;
+    margin: 1px 0 0 0;
+  }
+
+  .hidden-btn {
+    display: none !important;
+  }
+
+  .borders-default {
+    border: 1px solid black;
+  }
+
+  .hover-item {
+    border: 1px solid red;
+  }
+
+  .tree-container .x-panel-body{
+    background-color: #f0f0f0;
+  }
+}
+
+.menu-tip .x-tool-close {
+  background-color: #111111 !important;
+}
+
+.svg-icon-tool {
+  background-color: white !important;
+}
+

package/src/uielement/component/UiCPVisualEditorConfigWindow.js

@@ -0,0 +1,303 @@
+Ext.define('Coon.uielement.component.UiCPVisualEditorConfigWindow', {
+    extend: 'Ext.window.Window',
+    cls: 'UiCPVisualEditorConfigWindow',
+    alias: 'widget.UiCPVisualEditorConfigWindow',
+    xtype: 'UiCPVisualEditorConfigWindow',
+    title: 'Настройки компонента',
+    width: 500,
+    height: '80%',
+    layout: 'fit',
+    closeAction: 'destroy',
+    requires: [
+        'Coon.uielement.component.settings.UiAceEditor'
+    ],
+    controller: {
+        parentCfgLocalState: {},
+
+        init: function(view) {
+            this.initParentCfgLocalState();
+            this.loadGrid();
+        },
+        initParentCfgLocalState: function() {
+            const view = this.getView();
+            view.parentPanel.successUserEditingOptions.map((option) => {
+                const valueObj = this.getOptionValue(option);
+                const value = Object.keys(valueObj).length ? valueObj[Object.keys(valueObj)[0]] : null;
+                if (value !== null && typeof value === 'object') {
+                    if (typeof this.parentCfgLocalState[Object.keys(valueObj)[0]] !== 'object') {
+                        this.parentCfgLocalState[Object.keys(valueObj)[0]] = {};
+                    }
+                    Ext.apply(this.parentCfgLocalState[Object.keys(valueObj)[0]], value);
+                } else {
+                    if (value !== '' && value !== null && typeof value !== 'undefined') {
+                        Ext.apply(this.parentCfgLocalState, valueObj);
+                    }
+                }
+            });
+            Ext.applyIf(this.parentCfgLocalState, view.parentPanel.cmpParams);
+            delete this.parentCfgLocalState['dataId'];
+        },
+        loadGrid: function() {
+            const view = this.getView();
+            view.down('grid').getStore().loadData(view.parentPanel.successUserEditingOptions.map((option) => {
+                return Ext.apply({
+                    'id': option.name,
+                    'group': option.group || '',
+                    'description': option.description,
+                    'type': option.type,
+                    'options': this.getOptions(option),
+                }, this.getOptionValue(option, true));
+            }));
+        },
+        findDefaultOptionName: function(group) {
+            if (!group) {
+                return '';
+            }
+            const defaultOption = this.getView().parentPanel.successUserEditingOptions.find((item) => {
+                if (item.group === 'group' && item.defaultOption === true) {
+                    return item;
+                }
+            });
+            return defaultOption ? defaultOption.name : false;
+        },
+        getOptionValue: function(option, local) {
+            const objCfg = local ? this.parentCfgLocalState : this.getView().parentPanel;
+            const returnVariable = local ? 'value' : option.name;
+            const returningObj = {};
+            let value = null;
+            let isGroupOption = false;
+            if (typeof option.group !== 'undefined' && option.group) {
+                isGroupOption = true;
+                if (typeof objCfg[option.group] === 'undefined') {
+                    return {};
+                }
+                if (typeof objCfg[option.group][option.name] !== 'undefined') {
+                    value = objCfg[option.group][option.name];
+                } else {
+                    if (option.name === this.findDefaultOptionName(option.group)) {
+                        value = objCfg[option.group];
+                    } else {
+                        return {};
+                    }
+                }
+            } else {
+                if (typeof objCfg[option.name] === 'undefined') {
+                    return {};
+                }
+                value = objCfg[option.name];
+            }
+            switch (option.type) {
+            case 'int':
+            case 'integer':
+                returningObj[returnVariable] = Math.round(value) || null;
+                break;
+            case 'number':
+            case 'float':
+                returningObj[returnVariable] = Number(value) || null;
+                break;
+            case 'combo':
+                returningObj[returnVariable] = value || null;
+                break;
+            default:
+                returningObj[returnVariable] = value;
+            }
+            if (isGroupOption && !local) {
+                const tmpObj = {};
+                tmpObj[option.group] = returningObj;
+                return tmpObj;
+            }
+            return returningObj;
+        },
+        getOptions: function(option) {
+            if (option.type === 'bool') {
+                return ['true', 'false'];
+            }
+            if (option.options && option.options.length) {
+                return option.options;
+            }
+            return [];
+        },
+        onClose: function() {
+            this.getView().close();
+        },
+        applyGridChanges: function() {
+            this.getView().down('grid').getStore().getModifiedRecords().map((record) => {
+                const value = record.get('value');
+                const key = record.get('id');
+                const group = record.get('group');
+                if (value === null || value === '' || typeof value === 'undefined') {
+                    if (group) {
+                        if (typeof this.parentCfgLocalState[group][key] !== 'undefined') {
+                            delete this.parentCfgLocalState[group][key];
+                        }
+                    } else {
+                        if (typeof this.parentCfgLocalState[key] !== 'undefined') {
+                            delete this.parentCfgLocalState[key];
+                        }
+                    }
+                } else {
+                    if (group) {
+                        this.parentCfgLocalState[group][key] = value;
+                    } else {
+                        this.parentCfgLocalState[key] = value;
+                    }
+                }
+            });
+        },
+        applyEditorChanges: function() {
+            const aceEditor = this.getView().down('UiAceEditor');
+            const value = aceEditor.getValue();
+            if (aceEditor.hasErrors()) {
+                Ext.Msg.alert('Ошибка', 'В редакторе присутствуют ошибки.');
+                return false;
+            }
+            if (!this.valueIsValidJson(value)) {
+                Ext.Msg.alert('Ошибка', 'Не корректный JSON объект');
+                return false;
+            }
+            this.parentCfgLocalState = this.getValueJson(value);
+            return true;
+        },
+        getValueJson: function(str) {
+            try {
+                return JSON5.parse(str);
+            } catch (e) {
+                return str;
+            }
+        },
+        valueIsValidJson: function(str) {
+            try {
+                return JSON5.parse(str);
+            } catch (e) {
+                return false;
+            }
+        },
+        onApply: function() {
+            const view = this.getView();
+            const tab = this.getView().down('tabpanel').getActiveTab();
+            if (tab.xtype === 'UiAceEditor') {
+                if (!this.applyEditorChanges()) {
+                    return false;
+                }
+            } else {
+                this.applyGridChanges();
+            }
+            view.parentPanel.cmpParams = {'dataId': view.parentPanel.cmpParams['dataId']};
+            Ext.apply(view.parentPanel.cmpParams, this.parentCfgLocalState);
+            view.parentController.reloadView();
+            view.close();
+        },
+        onBeforeTabChange: function(tabPanel, newCard, oldCard, eOpts) {
+            if (newCard.xtype !== 'UiAceEditor') {
+                const aceEditor = tabPanel.down('UiAceEditor');
+                const value = aceEditor.getValue();
+                if (aceEditor.hasErrors()) {
+                    Ext.Msg.alert('Ошибка', 'В редакторе присутствуют ошибки.');
+                    return false;
+                }
+                if (!this.valueIsValidJson(value)) {
+                    Ext.Msg.alert('Ошибка', 'Не корректный JSON объект');
+                    return false;
+                }
+            }
+        },
+        onTabChange: function(panel, tab) {
+            if (tab.xtype === 'UiAceEditor') {
+                this.applyGridChanges();
+                tab.setValue(JSON.stringify(this.parentCfgLocalState, null, 2));
+            } else {
+                this.applyEditorChanges();
+                this.loadGrid();
+            }
+        },
+    },
+    items: [
+        {
+            xtype: 'tabpanel',
+            listeners: {
+                'tabchange': 'onTabChange',
+                'beforetabchange': 'onBeforeTabChange',
+            },
+            items: [
+                {
+                    xtype: 'grid',
+                    title: 'Таблица',
+                    store: {
+                        fields: ['id', 'description', 'type', 'options', 'value', 'group'],
+                        groupField: 'group',
+                        data: [],
+                    },
+                    features: [{ftype: 'grouping', groupHeaderTpl: '{name}', collapsible: false}],
+                    columns: [
+                        {dataIndex: 'description', text: 'Наименование', flex: 1, filter: {type: 'string'}},
+                        {
+                            dataIndex: 'value', text: 'Значение', flex: 1, getEditor: function(record) {
+                                switch (record.get('type')) {
+                                case 'bool':
+                                case 'boolean':
+                                    return Ext.create('Ext.grid.CellEditor', {
+                                        field: Ext.create('Ext.form.field.ComboBox', {
+                                            forceSelection: true,
+                                            store: [[true, 'true'], [false, 'false']],
+                                        }),
+                                    });
+                                    break;
+                                case 'int':
+                                case 'integer':
+                                    return Ext.create('Ext.grid.CellEditor', {
+                                        field: Ext.create('Ext.form.field.Number', {
+                                            allowDecimals: false,
+                                            minValue: 0,
+                                        }),
+                                    });
+                                    break;
+                                case 'number':
+                                case 'float':
+                                    return Ext.create('Ext.grid.CellEditor', {
+                                        field: Ext.create('Ext.form.field.Number', {
+                                            allowDecimals: true,
+                                            minValue: 0,
+                                        }),
+                                    });
+                                    break;
+                                case 'text':
+                                case 'string':
+                                    return Ext.create('Ext.grid.CellEditor', {
+                                        field: Ext.create('Ext.form.field.Text', {}),
+                                    });
+                                    break;
+                                case 'combo':
+                                    return Ext.create('Ext.grid.CellEditor', {
+                                        field: Ext.create('Ext.form.field.ComboBox', {
+                                            forceSelection: true,
+                                            store: record.get('options').map((option) => {
+                                                return [option, option];
+                                            }),
+                                        }),
+                                    });
+                                    break;
+                                }
+                            },
+                        }
+                    ],
+                    plugins: {
+                        cellediting: {
+                            clicksToEdit: 2,
+                        },
+                    },
+                },
+                {
+                    xtype: 'UiAceEditor',
+                    flex: true,
+                    scrollable: 'y',
+                    title: 'PRO',
+                }
+            ],
+        }
+
+    ],
+    buttons: [
+        {text: 'Применить', handler: 'onApply'},
+        {text: 'Отмена', handler: 'onClose'}
+    ],
+});

package/src/version.js

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

package/src/report/plugin/grid/ExportReportDataToFilePlugin.md

@@ -1,7 +0,0 @@
-**спецификация:**
-
-входные параметры:
-
-- exportFileFormat [xls/pdf]
-- allowUserSelectColumnsToUpload
-- addToSearchButton добавить в кнопку "поиск", в этом случае в качестве параметра отправляем текущие параметры из FilterPanel(useRawFilterParams: true)