ru.coon 3.0.59 → 3.0.60

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+# 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)
 * Копирование в буфер обмена без использования дополнительного окна prompt. Related to NEVA-990 ([41cd4e], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/41cd4ed4fdb7088d10df1eac44964c5aadae4646))
 * add Coon.validator singleton class ([a402d0], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/a402d0829e81d7f4297fba2af9b628a4528533c1))

package/package.json

@@ -4,7 +4,7 @@
     "name": "ru.coon"
   },
   "description": "",
-  "version": "3.0.59",
+  "version": "3.0.60",
   "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/report/component/ReportPanel.js

@@ -868,6 +868,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.59',
+    number: '3.0.60',
 });