/// <summary>
/// 获取同期流量
/// </summary>
/// <param name="dt">数据日期</param>
/// <returns></returns>
public double?GetSameSum(DateTime dt)
{
double?pSameSum = null;
using (DataSubmittedEntities db = new DataSubmittedEntities())
{
DateTime plasttime = new DateTime();
//获取报表12配置的假期同期
List <OT_HDayConfig> pdayconfigs = db.OT_HDayConfig.Where(s => s.Id == 12).ToList();
OT_HDayConfig pdayconfig = new OT_HDayConfig();
if (pdayconfigs.Count > 0)
{
pdayconfig = pdayconfigs.First();
if (pdayconfig.HDayStart.HasValue && pdayconfig.HDayEnd.HasValue)
{
int ptemp = 0;
//判断当天是否在假期配置时间范围内
DateTime ptempdt = DateTime.Parse(dt.ToShortDateString());
if (ptempdt >= pdayconfig.HDayStart.Value && ptempdt <= pdayconfig.HDayEnd)
{
//间隔的天数
ptemp = (ptempdt - pdayconfig.HDayStart.Value).Days;
}
if (pdayconfig.CompStart.HasValue)
{
plasttime = pdayconfig.CompStart.Value.AddDays(ptemp);
}
}
}
List <RP_HDayAADT> pOlds = db.RP_HDayAADT.Where(s => s.CalcuTime <= plasttime && s.CalcuTime >= pdayconfig.CompStart.Value).ToList();
pSameSum = pOlds.Sum(s => s.Sum.Value);
}
return(pSameSum);
}
/// <summary>
/// 添加报表备注
/// </summary>
/// <param name="sheet">工作表</param>
/// <param name="rownum">行数</param>
/// <param name="cellnum">列数</param>
/// <param name="value">值</param>
protected void SetReportRemark(ISheet sheet, int rownum, int cellnum, int reporttype)
{
OT_HDayConfig holiday = HolidayConfig.GetInstance().GetById(reporttype);
if (holiday != null)
{
SetValue(sheet, rownum, cellnum, holiday.RptRemark);
}
}
/// <summary>
/// 修改配置信息
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public CustomResult UpdateConfig(HolidayConfigViewModel model)
{
OT_HDayConfig modelHC = new OT_HDayConfig();
modelHC.CheckFloat = model.CheckFloat;
modelHC.CompEnd = model.ComparedEndTime;
modelHC.CompStart = model.ComparedStartTime;
modelHC.ConfigName = model.ConfigName;
modelHC.ForeDate = model.ForecastDate;
modelHC.ForeFloat = model.ForecastFloat;
modelHC.Id = model.HolidayConfigId;
modelHC.HDayEnd = model.HolidayEndTime;
modelHC.HDayId = model.HolidayId;
modelHC.HDayStart = model.HolidayStartTime;
modelHC.RptRemark = model.ReportRemark;
return(holidayConfig.Update(modelHC));
}
/// <summary>
/// 根据报表配置ID读取（假期和非假期表都存在HolidayConfig表）
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public OT_HDayConfig GetById(int id)
{
OT_HDayConfig pHolidayConfig = null;
try
{
using (DataSubmittedEntities db = new DataSubmittedEntities())
{
List <OT_HDayConfig> list = db.OT_HDayConfig.Where(s => s.Id == id).ToList();
if (list.Count > 0)
{
pHolidayConfig = list[0];
}
}
}
catch (Exception ex)
{
SystemLog.GetInstance().Error(ex);
pHolidayConfig = null;
}
return(pHolidayConfig);
}
/// <summary>
/// 报表17备注
/// </summary>
/// <param name="sheet"></param>
/// <param name="reporttype"></param>
private void SetRemark(ISheet sheet, int reporttype)
{
try
{
//17备注备注规则，二者用分号分隔,符合全为英文下的，如果不包含两个人的信息则不加分号示例：负责人:张三 联系电话:022-6583411 手机:18888888888;填表人:张四 联系电话:022-6583411 手机:18888888888
OT_HDayConfig holiday = HolidayConfig.GetInstance().GetById(reporttype);
if (holiday != null)
{
string[] remark = new string[] { };
string officer = string.Empty;
string preparer = string.Empty;
//包含两个人的信息
if (holiday.RptRemark.IndexOf(';') != -1)
{
remark = holiday.RptRemark.Split(';');
if (remark[0].Substring(0, 3).ToString() == "负责人")
{
officer = remark[0];
preparer = remark[1];
}
else
{
preparer = remark[0];
officer = remark[1];
}
}
else
{
if (holiday.RptRemark.Split(' ')[0].Substring(0, 3).ToString() == "负责人")
{
officer = holiday.RptRemark;
}
else
{
preparer = holiday.RptRemark;
}
}
if (!string.IsNullOrEmpty(officer))
{
string[] pTempOfficer = officer.Split(' ');
for (int i = 0; i < pTempOfficer.Count(); i++)
{
if (pTempOfficer[i].Substring(0, 3) == "负责人")
{
//负责人
SetValue(sheet, 6, 2, pTempOfficer[i]);
}
else if (pTempOfficer[i].Substring(0, 4) == "联系电话")
{
//负责人联系电话
SetValue(sheet, 6, 4, pTempOfficer[i].Substring(5));
}
else if (pTempOfficer[i].Substring(0, 2) == "手机")
{
//负责人手机
SetValue(sheet, 6, 6, pTempOfficer[i].Substring(3));
}
}
}
if (!string.IsNullOrEmpty(preparer))
{
string[] pTempPreparer = preparer.Split(' ');
for (int i = 0; i < pTempPreparer.Count(); i++)
{
//if (pTempPreparer[i].Substring(0, 3) == "填表人")
//{
// //填表人
// SetValue(sheet, 7, 2, pTempPreparer[i]);
//}
//else
if (pTempPreparer[i].Substring(0, 4) == "联系电话")
{
//填表人联系电话
SetValue(sheet, 7, 4, pTempPreparer[i].Substring(5));
}
else if (pTempPreparer[i].Substring(0, 2) == "手机")
{
//填表人手机
SetValue(sheet, 7, 6, pTempPreparer[i].Substring(3));
}
}
}
if (SessionManage.GetLoginUser() != null)
{
//填表人
SetValue(sheet, 7, 2, "填表人:" + SessionManage.GetLoginUser().UserName);
}
}
}
catch (Exception ex)
{
SystemLog.GetInstance().Info(ex.Message);
}
}
/// <summary>
/// 校正
/// </summary>
/// <param name="para"></param>
/// <returns></returns>
public Common.CustomResult CalibrationData(Common.QueryParameters para)
{
CustomResult pReturnValue = new CustomResult();
double pFloating = 1 + para.FloatingRange * 0.01;
using (DataSubmittedEntities db = new DataSubmittedEntities())
{
//判断报表浮动百分比配置是否正确
OT_HDayConfig pds = HolidayConfig.GetInstance().GetById(para.ReportType);
if (pds == null)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.CalibrationFaileNoConfig;
return(pReturnValue);
}
if (Math.Abs(para.FloatingRange) > (double)pds.CheckFloat.Value)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.ErrorInfo + "范围应在负" + pds.CheckFloat.Value + "%-正" + pds.CheckFloat.Value + "%之间";
return(pReturnValue);
}
//判断校正数据日期是否合理
if (para.LastYearStart < para.StartTime && para.StartTime < DateTime.Now.AddDays(1))
{
//获取参考日期符合校正时间段的数据,因为只校正一天的数据，所以只查询开始数据的日期就可以
List <RP_EnEx> pRefNaturalList = db.RP_EnEx.Where(s => s.CalcuTime == para.LastYearStart && s.StaType == para.StationType).ToList();
//如果参考日期数据为0 则返回失败
if (pRefNaturalList == null || pRefNaturalList.Count == 0)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.CalibrationFaileRefNoData;
return(pReturnValue);
}
//需要校正的数据
var pCheckNaturalList = db.RP_EnEx.Where(s => s.CalcuTime == para.StartTime && s.StaType == para.StationType).ToList();
//如果需要校正的数据为空则返回失败
if (pCheckNaturalList == null || pCheckNaturalList.Count == 0)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.CalibrationFaileNoData;
return(pReturnValue);
}
using (TransactionScope tran = new TransactionScope())
{
//校正数据
RP_EnEx pCheckInfo = pCheckNaturalList.First();
//参考数据
RP_EnEx pRefInfo = pRefNaturalList.First();
if (pRefInfo.EnOthCar != null)
{
pCheckInfo.EnOthCar = Math.Round(pRefInfo.EnOthCar.Value * pFloating);
}
if (pCheckInfo.EnSmaCar != null)
{
pCheckInfo.EnSmaCar = Math.Round(pRefInfo.EnSmaCar.Value * pFloating);
}
if (pCheckInfo.EnTruk != null)
{
pCheckInfo.EnTruk = Math.Round(pRefInfo.EnTruk.Value * pFloating);
}
if (SessionManage.GetLoginUser() != null)
{
pCheckInfo.UpdBy = SessionManage.GetLoginUser().UserName;
}
pCheckInfo.UpdDate = DateTime.Now;
pCheckInfo.State = "1";
try
{
db.SaveChanges();
tran.Complete();
pReturnValue.ResultKey = (byte)EResult.Succeed;
pReturnValue.ResultValue = TipInfo.CalibrationSuccess;
}
catch (Exception e)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.CalibrationFaile + e.Message.ToString();
SystemLog.GetInstance().Error(TipInfo.CalibrationFaile, e);
return(pReturnValue);
}
}
}
else
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.CalibrationFaileDate;
}
}
return(pReturnValue);
}
/// <summary>
/// 15,16,17根据查询条件获取数据
/// </summary>
/// <param name="para">查询条件类</param>
/// <returns></returns>
public IReportViewModel GetListByPra(QueryParameters para)
{
QueryNaturalInfoViewModel pReturn = new QueryNaturalInfoViewModel();
try
{
using (DataSubmittedEntities db = new DataSubmittedEntities())
{
//添加合计
new TrafficStatisticalSum().CreateOrUpdateSum(para, (int)para.StationType);
//某类报表所涉及的收费站名称
string[] pStationNames = null;
if (para.ReportType == 17)
{
//报表17所包含的站名称
pStationNames = db.OT_Station.Where(s => s.Num == para.StationType.Value.ToString()).Select(s => s.Name).ToArray();
pReturn.ReportData = db.RP_NatSta.Where(s => s.CalcuTime == para.StartTime && s.StaType == para.StationType && s.HourPer == 24).ToList().Select(s => new NaturalInfoViewModel
{
HourPer = 0,
DayTraffic = double.Parse(string.Format("{0:0.0000}", s.Sum * 0.0001)),
InDayTraffic = double.Parse(string.Format("{0:0.0000}", s.EnNum * 0.0001)),
OutDayTraffic = double.Parse(string.Format("{0:0.0000}", s.ExNum * 0.0001)),
RunningStatus = s.RunStae,
Remark = s.Rek
}).ToList();
if (pReturn.ReportData.Count == 0)
{
pReturn.ReportData.Add(new NaturalInfoViewModel
{
HourPer = 0,
RoadName = SystemConst.RoadName,
DayTraffic = null,
InDayTraffic = null,
OutDayTraffic = null,
RunningStatus = SystemConst.RunningStatus,
Remark = ""
});
pReturn.ReportData.Add(new NaturalInfoViewModel
{
HourPer = 24,
RoadName = SystemConst.RoadName,
DayTraffic = null,
InDayTraffic = null,
OutDayTraffic = null,
RunningStatus = "",
Remark = ""
});
}
else
{
pReturn.ReportData.Add(new NaturalInfoViewModel
{
HourPer = 24,
RoadName = SystemConst.RoadName,
DayTraffic = double.Parse(string.Format("{0:0.0000}", pReturn.ReportData[0].DayTraffic)),
InDayTraffic = double.Parse(string.Format("{0:0.0000}", pReturn.ReportData[0].InDayTraffic)),
OutDayTraffic = double.Parse(string.Format("{0:0.0000}", pReturn.ReportData[0].OutDayTraffic)),
RunningStatus = pReturn.ReportData[0].RunningStatus,
Remark = pReturn.ReportData[0].Remark
});
}
}
else
{
//报表15,16所包含的站名称
pStationNames = db.OT_Station.Where(s => s.District == para.StationType.Value).Select(s => s.Name).ToArray();
//获取查询日期当天所有已上传的数据，包括合计
pReturn.ReportData = db.RP_NatSta.Where(s => s.CalcuTime == para.StartTime && s.StaType == para.StationType).Select(s => new NaturalInfoViewModel
{
HourPer = (byte)s.HourPer,
DayTraffic = (double)s.Sum,
InDayTraffic = (double)s.EnNum,
OutDayTraffic = (double)s.ExNum,
RunningStatus = s.RunStae,
Remark = s.Rek
}).ToList();
//补充数据
IEnumerable <NaturalInfoViewModel> pNa = pReturn.ReportData.Where(s => s.HourPer != 24);
int pMaxTimeHour = -1; //补充在此之后的数据
int pMinTimeHour = -1; //补充在此之前的数据
if (pNa.Count() > 0)
{
pMinTimeHour = (int)pNa.Min(s => s.HourPer);
pMaxTimeHour = (int)pNa.Max(s => s.HourPer);
}
else
{
pReturn.ReportData.Add(new NaturalInfoViewModel
{
HourPer = 24,
DayTraffic = null,
InDayTraffic = null,
OutDayTraffic = null,
RunningStatus = SystemConst.RunningStatus,
Remark = ""
});
}
if (pMinTimeHour != -1 && pMinTimeHour != 0)
{
for (int i = 0; i < pMinTimeHour; i++)
{
InsertNull(para.StartTime.Value, (byte)i, para.StationType.Value);
pReturn.ReportData.Add(new NaturalInfoViewModel
{
HourPer = (byte)i,
DayTraffic = 0,
InDayTraffic = 0,
OutDayTraffic = 0,
RunningStatus = SystemConst.RunningStatus,
Remark = ""
});
}
}
//查看统计的最小时间和最大时间直接，数据是否统计上来
for (int i = pMinTimeHour + 1; i < pMaxTimeHour; i++)
{
if (db.RP_NatSta.Where(s => s.CalcuTime == para.StartTime && s.StaType == para.StationType && s.HourPer == (byte)i).Count() <= 0)
{
InsertNull(para.StartTime.Value, (byte)i, para.StationType.Value);
pReturn.ReportData.Add(new NaturalInfoViewModel
{
HourPer = (byte)i,
DayTraffic = 0,
InDayTraffic = 0,
OutDayTraffic = 0,
RunningStatus = SystemConst.RunningStatus,
Remark = ""
});
}
}
if (pMaxTimeHour < 23)
{
int pTemp = DateTime.Now.Hour;
for (int i = (int)pMaxTimeHour + 1; i < 24; i++)
{
//如果查询日期小于服务器时间，并且无数据上来，则认为是系统异常没有统计到数据，则将数据补充到数据库。
if (para.StartTime < DateTime.Now.Date)
{
InsertNull(para.StartTime.Value, (byte)i, para.StationType.Value);
pReturn.ReportData.Add(new NaturalInfoViewModel
{
HourPer = (byte)i,
DayTraffic = 0,
InDayTraffic = 0,
OutDayTraffic = 0,
RunningStatus = SystemConst.RunningStatus,
Remark = ""
});
}
}
if (para.StartTime == DateTime.Now.Date)
{
for (int n = 0; n < pTemp; n++)
{
if (db.RP_NatSta.Where(s => s.CalcuTime == para.StartTime && s.StaType == para.StationType && s.HourPer == (byte)n).Count() <= 0)
{
InsertNull(para.StartTime.Value, (byte)n, para.StationType.Value);
pReturn.ReportData.Add(new NaturalInfoViewModel
{
HourPer = (byte)n,
DayTraffic = 0,
InDayTraffic = 0,
OutDayTraffic = 0,
RunningStatus = SystemConst.RunningStatus,
Remark = ""
});
}
}
for (int m = pTemp; m < 24; m++)
{
pReturn.ReportData.Add(new NaturalInfoViewModel
{
HourPer = (byte)m,
DayTraffic = null,
InDayTraffic = null,
OutDayTraffic = null,
RunningStatus = SystemConst.RunningStatus,
Remark = ""
});
}
}
}
//按序号排序
pReturn.ReportData = pReturn.ReportData.OrderBy(s => s.HourPer).ToList();
//获取当前统计类型不包含的收费站列表
IEnumerable <OT_ErrorStation> pNoaccept = db.OT_ErrorStation.Where(i =>
pStationNames.Contains(i.StaName)).ToList().Where(s => s.CalcuTime == para.StartTime);
if (pNoaccept.Count() > 0)
{
pReturn.IsFull = 0;//不完整
}
else
{
pReturn.IsFull = 1;//完整
}
}
//获取报表备注
OT_HDayConfig holiday = HolidayConfig.GetInstance().GetById(para.ReportType);
if (holiday != null)
{
if (holiday.RptRemark != null)
{
pReturn.ReportRemark = holiday.RptRemark;
}
else
{
pReturn.ReportRemark = "";
}
}
else
{
pReturn.ReportRemark = "";
}
}
}
catch (Exception e)
{
SystemLog.GetInstance().Info(e);
}
return(pReturn);
}
/// <summary>
/// 校正数据
/// </summary>
/// <param name="args"></param>
/// <returns></returns>
public CustomResult CalibrationData(QueryParameters para)
{
CustomResult pReturnValue = new CustomResult();
QueryNaturalInfoViewModel queryNatural = new QueryNaturalInfoViewModel();
//判断选择校正时间段的有效性
string[] calibrationDataHour = new string[24];
if (para.StartHour <= para.EndHour)
{
for (int i = para.StartHour; i <= para.EndHour; i++)
{
calibrationDataHour[i] = i.ToString();
}
}
else
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.CalibrationFaileHour;
return(pReturnValue);
}
double pFloating = para.FloatingRange * 0.01;
List <RP_NatSta> pNaturalTraList = new List <RP_NatSta>();
try
{
using (DataSubmittedEntities db = new DataSubmittedEntities())
{
//判断报表浮动百分比配置是否正确
OT_HDayConfig pds = HolidayConfig.GetInstance().GetById(para.ReportType);
if (pds == null)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.CalibrationFaileNoConfig;
return(pReturnValue);
}
if (Math.Abs(para.FloatingRange) > (double)pds.CheckFloat.Value)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.ErrorInfo + "范围应在负" + pds.CheckFloat.Value + "%-正" + pds.CheckFloat.Value + "%之间";
return(pReturnValue);
}
//获取参考日期符合校正时间段的数据,因为只校正一天的数据，所以只查询开始数据的日期就可以
List <NaturalInfoViewModel> pRefNaturalList = db.RP_NatSta.Where(s => s.CalcuTime == para.LastYearStart && s.StaType == para.StationType && calibrationDataHour.Contains(s.HourPer.Value.ToString())).ToList().Select(s => new NaturalInfoViewModel
{
HourPer = (byte)s.HourPer,
DayTraffic = (double)s.Sum,
InDayTraffic = (double)s.EnNum,
OutDayTraffic = (double)s.ExNum,
RunningStatus = s.RunStae,
Remark = s.Rek
}).ToList();
//如果参考日期数据为0 则返回失败
if (pRefNaturalList.Count == 0)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.CalibrationFaileRefNoData;
return(pReturnValue);
}
//判断校正数据日期是否合理
if (para.LastYearStart < para.StartTime && para.StartTime < DateTime.Now.AddDays(1))
{
//需要校正的数据
var pCheckNaturalList = db.RP_NatSta.Where(s => s.CalcuTime == para.StartTime && s.StaType == para.StationType && calibrationDataHour.Contains(s.HourPer.Value.ToString())).ToList();
if (pCheckNaturalList.Count == 0)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.CalibrationFaileNoData;
return(pReturnValue);
}
using (TransactionScope tran = new TransactionScope())
{
foreach (var item in pCheckNaturalList)
{
IEnumerable <NaturalInfoViewModel> plist = pRefNaturalList.Where(i => i.HourPer == item.HourPer);
if (plist.Count() > 0)
{
NaturalInfoViewModel pTemp = plist.First();
item.EnNum = (int)(pTemp.InDayTraffic + pTemp.InDayTraffic * pFloating);
item.ExNum = (int)(pTemp.OutDayTraffic + pTemp.OutDayTraffic * pFloating);
item.Sum = item.EnNum + item.ExNum;
item.RunStae = pTemp.RunningStatus;
item.CalcuTime = para.StartTime.Value;
item.StaType = para.StationType;
if (SessionManage.GetLoginUser() != null)
{
item.UpdBy = SessionManage.GetLoginUser().UserName;
}
item.UpdDate = DateTime.Now;
item.State = "1";
}
}
db.SaveChanges();
tran.Complete();
pReturnValue.ResultKey = (byte)EResult.Succeed;
pReturnValue.ResultValue = TipInfo.CalibrationSuccess;
}
}
else
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.CalibrationFaileDate;
}
}
return(pReturnValue);
}
catch (Exception e)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.CalibrationFaile + e.Message.ToString();
SystemLog.GetInstance().Error(TipInfo.CalibrationFaile, e);
return(pReturnValue);
}
}
/// <summary>
/// 校正
/// </summary>
/// <param name="para"></param>
/// <returns></returns>
public CustomResult CalibrationData(QueryParameters para)
{
CustomResult pReturnValue = new CustomResult();
double pFloating = 1 + para.FloatingRange * 0.01;
List <RP_AADTSta> pNaturalTraList = new List <RP_AADTSta>();
try
{
using (DataSubmittedEntities db = new DataSubmittedEntities())
{
//判断报表浮动百分比配置是否正确
OT_HDayConfig pds = HolidayConfig.GetInstance().GetById(para.ReportType);
if (pds == null)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.CalibrationFaileNoConfig;
return(pReturnValue);
}
if (Math.Abs(para.FloatingRange) > (double)pds.CheckFloat.Value)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.ErrorInfo + "范围应在负" + pds.CheckFloat.Value + "%-正" + pds.CheckFloat.Value + "%之间";
return(pReturnValue);
}
//判断校正数据日期是否合理
if (para.LastYearStart < para.StartTime && para.StartTime < DateTime.Now.AddDays(1))
{
//获取参考日期符合校正时间段的数据,因为只校正一天的数据，所以只查询开始数据的日期就可以
List <RP_AADTSta> pRefNaturalList = db.RP_AADTSta.Where(s => s.CalculTime == para.LastYearStart).ToList();
//如果参考日期数据为0 则返回失败
if (pRefNaturalList.Count == 0)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.CalibrationFaileRefNoData;
return(pReturnValue);
}
//需要校正的数据
var pCheckNaturalList = db.RP_AADTSta.Where(s => s.CalculTime == para.StartTime).ToList();
//如果需要校正的数据为空则返回失败
if (pCheckNaturalList.Count == 0)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.CalibrationFaileNoData;
return(pReturnValue);
}
using (TransactionScope tran = new TransactionScope())
{
//校正数据
RP_AADTSta pCheckInfo = pCheckNaturalList.First();
//参考数据
RP_AADTSta pRefInfo = pRefNaturalList.First();
//出京总交通量（路线）
if (pRefInfo.LineExSum.HasValue)
{
pCheckInfo.LineExSum = Math.Round(pRefInfo.LineExSum.Value * pFloating);
}
//进京总交通量（路线）
if (pRefInfo.LineEnSum.HasValue)
{
pCheckInfo.LineEnSum = Math.Round(pRefInfo.LineEnSum.Value * pFloating);
}
//总交通量（路线）
pCheckInfo.LineSum = pCheckInfo.LineExSum + pCheckInfo.LineEnSum;
//总交通量同比增幅
pCheckInfo.SumGrow = double.Parse(string.Format("{0:0.00}", (pCheckInfo.LineSum - pRefInfo.LineSum) / pRefInfo.LineSum));
//出进京比
pCheckInfo.ExEnPer = double.Parse(string.Format("{0:0.00}", pCheckInfo.LineExSum / pCheckInfo.LineEnSum));
//免、收费总金额
if (pRefInfo.FeeSum.HasValue)
{
pCheckInfo.FeeSum = Math.Round(pRefInfo.FeeSum.Value * (decimal)pFloating, 2);
}
//出京小型客车免费通行交通量
if (pRefInfo.FeeSum.HasValue)
{
pCheckInfo.ExSmaCarFee = Math.Round(pRefInfo.ExSmaCarFee.Value * pFloating);
}
//进京小型客车免费通行交通量
if (pRefInfo.FeeSum.HasValue)
{
pCheckInfo.EnSmaCarFee = Math.Round(pRefInfo.EnSmaCarFee.Value * pFloating);
}
//小型客车免费通行交通量（合计）
if (pRefInfo.ExSmaCarFee.HasValue)
{
pCheckInfo.SmaCarFeeNum = pRefInfo.ExSmaCarFee.Value + pRefInfo.EnSmaCarFee.Value;
}
//小型客车交通量同比增幅
pCheckInfo.SmaCarCompGrow = double.Parse(string.Format("{0:0.00}", (pCheckInfo.SmaCarFeeNum - pRefInfo.SmaCarFeeNum) / pRefInfo.SmaCarFeeNum));
//小型客车免费金额
if (pRefInfo.SmaCarFee.HasValue)
{
pCheckInfo.SmaCarFee = Math.Round(pRefInfo.SmaCarFee.Value * (decimal)pFloating, 2);
}
//收费车辆（合计）
if (pRefInfo.ChagSumNum.HasValue)
{
pCheckInfo.ChagSumNum = Math.Round(pRefInfo.ChagSumNum.Value * pFloating);
}
//出京收费车辆
if (pRefInfo.ExChagNum.HasValue)
{
pCheckInfo.ExChagNum = Math.Round(pRefInfo.ExChagNum.Value * pFloating);
}
//进京收费车辆
if (pRefInfo.EnChagNum.HasValue)
{
pCheckInfo.EnChagNum = Math.Round(pRefInfo.EnChagNum.Value * pFloating);
}
//收费额度
if (pRefInfo.ChagAmount.HasValue)
{
pCheckInfo.ChagAmount = Math.Round(pRefInfo.ChagAmount.Value * (decimal)pFloating, 2);
}
//绿色通道车辆数
if (pRefInfo.GreNum.HasValue)
{
pCheckInfo.GreNum = Math.Round(pRefInfo.GreNum.Value * pFloating);
}
//绿色通道免收费金额
if (pRefInfo.GreFee.HasValue)
{
pCheckInfo.GreFee = Math.Round(pRefInfo.GreFee.Value * (decimal)pFloating, 2);
}
//出京总交通量（站）
if (pRefInfo.StaExSum.HasValue)
{
pCheckInfo.StaExSum = Math.Round(pRefInfo.StaExSum.Value * pFloating);
}
//进京总交通量（站）
if (pRefInfo.StaEnSum.HasValue)
{
pCheckInfo.StaEnSum = Math.Round(pRefInfo.StaEnSum.Value * pFloating);
}
if (SessionManage.GetLoginUser() != null)
{
pCheckInfo.UpdBy = SessionManage.GetLoginUser().UserName;
}
pCheckInfo.UpdDate = DateTime.Now;
pCheckInfo.State = "1";
db.SaveChanges();
tran.Complete();
pReturnValue.ResultKey = (byte)EResult.Succeed;
pReturnValue.ResultValue = TipInfo.CalibrationSuccess;
}
}
else
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.CalibrationFaileDate;
}
}
return(pReturnValue);
}
catch (Exception e)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.CalibrationFaile + e.Message.ToString();
SystemLog.GetInstance().Error(TipInfo.CalibrationFaile, e);
return(pReturnValue);
}
}
/// <summary>
/// 预测
/// </summary>
/// <param name="para"></param>
/// <returns></returns>
public CustomResult ForecastData(QueryParameters para)
{
CustomResult pReturnValue = new CustomResult();
//浮动范围
double pFloating = 1 + para.FloatingRange * 0.01;
List <RP_AADTSta> pForeList = new List <RP_AADTSta>();
//预测数据集合
List <IReportViewModel> pInList = new List <IReportViewModel>();
try
{
using (DataSubmittedEntities db = new DataSubmittedEntities())
{
//判断报表浮动百分比配置是否存在
OT_HDayConfig pds = HolidayConfig.GetInstance().GetById(para.ReportType);
if (pds == null)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.ForecastFaileNoConfig;
return(pReturnValue);
}
//判断报表预测浮动百分比配置是否正确
if (Math.Abs(para.FloatingRange) > (double)pds.ForeFloat.Value)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.ErrorInfo + "范围应在负" + pds.ForeFloat.Value + "%-正" + pds.ForeFloat.Value + "%之间";
return(pReturnValue);
}
//获取参考日期符合的数据
List <RP_AADTSta> pRefInfoList = db.RP_AADTSta.Where(s => s.CalculTime == para.StartTime).ToList();
//如果参考日期数据为0 则返回失败
if (pRefInfoList.Count == 0)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.ForecastFaileFaileRefNoData;
return(pReturnValue);
}
//预测数据
HDayTraInfoViewModel pInfo = new HDayTraInfoViewModel();
//预测数据集合
List <IReportViewModel> plist = new List <IReportViewModel>();
//参考数据
RP_AADTSta pRefInfo = pRefInfoList.First();
//出京总交通量（路线）
pInfo.LineExSum = Math.Round(pRefInfo.LineExSum.Value * pFloating);
//进京总交通量（路线）
pInfo.LineEnSum = Math.Round(pRefInfo.LineEnSum.Value * pFloating);
//总交通量（路线）
pInfo.LineSum = pInfo.LineExSum + pInfo.LineEnSum;
//免、收费总金额
pInfo.FeeSum = Math.Round(pRefInfo.FeeSum.Value * (decimal)pFloating, 2);
//出京小型客车免费通行交通量
pInfo.ExSmaCarFee = Math.Round(pRefInfo.ExSmaCarFee.Value * pFloating);
//进京小型客车免费通行交通量
pInfo.EnSmaCarFee = Math.Round(pRefInfo.EnSmaCarFee.Value * pFloating);
//小型客车免费通行交通量（合计）
pInfo.SmaCarFeeNum = pRefInfo.ExSmaCarFee.Value + pRefInfo.EnSmaCarFee.Value;
//小型客车免费金额
pInfo.SmaCarFee = Math.Round(pRefInfo.SmaCarFee.Value * (decimal)pFloating, 2);
//收费车辆（合计）
pInfo.ChagSumNum = Math.Round(pRefInfo.ChagSumNum.Value * pFloating);
//出京收费车辆
pInfo.ExChagNum = Math.Round(pRefInfo.ExChagNum.Value * pFloating);
//进京收费车辆
pInfo.EnChagNum = Math.Round(pRefInfo.EnChagNum.Value * pFloating);
//收费额度
pInfo.ChagAmount = Math.Round(pRefInfo.ChagAmount.Value * (decimal)pFloating, 2);
//绿色通道车辆数
pInfo.GreNum = Math.Round(pRefInfo.GreNum.Value * pFloating);
//绿色通道免收费金额
pInfo.GreFee = Math.Round(pRefInfo.GreFee.Value * (decimal)pFloating, 2);
//出京总交通量（站）
pInfo.StaExSum = Math.Round(pRefInfo.StaExSum.Value * pFloating);
//进京总交通量（站）
pInfo.StaEnSum = Math.Round(pRefInfo.StaEnSum.Value * pFloating);
plist.Add(pInfo);
string path = Export(para, plist);
pReturnValue.ResultKey = (byte)EResult.Succeed;
pReturnValue.ResultValue = path;
}
}
catch (Exception e)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.ForecastFail + e.Message.ToString();
SystemLog.GetInstance().Error(TipInfo.ForecastFail, e);
return(pReturnValue);
}
return(pReturnValue);
}
/// <summary>
/// 获取或更新报表11,12源数据
/// </summary>
/// <param name="dt"></param>
/// <param name="HourPer"></param>
public void Update(DateTime dt, int HourPer)
{
try
{
string startTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
SystemLog.GetInstance().Log.Info(string.Format("{0}：开始获取11,12报表数据", startTime));
using (DataSubmittedEntities db = new DataSubmittedEntities())
{
//获取报表12配置的假期信息
List <OT_HDayConfig> pdayconfigs = db.OT_HDayConfig.Where(s => s.Id == 12).ToList();
OT_HDayConfig pdayconfig = new OT_HDayConfig();
if (pdayconfigs.Count > 0)
{
pdayconfig = pdayconfigs.First();
}
DateTime pDt = DateTime.Parse(dt.ToShortDateString());
//报表11,12收费站
List <int> TJStation = StationConfiguration.GetStaionList();
//获取今年当日数据//p.VehType == 0 表示合计数据，
IEnumerable <DS_DataSource> pCollection = db.DS_DataSource.Where(p =>
DbFunctions.TruncateTime(p.CalcuTime) == DbFunctions.TruncateTime(dt) &&
p.VehType == 0 && TJStation.Contains(p.StaID.Value));
//今年数据
IEnumerable <DS_DataSource> pHdayCollection = db.DS_DataSource.Where(p =>
(DbFunctions.TruncateTime(p.CalcuTime) <= pdayconfig.HDayEnd.Value &&
DbFunctions.TruncateTime(p.CalcuTime) >= pdayconfig.HDayStart.Value) &&
p.VehType == 0 && TJStation.Contains(p.StaID.Value));
//每日数据
List <RP_HDayAADT> pList = db.RP_HDayAADT.Where(p => p.CalcuTime == pDt).ToList();
RP_HDayAADT pAADTInfo = null;
bool pIsHas = false;
if (pList.Count > 0)
{
pAADTInfo = pList.FirstOrDefault();
pIsHas = true;
}
else
{
pAADTInfo = new RP_HDayAADT();
}
//更新实体
UpdateInfo(pCollection, pAADTInfo, pDt, pIsHas, pHdayCollection);
using (TransactionScope transaction = new TransactionScope())
{
//如果不存在，则添加，否则则更新
if (!pIsHas)
{
db.RP_HDayAADT.Add(pAADTInfo);
}
db.SaveChanges();
transaction.Complete();
}
}
string endTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
SystemLog.GetInstance().Log.Info(string.Format("{0}：结束获取11,12报表数据", endTime));
SystemLog.GetInstance().Log.Info(string.Format("统计11,12报表数据耗时{0}秒", (DateTime.Parse(endTime) - DateTime.Parse(startTime)).TotalSeconds));
//显示执行该方法的线程ID
//SystemLog.GetInstance().Log.Info(string.Format("调用11,12Update的线程ID为：{0}", Thread.CurrentThread.ManagedThreadId));
Thread.Sleep(1000);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 8.9.10数据源更新方法
/// </summary>
/// <param name="dt"></param>
/// <param name="HourPer"></param>
public void Update(DateTime dt, int HourPer)
{
try
{
string startTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
SystemLog.GetInstance().Log.Info(string.Format("{0}：开始获取8,9,10报表数据", startTime));
using (DataSubmittedEntities db = new DataSubmittedEntities())
{
DateTime plasttime = new DateTime();
List <OT_HDayConfig> pdayconfigs = db.OT_HDayConfig.Where(s => s.Id == 9).ToList();
OT_HDayConfig pdayconfig = new OT_HDayConfig();
if (pdayconfigs.Count > 0)
{
pdayconfig = pdayconfigs.First();
if (pdayconfig.HDayStart.HasValue && pdayconfig.HDayEnd.HasValue)
{
int ptemp = 0;
//判断当天是否在假期配置时间范围内
DateTime ptempdt = DateTime.Parse(dt.ToShortDateString());
if (ptempdt >= pdayconfig.HDayStart.Value && ptempdt <= pdayconfig.HDayEnd)
{
//间隔的天数
ptemp = (ptempdt - pdayconfig.HDayStart.Value).Days;
}
if (pdayconfig.CompStart.HasValue)
{
plasttime = pdayconfig.CompStart.Value.AddDays(ptemp);
}
}
}
List <RP_AADTSta> pOlds = db.RP_AADTSta.Where(s => s.CalculTime == plasttime).ToList();
//判断去年同期是否存在
RP_AADTSta oldinfo = new RP_AADTSta();
if (pOlds.Count > 0)
{
oldinfo = pOlds.First();
}
DateTime pdt = DateTime.Parse(dt.ToShortDateString());
//北京段包含出入口收费站
List <int> BJStation = StationConfiguration.GetBJStaion();
//北京段只包含出口收费站
List <int> outBJStation = StationConfiguration.GetOutBJStaion();
//获取北京段数据//p.VehType == 0 表示合计数据，
IEnumerable <DS_DataSource> pBJCollection = db.DS_DataSource.Where(p =>
DbFunctions.TruncateTime(p.CalcuTime) == DbFunctions.TruncateTime(dt) &&
p.VehType == 0 &&
BJStation.Contains(p.StaID.Value));
//判断数据是否已存在
RP_AADTSta pAADTStaInfo = null;
List <RP_AADTSta> pList = db.RP_AADTSta.Where(p => p.CalculTime == pdt).ToList();
if (pList.Count > 0)//已存在，则更新
{
pAADTStaInfo = pList.FirstOrDefault();
pAADTStaInfo.UpdDate = DateTime.Now;
pAADTStaInfo.State = "1";
}
else//不存在，添加
{
pAADTStaInfo = new RP_AADTSta();
pAADTStaInfo.Id = Guid.NewGuid();
pAADTStaInfo.CrtDate = DateTime.Now;
pAADTStaInfo.State = "0";
}
//涉及到金额的单位全部转为万元，保留两位小数
//出京路线总交通量,不包括绿通
pAADTStaInfo.LineExSum = pBJCollection.Where(s => outBJStation.Contains(s.StaID.Value) && s.CalcuType != 3).Sum(s => s.InNum);
//入京路线总交通量，不包括绿通
pAADTStaInfo.LineEnSum = pBJCollection.Where(s => BJStation.Contains(s.StaID.Value) && s.CalcuType != 3).Sum(s => s.OutNum);
pAADTStaInfo.LineSum = pAADTStaInfo.LineEnSum + pAADTStaInfo.LineExSum;
//总交通量同比增幅
if (oldinfo.LineSum.HasValue)
{
pAADTStaInfo.SumGrow = double.Parse(string.Format("{0:0.00}", (pAADTStaInfo.LineSum - oldinfo.LineSum) / oldinfo.LineSum));
}
//出进京比
pAADTStaInfo.ExEnPer = double.Parse(string.Format("{0:0.00}", (pAADTStaInfo.LineExSum / pAADTStaInfo.LineEnSum)));
//收费/免征总金额
pAADTStaInfo.FeeSum = Math.Round(pBJCollection.Sum(s => s.RecMoney.Value) / 10000, 2);
//出京小型客车免费通行交通量
pAADTStaInfo.ExSmaCarFee = pBJCollection.Where(s => s.CalcuType == 0 && outBJStation.Contains(s.StaID.Value)).Sum(s => s.InNum);
//进京小型客车免费通行交通量
pAADTStaInfo.EnSmaCarFee = pBJCollection.Where(s => s.CalcuType == 0).Sum(s => s.OutNum);
//小型客车免费通行交通量（合计）
pAADTStaInfo.SmaCarFeeNum = pAADTStaInfo.ExSmaCarFee + pAADTStaInfo.EnSmaCarFee;
//小型客车交通量同比增幅
if (oldinfo.SmaCarFeeNum.HasValue)
{
pAADTStaInfo.SmaCarCompGrow = double.Parse(string.Format("{0:0.00}", (pAADTStaInfo.SmaCarFeeNum - oldinfo.SmaCarFeeNum) / oldinfo.SmaCarFeeNum));
}//小型客车免费金额
pAADTStaInfo.SmaCarFee = Math.Round(pBJCollection.Where(s => s.CalcuType.Value == 0).Sum(s => s.RecMoney.Value) / 10000, 2);
//出京收费车辆
pAADTStaInfo.ExChagNum = pBJCollection.Where(s => outBJStation.Contains(s.StaID.Value) && (s.CalcuType == 1 || s.CalcuType == 2)).Sum(s => s.InNum);
//进京收费车辆
pAADTStaInfo.EnChagNum = pBJCollection.Where(s => s.CalcuType == 1 || s.CalcuType == 2).Sum(s => s.OutNum);
//收费车辆合计
pAADTStaInfo.ChagSumNum = pAADTStaInfo.ExChagNum + pAADTStaInfo.EnChagNum;
//收费额度
pAADTStaInfo.ChagAmount = Math.Round(pBJCollection.Where(s => s.CalcuType == 1 || s.CalcuType == 2).Sum(s => s.RecMoney.Value) / 10000, 2);
//绿色通道车辆数
pAADTStaInfo.GreNum = pBJCollection.Where(s => s.CalcuType == 3).Sum(s => s.OutNum);
//绿色通道免收费金额
pAADTStaInfo.GreFee = Math.Round(pBJCollection.Where(s => s.CalcuType == 3).Sum(s => s.RecMoney.Value) / 10000, 2);
//出京总交通量（站）
pAADTStaInfo.StaExSum = pBJCollection.Where(s => s.StaID == (int)StationConfiguration.StationID.DYF).Sum(s => s.InNum);
//进京总交通量（站）
pAADTStaInfo.StaEnSum = pBJCollection.Where(s => s.StaID == (int)StationConfiguration.StationID.DYF).Sum(s => s.OutNum);
pAADTStaInfo.CalculTime = pdt;
using (TransactionScope trans = new TransactionScope())
{
if (pList.Count <= 0)
{
db.RP_AADTSta.Add(pAADTStaInfo);
}
db.SaveChanges();
trans.Complete();
}
}
string endTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
SystemLog.GetInstance().Log.Info(string.Format("{0}：结束获取8,9,10报表数据", endTime));
SystemLog.GetInstance().Log.Info(string.Format("统计8,9,10报表数据耗时{0}秒", (DateTime.Parse(endTime) - DateTime.Parse(startTime)).TotalSeconds));
//显示执行该方法的线程ID
//SystemLog.GetInstance().Log.Info(string.Format("调用8,9,10Update的线程ID为：{0}", Thread.CurrentThread.ManagedThreadId));
Thread.Sleep(1000);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 修改假期配置
/// </summary>
/// <param name="args">配置信息实体</param>
/// <returns>影响行数</returns>
public CustomResult Update(OT_HDayConfig model)
{
using (DataSubmittedEntities db = new DataSubmittedEntities())
{
using (TransactionScope transaction = new TransactionScope())
{
CustomResult pReturnValue = new CustomResult();
var list = db.OT_HDayConfig.Where(a => a.Id == model.Id).ToList();
if (list != null && list.Count > 0)
{
if (model.CheckFloat != null && model.CheckFloat > 0)
{
list[0].CheckFloat = model.CheckFloat;
}
if (model.CompEnd != null)
{
list[0].CompEnd = model.CompEnd;
}
if (model.CompStart != null)
{
list[0].CompStart = model.CompStart;
}
if (!string.IsNullOrEmpty(model.ConfigName))
{
list[0].ConfigName = model.ConfigName;
}
if (model.ForeDate != null)
{
list[0].ForeDate = model.ForeDate;
}
if (model.ForeFloat != null && model.ForeFloat > 0)
{
list[0].ForeFloat = model.ForeFloat;
}
if (model.HDayEnd != null)
{
list[0].HDayEnd = model.HDayEnd;
}
if (model.HDayId != null && model.HDayId > 0)
{
list[0].HDayId = model.HDayId;
}
if (model.HDayStart != null)
{
list[0].HDayStart = model.HDayStart;
}
if (!string.IsNullOrEmpty(model.RptRemark))
{
list[0].RptRemark = model.RptRemark;
}
pReturnValue = Result.SaveUpdateResult(db, transaction);
}
else
{
pReturnValue.ResultKey = (byte)EResult.IsNull1;
pReturnValue.ResultValue = Wttech.DataSubmitted.Common.Resources.TipInfo.Inexist;
}
return(pReturnValue);
}
}
}
/// <summary>
/// 校正
/// </summary>
/// <param name="para"></param>
/// <returns></returns>
public CustomResult CalibrationData(QueryParameters para)
{
CustomResult pReturnValue = new CustomResult();
double pFloating = 1 + para.FloatingRange * 0.01;
List <RP_HDayAADTSta> pNaturalTraList = new List <RP_HDayAADTSta>();
try
{
using (DataSubmittedEntities db = new DataSubmittedEntities())
{
//判断报表浮动百分比配置是否正确
OT_HDayConfig pds = HolidayConfig.GetInstance().GetById(para.ReportType);
if (pds == null)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.CalibrationFaileNoConfig;
return(pReturnValue);
}
if (Math.Abs(para.FloatingRange) > (double)pds.CheckFloat.Value)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.ErrorInfo + "范围应在负" + pds.CheckFloat.Value + "%-正" + pds.CheckFloat.Value + "%之间";
return(pReturnValue);
}
//判断校正数据日期是否合理
if (para.LastYearStart < para.StartTime && para.StartTime < DateTime.Now.AddDays(1))
{
//获取参考日期符合校正时间段的数据,因为只校正一天的数据，所以只查询开始数据的日期就可以
List <RP_HDayAADTSta> pRefNaturalList = db.RP_HDayAADTSta.Where(s => s.CalcuTime == para.LastYearStart).ToList();
//如果参考日期数据为0 则返回失败
if (pRefNaturalList.Count == 0)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.CalibrationFaileRefNoData;
return(pReturnValue);
}
//需要校正的数据
var pCheckNaturalList = db.RP_HDayAADTSta.Where(s => s.CalcuTime == para.StartTime).ToList();
//如果需要校正的数据为空则返回失败
if (pCheckNaturalList.Count == 0)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.CalibrationFaileNoData;
return(pReturnValue);
}
using (TransactionScope tran = new TransactionScope())
{
////校正数据
//RP_HDayAADTSta pCheckInfo = pCheckNaturalList.First();
////参考数据
//RP_HDayAADTSta pRefInfo = pRefNaturalList.First();
foreach (RP_HDayAADTSta pCheckInfo in pCheckNaturalList) //校正数据
{
foreach (RP_HDayAADTSta pRefInfo in pRefNaturalList) //参考数据
{
if (pRefInfo.LineType != 0 && pCheckInfo.LineType == pRefInfo.LineType)
{
//出京自然交通辆
if (pRefInfo.ExNat != null)
{
pCheckInfo.ExNat = Math.Round(pRefInfo.ExNat.Value * pFloating);
}
//进京自然交通辆
if (pRefInfo.EnNat != null)
{
pCheckInfo.EnNat = Math.Round(pRefInfo.EnNat.Value * pFloating);
}
//出京当量交通辆
if (pRefInfo.ExEqu != null)
{
pCheckInfo.ExEqu = Math.Round(pRefInfo.ExEqu.Value * pFloating);
}
//进京当量交通辆
if (pRefInfo.EnEqu != null)
{
pCheckInfo.EnEqu = Math.Round(pRefInfo.EnEqu.Value * pFloating);
}
//拥挤度-“拥挤度”=交通量（当量交通量）合计/设计交通量，保留四位小数；
if (pCheckInfo.ExEqu != null && pCheckInfo.EnEqu != null)
{
HDayAADTViewModel model = new HDayAADTViewModel();
model.LineType = pRefInfo.LineType;
pCheckInfo.CrowDeg = double.Parse(string.Format("{0:0.0000}", (pCheckInfo.ExEqu + pCheckInfo.EnEqu) / model.DeTra));
}
//小型车出京
if (pRefInfo.SmaEx != null)
{
pCheckInfo.SmaEx = Math.Round(pRefInfo.SmaEx.Value * pFloating);
}
//小型车进京
if (pRefInfo.SmaEn != null)
{
pCheckInfo.SmaEn = Math.Round(pRefInfo.SmaEn.Value * pFloating);
}
//中型车出京
if (pRefInfo.MedEx != null)
{
pCheckInfo.MedEx = Math.Round(pRefInfo.MedEx.Value * pFloating);
}
//中型车进京
if (pRefInfo.MedEn != null)
{
pCheckInfo.MedEn = Math.Round(pRefInfo.MedEn.Value * pFloating);
}
//大型车出京
if (pRefInfo.LarEx != null)
{
pCheckInfo.LarEx = Math.Round(pRefInfo.LarEx.Value * pFloating);
}
//大型车进京
if (pRefInfo.LarEn != null)
{
pCheckInfo.LarEn = Math.Round(pRefInfo.LarEn.Value * pFloating);
}
//重型车出京
if (pRefInfo.HeaEx != null)
{
pCheckInfo.HeaEx = Math.Round(pRefInfo.HeaEx.Value * pFloating);
}
//重型车进京
if (pRefInfo.HeaEn != null)
{
pCheckInfo.HeaEn = Math.Round(pRefInfo.HeaEn.Value * pFloating);
}
//超大型车出京
if (pRefInfo.SupEx != null)
{
pCheckInfo.SupEx = Math.Round(pRefInfo.SupEx.Value * pFloating);
}
//超大型车进京
if (pRefInfo.SupEn != null)
{
pCheckInfo.SupEn = Math.Round(pRefInfo.SupEn.Value * pFloating);
}
//进出京大货车以上车型数量-进出京大货车以上车型数量”=大型车（合计）+重型车（合计）+超大型车（合计）。
if (pCheckInfo.LarEx != null && pCheckInfo.LarEn != null && pCheckInfo.HeaEx != null && pCheckInfo.HeaEn != null && pCheckInfo.SupEx != null && pCheckInfo.SupEn != null)
{
pCheckInfo.SupTruNum = pCheckInfo.LarEx + pCheckInfo.LarEn + pCheckInfo.HeaEx + pCheckInfo.HeaEn + pCheckInfo.SupEx + pCheckInfo.SupEn;
}
//进出京货车数量
if (pRefInfo.EnExTrukNum != null)
{
pCheckInfo.EnExTrukNum = Math.Round(pRefInfo.EnExTrukNum.Value * pFloating);
}
//客车货车比例-客车货车比例=（交通量（自然交通量）合计-进出京货车数量)/进出京货车数量*100%，保留四位小数；
if (pCheckInfo.ExNat != null && pCheckInfo.EnNat != null && pCheckInfo.EnExTrukNum != null && pCheckInfo.EnExTrukNum != null && pCheckInfo.EnExTrukNum != 0)
{
pCheckInfo.CarTrukPer = double.Parse(string.Format("{0:0.0000}", (pCheckInfo.ExNat + pCheckInfo.EnNat - pCheckInfo.EnExTrukNum) / pCheckInfo.EnExTrukNum));
}
//大货车以上占货车交通量比例-大货车以上占货车交通量比例（%）=进出京大货车以上车型的数量/进出京货车数量*100%，保留四位小数。
if (pCheckInfo.SupTruNum != null && pCheckInfo.EnExTrukNum != null && pCheckInfo.EnExTrukNum != 0)
{
pCheckInfo.SupTruPer = double.Parse(string.Format("{0:0.0000}", pCheckInfo.SupTruNum / pCheckInfo.EnExTrukNum));
}
if (SessionManage.GetLoginUser() != null)
{
pCheckInfo.UpdBy = SessionManage.GetLoginUser().UserName;
}
pCheckInfo.UpdDate = DateTime.Now;
pCheckInfo.State = "1";
break;
}
}
}
db.SaveChanges();
tran.Complete();
pReturnValue.ResultKey = (byte)EResult.Succeed;
pReturnValue.ResultValue = TipInfo.CalibrationSuccess;
}
}
else
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.CalibrationFaileDate;
}
}
return(pReturnValue);
}
catch (Exception e)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.CalibrationFaile + e.Message.ToString();
SystemLog.GetInstance().Error(TipInfo.CalibrationFaile, e);
return(pReturnValue);
}
}
/// <summary>
/// 校正数据
/// </summary>
/// <param name="args"></param>
/// <returns></returns>
public CustomResult CalibrationData(QueryParameters para)
{
CustomResult pReturnValue = new CustomResult();
//判断选择校正时间段的有效性
string[] calibrationDataHour = new string[24];
if (para.StartHour <= para.EndHour)
{
for (int i = para.StartHour; i <= para.EndHour; i++)
{
calibrationDataHour[i] = i.ToString();
}
}
else
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.CalibrationFaileHour;
return(pReturnValue);
}
double pFloating = 1 + para.FloatingRange * 0.01;
List <RP_NatSta> pNaturalTraList = new List <RP_NatSta>();
try
{
using (DataSubmittedEntities db = new DataSubmittedEntities())
{
//判断报表浮动百分比配置是否正确
OT_HDayConfig pds = HolidayConfig.GetInstance().GetById(para.ReportType);
if (pds == null)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.CalibrationFaileNoConfig;
return(pReturnValue);
}
if (Math.Abs(para.FloatingRange) > (double)pds.CheckFloat.Value)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.ErrorInfo + "范围应在负" + pds.CheckFloat.Value + "%-正" + pds.CheckFloat.Value + "%之间";
return(pReturnValue);
}
//获取参考日期符合校正时间段的数据,因为只校正一天的数据，所以只查询开始数据的日期就可以
List <RP_HourAADT> pRefHourAADTList = db.RP_HourAADT.Where(s => s.CalcuTime == para.LastYearStart && calibrationDataHour.Contains(s.HourPer.ToString())).ToList();
//如果参考日期数据为0 则返回失败
if (pRefHourAADTList.Count <= 0)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.CalibrationFaileRefNoData;
return(pReturnValue);
}
//判断时间范围是否相同
if ((para.LastYearEnd - para.LastYearStart) == (para.EndTime - para.StartTime))
{
//需要校正的数据
var pCheckHourAADTList = db.RP_HourAADT.Where(s => s.CalcuTime == para.StartTime && calibrationDataHour.Contains(s.HourPer.ToString())).ToList();
if (pCheckHourAADTList.Count <= 0)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.CalibrationFaileNoData;
return(pReturnValue);
}
using (TransactionScope tran = new TransactionScope())
{
foreach (var item in pCheckHourAADTList)
{
List <RP_HourAADT> plist = pRefHourAADTList.Where(i => i.HourPer == item.HourPer).ToList();
if (plist.Count() > 0)
{
RP_HourAADT pTemp = plist.First();
item.Dyf_EnOut = Math.Round(pTemp.Dyf_EnOut.Value * pFloating);
item.Dyf_ExIn = Math.Round(pTemp.Dyf_ExIn.Value * pFloating);
item.Mjqd_EnIn = Math.Round(pTemp.Mjqd_EnIn.Value * pFloating);
item.Mjqd_EnOut = Math.Round(pTemp.Mjqd_EnOut.Value * pFloating);
item.Mjqx_ExIn = Math.Round(pTemp.Mjqx_ExIn.Value * pFloating);
item.Mjqx_EnOut = Math.Round(pTemp.Mjqx_EnOut.Value * pFloating);
item.Cy_EnOut = Math.Round(pTemp.Cy_EnOut.Value * pFloating);
item.Cy_ExIn = Math.Round(pTemp.Cy_ExIn.Value * pFloating);
item.CalcuTime = para.StartTime.Value;
if (SessionManage.GetLoginUser() != null)
{
item.UpdBy = SessionManage.GetLoginUser().UserName;
}
item.UpdDate = DateTime.Now;
item.State = "1";
}
}
db.SaveChanges();
tran.Complete();
pReturnValue.ResultKey = (byte)EResult.Succeed;
pReturnValue.ResultValue = TipInfo.CalibrationSuccess;
}
}
else
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.CalibrationRangeFaile;
}
}
}
catch (Exception e)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.CalibrationFaile + e.Message.ToString();
SystemLog.GetInstance().Error(TipInfo.CalibrationFaile, e);
return(pReturnValue);
}
return(pReturnValue);
}
/// <summary>
/// 预测数据
/// </summary>
/// <param name="para"></param>
/// <returns></returns>
public CustomResult ForecastData(QueryParameters para)
{
CustomResult pReturnValue = new CustomResult();
//浮动范围
double pFloating = para.FloatingRange * 0.01;
List <RP_Daily> pDailyList = new List <RP_Daily>();
//预测数据集合
List <IReportViewModel> pOutList = new List <IReportViewModel>();
List <IReportViewModel> pInList = new List <IReportViewModel>();
try
{
using (DataSubmittedEntities db = new DataSubmittedEntities())
{
//判断报表浮动百分比配置是否存在
OT_HDayConfig pds = HolidayConfig.GetInstance().GetById(para.ReportType);
if (pds == null)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.ForecastFaileNoConfig;
return(pReturnValue);
}
//判断报表预测浮动百分比配置是否正确
if (Math.Abs(para.FloatingRange) > (double)pds.ForeFloat.Value)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.ErrorInfo + "范围应在负" + pds.ForeFloat.Value + "%-正" + pds.ForeFloat.Value + "%之间";
return(pReturnValue);
}
//获取参考日期符合的数据
List <RP_Daily> pRefDataDailyInfo = db.RP_Daily.Where(s => s.CalcuTime == para.StartTime && s.StaType == para.StationType).ToList();
//如果参考日期数据为0 则返回失败
if (pRefDataDailyInfo.Count == 0)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.ForecastFaileFaileRefNoData;
return(pReturnValue);
}
foreach (RP_Daily info in pRefDataDailyInfo)
{
DataDailyInfoViewModel pOutInfo = new DataDailyInfoViewModel();
DataDailyInfoViewModel pInInfo = new DataDailyInfoViewModel();
pInInfo.VehNum = (float)Math.Round((double)(info.InNum + info.InNum * pFloating), 0);
pOutInfo.VehNum = (float)Math.Round((double)(info.OutNum + info.OutNum * pFloating), 0);
pInInfo.VehType = info.VehType.ToString();
pOutInfo.VehType = info.VehType.ToString();
pOutInfo.CarChag = Math.Round((decimal)(info.ChagFee + info.ChagFee * (decimal)pFloating) / 10000, 2);
pOutList.Add(pOutInfo);
pInList.Add(pInInfo);
}
string path = Export(para, pOutList, pInList);
pReturnValue.ResultKey = (byte)EResult.Succeed;
pReturnValue.ResultValue = path;
}
}
catch (Exception e)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.ForecastFail + e.Message.ToString();
SystemLog.GetInstance().Error(TipInfo.ForecastFail, e);
return(pReturnValue);
}
return(pReturnValue);
}
/// <summary>
/// 校正数据
/// </summary>
/// <param name="args">校正日期，参考日期，浮动百分比</param>
/// <returns></returns>
public CustomResult CalibrationData(QueryParameters para)
{
CustomResult pReturnValue = new CustomResult();
// QueryNaturalInfoViewModel queryNatural = new QueryNaturalInfoViewModel();
//校正浮动范围
double pFloating = para.FloatingRange * 0.01;
List <RP_Daily> pDailyList = new List <RP_Daily>();
try
{
using (DataSubmittedEntities db = new DataSubmittedEntities())
{
//判断报表浮动百分比配置是否存在
OT_HDayConfig pds = HolidayConfig.GetInstance().GetById(para.ReportType);
if (pds == null)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.CalibrationFaileNoConfig;
return(pReturnValue);
}
//判断报表浮动百分比配置是否正确
if (Math.Abs(para.FloatingRange) > (double)pds.CheckFloat.Value)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.ErrorInfo + "范围应在负%" + pds.CheckFloat.Value + "-正%" + pds.CheckFloat.Value + "之间";
return(pReturnValue);
}
//获取参考日期符合校正时间段的数据,因为只校正一天的数据，所以只查询开始数据的日期就可以
List <RP_Daily> pRefDataDailyInfo = db.RP_Daily.Where(s => s.CalcuTime == para.LastYearStart && s.StaType == para.StationType).ToList();
//如果参考日期数据为0 则返回失败
if (pRefDataDailyInfo.Count == 0)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.CalibrationFaileRefNoData;
return(pReturnValue);
}
//判断校正数据日期是否合理
if (para.LastYearStart < para.StartTime && para.StartTime < DateTime.Now.AddDays(1))
{
//需要校正的数据
var pCheckList = db.RP_Daily.Where(s => s.CalcuTime == para.StartTime && s.StaType == para.StationType).ToList();
//如果校正数据不存在则返回失败
if (pCheckList.Count == 0)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.CalibrationFaileNoData;
return(pReturnValue);
}
using (TransactionScope tran = new TransactionScope())
{
foreach (var item in pCheckList)
{
IEnumerable <RP_Daily> plist = pRefDataDailyInfo.Where(i => i.VehType == item.VehType);
if (plist.Count() > 0)
{
RP_Daily pTemp = plist.First();
item.InNum = (int)(pTemp.InNum + pTemp.InNum * pFloating);
item.OutNum = (int)(pTemp.OutNum + pTemp.OutNum * pFloating);
item.ChagFee = pTemp.ChagFee.Value + pTemp.ChagFee.Value * decimal.Parse(pFloating.ToString());
item.CalcuTime = para.StartTime.Value;
item.StaType = para.StationType;
if (SessionManage.GetLoginUser() != null)
{
item.UpdBy = SessionManage.GetLoginUser().UserName;
}
item.UpdDate = DateTime.Now;
item.State = 1;
}
}
db.SaveChanges();
tran.Complete();
pReturnValue.ResultKey = (byte)EResult.Succeed;
pReturnValue.ResultValue = TipInfo.CalibrationSuccess;
}
}
else
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.CalibrationFaileDate;
}
}
return(pReturnValue);
}
catch (Exception e)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.CalibrationFaile + e.Message.ToString();
SystemLog.GetInstance().Error(TipInfo.CalibrationFaile, e);
return(pReturnValue);
}
}
/// <summary>
/// 校正
/// </summary>
/// <param name="para"></param>
/// <returns></returns>
public Common.CustomResult CalibrationData(Common.QueryParameters para)
{
CustomResult pReturnValue = new CustomResult();
double pFloating = 1 + para.FloatingRange * 0.01;
using (DataSubmittedEntities db = new DataSubmittedEntities())
{
//判断报表浮动百分比配置是否正确
OT_HDayConfig pds = HolidayConfig.GetInstance().GetById(para.ReportType);
if (pds == null)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.CalibrationFaileNoConfig;
return(pReturnValue);
}
if (Math.Abs(para.FloatingRange) > (double)pds.CheckFloat.Value)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.ErrorInfo + "范围应在负" + pds.CheckFloat.Value + "%-正" + pds.CheckFloat.Value + "%之间";
return(pReturnValue);
}
//判断时间范围是否相同
if ((para.LastYearEnd - para.LastYearStart) == (para.EndTime - para.StartTime))
{
//获取参考日期符合校正时间段的数据
List <RP_HDayAADT> pRefNaturalList = db.RP_HDayAADT.Where(a => a.CalcuTime >= para.LastYearStart & a.CalcuTime <= para.LastYearEnd).OrderBy(a => a.CalcuTime).ToList();
//如果参考日期数据为0 则返回失败
if (pRefNaturalList == null || pRefNaturalList.Count == 0)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.CalibrationFaileRefNoData;
return(pReturnValue);
}
//需要校正的数据
var pCheckNaturalList = db.RP_HDayAADT.Where(a => a.CalcuTime >= para.StartTime & a.CalcuTime <= para.EndTime).OrderBy(a => a.CalcuTime).ToList();
//如果需要校正的数据为空则返回失败
if (pCheckNaturalList == null || pCheckNaturalList.Count == 0)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.CalibrationFaileNoData;
return(pReturnValue);
}
using (TransactionScope tran = new TransactionScope())
{
for (int i = 0; i < pCheckNaturalList.Count; i++)
{
if (pRefNaturalList[i].JC != null)
{
pCheckNaturalList[i].JC = Math.Round(pRefNaturalList[i].JC.Value * pFloating);
}
if (pRefNaturalList[i].JZL != null)
{
pCheckNaturalList[i].JZL = Math.Round(pRefNaturalList[i].JZL.Value * pFloating);
}
if (pRefNaturalList[i].KG != null)
{
pCheckNaturalList[i].KG = Math.Round(pRefNaturalList[i].KG.Value * pFloating);
}
if (pRefNaturalList[i].TGB != null)
{
pCheckNaturalList[i].TGB = Math.Round(pRefNaturalList[i].TGB.Value * pFloating);
}
if (pRefNaturalList[i].TGX != null)
{
pCheckNaturalList[i].TGX = Math.Round(pRefNaturalList[i].TGX.Value * pFloating);
}
if (pRefNaturalList[i].TGXF != null)
{
pCheckNaturalList[i].TGXF = Math.Round(pRefNaturalList[i].TGXF.Value * pFloating);
}
if (pRefNaturalList[i].YC != null)
{
pCheckNaturalList[i].YC = Math.Round(pRefNaturalList[i].YC.Value * pFloating);
}
if (pRefNaturalList[i].YXBD != null)
{
pCheckNaturalList[i].YXBD = Math.Round(pRefNaturalList[i].YXBD.Value * pFloating);
}
if (pRefNaturalList[i].YXBX != null)
{
pCheckNaturalList[i].YXBX = Math.Round(pRefNaturalList[i].YXBX.Value * pFloating);
}
if (SessionManage.GetLoginUser() != null)
{
pCheckNaturalList[i].UpdBy = SessionManage.GetLoginUser().UserName;
}
pCheckNaturalList[i].UpdDate = DateTime.Now;
pCheckNaturalList[i].State = "1";
}
try
{
db.SaveChanges();
tran.Complete();
pReturnValue.ResultKey = (byte)EResult.Succeed;
pReturnValue.ResultValue = TipInfo.CalibrationSuccess;
}
catch (Exception e)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.CalibrationFaile + e.Message.ToString();
SystemLog.GetInstance().Error(TipInfo.CalibrationFaile, e);
return(pReturnValue);
}
}
}
else
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.CalibrationRangeFaile;
}
}
return(pReturnValue);
}
/// <summary>
/// 预测
/// </summary>
/// <param name="para"></param>
/// <returns></returns>
public Common.CustomResult ForecastData(Common.QueryParameters para)
{
CustomResult pReturnValue = new CustomResult();
//浮动范围
double pFloating = 1 + para.FloatingRange * 0.01;
// List<RP_EnEx> pForeList = new List<RP_EnEx>();
//预测数据集合
List <IReportViewModel> pInList = new List <IReportViewModel>();
using (DataSubmittedEntities db = new DataSubmittedEntities())
{
//判断报表浮动百分比配置是否存在
OT_HDayConfig pds = HolidayConfig.GetInstance().GetById(para.ReportType);
if (pds == null)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.ForecastFaileNoConfig;
return(pReturnValue);
}
//判断报表预测浮动百分比配置是否正确
if (Math.Abs(para.FloatingRange) > (double)pds.ForeFloat.Value)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.ErrorInfo + "范围应在负" + pds.ForeFloat.Value + "%-正" + pds.ForeFloat.Value + "%之间";
return(pReturnValue);
}
//获取参考日期符合的数据
List <RP_EnEx> pRefInfoList = db.RP_EnEx.Where(s => s.CalcuTime == para.StartTime && s.StaType == para.StationType).ToList();
//如果参考日期数据为0 则返回失败
if (pRefInfoList == null || pRefInfoList.Count == 0)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.ForecastFaileFaileRefNoData;
return(pReturnValue);
}
//预测数据
ForecastEnExViewModel pInfo = new ForecastEnExViewModel();
//预测数据集合
List <IReportViewModel> plist = new List <IReportViewModel>();
//参考数据
RP_EnEx pRefInfo = pRefInfoList.First();
if (pRefInfo.EnOthCar != null)
{
pInfo.EnOthCar = Math.Round(pRefInfo.EnOthCar.Value * pFloating);
}
if (pInfo.EnSmaCar != null)
{
pInfo.EnSmaCar = Math.Round(pRefInfo.EnSmaCar.Value * pFloating);
}
if (pInfo.EnTruk != null)
{
pInfo.EnTruk = Math.Round(pRefInfo.EnTruk.Value * pFloating);
}
try
{
plist.Add(pInfo);
string path = Export(para, plist);
pReturnValue.ResultKey = (byte)EResult.Succeed;
pReturnValue.ResultValue = path;
}
catch (Exception e)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.ForecastFail + e.Message.ToString();
SystemLog.GetInstance().Error(TipInfo.ForecastFail, e);
return(pReturnValue);
}
}
return(pReturnValue);
}
/// <summary>
/// 校正数据
/// </summary>
/// <param name="args"></param>
/// <returns></returns>
public CustomResult CalibrationData(QueryParameters para)
{
CustomResult pReturnValue = new CustomResult();
double pFloating = 1 + para.FloatingRange * 0.01;
List <RP_HDayAADT> pHDayAADT = new List <RP_HDayAADT>();
try
{
using (DataSubmittedEntities db = new DataSubmittedEntities())
{
//判断报表浮动百分比配置是否正确
OT_HDayConfig pds = HolidayConfig.GetInstance().GetById(para.ReportType);
if (pds == null)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.CalibrationFaileNoConfig;
return(pReturnValue);
}
if (Math.Abs(para.FloatingRange) > (double)pds.CheckFloat.Value)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.ErrorInfo + "范围应在负" + pds.CheckFloat.Value + "%-正" + pds.CheckFloat.Value + "%之间";
return(pReturnValue);
}
//判断时间范围是否相同
if ((para.LastYearEnd - para.LastYearStart) == (para.EndTime - para.StartTime))
{
//获取参考日期符合校正时间段的数据
List <RP_HDayAADT> pRefList = db.RP_HDayAADT.Where(s => s.CalcuTime >= para.LastYearStart && s.CalcuTime <= para.LastYearEnd).ToList();
//如果参考日期数据为0 则返回失败
if (pRefList.Count == 0)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.CalibrationFaileRefNoData;
return(pReturnValue);
}
//需要校正的数据
var pCheckList = db.RP_HDayAADT.Where(s => s.CalcuTime >= para.StartTime && s.CalcuTime <= para.EndTime).ToList();
//如果需要校正的数据为空则返回失败
if (pCheckList.Count == 0)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.CalibrationFaileNoData;
return(pReturnValue);
}
using (TransactionScope tran = new TransactionScope())
{
////校正数据
//RP_HDayAADTSta pCheckInfo = pCheckNaturalList.First();
////参考数据
//RP_HDayAADTSta pRefInfo = pRefNaturalList.First();
foreach (RP_HDayAADT pCheckInfo in pCheckList) //校正数据
{
foreach (RP_HDayAADT pRefInfo in pRefList) //参考数据
{
if (pRefInfo.CalcuTime == pRefInfo.CalcuTime)
{
pCheckInfo.Out = Math.Round(pRefInfo.Out.Value * pFloating);
if (SessionManage.GetLoginUser() != null)
{
pCheckInfo.UpdBy = SessionManage.GetLoginUser().UserName;
}
pCheckInfo.UpdDate = DateTime.Now;
pCheckInfo.State = "1";
break;
}
}
}
db.SaveChanges();
tran.Complete();
pReturnValue.ResultKey = (byte)EResult.Succeed;
pReturnValue.ResultValue = TipInfo.CalibrationSuccess;
}
}
else
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.CalibrationRangeFaile;
}
}
return(pReturnValue);
}
catch (Exception e)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.CalibrationFaile + e.Message.ToString();
SystemLog.GetInstance().Error(TipInfo.CalibrationFaile, e);
return(pReturnValue);
}
}
/// <summary>
/// 预测
/// </summary>
/// <param name="para"></param>
/// <returns></returns>
public CustomResult ForecastData(QueryParameters para)
{
if (listExport != null)
{
listExport.Clear();
}
CustomResult pReturnValue = new CustomResult();
//浮动范围
double pFloating = 1 + para.FloatingRange * 0.01;
List <RoadRunSitViewModel> pForeList = new List <RoadRunSitViewModel>();
//预测数据集合
List <IReportViewModel> pInList = new List <IReportViewModel>();
try
{
using (DataSubmittedEntities db = new DataSubmittedEntities())
{
//判断报表浮动百分比配置是否存在
OT_HDayConfig pds = HolidayConfig.GetInstance().GetById(para.ReportType);
if (pds == null)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.ForecastFaileNoConfig;
return(pReturnValue);
}
//判断报表预测浮动百分比配置是否正确
if (Math.Abs(para.FloatingRange) > (double)pds.ForeFloat.Value)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.ErrorInfo + "范围应在负" + pds.ForeFloat.Value + "%-正" + pds.ForeFloat.Value + "%之间";
return(pReturnValue);
}
//获取参考日期符合的数据
List <RP_AADTSta> pRefInfoList = db.RP_AADTSta.Where(s => s.CalculTime == para.StartTime).ToList();
//如果参考日期数据为0 则返回失败
if (pRefInfoList == null || pRefInfoList.Count == 0)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.ForecastFaileFaileRefNoData;
return(pReturnValue);
}
//预测数据
RoadRunSitViewModel info = new RoadRunSitViewModel();
//预测数据集合
List <IReportViewModel> plist = new List <IReportViewModel>();
//参考数据
foreach (RP_AADTSta pRefInfo in pRefInfoList)
{
//出京总交通量（路线）
info.LineExSum = Math.Round(pRefInfo.LineExSum == null ? 0 : pRefInfo.LineExSum.Value * pFloating, 2);
//进京总交通量（路线）
info.LineEnSum = Math.Round(pRefInfo.LineEnSum == null ? 0 : pRefInfo.LineEnSum.Value * pFloating, 2);
//总交通量（路线）
info.LineSum = info.LineExSum + info.LineEnSum;
//小型客车免费通行交通量（合计）
info.SmaCarFeeNum = Math.Round(pRefInfo.ExSmaCarFee == null ? 0 : pRefInfo.ExSmaCarFee.Value + pRefInfo.EnSmaCarFee == null ? 0 : pRefInfo.EnSmaCarFee.Value, 2);
//小型客车免费金额
info.SmaCarFee = Math.Round(pRefInfo.SmaCarFee == null ? 0 : pRefInfo.SmaCarFee.Value * (decimal)pFloating, 2);
//收费车辆（合计）
info.ChagSumNum = Math.Round(pRefInfo.ChagSumNum == null ? 0 : pRefInfo.ChagSumNum.Value * pFloating, 2);
//数据日期
info.CalculTime = (pRefInfo.CalculTime).Month + "月" + (pRefInfo.CalculTime).Day + "日";
//出进京比“出进京比”=出京交通量/进京交通量，保留两位小数。
if (info.LineEnSum != 0)
{
info.ExEnPer = Math.Round(info.LineExSum / info.LineEnSum, 2);
}
//“同比增幅”=（本年数据-去年数据）/去年数据*100%，保留两位小数。
//小型客车交通量同比增幅
info.SmaCarCompGrow = pRefInfo.SmaCarCompGrow == null ? "0.00" : Math.Round(pRefInfo.SmaCarCompGrow.Value, 2).ToString();
//总交通量同比增幅
info.SumGrow = pRefInfo.SumGrow == null ? "0.00" : Math.Round(pRefInfo.SumGrow.Value, 2).ToString();
plist.Add(info);
}
string path = Export(para, plist);
pReturnValue.ResultKey = (byte)EResult.Succeed;
pReturnValue.ResultValue = path;
}
}
catch (Exception e)
{
pReturnValue.ResultKey = (byte)EResult.Fail;
pReturnValue.ResultValue = TipInfo.ForecastFail + e.Message.ToString();
SystemLog.GetInstance().Error(TipInfo.ForecastFail, e);
return(pReturnValue);
}
return(pReturnValue);
}
