Beispiel #1
0
        public static ICalculate GetAggCalculate(AggregateCalculateType act)
        {
            ICalculate co = null;

            if (act == AggregateCalculateType.C_Avg)
            {
                co = new Avg();
            }
            else if (act == AggregateCalculateType.C_Sum)
            {
                co = new Sum();
            }
            else if (act == AggregateCalculateType.C_Max)
            {
                co = new Max();
            }
            else if (act == AggregateCalculateType.C_Min)
            {
                co = new Min();
            }

            if (co == null)
            {
                co = new Avg();
            }
            return(co);
        }
        public static Calculate.Calculate GetAggregateCalculate(string resultId, AggregateCalculateType calType)
        {
            Calculate.Calculate calEntity;
            switch (calType)
            {
            case AggregateCalculateType.C_Avg:
                calEntity = new Avg(resultId);
                break;

            case AggregateCalculateType.C_Max:
                calEntity = new Max(resultId);
                break;

            case AggregateCalculateType.C_Min:
                calEntity = new Min(resultId);
                break;

            case AggregateCalculateType.C_Mode:
                calEntity = new Mode(resultId);
                break;

            case AggregateCalculateType.C_Sum:
                calEntity = new Sum(resultId);
                break;

            case AggregateCalculateType.C_Variance:
                calEntity = new Variance(resultId);
                break;

            case AggregateCalculateType.C_Median:
                calEntity = new Median(resultId);
                break;

            default:
                calEntity = new Avg(resultId);
                break;
            }
            return(calEntity);
        }
Beispiel #3
0
        public bool InsertOrUpdate(RpcContext[] rpcContexts)
        {
            try
            {
                foreach (RpcContext item in rpcContexts)
                {
                    if (item.CalculateType == CalculateType.Aggregate)
                    {
                        List <ICalculate> calcs = new List <ICalculate>();
                        for (int i = 0; i < item.AggregateCalculateTypeList.Length; i++)
                        {
                            string resultId = item.ResultIdList[i];
                            AggregateCalculateType aggType   = item.AggregateCalculateTypeList[i];
                            Calculate.Calculate    calEntity = WindowTaskUtil.GetAggregateCalculate(resultId, aggType);

                            calcs.Add(calEntity);
                        }

                        TaskManager.AddOrUpdateWindowTask(item.TaskId, item.TaskName, item.IsOpenWindow, item.WindowInterval, item.DelayWindowCount, calcs);
                    }
                    else if (item.CalculateType == CalculateType.Expression)
                    {
                        Calculate.Calculate calEntity = new ExpressionCalculate(item.ResultIdList[0]);
                        TaskManager.AddOrUpdateExpressionTask(item.TaskId, item.TaskName, item.ExpressionCalculateType, item.WindowInterval, item.ExpressionScript, new List <ICalculate>()
                        {
                            calEntity
                        });
                    }
                }
                return(true);
            }
            catch (Exception ex)
            {
                Logger.Log.Error(true, "执行InsertOrUpdate出错", ex);
                return(false);
            }
        }