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

namespace CommercialApi.Controllers
{
    /// <summary>
    /// 获取服务区考核数据相关接口
    /// </summary>
    public class ExamineController : BaseController
    {
        #region 获取考核管理表列表
        /// <summary>
        /// 获取考核管理表列表
        /// </summary>
        /// <param name="searchModel">查询条件对象</param>
        /// <returns></returns>
        [Route("Examine/GetEXAMINEList")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<ESCM.EXAMINEModel>>))]
        public IHttpActionResult GetEXAMINEList(ESCM.SearchModel<ESCM.EXAMINEModel> searchModel)
        {
            string Parameter = "入参信息：" + JsonConvert.SerializeObject(searchModel);
            try
            {
                int TotalCount = 0;
                //获取考核管理表列表
                List<ESCM.EXAMINEModel> EXAMINEList = ESCG.EXAMINEHelper.GetEXAMINEList(
                    transaction, ref TotalCount, searchModel);

                //转化json形式
                Models.JsonList<ESCM.EXAMINEModel> jsonList = Models.JsonList<ESCM.EXAMINEModel>.Success(
                    EXAMINEList, TotalCount, searchModel.PageIndex, searchModel.PageSize);

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

        #region 获取考核管理表明细
        /// <summary>
        /// 获取考核管理表明细
        /// </summary>
        /// <param name="EXAMINEId">考核管理表内码</param>
        /// <returns></returns>
        [Route("Examine/GetEXAMINEDetail")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<ESCM.EXAMINEModel>))]
        public IHttpActionResult GetEXAMINEDetail(int EXAMINEId)
        {
            string Parameter = "入参信息：考核管理表内码【" + EXAMINEId + "】";
            try
            {
                //获取考核管理表明细
                ESCM.EXAMINEModel examineModel = ESCG.EXAMINEHelper.GetEXAMINEDetail(transaction, EXAMINEId);

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

        #region 获取晨会管理表列表
        /// <summary>
        /// 获取晨会管理表列表
        /// </summary>
        /// <param name="searchModel">查询条件对象</param>
        /// <returns></returns>
        [Route("Examine/GetMEETINGList")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<ESCM.MEETINGModel>>))]
        public IHttpActionResult GetMEETINGList(ESCM.SearchModel<ESCM.MEETINGModel> searchModel)
        {
            string Parameter = "入参信息：" + JsonConvert.SerializeObject(searchModel);
            try
            {
                int TotalCount = 0;
                //获取晨会管理表列表
                List<ESCM.MEETINGModel> MEETINGList = ESCG.MEETINGHelper.GetMEETINGList(
                    transaction, ref TotalCount, searchModel);

                //转化json形式
                Models.JsonList<ESCM.MEETINGModel> jsonList = Models.JsonList<ESCM.MEETINGModel>.Success(
                    MEETINGList, TotalCount, searchModel.PageIndex, searchModel.PageSize);

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

        #region 获取晨会管理表明细
        /// <summary>
        /// 获取晨会管理表明细
        /// </summary>
        /// <param name="MEETINGId">晨会管理表内码</param>
        /// <returns></returns>
        [Route("Examine/GetMEETINGDetail")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<ESCM.MEETINGModel>))]
        public IHttpActionResult GetMEETINGDetail(int MEETINGId)
        {
            string Parameter = "入参信息：晨会管理表内码【" + MEETINGId + "】";
            try
            {
                //获取晨会管理表明细
                ESCM.MEETINGModel meetingModel = ESCG.MEETINGHelper.GetMEETINGDetail(transaction, MEETINGId);

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

        #region 获取日常巡检表列表
        /// <summary>
        /// 获取日常巡检表列表
        /// </summary>
        /// <param name="searchModel">查询条件对象</param>
        /// <returns></returns>
        [Route("Examine/GetPATROLList")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<ESCM.PATROLModel>>))]
        public IHttpActionResult GetPATROLList(ESCM.SearchModel<ESCM.PATROLModel> searchModel)
        {
            string Parameter = "入参信息：" + JsonConvert.SerializeObject(searchModel);
            try
            {
                int TotalCount = 0;
                //获取日常巡检表列表
                List<ESCM.PATROLModel> PATROLList = ESCG.PATROLHelper.GetPATROLList(
                    transaction, ref TotalCount, searchModel);

                //转化json形式
                Models.JsonList<ESCM.PATROLModel> jsonList = Models.JsonList<ESCM.PATROLModel>.Success(
                    PATROLList, TotalCount, searchModel.PageIndex, searchModel.PageSize);

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

        #region 获取日常巡检表明细
        /// <summary>
        /// 获取日常巡检表明细
        /// </summary>
        /// <param name="PATROLId">日常巡检表内码</param>
        /// <returns></returns>
        [Route("Examine/GetPATROLDetail")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<ESCM.PATROLModel>))]
        public IHttpActionResult GetPATROLDetail(int PATROLId)
        {
            string Parameter = "入参信息：日常巡检表内码【" + PATROLId + "】";
            try
            {
                //获取日常巡检表明细
                ESCM.PATROLModel patrolModel = ESCG.PATROLHelper.GetPATROLDetail(transaction, PATROLId);

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

        #region 获取小程序考核列表
        /// <summary>
        /// 获取小程序考核列表
        /// </summary>
        /// <param name="SPRegionType_ID">片区内码，多个片区用","隔开</param>
        /// <param name="Serverpart_ID">服务区内码，多个服务区用","隔开</param>
        /// <param name="SearchStartDate">考核日期（开始时间）</param>
        /// <param name="SearchEndDate">考核日期（结束时间）</param>
        /// <returns></returns>
        [Route("Examine/WeChat_GetExamineList")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<List<ESCM.ExamineReturnModel<ESCM.EXAMINEModel>>>))]
        public IHttpActionResult WeChat_GetExamineList(string SearchStartDate, string SearchEndDate,
            string SPRegionType_ID = "", string Serverpart_ID = "")
        {
            string Parameter = "入参信息：片区内码【" + SPRegionType_ID + "】，服务区内码【" + Serverpart_ID + "】，" +
                "考核日期（开始时间）【" + SearchStartDate + "】,考核日期（结束时间）【" + SearchEndDate + "】";
            try
            {
                //获取考核考评考核列表
                List<ESCM.ExamineReturnModel<ESCM.EXAMINEModel>> patrolModel = ESCG.EXAMINEHelper.WeChat_GetExamineList(
                    transaction, SPRegionType_ID, Serverpart_ID, SearchStartDate, SearchEndDate);

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

        #region 获取小程序考核明细数据
        /// <summary>
        /// 获取小程序考核明细数据
        /// </summary>
        /// <param name="ExamineId">考核内码</param>
        /// <returns></returns>
        [Route("Examine/WeChat_GetExamineDetail")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<List<ESCM.ExamineReturnModel<ESCM.EXAMINEModel>>>))]
        public IHttpActionResult WeChat_GetExamineDetail(int ExamineId)
        {
            string Parameter = "入参信息：考核内码【" + ExamineId + "】";
            try
            {
                //获取考核考评考核列表
                List<ESCM.ServerpartRegionModel<ESCM.ExamineDetailModel>> ExamineDetailList =
                    ESCG.EXAMINEHelper.GetExamineDetail(transaction, ExamineId);

                Models.JsonList<ESCM.ServerpartRegionModel<ESCM.ExamineDetailModel>> jsonList =
                    Models.JsonList<ESCM.ServerpartRegionModel<ESCM.ExamineDetailModel>>.Success(ExamineDetailList);

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

        #region 获取小程序日常巡检列表
        /// <summary>
        /// 获取小程序日常巡检列表
        /// </summary>
        /// <param name="SPRegionType_ID">片区内码，多个片区用","隔开</param>
        /// <param name="Serverpart_ID">服务区内码，多个服务区用","隔开</param>
        /// <param name="SearchStartDate">巡检日期（开始时间）</param>
        /// <param name="SearchEndDate">巡检日期（结束时间）</param>
        /// <returns></returns>
        [Route("Examine/WeChat_GetPatrolList")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<List<ESCM.ExamineReturnModel<ESCM.PATROLModel>>>))]
        public IHttpActionResult WeChat_GetPatrolList(string SearchStartDate, string SearchEndDate,
            string SPRegionType_ID = "", string Serverpart_ID = "")
        {
            string Parameter = "入参信息：片区内码【" + SPRegionType_ID + "】，服务区内码【" + Serverpart_ID + "】，" +
                "巡检日期（开始时间）【" + SearchStartDate + "】,巡检日期（结束时间）【" + SearchEndDate + "】";
            try
            {
                //获取考核考评日常巡检列表
                List<ESCM.ExamineReturnModel<ESCM.PATROLModel, ESCM.PATROLDETAILModel>> patrolModel =
                    ESCG.PATROLHelper.WeChat_GetPatrolList(transaction, SPRegionType_ID, Serverpart_ID, SearchStartDate, SearchEndDate);

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

        #region 获取小程序晨会列表
        /// <summary>
        /// 获取小程序晨会列表
        /// </summary>
        /// <param name="SPRegionType_ID">片区内码，多个片区用","隔开</param>
        /// <param name="Serverpart_ID">服务区内码，多个服务区用","隔开</param>
        /// <param name="SearchStartDate">晨会日期（开始时间）</param>
        /// <param name="SearchEndDate">晨会日期（结束时间）</param>
        /// <returns></returns>
        [Route("Examine/WeChat_GetMeetingList")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<List<ESCM.ExamineReturnModel<ESCM.MEETINGModel>>>))]
        public IHttpActionResult WeChat_GetMeetingList(string SearchStartDate, string SearchEndDate,
            string SPRegionType_ID = "", string Serverpart_ID = "")
        {
            string Parameter = "入参信息：片区内码【" + SPRegionType_ID + "】，服务区内码【" + Serverpart_ID + "】，" +
                "晨会日期（开始时间）【" + SearchStartDate + "】,晨会日期（结束时间）【" + SearchEndDate + "】";
            try
            {
                //获取考核考评晨会列表
                List<ESCM.ExamineReturnModel<ESCM.MEETINGModel>> patrolModel = ESCG.MEETINGHelper.WeChat_GetMeetingList(
                    transaction, SPRegionType_ID, Serverpart_ID, SearchStartDate, SearchEndDate);

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

        #region 方法 -> 获取日常巡检分析数据
        /// <summary>
        /// 获取日常巡检分析数据
        /// </summary>
        /// <param name="provinceCode">省份编码</param>
        /// <param name="ServerpartId">服务区内码</param>
        /// <param name="SPRegionType_ID">片区内码</param>
        /// <param name="StartDate">统计开始日期</param>
        /// <param name="EndDate">统计结束日期</param>
        /// <returns></returns>
        [Route("Examine/GetPatrolAnalysis")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<ESCM.PatrolAnalysisModel>))]
        public IHttpActionResult GetPatrolAnalysis(string StartDate, string EndDate,
            string provinceCode, int? ServerpartId = null, int? SPRegionType_ID = null)
        {
            string Parameter = "入参信息：省份编码【" + provinceCode + "】，" +
                "统计开始日期【" + StartDate + "】，统计结束日期【" + EndDate + "】，" +
                "服务区内码【" + ServerpartId + "】，片区内码【" + SPRegionType_ID + "】";
            try
            {
                //获取日常巡检表明细
                ESCM.PatrolAnalysisModel patrolAnalysisModel = ESCG.PATROLHelper.GetPatrolAnalysis(transaction,
                    provinceCode, ServerpartId, SPRegionType_ID, StartDate, EndDate);
                if (patrolAnalysisModel == null)
                {
                    return Ok(ESCG.Common.ReturnJson(200, "查询失败，无数据返回！"));
                }

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

        #region 方法 -> 获取月度考核结果
        /// <summary>
        /// 获取月度考核结果
        /// </summary>
        /// <param name="DataType">
        /// 考核类型：<br/>
        /// 1【月度】<br/>
        /// 2【季度】
        /// </param>
        /// <param name="StartMonth">统计开始月份</param>
        /// <param name="EndMonth">统计结束月份</param>
        /// <param name="provinceCode">省份编码</param>
        /// <param name="ServerpartId">服务区内码</param>
        /// <param name="SPRegionType_ID">片区内码</param>
        /// <returns></returns>
        [Route("Examine/GetExamineAnalysis")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<List<ESCM.CommonKeyModel>>))]
        public IHttpActionResult GetExamineAnalysis(string StartMonth, string EndMonth, string provinceCode,
            int? ServerpartId = null, int? SPRegionType_ID = null, int? DataType = null)
        {
            string Parameter = "入参信息：考核类型【" + DataType + "】，省份编码【" + provinceCode + "】，" +
                "统计开始月份【" + StartMonth + "】，统计结束月份【" + EndMonth + "】，" +
                "服务区内码【" + ServerpartId + "】，片区内码【" + SPRegionType_ID + "】";
            try
            {
                //获取考核考评晨会列表
                List<ESCM.CommonKeyModel> ExamineAnalysis = ESCG.EXAMINEHelper.GetExamineAnalysis(
                    transaction, DataType, provinceCode, ServerpartId, SPRegionType_ID, StartMonth, EndMonth);

                Models.JsonList<ESCM.CommonKeyModel> jsonList = Models.JsonList<ESCM.CommonKeyModel>.Success(ExamineAnalysis);

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

        #region 方法 -> 获取驿达看板-首页考核列表
        /// <summary>
        /// 获取驿达看板-首页考核列表，
        /// 可以按照全省、片区、服务区查询结果
        /// </summary>
        /// <remarks>
        /// 业务逻辑：<br/>
        /// 1、根据入参条件查询月度考核数据，包含考核明细信息（这里要注意考核明细不完整，要用左连接方式查询）<br/>
        /// 2、依次按照服务区、方位、考核主体信息、检查位置进行分组，返回结果集<br/>
        /// 3、服务区层次返参：服务区内码、服务区名称、考核等级（A/B/C三档，
        ///     分别对应优秀[分数大于等于90]/良好[分数大于等于80]/一般[分数小于80]）、方位集合<br/>
        /// 4、方位层次返参：方位名称、考核分数、检查位置集合<br/>
        /// 5、考核主体信息层次返参：考核内码、考核人员、考核分数、考核时间<br/>
        /// 6、检查位置层次返参：检查位置、检查结果集合（因为一个位置可能有多个问题，所以这里是个数组）<br/>
        /// 7、检查结果层次返参：检查位置、考核内容、扣减分数、扣分原因、备注说明、整改图片、整改后图片
        /// </remarks>
        /// <param name="DataType">
        /// 考核类型：<br/>
        /// 1【月度】<br/>
        /// 2【季度】
        /// </param>
        /// <param name="StartMonth">统计开始月份</param>
        /// <param name="EndMonth">统计结束月份</param>
        /// <param name="provinceCode">省份编码</param>
        /// <param name="ServerpartId">服务区内码</param>
        /// <param name="SPRegionType_ID">片区内码</param>
        /// <returns></returns>
        [Route("Examine/GetExamineResultList")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<ESCM.ExamineReturnModel<ESCM.EXAMINEModel>>>))]
        public IHttpActionResult GetExamineResultList(string StartMonth, string EndMonth, string provinceCode,
            int? ServerpartId = null, int? SPRegionType_ID = null, int? DataType = null)
        {
            string Parameter = "入参信息：考核类型【" + DataType + "】，省份编码【" + provinceCode + "】，" +
                "统计开始月份【" + StartMonth + "】，统计结束月份【" + EndMonth + "】，" +
                "服务区内码【" + ServerpartId + "】，片区内码【" + SPRegionType_ID + "】";
            try
            {
                //获取考核考评晨会列表
                List<ESCM.ExamineReturnModel<ESCM.EXAMINEModel>> ExamineAnalysis = ESCG.EXAMINEHelper.GetExamineResultList(
                    transaction, DataType, provinceCode, ServerpartId, SPRegionType_ID, StartMonth, EndMonth);

                Models.JsonList<ESCM.ExamineReturnModel<ESCM.EXAMINEModel>> jsonList =
                    Models.JsonList<ESCM.ExamineReturnModel<ESCM.EXAMINEModel>>.Success(ExamineAnalysis);

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

        #region 方法 -> 获取驿达看板-首页巡查列表
        /// <summary>
        /// 获取驿达看板-首页巡查列表，
        /// 可以按照全省、片区、服务区查询结果
        /// </summary>
        /// <remarks>
        /// 业务逻辑：<br/>
        /// 1、根据入参按日期查询巡检结果，包含整改过和未整改的明细数据<br/>
        /// 2、依次按照服务区、方位、巡查位置进行分组，返回结果集<br/>
        /// 3、服务区层次返参：服务区内码、服务区名称、方位集合<br/>
        /// 4、方位层次返参：方位名称、巡查位置集合<br/>
        /// 5、巡查位置层次返参：巡查位置、巡查结果集合（因为一个位置可能有多个问题，所以这里是个数组）<br/>
        /// 6、巡查结果层次返参：巡查时间、巡查人员、巡查问题、整改前图片、整改后图片
        /// </remarks>
        /// <param name="provinceCode">省份编码</param>
        /// <param name="ServerpartId">服务区内码</param>
        /// <param name="SPRegionType_ID">片区内码</param>
        /// <param name="StartDate">查询开始日期</param>
        /// <param name="EndDate">查询结束日期</param>
        /// <returns></returns>
        [Route("Examine/GetPatrolResultList")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<ESCM.ExamineReturnModel<ESCM.EXAMINEModel>>>))]
        public IHttpActionResult GetPatrolResultList(string StartDate, string EndDate,
            string provinceCode, int? ServerpartId = null, int? SPRegionType_ID = null)
        {
            string Parameter = "入参信息：省份编码【" + provinceCode + "】，" +
                "查询开始日期【" + StartDate + "】，查询结束日期【" + EndDate + "】，" +
                "服务区内码【" + ServerpartId + "】，片区内码【" + SPRegionType_ID + "】";
            try
            {
                //获取考核考评晨会列表
                List<ESCM.ExamineReturnModel<ESCM.PATROLDETAILModel>> PatrolAnalysis = ESCG.PATROLHelper.GetPatrolResultList(
                    transaction, provinceCode, ServerpartId, SPRegionType_ID, StartDate, EndDate);

                Models.JsonList<ESCM.ExamineReturnModel<ESCM.PATROLDETAILModel>> jsonList =
                    Models.JsonList<ESCM.ExamineReturnModel<ESCM.PATROLDETAILModel>>.Success(PatrolAnalysis);

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