ru.coon 3.0.58 → 3.0.59

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+# 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 +16,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.59",
   "repository": {
     "type": "git",
     "url": "git+http://gitlab-dbr.sigma-it.local/dbr/ru.coon"

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'},

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

@@ -210,7 +210,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 +228,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 +258,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 +385,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 +581,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 +672,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,173 @@
+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) {
+        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)
+                );
+            }
+        });
+        const validators = this.getValidators();
+        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);
+    },
+
+}, 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.59',
 });