ru.coon 2.8.22 → 2.8.23

package/CHANGELOG.md

@@ -1,6 +1,20 @@
+# Version 2.8.23, [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/c36774795559da6d9f0d5780d591a33e16b1c99f)
+* ## Features
+* <span style='color:green'>feat: HT-10270 CoonChart new chartType and refactoring</span> ([24fca5], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/24fca5f0d13c24b0e4d76c489d082589647d05de))
+* <span style='color:green'>feat: HT-10270 CoonChart new chartType and refactoring</span> ([055785], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/05578581ee41bb993ed48efbc9072d0fd11b69b5))
+* <span style='color:green'>feat: HT-10270 CoonChart new chartType and refactoring</span> ([dd953a], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/dd953a4782945ddfb6516fe8866bc9d6ee9d3370))
+* <span style='color:green'>feat: HT-10270 CoonChart new chartType and refactoring</span> ([81da35], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/81da35474745b812fcf89c4b569870ed72a4c66e))
+
+* upd ([571495], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/571495ffbd6b23c76edd9eac741b87163fc59cdc))
+* add loadFakeData to ReportPanel ([671b7f], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/671b7f27f3538291a56ba8c1b45016910b42e17d))
+* update: CHANGELOG.md ([c73ba4], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/c73ba4e040a66da70edbeb990b8e7d42a690cc1b))
+
 # Version 2.8.22, [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/abdcd052a504db9e3ef0d640c05c861dab6fc771)
 * ## Features
 * <span style='color:green'>feat: HT-10212: fix layout bug</span> ([cec2b3], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/cec2b36d2917ca56537c119f1ce1ead71c8ca009))
+* <span style='color:green'>feat: HT-10270 CoonChart new chartType and refactoring</span> ([6ddef7], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/6ddef7e1775c40563be1d0959a6270a929fa7509))
+* <span style='color:green'>feat: HT-10270 CoonChart new chartType and refactoring</span> ([57ffb8], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/57ffb80671975236cd3cfc78583ac9e13779392b))
+* <span style='color:green'>feat: HT-10270 CoonChart new chartType and refactoring</span> ([239bb2], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/239bb2d06eeb59e3dee05507fed41f41a8d64498))
 * <span style='color:green'>feat: HT-10463: fix add in context menu button</span> ([4588f7], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/4588f75ee55b80327192cb7df28770d41d4707c6))
 
 * update: CHANGELOG.md ([866504], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/86650477e9606983c72620ed063150bb23fc3e4e))
@@ -8,6 +22,7 @@
 # Version 2.8.21, [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/dcc7c4b24a73690b18533027979c7ed0e3c88a78)
 * ## Features
 * <span style='color:green'>feat: BFL-16584: fix create plugin method</span> ([0b4aaf], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/0b4aafb76151f2a689fed079857e972fb9c34ebd))
+* <span style='color:green'>feat: HT-10270 CoonChart new chartType and refactoring</span> ([9eff33], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/9eff333c0a480672aea7d594bd44688fe3e89653))
 
 * update: CHANGELOG.md ([5cbccf], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/5cbccffafebcc1252fae28c0ca74fa09e43b2180))
 
@@ -15,6 +30,7 @@
 * ## Features
 * <span style='color:green'>feat: BFL-16584: fix create plugin method</span> ([36b867], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/36b8678a1bb336a50930d379219dc61ac5a06a97))
 * <span style='color:green'>feat: Add itemId property with pluginId value on each toolbar item to auto generate testId. Related to HT-8881.</span> ([32f736], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/32f7362b2a2a090842dd56feadc5586a5188b037))
+* <span style='color:green'>feat: HT-10270 CoonChart new chartType and refactoring</span> ([fee620], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/fee62060cb96b665b4353b1c962b897de1c09046))
 
 * update: CHANGELOG.md ([7dcff7], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/7dcff78843efc4b137d3796aee2273bf65db0e53))
 

package/package.json

@@ -4,7 +4,7 @@
     "name": "ru.coon"
   },
   "description": "",
-  "version": "2.8.22",
+  "version": "2.8.23",
   "repository": {
     "type": "git",
     "url": "git+http://gitlab-dbr.sigma-it.local/dbr/ru.coon"

package/src/chart/BaseChart.js

@@ -63,6 +63,9 @@ Ext.define('Coon.chart.BaseChart', {
     },
 
     clearChart() {
+        if (!this.chart) {
+            return;
+        }
         this.chart.clear();
         this.ownerCt.setFilterDefaults({});
     },
@@ -71,7 +74,7 @@ Ext.define('Coon.chart.BaseChart', {
         rows = rows || cfg.rows;
         cfg.series = cfg.serieFields.map((field) => {
             return Object.assign({}, cfg.serieConfig, {data: rows.map((row) => {
-                return cfg.serieConfig.type === 'bar' ? row[field] : {name: row[cfg.axisField], value: row[field]};
+                return {name: row[cfg.legend], value: row[field]};
             })});
         });
         Coon.log.debug('loadChart', {cfg, rows});

package/src/chart/CoonChart.js

@@ -180,43 +180,45 @@ Ext.define('Coon.chart.CoonChart', {
     },
 
     getChartConfig(type) {
+        const typeConfig = type === 'pie' ? type : 'default';
+        const defaultConfig = {
+            rows: [],
+            tooltip: {
+                trigger: 'item',
+            },
+            legend: {},
+        };
         const config = {
-            bar: {
-                rows: [],
+            default: {
                 categoryAxis: {
                     type: 'category',
-                    data: [],
                 },
                 valueAxis: {
                     type: 'value',
+                    name: '',
+                },
+                legend: {
+                    data: [],
                 },
-                serieFields: [],
                 serieConfig: {
                     name: '',
-                    type: 'bar',
+                    type: type,
                 },
+                categoryLineY: false,
             },
             pie: {
-                rows: [],
-                tooltip: {
-                    trigger: 'item',
-                },
                 legend: {
                     orient: 'vertical',
                     left: 'left',
                 },
                 serieConfig: {
                     name: '',
-                    type: 'pie',
+                    type: type,
                     radius: '50%',
                 },
-                serieFields: [],
             },
         };
-        const result = config[type];
-        if (result) {
-            return result;
-        }
+        return Ext.apply(defaultConfig, config[typeConfig]);
     },
 
     getCoonChartData(coonChartId) {
@@ -224,7 +226,7 @@ Ext.define('Coon.chart.CoonChart', {
         loadUiElementCommand.on('complete', function(response) {
             const propertyData = response.propertyData && JSON.parse(response.propertyData);
             this.coonChartData = Object.assign(this.getChartConfig(propertyData.chartType), response, propertyData);
-            this.coonChartData.axisName = this.coonChartData.chartType === 'bar' && this.coonChartData.fieldset[this.coonChartData.axisField];
+            // this.coonChartData.axisName = this.coonChartData.chartType === 'bar' && this.coonChartData.fieldset[this.coonChartData.categoryField];
             this.loadDataFromSource();
         }, this);
         loadUiElementCommand.execute(coonChartId);
@@ -237,16 +239,20 @@ Ext.define('Coon.chart.CoonChart', {
         }
         const doFilter = (this.filterDefaults ? this.filterDefaults.doFilter : undefined);
         if (this.autoFilter || doFilter) {
-            me.mask();
+            me.loadMask = new Ext.LoadMask({
+                target: me,
+                msg: 'Идет построение графика...',
+            });
+            me.loadMask.show();
             this.getDataSourceData(this.coonChartData).then(function(data) {
                 if (data && Array.isArray(data.list) && data.list.length > 0) {
                     me.coonChartData.rows = data.list;
                     me.setChartData(me.coonChartData);
                 }
-                me.unmask();
             }).catch((error) => {
-                me.unmask();
                 Coon.log.error('getDataSourceData', error);
+            }).finally(() => {
+                me.loadMask && me.loadMask.destroy();
             });
         }
     },
@@ -301,51 +307,72 @@ Ext.define('Coon.chart.CoonChart', {
 
     setChartData(config, fieldAlerts) {
         const alerts = [];
-        const isSettingAxisData = config.serieConfig.type === 'bar';
+        const isSettingAxisData = config.chartType === 'bar' || config.chartType === 'line';
+        const defaultConfig = this.getChartConfig(config.chartType);
         const isNumber = (v) => Ext.Number.isFinite(parseFloat(v));
-        const normalizeSerieValue = (row, field) => {
-            const value = row[field] && row[field].trim();
-            if (typeof value !== 'number' && !value && isNumber(config.fieldDefaults)) {
-                return config.fieldDefaults;
+        const normalizeValue = (row, fieldConfig, type) => {
+            let value;
+            const field = fieldConfig.reportField;
+            if (type === 'serie') {
+                value = isNumber(row[field]) && row[field] ||
+                    isNumber(fieldConfig.defaultValue) && fieldConfig.defaultValue;
             }
-            if (!isNumber(value)) {
+            if (type === 'axis') {
+                value = row[field] || fieldConfig.defaultValue;
+            }
+            if (!value) {
                 alerts.push({type: 'serie', val: field});
+                return;
             }
             return value;
         };
 
-        config.categoryAxis = config.categoryAxis || {};
-        const normalizeAxisField = (field) => {
-            const result = field || config.fieldDefaults[config.axisField];
-            if (!result) {
-                alerts.push({type: 'axis', val: config.axisField});
-            }
-            return result;
-        };
-        const series = config.serieFields.reduce((acc, field) => {
-            acc[field] = Object.assign({}, config.serieConfig, {data: []});
-            return acc;
-        }, {});
-        config.rows.forEach((row) => {
-            const axisValue = normalizeAxisField(row[config.axisField]);
-            isSettingAxisData && config.categoryAxis.data.push(axisValue);
-            config.serieFields.map((field) => {
-                series[field].data.push({
-                    name: axisValue,
-                    value: normalizeSerieValue(row, field),
-                });
+        const categoryAxis = config.categoryConfig.map((fieldConfig) => {
+            const configObj = Object.assign({}, fieldConfig.additionalConfig, fieldConfig, defaultConfig.categoryAxis);
+            delete configObj.additionalConfig;
+            return configObj;
+        });
+        const valueAxis = config.valueConfig.map((fieldConfig) => {
+            const configObj = Object.assign({}, fieldConfig.additionalConfig, fieldConfig, defaultConfig.valueAxis);
+            delete configObj.additionalConfig;
+            return configObj;
+        });
+        const legend = config.legendConfig.map((fieldConfig) => {
+            const configObj = Object.assign({}, fieldConfig.additionalConfig, fieldConfig, defaultConfig.legend);
+            delete configObj.additionalConfig;
+            return configObj;
+        });
+        const series = config.serieConfig.map((fieldConfig) => {
+            const configObj = Object.assign({}, fieldConfig.additionalConfig, fieldConfig, defaultConfig.serieConfig);
+            delete configObj.additionalConfig;
+            return configObj;
+        });
+        config.rows.map((row) => {
+            categoryAxis.forEach((categoryEl) => {
+                categoryEl.data = categoryEl.data || [];
+                categoryEl.data.push(normalizeValue(row, categoryEl, 'axis'));
+            });
+            series.forEach((serieEl) => {
+                serieEl.data = serieEl.data || [];
+                serieEl.data.push(normalizeValue(row, serieEl, 'serie'));
+            });
+            legend.forEach((legendEl) => {
+                legendEl.data = legendEl.data || [];
+                legendEl.data.push(normalizeValue(row, legendEl, 'axis'));
             });
         });
-
-        if (config.axisName === 'x') {
+        config.categoryAxis = isSettingAxisData && categoryAxis;
+        config.valueAxis = isSettingAxisData && valueAxis;
+        config.legend = legend;
+        if (isSettingAxisData && !config.categoryLineY) {
             config.xAxis = config.categoryAxis;
             config.yAxis = config.valueAxis;
         }
-        if (config.axisName === 'y') {
+        if (isSettingAxisData && config.categoryLineY) {
             config.yAxis = config.categoryAxis;
             config.xAxis = config.valueAxis;
         }
-        config.series = Object.values(series);
+        config.series = series;
         this.showErrorMessage(alerts, fieldAlerts);
         this.down('BaseChart').clearChart();
         this.loadChart(config);

package/src/chart/editor/CoonChartEditor.js

@@ -34,13 +34,10 @@ Ext.define('Coon.chart.editor.CoonChartEditor', {
                 type: 'vbox',
                 align: 'stretch',
             },
-            // defaults: {
-            //     flex: 1,
-            // },
             items: [
                 {
                     xtype: 'panel',
-                    title: 'Параметры',
+                    title: 'Параметры диаграммы',
                     layout: {
                         type: 'vbox',
                         align: 'stretch',
@@ -74,61 +71,98 @@ Ext.define('Coon.chart.editor.CoonChartEditor', {
                                 reference: 'description',
                                 xtype: 'textfield',
                                 bind: '{coonChart.description}',
+                            },
+                            {
+                                xtype: 'combo',
+                                fieldLabel: 'Тип диаграммы',
+                                reference: 'chartType',
+                                editable: false,
+                                bind: {
+                                    value: '{coonChart.chartType}',
+                                },
+                                store: ['bar', 'pie', 'line'],
                             }
                         ],
                     },
                     {
-                        xtype: 'combo',
-                        fieldLabel: 'тип диаграммы',
-                        reference: 'chartType',
-                        editable: false,
-                        bind: {
-                            value: '{coonChart.chartType}',
+                        xtype: 'panel',
+                        layout: {
+                            type: 'hbox',
+                            align: 'stretch',
                         },
-                        store: ['bar', 'pie'],
-                    },
-                    {
-                        xtype: 'radiogroup',
-                        reference: 'sourceType',
                         items: [
-                            {boxLabel: 'репорт', name: 'sourceType', inputValue: 'report'},
-                            {boxLabel: 'команда', name: 'sourceType', inputValue: 'command'}
-                        ],
-                    },
-                    {
-                        xtype: 'AbstractComponentComboBox',
-                        fieldLabel: 'команда',
-                        reference: 'command',
-                        displayField: 'name',
-                        valueField: 'value',
-                        getData() {
-                            return [];
-                        },
-                        bind: {
-                            value: '{coonChart.commandSourceId}',
-                            hidden: '{coonChart.sourceType === "report"}',
-                        },
-                    },
+                            {
+                                xtype: 'combo',
+                                reference: 'sourceType',
+                                displayField: 'descr',
+                                valueField: 'val',
+                                name: 'sourceType',
+                                flex: 1,
+                                store: [
+                                    {descr: 'репорт', val: 'report'},
+                                    {descr: 'команда', val: 'command'}
+                                ],
+                                bind: {
+                                    value: '{coonChart.sourceType}',
+                                },
+                            },
+                            {
+                                xtype: 'AbstractComponentComboBox',
+                                fieldLabel: 'команда',
+                                reference: 'command',
+                                displayField: 'name',
+                                valueField: 'value',
+                                flex: 2,
+                                getData() {
+                                    return [];
+                                },
+                                bind: {
+                                    value: '{coonChart.commandSourceId}',
+                                    hidden: '{coonChart.sourceType === "report"}',
+                                },
+                            },
+                            {
+                                xtype: 'ReportLookupCombo',
+                                reportId: 'REPORTS',
+                                valueField: 'CM_REPORT_CD',
+                                displayField: 'CM_REPORT_CD',
+                                reference: 'reportSourceField',
+                                flex: 2,
+                                bind: {
+                                    value: '{coonChart.reportSourceId}',
+                                    hidden: '{coonChart.sourceType === "command"}',
+                                },
+                            }
+                        ]},
                     {
                         xtype: 'textfield',
-                        fieldLabel: 'reportId',
-                        reference: 'reportSourceField',
+                        fieldLabel: 'Параметры в фомате {"parameter1Name":"value","parameter2Name":"value"}',
+                        reference: 'parametersField',
                         bind: {
-                            value: '{coonChart.reportSourceId}',
-                            hidden: '{coonChart.sourceType === "command"}',
+                            value: '{coonChart.parameters}',
                         },
                     },
                     {
-                        xtype: 'textfield',
-                        fieldLabel: 'parameters',
-                        reference: 'parametersField',
+                        xtype: 'checkbox',
+                        boxLabel: 'Отобразить категорию по оси y',
+                        boxLabelAlign: 'after',
                         bind: {
-                            value: '{coonChart.parameters}',
+                            value: '{coonChart.categoryLineY}',
                         },
                     }
                     ],
                     buttons: [
-                        {text: 'загрузить данные', itemId: 'configDataSourceBindBtn'}
+                        {
+                            text: 'Загрузить данные',
+                            itemId: 'configDataSourceBindBtn',
+                            handler: 'configDataSourceBinds',
+                        },
+                        {
+                            text: 'Отобразить диаграмму',
+                            tooltip: 'Чтобы отобразить диаграмму нужно загрузить данные',
+                            itemId: 'loadDataBtn',
+                            handler: 'showCoonChartHandler',
+                        }
                     ],
                 },
                 {
@@ -140,23 +174,6 @@ Ext.define('Coon.chart.editor.CoonChartEditor', {
                         align: 'stretch',
                     },
                     items: [
-                        // {
-                        //     xtype: 'panel',
-                        //     title: 'конфигурация',
-                        //     layout: {
-                        //         type: 'vbox',
-                        //         align: 'stretch',
-                        //     },
-                        //     flex: 1,
-                        //     items: [
-                        //         {
-                        //             xtype: 'UiAceEditor',
-                        //             reference: 'UiAceEditor',
-                        //             flex: 1,
-                        //             margin: 10,
-                        //         }
-                        //     ],
-                        // },
                         {
                             xtype: 'DataSourceChartBindForm',
                             flex: 1,
@@ -183,7 +200,11 @@ Ext.define('Coon.chart.editor.CoonChartEditor', {
         {text: 'отменить', itemId: 'cancel', handler(btn) {
             btn.up('CoonChartEditor').close();
         }},
-        {text: 'подтвердить', itemId: 'submit'}
+        {
+            text: 'подтвердить',
+            itemId: 'submit',
+            handler: 'onSubmitCoonChart',
+        }
     ],
 
 });