ru.coon 2.7.32 → 2.7.34

package/src/security/securitySettingComponent/menu/RoleEditMenuController.js

@@ -0,0 +1,171 @@
+Ext.define('Coon.security.securitySettingComponent.menu.RoleEditMenuController', {
+    extend: 'Ext.app.ViewController',
+
+    alias: 'controller.RoleEditMenuController',
+
+    reportId: 'MENU_ALLITEMS',
+
+    init() {
+        const menuGrid = this.getView();
+        menuGrid.on('styleGrid', function() {
+            this.refreshTreeStyle();
+        }, this);
+        menuGrid.getView().on({
+            refresh: {
+                fn: function() {
+                    this.refreshTreeStyle();
+                },
+                scope: this,
+            },
+            scrollend: {
+                fn: function() {
+                    this.refreshTreeStyle();
+                },
+                scope: this,
+            },
+            afteritemexpand: {
+                fn: function(node) {
+                    this.refreshTreeStyle(node);
+                },
+                scope: this,
+            },
+            afteritemcollapse: {
+                fn: function(node) {
+                    this.refreshTreeStyle(node);
+                },
+                scope: this,
+            },
+        });
+    },
+
+    refreshTreeStyle(node) {
+        const menuGrid = this.getView();
+        const styledRows =[];
+        const unStyledRows =[];
+        const cascadeNode = (node) => {
+            node.cascade((childNode) => {
+                !childNode.isRoot() && childNode.get('menuCheck') ? styledRows.push(childNode) : unStyledRows.push(childNode);
+            });
+        };
+        node = node || menuGrid.getRootNode();
+        cascadeNode(node);
+        styledRows.length && styledRows.map((r) => {
+            menuGrid.getView().removeRowCls(r, 'unchecked-row');
+            menuGrid.getView().addRowCls(r, 'checked-row');
+        });
+        unStyledRows.length && unStyledRows.map((r) => {
+            menuGrid.getView().removeRowCls(r, 'checked-row');
+            menuGrid.getView().addRowCls(r, 'unchecked-row');
+        });
+    },
+
+    getData(newRoleName, shouldDeleteCurrentRole) {
+        const menuData = [];
+        this.getView().getStore().clearFilter();
+        this.getView().getRootNode().cascade((childNode) => {
+            const menu = childNode.get('MENU_ENTRY_CD');
+            childNode.get('menuCheck') && menu && menuData.push(menu);
+        });
+        this.menuGitDataContent[this.role] = menuData;
+        if (newRoleName) {
+            this.menuGitDataContent[newRoleName] = menuData;
+        }
+        if (shouldDeleteCurrentRole) {
+            delete this.menuGitDataContent[this.role];
+        }
+        return JSON.stringify(this.menuGitDataContent);
+    },
+
+    onCheckChange(col, rowIndex, checked, record) {
+        const parentNode = record.parentNode;
+        if (record.hasChildNodes()) {
+            record.cascade((child) => child.set('menuCheck', checked));
+        }
+        const checkParentFunction = (node) => {
+            if (!node || node.isRoot()) {
+                return;
+            }
+            if (!checked && node.get('menuCheck') && !node.findChild('menuCheck', true) ||
+                (checked && !node.get('menuCheck'))) {
+                node.set('menuCheck', checked);
+                checkParentFunction(node.parentNode);
+            }
+        };
+        checkParentFunction(parentNode);
+        col.up('treepanel').fireEvent('styleGrid');
+    },
+
+    loadAllMenuData(data, role) {
+        this.menuGitDataContent = data;
+        this.role = role;
+        const menuGitData = this.menuGitDataContent[this.role];
+        return Coon.util.promisifyCmd('command.GetDynamicReportDataCommand', this.reportId)
+            .then((data) => {
+                if (Ext.isArray(data.list)) {
+                    const transformData = data.list.map((el) => {
+                        return Coon.Function.convertObjectByMapping(el, {
+                            MENU_ENTRY_DESCR: 'text',
+                        });
+                    });
+                    this.allMenuData = transformData.reduce((acc, el) => {
+                        el.leaf = el.LEAF_SW === 'Y';
+                        el.menuCheck = !!menuGitData.find((menu) => menu === el.MENU_ENTRY_CD);
+                        if (!acc.find((item) => item.ws === el.WORKSPACE_CD)) {
+                            acc.push({
+                                text: el.WORKSPACE_DESCR,
+                                ws: el.WORKSPACE_CD,
+                                leaf: false,
+                                expanded: false,
+                                children: [],
+                            });
+                        }
+                        const found = acc.find((item) => item.ws === el.WORKSPACE_CD);
+                        if (el.menuCheck) {
+                            found.menuCheck = el.menuCheck;
+                        }
+                        if (!el.leaf) {
+                            el.expanded = false;
+                            el.children = transformData.filter((item) =>
+                                item.PARENT_MENU_ENTRY_CD === el.MENU_ENTRY_CD);
+                        }
+                        !el.PARENT_MENU_ENTRY_CD && found.children.push(el);
+                        return acc;
+                    }, []);
+                    this.getView().getStore().setRoot({expanded: true, children: this.allMenuData});
+                    this.getView().fireEvent('styleGrid');
+                } else {
+                    Ext.Msg.alert('Ошибка', 'Некорректный формат ответа или нет данных');
+                }
+            })
+            .catch((error) => {
+                Ext.Msg.alert('Ошибка', error.message);
+            });
+    },
+
+    filterTree(e, field) {
+        this.getView().getRootNode().cascade((node) => {
+            if (node.get('text').toLowerCase().includes(field.getValue().toLowerCase())) {
+                node.bubble((parentNode) => parentNode.expand());
+            }
+        });
+    },
+
+    collapseAll() {
+        this.getView().getRootNode().cascade((node) => {
+            if (node.isRoot()) {
+                return;
+            }
+            node.collapse();
+        });
+    },
+
+    expandAll() {
+        this.getView().getRootNode().cascade((node) => {
+            if (node.isRoot()) {
+                return;
+            }
+            node.expand();
+        });
+    },
+
+});

package/src/security/securitySettingComponent/menu/RoleEditMenuPanel.js

@@ -0,0 +1,72 @@
+Ext.define('Coon.security.securitySettingComponent.menu.RoleEditMenuPanel', {
+    extend: 'Ext.tree.Panel',
+    alias: 'widget.RoleEditMenuPanel',
+    controller: 'RoleEditMenuController',
+
+    cls: 'RoleEditPanel',
+
+    requires: [],
+
+    layout: {
+        type: 'hbox',
+        align: 'stretch',
+    },
+    title: 'Меню',
+    rootVisible: false,
+    store: {
+        type: 'tree',
+        statefulFilters: true,
+    },
+    tbar: {
+        items: [
+            {
+                xtype: 'textfield',
+                fieldLabel: 'Поиск',
+                keyMapEnabled: true,
+                tooltip: 'Для поиска нажмите Enter',
+                keyMap: {
+                    Enter: {
+                        handler: 'filterTree',
+                    },
+                },
+            },
+            {
+                text: 'Свернуть все',
+                handler: 'collapseAll',
+            },
+            {
+                text: 'Развернуть все',
+                handler: 'expandAll',
+            }
+        ],
+    },
+    columns: [
+        {
+            xtype: 'hintColumn',
+            dataIndex: 'WORKSPACE_CD',
+            text: 'WORKSPACE_CD',
+            hidden: true,
+        },
+        {
+            xtype: 'hintColumn',
+            dataIndex: 'MENU_ENTRY_CD',
+            text: 'MENU_ENTRY_CD',
+            hidden: true,
+        },
+        {
+            xtype: 'treecolumn',
+            dataIndex: 'text',
+            text: 'Меню',
+            flex: 1,
+        },
+        {
+            xtype: 'checkcolumn',
+            dataIndex: 'menuCheck',
+            text: 'v',
+            editable: true,
+            listeners: {
+                checkchange: 'onCheckChange',
+            },
+        }
+    ],
+});

package/src/security/securitySettingComponent/report/RoleEditReportController.js

@@ -0,0 +1,111 @@
+Ext.define('Coon.security.securitySettingComponent.report.RoleEditReportController', {
+    extend: 'Ext.app.ViewController',
+
+    alias: 'controller.RoleEditReportController',
+
+    init() {
+        this.lookup('reportPluginsGrid').getStore().on('datachanged', this.onEditReportGridButtonHandler.bind(this));
+    },
+
+    loadReportData(data, role) {
+        this.reportGitDataContent = data;
+        this.role = role;
+        this.reportGitDataObject = Object.entries(this.reportGitDataContent).reduce((acc, [repId, pluginsByRole]) => {
+            if (pluginsByRole[this.role] && pluginsByRole[this.role].length) {
+                acc[repId] = pluginsByRole[this.role];
+            }
+            return acc;
+        }, {});
+        this.lookup('reportsGrid').getStore().loadData(Object.keys(this.reportGitDataObject).map((report) => {
+            return {'report': report};
+        }));
+    },
+
+    getData(newRoleName, shouldDeleteCurrentRole) {
+        Object.keys(this.reportGitDataContent).map((repId) => {
+            if (newRoleName) {
+                this.reportGitDataContent[repId][newRoleName] = this.reportGitDataContent[repId][this.role];
+            }
+            if (shouldDeleteCurrentRole) {
+                delete this.reportGitDataContent[repId][this.role];
+            }
+        });
+        return JSON.stringify(this.reportGitDataContent);
+    },
+
+    onEditReportGridButtonHandler(store) {
+        const selection = this.lookup('reportsGrid').getSelection()[0];
+        if (!selection) {
+            return;
+        }
+        const masterReport = selection.get('report');
+        const plugins = store.getRange().map((record) => record.get('plugin'));
+        this.reportGitDataContent[masterReport][this.role] = plugins;
+    },
+
+    selectReport(grid, selected) {
+        const reportPluginsGrid = this.lookup('reportPluginsGrid');
+        reportPluginsGrid.getStore().removeAll();
+        if (!selected.length) {
+            return;
+        }
+        const reportPlugins = this.reportGitDataObject[selected[0].get('report')] || [];
+        this.lookup('reportPluginsGrid').getStore().loadData(reportPlugins.map((plugin) => {
+            return {'plugin': plugin};
+        }));
+        this.lookup('deleteReportPluginRecordButton').setDisabled(selected);
+    },
+
+    addReportRecordHandler() {
+        const reportsGrid = this.lookup('reportsGrid');
+        const panel = Ext.widget('ReportPanel', {
+            reportId: 'REPORTS',
+            preprocessPluginConfig: (config, xtype) => !['OpenCustomPanelButtonPlugin', 'ExecuteCommandButtonPlugin',
+                'CopyRowsFromGrid', 'OpenURLButtonPlugin'].includes(xtype) && config,
+        });
+        const win = Ext.widget('WindowWrap', {
+            items: panel,
+        });
+        win.down('ReportPanel').on('itemdblclick', (_, record) => {
+            if (reportsGrid.getStore().find('report', record.get('CM_REPORT_CD')) === -1) {
+                reportsGrid.getStore().add({
+                    report: record.get('CM_REPORT_CD'),
+                });
+                this.reportGitDataContent[record.get('CM_REPORT_CD')] = {};
+                this.reportGitDataContent[record.get('CM_REPORT_CD')][this.role] = [];
+            }
+            reportsGrid.setSelection(reportsGrid.getStore().find('report', record.get('CM_REPORT_CD')));
+            win.close();
+        });
+        win.show();
+    },
+
+    addReportPluginHandler() {
+        this.lookup('reportPluginsGrid').getStore().add({});
+    },
+
+    deleteReportRecordHandler() {
+        const reportsGrid = this.lookup('reportsGrid');
+        const selectedRecord = reportsGrid.selection;
+        delete this.reportGitDataContent[selectedRecord.get('report')][this.role];
+        reportsGrid.getStore().remove(selectedRecord);
+    },
+
+    deleteReportPluginRecordHandler() {
+        const selectedReportPluginRecord = this.lookup('reportPluginsGrid').getSelection()[0];
+        const masterReport = this.lookup('reportsGrid').getSelection()[0].get('report');
+        const plugin = selectedReportPluginRecord.get('plugin');
+        const pluginArray = this.reportGitDataContent[masterReport][this.role];
+        if (pluginArray && pluginArray.length) {
+            const index = pluginArray.findIndex((el) => el === plugin);
+            index !== -1 && pluginArray.splice(index, 1);
+            if (!pluginArray.length) {
+                delete this.reportGitDataContent[masterReport][this.role];
+            }
+            if (Ext.isEmpty(this.reportGitDataContent[masterReport])) {
+                delete this.reportGitDataContent[masterReport];
+            }
+        }
+        this.lookup('reportPluginsGrid').getStore().remove(selectedReportPluginRecord);
+    },
+});

package/src/security/securitySettingComponent/report/RoleEditReportPanel.js

@@ -0,0 +1,88 @@
+Ext.define('Coon.security.securitySettingComponent.report.RoleEditReportPanel', {
+    extend: 'Ext.Panel',
+    alias: 'widget.RoleEditReportPanel',
+    controller: 'RoleEditReportController',
+    uses: [],
+    requires: [],
+
+    layout: {
+        type: 'hbox',
+        align: 'stretch',
+    },
+
+    items: [
+        {
+            xtype: 'grid',
+            flex: 1,
+            reference: 'reportsGrid',
+            store: {},
+            columns: [
+                {dataIndex: 'report', text: 'Репорт', flex: 1}
+            ],
+            listeners: {
+                selectionChange: 'selectReport',
+            },
+            tbar: {
+                items: [
+                    {
+                        text: 'Добавить',
+                        ui: 'orange-button',
+                        handler: 'addReportRecordHandler',
+                    },
+                    {
+                        text: 'Удалить',
+                        ui: 'green-button',
+                        handler: 'deleteReportRecordHandler',
+                        disabled: true,
+                        bind: {
+                            disabled: '{!reportsGrid.selection}',
+                        },
+                    }
+                ],
+            },
+        },
+        {
+            xtype: 'grid',
+            flex: 1,
+            reference: 'reportPluginsGrid',
+            store: {},
+            columns: [
+                {
+                    dataIndex: 'plugin',
+                    text: 'Плагины',
+                    flex: 1,
+                    editor: {
+                        xtype: 'textfield',
+                    },
+                }
+            ],
+            plugins: [
+                'cellediting'
+            ],
+            tbar: {
+                items: [
+                    {
+                        text: 'Добавить',
+                        ui: 'orange-button',
+                        handler: 'addReportPluginHandler',
+                        disabled: true,
+                        bind: {
+                            disabled: '{!reportsGrid.selection}',
+                        },
+                    },
+                    {
+                        text: 'Удалить',
+                        ui: 'green-button',
+                        handler: 'deleteReportPluginRecordHandler',
+                        disabled: true,
+                        reference: 'deleteReportPluginRecordButton',
+                        bind: {
+                            disabled: '{!reportPluginsGrid.selection}',
+                        },
+                    }
+                ],
+            },
+        }
+    ],
+
+});

package/src/security/securitySettingComponent/uiCP/RoleEditUiCPController.js

@@ -0,0 +1,139 @@
+Ext.define('Coon.security.securitySettingComponent.uiCP.RoleEditUiCPController', {
+    extend: 'Ext.app.ViewController',
+
+    alias: 'controller.RoleEditUiCPController',
+
+    init() {
+        this.lookup('UICPButtonsGrid').getStore().on('datachanged', this.onEditUICPGridButtonHandler.bind(this));
+    },
+
+    loadUiCPData(data, role) {
+        this.uiCpGitDataContent = data;
+        this.role = role;
+        this.uiCpGitDataObject = {};
+        Object.keys(this.uiCpGitDataContent).map((uiName) => {
+            const buttonArr = Object.entries(this.uiCpGitDataContent[uiName].buttons).reduce((acc, [butName, butRoles]) => {
+                if (butRoles.find((el) => el === this.role)) {
+                    acc.push(butName);
+                }
+                return acc;
+            }, []);
+            if (!Ext.isEmpty(buttonArr)) {
+                this.uiCpGitDataObject[uiName] = buttonArr;
+            }
+        });
+        this.lookup('uiCpGrid').getStore().loadData(Object.keys(this.uiCpGitDataObject).map((uiElement) => {
+            return {'uiElement': uiElement};
+        }));
+    },
+
+    getData(newRoleName, shouldDeleteCurrentRole) {
+        Object.keys(this.uiCpGitDataContent).map((uiElId) => {
+            const uiElIdButton = this.uiCpGitDataContent[uiElId]['buttons'];
+            Object.keys(uiElIdButton).forEach((button) => {
+                if (newRoleName && !uiElIdButton[button].includes(newRoleName)) {
+                    uiElIdButton[button].push(newRoleName);
+                }
+                if (shouldDeleteCurrentRole) {
+                    const index = uiElIdButton[button].findIndex((role) => role === this.role);
+                    if (index !== -1) {
+                        uiElIdButton[button].splice(index, 1);
+                    }
+                }
+            });
+        });
+        return JSON.stringify(this.uiCpGitDataContent);
+    },
+
+    beforeEditUICPButtonRecordHandler(editor, context) {
+        if (context.value) {
+            this.deleteUICPButtonRecordHandler();
+        }
+    },
+
+    onEditUICPGridButtonHandler(store) {
+        const selection = this.lookup('uiCpGrid').getSelection()[0];
+        if (!selection) {
+            return;
+        }
+        const masterUiElement = selection.get('uiElement');
+        const buttons = store.getRange().map((record) => record.get('button'));
+        buttons.map((button) => {
+            if (!button) {
+                return;
+            }
+            const buttonsObject = this.uiCpGitDataContent[masterUiElement]['buttons'];
+            buttonsObject[button] = buttonsObject[button] || [];
+            if (!buttonsObject[button].includes(this.role)) {
+                buttonsObject[button].push(this.role);
+            }
+        });
+    },
+
+    selectUi(grid, selected) {
+        const UICPButtonsGrid = this.lookup('UICPButtonsGrid');
+        UICPButtonsGrid.getStore().removeAll();
+        if (!selected.length) {
+            return;
+        }
+        const uiButtons = this.uiCpGitDataObject[selected[0].get('uiElement')] || [];
+        uiButtons.length && UICPButtonsGrid.getStore().loadData(uiButtons.map((button) => {
+            return {'button': button};
+        }));
+        this.lookup('deleteUICPButtonRecordButton').setDisabled(true);
+    },
+
+    addUICPRecordHandler() {
+        const uiCpGrid = this.lookup('uiCpGrid');
+        const panel = Ext.widget('ReportPanel', {
+            reportId: 'UI_CUSTOM_PANELS_LIST',
+            autoFilter: true,
+            preprocessPluginConfig: (config, xtype) => !['OpenCustomPanelButtonPlugin', 'ExecuteCommandButtonPlugin',
+                'CopyRowsFromGrid', 'OpenURLButtonPlugin'].includes(xtype) && config,
+        });
+        const win = Ext.widget('WindowWrap', {
+            items: panel,
+        });
+        win.down('ReportPanel').on('itemdblclick', (_, record) => {
+            if (uiCpGrid.getStore().find('uiElement', record.get('UI_ELEMENT_CD')) === -1) {
+                uiCpGrid.getStore().add({
+                    uiElement: record.get('UI_ELEMENT_CD'),
+                });
+            }
+            uiCpGrid.setSelection(uiCpGrid.getStore().find('uiElement', record.get('UI_ELEMENT_CD')));
+            this.uiCpGitDataContent[record.get('UI_ELEMENT_CD')] = this.uiCpGitDataContent[record.get('UI_ELEMENT_CD')] || {buttons: {}};
+            win.close();
+        });
+        win.show();
+    },
+
+    addUiCPButtonHandler() {
+        this.lookup('UICPButtonsGrid').getStore().add({});
+    },
+
+    deleteUICPRecordHandler() {
+        const uiCpGrid = this.lookup('uiCpGrid');
+        const selectedRecord = uiCpGrid.selection;
+        delete this.uiCpGitDataContent[selectedRecord.get('uiElement')];
+        uiCpGrid.getStore().remove(selectedRecord);
+    },
+
+    deleteUICPButtonRecordHandler() {
+        const selectedUICPButtonRecord = this.lookup('UICPButtonsGrid').getSelection()[0];
+        const masterUiElement = this.lookup('uiCpGrid').getSelection()[0].get('uiElement');
+        const button = selectedUICPButtonRecord.get('button');
+        const buttonArray = this.uiCpGitDataContent[masterUiElement] && this.uiCpGitDataContent[masterUiElement]['buttons'][button];
+        if (buttonArray && buttonArray.length) {
+            const index = buttonArray.findIndex((role) => role === this.role);
+            index !== -1 && buttonArray.splice(index, 1);
+            if (!buttonArray.length) {
+                delete this.uiCpGitDataContent[masterUiElement]['buttons'][button];
+            }
+            if (Ext.isEmpty(this.uiCpGitDataContent[masterUiElement]['buttons'])) {
+                delete this.uiCpGitDataContent[masterUiElement];
+            }
+        }
+        this.lookup('UICPButtonsGrid').getStore().remove(selectedUICPButtonRecord);
+    },
+
+});

package/src/security/securitySettingComponent/uiCP/RoleEditUiCPPanel.js

@@ -0,0 +1,88 @@
+Ext.define('Coon.security.securitySettingComponent.uiCP.RoleEditUiCPPanel', {
+    extend: 'Ext.Panel',
+    alias: 'widget.RoleEditUiCPPanel',
+    controller: 'RoleEditUiCPController',
+    uses: [],
+    requires: [],
+
+    layout: {
+        type: 'hbox',
+        align: 'stretch',
+    },
+
+    items: [
+        {
+            xtype: 'grid',
+            flex: 1,
+            reference: 'uiCpGrid',
+            store: {},
+            columns: [
+                {dataIndex: 'uiElement', text: 'Панель', flex: 1}
+            ],
+            listeners: {
+                selectionChange: 'selectUi',
+            },
+            tbar: {
+                items: [
+                    {
+                        text: 'Добавить',
+                        ui: 'orange-button',
+                        handler: 'addUICPRecordHandler',
+                    },
+                    {
+                        text: 'Удалить',
+                        ui: 'green-button',
+                        handler: 'deleteUICPRecordHandler',
+                        disabled: true,
+                        bind: {
+                            disabled: '{!uiCpGrid.selection}',
+                        },
+                    }
+                ],
+            },
+        },
+        {
+            xtype: 'grid',
+            flex: 1,
+            reference: 'UICPButtonsGrid',
+            store: {},
+            columns: [
+                {
+                    dataIndex: 'button',
+                    text: 'Кнопки',
+                    flex: 1,
+                    editor: {
+                        xtype: 'textfield',
+                    },
+                }
+            ],
+            plugins: [
+                {
+                    ptype: 'cellediting',
+                    listeners: {
+                        beforeEdit: 'beforeEditUICPButtonRecordHandler',
+                    },
+                }
+            ],
+            tbar: {
+                items: [
+                    {
+                        text: 'Добавить',
+                        ui: 'orange-button',
+                        handler: 'addUiCPButtonHandler',
+                    },
+                    {
+                        text: 'Удалить',
+                        ui: 'green-button',
+                        handler: 'deleteUICPButtonRecordHandler',
+                        disabled: true,
+                        reference: 'deleteUICPButtonRecordButton',
+                        bind: {
+                            disabled: '{!UICPButtonsGrid.selection}',
+                        },
+                    }
+                ],
+            },
+        }
+    ],
+});