ru.coon 2.7.1 → 2.7.3

package/src/uielement/component/UiCustomController.js

@@ -64,21 +64,17 @@ Ext.define('Coon.uielement.component.UiCustomController', {
             view.tools.push({
                 tooltip: 'Скопировать ссылку на форму',
                 iconCls: 'svg-icon svg-icon-bg-white svg-icon-link',
-                callback: function() {
-                    me.copyLinkToBuffer();
-                },
+                callback: me.copyLinkToBuffer.bind(view),
             });
         }
     },
 
     copyLinkToBuffer: function() {
         const vm = this.content.getViewModel();
-        const area = document.createElement('textarea');
         const curDate = new Date(vm.get('effectiveDate'));
         const newDate = Ext.Date.format(curDate, 'Y-m-d');
         const curUrl = document.location.href;
         const curMenu = curUrl.substring(curUrl.search('#'), curUrl.length);
-
         const regUrl = '/#';
         const regIndex = curUrl.search(regUrl) + 1;
         const newUrl = curUrl.substring(0, regIndex);
@@ -87,20 +83,15 @@ Ext.define('Coon.uielement.component.UiCustomController', {
         const params = this.content.plugins.find((el) => el.ptype === 'AddDoInitSupportPlugin').parametersToModel;
         let paramsTextContent = '';
         for (let i = 0; i < params.length; i++) {
-            if (params[i] === 'effectiveDate' || vm.get(params[i]) === null) {
+            const parameter = typeof params[i] === 'string' ? params[i]: params[i]['valuePath'];
+            if (parameter === 'effectiveDate' || vm.get(parameter) === null) {
                 continue;
             }
-            paramsTextContent += params[i] + '=' + vm.get(params[i]) + '&';
+            paramsTextContent += parameter + '=' + vm.get(parameter) + '&';
         }
 
-        event.target.textContent = newUrl + curMenu + '|ui:' + ui + '?' + paramsTextContent + 'effectiveDate=' + newDate;
-        const BtnText = event.target.textContent;
-
-        event.target.appendChild(area);
-        area.value = BtnText;
-        area.select();
-        document.execCommand('copy');
-        event.target.removeChild(area);
+        const url = newUrl + curMenu + '|ui:' + ui + '?' + paramsTextContent + 'effectiveDate=' + newDate;
+        Coon.util.copyToClipboard(url);
         Ext.toast('Ссылка скопирована в буфер обмена!');
     },
     applyRestrictions(map) {

package/src/uielement/component/settings/UiAceEditor.js

@@ -173,7 +173,7 @@ Ext.define('Coon.uielement.component.settings.UiAceEditor', {
         return '';
     },
 
-    flush: function(rest) {
+    flush: function() {
         if (this.isValid()) {
             this.value = this.editor.getValue();
             this.publishState('value', this.value);

package/src/uielement/component/settings/UiAceEditorPanel.js

@@ -47,7 +47,12 @@ Ext.define('Coon.uielement.component.settings.UiAceEditorPanel', {
     },
 
     setValue(value) {
-        this.links && this.links.editor.editor.setValue(value);
+        if (this.links && this.links.editor) {
+            const editor = this.links.editor;
+            if (Ext.isFunction(editor.setValue)) {
+                editor.setValue(value);
+            }
+        }
     },
 
     initComponent() {

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

@@ -8,4 +8,23 @@
     .x-docked.x-panel-header-collapsed {
         padding: 8px 4px!important;
     }
+
+    .deletedRecord {
+        color: darkred;
+        text-decoration: line-through;
+    }
+    .readOnlyRecord {
+        .x-grid-td {
+            background-color: #f5f5f5;
+            color: #555;
+        }
+    }
+
+    .readOnlyDeletedRecord {
+        .x-grid-td {
+            color: darkred;
+            text-decoration: line-through;
+            background-color: #f5f5f5;
+        }
+    }
 }

package/src/uielement/plugin/ExecuteCommandPlugin.js

@@ -145,7 +145,7 @@ Ext.define('Coon.uielement.plugin.ExecuteCommandPlugin', {
                     fn();
                 }
             } else {
-                console.warn('Не определена команда');
+                Coon.log.warn('Не определена команда');
                 reject(new Error('Не определена команда'));
             }
         });
@@ -161,11 +161,13 @@ Ext.define('Coon.uielement.plugin.ExecuteCommandPlugin', {
         switch (this.getMappingMode()) {
         case 'map':
             for (const name in this.dataMapping) {
-                vm.set(this.dataMapping[name], data[name]);
+                vm.set(this.dataMapping[name], Coon.util.getByPath(data, name));
             }
             break;
         case 'data':
-            vm.setData(data);
+            if (Ext.isObject(data)) {
+                vm.setData(data);
+            }
         case 'object':
         default:
             let propertyPath = this.getPropertyPath();

package/src/uielement/plugin/configPanel/executeCommand/DataMappingPanel.js

@@ -0,0 +1,215 @@
+Ext.define('Coon.uielement.plugin.configPanel.executeCommand.DataMappingPanel', {
+    extend: 'Ext.grid.Panel',
+    xtype: 'DataMappingPanel',
+
+    viewModel: {
+        data: {
+            selected: 0,
+        },
+        stores: {
+            mappingGridStore: {
+                model: Ext.create('Ext.data.Model', {
+                    idProperty: 'viewModelPath',
+                    fields: [
+                        {name: 'resultPath', type: 'string'},
+                        {name: 'viewModelPath', type: 'string'}
+                    ],
+                }),
+            },
+        },
+    },
+
+    bind: {
+        store: '{mappingGridStore}',
+    },
+
+    viewConfig: {
+        getRowClass: function(rec) {
+            return rec.get('isDeleted') ? 'deletedRecord' : '';
+        },
+    },
+
+    tbar: [
+        {
+            text: 'Добавить',
+            ui: 'orange-button',
+            handler: 'onAddRow',
+        },
+        {
+            text: 'Удалить',
+            reference: 'deleteButton',
+            ui: 'blue-button',
+            bind: {
+                disabled: '{!selected}',
+            },
+            handler: 'onRemove',
+        },
+        {
+            text: '{}',
+            tooltip: 'Открыть в редакторе',
+            ui: 'blue-text-button-border',
+            handler: 'onOpenInEditor',
+        }
+    ],
+    columns: {
+        defaults: {
+            flex: 1,
+            editor: {
+                field: {
+                    xtype: 'textfield', allowBlank: false,
+                },
+            },
+        },
+        items: [
+            {
+                text: 'Путь в результате команды', dataIndex: 'resultPath',
+            },
+            {
+                text: 'Путь во viewModel', dataIndex: 'viewModelPath',
+            }
+        ],
+    },
+    plugins: [
+        {
+            ptype: 'cellediting',
+            clicksToEdit: 2,
+        }
+    ],
+    listeners: {
+        selectionchange: 'onSelectionChanged',
+    },
+
+    initComponent() {
+        this.callParent();
+        this.doInit = Ext.bind(this.getController().doInit, this.getController());
+        this.getMapping = Ext.bind(this.getController().getMapping, this.getController());
+    },
+
+    controller: {
+        doInit: function(v) {
+            if (v) {
+                const store = this.getViewModel().getStore('mappingGridStore');
+                store.loadData(this.dataForStore(v));
+            }
+        },
+
+        /**
+         * Возвращает значение маппинга
+         * @returns {string}
+         */
+        getMapping: function() {
+            const grid = this.getView();
+
+            const editor = grid.findPlugin('cellediting');
+            editor.completeEdit();
+
+            return this.dataFromStore();
+        },
+
+        /**
+         * Сериализация объекта
+         * @param {Object} data
+         * @returns {string}
+         */
+        serializeData(data) {
+            return JSON5.stringify(data, {
+                space: 4,
+                quote: '\'',
+            });
+        },
+
+        /**
+         * Возвращает сериализованные данные стора.
+         * @returns {string}
+         */
+        dataFromStore: function() {
+            const store = this.getViewModel().getStore('mappingGridStore');
+            const data = store.getRange().reduce((acc, cur) => {
+                acc[cur.get('resultPath')] = cur.get('viewModelPath');
+                return acc;
+            }, {});
+
+            return this.serializeData(data);
+        },
+
+        dataForStore: function(data) {
+            const records = [];
+            let parsed = {};
+            try {
+                parsed = JSON5.parse(data);
+            } catch (e) {
+                Coon.log.error(e);
+            }
+
+            for (const [resultPath, viewModelPath] of Object.entries(parsed)) {
+                records.push({resultPath, viewModelPath});
+            }
+
+            return records;
+        },
+
+        onAddRow: function() {
+            this.getViewModel().getStore('mappingGridStore').insert(0, {});
+            const grid = this.getView();
+            const editor = grid.findPlugin('cellediting');
+            editor.startEditByPosition({row: 0, column: 0});
+        },
+
+        onRemove: function() {
+            const grid = this.getView();
+            if (grid.getSelectionModel().getSelection()[0]) {
+                grid.getStore().remove(grid.getSelectionModel().getSelection()[0]);
+            }
+        },
+
+        onSelectionChanged: function(grid, selected) {
+            this.getViewModel().set('selected', selected.length);
+        },
+
+        onOpenInEditor: function() {
+            const editor = Ext.create('widget.ReportPropertiesAceEditor', {
+                propertyRecords: this.getDataForAceEditor(),
+            });
+            editor.on('changesComplete', this.loadChangesFromEditor, this);
+        },
+
+        getDataForAceEditor: function() {
+            return this.getViewModel().getStore('mappingGridStore').getRange()
+                .filter((record) => !record.get('isDeleted'))
+                .map((record) => {
+                    return {
+                        key: record.get('resultPath'), value: record.get('viewModelPath'),
+                    };
+                });
+        },
+
+        /**
+         * Загрузка изменений, внесенных в редакторе кода, в store.
+         * @param {Object} data
+         */
+        loadChangesFromEditor: function(data) {
+            const store = this.getViewModel().getStore('mappingGridStore');
+            const keys = new Set();
+            Object.entries(data || {}).forEach(function([key, value]) {
+                keys.add(key);
+                value = typeof value === 'string' ? value : JSON5.stringify(value);
+                const exist = store.findRecord('resultPath', key);
+                if (exist) {
+                    exist.set({viewModelPath: value, isDeleted: false});
+                } else {
+                    store.add({resultPath: key, viewModelPath: value, isNew: true});
+                }
+            }, this);
+            store.getRange()
+                .filter((el) => !keys.has(el.get('resultPath')))
+                .forEach((record) => this.deleteAction(record));
+        },
+
+        deleteAction: function(record) {
+            const store = this.getViewModel().getStore('mappingGridStore');
+            record.get('isNew') ? store.remove(record) :
+                record.set('isDeleted', !record.get('isDeleted'));
+            this.lookup('deleteButton').setText(record.get('isDeleted') ? 'Восстановить' : 'Удалить');
+        },
+    },
+});