using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Web.Http;
using IStation.Model.Api;
using IStation.ViewModel;
using AutoMapper;
using Microsoft.Web.Http;

namespace IStation.WebApi.Controllers.DispatchAna
{
    /// <summary>
    /// 
    /// </summary>
    [RoutePrefix("v1/Standard/DispatchAna")]
    [ApiVersion("v1")]
    public class DispatchAna_StandardController : ApiController
    {


        /// <summary>
        /// 根据流量扬程计算[FromUri]
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [Route("CalcByFlowHead")]
        [HttpPost]
        public Result CalcByFlowHead(IStation.Dto.DispatchAna.CalcByFlowHead_Request request)
        {
            if (request == null)
            {
                return new Result(IStation.Model.Api.Code.Error, "request为空");
            }
            if (request.CorpID <= 0)
            {
                return new Result(IStation.Model.Api.Code.Error, "CorpID为空");
            }
            if (request.StationID <= 0)
            {
                return new Result(IStation.Model.Api.Code.Error, "StationID为空");
            }
            string min_q = "", max_q = "";
            if (request.Range != null)
            {
                min_q = request.Range.MinQ;
                max_q = request.Range.MaxQ;
            }
            List<IStation.Model.Calc.DispatchAna.MachineRunFilter> RunStatusDict = null;
            if (request.RunStatusList == null)
            {
                // IStation.LogHelper.Info("RunStatusList none");
            }
            else if (request.RunStatusList.Count() == 0)
            {
                // IStation.LogHelper.Info("RunStatusList Count==0");
            }
            else //if (request.Setting.OpenStatus != null && request.Setting.OpenStatus.Count > 0)
            {
                RunStatusDict = new List<IStation.Model.Calc.DispatchAna.MachineRunFilter>();
                foreach (var d in request.RunStatusList)
                {
                    var binding_list = new Service.PipeLineBinding().GetByPipeLineID(request.CorpID, d.MachineID);
                    RunStatusDict.Add(new IStation.Model.Calc.DispatchAna.MachineRunFilter()
                    {
                        MachineID = binding_list.First().ObjectID,
                        RunStatus = d.Status,
                        MaxFlow = -1
                    });
                }
            }
            IStation.Calculation.IDispatchAnalyCalculator calc_helper = IStation.Calculation.DispatchAnalyCalculatorFactory.CreateCalculator(request.CorpID,
                IStation.ObjectType.Station_泵站,
                request.StationID, null);
            if (calc_helper == null)
            {
                return new Result(IStation.Model.Api.Code.Error, "Calculator 还未构建!");
            }
            IStation.Model.Calc.DispatchAna.RequestParas requestParas = new Model.Calc.DispatchAna.RequestParas();

            requestParas.InitialParas(request.CorpID, request.StationID, request.TargetQ, 0, request.TargetH / 102, min_q, max_q);
            requestParas.SchemeSortType = (IStation.Model.Calc.DispatchAna.eAnaSchemeSortType)request.SortType;

            var MachineRunPara = new IStation.Model.Calc.DispatchAna.MachineRunPara() { MachineRunFilter = RunStatusDict };
            string error_info;
            var items = calc_helper.CalcOptList(requestParas, MachineRunPara, out error_info);
            if (items == null || items.Count() == 0)
            {
                return new Result(IStation.Model.Api.Code.Alert, error_info);
            }
            else
            {
                return new Result<List<IStation.Model.Calc.DispatchAna.AnaScheme>>(items);
            }
        }

        /// <summary>
        /// 根据流量扬程计算
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [Route("CalcByFlowPress")]
        [HttpGet]
        public Result CalcByFlowPress([FromUri] IStation.Dto.DispatchAna.CalcByFlowPress_Request request)
        {
            if (request == null)
            {
                return new Result(IStation.Model.Api.Code.Error, "request为空");
            }
            if (request.CorpID <= 0)
            {
                return new Result(IStation.Model.Api.Code.Error, "CorpID为空");
            }
            if (request.StationID <= 0)
            {
                return new Result(IStation.Model.Api.Code.Error, "StationID为空");
            }
            string min_q = "", max_q = "";
             if (request.Range != null)
             {
                 min_q = request.Range.MinQ;
                 max_q = request.Range.MaxQ;
             }
             List<IStation.Model.Calc.DispatchAna.MachineRunFilter> RunStatusDict = null;
             if (request.RunStatusList == null)
             {
                 // IStation.LogHelper.Info("RunStatusList none");
             }
             else if (request.RunStatusList.Count() == 0)
             {
                 // IStation.LogHelper.Info("RunStatusList Count==0");
             }
             else //if (request.Setting.OpenStatus != null && request.Setting.OpenStatus.Count > 0)
             {
                 RunStatusDict = new List<IStation.Model.Calc.DispatchAna.MachineRunFilter>();
                 foreach (var d in request.RunStatusList)
                 {
                     RunStatusDict.Add(new IStation.Model.Calc.DispatchAna.MachineRunFilter()
                     {
                         MachineID = d.MachineID,
                         RunStatus = d.Status,
                         MaxFlow = -1
                     });

                     // RunStatusDict[d.MachineID] = d.Status;
                 }
                 //IStation.LogHelper.Info(request.RunStatusList.FirstOrDefault().MachineID + " : " +
                 //   request.RunStatusList.FirstOrDefault().Status);
             }
             IStation.Calculation.IDispatchAnalyCalculator calc_helper =   IStation.Calculation.DispatchAnalyCalculatorFactory.CreateCalculator(request.CorpID,
                 IStation.ObjectType.Station_泵站,
                 request.StationID, null);
            if(calc_helper == null)
            {
                return new Result(IStation.Model.Api.Code.Error, "Calculator 还未构建!");
            }
            IStation.Model.Calc.DispatchAna.RequestParas requestParas = new Model.Calc.DispatchAna.RequestParas();
            requestParas.SchemeSortType = (IStation.Model.Calc.DispatchAna.eAnaSchemeSortType)request.SortType;
            requestParas.InitialParas(request.CorpID,request.StationID, request.TargetQ, request.WaterLevel,request.OutletPress, min_q, max_q);
            var MachineRunPara = new IStation.Model.Calc.DispatchAna.MachineRunPara() { MachineRunFilter = RunStatusDict };

            string error_info;
            var items = calc_helper.CalcOptList (requestParas, MachineRunPara, out error_info);
            if (items == null || items.Count() == 0)
            {
                return new Result(IStation.Model.Api.Code.Alert, error_info);
            }
            else
            {
                return new Result<List<IStation.Model.Calc.DispatchAna.AnaScheme>>(items);
            }
        }


        /// <summary>
        /// 固定开停机方案, 计算最优参数
        /// </summary>
        /// <param name="CorpID">公司ID</param>
        /// <param name="StationID">泵站ID</param>
        /// <param name="TargetQ"></param>
        /// <param name="TargetH"></param>
        /// <param name="RunMachineID">运行的机泵ID</param>
        /// <returns></returns>
       /* [Route("CalcOptParas4Project")]
        [HttpGet]
        public Result CalcOptParas4Project(long CorpID, long StationID, double TargetQ, double TargetH, string RunMachineID)
        {
            if (string.IsNullOrEmpty(RunMachineID))
            {
                return new Result(Code.Alert, "RunMachineID 参数未输入");
            }
            if (CorpID <= 0)
            {
                return new Result(IStation.Model.Api.Code.Error, "CorpID为空");
            }
            if (StationID <= 0)
            {
                return new Result(IStation.Model.Api.Code.Error, "StationID为空");
            }

            var service_curve = new IStation.Service.PumpCurve();
               var service_product = new IStation.Service.Product();
               var all_machines = service_product.GetEnginePumpListByBelongTypeAndBelongID(CorpID, IStation.ObjectType.Station_泵站, StationID); //获取机泵列表
            if (all_machines  == null || all_machines.Count() == 0)
            {
                return new Result(Code.Alert, "此StationID未找到任何机泵");
            }
            var sssRunMachineID = RunMachineID.Split(',');

            IStation.Model.Calc.DispatchAna.AnaScheme project = new IStation.Model.Calc.DispatchAna.AnaScheme();
               project.Items = new List<IStation.Model.Calc.DispatchAna.AnaSchemeItem>();

               //获取并预算一下
               List<IStation.Model.Calc.DispatchAna.FixPumpAnaData> fixPumpDataList = new List<IStation.Model.Calc.DispatchAna.FixPumpAnaData>();//固频泵
               List<IStation.Model.Calc.DispatchAna.FrePumpAnaData> frequPumpItems = new List<IStation.Model.Calc.DispatchAna.FrePumpAnaData>();//变频泵

            IStation.Calculation.DispatchAnaHelper泵站4常规_根据扬程 helper = new IStation.Calculation.DispatchAnaHelper泵站4常规_根据扬程();
               helper.InitialParas(CorpID, StationID, TargetQ, TargetH, null, null);


               foreach (var s in sssRunMachineID)
               {
                   if (string.IsNullOrEmpty(s) || s == "null")
                       continue;

                   long machineID = 0;
                   if (!long.TryParse(s, out machineID))
                       continue;
                   var machine = (from x in all_machines where x.ID == machineID select x).FirstOrDefault();
                   if (machine == null)
                       continue;
                   var pump = service_product.GetChildPumpByEnginePumpID(CorpID, machineID);
                   if (pump == null)
                       continue;
                   var pump_curve = service_curve.GetDefaultCurveByPumpID(CorpID, pump.ID);
                   if (pump_curve == null)
                       continue;

                IStation.Model.Calc.DispatchAna.MachineDetail Machine = new IStation.Model.Calc.DispatchAna.MachineDetail(machine, pump, pump_curve);

                   if (pump.RatedParas != null && pump.RatedParas.IsFrequency)
                   {
                       var anaData = helper.GetFrePumpAnaData(Machine);
                       if (anaData != null)
                           frequPumpItems.Add(anaData);
                   }
                   else
                   {//算出是否符合的固频泵
                       var anaData = helper.GetFixPumpAnaData(Machine);
                       if (anaData != null)
                           fixPumpDataList.Add(anaData);
                   }
               }

               return new Result<List<IStation.Model.Calc.DispatchAna.FrePumpAnaData>>(frequPumpItems);
 
        }*/

        /// <summary>
        /// 修改频率后,重新计算
        /// </summary>
        /// <param name="CorpID">公司ID</param>
        /// <param name="StationID"></param>
        /// <param name="TargetQ"></param>
        /// <param name="TargetH"></param>
        /// <param name="ItemsParas"></param>
        /// <returns></returns>
        [Route("ReCalcProjectByItemFrequency")]
        [HttpGet]
        public Result ReCalcProjectByItemFrequency(long CorpID, long StationID, double TargetQ, double TargetH, string ItemsParas)
        {
            if (CorpID <= 0)
            {
                return new Result(IStation.Model.Api.Code.Error, "CorpID为空");
            }
 
            if (StationID <= 0)
            {
                return new Result(Code.Alert, "StationID 参数未输入");
            }
            if (string.IsNullOrEmpty(ItemsParas))
            {
                return new Result(Code.Alert, "ItemsParas 参数未输入");
            }

            IStation.Service.Product service_product = new IStation.Service.Product();
             IStation.Service.PumpCurve service_curve = new IStation.Service.PumpCurve();

             string strItemsParas = ItemsParas;
             var sss = strItemsParas.Split(',');

            IStation.Model.Calc.DispatchAna.AnaScheme project = new IStation.Model.Calc.DispatchAna.AnaScheme();
             project.Items = new List<IStation.Model.Calc.DispatchAna.AnaSchemeItem>();


             foreach (var s in sss)
             {
                 if (string.IsNullOrEmpty(s) || s == "null")
                     continue;

                 var bbb = s.Split('F');
                 if (bbb.Count() < 2)
                     continue;
                 var frequence = Convert.ToDouble(bbb[1]);
                 var aaa = bbb[0].Split('P');
                 var pumpID = Convert.ToInt64(aaa[1].Replace("P", ""));
                 var machineID = Convert.ToInt64(aaa[0].Replace("M", ""));

                 var engin = service_product.GetEnginePumpByProductID(CorpID, machineID);
                 if (engin == null)
                     continue;

                 var pump =  service_product.GetChildPumpByEnginePumpID(CorpID, engin.ID);
                 if (pump == null)
                     continue;

                 var pump_curve = service_curve.GetDefaultCurveByPumpID(CorpID, pumpID);
                 if (pump_curve == null)
                     continue;
                 if(pump_curve.CurveInfo == null)
                    continue;

                IStation.Model.Calc.DispatchAna.AnaCurveItem anaData = new IStation.Model.Calc.DispatchAna.AnaCurveItem();
                 int ret = IStation.Common.DispatchAnaGeneralHelper.CalcAnaCurve(
                     pump_curve.CurveInfo.CurveQH, 
                     pump_curve.CurveInfo.CurveQP,  
                     0,TargetH/102, frequence, ref anaData);
                 if (ret == -1)
                     break;//-1 表示最大扬程都已经低于目标扬程了, 没必要再迭代了
                 if (ret == 0)
                     continue;

                ////效率延长不稳定
                //var maxCurveQP = pump_curve.GetRatedCurveInfoQP();
                //var exPointsQP = IStation.Common.FitCurveHelper.GetFitPointsByExtend(, DispatchAnaHelper.ExtendMaxRatio, 50);//延长
                //double power = Math.Round(IStation.Common.FitCurveHelper.GetFitPointY(exPointsQP, curve.WorkPointQ), 1);


                IStation.Model.Calc.DispatchAna.AnaSchemeItem item = new IStation.Model.Calc.DispatchAna.AnaSchemeItem( new IStation.Model.Calc.DispatchAna.MachineDetail(engin, pump, pump_curve), anaData);
                 item.WorkPointP = anaData.WorkPointP; 
                 item.WorkPointE = IStation.Common.PumpParaHelper.CalculateE(anaData.WorkPointQ, anaData.WorkPointH, anaData.WorkPointP);

                 project.Items.Add(item);
             }
             project.TotalWrkQ = (from x in project.Items where x.WorkPointQ > 0 select x.WorkPointQ).Sum();
             project.TotalWrkP = (from x in project.Items where x.WorkPointP > 0 select x.WorkPointP).Sum();
             project.UWP = Math.Round(IStation.Common.DispatchAnaGeneralHelper.Calcu_UWP(project.TotalWrkP, project.TotalWrkQ, TargetH),3);
             project.WP = Math.Round(IStation.Common.DispatchAnaGeneralHelper.Calcu_UWP(project.TotalWrkP, project.TotalWrkQ, TargetH), 3);

             project.SpanQ = Math.Round(project.TotalWrkQ - TargetQ, 0) ;

             return new Result<IStation.Model.Calc.DispatchAna.AnaScheme>(project);   
        }
        

        /// <summary>
        /// 
        /// </summary>
        /// <param name="CorpID">公司ID</param>
        /// <param name="StationID"></param>
        /// <param name="ItemsParas"></param>
        /// <returns></returns>
        [Route("GetAnaItemDetail")]
        [HttpGet]
        public Result GetAnaItemDetail(long CorpID, string StationID, string ItemsParas)
        {
            if (CorpID <= 0)
            {
                return new Result(IStation.Model.Api.Code.Error, "CorpID为空");
            }
            if (string.IsNullOrEmpty(StationID))
            {
                return new Result(Code.Alert, "StationID 参数未输入");
            }
            if (string.IsNullOrEmpty(ItemsParas))
            {
                return new Result(Code.Alert, "ItemsParas 参数未输入");
            }
            IStation.Service.PumpCurve bllCurve = new IStation.Service.PumpCurve();

            string strItemsParas = ItemsParas;
            var sss = strItemsParas.Split(',');

              List<IStation.Model.CurveExpress> curveListQH = new List<IStation.Model.CurveExpress>();
             List<IStation.Model.CurveExpress> curveListQP = new List<IStation.Model.CurveExpress>();
             double r_maxH = double.MaxValue, r_minH = double.MinValue;
             List<IStation.Dto.DispatchAna.CurveItem> ParallelCurve = new List<IStation.Dto.DispatchAna.CurveItem>();

             foreach (var s in sss)
             {
                 if (string.IsNullOrEmpty(s) || s == "null")
                     continue;

                 var bbb = s.Split('F');
                 if (bbb.Count() < 2)
                     continue;
                 var frequence = Convert.ToDouble(bbb[1]);
                 var aaa = bbb[0].Split('P');
                 var pumpID = Convert.ToInt64(aaa[1].Replace("P", ""));
                 var machineID = Convert.ToInt64(aaa[0].Replace("M", ""));

                 var curve_default = bllCurve.GetDefaultCurveByPumpID(CorpID, pumpID);
                 if (curve_default == null)
                     continue;
                if (curve_default.CurveInfo == null)
                    continue;
                if (frequence > 49.5)
                 {
                     var curve_qh = curve_default.CurveInfo.CurveQH ;
                     curve_qh.Max = curve_qh.Max * IStation.Common.DispatchAnaGeneralHelper.ExtendMaxRatio;
                     curveListQH.Add(curve_qh);

                     var curve_qp = curve_default.CurveInfo.CurveQP;
                     curve_qp.Max = curve_qp.Max * IStation.Common.DispatchAnaGeneralHelper.ExtendMaxRatio;
                     curveListQP.Add(curve_qp);
                 }
                 else
                 {
                     var ration = frequence / 50.0;

                     var maxCurveQH = IStation.Model.FitCurveHelper.GetFitPointsByExtend(curve_default.CurveInfo.CurveQH , IStation.Common.DispatchAnaGeneralHelper.ExtendMaxRatio, 20);
                     var maxCurveQP = IStation.Model.FitCurveHelper.GetFitPointsByExtend(curve_default.CurveInfo.CurveQP, IStation.Common.DispatchAnaGeneralHelper.ExtendMaxRatio, 20);

                     List<IStation.Model.CurvePoint> simuPointsQH = new List<IStation.Model.CurvePoint>();
                     foreach (var pt in maxCurveQH)
                     {
                         simuPointsQH.Add(new IStation.Model.CurvePoint(pt.X * ration, pt.Y * ration * ration));
                     }

                     List<IStation.Model.CurvePoint> simuPointsQP = new List<IStation.Model.CurvePoint>();
                     foreach (var pt in maxCurveQP)
                     {
                         simuPointsQP.Add(new IStation.Model.CurvePoint(pt.X * ration, pt.Y * ration * ration * ration));
                     }
                     curveListQH.Add(new IStation.Model.CurveExpress(simuPointsQH));
                     curveListQP.Add(new IStation.Model.CurveExpress(simuPointsQP));
                 }
                 double maxH, minH;
                 IStation.Model.FitCurveHelper.GetMinMaxPointY(curveListQH.Last(), out maxH, out minH);
                 r_maxH = Math.Min(r_maxH, maxH);
                 r_minH = Math.Max(r_minH, minH);

                 var product  = new IStation.Service.Product().GetByID(CorpID, machineID);

                IStation.Dto.DispatchAna.CurveItem item = new IStation.Dto.DispatchAna.CurveItem();
                 item.Type = 0;
                 item.Name = product==null?"": product.Name;
                 item.PointQH = IStation.Model.PumpCurve.GetEChartPoint(new IStation.Model.CurveExpress(curveListQH.Last()), 20);
                 item.PointQP = IStation.Model.PumpCurve.GetEChartPoint(new IStation.Model.CurveExpress(curveListQP.Last()), 20);
                 ParallelCurve.Add(item);
             }

             if (curveListQH.Count < 1)
             {
                 return new Result(IStation.Model.Api.Code.Alert, "NULL1");
             }
             else if (curveListQH.Count == 1)
             {
                IStation.Dto.DispatchAna.CurveItem item_bl_Same = new IStation.Dto.DispatchAna.CurveItem();
                 item_bl_Same.Type = 1;
                 item_bl_Same.Name = "并联曲线";
                 item_bl_Same.PointQH = ParallelCurve.FirstOrDefault().PointQH;
                 item_bl_Same.PointQP = ParallelCurve.FirstOrDefault().PointQP;
                 ParallelCurve.Add(item_bl_Same);
                 return new Result<List<IStation.Dto.DispatchAna.CurveItem>>(ParallelCurve);
             }
             //if (curveListQH.Count < 2)
             //{
             //    return Json(new Result(IStation.Model.Api.Code.Alert, "NULL1"), JsonRequestBehavior.AllowGet);
             //}
             if (r_maxH < r_minH)
             {
                 return new Result(IStation.Model.Api.Code.Alert, "NULL2");
             }

             double space_h = (r_maxH - r_minH) / 19;
             List<IStation.Model.CurvePoint> conne_curve_qp = new List<IStation.Model.CurvePoint>();
             List<IStation.Model.CurvePoint> conne_curve_qh = new List<IStation.Model.CurvePoint>();
             for (var h = r_minH; h <= r_maxH; h = h + space_h)
             {
                 double total_flow = 0;
                 double total_power = 0;

                 for (int j = 0; j < curveListQH.Count; j++)
                 {
                     var curveQH = curveListQH[j];
                     var curveQP = curveListQP[j];
                     var pts = IStation.Model.FitCurveHelper.GetInterPointX(curveQH, h);
                     if (pts != null && pts.Count > 0)
                     {
                         var q = pts.Last().X;
                         total_flow += q;
                         total_power += IStation.Model.FitCurveHelper.GetFitPointY(curveQP, q);
                     }

                 }
                 conne_curve_qh.Add(new IStation.Model.CurvePoint(total_flow, h));
                 conne_curve_qp.Add(new IStation.Model.CurvePoint(total_flow, total_power));
             }

            IStation.Dto.DispatchAna.CurveItem item_bl = new IStation.Dto.DispatchAna.CurveItem();
             item_bl.Type = 1;
             item_bl.Name = "并联曲线";
             item_bl.PointQH = IStation.Model.PumpCurve.GetEChartPoint(new IStation.Model.CurveExpress(conne_curve_qh), 20);
             item_bl.PointQP = IStation.Model.PumpCurve.GetEChartPoint(new IStation.Model.CurveExpress(conne_curve_qp), 20);
             ParallelCurve.Insert(0,item_bl);//放在第一个

             return new Result<List<IStation.Dto.DispatchAna.CurveItem>>(ParallelCurve); 
 
        }


        /// <summary>
        /// 获取实时调度运行数据
        /// </summary>
        /// <param name="CorpID">公司ID</param>
        /// <param name="StationID"></param>
        /// <returns></returns>
        [Route("GetCurrentDispatchScheme")]
        [HttpGet]
        public Result GetCurrentDispatchScheme(long CorpID, long StationID)
        {
            if (CorpID <= 0)
            {
                return new Result(IStation.Model.Api.Code.Error, "CorpID为空");
            }

            if (StationID <= 0)
            {
                return new Result(Code.Alert, "StationID 参数未输入");
            }

       

             //获取当前运行流量扬程()
             // var redisStationRun = new Service.PumpRun().GetRunRealStatus(StationID);
             //if (redisStationRun == null)
             //    return new Result<StationRunRealData>(null);
          /*   var realData = new StationRunRealData();
             //realData.RealTime = redisStationRun.RealTime.ToString("yyyy-MM-dd HH:mm:ss");
             var stationRun = new StationRunRealTime();

             var eta_station = new Service.EtaPipeLine().GetDefaultByObjectTypeAndObjectID(ObjectType.Station_泵站, StationID);
             if (eta_station != null)
             {
                 var run_station = new Service.EtaPipeLineRun().GetLastTrunkRecord(eta_station.ID);
                 stationRun.H = Math.Round(run_station.Ha, 2);
                 stationRun.P = run_station.Pa;
                 //stationRun.P1 = run_station.p;
                 //stationRun.P2 = redisStationRun.P2;
                 stationRun.Q = run_station.Qa;
                 stationRun.UWP = Math.Round( run_station.UWPa, 2).ToString();

                 realData.StationRumReal = stationRun;
             }



             var server_product = new Service.Product();
             var all_machines = server_product.GetEnginePumpByStationID(StationID);
             if (all_machines == null || all_machines.Count < 1)
             {
                 return new Result(IStation.Model.Api.Code.Error, " 当前泵站未设置机泵信息");
             }
             all_machines = all_machines.OrderBy(t => t.SortCode).ToList();
             foreach (var machine in all_machines)
             {
                 var eta = new Service.EtaPipeLine().GetDefaultByObjectTypeAndObjectID(ObjectType.Product_设备, machine.ID);
                 if (eta != null)
                 {
                     var redisPumpRun = new Service.EtaPipeLineRun().GetLastBranchRecord(eta.ID);
                     if (redisPumpRun == null)
                         continue;

                     if (redisPumpRun != null && redisPumpRun.RSa == Model.eEtaRunStatus.开机)
                     {
                         var pumpRun = new PumpRunRealTime();
                         pumpRun.Name = machine.Name;
                         pumpRun.MachineID = machine.ID;

                         var pump = server_product.GetChildPumpByID(machine.ID);
                         if (pump != null)
                             pumpRun.PumpID = pump.ID;

                         pumpRun.E = redisPumpRun.Ea;
                         pumpRun.H = Math.Round(redisPumpRun.Ha, 2);
                         pumpRun.HZ = redisPumpRun.HZa;
                         pumpRun.P = redisPumpRun.Pa;
                         // pumpRun.P1 = redisPumpRun.P1m == null ? 0 : redisPumpRun.P1m.Value;
                         // pumpRun.P2 = redisPumpRun.P2m == null ? 0 : redisPumpRun.P2m.Value;
                         pumpRun.Q = redisPumpRun.Qa;
                         if (realData.PumpRunReals == null)
                             realData.PumpRunReals = new List<PumpRunRealTime>();
                         realData.PumpRunReals.Add(pumpRun);
                     }
                 }
             }



             List<string> sss = new List<string>();
             foreach (var item in realData.PumpRunReals)
             {
                 sss.Add(string.Format("M{0}P{1}F{2}", item.MachineID, item.PumpID, item.HZ));
             }
             realData.ItemsParas = string.Join(",", sss);

             return new Result<StationRunRealData>(realData);*/
            return new Result<string >("123456");
        }

        //泵站实时运行数据
        internal class StationRunRealData
        {
            /// <summary>
            /// 时间
            /// </summary>
            public string RealTime { get; set; }
            /// <summary>
            /// 
            /// </summary>
            public string ItemsParas { get; set; }
            /// <summary>
            /// 泵站
            /// </summary>
            public StationRunRealTime StationRumReal { get; set; }

            /// <summary>
            /// 机泵
            /// </summary>
            public List<PumpRunRealTime> PumpRunReals { get; set; }
        }

        //泵站
        internal class StationRunRealTime
        {
            //流量
            public double Q { get; set; }

            //功率
            public double P { get; set; }

            //出口压力
            public double P1 { get; set; }

            //进口压力
            public double P2 { get; set; }

            //扬程
            public double H { get; set; }

            //效率
            public double E { get; set; }

            //
            public string UWP { get; set; }
        }

        //单泵
        internal class PumpRunRealTime
        {
            //
            public long MachineID { get; set; }
            //
            public long PumpID { get; set; }

            //名称
            public string Name { get; set; }

            //功率
            public double P { get; set; }

            //流量
            public double Q { get; set; }

            //出口压力
            public double P1 { get; set; }

            //进口压力
            public double P2 { get; set; }

            //扬程
            public double H { get; set; }

            //效率
            public double E { get; set; }

            //频率
            public double HZ { get; set; }
        }

    }
}