ru.coon 2.7.32 → 2.7.34

package/src/security/securitySettingComponent/RoleEditPanel.js

@@ -0,0 +1,83 @@
+Ext.define('Coon.security.securitySettingComponent.RoleEditPanel', {
+    extend: 'Ext.panel.Panel',
+    requires: [],
+
+    controller: 'RoleEditPanelController',
+    layout: {
+        type: 'vbox',
+        align: 'stretch',
+    },
+    dockedItems: [{
+        xtype: 'toolbar',
+        dock: 'bottom',
+        layout: {
+            type: 'hbox',
+        },
+        items: [
+            {
+                xtype: 'button',
+                text: 'Переименовать роль',
+                ui: 'green-button',
+                handler: 'changeRoleNameHandler',
+            },
+            {
+                xtype: 'button',
+                text: 'Копировать роль',
+                ui: 'green-button',
+                handler: 'copyRoleHandler',
+            },
+            {
+                xtype: 'button',
+                text: 'Удалить роль',
+                ui: 'green-button',
+                handler: 'deleteHandler',
+            },
+            '->',
+            {
+                xtype: 'button',
+                text: 'Сохранить',
+                ui: 'orange-button',
+                handler: 'save',
+            },
+            {
+                xtype: 'button',
+                text: 'Закрыть',
+                ui: 'green-button',
+                handler: 'closeHandler',
+            }
+        ],
+    }],
+    items: [
+        {
+            xtype: 'tabpanel',
+            flex: 1,
+            items: [
+                {
+                    xtype: 'RoleEditMenuPanel',
+                    title: 'Навигация (меню)',
+                    reference: 'menuGrid',
+                },
+                {
+                    xtype: 'RoleEditReportPanel',
+                    title: 'Репорты',
+                    reference: 'reportsGridPanel',
+                },
+                {
+                    xtype: 'RoleEditUiCPPanel',
+                    title: 'Кастомные панели',
+                    reference: 'uiCPGridPanel',
+                },
+                {
+                    xtype: 'RoleEditUrlPanel',
+                    title: 'Url',
+                    reference: 'urlGrid',
+                },
+                {
+                    xtype: 'RoleEditUserPanel',
+                    title: 'Пользователи',
+                    reference: 'userNameGrid',
+                }
+            ],
+        }
+    ],
+});

package/src/security/securitySettingComponent/RoleEditPanel.scss

@@ -0,0 +1,17 @@
+.RoleEditPanel {
+  .x-grid-item {
+    .checked-row {
+      background-color: #f7f7f8;
+    }
+  }
+  .x-grid-item {
+    .unchecked-row {
+      background-color: white;
+    }
+  }
+  .x-grid-row {
+      &:hover {
+        background-color: #ebecee;
+      }
+  }
+}

package/src/security/securitySettingComponent/RoleEditPanelController.js

@@ -0,0 +1,211 @@
+Ext.define('Coon.security.securitySettingComponent.RoleEditPanelController', {
+    extend: 'Ext.app.ViewController',
+    requires: [
+        'Coon.report.command.GetDynamicReportDataCommand'
+    ],
+
+    alias: 'controller.RoleEditPanelController',
+
+    paths: {
+        menuByRole: 'policy/menu_by_role/data.json',
+        reportPlugin: 'policy/report_plugin_by_role/data.json',
+        uiElement: 'policy/UI_ELEMENT/data.json',
+        urlPattern: 'policy/url_pattern/data.json',
+        roleByUser: 'policy/role_by_user/data.json',
+    },
+
+    init(view) {
+        this.view = view;
+    },
+
+    doInit(role, isNew) {
+        this.role = role;
+        this.view.setTitle(`Редактирование роли ${role}`);
+        if (isNew) {
+            this.lookup('menuGrid').getController().loadAllMenuData([], this.role);
+        } else {
+            this.getGitData().then(this.processGitData.bind(this)).finally(() => this.view.unmask()); ;
+        }
+    },
+
+    getGitData() {
+        this.view.mask('Загрузка');
+        const params = new URLSearchParams();
+        const pathsArray = Object.values(this.paths);
+        pathsArray.forEach((path) => params.append('paths', path));
+        return new Promise((resolve, reject) => {
+            Coon.Function.doRequest(null, {
+                url: 'git/opa/downloadBulk',
+                processError: true,
+                params: params,
+                callback: (a, b, res) => resolve(res.responseText),
+                failure: (a, b, res) => {
+                    reject(new Error(res.responseJSON.message));
+                },
+            });
+        });
+    },
+
+    processGitData(data) {
+        const gitData = JSON.parse(data);
+        this.menuGitDataContent = JSON.parse(gitData.find((el) => el.path === this.paths['menuByRole']).content);
+        this.lookup('menuGrid').getController().loadAllMenuData(this.menuGitDataContent, this.role);
+        this.reportGitDataContent = JSON.parse(gitData.find((el) => el.path === this.paths['reportPlugin']).content);
+        this.lookup('reportsGridPanel').getController().loadReportData(this.reportGitDataContent, this.role);
+        this.uiCpGitDataContent = JSON.parse(gitData.find((el) => el.path === this.paths['uiElement']).content);
+        this.lookup('uiCPGridPanel').getController().loadUiCPData(this.uiCpGitDataContent, this.role);
+        this.urlGitDataContent = JSON.parse(gitData.find((el) => el.path === this.paths['urlPattern']).content);
+        this.lookup('urlGrid').getController().loadUrlData(this.urlGitDataContent, this.role);
+        this.userRoleGitDataContent = JSON.parse(gitData.find((el) => el.path === this.paths['roleByUser']).content);
+        this.lookup('userNameGrid').getController().loadUserData(this.userRoleGitDataContent, this.role);
+    },
+
+    save() {
+        this.saveHandler();
+    },
+
+    saveHandler(newRoleName, shouldDeleteCurrentRole) {
+        const dataToSave = [
+            {
+                path: this.paths['menuByRole'],
+                content: this.lookup('menuGrid').getController().getData(newRoleName, shouldDeleteCurrentRole),
+            },
+            {
+                path: this.paths['reportPlugin'],
+                content: this.lookup('reportsGridPanel').getController().getData(newRoleName, shouldDeleteCurrentRole),
+            },
+            {
+                path: this.paths['uiElement'],
+                content: this.lookup('uiCPGridPanel').getController().getData(newRoleName, shouldDeleteCurrentRole),
+            },
+            {
+                path: this.paths['urlPattern'],
+                content: this.lookup('urlGrid').getController().getData(newRoleName, shouldDeleteCurrentRole),
+            },
+            {
+                path: this.paths['roleByUser'],
+                content: this.lookup('userNameGrid').getController().getData(newRoleName, shouldDeleteCurrentRole),
+            }
+        ];
+        this.showCommitMessageWindow(dataToSave);
+    },
+
+    deleteHandler() {
+        this.saveHandler(undefined, true);
+    },
+
+    createWindow(title, fieldlabel, handler) {
+        return Ext.widget('WindowWrap', {
+            items:
+                {
+                    xtype: 'form',
+                    itemId: 'form',
+                    padding: 10,
+                    layout: 'anchor',
+                    items: [
+                        {
+                            fieldLabel: fieldlabel,
+                            name: 'valueField',
+                            anchor: '100%',
+                            xtype: 'textfield',
+                            allowBlank: false,
+                            maxLength: 100,
+                        }
+                    ],
+                },
+            height: 300,
+            width: 400,
+            maximizable: false,
+            dockedItems: [{
+                xtype: 'toolbar',
+                dock: 'bottom',
+                items: ['->',
+                    {
+                        xtype: 'button',
+                        ui: 'orange-button',
+                        text: 'Сохранить',
+                        handler,
+                    },
+                    {
+                        xtype: 'button',
+                        ui: 'orange-button',
+                        text: 'Отмена',
+                        handler() {
+                            this.up('window').close();
+                        },
+                    }
+                ],
+            }],
+            title: title,
+        });
+    },
+
+    showChangeRoleNameWindow(shouldDeleteCurrentRole) {
+        const handler = () => {
+            const role = form.getValues().valueField;
+            if (role && this.menuGitDataContent[role]) {
+                Ext.Msg.alert('Предупреждение', 'Роль с таким именем уже существует.');
+                return;
+            }
+            win.close();
+            this.saveHandler(role, shouldDeleteCurrentRole);
+        };
+        const win = this.createWindow('Изменения имени роли', 'Роль', handler);
+        const form = win.getComponent('form');
+        win.show();
+    },
+
+
+    showCommitMessageWindow(data) {
+        const handler = () => {
+            const commitMessage = form.getValues().valueField;
+            win.close();
+            this.view.mask('Сохранение');
+            this.commitAndPushData(data, commitMessage)
+                .then(() => {
+                    this.view.unmask();
+                    this.view.fireEvent('save');
+                    this.closeHandler();
+                })
+                .catch((error) => {
+                    this.view.unmask();
+                    Ext.Msg.alert('Ошибка', error.message);
+                });
+        };
+        const win = this.createWindow('Commit Message', 'text', handler);
+        const form = win.getComponent('form');
+        win.show();
+    },
+
+    commitAndPushData(data, commitMessage) {
+        const bean = {
+            elementList: data,
+            commitMessage: commitMessage,
+        };
+        return new Promise((resolve, reject) => {
+            Coon.Function.doRequest(null, {
+                url: 'git/opa/uploadBulk',
+                processError: true,
+                jsonData: JSON.stringify(bean),
+                callback: (a, b, res) => resolve(res.responseText),
+                failure: (a, b, res) => {
+                    this.view.unmask();
+                    reject(new Error(res.responseJSON.message));
+                },
+            });
+        });
+    },
+
+    changeRoleNameHandler() {
+        this.showChangeRoleNameWindow(true);
+    },
+
+    copyRoleHandler() {
+        this.showChangeRoleNameWindow(false);
+    },
+
+    closeHandler() {
+        this.view.close();
+    },
+
+});

package/src/security/securitySettingComponent/RoleListPanel.js

@@ -0,0 +1,35 @@
+Ext.define('Coon.security.securitySettingComponent.RoleListPanel', {
+    extend: 'Ext.grid.Panel',
+    requires: [],
+    viewModel: {},
+
+    xtype: 'RoleListPanel',
+
+    controller: 'RoleListPanelController',
+
+    tbar: [
+        {
+            iconCls: 'svg-icon svg-icon-update-arrows',
+            handler: 'loadRoleXml',
+        },
+        {
+            text: 'добавить роль',
+            handler: 'addRole',
+        },
+        {
+            text: 'редактировать роль',
+            handler: 'editRole',
+        }
+    ],
+    columns: [
+        {
+            dataIndex: 'role',
+            flex: true,
+        }
+    ],
+    store: {},
+
+    listeners: {
+        rowdblclick: 'editRole',
+    },
+});

package/src/security/securitySettingComponent/RoleListPanelController.js

@@ -0,0 +1,240 @@
+Ext.define('Coon.security.securitySettingComponent.RoleListPanelController', {
+    extend: 'Ext.app.ViewController',
+
+    requires: [
+        'Coon.Function'
+    ],
+
+    alias: 'controller.RoleListPanelController',
+
+    cachedRecordId: 'componentOpaData',
+    paths: {
+        menuByRole: 'policy/menu_by_role/data.json',
+    },
+
+    init(view) {
+        this.view = view;
+        this.verify();
+        this.on('validated', this.loadRoleXml, this);
+    },
+
+    verify() {
+        this.validate()
+            .then(() => {
+                this.isValid = true;
+            })
+            .catch((e) => {
+                this.isValid = false;
+                Ext.Msg.alert('Ошибка', e);
+            });
+    },
+
+    validate() {
+        const data = this.getCached();
+        const me = this;
+        return new Promise((resolve, reject) => {
+            if (data) {
+                Coon.Function.doRequest(null, {
+                    url: 'personification/personify',
+                    processError: true,
+                    params: {
+                        token: data,
+                    },
+                    callback(win, res, resp) {
+                        me.fireEvent('validated');
+                        resolve(resp.status === 200);
+                    },
+                    failure(_, __, res) {
+                        me.clearCache();
+                        me.verify();
+                        reject(new Error(res.responseJSON.message));
+                    },
+                });
+            } else {
+                this.generateToken();
+            }
+        });
+    },
+
+    loadRoleXml() {
+        if (!this.isValid) {
+            this.verify();
+        } else {
+            this.view.mask();
+            return Coon.util.promisifyCmd('command.GitOpaDownloadCommand', this.paths['menuByRole'])
+                .then((data) => {
+                    const roles = Object.keys(data).map((role) => {
+                        return {'role': role};
+                    });
+                    this.view.unmask();
+                    this.view.getStore().loadData(roles);
+                })
+                .catch((e) => {
+                    this.view.unmask();
+                    Ext.Msg.show({
+                        title: 'Ошибка',
+                        message: `${e.message}<br>Сгенерировать токен повторно?`,
+                        buttons: Ext.Msg.OKCANCEL,
+                        fn: (btn) => {
+                            if (btn === 'ok') {
+                                this.clearCache();
+                                this.verify();
+                            }
+                        },
+                    });
+                });
+        }
+    },
+
+    generateToken() {
+        const me = this;
+        const generateJwt = (gitToken, email) => {
+            return new Promise((resolve, reject) => {
+                Coon.Function.doRequest(null, {
+                    url: 'git/opa/generateToken',
+                    params: {gitToken, email},
+                    callback: (a, b, res) => resolve(res.responseText),
+                    failure: () => {
+                        reject(new Error('Token generation error.'));
+                    },
+                });
+            });
+        };
+        const handler = () => {
+            const form = win.getComponent('form');
+            const gitToken = form.getValues().gitToken;
+            const email = form.getValues().email;
+            generateJwt(gitToken, email).then((data) => {
+                me.cacheToken(data);
+                this.validate()
+                    .then(() => {
+                        this.isVerified = true;
+                    })
+                    .catch((e) => {
+                        Ext.Msg.alert('Ошибка', e.message);
+                        this.generateToken();
+                    });
+                win.close();
+            });
+        };
+        const items = [
+            {
+                fieldLabel: 'gitToken',
+                name: 'gitToken',
+                anchor: '100%',
+                xtype: 'textfield',
+                allowBlank: false,
+                maxLength: 100,
+            },
+            {
+                fieldLabel: 'email',
+                name: 'email',
+                anchor: '100%',
+                xtype: 'EmailField',
+                allowBlank: false,
+                maxLength: 100,
+            }
+        ];
+        const win = this.createWindow('Генерация jwt токена', items, handler);
+        win.show();
+    },
+
+    cacheToken(data) {
+        localStorage.setItem(this.cachedRecordId, Ext.encode(data));
+    },
+
+    getCached() {
+        const cachedData = localStorage.getItem(this.cachedRecordId);
+        return cachedData && Ext.decode(cachedData, true);
+    },
+
+    clearCache() {
+        localStorage.removeItem(this.cachedRecordId);
+    },
+
+    addRole() {
+        const handler = () => {
+            const role = form.getValues()['roleField'];
+            this.getView().getStore().add({
+                isNew: true,
+                role: role,
+            });
+            win.close();
+        };
+        const items = [
+            {
+                fieldLabel: 'Роль',
+                name: 'roleField',
+                anchor: '100%',
+                xtype: 'textfield',
+                allowBlank: false,
+                maxLength: 100,
+            }
+        ];
+        const win = this.createWindow('Создание роли', items, handler);
+        const form = win.getComponent('form');
+        win.show();
+    },
+
+    editRole() {
+        const selection = this.view.selection;
+        if (!selection) {
+            return;
+        }
+        const role = selection.get('role');
+        const isNew = selection.get('isNew');
+        const roleEditPanel = Ext.create('Coon.security.securitySettingComponent.RoleEditPanel', {});
+        const win = Ext.widget('WindowWrap', {
+            maximized: true,
+            maximizable: false,
+            items: roleEditPanel,
+        });
+        roleEditPanel.on('save', this.loadRoleXml, this);
+        win.show();
+        roleEditPanel.getController().doInit(role, isNew);
+    },
+
+    createWindow(title, items, handler) {
+        return Ext.widget('WindowWrap', {
+            items:
+                {
+                    xtype: 'form',
+                    itemId: 'form',
+                    padding: 10,
+                    layout: 'anchor',
+                    keyMapEnabled: true,
+                    keyMap: {
+                        Enter: {
+                            handler,
+                        },
+                    },
+                    items: items,
+                },
+            height: 300,
+            width: 400,
+            maximizable: false,
+            dockedItems: [{
+                xtype: 'toolbar',
+                dock: 'bottom',
+                items: ['->',
+                    {
+                        xtype: 'button',
+                        ui: 'orange-button',
+                        text: 'Сохранить',
+                        handler,
+                    },
+                    {
+                        xtype: 'button',
+                        ui: 'orange-button',
+                        text: 'Отмена',
+                        handler() {
+                            this.up('window').close();
+                        },
+                    }
+                ],
+            }],
+            title: title,
+        });
+    },
+
+});

package/src/security/securitySettingComponent/command/GitOpaDownloadCommand.js

@@ -0,0 +1,33 @@
+Ext.define('Coon.security.securitySettingComponent.command.GitOpaDownloadCommand', {
+    extend: 'Coon.command.ASyncBaseCommand',
+    alias: 'command.GitOpaDownloadCommand',
+    requires: [],
+    uses: [],
+    url: 'git/opa/download',
+    maskText: 'Загрузка....',
+
+    execute: function(path, branch, commitId) {
+        const inputData = {
+            path: path,
+            branch: branch,
+            commitId: commitId,
+        };
+        const data = Object.entries(inputData).reduce((acc, [name, val]) => {
+            if (val) {
+                acc[name] = val;
+            }
+            return acc;
+        }, {});
+        this.callParent([data]);
+    },
+
+    description: 'Получение содержимого файла',
+
+    inputParameters: function() {
+        return [
+            {name: 'path'},
+            {name: 'branch'},
+            {name: 'commitId'}
+        ];
+    },
+});