ru.coon 3.0.58 → 3.0.60

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+# 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))
+* upd ([61e613], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/61e6137120af2b8a95c0d7918a85afe2aa3d0456))
+* upd ([0258f1], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/0258f199b5928da341e6549f5589390f1fa87bcd))
+* add validator ([0ca7d7], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/0ca7d719f4715af1845f0b4385333271db2438bb))
+* update: CHANGELOG.md ([5969de], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/5969de159690ff30bc5194f8fe83a4d1d7507dd0))
+
 # Version 3.0.58, [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/9f4087fb2aba17d56ea49774ac21340c1b414307)
 * update: CHANGELOG.md ([fcea34], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/fcea34f891b7acc6a0b73200d9b6d7b60c383f46))
 
@@ -8,7 +22,13 @@
 * ## Features
 * <span style='color:green'>feat: add forceShowHeader</span> ([7ce368], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/7ce368898a1809f08aaa8331af2bdef4f40366da))
 
+* update: CHANGELOG.md ([8108ae], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/8108ae12826ada676cd8598e0c1ba8ce067fa32e))
+
+# Version 3.0.57, [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/28be9d312317e10260c5d784cf2eb09e83a30140)
 * HT-14299: изменение вида несохраненных изменений в вертикальных табах ([590315], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/59031554ed302eabdc194e916e44c3a8a3c77371))
+* update: CHANGELOG.md ([62c8b4], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/62c8b40173f540191ba7eeb9aad48dae93dd5f57))
+
+# Version 3.0.56, [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/74308acb16cf13c9793236b74d8fd025bd632cab)
 * HT-14580: повторный вход при завершении сессии ([66c811], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/66c81121345e02ec436a9ec3308db087030a25ac))
 * update: CHANGELOG.md ([0cd2cb], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/0cd2cb99bbdcdf6d8cf83c29c744dd0f02daa497))
 

package/package.json

@@ -4,7 +4,7 @@
     "name": "ru.coon"
   },
   "description": "",
-  "version": "3.0.58",
+  "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

@@ -2,7 +2,7 @@ Ext.define('Coon.report.util', {
     singleton: true,
 
     validateReportConfig(config) {
-        return Coon.util.isObjectValid(config, [
+        return Coon.validator.isObjectValid(config, [
             {path: 'reportDescription', valid: 'string, required'},
             {path: 'reportId', valid: 'string, required'},
             {path: 'SQLText', valid: 'string, required'},
@@ -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/uielement/component/UiCustomPanel.js

@@ -9,6 +9,9 @@ Ext.define('Coon.uielement.component.UiCustomPanel', {
         'Coon.uielement.component.UiCustomPanelTraceWindow'
     ],
     controller: 'UiCustomController',
+    mixins: [
+        'Coon.validator.mixin'
+    ],
 
     keyMap: {
         'Ctrl+Shift+Alt+F8': {
@@ -75,6 +78,9 @@ Ext.define('Coon.uielement.component.UiCustomPanel', {
     },
 
     forceShowHeader(_, title) {
+        if (this.assert.is_string_required(title).invalid) {
+            return;
+        }
         if (typeof title !== 'string' || !title) {
             return;
         }

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;
@@ -210,7 +208,7 @@ Ext.define('Coon.util', {
             const bAcc = acc;
             acc = this.safeCall(fn, acc);
             if (debug) {
-            // eslint-disable-next-line no-console
+                // eslint-disable-next-line no-console
                 console.debug(`\n \x1b[36m\x1b[4m BEFORE: \x1b[0m ${fn.toString()}`);
                 // eslint-disable-next-line no-console
                 console.dir(bAcc, {depth: debug.depth || 5});
@@ -228,7 +226,22 @@ Ext.define('Coon.util', {
         return acc;
     },
 
-    copyToClipboard(copiedData) {
+    getHtaEl() {
+        const textArea = document.createElement('textarea');
+        textArea.style.position = 'fixed';
+        textArea.style.top = 0;
+        textArea.style.left = 0;
+        textArea.style.width = '2em';
+        textArea.style.height = '2em';
+        textArea.style.padding = 0;
+        textArea.style.border = 'none';
+        textArea.style.outline = 'none';
+        textArea.style.boxShadow = 'none';
+        textArea.style.background = 'transparent';
+        return textArea;
+    },
+
+    copyToClipboard(copiedData, successText = 'Скопировано успешно') {
         try {
             if (!Ext.browser.is.Firefox && navigator && navigator.clipboard) {
                 navigator.permissions.query({name: 'clipboard-write'}).then((result) => {
@@ -243,13 +256,14 @@ Ext.define('Coon.util', {
             if (window.clipboardData && window.clipboardData.setData) {
                 window.clipboardData.setData('text', copiedData);
             }
-            if (document.queryCommandSupported && document.queryCommandSupported('copy')) {
-                const hiddenTextArea = this.getHtaEl();
-                hiddenTextArea.value = copiedData;
-                hiddenTextArea.focus();
-                hiddenTextArea.select();
-                return document.execCommand('copy');
-            }
+            const hiddenTextArea = this.getHtaEl();
+            hiddenTextArea.value = copiedData;
+            document.body.appendChild(hiddenTextArea);
+            hiddenTextArea.focus();
+            hiddenTextArea.select();
+            document.execCommand('copy');
+            document.body.removeChild(hiddenTextArea);
+            Ext.toast({html: successText, cls: ['toast-success']});
         } catch (ex) {
             return prompt('Copy to clipboard: Ctrl+C, Enter', copiedData);
         }
@@ -369,106 +383,6 @@ Ext.define('Coon.util', {
         return acc;
     },
 
-    /**
-     *
-     * @param {Object} obj
-     * @param {Array} rules
-     * @example
-     *      rules: [
-     *          {path: 'a.b.c', valid: 'string,nonempty,length.-.30,', msg: 'invalid string'}
-     *      ]
-     */
-    isObjectValid(obj, rules) {
-        const getValid = (valid) => {
-            if (typeof valid === 'string') {
-                return valid.split(',').map((el) => el.trim());
-            }
-            if (Array.isArray(valid)) {
-                return valid;
-            }
-        };
-        const checkValidity = (validProps, value) => validProps.find((prop) => {
-            const [name, ...args] = prop.split('.');
-            if (typeof validators[name] === 'function') {
-                return !(
-                    validators[name](value, ...args)
-                );
-            }
-        });
-        // validators
-        const validators = {
-            empty: (v) => Ext.isEmpty(v),
-            required: (v) => !Ext.isEmpty(v),
-            uppercase: (v) => typeof v === 'string' && v.toUpperCase() === v,
-            lowercase: (v) => typeof v === 'string' && v.toLowerCase() === v,
-            true: (v) => v === true,
-            false: (v) => v === false,
-            allowblank: (v) => true,
-            type: (v, expectedType) => {
-                if (expectedType === 'null') {
-                    return v === null;
-                }
-                if (expectedType === 'array') {
-                    return Array.isArray(v);
-                }
-                if (expectedType === 'object') {
-                    return Ext.isObject(v);
-                }
-                return typeof v === expectedType;
-            },
-            not: (name, ...args) => {
-                if (typeof validators[name] !== 'function') {
-                    throw new Error(`validator [${name}] is not exist!`);
-                }
-                return (v, ...args) => validators[name](v, ...args);
-            },
-        };
-        validators['!type'] = (v, typename) => !validators.type(v, typename);
-        validators.string = (v) => validators.type(v, 'string');
-        validators.array = (v) => validators.type(v, 'array');
-        validators.boolean = (v) => validators.type(v, 'boolean');
-        validators.number = (v) => validators.type(v, 'number');
-        validators.object = (v) => validators.type(v, 'object');
-        // EOF validators
-        const getErrors = (obj, rules) => {
-            const errors = Coon.util.filterMap(rules, (rule) => {
-                if (!rule.path) {
-                    return;
-                }
-                const value = Coon.util.getByPath(obj, rule.path);
-                const validTags = getValid(rule.valid) || [];
-                let subErrors;
-                let isInvalid = typeof valid === 'function' ?
-                    validTags(value) :
-                    checkValidity(validTags, value);
-                if (
-                    !Ext.isEmpty(value) &&
-                    !isInvalid &&
-                    Array.isArray(rule.rules) &&
-                    rule.rules.length
-                ) {
-                    const subResult = getErrors(value, rule.rules);
-                    if (!subResult.valid) {
-                        isInvalid = false;
-                        subErrors = subResult.errors.join('\n');
-                    }
-                }
-                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;
-                }
-            });
-            return {
-                valid: !errors.length,
-                errors,
-            };
-        };
-        return getErrors(obj, rules);
-    },
-
     getAllCommandsList() {
         if (Coon.util.locals.getAllCommandsList) {
             return Coon.util.locals.getAllCommandsList;
@@ -665,10 +579,10 @@ Ext.define('Coon.util', {
 
     getInstanceIdProperties(instance) {
         if (instance.id ||
-                instance.xtype ||
-                instance.ptype ||
-                instance.$className ||
-                Ext.isObject(instance.initialConfig)
+            instance.xtype ||
+            instance.ptype ||
+            instance.$className ||
+            Ext.isObject(instance.initialConfig)
         ) {
             return Object.assign(
                 {},
@@ -756,6 +670,7 @@ Ext.define('Coon.util', {
                 }
             }
         }
+
         return detectCycle(data);
     },
 

package/src/util.scss

@@ -0,0 +1,4 @@
+.x-window.toast-success {
+  border: 1px solid green !important;
+  border-radius: 2px !important;
+}

package/src/validator.js

@@ -0,0 +1,184 @@
+Ext.define('Coon.validator', {
+    singleton: true,
+
+    alternateClassName: 'Coon.v',
+
+    constructor() {
+        const validators = {
+            empty: (v) => Ext.isEmpty(v),
+            notempty: (v) => !Ext.isEmpty(v),
+            required: (v) => !Ext.isEmpty(v),
+            uppercase: (v) => typeof v === 'string' && v.toUpperCase() === v,
+            lowercase: (v) => typeof v === 'string' && v.toLowerCase() === v,
+            true: (v) => v === true,
+            false: (v) => v === false,
+            allowblank: (v) => true,
+            type: (v, expectedType) => {
+                if (expectedType === 'null') {
+                    return v === null;
+                }
+                if (expectedType === 'array') {
+                    return Array.isArray(v);
+                }
+                if (expectedType === 'object') {
+                    return Ext.isObject(v);
+                }
+                return typeof v === expectedType;
+            },
+            not: (name, ...args) => {
+                if (typeof validators[name] !== 'function') {
+                    throw new Error(`validator [${name}] is not exist!`);
+                }
+                return (v, ...args) => validators[name](v, ...args);
+            },
+        };
+        validators['!type'] = (v, typename) => !validators.type(v, typename);
+        validators.string = (v) => validators.type(v, 'string');
+        validators.array = (v) => validators.type(v, 'array');
+        validators.boolean = (v) => validators.type(v, 'boolean');
+        validators.number = (v) => validators.type(v, 'number');
+        validators.object = (v) => validators.type(v, 'object');
+        this.addValidator = (name, validator, override) => {
+            if (!validators[name] || override) {
+                validators[name] = validator;
+            }
+        };
+        this.getValidator = (name) => validators[name];
+        this.getValidators = () => validators;
+    },
+
+
+    /**
+     *
+     * @param {Object} obj
+     * @param {Array} rules
+     * @example
+     *      rules: [
+     *          {path: 'a.b.c', valid: 'string,nonempty,length.-.30,', msg: 'invalid string'}
+     *      ]
+     */
+    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());
+            }
+            if (Array.isArray(valid)) {
+                return valid;
+            }
+        };
+        const checkValidity = (validProps, value) => validProps.find((prop) => {
+            const [name, ...args] = prop.split('.');
+            if (typeof validators[name] === 'function') {
+                return validators[name](value, ...args);
+            } else {
+                console.error(`validator [${name}] is not exist!`);
+                return false;
+            }
+        });
+        const validators = this.getValidators();
+        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(src, rule.path);
+                const validTags = getValid(rule.valid) || [];
+                let subResult;
+                const isValid = checkValidity(validTags, value);
+                if (
+                    isValid &&
+                    Array.isArray(rule.rules) &&
+                    rule.rules.length
+                ) {
+                    subResult = getErrors(value, rule.rules);
+                }
+                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,
+                errors,
+            };
+        };
+        return getErrors(obj, rules);
+    },
+
+}, function() {
+    this.assert = new Proxy(this, {
+        get: function(target, name) {
+            if (!name.startsWith('is_')) {
+                return target[name];
+            }
+            const tokens = name.slice(3)
+                .split('_')
+                .map((name) => {
+                    if (!Coon.validator.getValidator(name)) {
+                        return {name};
+                    }
+                    return {
+                        fn: (tested) => {
+                            if (tested.invalid) {
+                                return tested;
+                            }
+                            const isValid = Coon.validator.getValidator(name).call(this, tested.value);
+                            tested.invalid = !isValid;
+                            tested.steps.push({[name]: isValid});
+                            return tested;
+                        },
+                        name,
+                    };
+                });
+            if (tokens.find(({fn}) => !fn)) {
+                return () => {
+                    const tested = {steps: []};
+                    tokens.filter(({fn}) => !fn)
+                        .map(({name}) => name)
+                        .forEach((name) => {
+                            tested.steps.push({[name]: `validator not found`});
+                        });
+                    tested.invalid = true;
+                    return tested;
+                };
+            }
+            if (tokens.length === 0) {
+                return (tested) => {
+                    tested.valid = true;
+                    return tested;
+                };
+            }
+            return (value) => Coon.util.chained(
+                tokens.map((el) => el.fn),
+                {value, steps: []}
+            );
+        },
+    });
+});
+
+Ext.define('Coon.validator.mixin', {
+    constructor(validator) {
+        this.assert = Coon.validator.assert;
+        this.callParent(arguments);
+    },
+});

package/src/version.js

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