ru.coon 2.6.5 → 2.6.7

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

@@ -0,0 +1,342 @@
+Ext.define('Coon.common.component.formeditor.UiCFFieldsConfig', {
+    alternateClassName: 'Coon.UiCFFieldsConfig',
+    singleton: true,
+    storageElemId: 'UiCFFieldsCfg',
+    storageElem: null,
+    settingsIsLoaded: false,
+    propsCfg: {},
+    defaultCfg: {
+        name: {
+            type: 'text',
+            description: 'Name',
+        },
+    },
+    applyDefaultCfg(cfg) {
+        if (cfg && Ext.isObject(cfg) && Object.keys(cfg).length) {
+            this.UiCFFieldsConfig = Ext.applyIf(cfg, this.UiCFFieldsConfig);
+        }
+    },
+    getCfgFromStorage() {
+        return Coon.util.promisifyCmd('command.GetUIElementCommand', this.storageElemId).then((data) => {
+            this.storageElem = data;
+            this.applyDefaultCfg(data && data.propertyData ? JSON.parse(data.propertyData) :{});
+            this.settingsIsLoaded = true;
+        }).catch((error) => {
+            Coon.log.debug(error);
+            Ext.Msg.alert('Ошибка', error.toString());
+        });
+    },
+    setCfgToStorage(cfg) {
+        this.storageElem.propertyData = JSON.stringify(cfg || {});
+        return Coon.util.promisifyCmd('command.SaveUIElementCommand', this.storageElem).catch((error) => {
+            Coon.log.debug(error);
+            Ext.Msg.alert('Ошибка', error.toString());
+        });
+    },
+    UiCFFieldsConfig: {
+        textfield: {
+            description: 'Текстовое поле',
+            cfg: {
+                plugins: [
+                    'RequiredFlagPlugin'
+                ],
+            },
+            ownProperties: {
+                value: {
+                    type: 'text',
+                    description: 'Значение по умолчанию',
+                    text: '',
+                },
+            },
+        },
+        numberfield: {
+            description: 'Числовое поле',
+            cfg: {
+                plugins: [
+                    'RequiredFlagPlugin'
+                ],
+            },
+            ownProperties: {
+                value: {
+                    type: 'text',
+                    description: 'Значение по умолчанию',
+                    text: '',
+                },
+            },
+        },
+
+        datefield: {
+            description: 'Дата',
+            cfg: {
+                plugins: [
+                    'RequiredFlagPlugin'
+                ],
+            },
+            ownProperties: {
+                minValue: {
+                    type: 'date',
+                    description: 'Значение по умолчанию',
+                    text: '',
+                },
+                maxValue: {
+                    type: 'date',
+                    description: 'Значение по умолчанию',
+                    text: '',
+                },
+                value: {
+                    type: 'date',
+                    description: 'Значение по умолчанию',
+                    text: '',
+                },
+            },
+        },
+        timefield: {
+            description: 'Поле время',
+            cfg: {
+                plugins: [
+                    'RequiredFlagPlugin'
+                ],
+            },
+        },
+        checkbox: {
+            description: 'Чек',
+            cfg: {
+                plugins: [
+                    'RequiredFlagPlugin'
+                ],
+            },
+        },
+        textareafield: {
+            description: 'Текст',
+            cfg: {
+                plugins: [
+                    'RequiredFlagPlugin'
+                ],
+            },
+        },
+        htmleditor: {
+            description: 'HTML',
+            cfg: {
+                plugins: [
+                    'RequiredFlagPlugin'
+                ],
+            },
+        },
+        ExtFileUploadField: {
+            description: 'Загрузка файла',
+            cfg: {
+                plugins: [
+                    'RequiredFlagPlugin'
+                ],
+            },
+        },
+        fieldset: {
+            description: 'Панель',
+            cfg: {
+                items: [
+                    {xtype: 'UiCFContainer'}
+                ],
+                plugins: [
+                    'RequiredFlagPlugin'
+                ],
+            },
+            ownProperties: {
+                title: {
+                    type: 'text',
+                    description: 'Заголовок',
+                    text: '',
+                },
+            },
+        },
+        ReportLookupCombo: {
+            description: 'Выбор из отчета',
+            cfg: {
+                plugins: [
+                    'RequiredFlagPlugin'
+                ],
+            },
+            ownProperties: {
+                reportId: {
+                    type: 'text',
+                    description: 'Идентификатор отчета',
+                    text: '',
+                },
+                displayField: {
+                    type: 'text',
+                    description: 'Поле для отображения',
+                    text: '',
+                },
+                valueField: {
+                    type: 'text',
+                    description: 'Поле идентификатор',
+                    text: '',
+                },
+            },
+        },
+        SimplestReportCombo: {
+            description: 'Выпадающий список',
+            cfg: {
+                plugins: [
+                    'RequiredFlagPlugin'
+                ],
+            },
+            ownProperties: {
+                reportId: {
+                    type: 'text',
+                    description: 'Идентификатор отчета',
+                    text: '',
+                },
+                displayField: {
+                    type: 'text',
+                    description: 'Поле для отображения',
+                    text: '',
+                },
+                valueField: {
+                    type: 'text',
+                    description: 'Поле идентификатор',
+                    text: '',
+                },
+            },
+        },
+        ReportTagLookup: {
+            description: 'Мульти список',
+            cfg: {
+                plugins: [
+                    'RequiredFlagPlugin'
+                ],
+            },
+            ownProperties: {
+                reportId: {
+                    type: 'text',
+                    description: 'Идентификатор отчета',
+                    text: '',
+                },
+                displayField: {
+                    type: 'text',
+                    description: 'Поле для отображения',
+                    text: '',
+                },
+                valueField: {
+                    type: 'text',
+                    description: 'Поле идентификатор',
+                    text: '',
+                },
+            },
+        },
+        UiCFSpacer: {
+            description: 'spacer',
+        },
+        ReportPanel: {
+            description: 'Репорт',
+            ownProperties: {
+                reportId: {
+                    type: 'text',
+                    description: 'Идентификатор отчета',
+                    text: '',
+                },
+                height: {
+                    type: 'int',
+                    description: 'Высота',
+                    text: '',
+                },
+            },
+        },
+        UiCFCard: {
+            description: 'Card',
+            ownProperties: {
+                countCards: {
+                    type: 'cards',
+                    description: 'Вкладки',
+                    text: '',
+                },
+                height: {
+                    type: 'int',
+                    description: 'Высота',
+                    text: '',
+                },
+            },
+        },
+        UiCFTab: {
+            description: 'Панель с вкладками',
+            ownProperties: {
+                countCards: {
+                    type: 'cards',
+                    description: 'Вкладки',
+                    text: '',
+                },
+                height: {
+                    type: 'int',
+                    description: 'Высота',
+                    text: '',
+                },
+            },
+        },
+        UiCFSegmentedButton: {
+            description: 'Выбор значения',
+            ownProperties: {
+                countCards: {
+                    type: 'segmented',
+                    description: 'Вложеные кнопки',
+                    text: '',
+                },
+            },
+        },
+        UiCFRadioGroup: {
+            description: 'Radio',
+            ownProperties: {
+                countCards: {
+                    type: 'radio',
+                    description: 'Значения',
+                    text: '',
+                },
+            },
+        },
+        UiCFCheckboxGroup: {
+            description: 'Группа чекбоксов',
+            ownProperties: {
+                countCards: {
+                    type: 'radio',
+                    description: 'Значения',
+                    text: '',
+                },
+            },
+        },
+        imagecomponent: {
+            description: 'Изображение',
+        },
+    },
+    getFieldsTypes() {
+        return Object.keys(this.UiCFFieldsConfig).map((key) => {
+            return {type: key, description: this.UiCFFieldsConfig[key]['description']};
+        });
+    },
+    getFieldsNames() {
+        return Object.keys(this.UiCFFieldsConfig);
+    },
+    getFieldDescription(field) {
+        return this.UiCFFieldsConfig[field] && this.UiCFFieldsConfig[field]['description'] ? this.UiCFFieldsConfig[field]['description'] : field;
+    },
+    getFieldCfg(field) {
+        return this.UiCFFieldsConfig[field] && this.UiCFFieldsConfig[field]['cfg'] ? this.UiCFFieldsConfig[field]['cfg'] : {
+            allowBlank: true,
+            fieldLabel: false,
+        };
+    },
+    getOwnPropertiesNames(field) {
+        return this.UiCFFieldsConfig[field] && this.UiCFFieldsConfig[field]['ownProperties'] ?
+            Object.keys(this.UiCFFieldsConfig[field]['ownProperties']) : [];
+    },
+    getOwnProperties(field) {
+        return this.UiCFFieldsConfig[field] && this.UiCFFieldsConfig[field]['ownProperties'] ? this.UiCFFieldsConfig[field]['ownProperties'] : {};
+    },
+    getFieldUserCfg(field) {
+        return this.UiCFFieldsConfig[field] && this.UiCFFieldsConfig[field]['userCfg'] ? this.UiCFFieldsConfig[field]['userCfg'] : {};
+    },
+    setFieldUserCfg(field, cfg) {
+        if (this.UiCFFieldsConfig[field]) {
+            this.UiCFFieldsConfig[field]['userCfg'] = Ext.isObject(cfg) ? Ext.apply(cfg, this.defaultCfg) : this.defaultCfg;
+            return this.setCfgToStorage(this.UiCFFieldsConfig);
+        }
+        return false;
+    },
+});

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

@@ -0,0 +1,70 @@
+/* global Ext */
+Ext.define('Coon.common.component.formeditor.UiCFRadioGrid', {
+    extend: 'Ext.grid.Panel',
+    xtype: 'UiCFRadioGrid',
+    flex: 1,
+    title: 'Значения',
+    minHeight: 100,
+    controller: {
+        init(view) {
+            const vm = this.getViewModel();
+            vm.getStore('cardsStore').on('datachanged', (store) => {
+                vm.set('dataCount', store.data.length);
+            }, this);
+            if (view.initialConfig && view.initialConfig.value) {
+                vm.getStore('cardsStore').loadData(view.initialConfig.value);
+            }
+            this.getView().getFormData = this.getFormData.bind(this);
+        },
+        getFormData() {
+            return this.getViewModel().getStore('cardsStore').getRange().map((rec) => {
+                return {boxLabel: rec.get('boxLabel'), itemId: rec.get('itemId'), inputValue: rec.get('inputValue')};
+            });
+        },
+        addRow() {
+            this.getViewModel().getStore('cardsStore').add({itemId: 'UiCFRadio_' + Ext.id().replace('-', '_')});
+        },
+        deleteRow() {
+            this.getViewModel().getStore('cardsStore').remove(this.getViewModel().get('selection'));
+        },
+    },
+    viewModel: {
+        data: {
+            selection: null,
+            dataCount: 1,
+        },
+        stores: {
+            cardsStore: {
+                type: 'json',
+                fields: ['boxLabel', 'itemId', 'inputValue'],
+                data: [
+                ],
+            },
+        },
+    },
+    tbar: [
+        {
+            text: 'Добавить',
+            handler: 'addRow',
+        },
+        {
+            text: 'Удалить',
+            handler: 'deleteRow',
+            bind: {
+                disabled: '{!selection || dataCount < 2}',
+            },
+        }
+    ],
+    bind: {
+        store: '{cardsStore}',
+        selection: '{selection}',
+    },
+    columns: [
+        {xtype: 'rownumberer'},
+        {dataIndex: 'boxLabel', text: 'Заголовок', flex: 2, editor: {xtype: 'textfield'}},
+        {dataIndex: 'inputValue', text: 'Значение', flex: 1, editor: {xtype: 'textfield'}}
+    ],
+    plugins: [
+        {ptype: 'cellediting'}
+    ],
+});

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

@@ -0,0 +1,53 @@
+/* global Ext */
+Ext.define('Coon.common.component.formeditor.UiCFRadioGroup', {
+    extend: 'Ext.form.RadioGroup',
+    xtype: 'UiCFRadioGroup',
+    controller: {
+        init(view) {
+            let i = 1;
+            if (view.initialConfig && !view.initialConfig.checkOptions) {
+                if (view.initialConfig && view.initialConfig.countCards) {
+                    view.initialConfig.countCards.forEach((setting, index) => {
+                        let item = view.items.getAt(view.items.findIndex('itemId', setting.itemId));
+                        if (!item) {
+                            item = view.add({
+                                itemId: setting.itemId,
+                                inputValue: setting.inputValue,
+                            });
+                        }
+                        if (setting.boxLabel) {
+                            item.setBoxLabel(setting.boxLabel);
+                        }
+                        if (setting.inputValue) {
+                            item.inputValue = setting.inputValue;
+                        } else {
+                            item.inputValue = i++;
+                        }
+                    });
+                    if (view.initialConfig.countCards.length < view.items.getCount()) {
+                        const ids = view.initialConfig.countCards.map((item) => item.itemId);
+                        view.items.items.forEach((item) => {
+                            if (ids.indexOf(item.itemId) < 0) {
+                                view.remove(item);
+                            }
+                        });
+                    }
+                } else {
+                    const itemId = 'UiCFRadio_' + Ext.id().replace('-', '_');
+                    view.countCards = [
+                        {
+                            'itemId': itemId,
+                            'inputValue': i,
+                        }
+                    ],
+                    view.add({
+                        'itemId': itemId,
+                        'inputValue': i,
+                    });
+                    i++;
+                }
+            }
+        },
+    },
+    items: [],
+});

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

@@ -0,0 +1,48 @@
+Ext.define('Coon.common.component.formeditor.UiCFReportField', {
+    extend: 'Ext.form.field.ComboBox',
+    xtype: 'UiCFReportField',
+    controller: {
+        refField: null,
+        init(view) {
+            view.on('render', (view) => {
+                const form = view.up('[reference="settingsForm"]');
+                if (!form) {
+                    Ext.Msg.alert('Ошибка', 'Не удалось найти форму');
+                    return;
+                }
+                const refField = form.down('[itemId="reportsList"]');
+                if (!refField) {
+                    Ext.Msg.alert('Ошибка', 'Не удалось найти поле - список отчетов');
+                    return;
+                }
+                this.refField = refField;
+                this.refField.on('change', this.onChangeRefField, this);
+            }, this);
+        },
+        onChangeRefField(field, value) {
+            const combo = this.getView();
+            combo.getStore().removeAll();
+            if (value) {
+                Coon.util.promisifyCmd('Coon.report.command.GetDynamicReportDataCommand',
+                    'REPORT_FIELDS',
+                    '[{"type":"REPORT_CD","value":"'+value+'"}]')
+                    .then((data) => {
+                        if (Ext.isArray(data.list)) {
+                            combo.getStore().loadData(data.list);
+                        }
+                    })
+                    .catch((error) => {
+                        Coon.log.debug(error);
+                        Ext.Msg.alert(error.toString());
+                    });
+            }
+        },
+    },
+    queryMode: 'local',
+    displayField: 'DESCR',
+    valueField: 'REPORT_FIELD_CD',
+    store: {
+        type: 'json',
+        data: [],
+    },
+});

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

@@ -0,0 +1,13 @@
+/* global Ext */
+Ext.define('Coon.common.component.formeditor.UiCFRow', {
+    extend: 'Ext.container.Container',
+    controller: 'UiCFRowController',
+    xtype: 'UiCFRow',
+    minHeight: 20,
+    layout: {
+        type: 'hbox',
+        align: 'stretch',
+    },
+    items: [
+    ],
+});

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

@@ -0,0 +1,155 @@
+Ext.define('Coon.common.component.formeditor.UiCFRowController', {
+    extend: 'Ext.app.ViewController',
+    alias: 'controller.UiCFRowController',
+    menuItems: {},
+
+    init() {
+        this.setDefaultMenuItems();
+    },
+
+    setDefaultMenuItems() {
+        this.menuItems = {
+            up: {text: 'вверх', iconCls: 'fa fa-arrow-up', handler: this.moveRowUp.bind(this)},
+            down: {text: 'вниз', iconCls: 'fa fa-arrow-down', handler: this.moveRowDown.bind(this)},
+        };
+    },
+    getCountRows() {
+        return this.getUiCFContainerController().getCountRows();
+    },
+    getRowIndex() {
+        return this.getUiCFContainerController().getRowIndex(this.getView());
+    },
+    getMenuItems(activeCell) {
+        const me = this;
+        const menuItems = [{
+            text: 'в строку', iconCls: 'fa fa-plus',
+            menu: Coon.UiCFFieldsConfig.getFieldsTypes().map((item) => {
+                return {
+                    text: item.description,
+                    iconCls: '',
+                    handler: () => {
+                        me.addCell(item.type, activeCell);
+                    },
+                };
+            }),
+        }];
+        const count = this.getCountRows();
+        if (count > 1) {
+            const index = this.getRowIndex() + 1;
+            if (index > 1) {
+                menuItems.push(this.menuItems.up);
+            }
+            if (count > index) {
+                menuItems.push(this.menuItems.down);
+            }
+        }
+        return menuItems;
+    },
+
+    getUiCFContainerController() {
+        return this.getView().up('UiCFContainer').getController();
+    },
+
+    setFlex() {
+        const cntr = this;
+        Ext.Msg.prompt('Относительный размер', 'Укажите размер:', function(btn, text) {
+            if (btn == 'ok') {
+                if (text && Ext.isNumber(Number(text))) {
+                    cntr.getView().setFlex(Number(text));
+                    cntr.getView().up('UiCFContainer').updateLayout();
+                } else {
+                    Ext.Msg.show({
+                        title: 'Ошибка',
+                        message: 'Значение должно быть числом от 0',
+                        buttons: Ext.Msg.YES,
+                        icon: Ext.Msg.ERROR,
+                    });
+                    return false;
+                }
+            }
+        }, this, false, this.getView().flex || 0);
+    },
+
+    addCell(type, activeCell) {
+        let cfg = null;
+        if (!Ext.isObject(type)) {
+            cfg = {
+                xtype: 'UiCFCell',
+                items: [Ext.apply({
+                    xtype: type,
+                    name: type + '-' + (this.getUiCFContainerController().getCountElemsByXtype(type) + 1),
+                    cls: 'componentTarget',
+                }, Coon.UiCFFieldsConfig.getFieldCfg(type))],
+            };
+        } else {
+            cfg = type;
+        }
+        const view = this.getView();
+        if (activeCell) {
+            view.insert(this.getCellIndexInRow(activeCell) + 1, cfg);
+            activeCell.getController().setResizer();
+        } else {
+            view.add(cfg);
+        }
+    },
+
+    removeCell(cell) {
+        this.getViewModel().set('focusedField', null);
+        if (this.getCountCells() > 1) {
+            this.getView().remove(this.getCellIndexInRow(cell));
+        } else {
+            this.getUiCFContainerController().removeRow(this.getView());
+        }
+    },
+
+    moveRowUp(direction) {
+        this.getUiCFContainerController().moveRow(this.getView(), 'up');
+    },
+
+    moveRowDown(direction) {
+        this.getUiCFContainerController().moveRow(this.getView(), 'down');
+    },
+
+    moveCell(cell, direction) {
+        const cellIndexInRow = this.getCellIndexInRow(cell);
+        const view = this.getView();
+        const countCells = this.getCountCells();
+        if (countCells > 1) {
+            if (direction === 'left') {
+                view.moveBefore(cell, view.items.getAt(cellIndexInRow - 1));
+            } else {
+                view.moveAfter(cell, view.items.getAt(cellIndexInRow + 1));
+            }
+        }
+    },
+
+    getCountCells() {
+        return this.getView().items.length;
+    },
+
+    getCellIndexInRow(cell) {
+        return this.getView().items.indexOfKey(cell.id);
+    },
+
+    getCells() {
+        return this.getView().items.getRange();
+    },
+
+    layoutCellsInRow() {
+        this.getCells().forEach((cell) => {
+            cell.setFlex(200);
+        });
+        this.getView().updateLayout();
+    },
+
+    layoutByTemplate() {
+        const uiCFContainerController = this.getUiCFContainerController();
+        const cells = this.getCells();
+        const flexMatrix = cells.map((cell) => cell.flex);
+        uiCFContainerController.getRows().filter(
+            (row) => row.items.length === cells.length && row.id !== this.getView().id
+        ).forEach((row) => row.items.getRange().forEach((cell, index) => cell.setFlex(flexMatrix[index])));
+        this.getView().updateLayout();
+    },
+
+});