ru.coon 3.0.67 → 3.0.68

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+# Version 3.0.68, [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/4c8a28a5fc4878ff7e670c77d3bc794069ab7d2d)
+* HT-14811: исправление редактирования характеристик FKV ([b5c035], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/b5c0356d657071ecc5353a39be973d5b592f7648))
+* update: CHANGELOG.md ([87a10f], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/87a10faa1d038191be9cec97076df7bcea165105))
+
 # Version 3.0.67, [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/d850ee12048246ba85557eef4475595043fc9d00)
 * HT-14811: исправление открытия редактора для характеристик FKV ([becf94], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/becf94689878553b8c8287c6260ca986a314b08e))
 * update: CHANGELOG.md ([ef54a3], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/ef54a339c72c36ce13a27672dff3cf89e35ddded))
@@ -38,6 +42,12 @@
 
 * HT-13993 добавлена боковая панель фильтров для репортов ([e2d5c7], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/e2d5c7436900d232cd48c9389a685affbacf721a))
 * HT-14628 открытие компонента внутри репорта - закрытие через крестик ([fc4f4e], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/fc4f4e9112a3ba1a85cb4a064d65d7a7cfb8cec1))
+* update: CHANGELOG.md ([2ab856], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/2ab8566fb3c7400e91d3706a5bd8383d48060556))
+
+# Version 3.0.60, [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/b3ba3aeb89954b8e1650cb40e052a4509b4809fb)
+* ## Fixes
+* <span style='color:red'>fix validator, util.getByPath</span> ([608e70], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/608e7096603a0ed31656b0f45686bab7a4ee302b))
+
 * update: CHANGELOG.md ([e42a2a], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/e42a2a6fb8b511ba174ab5060fc84c683a046945))
 
 # Version 3.0.59, [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/065a134b1f6c6211d56ef758b127778d5e104faa)

package/package.json

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

package/src/common/AbstractPlugin.js

@@ -0,0 +1,17 @@
+Ext.define('Coon.common.AbstractPlugin', {
+    extend: 'Ext.AbstractPlugin',
+
+    constructor(config) {
+        Ext.apply(this, config || {});
+
+        if (Array.isArray(this.validConfig)) {
+            const state = Coon.validator.isObjectValid(this.pluginConfig.properties, this.validConfig);
+            if (!state.valid) {
+                console.error(`Invalid configuration for plugin ${this.pluginConfig.name}:\n${state.errors}`);
+            }
+            this.pluginConfig.validity = state;
+        }
+
+        this.callParent([config]);
+    },
+});

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

@@ -245,9 +245,14 @@ Ext.define('Coon.common.component.editor.CharacteristicGridEditor', {
                 }
                 return Coon.format.withHint(visibleValue, visibleValue || tooltip);
             },
+
             getEditor: function(record) {
-                if ((record.get('entity') === 'FKV') && record.get('mask')) {
-                    return false;
+                if (record.get('entity') === 'FKV') {
+                    const mask = record.get('mask');
+                    const maskText = mask.match(/link:"(.*?)"/);
+                    if (maskText) {
+                        return false;
+                    }
                 }
                 return Ext.create('Ext.grid.CellEditor', {
                     field: Ext.create('Ext.form.field.Text', {

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

@@ -296,8 +296,12 @@ Ext.define('Coon.common.component.editor.TypedCharacteristicEditor', {
 
     cellclickHandler(cmp, td, cellIndex, record) {
         if (this.isEditableChar(record)) {
-            if ((record.get('entity') === 'FKV') && record.get('mask')) {
-                this.prepareType(record);
+            if (record.get('entity') === 'FKV') {
+                const mask = record.get('mask');
+                const maskText = mask.match(/link:"(.*?)"/);
+                if (maskText) {
+                    this.prepareType(record);
+                }
             }
         }
     },

package/src/report/component/ReportPanel.js

@@ -866,6 +866,11 @@ Ext.define('Coon.report.component.ReportPanel', {
             }
             config[prefix + 'type'] = plugin[ns.$uiElement].xtype || plugin[ns.$xtype];
             config[ns.$sortSequence] = plugin[ns.$sortSequence] || null;
+            config.pluginConfig = {
+                properties: Object.assign({}, config),
+                type,
+                name: prefix + 'type',
+            };
             return config;
         });
     },

package/src/report/component/reportpanel/ReportGrid.js

@@ -57,6 +57,7 @@ Ext.define('Coon.report.component.reportpanel.ReportGrid', {
                 try {
                     this.addPlugin(plugin);
                 } catch (e) {
+                    console.error('plugin error', e);
                     pluginErrors.push(e.message);
                 }
             });

package/src/report/util.js

@@ -10,17 +10,17 @@ Ext.define('Coon.report.util', {
                 path: 'fields',
                 valid: 'array',
                 rules: [
-                    {path: '[].description', valid: 'string, required'},
-                    {path: '[].reportFieldCd', valid: 'string, required'},
-                    {path: '[].visibleSwitch', valid: 'boolean'},
-                    {path: '[].reportFieldTypeLookup', valid: 'uppercase, required'},
+                    {path: 'description', valid: 'string, required'},
+                    {path: 'reportFieldCd', valid: 'string, required'},
+                    {path: 'visibleSwitch', valid: 'boolean'},
+                    {path: 'reportFieldTypeLookup', valid: 'uppercase, required'},
                     {
-                        path: '[].properties',
+                        path: 'properties',
                         valid: 'array',
                         rules: [
-                            {path: '[].sequenceNumber', valid: 'number'},
-                            {path: '[].key', valid: 'type.string'},
-                            {path: '[].value', valid: '!type.undefined'}
+                            {path: 'sequenceNumber', valid: 'number'},
+                            {path: 'key', valid: 'type.string'},
+                            {path: 'value', valid: '!type.undefined'}
                         ],
                     }
                 ],
@@ -29,40 +29,40 @@ Ext.define('Coon.report.util', {
                 path: 'plugins',
                 valid: 'array',
                 rules: [
-                    {path: '[].xtype', valid: 'string, required'},
-                    {path: '[].type', valid: 'string, required'},
-                    {path: '[].uiElement', valid: 'string, required'},
-                    {path: '[].jsonProperties', valid: 'string, required'},
-                    {path: '[].sequenceNumber', valid: 'number, required'},
-                    {path: '[].sortSequence', valid: 'number, required'}
+                    {path: 'xtype', valid: 'string, required'},
+                    {path: 'type', valid: 'string, required'},
+                    {path: 'uiElement', valid: 'string, required'},
+                    {path: 'jsonProperties', valid: 'string, required'},
+                    {path: 'sequenceNumber', valid: 'number, required'},
+                    {path: 'sortSequence', valid: 'number, required'}
                 ],
             },
             {
                 path: 'properties',
                 valid: 'array',
                 rules: [
-                    {path: '[].key', valid: 'string, required'},
-                    {path: '[].value', valid: 'string, required'},
-                    {path: '[].sequenceNumber', valid: 'string, required'}
+                    {path: 'key', valid: 'string, required'},
+                    {path: 'value', valid: 'string, required'},
+                    {path: 'sequenceNumber', valid: 'string, required'}
                 ],
             },
             {
                 path: 'parameters',
                 valid: 'array',
                 rules: [
-                    {path: '[].requiredSwitch', valid: 'boolean'},
-                    {path: '[].visibleSwitch', valid: 'boolean'},
-                    {path: '[].notUsedInSQLSwitch', valid: 'boolean'},
-                    {path: '[].description', valid: 'string, required'},
-                    {path: '[].reportParameterCd', valid: 'string, required'},
-                    {path: '[].reportParameterTypeLookup', valid: 'string, required, uppercase'},
+                    {path: 'requiredSwitch', valid: 'boolean'},
+                    {path: 'visibleSwitch', valid: 'boolean'},
+                    {path: 'notUsedInSQLSwitch', valid: 'boolean'},
+                    {path: 'description', valid: 'string, required'},
+                    {path: 'reportParameterCd', valid: 'string, required'},
+                    {path: 'reportParameterTypeLookup', valid: 'string, required, uppercase'},
                     {
-                        path: '[].properties',
+                        path: 'properties',
                         valid: 'array',
                         rules: [
-                            {path: '[].key', valid: 'string, required'},
-                            {path: '[].value', valid: 'string, required'},
-                            {path: '[].sequenceNumber', valid: 'number'}
+                            {path: 'key', valid: 'string, required'},
+                            {path: 'value', valid: 'string, required'},
+                            {path: 'sequenceNumber', valid: 'number'}
                         ],
                     }
                 ],

package/src/util.js

@@ -73,19 +73,17 @@ Ext.define('Coon.util', {
         }
         return path.reduce((acc, pathProp) => {
             if (acc) {
+                if (pathProp.startsWith('[') && pathProp.endsWith(']')) {
+                    pathProp = pathProp.slice(1, -1) || 0;
+                    if (Number.isInteger(parseInt(pathProp))) {
+                        acc = acc[parseInt(pathProp)];
+                        return acc;
+                    }
+                }
                 if (Ext.isObject(acc)) {
                     acc = acc[pathProp];
                     return acc;
                 }
-                if (Array.isArray(acc)) {
-                    if (pathProp.startsWith('[') && pathProp.endsWith(']')) {
-                        pathProp = pathProp.slice(1, -1) || 0;
-                        if (Number.isInteger(parseInt(pathProp))) {
-                            acc = acc[parseInt(pathProp)];
-                            return acc;
-                        }
-                    }
-                }
             } else {
                 path = [];
                 acc = defaultValue;

package/src/validator.js

@@ -58,6 +58,12 @@ Ext.define('Coon.validator', {
      *      ]
      */
     isObjectValid(obj, rules) {
+        if (!Ext.isObject(obj)) {
+            return {
+                valid: false,
+                errors: ['object is not valid'],
+            };
+        }
         const getValid = (valid) => {
             if (typeof valid === 'string') {
                 return valid.split(',').map((el) => el.trim());
@@ -69,42 +75,47 @@ Ext.define('Coon.validator', {
         const checkValidity = (validProps, value) => validProps.find((prop) => {
             const [name, ...args] = prop.split('.');
             if (typeof validators[name] === 'function') {
-                return !(
-                    validators[name](value, ...args)
-                );
+                return validators[name](value, ...args);
+            } else {
+                console.error(`validator [${name}] is not exist!`);
+                return false;
             }
         });
         const validators = this.getValidators();
-        const getErrors = (obj, rules) => {
+        const getErrors = (src, rules) => {
+            if (Array.isArray(src)) {
+                for (const el of src) {
+                    const state = getErrors(el, rules);
+                    if (!state.valid) {
+                        return state;
+                    }
+                }
+                return {valid: true, errors: []};
+            }
             const errors = Coon.util.filterMap(rules, (rule) => {
+                let errorMessage = '';
                 if (!rule.path) {
                     return;
                 }
-                const value = Coon.util.getByPath(obj, rule.path);
+                const value = Coon.util.getByPath(src, rule.path);
                 const validTags = getValid(rule.valid) || [];
-                let subErrors;
-                let isInvalid = typeof valid === 'function' ?
-                    validTags(value) :
-                    checkValidity(validTags, value);
+                let subResult;
+                const isValid = checkValidity(validTags, value);
                 if (
-                    !Ext.isEmpty(value) &&
-                    !isInvalid &&
+                    isValid &&
                     Array.isArray(rule.rules) &&
                     rule.rules.length
                 ) {
-                    const subResult = getErrors(value, rule.rules);
-                    if (!subResult.valid) {
-                        isInvalid = false;
-                        subErrors = subResult.errors.join('\n');
-                    }
+                    subResult = getErrors(value, rule.rules);
                 }
-                if (isInvalid) {
-                    rule.msg = rule.msg || `[by path: ${rule.path}], value [${value}]  is invalid`;
-                    if (subErrors) {
-                        rule.msg = rule.msg + '\n' + subErrors;
-                    }
-                    return rule.msg;
+                if (!isValid) {
+                    errorMessage += rule.msg ||
+                        `The property on the path "${rule.path}" with the value ${value} is invalid, validity check: ${rule.valid}`;
+                }
+                if (subResult && !subResult.valid) {
+                    errorMessage += '\n---\n  ' + subResult.errors.join('\n  ');
                 }
+                return errorMessage || false;
             });
             return {
                 valid: !errors.length,

package/src/version.js

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