ru.coon 2.8.65 → 3.0.2

package/src/uielement/component/settings/plugin/UiCustomPanelPluginGridController.js

@@ -3,6 +3,32 @@ Ext.define('Coon.uielement.component.settings.plugin.UiCustomPanelPluginGridCont
     alias: 'controller.UiCustomPanelPluginGridController',
 
     lastCellContext: undefined,
+    isForcedSelection: false,
+    historyMaxLength: 15,
+    favoritesMaxLength: 5,
+
+    bindings: {
+        switchFormDisable: '{favoriteButtonPressed}',
+    },
+
+    control: {
+        '#': {
+            select: 'saveHistory',
+        },
+        '#searchInPlugins': {
+            change: 'searchInPlugins',
+        },
+        '#clearHistoryButton': {
+            click: 'clearHistory',
+        },
+        '#historyButton': {
+            click: 'showHistory',
+        },
+        '#favoriteButton': {
+            toggle: 'switchFavoritesFilter',
+            arrowclick: 'showFavorites',
+        },
+    },
 
     init: function(view) {
         this.getViewModel().set('formEditor', this.getView().formEditor === true);
@@ -11,8 +37,24 @@ Ext.define('Coon.uielement.component.settings.plugin.UiCustomPanelPluginGridCont
                 r.sortable = true;
             });
         }
-        this.getView().getStore().on('endupdate', this.setHandlers, this);
+        view.getStore().on({
+            endupdate: this.setHandlers,
+            remove: this.removePluginFromFavorites,
+            scope: this,
+        });
         this.getViewModel().bind('{unusedHandlers}', this.highlightUnusedHandlers, this);
+        this.pluginNavHistory = {
+            buffer: Ext.create('Coon.ringBuffer', {length: this.historyMaxLength}),
+            cursor: -1,
+        };
+        this.favoritePlugins = {
+            items: {},
+            count: 0,
+        };
+    },
+
+    getAllPlugins() {
+        return this.getView().getStore().getDataSource().getRange();
     },
 
     highlightUnusedHandlers() {
@@ -25,13 +67,81 @@ Ext.define('Coon.uielement.component.settings.plugin.UiCustomPanelPluginGridCont
         });
     },
 
+    validateHandlerNames(plugins) {
+        const names = new Map();
+
+        plugins.forEach((plugin) => {
+            if (!plugin.get('isHandlerRequired')) {
+                return;
+            }
+
+            if (plugin.get('isDeleted')) {
+                plugin.set('hasInvalidName', false);
+                return;
+            }
+
+            const handlerName = plugin.get('handlerName').trim();
+
+            if (handlerName.length === 0 || handlerName === '-/-') {
+                plugin.set('hasInvalidName', true);
+                return;
+            }
+
+            const value = names.get(handlerName);
+
+            if (value) {
+                if (Array.isArray(value)) {
+                    value.push(plugin);
+                } else {
+                    names.set(handlerName, [value, plugin]);
+                }
+            } else {
+                names.set(handlerName, plugin);
+            }
+        });
+
+        for (const value of names.values()) {
+            if (Array.isArray(value)) {
+                value.forEach((plugin) => plugin.set('hasInvalidName', true));
+            } else {
+                value.set('hasInvalidName', false);
+            }
+        }
+    },
+
     searchInPlugins(field, value) {
-        const filterByText = (plugin) => JSON.stringify(plugin.get('jsonProperties')).includes(value);
-        const store = this.getView().getStore();
-        if (value) {
-            store.addFilter(filterByText);
+        const filters = this.getView().getStore().getFilters();
+
+        if (!value) {
+            filters.removeByKey('textFilter');
+            return;
+        }
+
+        if (filters.getByKey('textFilter')) {
+            filters.removeByKey('textFilter');
+        }
+
+        const textFilter = new Ext.util.Filter({
+            id: 'textFilter',
+            filterFn: (plugin) => JSON.stringify(plugin.get('jsonProperties')).includes(value),
+        });
+
+        this.getView().getStore().addFilter(textFilter);
+    },
+
+    switchFavoritesFilter(bt, pressed) {
+        const favoriteIds = Object.keys(this.favoritePlugins.items);
+
+        if (pressed) {
+            const favoritesFilter = new Ext.util.Filter({
+                id: 'favoritesFilter',
+                property: 'id',
+                value: favoriteIds,
+                operator: 'in',
+            });
+            this.getView().getStore().addFilter(favoritesFilter);
         } else {
-            store.clearFilter();
+            this.getView().getStore().getFilters().removeByKey('favoritesFilter');
         }
     },
 
@@ -60,6 +170,11 @@ Ext.define('Coon.uielement.component.settings.plugin.UiCustomPanelPluginGridCont
         return pClass && pClass.prototype && pClass.prototype[prop];
     },
 
+    isPluginPropExisting(ptype, prop) {
+        const pClass = Ext.ClassManager.getByAlias(`plugin.${ptype}`);
+        return pClass && pClass.prototype && pClass.prototype.getInitialConfig().hasOwnProperty(prop);
+    },
+
     addHandler: function(ptype) {
         const view = this.getView();
         const existInGrid = view.getStore().findRecord('ptype', ptype);
@@ -68,11 +183,13 @@ Ext.define('Coon.uielement.component.settings.plugin.UiCustomPanelPluginGridCont
             return;
         }
         const isSingle = this.getPluginClassProp(ptype, 'isSingle');
+        const isHandlerRequired = this.isPluginPropExisting(ptype, 'handlerName');
         const plugin = Ext.create('Coon.uielement.component.settings.plugin.UiCustomPanelPluginModel', {
             isNew: true,
             properties: [],
             jsonProperties: [],
             isSingle,
+            isHandlerRequired,
             ptype,
         });
         view.getStore().add(plugin);
@@ -109,47 +226,66 @@ Ext.define('Coon.uielement.component.settings.plugin.UiCustomPanelPluginGridCont
     deleteHandler: function(pluginInfoHeader) {
         const view = this.getView();
         const record = view.getSelectionModel().getLastSelected();
-        if (record) {
-            if (record.get('isNew')) {
-                view.getStore().remove(record);
-            } else {
-                record.set('isDeleted', !record.get('isDeleted'));
-                pluginInfoHeader.fireEvent(
-                    record.get('isDeleted') ? 'restoreaction' : 'deleteaction',
-                    pluginInfoHeader
-                );
+        const deleteOrRestoreRecord = () => {
+            if (record) {
+                if (record.get('isNew')) {
+                    view.getStore().remove(record);
+                } else {
+                    record.set('isDeleted', !record.get('isDeleted'));
+                    pluginInfoHeader.fireEvent(
+                        record.get('isDeleted') ? 'restoreaction' : 'deleteaction',
+                        pluginInfoHeader
+                    );
+                }
+                view.publishState('data', view.getData());
             }
-            view.publishState('data', view.getData());
+        };
+        if (!record.get('isDeleted')) {
+            Ext.Msg.show({
+                title: 'Подтвердите',
+                msg: 'Удалить плагин?',
+                fn: (btn) => {
+                    if (btn === 'no') {
+                        return;
+                    }
+                    deleteOrRestoreRecord();
+                },
+                buttons: Ext.MessageBox.YESNO,
+                scope: this,
+                width: 300,
+            });
+            return;
         }
+        deleteOrRestoreRecord();
     },
 
     cloneHandler: function() {
         const view = this.getView();
-        const record = view.getSelectionModel().getSelection()[0].copy();
+        const record = view.getSelectionModel().getSelection()[0].copy(null);
         const data = record.data;
         const isSingle = this.getPluginClassProp(data.ptype, 'isSingle');
         if (isSingle) {
             Ext.Msg.alert('Ошибка', 'этот плагин нельзя добавить дважды!');
             return;
         }
-        data['id'] = this.getNextIDSeq();
         data['isNew'] = true;
         data['sortSequence'] = this.getNextSeq();
         data['sequenceNumber'] = this.getNextIDSeq();
         const copyFunction = (btn) => {
-            if (btn === 'cancel') {
+            if (btn === 'no') {
                 return;
             }
             if (data) {
                 view.getStore().add(data);
                 view.publishState('data', view.getData());
+                view.getSelectionModel().select(view.getStore().getCount() -1);
             }
         };
         Ext.Msg.show({
             title: 'Подтвердите',
-            msg: 'Копировать с правами?',
+            msg: 'Копировать плагин?',
             fn: copyFunction,
-            buttons: Ext.MessageBox.YESNOCANCEL,
+            buttons: Ext.MessageBox.YESNO,
             scope: this,
             width: 300,
         });
@@ -209,7 +345,215 @@ Ext.define('Coon.uielement.component.settings.plugin.UiCustomPanelPluginGridCont
     },
 
     setHandlers() {
+        const plugins = this.getAllPlugins();
+        this.getViewModel().set('handlerList', plugins);
+        this.validateHandlerNames(plugins);
+    },
+
+    saveHistory(_, record) {
+        if (this.isForcedSelection) {
+            this.isForcedSelection = false;
+            return;
+        }
+
+        this.pluginNavHistory.buffer.push(record);
+        this.pluginNavHistory.cursor = this.pluginNavHistory.buffer.getBuffer().length - 1;
+
+        this.getView().down('#historyButton').setDisabled(false);
+        this.getView().down('#clearHistoryButton').setDisabled(false);
+    },
+
+    forcePluginSelection(record, newIndex) {
+        const selModel = this.getView().getSelectionModel();
+
+        if (Number.isInteger(newIndex)) {
+            this.pluginNavHistory.cursor = newIndex;
+        }
+
+        this.isForcedSelection = true;
+        selModel.deselectAll();
+        selModel.select(record);
+
+        const selection = selModel.getSelection();
+
+        if (!selection.includes(record)) {
+            this.isForcedSelection = false;
+            return;
+        }
+    },
+
+    clearHistory() {
+        const clearFn = (btn) => {
+            if (btn === 'no') {
+                return;
+            }
+
+            this.pluginNavHistory.cursor = -1;
+            this.pluginNavHistory.buffer.reset();
+            this.getView().down('#historyButton').setDisabled(true);
+            this.getView().down('#clearHistoryButton').setDisabled(true);
+            this.getView().getSelectionModel().deselectAll();
+        };
+
+        Ext.Msg.show({
+            title: 'Подтвердите',
+            msg: 'Очистить историю?',
+            fn: clearFn,
+            buttons: Ext.MessageBox.YESNO,
+            scope: this,
+            width: 300,
+        });
+    },
+
+    onMenuItemClick(menu, menuItem, e) {
+        if (!menuItem) {
+            return;
+        }
+
+        const hasSelection = this.getView().getSelection().length;
+
+        if (hasSelection && menuItem.historyIndex === this.pluginNavHistory.cursor) {
+            return;
+        }
+
+        const gridRecord = this.getAllPlugins().find((item) => item.getId() === menuItem.pluginId);
+        this.forcePluginSelection(gridRecord, menuItem.historyIndex);
+    },
+
+    setButtonMenu(btn, menuItems) {
+        btn.setMenu({
+            items: menuItems.reverse(),
+            cls: 'UICustomPanelPluginMenu',
+        });
+
+        const menu = btn.getMenu();
+        menu.on('click', this.onMenuItemClick, this);
+        return menu;
+    },
+
+    showHistory(historyBtn) {
+        const historyItems = this.pluginNavHistory.buffer.get();
+
+        if (!historyItems.length && historyBtn.getMenu()) {
+            historyBtn.getMenu().destroy();
+            return;
+        }
+
+        const newMenuItems = historyItems.map((item, index) => {
+            let classes = 'menuPluginItem';
+            const abbr = item.el.get('ptype').split('').filter(Coon.util.isUpperLetter).join('');
+            const isPluginExisting = this.getAllPlugins().includes(item.el);
+            const tooltipText = !isPluginExisting ? '(Удален)' : item.el.get('isDeleted') ? '(Помечен на удаление)' : '';
+
+            const menuItem = {
+                pluginId: item.el.get('id'),
+                historyIndex: index,
+                text: `${index + 1} - ${item.el.get('handlerName')} (${abbr}) ${tooltipText}`,
+            };
+
+            if (!isPluginExisting) {
+                menuItem.disabled = true;
+            }
+
+            if (index === this.pluginNavHistory.cursor) {
+                classes = `${classes} menuPluginItemCurrent`;
+            }
+
+            menuItem.cls = classes;
+            return menuItem;
+        });
+
+        const menu = this.setButtonMenu(historyBtn, newMenuItems);
+        menu.showBy(historyBtn);
+    },
+
+    removePluginFromFavorites(_, records) {
+        const pluginId = records[0].getId();
+
+        if (this.favoritePlugins.items[pluginId]) {
+            delete this.favoritePlugins.items[pluginId];
+            this.favoritePlugins.count--;
+        }
+
+        if (!this.favoritePlugins.count) {
+            this.getView().down('#favoriteButton').setDisabled(true);
+        }
+    },
+
+    showFavorites(favoritesBtn) {
+        if (!this.favoritePlugins.count && favoritesBtn.getMenu()) {
+            favoritesBtn.getMenu().destroy();
+            return;
+        }
+
+        const newMenuItems = [];
+
+        for (const recordId in this.favoritePlugins.items) {
+            const plugin = this.favoritePlugins.items[recordId];
+            const abbr = plugin.get('ptype').split('').filter(Coon.util.isUpperLetter).join('');
+            const tooltipText = plugin.get('isDeleted') ? '(Помечен на удаление)' : '';
+
+            const menuItem = {
+                pluginId: recordId,
+                text: `${plugin.get('handlerName')} (${abbr}) ${tooltipText}`,
+            };
+
+            let classes = 'menuPluginItem';
+            const selected = this.getView().getSelectionModel().getSelection();
+            if (selected.length && (recordId === selected[0].getId())) {
+                classes = `${classes} menuPluginItemCurrent`;
+            }
+            menuItem.cls = classes;
+            newMenuItems.push(menuItem);
+        }
+
+        const menu = this.setButtonMenu(favoritesBtn, newMenuItems);
+        menu.showBy(favoritesBtn);
+    },
+
+    toggleFavoriteState(grid, rowIndex, colIndex, item, e, record) {
         const vm = this.getViewModel();
-        vm.set('handlerList', this.getView().getStore().getData().getRange());
+        const isFavoritesBtnPressed = vm.get('favoriteButtonPressed');
+        const recordId = record.getId();
+
+        if (record.get('hasInvalidName')) {
+            return;
+        }
+
+        if (!this.favoritePlugins.items[recordId]) {
+            if (this.favoritePlugins.count === this.favoritesMaxLength) {
+                Ext.toast(`Достигнуто максимальное количество плагинов в избранном (${this.favoritesMaxLength})`);
+                return;
+            }
+            this.favoritePlugins.items[recordId] = record;
+            this.favoritePlugins.count++;
+        } else {
+            delete this.favoritePlugins.items[recordId];
+            this.switchFavoritesFilter(null, isFavoritesBtnPressed);
+            this.favoritePlugins.count--;
+        }
+        this.updateFavoriteBtnState();
+        this.getView().getView().refresh();
+    },
+
+    updateFavoriteBtnState() {
+        const favoriteBtn = this.getView().down('#favoriteButton');
+
+        if (!this.favoritePlugins.count) {
+            favoriteBtn.setPressed(false);
+            favoriteBtn.setDisabled(true);
+        } else {
+            favoriteBtn.setDisabled(false);
+        }
+    },
+
+    switchFormDisable(isFavoritesPressed) {
+        const pluginForm = this.getView().up('UiCustomPanelPluginPanel').lookup('pluginForm');
+
+        if (isFavoritesPressed) {
+            pluginForm.mask();
+        } else {
+            pluginForm.unmask();
+        }
     },
 });

package/src/uielement/component/settings/plugin/UiCustomPanelPluginModel.js

@@ -4,6 +4,7 @@ Ext.define('Coon.uielement.component.settings.plugin.UiCustomPanelPluginModel',
 
     fields: [
         {name: 'isSingle', type: 'boolean'},
+        {name: 'isHandlerRequired', type: 'boolean'},
         {name: 'isNew', type: 'boolean'},
         {name: 'sequenceNumber', type: 'number'},
         {name: 'sortSequence', type: 'number'},

package/src/uielement/component/settings/plugin/UiCustomPanelPluginPanel.js

@@ -61,16 +61,22 @@ Ext.define('Coon.report.component.settings.plugin.UiCustomPanelPluginPanel', {
                         },
                         {
                             xtype: 'button',
-                            iconCls: 'x-fa fa-trash-alt',
+                            iconCls: 'svg-fa svg-fa-trash-can',
                             reference: 'deleteButton',
                             itemId: 'deleteButton',
+                            bind: {
+                                disabled: '{!pluginGrid.selection}',
+                            },
                         },
                         {
                             xtype: 'button',
                             tooltip: 'Клонировать',
                             reference: 'cloneButton',
                             itemId: 'cloneButton',
-                            iconCls: 'x-fa fa-clone',
+                            iconCls: 'svg-fa svg-fa-clone',
+                            bind: {
+                                disabled: '{!pluginGrid.selection}',
+                            },
                         }
                     ],
                     listeners: {
@@ -81,7 +87,7 @@ Ext.define('Coon.report.component.settings.plugin.UiCustomPanelPluginPanel', {
                             });
                             ct.down('#cloneButton').disable();
                             const btn = ct.down('button#deleteButton');
-                            btn.setIconCls('x-fa fa-trash-restore');
+                            btn.setIconCls('svg-fa svg-fa-trash-arrow-up');
                             btn.setTooltip('восстановить плагин?');
                         },
                         deleteaction: function(ct) {
@@ -91,7 +97,7 @@ Ext.define('Coon.report.component.settings.plugin.UiCustomPanelPluginPanel', {
                             });
                             ct.down('#cloneButton').enable();
                             const btn = ct.down('button#deleteButton');
-                            btn.setIconCls('x-fa fa-trash-alt');
+                            btn.setIconCls('svg-fa svg-fa-trash-can');
                             btn.setTooltip('пометить на удаление плагин?');
                         },
                     },

package/src/uielement/component/settings/plugin/UiCustomPanelPluginPanelController.js

@@ -51,38 +51,36 @@ Ext.define('Coon.uielement.component.settings.plugin.UiCustomPanelPluginPanelCon
     },
 
     saveState: function() {
-        if (this.activeRecord && this.activePanel) {
-            if (
-                this.activePanel.xtype === 'ExecuteFunctionPluginConfigPanelFormEditor' &&
-                !this.activeRecord.data._skipErrors
-            ) {
-                const editor = this.activePanel.down('UiAceEditor');
-                const me = this;
-                if (editor.hasErrors()) {
-                    Ext.Msg.show({
-                        title: 'Обнаружены ошибки в функции,подтвердите чтобы пропустить проверку в следующий раз',
-                        message: 'Пропустить проверку?',
-                        buttons: Ext.Msg.YESNO,
-                        icon: Ext.Msg.WARNING,
-                        fn: function(btn) {
-                            if (btn === 'yes') {
-                                me.activeRecord.data._skipErrors = true;
-                                // me.activePanel.down('UiAceEditor').setValue(me.activeRecord.get('fnBody'));
-                            }
-                        },
-                    });
-                    return false;
-                }
-            }
-            this.activeRecord.data._skipErrors = false;
-            this.activeRecord.set({
-                modified: true,
-                jsonProperties: this.activePanel.getData(),
-            });
-            if (this.activePanel.xtype === 'ExecuteFunctionPluginConfigPanelFormEditor') {
-                this.fireViewEvent('ExecuteFunctionPluginChange');
+        if (!this.activeRecord || !this.activePanel) {
+            return;
+        }
+        if (
+            this.activePanel.xtype === 'ExecuteFunctionPluginConfigPanelFormEditor' &&
+            !this.activeRecord.data._skipErrors
+        ) {
+            const editor = this.activePanel.down('UiAceEditor');
+            const me = this;
+            if (editor.hasErrors()) {
+                Ext.Msg.show({
+                    title: 'Обнаружены ошибки в функции,подтвердите чтобы пропустить проверку в следующий раз',
+                    message: 'Пропустить проверку?',
+                    buttons: Ext.Msg.YESNO,
+                    icon: Ext.Msg.WARNING,
+                    fn: function(btn) {
+                        if (btn === 'yes') {
+                            me.activeRecord.data._skipErrors = true;
+                            // me.activePanel.down('UiAceEditor').setValue(me.activeRecord.get('fnBody'));
+                        }
+                    },
+                });
+                return false;
             }
         }
+        this.activeRecord.data._skipErrors = false;
+        this.activeRecord.set({
+            modified: true,
+            jsonProperties: this.activePanel.getData(),
+        });
     },
 
     selectPlugin(plugin) {