using System;
using System.Collections.Generic;
using System.Linq;
using System.Web.Http;
using System.Web.Http.Description;
using ESCG = CommercialApi.GeneralMethod;
using ESCM = CommercialApi.Model;
using Newtonsoft.Json;
using HZQR.Common;

namespace CommercialApi.Controllers
{
    /// <summary>
    /// 大数据分析相关接口
    /// </summary>
    public class BigDataController : BaseController
    {
        #region 方法 -> 服务区入区车流分析
        /// <summary>
        /// 服务区入区车流分析
        /// </summary>
        /// <param name="StatisticsDate">统计日期，格式yyyy-MM-dd</param>
        /// <param name="Serverpart_ID">服务区内码</param>
        /// <param name="Serverpart_Region">服务区方位</param>
        /// <param name="ShowAddUpCount">是否统计累计数据</param>
        /// <returns></returns>
        [Route("Revenue/GetBayonetEntryList")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<ESCM.BayonetEntryModel>>))]
        public IHttpActionResult GetBayonetEntryList(string StatisticsDate, int? Serverpart_ID = null,
            string Serverpart_Region = "", bool ShowAddUpCount = false)
        {
            string Parameter = "入参信息：统计日期【" + StatisticsDate + "】，" +
                "服务区内码【" + Serverpart_ID + "】，服务区方位【" + Serverpart_Region + "】";
            try
            {
                //服务区入区车流分析
                List<ESCM.BayonetEntryModel> BayonetEntryList = ESCG.BayonetHelper.GetBayonetEntryList(
                    transaction, StatisticsDate, Serverpart_ID, Serverpart_Region, ShowAddUpCount);

                //转化json形式
                Models.JsonList<ESCM.BayonetEntryModel> jsonList = Models.JsonList<ESCM.BayonetEntryModel>.Success(
                    BayonetEntryList, BayonetEntryList.Count, 1, BayonetEntryList.Count);

                return Ok(Models.JsonMsg<Models.JsonList<ESCM.BayonetEntryModel>>.Success(jsonList, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetBayonetEntryList");
                return Ok(ESCG.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 方法 -> 获取车辆停留时长分析
        /// <summary>
        /// 获取车辆停留时长分析
        /// </summary>
        /// <param name="StatisticsDate">统计日期，格式yyyy-MM-dd</param>
        /// <param name="Serverpart_ID">服务区内码</param>
        /// <param name="Serverpart_Region">服务区方位</param>
        /// <param name="ContainWhole">是否显示全服务区数据，即将两个方位的值合计</param>
        /// <returns></returns>
        [Route("Revenue/GetBayonetSTAList")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<ESCM.BayonetSTAModel>>))]
        public IHttpActionResult GetBayonetSTAList(string StatisticsDate, int? Serverpart_ID = null,
            string Serverpart_Region = "", bool ContainWhole = false)
        {
            string Parameter = "入参信息：统计日期【" + StatisticsDate + "】，服务区内码【" + Serverpart_ID + "】，" +
                "服务区方位【" + Serverpart_Region + "】，显示全服务区【" + ContainWhole + "】";
            try
            {
                //获取车辆停留时长分析
                List<ESCM.BayonetSTAModel> BayonetSTAList = ESCG.BayonetHelper.GetBayonetSTAList(
                    transaction, StatisticsDate, Serverpart_ID, Serverpart_Region, ContainWhole);

                //转化json形式
                Models.JsonList<ESCM.BayonetSTAModel> jsonList = Models.JsonList<ESCM.BayonetSTAModel>.Success(
                    BayonetSTAList, BayonetSTAList.Count, 1, BayonetSTAList.Count);

                return Ok(Models.JsonMsg<Models.JsonList<ESCM.BayonetSTAModel>>.Success(jsonList, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetBayonetSTAList");
                return Ok(ESCG.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 方法 -> 获取车辆归属地分析
        /// <summary>
        /// 获取车辆归属地分析
        /// </summary>
        /// <param name="StatisticsMonth">统计月份，格式yyyyMM</param>
        /// <param name="Serverpart_ID">服务区内码</param>
        /// <param name="Serverpart_Region">服务区方位</param>
        /// <param name="VehicleType">车辆类型</param>
        /// <param name="OwnerCityLenth">显示车牌归属地数量，默认6</param>
        /// <param name="OwnerProvinceLenth">显示车牌所在省份数量，默认4</param>
        /// <param name="ContainWhole">是否显示全服务区数据，即将两个方位的值合计</param>
        /// <returns></returns>
        [Route("Revenue/GetBayonetOAList")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<ESCM.BayonetOAModel, string[]>>))]
        public IHttpActionResult GetBayonetOAList(string StatisticsMonth, int? Serverpart_ID = null, string Serverpart_Region = "",
            string VehicleType = "", int OwnerCityLenth = 6, int OwnerProvinceLenth = 4, bool ContainWhole = false)
        {
            string Parameter = "入参信息：统计月份【" + StatisticsMonth + "】，服务区内码【" + Serverpart_ID + "】，" +
                "服务区方位【" + Serverpart_Region + "】，车辆类型【" + VehicleType + "】，显示全服务区【" + ContainWhole + "】";
            try
            {
                string[] Vehicle_TypeList = new string[3] { "小型车", "中型车", "大型车" };

                //获取车辆归属地分析
                List<ESCM.BayonetOAModel> BayonetOAList = ESCG.BayonetHelper.GetBayonetOAList(transaction, ref Vehicle_TypeList,
                    StatisticsMonth, Serverpart_ID, Serverpart_Region, VehicleType, OwnerCityLenth, OwnerProvinceLenth, ContainWhole);

                //转化json形式
                Models.JsonList<ESCM.BayonetOAModel, string[]> jsonList = Models.JsonList<ESCM.BayonetOAModel, string[]>.Success(
                    BayonetOAList, Vehicle_TypeList, BayonetOAList.Count, 1, BayonetOAList.Count);

                return Ok(Models.JsonMsg<Models.JsonList<ESCM.BayonetOAModel, string[]>>.Success(jsonList, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetBayonetOAList");
                return Ok(ESCG.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }

        /// <summary>
        /// 获取车辆省份地市归属地分析
        /// </summary>
        /// <param name="StatisticsMonth">统计月份，格式yyyyMM</param>
        /// <param name="Serverpart_ID">服务区内码</param>
        /// <param name="Serverpart_Region">服务区方位</param>
        /// <param name="VehicleType">车辆类型</param>
        /// <param name="ProvinceName">省份名称</param>
        /// <param name="OwnerCityLenth">显示车牌归属地数量，默认6</param>
        /// <param name="ContainWhole">是否显示全服务区数据，即将两个方位的值合计</param>
        /// <param name="isExclude">是否统计其他省份</param>
        /// <returns></returns>
        [Route("Revenue/GetBayonetProvinceOAList")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<ESCM.BayonetOAModel, string[]>>))]
        public IHttpActionResult GetBayonetProvinceOAList(string StatisticsMonth, int? Serverpart_ID = null, string Serverpart_Region = "",
            string VehicleType = "", string ProvinceName = "", int OwnerCityLenth = 6, bool ContainWhole = false, bool isExclude = false)
        {
            string Parameter = "入参信息：统计月份【" + StatisticsMonth + "】，服务区内码【" + Serverpart_ID + "】，" +
                "服务区方位【" + Serverpart_Region + "】，车辆类型【" + VehicleType + "】，省份名称【" + ProvinceName + "】，" +
                "显示车牌归属地数量【" + OwnerCityLenth + "】，显示全服务区【" + ContainWhole + "】，统计其他省份【" + isExclude + "】";
            try
            {
                string[] Vehicle_TypeList = new string[3] { "小型车", "中型车", "大型车" };

                //获取车辆归属地分析
                List<ESCM.BayonetOAModel> BayonetOAList = ESCG.BayonetHelper.GetBayonetProvinceOAList(transaction, ref Vehicle_TypeList,
                    StatisticsMonth, Serverpart_ID, Serverpart_Region, VehicleType, ProvinceName, OwnerCityLenth, ContainWhole, isExclude);

                //转化json形式
                Models.JsonList<ESCM.BayonetOAModel, string[]> jsonList = Models.JsonList<ESCM.BayonetOAModel, string[]>.Success(
                    BayonetOAList, Vehicle_TypeList, BayonetOAList.Count, 1, BayonetOAList.Count);

                return Ok(Models.JsonMsg<Models.JsonList<ESCM.BayonetOAModel, string[]>>.Success(jsonList, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetBayonetProvinceOAList");
                return Ok(ESCG.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 方法 -> 获取服务区车流量分析
        /// <summary>
        /// 获取服务区车流量分析
        /// </summary>
        /// <param name="Statistics_Date">统计日期，格式yyyy-MM-dd</param>
        /// <param name="Province_Code">省份编码</param>
        /// <param name="SPRegionType_ID">片区内码</param>
        /// <param name="Serverpart_ID">服务区内码</param>
        /// <param name="Serverpart_Region">服务区方位</param>
        /// <param name="GroupType">
        /// 统计方式：<br/>
        /// 1：统计当日<br/>
        /// 2：统计当月<br/>
        /// 3：统计当年
        /// </param>
        /// <param name="ShowGrowthRate">是否显示增长率，如果不显示增长率，
        /// 接口是给驿行畅旅【每日营收推送】展示车流分析数据的，要放上服务区方位</param>
        /// <returns></returns>
        [Route("Revenue/GetSPBayonetList")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<ESCM.BayonetInModel>>))]
        public IHttpActionResult GetSPBayonetList(string Statistics_Date, string Province_Code = "", string SPRegionType_ID = "",
            string Serverpart_ID = "", string Serverpart_Region = "", int GroupType = 1, bool ShowGrowthRate = false)
        {
            string Parameter = "入参信息：统计日期【" + Statistics_Date + "】，省份编码【" + Province_Code + "】，" +
                "片区内码【" + SPRegionType_ID + "】，服务区内码【" + Serverpart_ID + "】，服务区方位【" + Serverpart_Region + "】";
            try
            {
                //获取服务区车流量分析
                List<ESCM.BayonetInModel> SPBayonetList;
                if (Province_Code != "340000")
                {
                    SPBayonetList = new List<ESCM.BayonetInModel>();
                }
                else
                {
                    string Statistics_StartDate;
                    switch (GroupType)
                    {
                        case 2:
                            Statistics_StartDate = DateTime.Parse(Statistics_Date).ToString("yyyy-MM-01");
                            break;
                        case 3:
                            Statistics_StartDate = DateTime.Parse(Statistics_Date).ToString("yyyy-01-01");
                            break;
                        default:
                            Statistics_StartDate = Statistics_Date;
                            break;
                    }

                    SPBayonetList = ESCG.BayonetHelper.GetSPBayonetList(transaction, Statistics_StartDate,
                        Statistics_Date, SPRegionType_ID, Serverpart_ID, Serverpart_Region, ShowGrowthRate);
                }

                Models.JsonList<ESCM.BayonetInModel> jsonList = Models.JsonList<ESCM.BayonetInModel>.Success(
                    SPBayonetList, SPBayonetList.Count, 1, SPBayonetList.Count);

                return Ok(Models.JsonMsg<Models.JsonList<ESCM.BayonetInModel>>.Success(jsonList, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                transaction.Rollback();
                LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetSPBayonetList");
                return Ok(ESCG.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }

        /// <summary>
        /// 获取服务区车流量排行
        /// </summary>
        /// <param name="Statistics_Date">统计日期，格式yyyy-MM-dd</param>
        /// <param name="Province_Code">省份编码</param>
        /// <param name="SPRegionType_ID">片区内码</param>
        /// <param name="Serverpart_ID">服务区内码</param>
        /// <param name="Serverpart_Region">服务区方位</param>
        /// <param name="GroupType">
        /// 统计方式：<br/>
        /// 1：统计当日<br/>
        /// 2：统计当月<br/>
        /// 3：统计当年
        /// </param>
        /// <param name="ShowGrowthRate">是否显示增长率，如果不显示增长率，
        /// 接口是给驿行畅旅【每日营收推送】展示车流分析数据的，要放上服务区方位</param>
        /// <returns></returns>
        [Route("Revenue/GetBayonetRankList")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<ESCM.BayonetRankModel>))]
        public IHttpActionResult GetBayonetRankList(string Statistics_Date, string Province_Code = "", string SPRegionType_ID = "",
            string Serverpart_ID = "", string Serverpart_Region = "", int GroupType = 1, bool ShowGrowthRate = false)
        {
            string Parameter = "入参信息：统计日期【" + Statistics_Date + "】，省份编码【" + Province_Code + "】，" +
                "片区内码【" + SPRegionType_ID + "】，服务区内码【" + Serverpart_ID + "】，服务区方位【" + Serverpart_Region + "】";
            try
            {
                if (Province_Code != "340000")
                {
                    return Ok(ESCG.Common.ReturnJson(200, "查询失败，无数据返回！"));
                }
                else
                {
                    //获取服务区车流量分析
                    string Statistics_StartDate;
                    switch (GroupType)
                    {
                        case 2:
                            Statistics_StartDate = DateTime.Parse(Statistics_Date).ToString("yyyy-MM-01");
                            break;
                        case 3:
                            Statistics_StartDate = DateTime.Parse(Statistics_Date).ToString("yyyy-01-01");
                            break;
                        default:
                            Statistics_StartDate = Statistics_Date;
                            break;
                    }

                    List<ESCM.BayonetInModel> SPBayonetList = ESCG.BayonetHelper.GetSPBayonetList(transaction, Statistics_StartDate,
                        Statistics_Date, SPRegionType_ID, Serverpart_ID, Serverpart_Region, ShowGrowthRate);
                    if (SPBayonetList.Count == 0)
                    {
                        return Ok(ESCG.Common.ReturnJson(200, "查询失败，无数据返回！"));
                    }
                    ESCM.BayonetRankModel bayonetRankModel = new ESCM.BayonetRankModel
                    {
                        ServerpartFlowList = SPBayonetList.OrderByDescending(o => o.Vehicle_Count).ToList(),
                        SectionFlowList = SPBayonetList.OrderByDescending(o => o.SectionFlow_Count).ToList(),
                        EntryRateList = SPBayonetList.FindAll(o => o.Entry_Rate < 100).OrderByDescending(o => o.Entry_Rate).ToList(),
                    };

                    return Ok(Models.JsonMsg<ESCM.BayonetRankModel>.Success(bayonetRankModel, 100, "查询成功"));
                }
            }
            catch (Exception ex)
            {
                transaction.Rollback();
                LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetBayonetRankList");
                return Ok(ESCG.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 方法 -> 获取服务区平均车流量分析
        /// <summary>
        /// 获取服务区平均车流量分析
        /// </summary>
        /// <param name="Statistics_Date">统计日期，格式yyyy-MM-dd</param>
        /// <param name="Province_Code">省份编码</param>
        /// <param name="SPRegionType_ID">片区内码</param>
        /// <param name="Serverpart_ID">服务区内码</param>
        /// <param name="Serverpart_Region">服务区方位</param>
        /// <returns></returns>
        [Route("Revenue/GetAvgBayonetAnalysis")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<ESCM.BayonetEntryModel>))]
        public IHttpActionResult GetAvgBayonetAnalysis(string Statistics_Date, string Province_Code = "",
            string SPRegionType_ID = "", string Serverpart_ID = "", string Serverpart_Region = "")
        {
            string Parameter = "入参信息：统计日期【" + Statistics_Date + "】，省份编码【" + Province_Code + "】，" +
                "片区内码【" + SPRegionType_ID + "】，服务区内码【" + Serverpart_ID + "】，服务区方位【" + Serverpart_Region + "】";
            try
            {
                if (Province_Code != "340000")
                {
                    return Ok(ESCG.Common.ReturnJson(101, "查询失败，无数据返回！"));
                }

                //获取服务区车流量分析
                ESCM.BayonetEntryModel bayonetEntryModel = ESCG.BayonetHelper.GetAvgBayonetAnalysis(
                    transaction, Statistics_Date, SPRegionType_ID, Serverpart_ID, Serverpart_Region);

                if (bayonetEntryModel == null)
                {
                    return Ok(ESCG.Common.ReturnJson(101, "查询失败，无数据返回！"));
                }
                else
                {
                    return Ok(Models.JsonMsg<ESCM.BayonetEntryModel>.Success(bayonetEntryModel, 100, "查询成功"));
                }
            }
            catch (Exception ex)
            {
                transaction.Rollback();
                LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetAvgBayonetAnalysis");
                return Ok(ESCG.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 方法 -> 获取全省平均车流量分析
        /// <summary>
        /// 获取全省平均车流量分析
        /// </summary>
        /// <param name="Province_Code">省份编码</param>
        /// <param name="Statistics_Date">
        /// 统计日期,格式:yyyy-MM-dd<br/>
        /// 统计月份,格式:yyyyMM
        /// </param>
        /// <returns></returns>
        [Route("Revenue/GetProvinceAvgBayonetAnalysis")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<ESCM.BayonetEntryModel>>))]
        public IHttpActionResult GetProvinceAvgBayonetAnalysis(string Province_Code, string Statistics_Date)
        {
            string Parameter = "入参信息：统计日期/月份【" + Statistics_Date + "】";
            try
            {
                if (Province_Code != "340000")
                {
                    return Ok(ESCG.Common.ReturnJson(101, "查询失败，无数据返回！"));
                }

                //获取服务区车流量分析
                List<ESCM.BayonetEntryModel> AvgBayonetAnalysis = ESCG.BayonetHelper.GetAvgBayonetAnalysis(transaction, Statistics_Date);

                Models.JsonList<ESCM.BayonetEntryModel> jsonList = Models.JsonList<ESCM.BayonetEntryModel>.Success(AvgBayonetAnalysis);

                return Ok(Models.JsonMsg<Models.JsonList<ESCM.BayonetEntryModel>>.Success(jsonList, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                transaction.Rollback();
                LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetAvgBayonetAnalysis");
                return Ok(ESCG.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 方法 -> 获取服务区车辆时段停留时长分析
        /// <summary>
        /// 获取服务区车辆时段停留时长分析
        /// </summary>
        /// <param name="StartMonth">统计开始月份</param>
        /// <param name="EndMonth">统计结束月份</param>
        /// <param name="Province_Code">省份编码</param>
        /// <param name="SPRegionType_ID">片区内码</param>
        /// <param name="Serverpart_ID">服务区内码</param>
        /// <param name="Serverpart_Region">服务区方位</param>
        /// <param name="TimeSpan">时间间隔，默认4h</param>
        /// <returns>
        /// 返参字段：<br/>
        /// name：车辆类型<br/>
        /// data：数组[时间段，停留时长]
        /// </returns>
        [Route("Revenue/GetBayonetSTAnalysis")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<ESCM.CommonScatterModel>>))]
        public IHttpActionResult GetBayonetSTAnalysis(string StartMonth, string EndMonth, string Province_Code = "",
            string SPRegionType_ID = "", string Serverpart_ID = "", string Serverpart_Region = "", int TimeSpan = 4)
        {
            string Parameter = "入参信息：统计开始月份【" + StartMonth + "】，统计结束月份【" + EndMonth + "】，" +
                "省份编码【" + Province_Code + "】，片区内码【" + SPRegionType_ID + "】，服务区内码【" + Serverpart_ID + "】，" +
                "服务区方位【" + Serverpart_Region + "】，时间间隔【" + TimeSpan + "】";
            try
            {
                List<ESCM.CommonScatterModel> SPBayonetList;
                if (Province_Code != "340000" || StartMonth.TryParseToInt() <= 202302)
                {
                    //非安徽省的没有车流数据，直接返回空列表
                    SPBayonetList = new List<ESCM.CommonScatterModel>();
                }
                else
                {
                    //获取服务区车辆时段停留时长分析
                    SPBayonetList = ESCG.BayonetHelper.GetBayonetSTAnalysis(transaction, StartMonth,
                        EndMonth, SPRegionType_ID, Serverpart_ID, Serverpart_Region, TimeSpan);
                }

                Models.JsonList<ESCM.CommonScatterModel> jsonList = Models.JsonList<ESCM.CommonScatterModel>.Success(
                    SPBayonetList, SPBayonetList.Count, 1, SPBayonetList.Count);

                return Ok(Models.JsonMsg<Models.JsonList<ESCM.CommonScatterModel>>.Success(jsonList, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                transaction.Rollback();
                LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetBayonetSTAnalysis");
                return Ok(ESCG.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 方法 -> 获取月度车流分析数据
        /// <summary>
        /// 获取月度车流分析数据
        /// </summary>
        /// <param name="StatisticsDate">统计日期<br/>格式yyyy-MM-dd</param>
        /// <param name="StartDate">统计开始日期<br/>格式yyyy-MM-dd</param>
        /// <param name="EndDate">统计结束日期<br/>格式yyyy-MM-dd</param>
        /// <param name="Serverpart_ID">服务区内码</param>
        /// <param name="Serverpart_Region">服务区方位</param>
        /// <param name="ServerpartShopIds">门店内码集合</param>
        /// <returns></returns>
        [Route("BigData/GetMonthAnalysis")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<ESCM.BayonetMonthAModel>>))]
        public IHttpActionResult GetMonthAnalysis(string StatisticsDate = "", string StartDate = "", string EndDate = "",
            int? Serverpart_ID = null, string Serverpart_Region = "", string ServerpartShopIds = "")
        {
            string Parameter = "入参信息：统计日期【" + StatisticsDate + "】，统计开始日期【" + StartDate + "】，" +
                "统计结束日期【" + EndDate + "】，服务区内码【" + Serverpart_ID + "】，" +
                "服务区方位【" + Serverpart_Region + "】，门店内码【" + ServerpartShopIds + "】";
            try
            {
                if ((string.IsNullOrWhiteSpace(StartDate) || string.IsNullOrWhiteSpace(EndDate)) &&
                    string.IsNullOrWhiteSpace(StatisticsDate))
                {
                    return Ok(ESCG.Common.ReturnJson(200, "查询失败，请传入正确的统计时间！"));
                }
                //当统计开始日期为空，设置查询开始日期是统计日期所在年份的第一天
                if (string.IsNullOrWhiteSpace(StartDate))
                {
                    StartDate = DateTime.Parse(StatisticsDate).ToString("yyyy-01-01");
                }
                //当统计结束日期为空，设置查询结束日期是统计日期所在年份的第一天
                if (string.IsNullOrWhiteSpace(EndDate))
                {
                    EndDate = StatisticsDate;
                }

                bool showBayonet = false;
                //获取营收推送数据表列表
                List<ESCM.BayonetMonthAModel> BayonetEntryList = ESCG.BayonetHelper.GetMonthAnalysis(transaction,
                    ref showBayonet, StartDate, EndDate, Serverpart_ID, Serverpart_Region, ServerpartShopIds);

                //转化json形式
                Models.JsonList<ESCM.BayonetMonthAModel, bool> jsonList = Models.JsonList<ESCM.BayonetMonthAModel, bool>.Success(
                    BayonetEntryList, showBayonet);

                return Ok(Models.JsonMsg<Models.JsonList<ESCM.BayonetMonthAModel, bool>>.Success(jsonList, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetMonthAnalysis");
                return Ok(ESCG.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 方法 -> 获取全省月度车流分析数据
        /// <summary>
        /// 获取全省月度车流分析数据
        /// </summary>
        /// <param name="StatisticsMonth">统计月份，格式：yyyyMM</param>
        /// <param name="SPRegion_ID">片区内码</param>
        /// <param name="Serverpart_ID">服务区内码</param>
        /// <param name="SortStr">排序内容</param>
        /// <returns></returns>
        [Route("BigData/GetProvinceMonthAnalysis")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<ESCM.BayonetMonthAModel>>))]
        public IHttpActionResult GetProvinceMonthAnalysis(string StatisticsMonth,
            string SPRegion_ID = "", string Serverpart_ID = "", string SortStr = "")
        {
            string Parameter = "入参信息：统计月份【" + StatisticsMonth + "】，" +
                "片区内码【" + SPRegion_ID + "】，服务区内码【" + Serverpart_ID + "】";
            try
            {
                //获取营收推送数据表列表
                List<ESCM.BayonetMonthAModel> BayonetEntryList = ESCG.BayonetHelper.GetProvinceMonthAnalysis(
                    transaction, StatisticsMonth, SPRegion_ID, Serverpart_ID, SortStr);

                //转化json形式
                Models.JsonList<ESCM.BayonetMonthAModel> jsonList = Models.JsonList<ESCM.BayonetMonthAModel>.Success(BayonetEntryList);

                return Ok(Models.JsonMsg<Models.JsonList<ESCM.BayonetMonthAModel>>.Success(jsonList, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetProvinceMonthAnalysis");
                return Ok(ESCG.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 方法 -> 获取车流预警数据
        /// <summary>
        /// 获取车流预警数据
        /// </summary>
        /// <param name="StatisticsDate">统计日期</param>
        /// <param name="StatisticsHour">统计时段</param>
        /// <param name="StatisticsType">统计方式<br/>
        /// 1：即时预警数据<br/>
        /// 2：当日车流排行
        /// </param>
        /// <param name="ShowCount">排行显示行数，默认20</param>
        /// <returns></returns>
        [Route("BigData/GetBayonetWarning")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<ESCM.BayonetWarnningModel>>))]
        public IHttpActionResult GetBayonetWarning(string StatisticsDate, int StatisticsHour, int StatisticsType, int ShowCount = 20)
        {
            string Parameter = "入参信息：统计日期【" + StatisticsDate + "】，统计时段【" + StatisticsHour + "】，" +
                "统计方式【" + StatisticsType + "】，排行显示行数【" + ShowCount + "】";
            try
            {
                //获取营收推送数据表列表
                List<ESCM.BayonetWarnningModel> BayonetEntryList = ESCG.BayonetHelper.GetBayonetWarning(
                    transaction, StatisticsDate, StatisticsHour, StatisticsType, ShowCount);

                //转化json形式
                Models.JsonList<ESCM.BayonetWarnningModel> jsonList = Models.JsonList<ESCM.BayonetWarnningModel>.Success(
                    BayonetEntryList, BayonetEntryList.Count, 1, BayonetEntryList.Count);

                return Ok(Models.JsonMsg<Models.JsonList<ESCM.BayonetWarnningModel>>.Success(jsonList, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetBayonetWarning");
                return Ok(ESCG.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 方法 -> 获取当日服务区车流量分析
        /// <summary>
        /// 获取当日服务区车流量分析
        /// </summary>
        /// <param name="pushProvinceCode">省份编码</param>
        /// <param name="StatisticsStartDate">统计开始日期</param>
        /// <param name="StatisticsEndDate">统计结束日期</param>
        /// <param name="SPRegionType_ID">片区内码</param>
        /// <param name="Serverpart_ID">服务区内码</param>
        /// <param name="Serverpart_Region">服务区方位</param>
        /// <param name="ShowGrowthRate">是否显示入区流量增幅</param>
        /// <returns></returns>
        [Route("BigData/GetBayonetGrowthAnalysis")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<ESCM.BayonetGrowthModel>))]
        public IHttpActionResult GetBayonetGrowthAnalysis(string pushProvinceCode, string StatisticsEndDate,
            string StatisticsStartDate = "", string SPRegionType_ID = "", string Serverpart_ID = "",
            string Serverpart_Region = "", bool ShowGrowthRate = false)
        {
            string Parameter = "入参信息：推送省份【" + pushProvinceCode + "】，统计开始日期【" + StatisticsStartDate + "】，" +
                "统计日期【" + StatisticsEndDate + "】，区域内码【" + SPRegionType_ID + "】，服务区内码【" + Serverpart_ID + "】，" +
                "统计营收【" + Serverpart_Region + "】，是否计算增幅【" + ShowGrowthRate + "】";
            try
            {
                if (pushProvinceCode != "340000")
                {
                    return Ok(ESCG.Common.ReturnJson(200, "查询失败，无数据返回！"));
                }

                if (string.IsNullOrWhiteSpace(StatisticsStartDate))
                {
                    StatisticsStartDate = StatisticsEndDate;
                }

                //获取营收推送数据表列表
                ESCM.BayonetGrowthModel bayonetGrowthModel = ESCG.BayonetHelper.GetBayonetGrowthAnalysis(transaction,
                    StatisticsStartDate, StatisticsEndDate, SPRegionType_ID, Serverpart_ID, Serverpart_Region, ShowGrowthRate);
                if (bayonetGrowthModel == null)
                {
                    return Ok(ESCG.Common.ReturnJson(200, "查询失败，无数据返回！"));
                }

                return Ok(Models.JsonMsg<ESCM.BayonetGrowthModel>.Success(bayonetGrowthModel, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetBayonetGrowthAnalysis");
                return Ok(ESCG.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 方法 -> 获取服务区车流量同比分析
        /// <summary>
        /// 获取服务区车流量同比分析
        /// </summary>
        /// <param name="pushProvinceCode">省份编码</param>
        /// <param name="StatisticsStartDate">统计开始日期</param>
        /// <param name="StatisticsEndDate">统计结束日期</param>
        /// <param name="CompareStartDate">同比开始日期</param>
        /// <param name="CompareEndDate">同比结束日期</param>
        /// <param name="SPRegionType_ID">片区内码</param>
        /// <param name="Serverpart_ID">服务区内码</param>
        /// <param name="Serverpart_Region">服务区方位</param>
        /// <returns></returns>
        [Route("BigData/GetBayonetCompare")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<ESCM.BayonetCompareModel>))]
        public IHttpActionResult GetBayonetCompare(string pushProvinceCode, string StatisticsStartDate, string StatisticsEndDate,
            string CompareStartDate = "", string CompareEndDate = "", string SPRegionType_ID = "",
            string Serverpart_ID = "", string Serverpart_Region = "")
        {
            string Parameter = "入参信息：推送省份【" + pushProvinceCode + "】，统计开始日期【" + StatisticsStartDate + "】，" +
                "统计结束日期【" + StatisticsEndDate + "】，区域内码【" + SPRegionType_ID + "】，服务区内码【" + Serverpart_ID + "】，" +
                "统计营收【" + Serverpart_Region + "】";
            try
            {
                if (pushProvinceCode != "340000")
                {
                    return Ok(ESCG.Common.ReturnJson(200, "查询失败，无数据返回！"));
                }
                //默认同比开始时间为去年同期开始时间
                if (string.IsNullOrWhiteSpace(CompareStartDate))
                {
                    CompareStartDate = DateTime.Parse(StatisticsStartDate).AddYears(-1).ToString("yyyy/MM/dd");
                }
                //默认同比结束时间为去年同期结束时间
                if (string.IsNullOrWhiteSpace(CompareEndDate))
                {
                    CompareEndDate = DateTime.Parse(StatisticsEndDate).AddYears(-1).ToString("yyyy/MM/dd");
                }

                //获取营收推送数据表列表
                ESCM.BayonetCompareModel bayonetGrowthModel = ESCG.BayonetHelper.GetBayonetCompare(transaction,
                    StatisticsStartDate, StatisticsEndDate, CompareStartDate, CompareEndDate,
                    SPRegionType_ID, Serverpart_ID, Serverpart_Region);
                if (bayonetGrowthModel == null)
                {
                    return Ok(ESCG.Common.ReturnJson(200, "查询失败，无数据返回！"));
                }

                return Ok(Models.JsonMsg<ESCM.BayonetCompareModel>.Success(bayonetGrowthModel, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetBayonetCompare");
                return Ok(ESCG.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 方法 -> 获取节日服务区平均入区流量对比数据
        /// <summary>
        /// 获取节日服务区平均入区流量对比数据
        /// </summary>
        /// <param name="pushProvinceCode">省份编码</param>
        /// <param name="holidayType">
        /// 节日类型：<br/>
        /// 1【元旦】<br/>2【春运】<br/>3【清明】<br/>4【五一】<br/>5【端午】<br/>6【暑期】<br/>7【中秋】<br/>8【国庆】
        /// </param>
        /// <param name="curYear">当前年份</param>
        /// <param name="compareYear">同比年份</param>
        /// <param name="SPRegionType_ID">片区内码</param>
        /// <param name="Serverpart_ID">服务区内码</param>
        /// <param name="Serverpart_Region">服务区方位</param>
        /// <returns></returns>
        [Route("BigData/GetHolidayCompare")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<ESCM.BayonetCompareModel>))]
        public IHttpActionResult GetHolidayCompare(string pushProvinceCode, int holidayType,
            int curYear, int compareYear, string SPRegionType_ID = "", string Serverpart_ID = "", string Serverpart_Region = "")
        {
            string Parameter = "入参信息：推送省份【" + pushProvinceCode + "】，节日类型【" + holidayType + "】，" +
                "当前年份【" + curYear + "】，同比年份【" + compareYear + "】，区域内码【" + SPRegionType_ID + "】，" +
                "服务区内码【" + Serverpart_ID + "】，统计营收【" + Serverpart_Region + "】";
            try
            {
                if (pushProvinceCode != "340000")
                {
                    return Ok(ESCG.Common.ReturnJson(200, "查询失败，无数据返回！"));
                }

                //获取营收推送数据表列表
                ESCM.BayonetCompareModel bayonetGrowthModel = ESCG.BayonetHelper.GetHolidayCompare(transaction,
                    holidayType, curYear, compareYear, SPRegionType_ID, Serverpart_ID, Serverpart_Region);
                if (bayonetGrowthModel == null)
                {
                    return Ok(ESCG.Common.ReturnJson(200, "查询失败，无数据返回！"));
                }

                return Ok(Models.JsonMsg<ESCM.BayonetCompareModel>.Success(bayonetGrowthModel, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetHolidayCompare");
                return Ok(ESCG.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 方法 -> 获取日均车流归属地数据分析
        /// <summary>
        /// 获取日均车流归属地数据分析
        /// </summary>
        /// <param name="HolidayType">
        /// 节日类型：<br/>
        /// 0【全部】<br/>
        /// 1【节假日】<br/>
        /// 2【非节假日】
        /// </param>
        /// <param name="ServerpartId">服务区内码</param>
        /// <param name="ServerpartType">服务区类型</param>
        /// <param name="StartMonth">统计开始月份，格式yyyyMM</param>
        /// <param name="EndMonth">统计结束月份，格式yyyyMM</param>
        /// <param name="VehicleType">车辆类型</param>
        /// <returns></returns>
        [Route("BigData/GetBayonetOAAnalysis")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<ESCM.BayonetOAModel, string[]>>))]
        public IHttpActionResult GetBayonetOAAnalysis(int HolidayType, string ServerpartId = "", string ServerpartType = "",
            string StartMonth = "", string EndMonth = "", string VehicleType = "")
        {
            string Parameter = "入参信息：节日类型【" + HolidayType + "】，服务区内码【" + ServerpartId + "】，" +
                "服务区类型【" + ServerpartType + "】，车辆类型【" + VehicleType + "】，" +
                "统计开始月份【" + StartMonth + "】，统计结束月份【" + EndMonth + "】";
            try
            {
                //获取车辆归属地分析
                List<ESCM.BayonetOAModel> BayonetOAList = ESCG.BayonetHelper.GetBayonetOAAnalysis(transaction,
                    HolidayType, ServerpartId, ServerpartType, ref StartMonth, ref EndMonth, VehicleType);
                string[] StatisticsMonth = new string[2] { StartMonth, EndMonth };

                //转化json形式
                Models.JsonList<ESCM.BayonetOAModel, string[]> jsonList = Models.JsonList<ESCM.BayonetOAModel, string[]>.Success(
                    BayonetOAList, StatisticsMonth, BayonetOAList.Count, 1, BayonetOAList.Count);

                return Ok(Models.JsonMsg<Models.JsonList<ESCM.BayonetOAModel, string[]>>.Success(jsonList, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetBayonetOAAnalysis");
                return Ok(ESCG.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 方法 -> 获取日度车流分析数据
        /// <summary>
        /// 获取日度车流分析数据
        /// </summary>
        /// <param name="StartDate">统计开始日期<br/>格式yyyy-MM-dd</param>
        /// <param name="EndDate">统计结束日期<br/>格式yyyy-MM-dd</param>
        /// <param name="Serverpart_ID">服务区内码</param>
        /// <returns></returns>
        [Route("BigData/GetDateAnalysis")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<ESCM.BayonetDateModel, List<ESCM.BayonetDateModel>>>))]
        public IHttpActionResult GetDateAnalysis(int Serverpart_ID, string StartDate = "", string EndDate = "")
        {
            string Parameter = "入参信息：统计开始日期【" + StartDate + "】，统计结束日期【" + EndDate + "】"
               + "服务区内码【" + Serverpart_ID + "】";
            try
            {
                List<ESCM.BayonetDateModel> SummaryList = new List<ESCM.BayonetDateModel>();

                List<ESCM.BayonetDateModel> BayonetEntryList = ESCG.BayonetHelper.GetDateAnalysis(transaction,
                    StartDate, EndDate, Serverpart_ID, ref SummaryList);

                //转化json形式
                Models.JsonList<ESCM.BayonetDateModel, List<ESCM.BayonetDateModel>> jsonList = Models.JsonList<
                    ESCM.BayonetDateModel, List<ESCM.BayonetDateModel>>.Success(BayonetEntryList, SummaryList);

                return Ok(Models.JsonMsg<Models.JsonList<ESCM.BayonetDateModel,
                    List<ESCM.BayonetDateModel>>>.Success(jsonList, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetMonthAnalysis");
                return Ok(ESCG.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 方法 -> 根据选择的时间范围补充卡口缺失的数据
        /// <summary>
        /// 根据选择的时间范围补充卡口缺失的数据
        /// </summary>
        /// <param name="ServerpartId">服务区内码ID</param>
        /// <param name="StartDate">统计开始日期</param>
        /// <param name="EndDate">统计结束日期</param>
        /// <param name="ReferenceStartDate">参考数据开始日期</param>
        /// <param name="ReferenceEndDate">参考数据结束日期</param>
        /// <returns></returns>
        [Route("BigData/CorrectBayonet")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<ESCM.BayonetDateModel>>))]
        public IHttpActionResult CorrectBayonet(string ServerpartId,
            string StartDate, string EndDate, string ReferenceStartDate = "", string ReferenceEndDate = "")
        {
            string Parameter = "入参信息：服务区内码集合【" + ServerpartId + "】";
            try
            {
                ESCG.BayonetHelper.CorrectBayonet(
                    transaction, ServerpartId, StartDate, EndDate, ReferenceStartDate, ReferenceEndDate);

                return Ok(ESCG.Common.ReturnJson(100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetBayonetVehicleList");
                return Ok(ESCG.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 方法 -> 判断当前月份是否有有效车流数据
        /// <summary>
        /// 判断当前月份是否有有效车流数据
        /// </summary>
        /// <param name="ServerpartId">服务区内码ID</param>
        /// <param name="StartDate">统计开始日期</param>
        /// <param name="EndDate">统计结束日期</param>
        /// <returns></returns>
        [Route("BigData/JudgeBayonet")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(string))]
        public IHttpActionResult JudgeBayonet(string ServerpartId, string StartDate, string EndDate)
        {
            string Parameter = "入参信息：服务区内码集合【" + ServerpartId + "】";
            try
            {
                string HolidayName = "";
                bool BayonetValid = ESCG.BayonetHelper.JudgeBayonet(transaction, ServerpartId, StartDate, EndDate, ref HolidayName);
                if (BayonetValid)
                {
                    return Ok(ESCG.Common.ReturnJson(100, "车流数据有效", HolidayName));
                }
                else
                {
                    return Ok(ESCG.Common.ReturnJson(200, "车流数据有效天数不足10天！"));
                }
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetBayonetVehicleList");
                return Ok(ESCG.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 方法 -> 更新车流模拟值
        /// <summary>
        /// 更新车流模拟值
        /// </summary>
        /// <param name="sectionFlowList">更新内容</param>
        /// <returns></returns>
        [Route("BigData/CorrectBayonetFlow")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(string))]
        public IHttpActionResult CorrectBayonetFlow(List<ESCM.SectionFlowModel> sectionFlowList)
        {
            string Parameter = "入参信息：" + JsonConvert.SerializeObject(sectionFlowList);
            try
            {
                ESCG.BayonetHelper.CorrectBayonetFlow(transaction, sectionFlowList);

                return Ok(ESCG.Common.ReturnJson(100, "更新成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_CorrectBayonetFlow");
                return Ok(ESCG.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 方法 -> 多维数据看板车流相关接口

        /// <summary>
        /// 获取车辆归属地统计汇总列表(树形)
        /// </summary>
        /// <param name="dataType">统计类型 0：中心统计 1：服务区统计</param>
        /// <param name="serverPartId">服务区内码</param>
        /// <param name="statisticsStartMonth">开始日期(yyyyMM)</param>
        /// <param name="statisticsEndMonth">结束日期(yyyyMM)</param>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <param name="rankNum">省份或城市top</param>
        /// <param name="isSync">是否异步执行</param>
        /// <returns></returns>
        [Route("BigData/GetBayonetOwnerAHTreeList")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<ESCM.NestingModel<ESCM.BayonetOwnerAHRegionModel>>>))]
        public IHttpActionResult GetBayonetOwnerAHTreeList(int dataType, string serverPartId, int statisticsStartMonth,
            int statisticsEndMonth, int? rankNum = null, bool isSync = true, int? pageIndex = 1, int? pageSize = 10)
        {
            var parameter = $@"入参条件：统计类型【{dataType}】，服务区内码【{serverPartId}】，开始日期【{statisticsStartMonth}】，
                结束日期【{statisticsEndMonth}】";
            try
            {
                //获取请求头服务区code,与入参serverPartId取交集,获取对应权限的服务区信息

                var treeList = new List<ESCM.NestingModel<ESCM.BayonetOwnerAHRegionModel>>();
                if (dataType == 1)
                {
                    if (!string.IsNullOrWhiteSpace(serverPartId))
                    {
                        treeList = ESCG.BayonetHelper.GetBayonetOwnerAHTreeDetail(transaction,
                        serverPartId.Split(",")[0].TryParseToInt(), statisticsStartMonth, statisticsEndMonth, rankNum);
                    }
                    else
                    {
                        return Ok(ESCG.Common.ReturnJson(200, "查询失败：服务区信息不能为空"));
                    }
                }
                else
                {
                    treeList = ESCG.BayonetHelper.GetBayonetOwnerAHTreeList(transaction,
                        serverPartId, statisticsStartMonth, statisticsEndMonth, rankNum, isSync);
                }
                var jsonList = Models.JsonList<ESCM.NestingModel<ESCM.BayonetOwnerAHRegionModel>>
                    .Success(treeList, treeList.Count, pageIndex.Value, pageSize.Value);
                return Ok(Models.JsonMsg<Models.JsonList<ESCM.NestingModel<ESCM.BayonetOwnerAHRegionModel>>>.Success(jsonList));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                LogUtil.WriteLog(null, $"查询失败！失败原因：{ex.Message } \r\n {parameter},{DateTime.Now:yyyyMMdd}_GetBayonetOwnerAHTreeList");
                return Ok(ESCG.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }

        /// <summary>
        /// 获取各省入区车辆统计表(树形)
        /// </summary>
        /// <param name="serverPartId">服务区内码集合</param>
        /// <param name="statisticsStartMonth">开始日期(yyyyMM)</param>
        /// <param name="statisticsEndMonth">结束日期(yyyyMM)</param>
        /// <param name="rankNum">城市top</param>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <returns></returns>
        [Route("BigData/GetProvinceVehicleTreeList")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<ESCM.NestingModel<ESCM.ServerPartProvinceModel>>>))]
        public IHttpActionResult GetProvinceVehicleTreeList(string serverPartId, int statisticsStartMonth,
            int statisticsEndMonth, int? rankNum = null, int? pageIndex = 1, int? pageSize = 10)
        {
            var parameter = $@"入参条件：服务区内码【{serverPartId}】，开始日期【{statisticsStartMonth}】，
                结束日期【{statisticsEndMonth}】";
            try
            {
                //获取请求头服务区code,与入参serverPartId取交集,获取对应权限的服务区信息

                var treeList = ESCG.BayonetHelper.GetProvinceVehicleTreeList(transaction,
                    serverPartId, statisticsStartMonth, statisticsEndMonth, rankNum);
                var jsonList = Models.JsonList<ESCM.NestingModel<ESCM.ServerPartProvinceModel>>
                    .Success(treeList, treeList.Count, pageIndex.Value, pageSize.Value);
                return Ok(Models.JsonMsg<Models.JsonList<ESCM.NestingModel<ESCM.ServerPartProvinceModel>>>.Success(jsonList));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                LogUtil.WriteLog(null, $"查询失败！失败原因：{ex.Message } \r\n {parameter},{DateTime.Now:yyyyMMdd}_GetProvinceVehicleTreeList");
                return Ok(ESCG.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }

        /// <summary>
        /// 获取各省入区车辆统计表明细
        /// </summary>
        /// <param name="provinceName">省份</param>
        /// <param name="serverPartId">服务区内码</param>
        /// <param name="cityName">城市</param>
        /// <param name="statisticsStartMonth">开始日期(yyyyMM)</param>
        /// <param name="statisticsEndMonth">结束日期(yyyyMM)</param>
        /// <param name="rankNum">城市top</param>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <returns></returns>
        [Route("BigData/GetProvinceVehicleDetail")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<ESCM.ServerPartProvinceModel>>))]
        public IHttpActionResult GetProvinceVehicleDetail(int statisticsStartMonth, int statisticsEndMonth,
            string provinceName, string serverPartId = "", string cityName = "", int? rankNum = null, int? pageIndex = 1, int? pageSize = 10)
        {
            var parameter = $@"入参条件：省份【{provinceName}】，城市【{cityName}】，开始日期【{statisticsStartMonth}】，
                结束日期【{statisticsEndMonth}】";
            try
            {
                var list = ESCG.BayonetHelper.GetProvinceVehicleDetail(transaction, provinceName, serverPartId, cityName, statisticsStartMonth, statisticsEndMonth, rankNum);
                var jsonList = Models.JsonList<ESCM.SPRegionTypeModel>
                 .Success(list, list.Count, pageIndex.Value, pageSize.Value);
                return Ok(Models.JsonMsg<Models.JsonList<ESCM.SPRegionTypeModel>>.Success(jsonList));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                LogUtil.WriteLog(null, $"查询失败！失败原因：{ex.Message } \r\n {parameter},{DateTime.Now:yyyyMMdd}_GetProvinceVehicleTreeList");
                return Ok(ESCG.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 方法 -> 获取实况车流信息（百度API）
        /// <summary>
        /// 获取实况车流信息（百度API）
        /// </summary>
        /// <param name="RoadName">道路名称</param>
        /// <param name="CityName">城市名称</param>
        /// <returns></returns>
        [Route("BigData/GetBaiDuTrafficInfo")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(string))]
        public IHttpActionResult GetBaiDuTrafficInfo(string RoadName, string CityName)
        {
            try
            {
                string url = "https://api.map.baidu.com/traffic/v1/road?road_name=" + RoadName +
                    "&city=" + CityName + "&ak=XrQQuNQRGxap9YH2xmvx3dzuJVkXhTzT";
                string resultStr = ESCG.HttpUtil.HttpUrlGet(url);

                return Ok(ESCG.Common.ReturnJson(100, "查询成功", resultStr));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                string Parameter = "入参信息：道路名称【" + RoadName + "】，城市名称【" + CityName + "】";
                LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetBaiDuTrafficInfo");
                return Ok(ESCG.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion
    }
}