Example #1
0
        private static object CalulateFunction(string funcName, ParamObjectCollection arrParams, object callerContext)
        {
            object result = null;

            var member = (Member)callerContext;
            switch (funcName)
            {
                case "Gender":
                    result = member.Gender;
                    break;
                case "Age":
                    result = member.Age;
                    break;
                case "AnnualHouseholdIncome":
                    result = member.AnnualHouseholdIncome;
                    break;
                case "FamilyComposition":
                    result = member.FamilyComposition;
                    break;
                case "HousePaymentPrice":
                    result = member.HousePaymentPrice;
                    break;
                case "NativePlace":
                    result = member.NativePlace;
                    break;
                case "RegisteredPermanentResidence":
                    result = member.RegisteredPermanentResidence;
                    break;
            }

            return result;
        }
        private static object ExpCalculateUserFunction(string funcName, ParamObjectCollection arrParams, object callerContext)
        {
            object     result  = null;
            ExpContext context = (ExpContext)callerContext;

            switch (funcName.ToLower())
            {
            case "users":
                result = "USERS";
                break;

            case "organizations":
                result = "ORGANIZATIONS";
                break;

            case "groups":
                result = "GROUPS";
                break;

            case "belongto":
                result = CalculateBelongTo((string)arrParams[0].Value, (string)arrParams[1].Value, (string)arrParams[2].Value, context);
                break;

            case "userrank":
                result = CompareUserRank((string)arrParams[0].Value, (string)arrParams[1].Value, context);
                break;
            }

            return(result);
        }
Example #3
0
        private static object UserFunctionImpl(string funcName, ParamObjectCollection arrParams, object callerContext)
        {
            object result = null;

            switch (funcName.ToLower())
            {
                case "power":
                    result = Math.Pow(Decimal.ToDouble((decimal)arrParams[0].Value),
                        Decimal.ToDouble((decimal)arrParams[1].Value));
                    break;
                case "expparse":
                    result = ExpressionParser.Parse((string)arrParams[0].Value).Identifiers.ToString();
                    break;
                case "author":
                    result = "Shen Zheng";
                    break;
                default:
                    if (BuiltInFunctionsCalculator.Instance.IsFunction(funcName))
                        result = BuiltInFunctionHelper.ExecuteFunction(funcName, BuiltInFunctionsCalculator.Instance, arrParams, callerContext);
                    else
                        throw new ApplicationException(string.Format("'{0}'是一个无法识别的标识符.", funcName));
                    break;
            }

            return result;
        }
Example #4
0
        private static object UserFunctionImpl(string funcName, ParamObjectCollection arrParams, object callerContext)
        {
            object result = null;

            switch (funcName.ToLower())
            {
            case "power":
                result = Math.Pow(Decimal.ToDouble((decimal)arrParams[0].Value),
                                  Decimal.ToDouble((decimal)arrParams[1].Value));
                break;

            case "expparse":
                result = ExpressionParser.Parse((string)arrParams[0].Value).Identifiers.ToString();
                break;

            case "author":
                result = "Shen Zheng";
                break;

            default:
                if (BuiltInFunctionsCalculator.Instance.IsFunction(funcName))
                {
                    result = BuiltInFunctionHelper.ExecuteFunction(funcName, BuiltInFunctionsCalculator.Instance, arrParams, callerContext);
                }
                else
                {
                    throw new ApplicationException(string.Format("'{0}'是一个无法识别的标识符.", funcName));
                }
                break;
            }

            return(result);
        }
		public override object GetValue(ISCConditionCalculatingContext context, ParamObjectCollection arrParams)
		{
			object result = context.CurrentObject.Properties.GetValue<string>(this.SchemaAndPropertyName.PropertyName, null);

			if (result == null)
				result = string.Empty;

			return result;
		}
Example #6
0
		internal object OnCalculateUserFunction(string funcName, ParamObjectCollection arrParams, object callerContext)
		{
			object result = null;

			if (ConditionUserFunction != null)
				result = ConditionUserFunction(funcName, arrParams, callerContext);

			return result;
		}
		public object CalculateUserFunction(string funcName, ParamObjectCollection arrParams, object callerContext)
		{
			object result = null;

			if (this.IsFunction(funcName))
				result = BuiltInFunctionHelper.ExecuteFunction(funcName, this, arrParams, callerContext);

			return result;
		}
        public object CalculateUserFunction(string funcName, ParamObjectCollection arrParams, object callerContext)
        {
            object result = null;

            switch (funcName.ToLower())
            {
                case "currentuserinrole":   //CurrentUserInRole
                    CheckParamsCount(funcName, arrParams, 1);
                    result = CurrentUserInRole((string)arrParams[0].Value, callerContext);
                    break;
                case "userinrole":  //UserInRole
                    CheckParamsCount(funcName, arrParams, 2);

                    if (arrParams[1].Value == null)
                        result = false;
                    else
                    {
                        (arrParams[1].Value is IUser).FalseThrow("用户自定义函数{0}的第二个参数值必须是IUser类型", funcName);
                        result = UserInRole((string)arrParams[0].Value, (IUser)arrParams[1].Value, callerContext);
                    }
                    break;
                case "aresamecandidates":   //AreSameCandidates
                    (arrParams.Count == 0 || arrParams.Count == 2).FalseThrow("用户自定义函数{0}必须没有参数或者有两个参数", funcName);

                    switch (arrParams.Count)
                    {
                        case 0:
                            result = AreSameCandidates(callerContext);
                            break;
                        case 2:
                            result = AreSameCandidates((string)arrParams[0].Value, (string)arrParams[1].Value, callerContext);
                            break;
                    }
                    break;
                case "branchesreturnvalue": //BranchesReturnValue
                    result = BranchesReturnValue(callerContext);
                    break;
                case "alltrue": //AllTrue
                    result = BranchProcessReturnType.AllTrue.ToString();
                    break;
                case "allfalse":    //AllFalse
                    result = BranchProcessReturnType.AllFalse.ToString();
                    break;
                case "partialtrue": //PartialTrue
                    result = BranchProcessReturnType.PartialTrue.ToString();
                    break;
                case "containsuser":    //ContainsUser
                    result = ContainsUserImpl(funcName, arrParams, callerContext);
                    break;
                case "allelapsedoperators": //AllElapsedOperators
                    result = AllElapsedOperators(callerContext);
                    break;
            }

            return result;
        }
        public override object GetValue(ISCConditionCalculatingContext context, ParamObjectCollection arrParams)
        {
            object result = context.CurrentObject.Properties.GetValue <string>(this.SchemaAndPropertyName.PropertyName, null);

            if (result == null)
            {
                result = string.Empty;
            }

            return(result);
        }
Example #10
0
        public object CalculateUserFunction(string funcName, ParamObjectCollection arrParams, object callerContext)
        {
            object result = null;

            if (this.IsFunction(funcName))
            {
                result = BuiltInFunctionHelper.ExecuteFunction(funcName, this, arrParams, callerContext);
            }

            return(result);
        }
Example #11
0
        internal object OnCalculateUserFunction(string funcName, ParamObjectCollection arrParams, object callerContext)
        {
            object result = null;

            if (ConditionUserFunction != null)
            {
                result = ConditionUserFunction(funcName, arrParams, callerContext);
            }

            return(result);
        }
        private static bool ContainsUserImpl(string funcName, ParamObjectCollection arrParams, object callerContext)
        {
            CheckParamsCount(funcName, arrParams, 2);

            (arrParams[0].Value is IEnumerable<IUser>).FalseThrow("用户自定义函数{0}的第一个参数值必须是IEnumerable<IUser>类型", funcName);
            (arrParams[1].Value is IUser).FalseThrow("用户自定义函数{0}的第二个参数值必须是IUser类型", funcName);

            IEnumerable<IUser> users = (IEnumerable<IUser>)arrParams[0].Value;
            IUser target = (IUser)arrParams[1].Value;

            return users.Contains(target, OguObjectIDEqualityComparer<IUser>.Default);
        }
        private static bool ContainsUserImpl(string funcName, ParamObjectCollection arrParams, object callerContext)
        {
            CheckParamsCount(funcName, arrParams, 2);

            (arrParams[0].Value is IEnumerable <IUser>).FalseThrow("用户自定义函数{0}的第一个参数值必须是IEnumerable<IUser>类型", funcName);
            (arrParams[1].Value is IUser).FalseThrow("用户自定义函数{0}的第二个参数值必须是IUser类型", funcName);

            IEnumerable <IUser> users = (IEnumerable <IUser>)arrParams[0].Value;
            IUser target = (IUser)arrParams[1].Value;

            return(users.Contains(target, OguObjectIDEqualityComparer <IUser> .Default));
        }
		/// <summary>
		/// 执行函数
		/// </summary>
		/// <param name="funcName"></param>
		/// <param name="target"></param>
		/// <param name="arrParams"></param>
		/// <param name="callerContext"></param>
		/// <returns></returns>
		public static object ExecuteFunction(string funcName, object target, ParamObjectCollection arrParams, object callerContext)
		{
			target.NullCheck("target");

			BuiltInFunctionInfoCollection funcsInfo = GetBuiltInFunctionsInfo(target.GetType());

			object result = null;

			if (funcsInfo.Contains(funcName))
				result = funcsInfo[funcName].ExecuteFunction(target, arrParams, callerContext);

			return result;
		}
		/// <summary>
		/// 执行静态函数
		/// </summary>
		/// <param name="funcName"></param>
		/// <param name="type"></param>
		/// <param name="arrParams"></param>
		/// <param name="callerContext"></param>
		/// <returns></returns>
		public static object ExecuteFunction(string funcName, Type type, ParamObjectCollection arrParams, object callerContext)
		{
			type.NullCheck("type");

			BuiltInFunctionInfoCollection funcsInfo = GetBuiltInFunctionsInfo(type);

			object result = null;

			if (funcsInfo.Contains(funcName))
				result = funcsInfo[funcName].ExecuteFunction(null, arrParams, callerContext);

			return result;
		}
		/// <summary>
		/// 计算内置函数
		/// </summary>
		/// <param name="funcName"></param>
		/// <param name="arrParams"></param>
		/// <param name="callerContext"></param>
		/// <returns></returns>
		public object Calculate(string funcName, ParamObjectCollection arrParams, object callerContext)
		{
			object result = null;

			if (WfCreateActivityBuiltInFunctions.Instance.IsFunction(funcName) == false)
			{
				result = MatchedActivityKey(funcName, (WfCreateActivityFunctionContext)callerContext);

				if (result == null || (string)result == string.Empty)
					throw new InvalidOperationException(string.Format("\"{0}\"是非法的函数名称", funcName));
			}
			else
				result = BuiltInFunctionHelper.ExecuteFunction(funcName, this, arrParams, callerContext);

			return result;
		}
        public object GetUserFunctionValue(string strFuncName, ParamObjectCollection arrParams)
        {
            object oValue = null;

            if (this.CalculateUserFunction != null)
            {
                oValue = this.CalculateUserFunction(strFuncName, arrParams, this.CallerContxt);
            }
            else
                if (this.BuiltInFunctionsWrapper != null)
                {
                    oValue = BuiltInFunctionHelper.ExecuteFunction(strFuncName, this.BuiltInFunctionsWrapper, arrParams, this.CallerContxt);
                }

            return oValue;
        }
        private static object CallUserFunctionsPlugIns(string funcName, ParamObjectCollection paramObjects, object callerContext)
        {
            object result = null;

            foreach (IWfCalculateUserFunction uf in WfActionSettings.GetConfig().Functions)
            {
                result = uf.CalculateUserFunction(funcName, paramObjects, callerContext);

                if (result != null)
                {
                    break;
                }
            }

            return(result);
        }
Example #19
0
        /// <summary>
        /// 计算内置函数
        /// </summary>
        /// <param name="funcName"></param>
        /// <param name="arrParams"></param>
        /// <param name="callerContext"></param>
        /// <returns></returns>
        public object Calculate(string funcName, ParamObjectCollection arrParams, object callerContext)
        {
            object result = null;

            if (WfCreateActivityBuiltInFunctions.Instance.IsFunction(funcName) == false)
            {
                result = MatchedActivityKey(funcName, (WfCreateActivityFunctionContext)callerContext);

                if (result == null || (string)result == string.Empty)
                {
                    throw new InvalidOperationException(string.Format("\"{0}\"是非法的函数名称", funcName));
                }
            }
            else
            {
                result = BuiltInFunctionHelper.ExecuteFunction(funcName, this, arrParams, callerContext);
            }

            return(result);
        }
        private static object InternalCalculateFunction(string funcName, ParamObjectCollection arrParams, object callerContext)
        {
            List<int> list = (List<int>)callerContext;

            object result = false;

            switch (funcName.ToLower())
            {
                case "data1":
                    result = 1;
                    list.Add(1);
                    break;
                case "data2":
                    result = 2;
                    list.Add(2);
                    break;
            }

            return result;
        }
        private static object CalculateUserFunction(string funcName, ParamObjectCollection arrParams, object callerContext)
        {
            SCConditionCalculatingContext context = (SCConditionCalculatingContext)callerContext;

            object result = null;

            if (SCBuiltInFunctionsCalculator.Instance.IsFunction(funcName))
            {
                //如果是内置函数,则返回内置函数的结果
                result = SCBuiltInFunctionsCalculator.Instance.Calculate(funcName, arrParams, context);
            }
            else
            {
                //根据函数名称,获取属性访问器
                SCPropertyAccessorBase accessor = GetPropertyAccessor(funcName, context);
                result = accessor.GetValue(context, arrParams);
            }

            return(result);
        }
        internal object FireEvaluateDynamicResourceCondition(string funcName, ParamObjectCollection paramObjects, object callerContext)
        {
            object result = null;

            if (EvaluateDynamicResourceCondition != null)
            {
                result = EvaluateDynamicResourceCondition(funcName, paramObjects, callerContext);
            }

            if (result == null && paramObjects.Count == 0)
            {
                result = GetConditionValueFromAppRuntimeParameters((WfConditionDescriptor)callerContext, funcName);
            }

            if (result == null)
            {
                result = CallUserFunctionsPlugIns(funcName, paramObjects, callerContext);
            }

            return(result);
        }
Example #23
0
        private static object InternalCalculateFunction(string funcName, ParamObjectCollection arrParams, object callerContext)
        {
            List <int> list = (List <int>)callerContext;

            object result = false;

            switch (funcName.ToLower())
            {
            case "data1":
                result = 1;
                list.Add(1);
                break;

            case "data2":
                result = 2;
                list.Add(2);
                break;
            }

            return(result);
        }
        private static object EvaluateRoleMatrixCondition(string funcName, ParamObjectCollection paramObjects, object callerContext)
        {
            object result = null;

            switch (funcName.ToLower())
            {
            case "rowoperators":
                result = CalculateRowOperators();
                break;

            case "rowoperators.count":
                result = CalculateRowOperators().Count;
                break;

            default:
                result = WfRuntime.ProcessContext.FireEvaluateRoleMatrixCondition(funcName, paramObjects, callerContext);
                break;
            }

            return(result);
        }
Example #25
0
        private static object CalulateFunction(string funcName, ParamObjectCollection arrParams, object callerContext)
        {
            object result = null;

            var member = (Member)callerContext;

            switch (funcName)
            {
            case "Gender":
                result = member.Gender;
                break;

            case "Age":
                result = member.Age;
                break;

            case "AnnualHouseholdIncome":
                result = member.AnnualHouseholdIncome;
                break;

            case "FamilyComposition":
                result = member.FamilyComposition;
                break;

            case "HousePaymentPrice":
                result = member.HousePaymentPrice;
                break;

            case "NativePlace":
                result = member.NativePlace;
                break;

            case "RegisteredPermanentResidence":
                result = member.RegisteredPermanentResidence;
                break;
            }

            return(result);
        }
 /// <summary>
 /// 计算内置函数
 /// </summary>
 /// <param name="funcName"></param>
 /// <param name="arrParams"></param>
 /// <param name="callerContext"></param>
 /// <returns></returns>
 public object Calculate(string funcName, ParamObjectCollection arrParams, object callerContext)
 {
     return(BuiltInFunctionHelper.ExecuteFunction(funcName, this, arrParams, callerContext));
 }
		private static object CallUserFunctionsPlugIns(string funcName, ParamObjectCollection paramObjects, object callerContext)
		{
			object result = null;

			foreach (IWfCalculateUserFunction uf in WfActionSettings.GetConfig().Functions)
			{
				result = uf.CalculateUserFunction(funcName, paramObjects, callerContext);

				if (result != null)
					break;
			}

			return result;
		}
		internal object FireEvaluateDynamicResourceCondition(string funcName, ParamObjectCollection paramObjects, object callerContext)
		{
			object result = null;

			if (EvaluateDynamicResourceCondition != null)
				result = EvaluateDynamicResourceCondition(funcName, paramObjects, callerContext);

			if (result == null && paramObjects.Count == 0)
				result = GetConditionValueFromAppRuntimeParameters((WfConditionDescriptor)callerContext, funcName);

			if (result == null)
				result = CallUserFunctionsPlugIns(funcName, paramObjects, callerContext);

			return result;
		}
		public abstract object GetValue(ISCConditionCalculatingContext context, ParamObjectCollection arrParams);
 private static void CheckParamsCount(string funcName, ParamObjectCollection arrParams, int count)
 {
     (arrParams.Count == count).FalseThrow("用户自定义函数\"{0}\"必须有{1}个参数", funcName, count);
 }
        /// <summary>
        /// 计算所有参数都已经准备好了的函数
        /// </summary>
        /// <param name="strFuncName"></param>
        /// <param name="arrParams"></param>
        /// <param name="calcContext"></param>
        /// <returns></returns>
        private static object CalculateFunctionWithParameters(string strFuncName, ParamObjectCollection arrParams, CalculateContext calcContext)
        {
            object oValue = null;

            try
            {
                switch (strFuncName.ToLower())
                {
                    case "now":
                        oValue = DateTime.Now;
                        break;
                    case "today":
                        oValue = DateTime.Today;
                        break;
                    case "dateinterval.day":
                        oValue = "d";
                        break;
                    case "dateinterval.hour":
                        oValue = "h";
                        break;
                    case "dateinterval.minute":
                        oValue = "n";
                        break;
                    case "dateinterval.second":
                        oValue = "s";
                        break;
                    case "dateinterval.millisecond":
                        oValue = "ms";
                        break;
                    case "datediff":
                        oValue = DoDateDiff(arrParams);
                        break;
                    case "mindate":
                        oValue = DateTime.MinValue;
                        break;
                    case "maxdate":
                        oValue = DateTime.MaxValue;
                        break;
                    //default:
                    //    {
                    //        if (calcContext.CalculateUserFunction != null)
                    //            oValue = calcContext.CalculateUserFunction(strFuncName, arrParams, calcContext.CallerContxt);

                    //        break;
                    //    }
                }

                return oValue;
            }
            catch (ParsingException)
            {
                throw;
            }
            catch (System.Exception ex)
            {
                throw new SystemSupportException(string.Format(ExpressionParserRes.FunctionError, strFuncName, ex.Message));
            }
        }
        private static object DoInFunction(ParamObjectCollection arrParams, CalculateContext calcContext)
        {
            bool result = false;

            if (arrParams.Count > 0)
            {
                object sourceData = arrParams[0].Value;

                for (int i = 1; i < arrParams.Count; i++)
                {
                    if ((bool)CompareEqualOP(sourceData, arrParams[i].Value, 0))
                    {
                        result = true;
                        break;
                    }
                }
            }

            return result;
        }
 private static void CheckParamsCount(string funcName, ParamObjectCollection arrParams, int count)
 {
     (arrParams.Count == count).FalseThrow("用户自定义函数\"{0}\"必须有{1}个参数", funcName, count);
 }
		/// <summary>
		/// 计算内置函数
		/// </summary>
		/// <param name="funcName"></param>
		/// <param name="arrParams"></param>
		/// <param name="callerContext"></param>
		/// <returns></returns>
		public object Calculate(string funcName, ParamObjectCollection arrParams, object callerContext)
		{
			return BuiltInFunctionHelper.ExecuteFunction(funcName, this, arrParams, callerContext);
		}
 public abstract object GetValue(ISCConditionCalculatingContext context, ParamObjectCollection arrParams);
Example #36
0
        private object ProcessContext_EvaluateDynamicResourceCondition(string funcName, ParamObjectCollection arrParams, object callerContext)
        {
            object result = null;

            switch (funcName)
            {
            case "Requestor":
                List <IUser> users = new List <IUser>();

                users.Add((IUser)OguObjectSettings.GetConfig().Objects["requestor"].Object);
                users.Add((IUser)OguObjectSettings.GetConfig().Objects["approver1"].Object);

                result = users;
                break;

            case "EmptyUser":
                OguUser user = new OguUser("FakeID");
                user.ID = string.Empty;
                result  = user;
                break;
            }

            return(result);
        }
		private static object ExpCalculateUserFunction(string funcName, ParamObjectCollection arrParams, object callerContext)
		{
			object result = null;
			ExpContext context = (ExpContext)callerContext;

			switch (funcName.ToLower())
			{
				case "users":
					result = "USERS";
					break;
				case "organizations":
					result = "ORGANIZATIONS";
					break;
				case "groups":
					result = "GROUPS";
					break;
				case "belongto":
					result = CalculateBelongTo((string)arrParams[0].Value, (string)arrParams[1].Value, (string)arrParams[2].Value, context);
					break;
				case "userrank":
					result = CompareUserRank((string)arrParams[0].Value, (string)arrParams[1].Value, context);
					break;
			}

			return result;
		}
        /// <summary>
        /// 计算表达式字典
        /// </summary>
        /// <param name="strFuncName"></param>
        /// <param name="arrParams"></param>
        /// <param name="calcContext"></param>
        /// <returns></returns>
        private static object CalculateExpressionDictionary(string strFuncName, ParamObjectCollection arrParams, CalculateContext calcContext)
        {
            ExpressionDictionaryCollection dictionaries = (ExpressionDictionaryCollection)ObjectContextCache.Instance.GetOrAddNewValue(
                "ExpressionDictionaries",
                (cache, key) =>
                {
                    ExpressionDictionaryCollection expDicts = new ExpressionDictionaryCollection();

                    expDicts.InitFromConfiguration(ExpressionDictionarySettings.GetConfig());

                    cache.Add("ExpressionDictionaries", expDicts);

                    return expDicts;
                });

            ExpressionDictionary dictionary = dictionaries[strFuncName];

            object oValue = null;

            if (dictionary != null)
            {
                ExpressionDictionaryCalculatorContext context = new ExpressionDictionaryCalculatorContext(dictionary, calcContext.CallerContxt);

                string key = string.Empty;

                if (arrParams.Count > 0 && arrParams[0].Value != null)
                    key = arrParams[0].Value.ToString();

                oValue = dictionary.Calculator.Calculate(strFuncName, key, context);
            }

            return oValue;
        }
        private object ProcessContext_EvaluateDynamicResourceCondition(string funcName, ParamObjectCollection arrParams, object callerContext)
        {
            object result = null;

            switch (funcName)
            {
                case "Requestor":
                    List<IUser> users = new List<IUser>();

                    users.Add((IUser)OguObjectSettings.GetConfig().Objects["requestor"].Object);
                    users.Add((IUser)OguObjectSettings.GetConfig().Objects["approver1"].Object);

                    result = users;
                    break;
                case "EmptyUser":
                    OguUser user = new OguUser("FakeID");
                    user.ID = string.Empty;
                    result = user;
                    break;
            }

            return result;
        }
        public object CalculateUserFunction(string funcName, ParamObjectCollection arrParams, object callerContext)
        {
            object result = null;

            switch (funcName.ToLower())
            {
            case "currentuserinrole":       //CurrentUserInRole
                CheckParamsCount(funcName, arrParams, 1);
                result = CurrentUserInRole((string)arrParams[0].Value, callerContext);
                break;

            case "userinrole":      //UserInRole
                CheckParamsCount(funcName, arrParams, 2);

                if (arrParams[1].Value == null)
                {
                    result = false;
                }
                else
                {
                    (arrParams[1].Value is IUser).FalseThrow("用户自定义函数{0}的第二个参数值必须是IUser类型", funcName);
                    result = UserInRole((string)arrParams[0].Value, (IUser)arrParams[1].Value, callerContext);
                }
                break;

            case "aresamecandidates":       //AreSameCandidates
                (arrParams.Count == 0 || arrParams.Count == 2).FalseThrow("用户自定义函数{0}必须没有参数或者有两个参数", funcName);

                switch (arrParams.Count)
                {
                case 0:
                    result = AreSameCandidates(callerContext);
                    break;

                case 2:
                    result = AreSameCandidates((string)arrParams[0].Value, (string)arrParams[1].Value, callerContext);
                    break;
                }
                break;

            case "branchesreturnvalue":     //BranchesReturnValue
                result = BranchesReturnValue(callerContext);
                break;

            case "alltrue":     //AllTrue
                result = BranchProcessReturnType.AllTrue.ToString();
                break;

            case "allfalse":        //AllFalse
                result = BranchProcessReturnType.AllFalse.ToString();
                break;

            case "partialtrue":     //PartialTrue
                result = BranchProcessReturnType.PartialTrue.ToString();
                break;

            case "containsuser":        //ContainsUser
                result = ContainsUserImpl(funcName, arrParams, callerContext);
                break;

            case "allelapsedoperators":     //AllElapsedOperators
                result = AllElapsedOperators(callerContext);
                break;
            }

            return(result);
        }
        private static object DoDateDiff(ParamObjectCollection arrParams)
        {
            arrParams.CheckParamsLength(3);
            arrParams[0].CheckParameterType<string>();
            arrParams[1].CheckParameterType<DateTime>();
            arrParams[2].CheckParameterType<DateTime>();

            DateTime startTime = (DateTime)arrParams[1].Value;
            DateTime endTime = (DateTime)arrParams[2].Value;

            TimeSpan ts = endTime - startTime;

            double result = 0;

            string intervalType = arrParams[0].Value.ToString().ToLower();

            switch (intervalType)
            {
                case "d":
                    result = ts.TotalDays;
                    break;
                case "h":
                    result = ts.TotalHours;
                    break;
                case "n":
                    result = ts.TotalMinutes;
                    break;
                case "s":
                    result = ts.TotalSeconds;
                    break;
                case "ms":
                    result = ts.TotalMilliseconds;
                    break;
                default:
                    throw new SystemSupportException(string.Format(ExpressionParserRes.InvalidDateDiffType, intervalType));
            }

            return Math.Ceiling(Convert.ToDecimal(result));
        }
		private static object CalculateObjectFunction(string funcName, ParamObjectCollection arrParams, object callerContext)
		{
			AUConditionCalculatingContext context = (AUConditionCalculatingContext)callerContext;

			object result = null;

			if (SCBuiltInFunctionsCalculator.Instance.IsFunction(funcName))
			{
				//如果是内置函数,则返回内置函数的结果
				result = SCBuiltInFunctionsCalculator.Instance.Calculate(funcName, arrParams, context);
			}
			else
			{
				//根据函数名称,获取属性访问器
				SCPropertyAccessorBase accessor = GetPropertyAccessor(funcName, context);
				result = accessor.GetValue(context, arrParams);
			}

			return result;
		}