ru.coon 2.8.12 → 2.8.13

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+# Version 2.8.13, [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/33ee197b3f9236825df8a0fca08d2b6d8b873d65)
+* TR-69125 feat: плагин ExecuteReportPlugin ([9950bc], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/9950bce3518c8edb9512d5125c3c0a7bca284c21))
+* update: CHANGELOG.md ([d117f3], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/d117f322365a1d8d5399cb1031edc2a1d9579caf))
+
 # Version 2.8.12, [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/89d48dd480147733a75d36a62408ec92070c497a)
 * ## Features
 * <span style='color:green'>feat: HT-10449: Add extra fields to plugin

package/package.json

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

package/src/uielement/plugin/ExecuteReportPlugin.js

@@ -0,0 +1,187 @@
+Ext.define('Coon.uielement.plugin.ExecuteReportPlugin', {
+    extend: 'Ext.AbstractPlugin',
+    alias: 'plugin.ExecuteReportPlugin',
+    requires: [
+        'Coon.log',
+        'Coon.Function',
+        'Coon.report.component.ErrorWindow'
+    ],
+    configurePanelWizardForFormEditor: 'ExecuteReportPluginConfigPanelFormEditor',
+    config: {
+        parameters: {},
+        handlerName: undefined,
+        ctype: undefined,
+        confirmExecution: false,
+        confirmTitle: 'Сообщение системы',
+        confirmText: 'Вы уверены, что хотите выполнить действие?',
+        successTitle: 'Операция завершена',
+        successText: 'Операция завершена успешно',
+        successMessage: false,
+        propertyPath: undefined,
+        requiredValidView: false,
+        requiredValidReference: undefined,
+        requiredValidTitle: 'Сообщение системы',
+        requiredValidMessage: 'Не все обязательные поля заполнены.',
+        saveAnimation: false,
+        disabledReference: undefined,
+        completeHandler: undefined,
+        errorHandler: undefined,
+    },
+
+    init: function(view) {
+        this.view = view;
+        if (view.getController()) {
+            view.getController()[this.handlerName] = Ext.bind(this.handler, this);
+            this.vm = view.getController().getViewModel();
+            this.disablingElement = this.disabledReference && view.getController().lookup(this.disabledReference);
+        }
+
+        if (this.disablingElement) {
+            const defaultFocus = view.getDefaultFocus();
+            defaultFocus && defaultFocus.setConfig({
+                preventRefocus: true,
+            });
+        }
+    },
+
+    parsePropertiesToArray: function(paramValue) {
+        try {
+            const paramObj = JSON5.parse(paramValue);
+            const arr = [];
+            Object.keys(paramObj).forEach((param) => arr.push({type: param, value: paramObj[param]}));
+            return arr;
+        } catch (ex) {
+            Coon.log.error(ex);
+            return;
+        }
+    },
+
+    handler: function() {
+        if (this.paramsPath && this.vm.get(this.paramsPath)) {
+            this.parameters.parameterList = JSON5.stringify(this.vm.get(this.paramsPath));
+        }
+        const parameters = Ext.decode(Ext.encode(this.parameters));
+        return new Promise((resolve, reject) => {
+            this.setDisabled(true);
+            if (this.ctype) {
+                if (this.getRequiredValidView()) {
+                    const reference = this.getRequiredValidReference();
+                    const validateView = reference ?
+                        this.view.getController().lookup(reference) :
+                        this.view;
+                    if (!validateView) {
+                        Coon.log.log('Component with reference "' + reference + '" not found. Nothing to validate');
+                        reject(new Error('Component with reference "' + reference + '" not found. Nothing to validate'));
+                        return;
+                    }
+                    if (!Coon.Function.validateAllFieldsOnForm(validateView, true)) {
+                        Ext.Msg.alert(this.getRequiredValidTitle(), this.getRequiredValidMessage());
+                        this.setDisabled(false);
+                        reject(new Error(this.getRequiredValidTitle()+ '-' + this.getRequiredValidMessage()));
+                        return;
+                    }
+                }
+
+                const commandProperties = parameters._commandProperties || {};
+                if (parameters._commandProperties) {
+                    delete parameters._commandProperties;
+                }
+                if (this.saveAnimation) {
+                    commandProperties.activeComponent = Coon.Function.getComponentForMasking(this.view);
+                }
+                const command = Ext.create('command.' + this.ctype, commandProperties);
+                const initArguments = [];
+
+                command.on('complete', function(data) {
+                    this.processData(data);
+                    resolve(data);
+                }, this);
+
+                command.processError = !!this.errorHandler;
+                command.on('failure', function(e) {
+                    this.setDisabled(false);
+                    if (this.errorHandler) {
+                        try {
+                            const controller = this.view.getController();
+                            const callback = controller[this.errorHandler];
+                            if (typeof callback !== 'function') {
+                                throw new Error(`No method named '${this.errorHandler}' on ${controller['$className']}`);
+                            }
+                            callback.call(this.view, e, this);
+                        } catch (ex) {
+                            this.processError(e);
+                            Coon.log.error(ex);
+                        }
+                    } else {
+                        reject(e);
+                    }
+                }, this);
+
+                Ext.each(command.inputParameters(), (field) => {
+                    const paramValue = parameters[field.name];
+                    if (Ext.isString(paramValue) && paramValue.startsWith('{')) {
+                        initArguments.push(this.parsePropertiesToArray(paramValue));
+                    } else {
+                        initArguments.push(paramValue);
+                    }
+                });
+                const fn = () => command.execute.apply(command, initArguments);
+
+                if (this.confirmExecution) {
+                    Ext.Msg.confirm(this.confirmTitle, this.confirmText, (btn) => btn === 'yes' && fn());
+                } else {
+                    fn();
+                }
+            } else {
+                Coon.log.warn('Не определена команда');
+                reject(new Error('Не определена команда'));
+            }
+        });
+    },
+
+    asyncHandler() {
+        return this.handler();
+    },
+
+    processData: function(response) {
+        this.setDisabled(false);
+        const vm = this.view.getController().getViewModel();
+        let data = response;
+        if (this.resultMode === 'one') {
+            data = response.list ? response.list[0] : undefined;
+        } else {
+            data = response.list;
+        }
+        let propertyPath = this.getPropertyPath();
+        if (!propertyPath) {
+            propertyPath = this.getCtype();
+        }
+        vm.set(propertyPath, data);
+        if (this.successMessage) {
+            Ext.Msg.alert(this.successTitle, this.successText);
+        }
+
+        if (this.completeHandler) {
+            try {
+                const controller = this.view.getController();
+                const callback = controller[this.completeHandler];
+                if (typeof callback !== 'function') {
+                    throw new Error(`No method named '${this.completeHandler}' on ${controller['$className']}`);
+                }
+                callback.call(this.view, data);
+            } catch (ex) {
+                Coon.log.error(ex);
+            }
+        }
+    },
+
+    setDisabled: function(value) {
+        this.disablingElement && Ext.isFunction(this.disablingElement.setDisabled) && this.disablingElement.setDisabled(value);
+    },
+
+    processError(e) {
+        Ext.widget('ErrorWindow', {
+            autoShow: true,
+        }).setFaultInfo(e.message);
+    },
+});

package/src/uielement/plugin/configPanel/executeReport/ExecuteReportPluginConfigPanelFormEditor.js

@@ -0,0 +1,445 @@
+Ext.define('Coon.uielement.plugin.configPanel.executeCommand.ExecuteReportPluginConfigPanelFormEditor', {
+    extend: 'Ext.panel.Panel',
+    alias: 'widget.ExecuteReportPluginConfigPanelFormEditor',
+    description: 'Выполняет команду GetDynamicReportDataCommand, считывает и возвращает результат выполнения запроса репорта',
+    requires: [
+        'Coon.uielement.plugin.configPanel.executeCommand.DataMappingPanel'
+    ],
+    cls: 'ExecuteReportPluginConfigPanelFormEditor',
+    viewModel: {
+        data: {
+            parameters: '{}',
+            ctype: 'GetDynamicReportDataCommand',
+            handlerName: '',
+            propertyPath: '',
+            paramsPath: '',
+            disabledReference: undefined,
+            completeHandler: undefined,
+            errorHandler: undefined,
+
+            successMessage: false,
+            successTitle: 'Операция завершена',
+            successText: 'Операция завершена успешно',
+
+
+            confirmExecution: false,
+            confirmTitle: 'Сообщение системы',
+            confirmText: 'Вы уверены, что хотите выполнить действие?',
+
+            requiredValidView: false,
+            requiredValidReference: '',
+            requiredValidTitle: 'Сообщение системы',
+            requiredValidMessage: 'Не все обязательные поля заполнены.',
+
+            saveAnimation: false,
+            resultMode: 'array',
+        },
+    },
+    referenceHolder: true,
+    reportParameters: [],
+
+    layout: {
+        type: 'vbox', align: 'stretch',
+    },
+    getData: function() {
+        return this.getConfiguration();
+    },
+    setData: function(data) {
+        data && this.doInit(data);
+    },
+    doInit: function(config) {
+        this.getViewModel().set('description', this.description);
+        for (const parameterName in config) {
+            if (!config.hasOwnProperty(parameterName) || parameterName === 'ptype') {
+                continue;
+            }
+            this.getViewModel().set(parameterName, config[parameterName]);
+        }
+    },
+
+    getConfiguration: function() {
+        const result = {};
+        const vm = this.getViewModel();
+
+        if (this.lookup('parametersRef').rendered && !vm.get('paramsPath')) {
+            if (this.lookup('parametersRef').links.editor.isJSON5Valid()) {
+                vm.set('parameters.parameterList', this.lookup('parametersRef').getValue());
+            } else {
+                Ext.Msg.alert('Ошибка', 'В параметрах присутствуют ошибки. Параметры прошлого плагина не сохранены');
+            }
+        }
+        result['parameters'] = vm.get('parameters');
+        result['propertyPath'] = vm.get('propertyPath');
+        result['paramsPath'] = vm.get('paramsPath');
+        result['handlerName'] = vm.get('handlerName');
+        result['ctype'] = vm.get('ctype');
+        if (vm.get('confirmExecution')) {
+            result['confirmExecution'] = vm.get('confirmExecution');
+            result['confirmTitle'] = vm.get('confirmTitle');
+            result['confirmText'] = vm.get('confirmText');
+        }
+        if (vm.get('completeHandler')) {
+            result['completeHandler'] = vm.get('completeHandler');
+        }
+        if (vm.get('errorHandler')) {
+            result['errorHandler'] = vm.get('errorHandler');
+        }
+        if (vm.get('disabledReference')) {
+            result['disabledReference'] = vm.get('disabledReference');
+        }
+        if (vm.get('successMessage')) {
+            result['successMessage'] = vm.get('successMessage');
+            result['successTitle'] = vm.get('successTitle');
+            result['successText'] = vm.get('successText');
+        }
+        if (vm.get('requiredValidView')) {
+            result['requiredValidView'] = vm.get('requiredValidView');
+            result['requiredValidTitle'] = vm.get('requiredValidTitle');
+            result['requiredValidMessage'] = vm.get('requiredValidMessage');
+            result['requiredValidReference'] = vm.get('requiredValidReference') ? vm.get('requiredValidReference'):undefined;
+        }
+        if (vm.get('saveAnimation')) {
+            result['saveAnimation'] = vm.get('saveAnimation');
+        }
+        if (vm.get('resultMode')) {
+            result['resultMode'] = vm.get('resultMode');
+        }
+        return result;
+    },
+
+    initComponent: function() {
+        this.items = [
+            {
+                xtype: 'pluginDescriptionLabel',
+                bind: {
+                    value: '{description}',
+                },
+            },
+            {
+                xtype: 'comboBtnWrapper',
+                combobox: {
+                    reference: 'handlerCombo',
+                    xtype: 'BaseComboBox',
+                    fieldLabel: 'handlerName',
+                    flex: 1,
+                    store: 'codeHandlers',
+                    bind: {
+                        value: '{handlerName}',
+                    },
+                    valueField: 'id',
+                    displayField: 'id',
+                },
+            },
+            {
+                fieldLabel: 'ReportCd',
+                reference: 'reportCd',
+                xtype: 'ReportLookupCombo',
+                reportId: 'REPORTS',
+                valueField: 'CM_REPORT_CD',
+                displayField: 'CM_REPORT_CD',
+                searchField: 'CM_REPORT_CD',
+                editable: true,
+                autoLoadData: false,
+                bindToModel: {
+                    CM_REPORT_CD: 'parameters.reportId',
+                },
+                bind: {
+                    value: '{parameters.reportId}',
+                },
+                listeners: {
+                    change: this.loadReportParameters.bind(this),
+                },
+            },
+            {
+                xtype: 'tabpanel',
+                flex: 1,
+                items: [
+                    {
+                        xtype: 'panel',
+                        title: 'Параметры',
+                        tooltip: 'Настройка параметров команды',
+                        layout: {
+                            type: 'vbox',
+                            align: 'stretch',
+                        },
+                        scrollable: true,
+                        items: [
+                            {
+                                xtype: 'textfield',
+                                fieldLabel: 'Путь к объекту во ViewModel с параметрами репорта (приоритетный источник)',
+                                bind: {
+                                    value: '{paramsPath}',
+                                },
+                            },
+                            {
+                                xtype: 'panel',
+                                flex: 1,
+                                layout: 'fit',
+                                tbar: [
+                                    {
+                                        xtype: 'button',
+                                        text: 'Загрузить параметры',
+                                        tooltip: 'Параметры',
+                                        ui: 'blue-text-button-border',
+                                        handler: this.setReportParametersToEditor.bind(this),
+                                        bind: {
+                                            disabled: '{paramsPath}',
+                                        },
+                                    }
+                                ],
+                                items: [
+                                    {
+                                        xtype: 'UiAceEditorPanel',
+                                        reference: 'parametersRef',
+                                        title: 'Настроить параметры вручную',
+                                        hideSearchPanel: true,
+                                        bind: {
+                                            disabled: '{paramsPath}',
+                                            value: '{parameters.parameterList}',
+                                        },
+                                    }
+                                ],
+                            }
+                        ],
+                    },
+                    {
+                        xtype: 'panel',
+                        title: 'Настройки',
+                        layout: {
+                            type: 'vbox',
+                            align: 'stretch',
+                        },
+                        scrollable: true,
+                        items: [
+                            {
+                                xtype: 'checkbox',
+                                boxLabel: 'successMessage',
+                                boxLabelAlign: 'after',
+                                padding: '0 0 0 10',
+                                bind: '{successMessage}',
+                            },
+                            {
+                                xtype: 'textfield',
+                                fieldLabel: 'successText',
+                                bind: {
+                                    value: '{successText}',
+                                    visible: '{successMessage}',
+                                },
+                            },
+                            {
+                                xtype: 'textfield',
+                                fieldLabel: 'successTitle',
+                                bind: {
+                                    value: '{successTitle}',
+                                    visible: '{successMessage}',
+                                },
+                            },
+                            {
+                                xtype: 'checkbox',
+                                boxLabel: 'confirmExecution',
+                                boxLabelAlign: 'after',
+                                padding: '0 0 0 10',
+                                bind: '{confirmExecution}',
+                            },
+                            {
+                                xtype: 'textfield',
+                                fieldLabel: 'confirmText',
+                                bind: {
+                                    value: '{confirmText}',
+                                    visible: '{confirmExecution}',
+                                },
+                            },
+                            {
+                                xtype: 'checkbox',
+                                padding: '0 0 0 10',
+                                boxLabel: 'saveAnimation',
+                                bind: {
+                                    value: '{saveAnimation}',
+                                },
+                            },
+                            {
+                                xtype: 'textfield',
+                                fieldLabel: 'confirmTitle',
+                                bind: {
+                                    value: '{confirmTitle}',
+                                    visible: '{confirmExecution}',
+                                },
+                            },
+                            {
+                                xtype: 'checkbox',
+                                boxLabel: 'нужна ли валидация view[requiredValidView]',
+                                boxLabelAlign: 'after',
+                                padding: '0 0 0 10',
+                                bind: '{requiredValidView}',
+                            },
+                            {
+                                xtype: 'textfield',
+                                fieldLabel: 'референс компонента для валидации[requiredValidReference]',
+                                bind: {
+                                    value: '{requiredValidReference}',
+                                    visible: '{requiredValidView}',
+                                },
+                            },
+                            {
+                                xtype: 'textfield',
+                                fieldLabel: 'requiredValidMessage',
+                                bind: {
+                                    value: '{requiredValidMessage}',
+                                    visible: '{requiredValidView}',
+                                },
+                            },
+                            {
+                                xtype: 'textfield',
+                                fieldLabel: 'requiredValidTitle',
+                                bind: {
+                                    value: '{requiredValidTitle}',
+                                    visible: '{requiredValidView}',
+                                },
+                            },
+                            {
+                                xtype: 'textfield',
+                                fieldLabel: 'disabledReference',
+                                bind: '{disabledReference}',
+                                description: `Здесь при необходимости указывается reference, который при выполнении команды блокируется.
+                                Частый вариант использования - блокировка повторного нажатия кнопки, которая вызывает выполнение команды. `,
+                                triggers: {
+                                    help: {
+                                        cls: 'x-fa fa-question helpicon',
+                                        handler: this.showDescription,
+                                    },
+                                },
+                            }
+                        ],
+                    },
+                    {
+                        title: 'Отражение результатов',
+                        scrollable: true,
+                        tooltip: 'Отражение результатов команды во viewModel',
+                        layout: {
+                            type: 'vbox',
+                            align: 'stretch',
+                        },
+                        items: [
+                            {
+                                xtype: 'radiogroup',
+                                fieldLabel: 'Количество строк из результата выполнения отчета, которые надо положить во ViewModel',
+                                reference: 'resultMode',
+                                columns: 2,
+                                simpleValue: true,
+                                bind: '{resultMode}',
+                                items: [
+                                    {boxLabel: 'Одна строка', name: 'resultMode', inputValue: 'one'},
+                                    {boxLabel: 'Все строки', name: 'resultMode', inputValue: 'array', checked: true}
+                                ],
+                            },
+                            {
+                                xtype: 'textfield',
+                                fieldLabel: 'completeHandler',
+                                bind: '{completeHandler}',
+                            },
+                            {
+                                xtype: 'textfield',
+                                fieldLabel: 'errorHandler',
+                                bind: '{errorHandler}',
+                            },
+                            {
+                                xtype: 'textfield',
+                                fieldLabel: 'propertyPath',
+                                bind: {
+                                    value: '{propertyPath}',
+                                },
+                            }
+                        ],
+                    }
+                ],
+            }
+        ];
+        this.callParent();
+    },
+
+    showDescription: function(cmp) {
+        Ext.Msg.alert('Описание свойства', cmp.description);
+    },
+
+    /**
+     * Считывание параметров репорта. Запускается при открытии редактора или смене репорта
+     */
+    loadReportParameters: function() {
+        const reportId = this.lookup('reportCd').getValue();
+
+        if (reportId) {
+            const command = Ext.create('command.GetReportCommand');
+
+            command.on('complete', function(bean) {
+                const reportParameters = bean['parameters'];
+                if (reportParameters) {
+                    this.reportParameters = this.parseReportParameters(reportParameters);
+                }
+            }, this);
+
+            command.execute(reportId);
+        }
+    },
+
+    /**
+     * Вывод параметров текущего репорта в редактор
+     */
+    setReportParametersToEditor: function() {
+        const vm = this.getViewModel();
+        const currentParameters = this.lookup('parametersRef').getValue() ? JSON5.parse(this.lookup('parametersRef').getValue()) : {};
+        this.reportParameters.forEach((param) => {
+            if (!currentParameters.hasOwnProperty(param['name'])) {
+                currentParameters[param['name']] = '';
+            }
+        });
+        const stringParam = JSON5.stringify(currentParameters, {
+            space: 4,
+            quote: '\'',
+        });
+
+        vm.set('parameters.parameterList', stringParam);
+        this.checkParameters(currentParameters);
+    },
+
+    /**
+     * Преобразование параметров репорта из структуры, которую вернула команда, в массив объектов
+     * @param [{Object}] reportParameters
+     */
+    parseReportParameters: function(reportParameters) {
+        const params = [];
+        reportParameters.forEach((param) => {
+            params.push({name: param['reportParameterCd'], required: param['requiredSwitch']});
+        });
+        return params;
+    },
+
+    /**
+     * Проверка текущих параметров. Не должно быть параметров, которые не определены у репорта
+     * @param {Object} currentParameters
+     */
+    checkParameters: function(currentParameters) {
+        const reportId = this.lookup('reportCd').getValue();
+        const wrongParameters = Object.keys(currentParameters)
+            .filter((name) => !this.reportParameters.find((parameter) => parameter['name'] === name));
+        let goodParametersStr = this.reportParameters
+            .reduce((acc, cur) => {
+                const required = cur.required ? 'обязательный' : 'не обязательный';
+                acc.push(`<li> ${cur.name} - ${required} </li>`);
+                return acc;
+            }, [])
+            .join('<br>');
+
+        if (wrongParameters.length) {
+            const paramsString = `<span class="wrong-parameters"> ${wrongParameters.join(', ')} </span>`;
+            goodParametersStr = `<ul class="wrong-parameters"> ${goodParametersStr} </ul>`;
+            Ext.Msg.show({
+                title: 'Внимание!',
+                message: `Следующие параметры: <br> ${paramsString} <br> не являются параметрами репорта ${reportId}.
+                <p>Список параметров репорта: ${goodParametersStr}</p>
+                `,
+                buttons: Ext.Msg.YES,
+                cls: 'ExecuteReportPluginConfigPanelFormEditor',
+            });
+        }
+    },
+});

package/src/uielement/plugin/configPanel/executeReport/ExecuteReportPluginConfigPanelFormEditor.scss

@@ -0,0 +1,22 @@
+.ExecuteReportPluginConfigPanelFormEditor {
+  $required-flag-color: dynamic(#bf1313);
+  font-size: 12px;
+  margin: 5px;
+  .required-flag {
+    font-size: 18px;
+    color: $required-flag-color;
+  }
+  span.code {
+    color: green;
+    font-family: "Lucida Console", "Courier New", monospace;
+  }
+  .x-form-trigger-default.helpicon {
+    background-color: white;
+  }
+
+  .wrong-parameters {
+    color: green;
+    font-style: italic;
+    font-family: "Lucida Console", "Courier New", monospace;
+  }
+}

package/src/version.js

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