@steedos/objectql 2.1.54 → 2.1.58

package/src/dynamic-load/trigger.ts

@@ -35,8 +35,8 @@ export const addObjectListenerConfig = (json: SteedosListenerConfig) => {
         throw new Error('missing attribute listenTo')
     }
 
-    if (!_.isString(json.listenTo) && !_.isFunction(json.listenTo)) {
-        throw new Error('listenTo must be a function or string')
+    if (!_.isString(json.listenTo) && !_.isFunction(json.listenTo) && !_.isArray(json.listenTo) && !_.isRegExp(json.listenTo)) {
+        throw new Error('listenTo must be a function or string or array or regExp')
     }
 
     let object_name = '';
@@ -46,22 +46,29 @@ export const addObjectListenerConfig = (json: SteedosListenerConfig) => {
     } else if (_.isFunction(json.listenTo)) {
         object_name = json.listenTo()
     }
-
-    let object = getObjectConfig(object_name);
-    if (object) {
-        if(!object.listeners){
-            object.listeners = {}
+    if(object_name){
+        let object = getObjectConfig(object_name);
+        if (object) {
+            if(!object.listeners){
+                object.listeners = {}
+            }
+            delete json.listenTo
+            const license = clone(json);
+            license.name = json._id || getMD5(JSONStringify(json));
+            object.listeners[license.name] = license
+            if(object.datasource === 'meteor'){
+                util.extend(object, {triggers: transformListenersToTriggers(object, license)})
+            }
         }
-        delete json.listenTo
-        const license = clone(json);
-        license.name = json._id || getMD5(JSONStringify(json));
-        object.listeners[license.name] = license
-        if(object.datasource === 'meteor'){
-            util.extend(object, {triggers: transformListenersToTriggers(object, license)})
+        addLazyLoadListeners(object_name, Object.assign({}, json, {listenTo: object_name}));
+        return Object.assign({}, json, {listenTo: object_name}); 
+    }else{
+        if(_.isRegExp(json.listenTo)){
+            return Object.assign({}, json, {listenTo: json.listenTo.toString()}); 
+        }else{
+            return json; 
         }
     }
-    addLazyLoadListeners(object_name, Object.assign({}, json, {listenTo: object_name}));
-    return Object.assign({}, json, {listenTo: object_name}); 
 }
 
 export const loadObjectTriggers = function (filePath: string){

package/src/formula/core.ts

@@ -11,6 +11,7 @@ import _ = require('lodash')
 // import _eval = require('eval')
 import { extract, parse } from '@steedos/formula';
 import { getFieldSubstitution, FormulonDataType } from './params'
+import { getSimpleParamSubstitution } from './simple_params'
 
 /**
  * 根据公式内容，取出其中{}中的变量
@@ -63,7 +64,7 @@ export const computeFormulaParams = async (doc: JsonMap, vars: Array<SteedosForm
     let params: Array<SteedosFormulaParamTypeConfig> = [];
     const spaceId = doc.space;
     if (vars && vars.length) {
-        for (let { key, paths, is_user_var: isUserVar } of vars) {
+        for (let { key, paths, is_user_var: isUserVar, is_simple_var: isSimpleVar } of vars) {
             key = key.trim();
             // 如果变量key以$user开头,则解析为userSession,此时paths为空
             let tempValue: any;
@@ -83,6 +84,16 @@ export const computeFormulaParams = async (doc: JsonMap, vars: Array<SteedosForm
                 // tempFormulaParams[FormulaUserKey] = currentUserId;
                 // tempValue = evalFieldFormula(tepmFormula, tempFormulaParams);
             }
+            if(isSimpleVar){
+                // 普通变量，取参数值时直接取值，而不用走变量上的paths属性。
+                // 注意未传入objectName时，公式中的user var的isSimpleVar为false，还是走下面的paths取值逻辑。
+                tempValue = <any>doc[key];
+                params.push({
+                    key: key,
+                    value: tempValue
+                });
+                continue;
+            }
             tempValue = _.reduce(paths, (reslut, next, index) => {
                 if (index === 0) {
                     if (isUserVar) {
@@ -176,7 +187,13 @@ export const runFormula = function (formula: string, params: Array<SteedosFormul
         // formulaParams[key] = value;
         // 把{}括起来的变量替换为计算得到的变量值
         // formula = formula.replace(`{${key}}`, `__params["${key}"]`);
-        formulaParams[key] = getFieldSubstitution(path.reference_from, path.field_name, value, blankValue);
+        if(path){
+            formulaParams[key] = getFieldSubstitution(path.reference_from, path.field_name, value, blankValue);
+        }
+        else{
+            // 变量中没有path属性说明是普通变量
+            formulaParams[key] = getSimpleParamSubstitution(value, blankValue);
+        }
     });
     
     // console.log("===runFormula===formula====", formula);

package/src/formula/index.ts

@@ -58,4 +58,24 @@ async function _computeFormula(formula: string, objectName:string, data: any, cu
     return runFormula(formula, params, options, {objectName});
 }
 
-export const computeFormula = _computeFormula 
+export const computeFormula = _computeFormula 
+
+async function _computeSimpleFormula(formula: string, data: any, currentUserId?: string, spaceId?: string, options?: SteedosFormulaOptions) {
+    // objectConfig参数值设置为null传入computeFormulaVarsAndQuotes表示计算不带objectConfig参数的普通公式变量
+    const varsAndQuotes = await computeFormulaVarsAndQuotes(formula, null);
+    const vars = varsAndQuotes.vars;
+    if (!currentUserId) {
+        const required = isCurrentUserIdRequiredForFormulaVars(vars);
+        if(required){
+            throw new Error(`The param 'currentUserId' is required for formula ${formula.replace("$", "\\$")}`);
+        }
+    }
+    if(spaceId){
+        data.space = spaceId;
+    }
+
+    let params = await computeFormulaParams(data, vars, currentUserId);
+    return runFormula(formula, params, options);
+}
+
+export const computeSimpleFormula = _computeSimpleFormula 

package/src/formula/simple_params.ts

@@ -0,0 +1,92 @@
+import { SteedosFormulaBlankValue } from './type';
+import { FormulonDataType } from './params';
+
+const VALUE_TYPES_NOT_SUPPORTED = ["function"];
+
+function getSubstitutionDataType(value: any){
+    const valueType = typeof value;
+    let dateType: FormulonDataType;
+    if(VALUE_TYPES_NOT_SUPPORTED.indexOf(dateType) > -1){
+        throw new Error(`runFormula:Catch an error the param type "${valueType}" is not supported while eval formula with the params value: "${value}"`);
+    }
+    switch (valueType) {
+        case 'string':
+            dateType = FormulonDataType.Text;
+            break;
+        case 'number':
+            dateType = FormulonDataType.Number;
+            break;
+        case 'boolean':
+            dateType = FormulonDataType.Checkbox;
+            break;
+        case 'object':
+            if(value === null){
+                dateType = FormulonDataType.Null;
+            }
+            else if (value instanceof Date){
+                dateType = FormulonDataType.Datetime;
+            }
+            else{
+                throw new Error(`runFormula:Catch an error the param type "${valueType}" is not supported while eval formula with the params value: "${value}"`);
+            }
+            break;
+        case 'undefined':
+            dateType = FormulonDataType.Null;
+            break;
+        default:
+            break;
+    }
+    return dateType;
+}
+
+function getSubstitutionOptions(dataType: string, value: any){
+    switch (dataType) {
+        case FormulonDataType.Number:
+            let scale = 0;
+            let str = value.toString();
+            let dotStr = str.toString().split(".")[1];
+            let dotCount = dotStr && dotStr.length;
+            if(dotCount > 0){
+                scale = dotCount;
+            }
+            return { scale };
+        case FormulonDataType.Text:
+            return {length: Number.MAX_VALUE};
+        default:
+            return ;
+    }
+}
+
+function getSubstitutionValue(dataType: string, value: any, blankValue: SteedosFormulaBlankValue){
+    switch (dataType) {
+        case FormulonDataType.Text:
+            if(value === null || value === undefined){
+                return '';
+            }
+            break;
+        case FormulonDataType.Number:
+            if(value === null || value === undefined){
+                if(blankValue === SteedosFormulaBlankValue.blanks){
+                    return null;
+                }
+                else{
+                    return 0;
+                }
+            }
+            break;
+        default:
+            break;
+    }
+    return value;
+}
+
+export function getSimpleParamSubstitution(value: any, blankValue: SteedosFormulaBlankValue){
+    let fieldSubstitution: any = {
+        type: 'literal',
+        value: value
+    }
+    fieldSubstitution.dataType = getSubstitutionDataType(value);
+    fieldSubstitution.options = getSubstitutionOptions(fieldSubstitution.dataType, value);
+    fieldSubstitution.value  = getSubstitutionValue(fieldSubstitution.dataType, value, blankValue);
+    return fieldSubstitution;
+}

package/src/formula/type.ts

@@ -44,7 +44,7 @@ export type SteedosFormulaVarPathTypeConfig = {
  */
 export type SteedosFormulaParamTypeConfig = {
     key: string,
-    path: any,
+    path?: any,
     value: any
 }
 
@@ -62,8 +62,9 @@ export type SteedosFormulaParamTypeConfig = {
  */
 export type SteedosFormulaVarTypeConfig = {
     key: string,
-    paths: Array<SteedosFormulaVarPathTypeConfig>,
-    is_user_var?: boolean
+    paths?: Array<SteedosFormulaVarPathTypeConfig>,
+    is_user_var?: boolean,
+    is_simple_var?: boolean //当不传入objectApiName时变量上设置该属性表示一个普通的变量，此时paths为空
 }
 
 export type SteedosFieldFormulaTypeConfig = {

package/src/index.ts

@@ -10,4 +10,7 @@ export * from "./dynamic-load"
 export * from './metadata-register/query'
 export * from './metadata-register/chart'
 export * from './metadata-register/page'
-export * from './metadata-register/tab'
+export * from './metadata-register/tab'
+export * from './metadata-register/shareRules'
+export * from './metadata-register/restrictionRules'
+export * from './metadata-register/permissionFields'

package/src/metadata-register/_base.ts

@@ -1,3 +1,5 @@
+import { JsonMap } from "@salesforce/ts-types"
+import * as _ from 'lodash';
 const clone = require('clone');
 export class RegisterBase{
     serviceName;
@@ -5,9 +7,14 @@ export class RegisterBase{
         this.serviceName = serviceName;
     }
 
+    getApiName(metadata) {
+        return metadata._id || metadata.name;
+    }
+
     async register(broker, packageServiceName, config){
         const metadata = clone(config);
-        const res = await broker.call(`${this.serviceName}.add`, {apiName: metadata._id || metadata.name ,data: metadata}, {meta: {
+        const res = await broker.call(`${this.serviceName}.add`, { apiName: this.getApiName(metadata), data: metadata }, {
+            meta: {
             metadataServiceName: packageServiceName,
             caller: {
                 nodeID: broker.nodeID,
@@ -19,8 +26,12 @@ export class RegisterBase{
         return res;
     }
 
-    async remove(broker, metadataApiName){
-        const res = await broker.call(`${this.serviceName}.delete`, {fullName: metadataApiName});
+    async remove(broker, metadataApiNameOrConfig: string | JsonMap) {
+        let metadataApiName = metadataApiNameOrConfig;
+        if (_.isObject(metadataApiName)) {
+            metadataApiName = this.getApiName(metadataApiNameOrConfig);
+        }
+        const res = await broker.call(`${this.serviceName}.delete`, { fullName: metadataApiName, metadataApiName: metadataApiName });
         return res;
     }
 

package/src/metadata-register/permissionFields.ts

@@ -0,0 +1,13 @@
+import { RegisterBase } from "./_base";
+const SERVICE_NAME = 'permission_fields';
+class RegisterPermissionFields extends RegisterBase {
+    constructor() {
+        super(SERVICE_NAME);
+    }
+
+    getApiName(config) {
+        return `${config.name}`
+    }
+}
+
+export const registerPermissionFields = new RegisterPermissionFields();

package/src/metadata-register/restrictionRules.ts

@@ -0,0 +1,12 @@
+import { RegisterBase } from "./_base";
+const SERVICE_NAME = 'restriction_rules';
+class RegisterRestrictionRules extends RegisterBase {
+    constructor() {
+        super(SERVICE_NAME);
+    }
+
+    getApiName(config) {
+        return `${config.object_name}.${config.name}`
+    }
+}
+export const registerRestrictionRules = new RegisterRestrictionRules();

package/src/metadata-register/shareRules.ts

@@ -0,0 +1,13 @@
+import { RegisterBase } from "./_base";
+const SERVICE_NAME = 'share_rules';
+class RegisterShareRules extends RegisterBase {
+    constructor() {
+        super(SERVICE_NAME);
+    }
+
+    getApiName(config) {
+        return `${config.object_name}.${config.name}`
+    }
+}
+
+export const registerShareRules = new RegisterShareRules();

package/src/ts-types/triggerActionParams.ts

@@ -2,6 +2,7 @@ import { JsonMap } from "@salesforce/ts-types";
 import { SteedosIDType } from "..";
 
 export type TriggerActionParams = {
+    objectName?: string
     isExecuting?: boolean,
     isInsert?: boolean,
     isUpdate?: boolean,

package/src/types/field_permission.ts

@@ -0,0 +1,26 @@
+import { registerPermissionFields } from '../metadata-register/permissionFields';
+import { getSteedosSchema } from '../types'
+import * as _ from 'lodash'
+
+export class FieldPermission {
+
+    static async getObjectFieldsPermission(objectApiName, permissionSetApiName) {
+        const schema = getSteedosSchema();
+        return await registerPermissionFields.find(schema.broker, {
+            pattern: `${permissionSetApiName}.${objectApiName}.*`
+        })
+    }
+
+    static async getObjectFieldsPermissionGroupRole(objectApiName) {
+        const permissions = await this.getObjectFieldsPermission(objectApiName, '*');
+        const result = {};
+        _.each(permissions, (permission) => {
+            const { permission_set_id, field, editable, readable } = permission.metadata;
+            if (!result[permission_set_id]) {
+                result[permission_set_id] = [];
+            }
+            result[permission_set_id].push({ field: field, read: readable, edit: editable })
+        })
+        return result;
+    }
+}