ru.coon 2.5.63 → 2.5.65

package/src/report/plugin/configPanel/GridEditorPluginConfig.js

@@ -21,33 +21,206 @@ Ext.define('Coon.report.plugin.configPanel.GridEditorPluginConfig', {
     },
 
     createItems: function() {
-        this.grid = Ext.create('Coon.report.plugin.configPanel.GridEditorPluginConfigGrid', {
+        this.layout = 'fit';
+        this.fieldEditor = this.createFieldColumns({
+            hideLabel: true,
+            allowBlank: false,
+        });
+        const ns = Coon.report.model.CharacteristicBeanFields;
+        this.grid = Ext.create('Ext.grid.Panel', {
             flex: 1,
-            fieldEditor: this.createFieldColumns({
-                hideLabel: true,
-                allowBlank: false,
-            }),
+            region: 'center',
+            store: {
+                type: 'json',
+                data: [],
+            },
+            tbar: {
+                defaults: {
+                    margin: 5,
+                },
+                items: [
+                    {
+                        xtype: 'button',
+                        text: 'Добавить',
+                        ui: 'blue-text-button-border',
+                        handler: Ext.bind(this.addHandler, this),
+                    },
+                    {
+                        xtype: 'button',
+                        text: 'Удалить',
+                        ui: 'blue-text-button-border',
+                        handler: Ext.bind(this.deleteHandler, this),
+                    }
+                ],
+            },
+            columns: [
+                {
+                    header: 'Поле',
+                    dataIndex: ns.$type,
+                    xtype: 'hintColumn',
+                    editor: this.fieldEditor,
+                    flex: 1,
+                }
+            ],
+            plugins: [
+                {ptype: 'cellediting', clicksToEdit: 2}
+            ],
+            listeners: {
+                select: function(grid, record) {
+                    Coon.Function.clearAllFieldsOnForm(this.editForm);
+                    const recordConfig = this.editorConfig.find((el) => el.type === record.get(ns.$type));
+                    Coon.Function.fillFormFields(this.editForm, recordConfig);
+                    if (recordConfig[ns.$mask]) {
+                        this.editForm.down('UiAceEditor').setValue(recordConfig[ns.$mask]);
+                    }
+                    this.editForm.setDisabled(!record);
+                }.bind(this),
+                deselect: this.setEditorConfig.bind(this),
+            },
         });
 
-        return [
-            this.grid
-        ];
+        this.editForm = Ext.create({
+            xtype: 'form',
+            region: 'east',
+            header: {
+                title: 'Редактор',
+                height: 55,
+            },
+            disabled: true,
+            flex: 2,
+            defaults: {
+                margin: 10,
+                anchor: '100%',
+            },
+            items: [
+                {
+                    fieldLabel: 'Тип редактора',
+                    name: ns.$typeOfValue,
+                    xtype: 'lookupCombo',
+                    lookupId: 'ADHOC_CHAR_TYPE_FLG',
+                    submitFormat: false,
+                    allowBlank: false,
+                    loadOnRender: false,
+                },
+                {
+                    boxLabel: 'Значение обязательно',
+                    name: ns.$required,
+                    xtype: 'checkbox',
+                },
+                {
+                    title: 'Редактировать в зависимости от поля',
+                    xtype: 'fieldset',
+                    checkboxName: 'dependsOnField',
+                    checkboxToggle: true,
+                    layout: {
+                        type: 'vbox',
+                        align: 'stretch',
+                    },
+                    defaults: {
+                        flex: 1,
+                    },
+                    items: [
+                        {
+                            xtype: 'checkbox',
+                            boxLabel: 'Редактировать если значение поля false/пусто',
+                            name: 'invertValue',
+                        },
+                        this.createFieldColumns({
+                            name: 'dependsOnFieldName',
+                        }),
+                        {
+                            boxLabel: 'Выделить редактируемые ячейки',
+                            name: 'highlightEditableCells',
+                            xtype: 'checkbox',
+                        }
+                    ],
+                },
+                {
+                    xtype: 'fieldset',
+                    title: 'Конфиг',
+                    height: 200,
+                    items: [
+                        {
+                            xtype: 'UiAceEditor',
+                            useLinter: true,
+                            scrollable: 'y',
+                            name: ns.$mask,
+                            value: {},
+                        }
+                    ],
+                }
+            ],
+        });
+
+        return [{
+            frame: true,
+            align: 'stretch',
+            layout: 'border',
+            defaults: {
+                split: true,
+                border: false,
+            },
+            items: [
+                this.grid,
+                this.editForm
+            ],
+        }];
     },
 
     doInit: function(properties) {
         if (properties) {
-            let editorConfig = properties['editorConfig'];
-            if (Ext.isString(editorConfig)) {
-                editorConfig = Ext.decode(editorConfig);
+            this.editorConfig = properties['editorConfig'];
+            if (Ext.isString(this.editorConfig)) {
+                this.editorConfig = Ext.decode(this.editorConfig);
             }
-            this.grid.doInit(editorConfig);
+            if (!Ext.isEmpty(this.editorConfig) && !Ext.isArray(this.editorConfig)) {
+                this.editorConfig = [this.editorConfig];
+            }
+            this.grid.getStore().loadData(this.editorConfig || []);
         }
     },
 
-    getConfiguration: function() {
-        const config = Coon.Function.getDataFromForm(this);
-        config['editorConfig'] = this.grid.getData();
+    addHandler: function() {
+        const ns = Coon.report.model.CharacteristicBeanFields;
+        const data = {};
+        data[ns.$entity] = 'ADV';
+        const newRecord = Ext.create('Coon.report.model.CharacteristicBean', data);
+        this.grid.getStore().add(newRecord);
+        const editor = this.grid.findPlugin('cellediting');
+        editor.startEditByPosition({row: this.grid.getStore().getCount() - 1, column: 0});
+    },
+
+    deleteHandler: function() {
+        const record = this.grid.getSelectionModel().getSelection()[0];
+        if (!record) {
+            return;
+        }
+        record.set('isDeleted', true);
+        const foundIndex = this.editorConfig.findIndex((el) => el.type === record.get('type'));
+        this.editorConfig.splice(foundIndex, 1);
+        Coon.Function.clearAllFieldsOnForm(this.editForm);
+        this.editForm.setDisabled(true);
+        this.grid.getStore().remove(record);
+    },
 
+    setEditorConfig: function() {
+        const ns = Coon.report.model.CharacteristicBeanFields;
+        const record = this.grid.getSelection()[0];
+        if (!record || record.get('isDeleted')) {
+            return;
+        }
+        record.set(ns.$mask, this.editForm.down('UiAceEditor').getValue());
+        const foundIndex = this.editorConfig.findIndex((el) => el.type === record.get(ns.$type));
+        const deleteCount = foundIndex === -1 ? 0 : 1;
+        const position = foundIndex === -1 ? this.editorConfig.length : foundIndex;
+        this.editorConfig.splice(position, deleteCount, Object.assign(
+            record.getData(),
+            Coon.Function.getDataFromForm(this.editForm)));
+    },
+
+    getConfiguration: function() {
+        this.setEditorConfig();
+        const config = {editorConfig: this.editorConfig};
         return config;
     },
 });

package/src/report/plugin/configPanel/GridEditorPluginConfigPanel.js

@@ -0,0 +1,22 @@
+Ext.define('Coon.report.plugin.configPanel.GridEditorPluginConfigPanel', {
+    extend: 'Coon.report.plugin.configPanel.BasePluginConfig',
+    alias: 'widget.GridEditorPluginConfigPanel',
+    uses: [],
+    requires: [
+        'Coon.Function'
+    ],
+    alternateClassName: 'Sigma.common.grid.plugin.configPanel.GridEditorPluginConfig',
+
+    description: 'Плагин позволяет задать редактор для столбцов',
+    tags: ['Редактирование'],
+
+    config: {
+        pluginTypeSettings: {
+            defaultType: 'GRID_PLUGIN',
+            allowedTypes: [
+                'GRID_PLUGIN'
+            ],
+        },
+    },
+
+});

package/src/report/plugin/configPanel/selectionModelFeature/SelectionModelFeatureConfigPanel.js

@@ -1,7 +1,7 @@
 Ext.define('Coon.report.plugin.configPanel.selectionModelFeature.SelectionModelFeatureConfigPanel', {
     extend: 'Coon.report.plugin.configPanel.PluginDefaults',
     alias: 'widget.SelectionModelFeatureConfigPanel',
-
+    requires: ['Ext.selection.MixedRowSelectionModel'],
     pluginType: 'SelectionModelPlugin',
     description: 'Настройки SelectionModel',
     tags: ['Поведение', 'Выделение'],

package/src/report/plugin/grid/GridEditorsPlugin.js

@@ -58,6 +58,9 @@ Ext.define('Coon.report.plugin.grid.GridEditorsPlugin', {
                 }
             }
         }
+        hasEditor.on('beforeedit', function(editor, context) {
+            return context.record.allowEditWithEditorPlugin;
+        }, this);
     },
 
     createEditorItem: function(configuration) {
@@ -134,6 +137,20 @@ Ext.define('Coon.report.plugin.grid.GridEditorsPlugin', {
         editor.on('beforeedit', function() {
             Ext.emptyFn();
         }, this);
+        let editable = true;
+        if (configuration['dependsOnField'] && configuration['dependsOnFieldName']) {
+            const editableColumn = this.grid.getColumns().find((col) => col.dataIndex === configuration[ns.$type]);
+            editableColumn.renderer = (value, metaData, record) => {
+                const dependsOnFieldName = configuration['dependsOnFieldName'];
+                const invertValue = configuration['invertValue'];
+                editable = invertValue === !record.get(dependsOnFieldName);
+                record.allowEditWithEditorPlugin = editable;
+                if (configuration['highlightEditableCells']) {
+                    metaData.tdCls = editable ? 'create-line-left' : 'hover-style';
+                }
+                return value;
+            };
+        }
         return editor;
     },
 });