ru.coon 2.6.6 → 2.6.7

package/CHANGELOG.md

@@ -1,3 +1,13 @@
+# Version 2.6.7, [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/6802942bc71e923767f61cfc703ea6385d7f932e)
+* ## Features
+* <span style='color:green'>feat: HT-8060: if we have grid AutoSize option true and have saved grid columns config set it in false</span> ([2c6e2d], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/2c6e2d28a88cfbd383ea963e35cd7289e8412c49))
+
+* ## Fixes
+* <span style='color:red'> HT-7489 убрана лишняя зависимость mode-sql</span> ([f8ae6d], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/f8ae6d20e8285ddeaaa9063f1e9f5524ed0832d5))
+
+* BFL-11343 fix: creating SpecificPluginConfig widget ([f9a765], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/f9a765b241ac2b44d0e12a4cc1c10acff765c4e7))
+* update: CHANGELOG.md ([1ab75d], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/1ab75dc59921e43812349bf8bf38432c35d62fc1))
+
 # Version 2.6.6, [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/5a18af0bcc182d756427e1fd5e522dab51f5f6ca)
 * ## Features
 * <span style='color:green'>feat: HT-8006: Create cancel button, add search plugin by name form combo, change field labels</span> ([7dc802], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/7dc8027771536eb1fcffd9d3f59a362699abf5c6))
@@ -433,6 +443,7 @@ fix ExecuteCommandPlugin - remove reject on failure if command hasnt erorHandler
 # Version 2.5.26, [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/da7767ea8d5507d8b2081aeaf13f46c21010f0d2)
 * ## Features
 * <span style='color:green'>feat: BFL-8383 механизм сравнения конфигураций кастомных панелей</span> ([ced608], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/ced608b24610366e2fac65f7a9b546d31b6b34b8))
+* <span style='color:green'>feat: TR-66759: create form editor</span> ([94e9ab], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/94e9ab0ca454e8835d36dcc88612702c74bad84d))
 * <span style='color:green'>feat: HT-6956 add SQL beautifier</span> ([c8e391], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/c8e391e07989f4e04dc5229ba8a1671ea84f9027))
 * <span style='color:green'>feat: TR-67310 исправление ситуации когда defaultFocus на поле в состоянии disabled приводит к возврату фокуса на предыдущий элемент</span> ([335b93], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/335b9374874e2406e6f5c80daada6ba49eef05dc))
 

package/index.js

@@ -17,7 +17,6 @@ import 'ace-builds/src-noconflict/theme-xcode';
 import 'ace-builds/src-noconflict/theme-iplastic';
 import 'ace-builds/src-noconflict/ext-searchbox';
 import 'ace-builds/src-noconflict/mode-javascript';
-import 'ace-builds/src-noconflict/mode-sql';
 import 'ace-builds/src-noconflict/mode-pgsql';
 import 'ace-builds/src-noconflict/snippets/javascript';
 import 'ace-builds/src-noconflict/snippets/sql';

package/package.json

@@ -4,7 +4,7 @@
     "name": "ru.coon"
   },
   "description": "",
-  "version": "2.6.6",
+  "version": "2.6.7",
   "repository": {
     "type": "git",
     "url": "git+http://gitlab-dbr.sigma-it.local/dbr/ru.coon"

package/src/Function.js

@@ -126,7 +126,7 @@ Ext.define('Coon.Function', {
      */
     getDataFromForm: function(formPanel, valuesAsIs, dateFormat, excludeReadOnly, excludeDisabled) {
         let fields = formPanel.query('field');
-        fields = (fields || []).concat(formPanel.query('fieldcontainer'));
+        fields = (fields || []).concat(formPanel.query('fieldcontainer')).concat(formPanel.query('UiCFSegmentedButton'));
         const params = {};
         for (let i = 0; i < fields.length; i++) {
             const field = fields[i];

package/src/common/component/formeditor/UiCFCard.js

@@ -0,0 +1,86 @@
+/* global Ext */
+Ext.define('Coon.common.component.formeditor.UiCFCard', {
+    extend: 'Ext.panel.Panel',
+    xtype: 'UiCFCard',
+    layout: 'card',
+    bind: {
+        activeItem: '{activeItem}',
+    },
+    viewModel: {
+        data: {
+            activeItem: 0,
+        },
+    },
+    controller: {
+        init(view) {
+            if (view.initialConfig && !view.initialConfig.checkOptions) {
+                if (view.initialConfig && view.initialConfig.countCards) {
+                    view.initialConfig.countCards.forEach((setting, index) => {
+                        let item = view.items.getAt(view.items.findIndex('itemId', setting.itemId));
+                        if (!item) {
+                            item = view.add({
+                                xtype: 'panel',
+                                layout: 'fit',
+                                itemId: setting.itemId,
+                                items: [{xtype: 'UiCFContainer'}],
+                            });
+                        }
+                        if (setting.title) {
+                            item.setTitle(setting.title);
+                        }
+                    });
+                    if (view.initialConfig.countCards.length < view.items.getCount()) {
+                        const ids = view.initialConfig.countCards.map((item) => item.itemId);
+                        view.items.items.forEach((item) => {
+                            if (ids.indexOf(item.itemId) < 0) {
+                                view.remove(item);
+                            }
+                        });
+                    }
+                } else {
+                    const itemId = 'UiCFCard_' + Ext.id().replace('-', '_');
+                    view.value = view.countCards = [
+                        {
+                            'title': '',
+                            'itemId': itemId,
+                        }
+                    ],
+                    view.add({
+                        xtype: 'panel',
+                        layout: 'fit',
+                        itemId: itemId,
+                        items: [{xtype: 'UiCFContainer'}],
+                    });
+                }
+                const vm = this.getViewModel();
+                vm.bind('{activeItem}', (activeItem) => {
+                    this.lookup('backButton').setVisible(view.items.getCount() > 1 && Number(activeItem) > 0);
+                    this.lookup('forwardButton').setVisible(view.items.getCount() > 1 && Number(activeItem) < view.items.items.length - 1);
+                }, this);
+            }
+        },
+        back() {
+            const vm = this.getViewModel();
+            this.getViewModel().set('activeItem', Number(vm.get('activeItem'))-1);
+        },
+        forward() {
+            const vm = this.getViewModel();
+            if (Coon.Function.validateAllFieldsOnForm(this.getView().items.getAt(Number(vm.get('activeItem'))))) {
+                this.getViewModel().set('activeItem', Number(vm.get('activeItem'))+1);
+            } else {
+                Ext.Msg.show({
+                    title: 'Ошибка',
+                    message: 'Проверьте корректность заполнения полей формы',
+                    icon: Ext.Msg.ERROR,
+                    buttons: Ext.Msg.OK,
+                });
+            }
+        },
+    },
+    minHeight: 100,
+    buttons: [
+        {text: 'Назад', reference: 'backButton', handler: 'back'},
+        {text: 'Вперед', reference: 'forwardButton', handler: 'forward'}
+    ],
+    items: [],
+});

package/src/common/component/formeditor/UiCFCardsGrid.js

@@ -0,0 +1,69 @@
+/* global Ext */
+Ext.define('Coon.common.component.formeditor.UiCFCardsGrid', {
+    extend: 'Ext.grid.Panel',
+    xtype: 'UiCFCardsGrid',
+    flex: 1,
+    title: 'Элементы компонента',
+    minHeight: 100,
+    controller: {
+        init(view) {
+            const vm = this.getViewModel();
+            vm.getStore('cardsStore').on('datachanged', (store) => {
+                vm.set('dataCount', store.data.length);
+            }, this);
+            if (view.initialConfig && view.initialConfig.value) {
+                vm.getStore('cardsStore').loadData(view.initialConfig.value);
+            }
+            this.getView().getFormData = this.getFormData.bind(this);
+        },
+        getFormData() {
+            return this.getViewModel().getStore('cardsStore').getRange().map((rec) => {
+                return {title: rec.get('title'), itemId: rec.get('itemId')};
+            });
+        },
+        addRow() {
+            this.getViewModel().getStore('cardsStore').add({itemId: 'UiCFCard_' + Ext.id().replace('-', '_')});
+        },
+        deleteRow() {
+            this.getViewModel().getStore('cardsStore').remove(this.getViewModel().get('selection'));
+        },
+    },
+    viewModel: {
+        data: {
+            selection: null,
+            dataCount: 1,
+        },
+        stores: {
+            cardsStore: {
+                type: 'json',
+                fields: ['title', 'itemId'],
+                data: [
+                ],
+            },
+        },
+    },
+    tbar: [
+        {
+            text: 'Добавить',
+            handler: 'addRow',
+        },
+        {
+            text: 'Удалить',
+            handler: 'deleteRow',
+            bind: {
+                disabled: '{!selection || dataCount < 2}',
+            },
+        }
+    ],
+    bind: {
+        store: '{cardsStore}',
+        selection: '{selection}',
+    },
+    columns: [
+        {xtype: 'rownumberer'},
+        {dataIndex: 'title', text: 'Заголовок', flex: 1, editor: {xtype: 'textfield'}}
+    ],
+    plugins: [
+        {ptype: 'cellediting'}
+    ],
+});

package/src/common/component/formeditor/UiCFCell.js

@@ -0,0 +1,12 @@
+/* global Ext */
+Ext.define('Coon.common.component.formeditor.UiCFCell', {
+    extend: 'Ext.container.Container',
+    controller: 'UiCFCellController',
+    xtype: 'UiCFCell',
+    flex: 200,
+    collapsible: true,
+    margin: 5,
+    layout: 'fit',
+    items: [
+    ],
+});

package/src/common/component/formeditor/UiCFCellController.js

@@ -0,0 +1,236 @@
+Ext.define('Coon.common.component.formeditor.UiCFCellController', {
+    extend: 'Ext.app.ViewController',
+    alias: 'controller.UiCFCellController',
+    menuItems: {},
+    oldWidth: 0,
+    minCellWidth: 150,
+    readOnly: false,
+    init: function() {
+        this.setDefaultMenuItems();
+        this.initMouseEvents();
+    },
+    setDefaultMenuItems() {
+        const rowCnt = this.getUiCFRowController();
+        this.menuItems = {
+            left: {
+                text: 'влево', iconCls: 'fa fa-arrow-left',
+                handler: this.moveCellLeft.bind(this),
+            },
+            right: {
+                text: 'вправо', iconCls: 'fa fa-arrow-right',
+                handler: this.moveCellRight.bind(this),
+            },
+            copy: {
+                text: 'копировать', iconCls: 'fa fa-copy',
+                handler: this.copyCell.bind(this),
+            },
+            cut: {
+                text: 'вырезать', iconCls: 'fa fa-cut',
+                handler: this.cutCell.bind(this),
+            },
+            paste: {
+                text: 'вставить', iconCls: 'fa fa-paste',
+                handler: this.pasteCell.bind(this),
+            },
+            remove: {
+                text: 'удалить', iconCls: 'fa fa-trash',
+                handler: this.removeCell.bind(this),
+            },
+            layout: {
+                text: 'выравнивание', iconCls: 'fa fa-bars',
+                menu: [
+                    {text: 'выравнять текущую строку', handler: rowCnt.layoutCellsInRow.bind(rowCnt)},
+                    {text: 'выравнять по шаблону', handler: rowCnt.layoutByTemplate.bind(rowCnt)}
+                ],
+            },
+            flexLayout: {
+                text: 'задать относительный размер', iconCls: 'fa fa-arrows-alt-v',
+                handler: rowCnt.setFlex.bind(rowCnt),
+            },
+        };
+    },
+
+    setResizer() {
+        this.oldWidth = this.getView().getWidth();
+        const uiCFEditorController = this.getUiCFEditorController();
+        if (uiCFEditorController && uiCFEditorController.activeResizer) {
+            uiCFEditorController.activeResizer.destroy();
+            uiCFEditorController.activeResizer = null;
+        }
+        const rowController = this.getUiCFRowController();
+        const row = this.getView().up('UiCFRow');
+        const countCells = rowController.getCountCells();
+        const cellIndex = rowController.getCellIndexInRow(this.getView());
+        if (cellIndex !== countCells - 1) {
+            const currentItem = this.getView();
+            const nextItem = row.items.getAt(cellIndex + 1);
+            this.oldWidth = currentItem.getWidth();
+            if (uiCFEditorController) {
+                uiCFEditorController.activeResizer = Ext.create('Ext.resizer.Resizer', {
+                    target: currentItem.getEl(),
+                    handles: 'e',
+                    minWidth: this.minCellWidth,
+                    pinned: true,
+                    listeners: {
+                        resize: (cmp, width) => {
+                            const dif = width - this.oldWidth;
+                            const module = Math.abs(dif);
+                            const percent = Ext.Number.parseInt(Ext.Number.toFixed(module/this.oldWidth, 2)*100);
+                            const difFlex = Ext.Number.parseInt(currentItem.flex * percent / 100);
+                            const minFlex = Ext.Number.parseInt(this.minCellWidth * nextItem.flex / nextItem.getWidth());
+                            let nextSum = nextItem.flex - difFlex;
+                            let curSum = currentItem.flex + difFlex;
+                            if (dif > 0 && nextItem.flex - difFlex < minFlex) {
+                                curSum -= minFlex - nextSum;
+                                nextSum = minFlex;
+                            }
+                            nextItem.setFlex(dif > 0 ? nextSum : nextItem.flex + difFlex);
+                            currentItem.setFlex(dif > 0 ? curSum : currentItem.flex - difFlex);
+                            row.updateLayout();
+                            this.oldWidth = currentItem.getWidth();
+                        },
+                    },
+                });
+            }
+        }
+    },
+    moveCellLeft() {
+        const rowController = this.getUiCFRowController();
+        rowController.moveCell(this.getView(), 'left');
+        this.setResizer();
+    },
+
+    moveCellRight() {
+        const rowController = this.getUiCFRowController();
+        rowController.moveCell(this.getView(), 'right');
+        this.setResizer();
+    },
+
+    copyCell() {
+        const cnt = this.getUiCFEditorController();
+        cnt.copyCell = this;
+        if (cnt.cutCell) {
+            cnt.cutCell.getView().removeCls('cutCell');
+            cnt.cutCell = null;
+        }
+    },
+
+    pasteCell() {
+        const cnt = this.getUiCFEditorController();
+        const cell = cnt.copyCell || cnt.cutCell;
+        if (cell) {
+            const cfg = cnt.getCfg(cell.getView());
+            if (cnt.copyCell) {
+                this.getUiCFRowController().addCell(this.getUiCFContainerController().generateNewNames(cfg), this.getView());
+            } else {
+                cell.getUiCFRowController().removeCell(cell.getView());
+                cnt.cutCell = null;
+                this.getUiCFRowController().addCell(cfg, this.getView());
+            }
+        }
+    },
+
+    cutCell() {
+        const cnt = this.getUiCFEditorController();
+        this.getView().addCls('cutCell');
+        cnt.cutCell = this;
+        cnt.copyCell = null;
+    },
+
+    getUiCFEditorController() {
+        return this.getView().up('UiCustomFormEditor').getController();
+    },
+
+    removeCell() {
+        const rowController = this.getUiCFRowController();
+        rowController.removeCell(this.getView());
+    },
+
+    getField() {
+        return this.getView().items.find((el) => el.itemId === 'field');
+    },
+
+    initMouseEvents() {
+        if (!this.getUiCFContainerController() || this.readOnly) {
+            return;
+        }
+        this.getView().on('render', (cmp) => {
+            const listeners = {
+                contextmenu: 'onMouseEvent',
+                scope: this,
+                destroyable: true,
+                priority: 1,
+                stopPropagation: true,
+            };
+            cmp.getEl().on(listeners);
+        }, this);
+    },
+    onMouseEvent(event) {
+        if (this.readOnly) {
+            return;
+        }
+        const contextMenu = new Ext.menu.Menu({
+            closeAction: 'destroy',
+            items: this.getMenuItems(),
+            listeners: {
+                hide: function() {
+                    const me = this;
+                    Ext.defer(() => me.destroy(), 2000);
+                },
+            },
+        });
+        contextMenu.showAt(event.pageX, event.pageY);
+        event.preventDefault();
+        return false;
+    },
+    getCellIndexInRow() {
+        return this.getUiCFRowController().getCellIndexInRow(this.getView());
+    },
+    getCountCellsInRow() {
+        return this.getUiCFRowController().getCountCells();
+    },
+    getMenuItems() {
+        const count = this.getCountCellsInRow();
+        const mainC = this.getUiCFContainerController();
+        const rowC = this.getUiCFRowController();
+        let menuItems = [];
+        menuItems = menuItems.concat(mainC.getMenuItems(this.getRow()));
+        menuItems = menuItems.concat(rowC.getMenuItems(this.getView()));
+        if (count > 1) {
+            const index = this.getCellIndexInRow() + 1;
+            if (count > index) {
+                menuItems.push(this.menuItems.right);
+            }
+            if (index > 1) {
+                menuItems.push(this.menuItems.left);
+            }
+        }
+        const cnt = this.getUiCFEditorController();
+        const cell = cnt.copyCell || cnt.cutCell;
+        menuItems.push(this.menuItems.copy);
+        menuItems.push(this.menuItems.cut);
+        if (cell && cell.getView() && cell.getView().id !== this.getView().id) {
+            menuItems.push(this.menuItems.paste);
+        }
+        if (rowC.getCountCells() > 1) {
+            menuItems.push(this.menuItems.layout);
+        }
+        if (this.menuItems.flexLayout) {
+            const tmp = this.menuItems.flexLayout;
+            tmp.text = 'задать относительный размер' + (rowC.getView().flex > 0 ? ' (' + rowC.getView().flex + ')' : '');
+            menuItems.push(tmp);
+        }
+
+        menuItems.push(this.menuItems.remove);
+        return menuItems;
+    },
+    getUiCFContainerController() {
+        return this.getView().up('UiCFContainer') ? this.getView().up('UiCFContainer').getController() : null;
+    },
+    getRow() {
+        return this.getView().up('UiCFRow');
+    },
+    getUiCFRowController() {
+        return this.getRow().getController();
+    },
+});

package/src/common/component/formeditor/UiCFCheckboxGroup.js

@@ -0,0 +1,53 @@
+/* global Ext */
+Ext.define('Coon.common.component.formeditor.UiCFCheckboxGroup', {
+    extend: 'Ext.form.CheckboxGroup',
+    xtype: 'UiCFCheckboxGroup',
+    controller: {
+        init(view) {
+            let i = 1;
+            if (view.initialConfig && !view.initialConfig.checkOptions) {
+                if (view.initialConfig && view.initialConfig.countCards) {
+                    view.initialConfig.countCards.forEach((setting, index) => {
+                        let item = view.items.getAt(view.items.findIndex('itemId', setting.itemId));
+                        if (!item) {
+                            item = view.add({
+                                itemId: setting.itemId,
+                                inputValue: setting.inputValue,
+                            });
+                        }
+                        if (setting.boxLabel) {
+                            item.setBoxLabel(setting.boxLabel);
+                        }
+                        if (setting.inputValue) {
+                            item.inputValue = setting.inputValue;
+                        } else {
+                            item.inputValue = i++;
+                        }
+                    });
+                    if (view.initialConfig.countCards.length < view.items.getCount()) {
+                        const ids = view.initialConfig.countCards.map((item) => item.itemId);
+                        view.items.items.forEach((item) => {
+                            if (ids.indexOf(item.itemId) < 0) {
+                                view.remove(item);
+                            }
+                        });
+                    }
+                } else {
+                    const itemId = 'UiCFRadio_' + Ext.id().replace('-', '_');
+                    view.countCards = [
+                        {
+                            'itemId': itemId,
+                            'inputValue': i,
+                        }
+                    ],
+                    view.add({
+                        'itemId': itemId,
+                        'inputValue': i,
+                    });
+                    i++;
+                }
+            }
+        },
+    },
+    items: [],
+});

package/src/common/component/formeditor/UiCFContainer.js

@@ -0,0 +1,15 @@
+/* global Ext */
+Ext.define('Coon.common.component.formeditor.UiCFContainer', {
+    extend: 'Ext.panel.Panel',
+    controller: 'UiCFContainerController',
+    xtype: 'UiCFContainer',
+    cls: 'UiCFContainer',
+    layout: {
+        type: 'vbox',
+        align: 'stretch',
+    },
+    minHeight: 30,
+    items: [
+
+    ],
+});