ru.coon 2.6.4 → 2.6.6

package/CHANGELOG.md

@@ -1,4 +1,23 @@
+# Version 2.6.6, [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/5a18af0bcc182d756427e1fd5e522dab51f5f6ca)
+* ## Features
+* <span style='color:green'>feat: HT-8006: Create cancel button, add search plugin by name form combo, change field labels</span> ([7dc802], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/7dc8027771536eb1fcffd9d3f59a362699abf5c6))
+
+* ## Fixes
+* <span style='color:red'> HT-8036: remove override view config</span> ([f13055], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/f1305573f3761f2657e995310a79a7d75887c091))
+
+* update extjs_iconpack to 1.3.19 ([adff9d], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/adff9d7411fad6a04e153065c9c472b080d7e719))
+* update: CHANGELOG.md ([f82d7f], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/f82d7f36520836cc6733ac936ef98bf0589b15d2))
+
+# Version 2.6.5, [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/5695d2c215ad6469aacd802ca46a536c81845c35)
+* ## Fixes
+* <span style='color:red'>Fix:TR-67289 refactoring authorization</span> ([8bdc4b], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/8bdc4b11e7443b819b52c4eef8e0cc2d9c8f3f5b))
+
+* update: CHANGELOG.md ([490d0e], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/490d0eb96a199419068bdf69e20aa0db63a6180d))
+
 # Version 2.6.4, [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/f9a1013bbcc9c01ba7baa130b16648d222144ea0)
+* ## Features
+* <span style='color:green'>feat: HT-7986: Create mask editing form panel</span> ([5d812e], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/5d812e4dd2087bbf6be625630133bfc120b5a60f))
+
 * ## Fixes
 * <span style='color:red'>fix "сохнарить"</span> ([a5fa42], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/a5fa421c079792cf51f04ac696664731427620bf))
 
@@ -9,6 +28,7 @@
 * <span style='color:red'>fix uiElement/get request</span> ([edac67], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/edac674cb5d023de5ad274262db6d619de7d50fd))
 * <span style='color:red'> Added 'nullable' then using command.GetUIElementCommand. Related to TR-67200.</span> ([dbc2bb], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/dbc2bbb53c333bab4d0e659cc4118de4e920a299))
 
+* CRM-8252 2-й этап_Реализация перехода в карточку дела/документа ПИР ([d7b3f8], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/d7b3f8e9f622679fbffb338530ee014736b61446))
 * update: CHANGELOG.md ([1e55ff], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/1e55ff88b8c2f2a8c0b71674c719a0daa1e2dbc3))
 
 # Version 2.6.2, [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/b12213a59d39c7fd13513b74268eb902a0c86720)

package/package.json

@@ -4,7 +4,7 @@
     "name": "ru.coon"
   },
   "description": "",
-  "version": "2.6.4",
+  "version": "2.6.6",
   "repository": {
     "type": "git",
     "url": "git+http://gitlab-dbr.sigma-it.local/dbr/ru.coon"
@@ -27,7 +27,7 @@
     "ace-diff": "^3.0.3",
     "decimal.js-light": "^2.5.1",
     "echarts": "^5.3.3",
-    "extjs_iconpack": "1.3.15",
+    "extjs_iconpack": "1.3.19",
     "json5": "2.2.3",
     "object-hash": "^3.0.0",
     "sigma-printjs": "^1.0.1",

package/src/common/component/Auth.js

@@ -4,14 +4,6 @@ Ext.define('Coon.common.component.Auth', {
     systemPropertyName: 'VERSIONING_EMAIL_PERSONIFICATION_SW',
     defaultDomain: '@sigma-it.ru',
     privates: {
-        showError(e) {
-            Ext.create('Coon.report.component.ErrorWindow', {
-                autoShow: true,
-                title: 'Ошибка авторизации',
-                trace: e.message,
-                message: 'Во время авторизации произошла ошибка',
-            });
-        },
 
         verify(data) {
             return new Promise((resolve, reject) => {
@@ -39,25 +31,6 @@ Ext.define('Coon.common.component.Auth', {
             });
         },
 
-        isVerified(data) {
-            return (
-                data &&
-                Coon.util.generateHashFromObj(
-                    Object.assign({}, data, {salt: 'auth'})
-                ) === this.dataChecksum
-            );
-        },
-
-        markAsVerified(data) {
-            try {
-                this.dataChecksum = Coon.util.generateHashFromObj(
-                    Object.assign({}, data, {salt: 'auth'})
-                );
-            } catch (e) {
-                Coon.log.error('Failed to mark auth data as verified', e);
-            }
-        },
-
         parseJWT: (token) => {
             try {
                 return JSON.parse(
@@ -99,6 +72,14 @@ Ext.define('Coon.common.component.Auth', {
             });
         },
     },
+    showError(e) {
+        Ext.create('Coon.report.component.ErrorWindow', {
+            autoShow: true,
+            title: 'Ошибка авторизации',
+            trace: e.message,
+            message: 'Во время авторизации произошла ошибка',
+        });
+    },
 
     handleAuthorization() {
         return this.isValid().then((authorized) => authorized || this.request());
@@ -106,6 +87,7 @@ Ext.define('Coon.common.component.Auth', {
 
     // Проверяет включена ли авторизация
     isEnabled() {
+        return Promise.resolve(true);
         return Coon.SystemProperties.fetch(
             this.systemPropertyName,
             'boolean'
@@ -116,20 +98,15 @@ Ext.define('Coon.common.component.Auth', {
         return new Promise((resolve) => {
             const data = this.getCachedData();
             if (data) {
-                if (!this.isVerified(data)) {
-                    this.verify(data)
-                        .then((isValid) => {
-                            this.markAsVerified(data);
-                            resolve(isValid);
-                        })
-                        .catch((e) => {
-                            this.clearCache();
-                            this.showError(e);
-                            resolve(false);
-                        });
-                } else {
-                    resolve(true);
-                }
+                this.verify(data)
+                    .then((isValid) => {
+                        resolve(isValid);
+                    })
+                    .catch((e) => {
+                        this.clearCache();
+                        this.showError(e);
+                        resolve(false);
+                    });
             } else {
                 resolve(false);
             }
@@ -142,8 +119,10 @@ Ext.define('Coon.common.component.Auth', {
             const wrap = Ext.widget('WindowWrap', {
                 title: 'Авторизация',
                 maximizable: false,
-                resizable: false,
+                resizable: true,
                 autoShow: true,
+                width: 520,
+                height: 280,
                 listeners: {
                     close: function() {
                         resolve(authorized);

package/src/common/component/characteristic/characteristicGroup/EditorOptionsWindow.js

@@ -0,0 +1,150 @@
+Ext.define('Coon.uielement.component.characteristic.characteristicGroup.EditorOptionsWindow', {
+    extend: 'Ext.window.Window',
+    controller: 'EditorOptionsWindowController',
+    modal: true,
+    xtype: 'EditorOptionsWindow',
+    width: 800,
+    closeAction: 'destroy',
+    title: 'Работа со свойствами',
+    height: '80%',
+    config: {
+        value: null,
+        editor: null,
+        editorOptions: {},
+    },
+    listeners: {
+        show: 'onShowWindow',
+    },
+    viewModel: {
+        stores: {
+            mainStore: {
+                type: 'json',
+                fields: ['option', 'value'],
+                data: [],
+            },
+            optionsStore: {
+                type: 'json',
+                data: [],
+            },
+        },
+        data: {
+            record: null,
+            optionsDataLength: 0,
+            currentOption: null,
+            optionDescription: '',
+        },
+    },
+    layout: 'border',
+    items: [
+        {
+            xtype: 'grid',
+            region: 'center',
+            width: 200,
+            plugins: {
+                cellediting: {
+                    listeners: {
+                        edit: 'onEditItem',
+                    },
+                },
+            },
+            viewConfig: {
+                plugins: {
+                    gridviewdragdrop: {
+                        dragText: 'Сортировка',
+                    },
+                },
+            },
+            tbar: {
+                items: [
+                    {
+                        text: 'Добавить',
+                        handler: 'addHandler',
+                        bind: {
+                            disabled: '{!optionsDataLength}',
+                        },
+                    },
+                    {
+                        handler: 'deleteHandler',
+                        text: 'Удалить',
+                        bind: {
+                            disabled: '{!record}',
+                            text: '{buttonText}',
+                        },
+                    }
+                ],
+            },
+            bind: {
+                store: '{mainStore}',
+                selection: '{record}',
+            },
+            columns: [
+                {
+                    header: 'Свойство',
+                    dataIndex: 'option',
+                    xtype: 'hintColumn',
+                    editor: {
+                        xtype: 'combo',
+                        allowBlank: false,
+                        tpl: Ext.create('Ext.XTemplate',
+                            '<ul class="x-list-plain">' +
+                            '<tpl for=".">',
+                            '<li role="option" data-qtip="{[values.description]}" class="x-boundlist-item">{[values.option]}</li>',
+                            '</tpl>' +
+                            '</ul>'),
+                        queryMode: 'local',
+                        editable: false,
+                        displayField: 'option',
+                        valueField: 'option',
+                        bind: {
+                            store: '{optionsStore}',
+                        },
+                        listeners: {
+                            select: 'onSelectCombo',
+                        },
+                    },
+                    flex: 1,
+                }
+            ],
+        },
+        {
+            xtype: 'form',
+            reference: 'valuesForm',
+            flex: 1,
+            bodyPadding: 10,
+            split: true,
+            region: 'east',
+            bind: {
+                disabled: '{!record || !currentOption}',
+            },
+            items: [
+                {
+                    xtype: 'displayfield',
+                    fieldLabel: 'Свойство',
+                    anchor: '100%',
+                    bind: {
+                        value: '{currentOption}',
+                    },
+                },
+                {
+                    xtype: 'displayfield',
+                    fieldLabel: 'Описание',
+                    anchor: '100%',
+                    bind: {
+                        value: '{optionDescription}',
+                    },
+                }
+            ],
+        }
+    ],
+    buttons: [
+        {
+            text: 'Сохранить',
+            ui: 'orange-button',
+            handler: 'saveHandler',
+        },
+        {
+            text: 'Закрыть',
+            handler: 'closeHandler',
+        }
+    ],
+});

package/src/common/component/characteristic/characteristicGroup/EditorOptionsWindowController.js

@@ -0,0 +1,174 @@
+Ext.define('Coon.uielement.component.characteristic.characteristicGroup.EditorOptionsWindowController', {
+    extend: 'Ext.app.ViewController',
+    alias: 'controller.EditorOptionsWindowController',
+    saveHandler: function() {
+        this.updateValue();
+        const data = {};
+        const items = this.getViewModel().getStore('mainStore').getRange();
+        if (!items.length) {
+            this.fireViewEvent('dataIsSaved', '');
+            this.closeHandler();
+        }
+        items.forEach((rec) => {
+            if (rec.get('value')) {
+                data[rec.get('option')] = rec.get('value');
+            }
+        });
+        // console.log(data);
+        // const converted = Coon.Function.convertAdvancedProperties(data);
+        // console.log(converted);
+        this.fireViewEvent('dataIsSaved', Ext.JSON.encode(data));
+        this.closeHandler();
+    },
+    closeHandler: function() {
+        if (this.getView()) {
+            this.getView().close();
+        }
+    },
+    onShowWindow: function() {
+        if (!this.getView().getEditor()) {
+            Ext.Msg.show({
+                title: 'Ошибка',
+                message: 'Не определен едитор',
+                icon: Ext.Msg.ERROR,
+                buttons: Ext.Msg.OK,
+            });
+            this.closeHandler();
+        }
+        const value = this.getView().getValue();
+        const proto = Ext.ClassManager.classes[Ext.ClassManager.aliasToName['widget.'+this.getView().getEditor()]].prototype;
+        if (!Ext.isObject(proto.editorOptions)) {
+            Ext.Msg.show({
+                title: 'Ошибка',
+                message: 'Не определены опции едитора',
+                icon: Ext.Msg.ERROR,
+                buttons: Ext.Msg.OK,
+            });
+            this.closeHandler();
+        }
+        this.getView().setEditorOptions(proto.editorOptions);
+        if (value && Ext.isObject(value)) {
+            this.getViewModel().getStore('mainStore').add(Object.keys(value).map((key) => {
+                return {option: key, value: value[key]};
+            }));
+        }
+        this.initOptionStore();
+        this.getViewModel().bind('{record}', (rec) => {
+            this.getViewModel().set('currentOption', rec && !!rec.get('option') ? rec.get('option') : null);
+        }, this);
+        this.getViewModel().bind('{currentOption}', this.initValuePanel, this);
+    },
+    updateValue() {
+        const form = this.lookup('valuesForm');
+        if (form.getRecord()) {
+            form.updateRecord();
+        }
+    },
+    initValuePanel(currentOption) {
+        this.updateValue();
+        const editorOptions = this.getView().getEditorOptions();
+        this.getViewModel().set('optionDescription',
+            currentOption && Ext.isObject(editorOptions) && editorOptions[currentOption] ?
+                editorOptions[currentOption]['description'] : ''
+        );
+        const form = this.lookup('valuesForm');
+        if (form.items.items[1]) {
+            form.remove(form.items.items.find((field) => field.name === 'value'), true);
+        }
+        if (currentOption && Ext.isObject(editorOptions) && editorOptions[currentOption] && editorOptions[currentOption]['type']) {
+            let config = {
+                fieldLabel: 'Значение',
+                xtype: 'textfield',
+                anchor: '100%',
+                name: 'value',
+                allowBlank: true,
+            };
+            let isBool = false;
+            switch (editorOptions[currentOption]['type']) {
+            case 'bool':
+                isBool = true,
+                config = {
+                    xtype: 'combobox',
+                    allowBlank: true,
+                    forceSelection: true,
+                    editable: false,
+                    anchor: '100%',
+                    name: 'value',
+                    value: true,
+                    fieldLabel: 'Значение',
+                    store: {
+                        fields: ['val', 'descr'],
+                        data: [
+                            {'val': true, 'descr': 'Да'},
+                            {'val': false, 'descr': 'Нет'}
+                        ],
+                    },
+                    queryMode: 'local',
+                    displayField: 'descr',
+                    valueField: 'val',
+                };
+                break;
+            case 'int':
+                config.xtype = 'numberfield';
+                break;
+            case 'js':
+                config.xtype = 'textarea';
+                config.grow = true;
+                break;
+            }
+            form.add(config);
+            const record = this.getViewModel().get('record');
+            if (isBool && record && typeof record.get('value') !== 'boolean') {
+                record.set('value', true);
+            }
+            form.loadRecord(record);
+        }
+    },
+    addHandler() {
+        const record = this.getViewModel().getStore('mainStore').insert(0, {value: null});
+        const grid = this.getView().down('grid');
+        grid.getSelectionModel().select(0);
+        grid.getView().scrollTo(0, 0);
+        const context = grid.getView().getPosition(record[0], grid.getColumns()[0]);
+        grid.setActionableMode(true, context);
+    },
+    deleteHandler() {
+        const vm = this.getViewModel();
+        const record = vm.get('record');
+        if (record) {
+            vm.getStore('mainStore').remove(record);
+            this.initOptionStore();
+        }
+    },
+    onEditItem(el, context) {
+        if (context.field === 'option') {
+            this.initOptionStore();
+            this.getViewModel().set('currentOption', context.record.get('option') || null);
+            context.record.set('value', null);
+        }
+    },
+    onSelectCombo(el, rec) {
+        const record = this.getViewModel().get('record');
+        const field = this.lookup('valuesForm').items.items.find((f) => f.name === 'value');
+        if (field) {
+            field.setValue(null);
+        }
+        record.set('value', null);
+        const grid = this.getView().down('grid');
+        const context = grid.getView().getPosition(record, grid.getColumns()[0]);
+        grid.setActionableMode(false, context);
+    },
+    initOptionStore() {
+        const vm = this.getViewModel();
+        const options = vm.getStore('mainStore').getRange().map((rec) => rec.get('option'));
+        const optionsData = [];
+        const editorOptions = this.getView().getEditorOptions();
+        Object.keys(editorOptions).forEach((key) => {
+            if (options.indexOf(key) < 0) {
+                optionsData.push({option: key, description: editorOptions[key]['description']});
+            }
+        });
+        vm.set('optionsDataLength', optionsData.length);
+        vm.getStore('optionsStore').setData(optionsData);
+    },
+});

package/src/common/component/characteristic/characteristicGroup/EntityGroupCharacteristicEditor.js

@@ -159,6 +159,14 @@ Ext.define('Coon.uielement.component.characteristic.characteristicGroup.EntityGr
             xtype: 'hintColumn',
             editor: {
                 xtype: 'textfield',
+                triggers: {
+                    info: {
+                        cls: 'svg-icon svg-icon-settings',
+                        tooltip: 'Очистить поле',
+                        hideOnReadOnly: true,
+                        handler: 'onTriggerClick',
+                    },
+                },
             },
             flex: 1,
         },
@@ -188,6 +196,21 @@ Ext.define('Coon.uielement.component.characteristic.characteristicGroup.EntityGr
         cellediting: {
             listeners: {
                 edit: 'onEditItem',
+                beforeedit: (el, context) => {
+                    if (context.field === 'mask') {
+                        const editor = context.record.get('editor');
+                        if (editor) {
+                            const proto = Ext.ClassManager.classes[Ext.ClassManager.aliasToName['widget.'+editor]].prototype;
+                            if (Ext.isObject(proto.editorOptions)) {
+                                context.column.field.triggers.info.show();
+                            } else {
+                                context.column.field.triggers.info.hide();
+                            }
+                        } else {
+                            context.column.field.triggers.info.hide();
+                        }
+                    }
+                },
             },
         },
     },

package/src/common/component/characteristic/characteristicGroup/EntityGroupCharacteristicEditorController.js

@@ -162,4 +162,42 @@ Ext.define('Coon.uielement.component.characteristic.characteristicGroup.EntityGr
         }
     },
 
+    onTriggerClick(el) {
+        const record = this.getViewModel().get('record');
+        if (record && record.get('editor')) {
+            const fn = () => {
+                const json = Ext.JSON.decode(el.getValue(), true);
+                const window = Ext.create('Coon.uielement.component.characteristic.characteristicGroup.EditorOptionsWindow', {
+                    value: json || null,
+                    editor: record.get('editor') || null,
+                });
+                window.on('dataIsSaved', (win, data) => {
+                    record.set('mask', data);
+                }, this);
+                window.show();
+            };
+            if (el.getValue()) {
+                const json = Ext.JSON.decode(el.getValue(), true);
+                if (!json || !Ext.isObject(json)) {
+                    Ext.Msg.show({
+                        title: 'Внимание',
+                        message: 'Текущее значение не является JSON объектом и оно будет удалено. Продолжить?',
+                        buttons: Ext.Msg.YESNO,
+                        icon: Ext.Msg.QUESTION,
+                        fn: function(btn) {
+                            if (btn === 'yes') {
+                                record.set('mask', null);
+                                fn();
+                            }
+                        },
+                    });
+                } else {
+                    fn();
+                }
+            } else {
+                fn();
+            }
+        }
+    },
+
 });

package/src/common/component/editor/CharacteristicGridEditor.js

@@ -24,6 +24,9 @@ Ext.define('Coon.common.component.editor.CharacteristicGridEditor', {
     viewConfig: {
         getRowClass(record) {
             const ns = Coon.report.model.CharacteristicBeanFields;
+            if (record.get('isDeleted')) {
+                return 'delete-row';
+            }
             if (
                 record.get(ns.$required) &&
                 !record.get(ns.$allowEmpty) &&

package/src/common/component/editor/TypedCharacteristicEditor.js

@@ -44,11 +44,6 @@ Ext.define('Coon.common.component.editor.TypedCharacteristicEditor', {
                 },
             },
         });
-        this.viewConfig = {
-            getRowClass: Coon.Function.markDelete(
-                'isDeleted'
-            ),
-        };
         this.plugins = Ext.clone(this.plugins) || [];
 
         if (this.enableToolBar) {

package/src/common/component/editor/creators/BaseEditorCreator.js

@@ -1,7 +1,4 @@
 Ext.define('Coon.common.component.editor.creators.BaseEditorCreator', {
-    alternateClassName: [
-        'SigmaUtilities.view.common.component.editor.creators.BaseEditorCreator'
-    ],
     alias: 'widget.BaseEditorCreator',
     getEditWindow: undefined,
     getAddWindow: undefined,

package/src/common/component/editor/creators/ByReportEditorCreator.js

@@ -1,8 +1,5 @@
 Ext.define('Coon.common.component.editor.creators.ByReportEditorCreator', {
     extend: 'Coon.common.component.editor.creators.TriggerFieldEditorCreator',
-    alternateClassName: [
-        'SigmaUtilities.view.common.component.editor.creators.ByReportEditorCreator'
-    ],
     alias: 'widget.ByReportEditorCreator',
     xtype: 'ByReportEditorCreator',
     editable: false,

package/src/common/component/editor/creators/CustomPanelEditorCreator.js

@@ -1,8 +1,5 @@
 Ext.define('Coon.common.component.editor.creators.CustomPanelEditorCreator', {
     extend: 'Coon.common.component.editor.creators.BaseEditorCreator',
-    alternateClassName: [
-        'SigmaUtilities.view.common.component.editor.creators.CustomPanelEditorCreator'
-    ],
     alias: 'widget.CustomPanelEditorCreator',
     xtype: 'CustomPanelEditorCreator',
     config: {

package/src/common/component/editor/creators/ForeignKeyEditorCreator.js

@@ -1,8 +1,5 @@
 Ext.define('Coon.common.component.editor.creators.ForeignKeyEditorCreator', {
     extend: 'Coon.common.component.editor.creators.BaseEditorCreator',
-    alternateClassName: [
-        'SigmaUtilities.view.common.component.editor.creators.ForeignKeyEditorCreator'
-    ],
     alias: 'widget.ForeignKeyEditorCreator',
     xtype: 'ForeignKeyEditorCreator',
     disableInternalEditor: true,

package/src/common/component/editor/creators/NoteEditorCreator.js

@@ -1,8 +1,5 @@
 Ext.define('Coon.common.component.editor.creators.NoteEditorCreator', {
     extend: 'Coon.common.component.editor.creators.BaseEditorCreator',
-    alternateClassName: [
-        'SigmaUtilities.view.common.component.editor.creators.NoteEditorCreator'
-    ],
     alias: 'widget.NoteEditorCreator',
     xtype: 'NoteEditorCreator',
     createField: function(record, parent) {

package/src/common/component/editor/creators/NumberEditorCreator.js

@@ -1,12 +1,25 @@
 Ext.define('Coon.common.component.editor.creators.NumberEditorCreator', {
     extend: 'Coon.common.component.editor.creators.BaseEditorCreator',
-    alternateClassName: [
-        'SigmaUtilities.view.common.component.editor.creators.NumberEditorCreator'
-    ],
     alias: 'widget.NumberEditorCreator',
     xtype: 'NumberEditorCreator',
     decimalSeparator: ',',
-
+    /**
+     * @description Перенчень параметров разрешенных для добавление в поле маски сущности (характеристики)
+     * @param config
+     * @example
+     * editorOptions: {
+     *         allowDecimals: {
+     *             type: 'bool',
+     *             description: 'Разрешать дробные значения',
+     *         },
+     *     },
+     */
+    editorOptions: {
+        allowDecimals: {
+            type: 'bool',
+            description: 'Разрешать дробные значения',
+        },
+    },
     normalizeRawValue(raw, separator) {
         if (!raw) {
             throw new Error('ERROR: normalizeRawValue, raw must be nonempty string!');

package/src/common/component/editor/creators/SimpleReportEditorCreator.js

@@ -7,9 +7,6 @@
  */
 Ext.define('Coon.common.component.editor.creators.SimpleReportEditorCreator', {
     extend: 'Coon.common.component.editor.creators.BaseEditorCreator',
-    alternateClassName: [
-        'SigmaUtilities.view.common.component.editor.creators.SimpleReportEditorCreator'
-    ],
     alias: 'widget.SimpleReportEditorCreator',
     xtype: 'SimpleReportEditorCreator',
     createField: function(record, parent, context) {

package/src/common/component/editor/creators/TriggerFieldEditorCreator.js

@@ -1,8 +1,5 @@
 Ext.define('Coon.common.component.editor.creators.TriggerFieldEditorCreator', {
     extend: 'Coon.common.component.editor.creators.BaseEditorCreator',
-    alternateClassName: [
-        'SigmaUtilities.view.common.component.editor.creators.TriggerFieldEditorCreator'
-    ],
     alias: 'widget.TriggerFieldEditorCreator',
     xtype: 'TriggerFieldEditorCreator',
     assignDoubleClick: true,

package/src/security/GenerateTokenPanel.js

@@ -24,8 +24,6 @@ Ext.define('Coon.security.GenerateTokenPanel', {
             },
         },
     },
-    width: 520,
-    height: 240,
     bodyPadding: 20,
     items: [
         {
@@ -102,8 +100,10 @@ Ext.define('Coon.security.GenerateTokenPanel', {
                 const email =
                     values.emailPrefix.replace(this.vm.get('defaultDomain'), '') +
                     this.vm.get('defaultDomain');
+                form.mask();
                 this.auth.generateToken(email, values.gitToken)
                     .then(function(properties) {
+                        form && form.unmask();
                         if (!Ext.isObject(properties)) {
                             throw new Error('Не удалось сохранить токен');
                         }
@@ -117,6 +117,7 @@ Ext.define('Coon.security.GenerateTokenPanel', {
                         }
                     })
                     .catch((e) => {
+                        form && form.unmask();
                         Coon.log.error(e.message);
                         this.vm.set('pending', false);
                     });

package/src/uielement/component/SearchByPropCombo.js

@@ -0,0 +1,53 @@
+Ext.define('Coon.uielement.component.SearchByPropCombo', {
+    extend: 'Coon.common.field.combo.BaseComboBox',
+    xtype: 'SearchByPropCombo',
+    fieldLabel: 'Обработчик',
+    loadOnRender: false,
+    hideMode: 'offsets',
+    valueField: 'handlerName',
+    displayField: 'handlerWithPtype',
+    minChars: 2,
+    store: {
+        fields: [
+            {name: 'handlerName', type: 'string'},
+            {name: 'ptype', type: 'string'},
+            {
+                name: 'handlerWithPtype',
+                calculate: function(data) {
+                    return data.handlerName + ' - ' + data.ptype;
+                },
+            }
+        ],
+        autoLoad: false,
+    },
+    triggers: {
+        search: {
+            cls: 'svg-icon svg-icon-magnifying-glass',
+            handler: function(el) {
+                this.up('UiCustomPanelPluginPanel').getController().searchByProp(this.getValue());
+            },
+        },
+    },
+    getActualPlugins: function() {
+        const pluginGrid = this.up('UiCustomPanelEditor').down('UiCustomPanelPluginGrid');
+        if (pluginGrid) {
+            const data = pluginGrid.getStore().getRange().map((record) => {
+                if (record.get('handlerName') !== '-/-') {
+                    return {
+                        handlerName: record.get('handlerName'),
+                        ptype: record.get('ptype'),
+                    };
+                }
+            }).filter((item) => item!==undefined);
+            this.store.loadData(data);
+        }
+    },
+    initComponent() {
+        this.on('focus', this.getActualPlugins, this);
+        this.on('render', this.getActualPlugins, this);
+        this.on('change', (el, newVal) => {
+            el.triggers.search.setHidden(!newVal);
+        }, this);
+        this.callParent();
+    },
+});

package/src/uielement/plugin/UnifiedButtonToolbarPlugin.js

@@ -14,15 +14,27 @@ Ext.define('Coon.uielement.plugin.UnifiedButtonToolbarPlugin', {
         this.controller.callDialog = this.callDialog.bind(this);
         view.on('afterrender', () => {
             const window = view.up('WindowWrap');
-            if (window) {
+            if (window && this.checkChangesOnSave !== false) {
                 window.on('beforeclose', this.onBeforeCloseWindow, this);
             }
+            this.controller.lookup('standardCancelButton').setHidden(!window);
         }, this);
-
         this.controller.unifiedButtonToolbar = Ext.create('Ext.toolbar.Toolbar', {
             dock: this.dock,
             items: [
                 '->',
+                {
+                    xtype: 'button',
+                    reference: 'standardCancelButton',
+                    text: 'Закрыть',
+                    hidden: true,
+                    handler: () => {
+                        const window = view.up('WindowWrap');
+                        if (window) {
+                            window.close();
+                        }
+                    },
+                },
                 {
                     xtype: 'button',
                     reference: 'standardSaveButton',
@@ -50,6 +62,11 @@ Ext.define('Coon.uielement.plugin.UnifiedButtonToolbarPlugin', {
             title: 'Сохранить изменения?',
             message: 'Были обнаружены изменения, сохранить их?',
             buttons: Ext.Msg.YESNOCANCEL,
+            buttonText: {
+                yes: 'Сохранить и закрыть',
+                no: 'Закрыть без сохранения',
+                cancel: 'Вернуться',
+            },
             icon: Ext.Msg.QUESTION,
             fn: function(btn) {
                 if (btn === 'yes') {

package/src/uielement/plugin/configPanel/MethodChainPluginConfigPanelFormEditor.js

@@ -60,19 +60,21 @@ Ext.define('Coon.uielement.plugin.configPanel.MethodChainPluginConfigPanelFormEd
         },
         {
             xtype: 'checkbox',
-            boxLabel: 'Прерывать выполнение последовательности если Method возвращает false',
-            flex: 1,
+            boxLabel: 'Прерывать выполнение последовательности если Обработчик возвращает false',
             bind: {
                 value: '{breakChainOnFalse}',
             },
         },
         {
             xtype: 'ReportPropertiesGrid',
-            title: 'Method names',
-            flex: 2,
+            plugins: [
+                {ptype: 'cellediting', clicksToEdit: 2}
+            ],
+            title: 'Последовательно вызываемые обработчики',
+            flex: 1,
             columns: [
                 {
-                    text: 'Method',
+                    text: 'Обработчик',
                     dataIndex: 'value',
                     required: true,
                     flex: 1,
@@ -97,6 +99,7 @@ Ext.define('Coon.uielement.plugin.configPanel.MethodChainPluginConfigPanelFormEd
                 },
                 {
                     xtype: 'widgetcolumn',
+                    width: 40,
                     widget: {
                         xtype: 'SearchByPropButton',
                         tooltip: 'перейти к плагину с таким обработчиком',
@@ -104,7 +107,7 @@ Ext.define('Coon.uielement.plugin.configPanel.MethodChainPluginConfigPanelFormEd
                     },
                 },
                 {
-                    text: 'Error handler (when Method return false)',
+                    text: 'Обработчик ошибки (Когда основной обработчик вернет false)',
                     dataIndex: 'errorHandler',
                     required: true,
                     flex: 1,
@@ -137,6 +140,7 @@ Ext.define('Coon.uielement.plugin.configPanel.MethodChainPluginConfigPanelFormEd
                 },
                 {
                     xtype: 'widgetcolumn',
+                    width: 40,
                     widget: {
                         xtype: 'SearchByPropButton',
                         tooltip: 'перейти к плагину с таким обработчиком',

package/src/uielement/plugin/configPanel/UnifiedButtonToolbarPluginConfigPanelFormEditor.js

@@ -8,6 +8,7 @@ Ext.define('Coon.uielement.plugin.configPanel.UnifiedButtonToolbarPluginConfigPa
             prepareBeanHandlerName: '',
             validateBeanHandlerName: '',
             dock: 'bottom',
+            checkChangesOnSave: true,
         },
     },
     layout: {
@@ -22,56 +23,24 @@ Ext.define('Coon.uielement.plugin.configPanel.UnifiedButtonToolbarPluginConfigPa
             },
         },
         {
-            xtype: 'comboBtnWrapper',
-            combobox: {
-                xtype: 'BaseComboBox',
-                fieldLabel: 'Функция сохранения данных',
-                labelWidth: 60,
-                flex: 1,
-                loadOnRender: false,
-                hideMode: 'offsets',
-                allowBlank: false,
-                store: 'codeHandlers',
-                bind: {
-                    value: '{saveHandlerName}',
-                },
-                valueField: 'id',
-                displayField: 'id',
+            xtype: 'SearchByPropCombo',
+            fieldLabel: 'Обработчик валидации данных',
+            bind: {
+                value: '{validateBeanHandlerName}',
             },
         },
         {
-            xtype: 'comboBtnWrapper',
-            combobox: {
-                xtype: 'BaseComboBox',
-                fieldLabel: 'Функция подготовки данных для сохранения',
-                labelWidth: 60,
-                flex: 1,
-                loadOnRender: false,
-                hideMode: 'offsets',
-                allowBlank: false,
-                store: 'codeHandlers',
-                bind: {
-                    value: '{prepareBeanHandlerName}',
-                },
-                valueField: 'id',
-                displayField: 'id',
+            xtype: 'SearchByPropCombo',
+            fieldLabel: 'Обработчик подготовки данных для сохранения',
+            bind: {
+                value: '{prepareBeanHandlerName}',
             },
         },
         {
-            xtype: 'comboBtnWrapper',
-            combobox: {
-                xtype: 'BaseComboBox',
-                fieldLabel: 'Функция валидации данных',
-                labelWidth: 60,
-                flex: 1,
-                loadOnRender: false,
-                hideMode: 'offsets',
-                store: 'codeHandlers',
-                bind: {
-                    value: '{validateBeanHandlerName}',
-                },
-                valueField: 'id',
-                displayField: 'id',
+            xtype: 'SearchByPropCombo',
+            fieldLabel: 'Обработчик сохранения данных',
+            bind: {
+                value: '{saveHandlerName}',
             },
         },
         {
@@ -88,6 +57,24 @@ Ext.define('Coon.uielement.plugin.configPanel.UnifiedButtonToolbarPluginConfigPa
                 text: 'Отобразить вверху',
                 value: 'top',
             }],
+        },
+        {
+            fieldLabel: 'Отслеживать не сохраненные данные при закрытии',
+            xtype: 'combo',
+            store: {
+                fields: ['val', 'descr'],
+                data: [
+                    {'val': true, 'descr': 'Да'},
+                    {'val': false, 'descr': 'Нет'}
+                ],
+            },
+            editable: false,
+            queryMode: 'local',
+            displayField: 'descr',
+            valueField: 'val',
+            bind: {
+                value: '{checkChangesOnSave}',
+            },
         }
     ],
     getData: function() {
@@ -108,11 +95,12 @@ Ext.define('Coon.uielement.plugin.configPanel.UnifiedButtonToolbarPluginConfigPa
     getConfiguration: function() {
         const result = {};
         const vm = this.getViewModel();
-        ['saveHandlerName', 'prepareBeanHandlerName', 'validateBeanHandlerName', 'dock'].forEach((el) => {
-            if (vm.get(el)) {
+        ['saveHandlerName', 'prepareBeanHandlerName', 'validateBeanHandlerName', 'dock', 'checkChangesOnSave'].forEach((el) => {
+            if (typeof vm.get(el) !== 'undefined') {
                 result[el] = vm.get(el);
             }
         });
         return result;
     },
+
 });

package/src/version.js

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