ru.coon 2.6.5 → 2.6.7

package/src/common/component/formeditor/UiCustomFormEditorController.js

@@ -0,0 +1,654 @@
+Ext.define('Coon.common.component.formeditor.UiCustomFormEditorController', {
+    extend: 'Ext.app.ViewController',
+    alias: 'controller.UiCustomFormEditorController',
+    pinned: false,
+    uiElement: {
+        xtype: 'UiCustomForm',
+        id: null,
+        description: null,
+    },
+    activeResizer: null,
+    paramsList: {},
+    init(view) {
+        this.getViewModel().bind('{viewMode}', 'changeViewMode', this);
+        this.getViewModel().bind('{description}', (description) => {
+            const window = this.getView().up('WindowWrap');
+            if (window) {
+                window.setTitle(description ? 'Редактирование формы '+ description : 'Создание новой формы');
+            }
+        }, this);
+        this.getViewModel().bind('{focusedField}', 'loadSettingsForm', this);
+        this.getViewModel().bind('{focusedFieldXType}', 'showXTypeSettingsForm', this);
+        const params = view.initialConfig && view.initialConfig.launchConfig ? view.initialConfig.launchConfig.params : {};
+        const inputParamsArr = Object.keys(params).map(function(item) {
+            return {name: item};
+        });
+        this.inputParameters = function() {
+            return inputParamsArr && inputParamsArr.length ? inputParamsArr : [
+                {name: 'UiCustomForm'},
+                {name: 'mode'}
+            ];
+        };
+    },
+    getParamsList(params) {
+        const list = {};
+        this.inputParameters().map((item, index) => {
+            list[item['name']] = params[index];
+        });
+        return list;
+    },
+    doInit(...params) {
+        this.showWindowWrapTools();
+        this.paramsList = this.getParamsList(params);
+        if (this.paramsList['UiCustomForm']) {
+            this.getViewModel().set('UI_ELEMENT_CD', this.paramsList['UiCustomForm']);
+            const command = Ext.create('Coon.uielement.command.GetUIElementCommand');
+            command.on('complete', function(response) {
+                if (response) {
+                    this.getViewModel().set('description', response['description']);
+                    const data = response.propertyData !== '{}' ? JSON.parse(response.propertyData) : null;
+                    if (data) {
+                        this.getView().down('UiCFContainer').add(data.items || []);
+                    }
+                    this.uiElement = response;
+                }
+            }, this);
+            command.execute(this.paramsList['UiCustomForm']);
+        }
+    },
+    onSettingsClick() {
+        const vm = this.getViewModel();
+        if (!this.settingsWindow) {
+            this.settingsWindow = Ext.create({xtype: 'UiCFSettingsWindow'});
+            this.settingsWindow.on('applySettings', this.applySettingsUi, this);
+        }
+        this.settingsWindow.loadFormData({UI_ELEMENT_CD: vm.get('UI_ELEMENT_CD'), description: vm.get('description')});
+        this.settingsWindow.show();
+    },
+    applySettingsUi(params) {
+        this.getViewModel().set(params);
+    },
+    showWindowWrapTools() {
+        const me = this;
+        if (this.getView().up().xtype === 'WindowWrap') {
+            const header = this.getView().up().header;
+            Ext.ComponentQuery.query('[dataType=widgetPanelBtn]', header).map((item) => {
+                item.destroy();
+            });
+            this.getView().up().header.insert(1, {
+                xtype: 'tool',
+                tooltip: 'Сохранить',
+                dataType: 'widgetPanelBtn',
+                reference: 'saveToolButton',
+                handler: me.saveForm.bind(me),
+                iconCls: 'svg-icon-tool svg-icon-save-view',
+            });
+            this.getView().up().header.insert(2, {
+                xtype: 'tool',
+                dataType: 'widgetPanelBtn',
+                tooltip: 'Настройки',
+                handler: me.onSettingsClick.bind(me),
+                iconCls: 'svg-icon-tool svg-icon-settings',
+            });
+        }
+    },
+    applySettings() {
+        const field = this.getViewModel().get('focusedField');
+        if (!field) {
+            return false;
+        }
+        const cfg = this.getMergedCfg(field, true);
+        if (this.getViewModel().get('viewMode') === true) {
+            if (cfg.hidden) {
+                cfg.hiddenFake = true;
+                delete cfg['hidden'];
+            }
+            if (cfg.disabled) {
+                cfg.disabledFake = true;
+                delete cfg['disabled'];
+            }
+        } else {
+            if (cfg.hidden) {
+                field.up('UiCFCell').setHidden(true);
+            }
+        }
+
+        const UiCFCell = field.up('UiCFCell');
+        UiCFCell.removeAll();
+        UiCFCell.add(cfg);
+        const cmp = UiCFCell.down();
+        if (cmp) {
+            const vm = this.getViewModel();
+            const currentField = vm.get('focusedField');
+            if (currentField && currentField.el && currentField.el.dom) {
+                currentField.removeCls('selectedField');
+            }
+            vm.set('focusedField', cmp);
+            cmp.addCls('selectedField');
+        }
+    },
+    getMergedCfg(field, applyFormValues) {
+        if (!field) {
+            return {};
+        }
+        const cfg = Object.keys(Coon.UiCFFieldsConfig.getFieldCfg(field.xtype));
+        const userCfgFields = Object.keys(Coon.UiCFFieldsConfig.getFieldUserCfg(field.xtype));
+        const resCfg = {xtype: field.xtype, cls: userCfgFields.length ? 'componentTarget' : field.cls};
+        Ext.Array.unique(
+            cfg.concat(
+                userCfgFields
+            )).forEach((item) => {
+            if (typeof field[item] !== 'undefined') {
+                resCfg[item] = field[item];
+            }
+        });
+        if (applyFormValues === true) {
+            const cardsSettingsGrid = this.lookup('settingsForm').down('UiCFCardsGrid');
+            if (cardsSettingsGrid) {
+                Ext.apply(resCfg, {countCards: cardsSettingsGrid.getFormData()});
+            }
+            const UiCFRadioGrid = this.lookup('settingsForm').down('UiCFRadioGrid');
+            if (UiCFRadioGrid) {
+                resCfg.countCards = UiCFRadioGrid.getFormData();
+            }
+
+            const UiCFSegmentedButtonGrid = this.lookup('settingsForm').down('UiCFSegmentedButtonGrid');
+            if (UiCFSegmentedButtonGrid) {
+                resCfg.countCards = UiCFSegmentedButtonGrid.getFormData();
+            }
+            Ext.apply(resCfg, Coon.Function.getDataFromForm(this.lookup('settingsForm')));
+        }
+        if (field.items && field.items.length) {
+            resCfg['items'] = field.items.items.map((item) => {
+                return this.getMergedCfg(item);
+            });
+        } else {
+            delete resCfg['items'];
+        }
+        if (field.plugins && field.plugins.length) {
+            resCfg['plugins'] = field.plugins.map((item) => {
+                return item.ptype;
+            });
+        } else {
+            delete resCfg['plugins'];
+        }
+        if (!resCfg.cls) {
+            delete resCfg['cls'];
+        }
+        if (resCfg.xtype === 'panel' && field.initialConfig.layout) {
+            resCfg.layout = field.initialConfig.layout;
+        } else {
+            delete resCfg['layout'];
+        }
+        if ((resCfg.xtype === 'panel' || resCfg.xtype === 'button' || resCfg.xtype === 'radiofield' || resCfg.xtype === 'radio' ||
+                resCfg.xtype === 'tabpanel' || resCfg.xtype === 'checkboxfield' || resCfg.xtype === 'checkbox') &&
+            field.initialConfig.itemId) {
+            resCfg.itemId = field.initialConfig.itemId;
+        }
+        if (resCfg.xtype === 'button') {
+            if (field.up().name) {
+                resCfg.name = field.up().name;
+            }
+            if (field.initialConfig.text) {
+                resCfg.text = field.initialConfig.text;
+            }
+            if (field.initialConfig.value) {
+                resCfg.value = field.initialConfig.value;
+            }
+        }
+        if (resCfg.xtype === 'radiofield' || resCfg.xtype === 'checkboxfield' || resCfg.xtype === 'radio' || resCfg.xtype === 'checkbox') {
+            if (field.up().name) {
+                resCfg.name = field.up().name;
+            }
+            if (field.initialConfig.boxLabel) {
+                resCfg.boxLabel = field.initialConfig.boxLabel;
+            }
+            if (field.initialConfig.inputValue) {
+                resCfg.inputValue = field.initialConfig.inputValue;
+            }
+        }
+        if (field.xtype === 'UiCFCell') {
+            resCfg.flex = field.flex;
+            if (field.hidden) {
+                resCfg.hidden = field.hidden;
+            }
+        }
+        return JSON.parse(JSON.stringify(resCfg));
+    },
+    getCfg(field) {
+        if (!field) {
+            return {};
+        }
+        const cfg = Object.keys(Coon.UiCFFieldsConfig.getFieldCfg(field.xtype));
+        const userCfgFields = Object.keys(Coon.UiCFFieldsConfig.getFieldUserCfg(field.xtype));
+        const resCfg = {xtype: field.xtype, cls: userCfgFields.length ? 'componentTarget' : field.cls};
+        Ext.Array.unique(
+            cfg.concat(
+                userCfgFields
+            )).forEach((item) => {
+            if (typeof field[item] !== 'undefined') {
+                resCfg[item] = field[item];
+            }
+        });
+        if (field.items && field.items.length) {
+            resCfg['items'] = field.items.items.map((item) => {
+                return this.getCfg(item);
+            });
+        } else {
+            delete resCfg['items'];
+        }
+        if (field.plugins && field.plugins.length) {
+            resCfg['plugins'] = field.plugins.map((item) => {
+                return item.ptype;
+            });
+        } else {
+            delete resCfg['plugins'];
+        }
+        if ((resCfg.xtype === 'panel' || resCfg.xtype === 'button' ||
+                resCfg.xtype === 'radiofield' || resCfg.xtype === 'radio' || resCfg.xtype === 'checkbox' ||
+                resCfg.xtype === 'checkboxfield' || resCfg.xtype === 'tabpanel') &&
+            field.initialConfig.itemId) {
+            resCfg.itemId = field.initialConfig.itemId;
+        }
+        if (resCfg.xtype === 'button') {
+            if (field.up().name) {
+                resCfg.name = field.up().name;
+            }
+            if (field.initialConfig.text) {
+                resCfg.text = field.initialConfig.text;
+            }
+            if (field.initialConfig.value) {
+                resCfg.value = field.initialConfig.value;
+            }
+        }
+        if (resCfg.xtype === 'radiofield' || resCfg.xtype === 'checkboxfield' || resCfg.xtype === 'radio' || resCfg.xtype === 'checkbox') {
+            if (field.up().name) {
+                resCfg.name = field.up().name;
+            }
+            if (field.initialConfig.boxLabel) {
+                resCfg.boxLabel = field.initialConfig.boxLabel;
+            }
+            if (field.initialConfig.inputValue) {
+                resCfg.inputValue = field.initialConfig.inputValue;
+            }
+        }
+        if (!resCfg.cls) {
+            delete resCfg['cls'];
+        }
+        delete resCfg['layout'];
+        if (field.xtype === 'UiCFCell') {
+            resCfg.flex = field.flex;
+        }
+        return JSON.parse(JSON.stringify(resCfg));
+    },
+    loadSettingsForm(field) {
+        const form = this.lookup('settingsForm');
+        form.removeAll();
+        if (field) {
+            field.up('UiCFCell').getController().setResizer();
+            this.getViewModel().set('focusedFieldXType', field.xtype);
+            const doForm = () => {
+                const cfg = Ext.apply(Coon.UiCFFieldsConfig.getFieldUserCfg(field.xtype), Coon.UiCFFieldsConfig.defaultCfg);
+                const viewMode = this.getViewModel().get('viewMode');
+                if (cfg) {
+                    Object.keys(cfg).forEach((key) => {
+                        const cmp = cfg[key];
+                        let tmpKey = null;
+                        if (viewMode === true) {
+                            if (key === 'hidden') {
+                                tmpKey = 'hiddenFake';
+                            }
+                            if (key === 'disabled') {
+                                tmpKey = 'disabledFake';
+                            }
+                        }
+                        const fieldCfg = JSON.parse(JSON.stringify({
+                            name: key,
+                            value: field[tmpKey || key],
+                            fieldLabel: cmp.description,
+                        }));
+                        switch (cmp.type) {
+                        case 'text':
+                            Ext.apply(fieldCfg, {
+                                xtype: 'textfield',
+                                value: field[key] === false || field[key] === 'false' ? '' : field[key],
+                            });
+                            break;
+                        case 'dateFormat':
+                            Ext.apply(fieldCfg, {
+                                xtype: 'combo',
+                                queryMode: 'local',
+                                displayField: 'key',
+                                valueField: 'key',
+                                store: {
+                                    type: 'json',
+                                    data: [
+                                        {key: 'd.m.Y'},
+                                        {key: 'd M Y'},
+                                        {key: 'M Y'},
+                                        {key: 'd-m-Y'},
+                                        {key: 'Y-m-d'},
+                                        {key: 'Y.m.d'}
+                                    ],
+                                },
+                            });
+                            break;
+                        case 'date':
+                            Ext.apply(fieldCfg, {
+                                xtype: 'datefield',
+                            });
+                            break;
+                        case 'timeFormat':
+                            Ext.apply(fieldCfg, {
+                                xtype: 'combo',
+                                queryMode: 'local',
+                                displayField: 'key',
+                                valueField: 'key',
+                                store: {
+                                    type: 'json',
+                                    data: [
+                                        {key: 'g:i A'},
+                                        {key: 'H:i'}
+                                    ],
+                                },
+                            });
+                            break;
+                        case 'timeTextFormat':
+                            Ext.apply(fieldCfg, {
+                                xtype: 'combo',
+                                queryMode: 'local',
+                                displayField: 'key',
+                                valueField: 'key',
+                                store: {
+                                    type: 'json',
+                                    data: [
+                                        {key: 'g:i A'},
+                                        {key: 'H:i'}
+                                    ],
+                                },
+                            });
+                            break;
+
+                        case 'reportsList':
+                            Ext.apply(fieldCfg, {
+                                xtype: 'ReportLookupCombo',
+                                itemId: 'reportsList',
+                                reportId: 'REPORTS',
+                                valueField: 'CM_REPORT_CD',
+                                displayField: 'DESCR',
+                            });
+                            break;
+                        case 'bool':
+                            fieldCfg['boxLabel'] = fieldCfg.fieldLabel;
+                            delete fieldCfg['fieldLabel'];
+                            Ext.apply(fieldCfg, {
+                                xtype: 'checkbox',
+                                inputValue: true,
+                                boxLabelAlign: 'before',
+                            });
+                            break;
+                        case 'int':
+                            Ext.apply(fieldCfg, {
+                                xtype: 'numberfield',
+                                value: Ext.isNumber(field[key]) && field[key].toString().length <= 10 ? field[key] : null,
+                            });
+                            break;
+                        case 'cards':
+                            Ext.apply(fieldCfg, {
+                                xtype: 'UiCFCardsGrid',
+                            });
+                            break;
+                        case 'radio':
+                            Ext.apply(fieldCfg, {
+                                xtype: 'UiCFRadioGrid',
+                            });
+                            break;
+                        case 'segmented':
+                            Ext.apply(fieldCfg, {
+                                xtype: 'UiCFSegmentedButtonGrid',
+                            });
+                            break;
+                        case 'reportField':
+                            Ext.apply(fieldCfg, {
+                                xtype: 'UiCFReportField',
+                            });
+                            break;
+                        case 'allowedExtensions':
+                            Ext.apply(fieldCfg, {
+                                xtype: 'tagfield',
+                                submitFormat: true,
+                                queryMode: 'local',
+                                displayField: 'key',
+                                valueField: 'key',
+                                store: {
+                                    type: 'json',
+                                    data: [
+                                        {key: 'xls'},
+                                        {key: 'xlsx'},
+                                        {key: 'doc'},
+                                        {key: 'docx'},
+                                        {key: 'pdf'},
+                                        {key: 'txt'},
+                                        {key: 'csv'},
+                                        {key: 'jpeg'},
+                                        {key: 'jpg'},
+                                        {key: 'png'},
+                                        {key: 'ico'}
+                                    ],
+                                },
+                            });
+                            break;
+                        }
+                        form.add(fieldCfg);
+                    });
+                }
+            };
+            if (!Coon.UiCFFieldsConfig.settingsIsLoaded) {
+                Coon.UiCFFieldsConfig.getCfgFromStorage().then((data) => {
+                    doForm();
+                });
+            } else {
+                doForm();
+            }
+        } else {
+            this.getViewModel().set('focusedFieldXType', null);
+            if (this.activeResizer) {
+                this.activeResizer.destroy();
+                this.activeResizer = null;
+            }
+        }
+    },
+    recursiveGetProps(field) {
+        if (!field || !field.self) {
+            return [];
+        }
+        return Object.getOwnPropertyNames(field.self.prototype).
+            concat(Object.getOwnPropertyNames(field.self), this.recursiveGetProps(field['__proto__']));
+    },
+    getAllProperties(xtype) {
+        if (Coon.UiCFFieldsConfig.propsCfg && Coon.UiCFFieldsConfig.propsCfg[xtype] && Coon.UiCFFieldsConfig.propsCfg[xtype].length) {
+            return Coon.UiCFFieldsConfig.propsCfg[xtype];
+        }
+        const field = Ext.create('widget.' + xtype, {checkOptions: true});
+        const exceptions = [
+            'superclass',
+            'defaultConfig',
+            'config',
+            'noClearOnDestroy',
+            'alias',
+            'alternateClassName',
+            'requires',
+            'componentLayout',
+            'ariaRole',
+            'xtype',
+            'xtypes',
+            'xtypesChain',
+            'xtypesMap',
+            'fakeSizeModel',
+            'successUserEditingOptions',
+            'defaultListenerScope',
+            'childEls'
+        ];
+        const data = Ext.Array.unique(this.recursiveGetProps(field)).reduce((acc, item) => {
+            if (typeof field[item] !== 'function' && exceptions.indexOf(item) < 0 &&
+                item.indexOf('_') !== 0 && item.indexOf('$') !== 0) {
+                acc.push(item);
+            }
+            return acc;
+        }, []);
+        field.destroy();
+        Coon.UiCFFieldsConfig.propsCfg[xtype] = data;
+        return data;
+    },
+    detectPropertyType(val) {
+        if (Ext.isNumber(val)) {
+            return 'int';
+        } else if (Ext.isBoolean(val)) {
+            return 'bool';
+        } else {
+            return 'text';
+        }
+    },
+    applyXTypeSettings() {
+        const field = this.getViewModel().get('focusedField');
+        const props ={};
+        this.getViewModel().getStore('configStore').getFilters().removeAll();
+        this.getViewModel().getStore('configStore').getData().items.
+            filter((rec) => rec.get('visible') === true).
+            forEach((item) => {
+                props[item.get('property')] = {
+                    type: item.get('type'),
+                    description: item.get('title') ? item.get('title') : item.get('property'),
+                    text: item.get('description'),
+                };
+            });
+        const setter = Coon.UiCFFieldsConfig.setFieldUserCfg(field.xtype, props);
+        if (setter !== false) {
+            setter.then(() => {
+                this.loadSettingsForm(field);
+                this.getViewModel().set('activeForm', 0);
+            });
+        }
+    },
+    showXTypeSettingsForm() {
+        const field = this.getViewModel().get('focusedField');
+        const store = this.getViewModel().getStore('configStore');
+        if (!field) {
+            store.removeAll();
+            return false;
+        }
+
+        const doForm = () => {
+            const ownCfg = Coon.UiCFFieldsConfig.getOwnProperties(field.xtype);
+            const props = this.getAllProperties(field.xtype).concat(Object.keys(ownCfg));
+            const fieldCfg = Coon.UiCFFieldsConfig.getFieldUserCfg(field.xtype);
+            const data = props.sort().map((item) => {
+                return {
+                    key: field.xtype,
+                    visible: typeof fieldCfg[item] !== 'undefined' ? true : false,
+                    property: item,
+                    title: typeof fieldCfg[item] !== 'undefined' ? fieldCfg[item]['description'] :
+                        typeof ownCfg[item] !== 'undefined' ? ownCfg[item]['description'] : '',
+                    description: typeof fieldCfg[item] !== 'undefined' ? fieldCfg[item]['text'] :
+                        typeof ownCfg[item] !== 'undefined' ? ownCfg[item]['text'] : '',
+                    type: typeof fieldCfg[item] !== 'undefined' ? fieldCfg[item]['type'] :
+                        typeof ownCfg[item] !== 'undefined' ? ownCfg[item]['type'] : this.detectPropertyType(field[item]),
+                };
+            });
+            store.loadData(data);
+        };
+        if (!Coon.UiCFFieldsConfig.settingsIsLoaded) {
+            Coon.UiCFFieldsConfig.getCfgFromStorage().then((data) => {
+                doForm();
+            });
+        } else {
+            doForm();
+        }
+    },
+    saveForm() {
+        const vm = this.getViewModel();
+        if (!vm.get('UI_ELEMENT_CD') || !vm.get('description')) {
+            this.onSettingsClick();
+            return false;
+        }
+        this.uiElement.id = vm.get('UI_ELEMENT_CD');
+        this.uiElement.description = vm.get('description');
+        this.uiElement.propertyData = JSON.stringify(this.getMergedCfg(this.getView().down('UiCFContainer')));
+        const command = Ext.create('command.SaveUIElementCommand');
+        command.on('complete', function(uiElementBean) {
+            Ext.Msg.alert('Успех', 'Данные успешно сохранены');
+        }, this);
+        command.execute(this.uiElement);
+    },
+    onSettingsRender(cmp) {
+        cmp.query('header').forEach((header) => {
+            header.setStyle({
+                cursor: 'pointer',
+            });
+            header.on('click', () => {
+                const panel = this.lookup('settingsPanel');
+                if (!this.getPinned()) {
+                    panel.setCollapsed(!panel.getCollapsed());
+                }
+            }, this);
+        });
+    },
+
+    getPinned() {
+        return this.pinned;
+    },
+    setPinned(state) {
+        this.pinned = state;
+        const tool = this.lookup('settingsPanel').tools.find((el) => el.itemId === 'pinned');
+        if (tool) {
+            if (typeof tool.setType === 'function') {
+                tool.setType(state ? 'unpin' : 'pin');
+            } else {
+                tool.type = state ? 'unpin' : 'pin';
+            }
+        }
+    },
+    changeViewMode(viewMode) {
+        const saveBtns = Ext.ComponentQuery.query('[reference="saveToolButton"]', this.getView().up().header);
+        if (saveBtns.length) {
+            saveBtns[0].setHidden(viewMode === true);
+        }
+        const doAction = () => {
+            const panel = this.getView().down('UiCFContainer');
+            const hiddenElems = Ext.ComponentQuery.query(viewMode === true ? '[hidden=true]' : '[hiddenFake=true]', panel);
+            const disabledElems = Ext.ComponentQuery.query(viewMode === true ? '[disabled=true]' : '[disabledFake=true]', panel);
+            const fieldsNames = Coon.UiCFFieldsConfig.getFieldsNames();
+            hiddenElems.forEach((cmp) => {
+                if (fieldsNames.indexOf(cmp.xtype) >= 0) {
+                    cmp.setHidden(viewMode !== true);
+                    const UiCFCell = cmp.up();
+                    if (UiCFCell.xtype === 'UiCFCell') {
+                        UiCFCell.setHidden(viewMode !== true);
+                        if (viewMode === true) {
+                            cmp.hiddenFake = true;
+                        } else {
+                            delete cmp['hiddenFake'];
+                        }
+                    }
+                }
+            });
+            disabledElems.forEach((cmp) => {
+                if (fieldsNames.indexOf(cmp.xtype) >= 0) {
+                    cmp.setDisabled(viewMode !== true);
+                    if (viewMode === true) {
+                        cmp.disabledFake = true;
+                    } else {
+                        delete cmp['disabledFake'];
+                    }
+                }
+            });
+        };
+        if (!Coon.UiCFFieldsConfig.settingsIsLoaded) {
+            Coon.UiCFFieldsConfig.getCfgFromStorage().then((data) => {
+                doAction();
+            });
+        } else {
+            doAction();
+        }
+    },
+});

package/src/common/component/formeditor/UiCustomFormEditorView.js

@@ -0,0 +1,7 @@
+/* global Ext */
+Ext.define('Coon.common.component.formeditor.UiCustomFormEditorView', {
+    extend: 'Coon.report.component.ReportPanel',
+    xtype: 'UiCustomFormEditorView',
+    reportId: 'UiCustomForm_LIST',
+    autoFilter: true,
+});

package/src/report/component/settings/plugin/ReportFormPluginPanelController.js

@@ -107,7 +107,7 @@ Ext.define('Coon.report.component.settings.plugin.ReportFormPluginPanelControlle
                     Coon.report.plugin.util.getConfigPanelClassName(
                         xtype,
                         this.getViewModel().get('formEditor')
-                    ) || 'SpecificPluginConfig',
+                    ) || 'widget.SpecificPluginConfig',
                     {
                         readOnly: record.get('readOnly'),
                         isNew: record.get('isNew'),