@steedos/objectql 2.1.55 → 2.1.59

package/src/types/restrictionRule.ts

@@ -0,0 +1,57 @@
+import { registerRestrictionRules } from '../metadata-register/restrictionRules';
+import { getSteedosSchema } from '../types'
+import * as _ from 'lodash'
+import { isExpression, parseSingleExpression } from '../util'
+import { formatFiltersToODataQuery } from "@steedos/filters";
+
+export type SteedosRestrictionRuleConfig = {
+    _id: string,
+    name: string,
+    object_name: string,
+    active: boolean,
+    record_filter: string,
+    entry_criteria: string,
+    description: string
+}
+
+export class RestrictionRule {
+    static async find(objectApiName) {
+        const schema = getSteedosSchema();
+        return await registerRestrictionRules.find(schema.broker, {
+            pattern: `${objectApiName}.*`
+        })
+    }
+    static async getUserObjectFilters(objectApiName, userSession: any) {
+        const rules = await this.find(objectApiName);
+        if (_.isEmpty(rules)) {
+            return;
+        }
+        const rulesFilters = [];
+        const globalData = { now: new Date() };
+        _.each(rules, (rule) => {
+            const { active, entry_criteria, record_filter } = rule.metadata;
+            if (active) {
+                if (_.isString(entry_criteria) && isExpression(entry_criteria.trim())) {
+                    try {
+                        const meetCriteria = parseSingleExpression(entry_criteria, {}, "#", globalData, userSession);
+                        if (_.isBoolean(meetCriteria) && meetCriteria) {
+                            if (_.isString(record_filter) && isExpression(record_filter.trim())) {
+                                try {
+                                    const filters = parseSingleExpression(record_filter, {}, "#", globalData, userSession);
+                                    if (filters && !_.isString(filters)) {
+                                        rulesFilters.push(`(${formatFiltersToODataQuery(filters, userSession)})`)
+                                    }
+                                } catch (error) {
+                                    console.error(`RestrictionRule.getUserObjectFilters record_filter error`, objectApiName, record_filter, error.message);
+                                }
+                            }
+                        }
+                    } catch (error) {
+                        console.error(`RestrictionRule.getUserObjectFilters entry_criteria error`, objectApiName, entry_criteria, error.message);
+                    }
+                }
+            }
+        })
+        return rulesFilters;
+    }
+}

package/src/types/shareRule.ts

@@ -0,0 +1,57 @@
+import { registerShareRules } from '../metadata-register/shareRules';
+import { getSteedosSchema } from '../types'
+import * as _ from 'lodash'
+import { isExpression, parseSingleExpression } from '../util'
+import { formatFiltersToODataQuery } from "@steedos/filters";
+
+export type SteedosShareRuleConfig = {
+    _id: string,
+    name: string,
+    object_name: string,
+    active: boolean,
+    record_filter: string,
+    entry_criteria: string,
+    description: string
+}
+
+export class ShareRules {
+    static async find(objectApiName) {
+        const schema = getSteedosSchema();
+        return await registerShareRules.find(schema.broker, {
+            pattern: `${objectApiName}.*`
+        })
+    }
+    static async getUserObjectFilters(objectApiName, userSession: any) {
+        const rules = await this.find(objectApiName);
+        if (_.isEmpty(rules)) {
+            return;
+        }
+        const rulesFilters = [];
+        const globalData = { now: new Date() };
+        _.each(rules, (rule) => {
+            const { active, entry_criteria, record_filter } = rule.metadata;
+            if (active) {
+                if (_.isString(entry_criteria) && isExpression(entry_criteria.trim())) {
+                    try {
+                        const meetCriteria = parseSingleExpression(entry_criteria, {}, "#", globalData, userSession);
+                        if (_.isBoolean(meetCriteria) && meetCriteria) {
+                            if (_.isString(record_filter) && isExpression(record_filter.trim())) {
+                                try {
+                                    const filters = parseSingleExpression(record_filter, {}, "#", globalData, userSession);
+                                    if (filters && !_.isString(filters)) {
+                                        rulesFilters.push(`(${formatFiltersToODataQuery(filters, userSession)})`)
+                                    }
+                                } catch (error) {
+                                    console.error(`ShareRules.getUserObjectFilters record_filter error`, objectApiName, record_filter, error.message);
+                                }
+                            }
+                        }
+                    } catch (error) {
+                        console.error(`ShareRules.getUserObjectFilters entry_criteria error`, objectApiName, entry_criteria, error.message);
+                    }
+                }
+            }
+        })
+        return rulesFilters;
+    }
+}

package/src/util/field.ts

@@ -71,13 +71,13 @@ export const getFieldsByType = (doc, type: string, dataType?: string) => {
             fields.push({ name: 'formula_blank_value', required: false });
             fields.push({ name: 'summary_object', required: true });
             fields.push({ name: 'summary_type', required: true });
-            fields.push({ name: 'summary_filters', required: true });
+            fields.push({ name: 'summary_filters', required: false });
             if (doc.summary_type != 'count') {
                 fields.push({ name: 'summary_field', required: true });
             }
-            fields.push({ name: 'data_type', required: true });
-            fields.push({ name: 'precision', required: false });
-            fields.push({ name: 'scale', required: false });
+            fields.push({ name: 'data_type', required: false });
+            fields.push({ name: 'precision', required: true });
+            fields.push({ name: 'scale', required: true });
             fields.push({ name: 'filters' });
             fields.push({ name: 'filters.$' });
             fields.push({ name: 'filters.$.field' });

package/src/util/function_expression.ts

@@ -0,0 +1,63 @@
+import * as _ from 'lodash'
+
+const globalTag = '__G_L_O_B_A_L__';
+
+const getParentPath = function (path) {
+    var pathArr;
+    if (typeof path === 'string') {
+        pathArr = path.split('.');
+        if (pathArr.length === 1) {
+            return '#';
+        }
+        pathArr.pop();
+        return pathArr.join('.');
+    }
+    return '#';
+}
+
+const getValueByPath = function (formData, path) {
+    if (path === '#' || !path) {
+        return formData || {};
+    } else if (typeof path === 'string') {
+        return _.get(formData, path);
+    } else {
+        console.error('path has to be a string');
+    }
+};
+
+export const isExpression = function (func) {
+    var pattern, reg1, reg2;
+    if (typeof func !== 'string') {
+        return false;
+    }
+    pattern = /^{{(.+)}}$/;
+    reg1 = /^{{(function.+)}}$/;
+    reg2 = /^{{(.+=>.+)}}$/;
+    if (typeof func === 'string' && func.match(pattern) && !func.match(reg1) && !func.match(reg2)) {
+        return true;
+    }
+    return false;
+};
+
+export const parseSingleExpression = function (func, formData, dataPath, global, userSession = {}) {
+    var error, funcBody, parent, parentPath, str;
+
+    if (formData === void 0) {
+        formData = {};
+    }
+    parentPath = getParentPath(dataPath);
+    parent = getValueByPath(formData, parentPath) || {};
+    if (typeof func === 'string') {
+        funcBody = func.substring(2, func.length - 2);
+        str = `\n  var $user=${JSON.stringify(userSession)};   return ` + funcBody.replace(/\bformData\b/g, JSON.stringify(formData).replace(/\bglobal\b/g, globalTag)).replace(/\bglobal\b/g, JSON.stringify(global)).replace(new RegExp('\\b' + globalTag + '\\b', 'g'), 'global').replace(/rootValue/g, JSON.stringify(parent));
+        try {
+            return Function(str)();
+        } catch (_error) {
+            error = _error;
+            console.log(error, func, dataPath);
+            return func;
+        }
+    } else {
+        return func;
+    }
+};

package/src/util/index.ts

@@ -27,6 +27,7 @@ export * from './permission_shares'
 export * from './suffix'
 export * from './locale'
 export * from './field'
+export * from './function_expression'
 
 exports.loadJSONFile = (filePath: string)=>{
     return JSON.parse(fs.readFileSync(filePath, 'utf8').normalize('NFC'));