Merge branch 'dev' of http://110.188.24.182:10023/Fengwo/hotline into dev

src/Hotline.Api/Controllers/Bi/BiOrderController.cs

@@ -3791,5 +3791,131 @@ namespace Hotline.Api.Controllers.Bi
 
             return ExcelStreamResult(stream, "企业专席信件统计");
         }
-    }
+
+		/// <summary>
+		/// 中心受理统计
+		/// </summary>
+		/// <param name="dto"></param>
+		/// <returns></returns>
+		[HttpGet("center-accept")]
+		public async Task<object> OrderCenterAccept([FromQuery] OrderCenterAcceptPagedRequest dto)
+		{
+			var (total, items) = await _orderApplication.OrderCenterAccept(dto).ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);
+            var time = items.Select(x => x.Time).ToList();
+            var handleNum = items.Sum(x => x.HandleNum);
+            var noHandleNum = items.Sum(x => x.NoHandleNum);
+			return new { Time = time,Data = new PagedDto<OrderCenterAcceptVo>(total, items),PieData = new { HandleNum = handleNum, NoHandleNum = noHandleNum } } ;
+		}
+		/// <summary>
+		/// 中心受理统计导出
+		/// </summary>
+		/// <param name="dto"></param>
+		/// <returns></returns>
+		[HttpPost("center-accept-export")]
+		public async Task<FileStreamResult> OrderCenterAcceptExport([FromBody] ExportExcelDto<OrderCenterAcceptPagedRequest> dto)
+		{
+			var query = _orderApplication.OrderCenterAccept(dto.QueryDto);
+
+			List<OrderCenterAcceptVo> datas;
+			if (dto.IsExportAll)
+			{
+				datas = await query.ToListAsync(HttpContext.RequestAborted);
+			}
+			else
+			{
+				var (_, items) = await query.ToPagedListAsync(dto.QueryDto, HttpContext.RequestAborted);
+				datas = items;
+			}
+			dynamic? dynamicClass = DynamicClassHelper.CreateDynamicClass(dto.ColumnInfos);
+			var dtos = datas
+				.Select(stu => _mapper.Map(stu, typeof(OrderCenterAcceptVo), dynamicClass))
+				.Cast<object>()
+				.ToList();
+
+			var stream = ExcelHelper.CreateStream(dtos);
+			return ExcelStreamResult(stream, "中心受理统计");
+		}
+
+		/// <summary>
+		/// 中心受理值班坐席统计
+		/// </summary>
+		/// <param name="dto"></param>
+		/// <returns></returns>
+		[HttpGet("center-accept-user")]
+		public async Task<PagedDto<OrderCenterAcceptUserVo>> OrderCenterAcceptUser([FromQuery] OrderCenterAcceptPagedRequest dto)
+		{
+			var (total, items) = await _orderApplication.OrderCenterAcceptUser(dto).ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);
+			return new PagedDto<OrderCenterAcceptUserVo>(total, items);
+		}
+		/// <summary>
+		/// 中心受理值班坐席统计导出
+		/// </summary>
+		/// <param name="dto"></param>
+		/// <returns></returns>
+		[HttpPost("center-accept-user-export")]
+		public async Task<FileStreamResult> OrderCenterAcceptUserExport([FromBody] ExportExcelDto<OrderCenterAcceptPagedRequest> dto)
+		{
+			var query = _orderApplication.OrderCenterAcceptUser(dto.QueryDto);
+
+			List<OrderCenterAcceptUserVo> datas;
+			if (dto.IsExportAll)
+			{
+				datas = await query.ToListAsync(HttpContext.RequestAborted);
+			}
+			else
+			{
+				var (_, items) = await query.ToPagedListAsync(dto.QueryDto, HttpContext.RequestAborted);
+				datas = items;
+			}
+			dynamic? dynamicClass = DynamicClassHelper.CreateDynamicClass(dto.ColumnInfos);
+			var dtos = datas
+				.Select(stu => _mapper.Map(stu, typeof(OrderCenterAcceptUserVo), dynamicClass))
+				.Cast<object>()
+				.ToList();
+
+			var stream = ExcelHelper.CreateStream(dtos);
+			return ExcelStreamResult(stream, "中心受理值班坐席统计");
+		}
+
+		/// <summary>
+		/// 中心受理时间段统计
+		/// </summary>
+		/// <param name="dto"></param>
+		/// <returns></returns>
+		[HttpGet("center-accept-hour")]
+		public async Task<PagedDto<OrderCenterAcceptHourVo>> OrderCenterAcceptHour([FromQuery] OrderCenterAcceptPagedRequest dto)
+		{
+			var (total, items) = await _orderRepository.OrderCenterAcceptHour(dto).ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);
+			return new PagedDto<OrderCenterAcceptHourVo>(total, items);
+		}
+		/// <summary>
+		/// 中心受理时间段统计导出
+		/// </summary>
+		/// <param name="dto"></param>
+		/// <returns></returns>
+		[HttpPost("center-accept-hour-export")]
+		public async Task<FileStreamResult> OrderCenterAcceptHourExport([FromBody] ExportExcelDto<OrderCenterAcceptPagedRequest> dto)
+		{
+			var query = _orderRepository.OrderCenterAcceptHour(dto.QueryDto);
+
+			List<OrderCenterAcceptHourVo> datas;
+			if (dto.IsExportAll)
+			{
+				datas = await query.ToListAsync(HttpContext.RequestAborted);
+			}
+			else
+			{
+				var (_, items) = await query.ToPagedListAsync(dto.QueryDto, HttpContext.RequestAborted);
+				datas = items;
+			}
+			dynamic? dynamicClass = DynamicClassHelper.CreateDynamicClass(dto.ColumnInfos);
+			var dtos = datas
+				.Select(stu => _mapper.Map(stu, typeof(OrderCenterAcceptHourVo), dynamicClass))
+				.Cast<object>()
+				.ToList();
+
+			var stream = ExcelHelper.CreateStream(dtos);
+			return ExcelStreamResult(stream, "中心受理时间段统计");
+		}
+	}
 }

src/Hotline.Api/Controllers/OrderController.cs

@@ -52,6 +52,7 @@ using Microsoft.Extensions.Options;
 using MiniExcelLibs;
 using MongoDB.Driver;
 using SqlSugar;
+using StackExchange.Redis;
 using XF.Domain.Authentications;
 using XF.Domain.Cache;
 using XF.Domain.Entities;
@@ -593,6 +594,138 @@ public class OrderController : BaseController
         return res;
     }
 
+    /// <summary>
+    /// 部门发布量统计
+    /// </summary>
+    /// <param name="dto"></param>
+    /// <returns></returns>
+    [HttpGet("published/statistics/department")]
+    [AllowAnonymous]
+    public async Task<PagedDto<PublishedOrderStatisticsDto>> QueryPublishedOrderDepartmentAsync([FromQuery] QueryOrderPublishStatisticsAllDto dto)
+    {
+        var (total, items) = await _orderApplication.QueryPublishedOrderDepartmentAsync(dto, false);
+        return new PagedDto<PublishedOrderStatisticsDto>(total, _mapper.Map<IReadOnlyList<PublishedOrderStatisticsDto>>(items));
+    }
+
+    /// <summary>
+    /// 部门发布量统计-导出
+    /// </summary>
+    /// <param name="dto"></param>
+    /// <returns></returns>
+    [HttpPost("published/statistics/department/export")]
+    [AllowAnonymous]
+    public async Task<FileStreamResult> ExportQueryPublishedOrderDepartmentAsync([FromBody]ExportExcelDto<QueryOrderPublishStatisticsAllDto> dto)
+    {
+        var (total, list) = await _orderApplication.QueryPublishedOrderDepartmentAsync(dto.QueryDto, dto.IsExportAll);
+        if (list != null && list.Count > 0)
+        {
+            list.Add(new PublishedOrderStatisticsDto()
+            {
+                Name = "合计",
+                PrivateCount = list.Sum(m => m.PrivateCount),
+                TotalCount = list.Sum(p => p.TotalCount),
+                PublicCount = list.Sum(m => m.PublicCount),
+                WaitCount = list.Sum(m => m.WaitCount)
+            });
+        }
+
+        dynamic? dynamicClass = DynamicClassHelper.CreateDynamicClass(dto.ColumnInfos);
+
+        var dtos = list
+            .Select(stu => _mapper.Map(stu, typeof(PublishedOrderStatisticsDto), dynamicClass))
+            .Cast<object>()
+            .ToList();
+
+        var stream = ExcelHelper.CreateStream(dtos);
+
+        return ExcelStreamResult(stream, "部门发布量统计");
+    }
+
+    /// <summary>
+    /// 发布量统计
+    /// </summary>
+    /// <param name="dto"></param>
+    /// <returns></returns>
+    [HttpGet("published/statistics/user")]
+    [AllowAnonymous]
+    public async Task<PagedDto<PublishedOrderStatisticsDto>> QueryPublishedOrderUserAsync([FromQuery] QueryOrderPublishStatisticsDto dto)
+    {
+        var (total, list) = await _orderApplication.QueryPublishedOrderAsync(dto, false);
+        return new PagedDto<PublishedOrderStatisticsDto>(total, _mapper.Map<IReadOnlyList<PublishedOrderStatisticsDto>>(list));
+    }
+
+    /// <summary>
+    /// 发布量统计-导出
+    /// </summary>
+    /// <param name="dto"></param>
+    /// <returns></returns>
+    [HttpPost("published/statistics/user/export")]
+    [AllowAnonymous]
+    public async Task<FileStreamResult> ExportQueryPublishedOrder([FromBody] ExportExcelDto<QueryOrderPublishStatisticsDto> dto)
+    {
+        var (total, list) = await _orderApplication.QueryPublishedOrderAsync(dto.QueryDto, dto.IsExportAll);
+        if (list != null && list.Count > 0)
+        {
+            list.Add(new PublishedOrderStatisticsDto()
+            {
+                Name = "合计",
+                PrivateCount = list.Sum(m => m.PrivateCount),
+                TotalCount = list.Sum(p => p.TotalCount),
+                PublicCount = list.Sum(m => m.PublicCount),
+                WaitCount = list.Sum(m => m.WaitCount)
+            });
+        }
+
+        dynamic? dynamicClass = DynamicClassHelper.CreateDynamicClass(dto.ColumnInfos);
+
+        var dtos = list
+            .Select(stu => _mapper.Map(stu, typeof(PublishedOrderStatisticsDto), dynamicClass))
+            .Cast<object>()
+            .ToList();
+
+        var stream = ExcelHelper.CreateStream(dtos);
+
+        return ExcelStreamResult(stream, "发布量统计");
+    }
+
+    /// <summary>
+    /// 发布量统计
+    /// </summary>
+    /// <param name="dto"></param>
+    /// <returns></returns>
+    [HttpGet("published/statistics")]
+    [AllowAnonymous]
+    public async Task<PublishedOrderStatisticsDto> QueryPublishedOrderAsync([FromQuery] QueryOrderPublishStatisticsAllDto dto)
+    {
+        var totalCount = await _orderRepository.Queryable()
+         .Where(order => order.CreationTime >= dto.StartTime && order.CreationTime <= dto.EndTime)
+         .Select(order => SqlFunc.AggregateCount(order.Id))
+         .FirstAsync();
+
+        var publicCount = await _orderPublishRepository.Queryable()
+            .LeftJoin<Hotline.Orders.Order>((publish, order) => publish.OrderId == order.Id)
+            .Where((publish, order) => publish.CreationTime >= dto.StartTime && publish.CreationTime <= dto.EndTime)
+            .Where((publish, order) => publish.PublishState == true)
+            .Select((publish, order) => SqlFunc.AggregateCount(order.Id))
+            .FirstAsync();
+
+        var privateCount = await _orderPublishRepository.Queryable()
+            .LeftJoin<Hotline.Orders.Order>((publish, order) => publish.OrderId == order.Id)
+            .Where((publish, order) => publish.CreationTime >= dto.StartTime && publish.CreationTime <= dto.EndTime)
+            .Where((publish, order) => publish.PublishState == false)
+            .Select((publish, order) => SqlFunc.AggregateCount(order.Id)
+            )
+            .FirstAsync();
+
+
+        return new PublishedOrderStatisticsDto {
+            TotalCount = totalCount,
+            PrivateCount = privateCount,
+            PublicCount = publicCount,
+            WaitCount = totalCount - privateCount - publicCount
+        };
+    }
+
     /// <summary>
     /// 已发布列表
     /// </summary>

src/Hotline.Application/Orders/IOrderApplication.cs

@@ -81,6 +81,21 @@ namespace Hotline.Application.Orders
         /// <returns></returns>
         Task<IList<OrderVisitSourceChannelDto>> QueryOrderVisitSourceChannelAsync(QueryOrderVisitSourceChannelDto dto);
 
+        /// <summary>
+        /// 发布量统计
+        /// </summary>
+        /// <param name="dto"></param>
+        /// <returns></returns>
+        Task<(int, IList<PublishedOrderStatisticsDto>)> QueryPublishedOrderAsync(QueryOrderPublishStatisticsDto dto, bool isFull);
+
+        /// <summary>
+        /// 部门发布量统计
+        /// </summary>
+        /// <param name="dto"></param>
+        /// <returns></returns>
+        /// <exception cref="UserFriendlyException"></exception>
+        Task<(int, IList<PublishedOrderStatisticsDto>)> QueryPublishedOrderDepartmentAsync(QueryOrderPublishStatisticsAllDto dto, bool isFull);
+
         #region 工单办理
 
         ISugarQueryable<Order> QueryOrders(QueryOrderDto dto);
@@ -245,5 +260,18 @@ namespace Hotline.Application.Orders
         /// <returns></returns>
         ISugarQueryable<OrderScreenAuditVo> OrderScreenAudit(OrderScreenAuditPagedRequest dto);
 
+
+        /// <summary>
+        /// 中心受理统计（日期）
+        /// </summary>
+        /// <param name="dto"></param>
+        /// <returns></returns>
+		ISugarQueryable<OrderCenterAcceptVo> OrderCenterAccept(OrderCenterAcceptPagedRequest dto);
+
+        /// <summary>
+        /// 中心受理统计（值班坐席）
+        /// </summary>
+        /// <returns></returns>
+		ISugarQueryable<OrderCenterAcceptUserVo> OrderCenterAcceptUser(OrderCenterAcceptPagedRequest dto);
 	}
 }

src/Hotline.Application/Orders/OrderApplication.cs

@@ -42,19 +42,22 @@ using PanGu.Match;
 using Hotline.Settings.Hotspots;
 using Hotline.Share.Enums.FlowEngine;
 using Hotline.Authentications;
+using Hotline.Repository.SqlSugar;
 using MediatR;
 using Hotline.Share.Mq;
 using JiebaNet.Segmenter;
 using Microsoft.AspNetCore.Http;
 using WordInfo = PanGu.WordInfo;
 using Hotline.Schedulings;
+using NPOI.SS.Formula.Functions;
 using XF.Domain.Entities;
 
 namespace Hotline.Application.Orders;
 
 public class OrderApplication : IOrderApplication, IScopeDependency
 {
-    private readonly IOrderDomainService _orderDomainService;
+	
+	private readonly IOrderDomainService _orderDomainService;
     private readonly IWorkflowDomainService _workflowDomainService;
     private readonly IOrderRepository _orderRepository;
     private readonly ITimeLimitDomainService _timeLimitDomainService;
@@ -76,10 +79,12 @@ public class OrderApplication : IOrderApplication, IScopeDependency
     private readonly IRepository<WorkflowStep> _workflowStepRepository;
     private readonly IRepository<WorkflowTrace> _workflowTraceRepository;
     private readonly IRepository<SystemDicData> _systemDicDataRepository;
+    private readonly IRepository<OrderPublish> _orderPublishRepository;
     private readonly IRepository<OrderScreen> _orderScreenRepository;
+    private readonly IRepository<OrderSendBackAudit> _orderSendBackAuditRepository;
 
 
-	public OrderApplication(
+    public OrderApplication(
         IOrderDomainService orderDomainService,
         IOrderRepository orderRepository,
         IWorkflowDomainService workflowDomainService,
@@ -102,7 +107,9 @@ public class OrderApplication : IOrderApplication, IScopeDependency
         IRepository<WorkflowStep> workflowStepRepository,
         IRepository<SystemDicData> systemDicDataRepository,
         IRepository<WorkflowTrace> workflowTraceRepository,
-        IRepository<OrderScreen> orderScreenRepository)
+        IRepository<OrderPublish> orderPublishRepository,
+        IRepository<OrderScreen> orderScreenRepository,
+        IRepository<OrderSendBackAudit> orderSendBackAuditRepository)
     {
         _orderDomainService = orderDomainService;
         _workflowDomainService = workflowDomainService;
@@ -127,7 +134,8 @@ public class OrderApplication : IOrderApplication, IScopeDependency
         _systemDicDataRepository = systemDicDataRepository;
         _workflowTraceRepository = workflowTraceRepository;
         _orderScreenRepository = orderScreenRepository;
-
+        _orderPublishRepository = orderPublishRepository;
+        _orderSendBackAuditRepository = orderSendBackAuditRepository;
 	}
 
     /// <summary>
@@ -342,7 +350,7 @@ public class OrderApplication : IOrderApplication, IScopeDependency
         var seg = new Segment();
         ICollection<WordInfo> splitWords = seg.DoSegment(inputStr);
         var words = new List<string>();
-        for (int i = 0; i < splitWords.Count; i++)
+        for (int i = 0;i < splitWords.Count;i++)
         {
             var word = splitWords.ElementAt(i);
             if (word is { WordType: WordType.SimplifiedChinese, Word.Length: > 1 })
@@ -442,38 +450,156 @@ public class OrderApplication : IOrderApplication, IScopeDependency
     }
 
     /// <summary>
-    /// 回访来源统计
+    /// 发布量统计
     /// </summary>
     /// <param name="dto"></param>
     /// <returns></returns>
-    /// <exception cref="NotImplementedException"></exception>
-    public async Task<IList<OrderVisitSourceChannelDto>> QueryOrderVisitSourceChannelAsync(QueryOrderVisitSourceChannelDto dto)
+    /// <exception cref="UserFriendlyException"></exception>
+    public async Task<(int, IList<PublishedOrderStatisticsDto>)> QueryPublishedOrderAsync(QueryOrderPublishStatisticsDto dto, bool isFull)
     {
-        var startDate = new DateTime();
-        var endDate = new DateTime();
-        switch (dto.DateType)
+        var publicCount = await GetPublishCount(dto, true);
+
+        var privateCount = await GetPublishCount(dto, false);
+
+        var query = _orderRepository.Queryable()
+         .Where(order => order.CreationTime >= dto.StartTime && order.CreationTime <= dto.EndTime)
+         .WhereIF(dto.ProcessType != null, order => order.ProcessType == dto.ProcessType)
+         .GroupBy(order => order.AcceptorName)
+         .Select(order => new QueryPublishedOrderDataDto
+         {
+             Count = SqlFunc.AggregateCount(order.Id),
+             Name = SqlFunc.AggregateMax(order.AcceptorName),
+             Id = SqlFunc.AggregateMax(order.AcceptorId),
+         });
+
+        int total = 0;
+
+        var items = new List<QueryPublishedOrderDataDto>();
+
+        if (isFull)
         {
-            case EDateType.Day:
-                (startDate, endDate) = dto.StartTime.GetDayStartAndEnd();
-                break;
-            case EDateType.Week:
-                (startDate, endDate) = dto.StartTime.GetWeekStartAndEnd();
-                break;
-            case EDateType.Month:
-                (startDate, endDate) = dto.StartTime.GetMonthStartAndEnd();
-                break;
-            case EDateType.TimeLimit:
-                if (dto.EndTime is null) throw new UserFriendlyException("结束时间错误");
-                startDate = dto.StartTime;
-                endDate = dto.EndTime.Value;
-                break;
-            default:
-                break;
+            items = await query.ToListAsync();
+        }
+        else
+        {
+            (total, items) = await query.ToPagedListAsync(dto.PageIndex, dto.PageSize);
+        }
+
+        var result = new List<PublishedOrderStatisticsDto>();
+        foreach (var item in items)
+        {
+            var statisticsDto = new PublishedOrderStatisticsDto
+            {
+                Name = item.Name,
+                TotalCount = item.Count,
+                PrivateCount = privateCount.Where(m => m.Id == item.Id).FirstOrDefault()?.Count ?? 0,
+                PublicCount = publicCount.Where(m => m.Id == item.Id).FirstOrDefault()?.Count ?? 0,
+            };
+            statisticsDto.WaitCount = statisticsDto.TotalCount - statisticsDto.PrivateCount - statisticsDto.PublicCount;
+            result.Add(statisticsDto);
         }
+        return (total, result);
+    }
 
+    private async Task<List<QueryPublishedOrderDataDto>> GetPublishCount(QueryOrderPublishStatisticsDto dto, bool isPublic)
+    {
+        return await _orderPublishRepository.Queryable()
+            .LeftJoin<Order>((publish, order) => publish.OrderId == order.Id)
+            .Where((publish, order) => publish.CreationTime >= dto.StartTime && publish.CreationTime <= dto.EndTime)
+            .Where((publish, order) => publish.PublishState == isPublic)
+            .WhereIF(dto.ProcessType != null, (publish, order) => order.ProcessType == dto.ProcessType)
+            .GroupBy((publish, order) => new { publish.CreatorId })
+            .Select((publish, order) => new QueryPublishedOrderDataDto
+            {
+                Count = SqlFunc.AggregateCount(order.Id),
+                Id = SqlFunc.AggregateMax(order.AcceptorId),
+                Name = SqlFunc.AggregateMax(order.AcceptorName)
+            })
+            .ToListAsync();
+    }
+
+    /// <summary>
+    /// 发布量统计(部门)
+    /// </summary>
+    /// <param name="dto"></param>
+    /// <returns></returns>
+    /// <exception cref="UserFriendlyException"></exception>
+    public async Task<(int, IList<PublishedOrderStatisticsDto>)> QueryPublishedOrderDepartmentAsync(QueryOrderPublishStatisticsAllDto dto, bool isFull)
+    {
+        var publicCount = await GetPublishCountDepartment(dto, true);
+        var privateCount = await GetPublishCountDepartment(dto, false);
+
+        var total = 0;
+        var items = new List<QueryPublishedOrderDataDto>();
+
+        var query = _orderRepository.Queryable()
+            .Where(order => order.CreationTime >= dto.StartTime && order.CreationTime <= dto.EndTime)
+            .GroupBy(order => order.ActualHandleOrgName)
+            .Select(order => new QueryPublishedOrderDataDto
+            {
+                Count = SqlFunc.AggregateCount(order.Id),
+                Name = SqlFunc.AggregateMax(order.ActualHandleOrgName),
+                Id = SqlFunc.AggregateMax(order.ActualHandleOrgCode),
+            });
+
+        if (isFull)
+        {
+            items = await query.ToListAsync();
+        }
+        else
+        {
+            (total, items) = await query.ToPagedListAsync(dto.PageIndex, dto.PageSize);
+        }
+
+        var result = new List<PublishedOrderStatisticsDto>();
+        foreach (var item in items)
+        {
+            var privateItem = privateCount?.Where(m => m.Id == item.Id).FirstOrDefault();
+            var publicItem = publicCount?.Where(m => m.Id == item.Id).FirstOrDefault();
+            var statisticsDto = new PublishedOrderStatisticsDto
+            {
+                Name = item.Name,
+                TotalCount = item.Count,
+                PrivateCount = privateItem?.Count ?? 0,
+                PublicCount = publicItem?.Count ?? 0,
+            };
+            if (publicItem is not null) statisticsDto.PublishTime = publicItem.CreationTime;
+            if (privateItem is not null) statisticsDto.PublishTime = privateItem.CreationTime;
+            statisticsDto.WaitCount = statisticsDto.TotalCount - statisticsDto.PrivateCount - statisticsDto.PublicCount;
+            result.Add(statisticsDto);
+        }
+        return (total, result);
+    }
+
+    private async Task<List<QueryPublishedOrderDataDto>> GetPublishCountDepartment(QueryOrderPublishStatisticsAllDto dto, bool isPublic)
+    {
+        return await _orderPublishRepository.Queryable()
+            .LeftJoin<Order>((publish, order) => publish.OrderId == order.Id)
+            .Where((publish, order) => publish.CreationTime >= dto.StartTime && publish.CreationTime <= dto.EndTime)
+            .Where((publish, order) => publish.PublishState == isPublic)
+            .GroupBy((publish, order) => order.ActualHandleOrgCode)
+            .Select((publish, order) => new QueryPublishedOrderDataDto
+            {
+                Count = SqlFunc.AggregateCount(order.Id),
+                Id = SqlFunc.AggregateMax(order.ActualHandleOrgCode),
+                Name = SqlFunc.AggregateMax(order.ActualHandleOrgName),
+                CreationTime = SqlFunc.AggregateMax(publish.CreationTime)
+            })
+            .ToListAsync();
+    }
+
+
+    /// <summary>
+    /// 回访来源统计
+    /// </summary>
+    /// <param name="dto"></param>
+    /// <returns></returns>
+    /// <exception cref="NotImplementedException"></exception>
+    public async Task<IList<OrderVisitSourceChannelDto>> QueryOrderVisitSourceChannelAsync(QueryOrderVisitSourceChannelDto dto)
+    {
         var result = await _orderVisitRepository.Queryable()
             .LeftJoin<Order>((visit, order) => order.Id == visit.OrderId)
-            .Where((visit, order) => visit.VisitTime >= startDate && visit.VisitTime <= endDate)
+            .Where((visit, order) => visit.VisitTime >= dto.StartTime && visit.VisitTime <= dto.EndTime)
             .GroupBy((visit, order) => new { order.SourceChannel })
             .Select((visit, order) => new OrderVisitSourceChannelDto
             {
@@ -509,7 +635,7 @@ public class OrderApplication : IOrderApplication, IScopeDependency
             visit.VisitTime = dto.VisitTime;
             visit.VisitType = dto.VisitType;
 
-            for (int i = 0; i < visit.OrderVisitDetails.Count; i++)
+            for (int i = 0;i < visit.OrderVisitDetails.Count;i++)
             {
                 var detail = visit.OrderVisitDetails[i];
                 var detaildto = dto.OrderVisitDetailDto.FirstOrDefault(x => x.Id == detail.Id);
@@ -1201,10 +1327,10 @@ public class OrderApplication : IOrderApplication, IScopeDependency
             dt.Columns.Remove("Column1");
 
         //计算小计
-        for (int i = 0; i < dt.Rows.Count; i++)
+        for (int i = 0;i < dt.Rows.Count;i++)
         {
             int sumcount = 0;
-            for (int j = 1; j < dt.Columns.Count - 1; j++)
+            for (int j = 1;j < dt.Columns.Count - 1;j++)
             {
                 sumcount += Convert.ToInt32(dt.Rows[i][j].ToString());
             }
@@ -1215,10 +1341,10 @@ public class OrderApplication : IOrderApplication, IScopeDependency
         DataRow totalRow = dt.NewRow();
         if (dt.Columns[0].ColumnName == "HotspotName") totalRow["HotspotName"] = "合计";
         else totalRow["一级热点"] = "合计";
-        for (int i = 1; i < dt.Columns.Count; i++)
+        for (int i = 1;i < dt.Columns.Count;i++)
         {
             int sumcount = 0;
-            for (int j = 0; j < dt.Rows.Count; j++)
+            for (int j = 0;j < dt.Rows.Count;j++)
             {
                 sumcount += Convert.ToInt32(dt.Rows[j][i].ToString());
             }
@@ -1515,144 +1641,144 @@ public class OrderApplication : IOrderApplication, IScopeDependency
         return query;
     }
 
-	/// <summary>
-	/// 热点受理类型统计
-	/// </summary>
-	/// <param name="dto"></param>
-	/// <returns></returns>
-	public async Task<(List<SystemDicData> acceptTypes, object items)> HotspotAndAcceptTypeStatistics(HotspotAndAcceptTypeStatisticsReq dto)
-	{
-		dto.EndTime = dto.EndTime.AddDays(1).AddSeconds(-1);
-		var dicList = _systemDicDataRepository.Queryable().Where(x => x.DicTypeCode == "AcceptType").OrderBy(x => x.Sort).MergeTable();
-		var endIndex = (2 * dto.HotspotLevel).ToString();
-		var hotspotList = _hotspotRepository.Queryable().Where(x => SqlFunc.Length(x.Id) == int.Parse(endIndex))
-			.Select(x => new
-			{
-				HotspotId = x.Id,
-				HotspotName = x.HotSpotFullName,
-			}).MergeTable();
-    
-		var orderList = _orderRepository.Queryable().Where(x => x.CreationTime >= dto.StartTime && x.CreationTime < dto.EndTime)
-			.Select(x => new
-			{
-				HotspotId = x.HotspotId.Substring(0, int.Parse(endIndex)),
-				AcceptTypeCode = x.AcceptTypeCode,
-			}).MergeTable();
-
-		var hotListAndOrder = hotspotList.LeftJoin(orderList, (it, o) => it.HotspotId == o.HotspotId)
-			 .GroupBy((it, o) => new
-			 {
-				 it.HotspotId,
-				 it.HotspotName,
-				 AcceptTypeCode = o.AcceptTypeCode,
-			 })
-			 .OrderBy((it, o) => it.HotspotId)
-			 .Select((it, o) => new
-			 {
-				 HotspotId = it.HotspotId,
-				 HotspotName = it.HotspotName,
-				 AcceptTypeCode = o.AcceptTypeCode,
-				 Count = SqlFunc.AggregateCount(it.HotspotId)
-			 }).MergeTable();
-
-		var returnList = await dicList.LeftJoin(hotListAndOrder, (pp, dd) => pp.DicDataValue == dd.AcceptTypeCode)
-		   .GroupBy((pp, dd) => new
-		   {
-			   HotspotId = dd.HotspotId,
-			   HotspotName = dd.HotspotName,
-			   AcceptTypeCode = pp.DicDataValue,
-			   AcceptType = pp.DicDataName,
-		   })
-		   .OrderBy((pp, dd) => dd.HotspotId)
-		   .Select((pp, dd) => new
-		   {
-			   HotspotId = dd.HotspotId,
-			   HotspotName = dd.HotspotName,
-			   AcceptTypeCode = pp.DicDataValue,
-			   AcceptType = pp.DicDataName,
-			   Count = SqlFunc.AggregateSum(dd.Count)
-		   }).ToPivotListAsync(q => q.AcceptTypeCode, q => new { q.HotspotName, q.HotspotId }, q => q.Sum(x => x.Count));
-
-		var titleList = await _systemDicDataRepository.Queryable().Where(x => x.DicTypeCode == "AcceptType").OrderBy(x => x.Sort).ToListAsync();
-		return (titleList, returnList);
-	}
+    /// <summary>
+    /// 热点受理类型统计
+    /// </summary>
+    /// <param name="dto"></param>
+    /// <returns></returns>
+    public async Task<(List<SystemDicData> acceptTypes, object items)> HotspotAndAcceptTypeStatistics(HotspotAndAcceptTypeStatisticsReq dto)
+    {
+        dto.EndTime = dto.EndTime.AddDays(1).AddSeconds(-1);
+        var dicList = _systemDicDataRepository.Queryable().Where(x => x.DicTypeCode == "AcceptType").OrderBy(x => x.Sort).MergeTable();
+        var endIndex = (2 * dto.HotspotLevel).ToString();
+        var hotspotList = _hotspotRepository.Queryable().Where(x => SqlFunc.Length(x.Id) == int.Parse(endIndex))
+            .Select(x => new
+            {
+                HotspotId = x.Id,
+                HotspotName = x.HotSpotFullName,
+            }).MergeTable();
 
-	/// <summary>
-	/// 热点受理类型统计--导出
-	/// </summary>
-	/// <param name="dto"></param>
-	/// <returns></returns>
-	public async Task<DataTable> HotspotAndAcceptTypeStatisticsExport(HotspotAndAcceptTypeStatisticsReq dto)
-	{
-		dto.EndTime = dto.EndTime.AddDays(1).AddSeconds(-1);
-		var dicList = _systemDicDataRepository.Queryable().Where(x => x.DicTypeCode == "AcceptType").OrderBy(x => x.Sort).MergeTable();
-		var endIndex = (2 * dto.HotspotLevel).ToString();
-		var hotspotList = _hotspotRepository.Queryable().Where(x => SqlFunc.Length(x.Id) == int.Parse(endIndex))
-			.Select(x => new
-			{
-				HotspotId = x.Id,
-				HotspotName = x.HotSpotFullName,
-			}).MergeTable();
+        var orderList = _orderRepository.Queryable().Where(x => x.CreationTime >= dto.StartTime && x.CreationTime < dto.EndTime)
+            .Select(x => new
+            {
+                HotspotId = x.HotspotId.Substring(0, int.Parse(endIndex)),
+                AcceptTypeCode = x.AcceptTypeCode,
+            }).MergeTable();
 
-		var orderList = _orderRepository.Queryable().Where(x => x.CreationTime >= dto.StartTime && x.CreationTime < dto.EndTime)
-			.Select(x => new
-			{
-				HotspotId = x.HotspotId.Substring(0, int.Parse(endIndex)),
-				AcceptTypeCode = x.AcceptTypeCode,
-			}).MergeTable();
-
-		var hotListAndOrder = hotspotList.LeftJoin(orderList, (it, o) => it.HotspotId == o.HotspotId)
-			 .GroupBy((it, o) => new
-			 {
-				 it.HotspotId,
-				 it.HotspotName,
-				 AcceptTypeCode = o.AcceptTypeCode,
-			 })
-			 .OrderBy((it, o) => it.HotspotId)
-			 .Select((it, o) => new
-			 {
-				 HotspotId = it.HotspotId,
-				 HotspotName = it.HotspotName,
-				 AcceptTypeCode = o.AcceptTypeCode,
-				 Count = SqlFunc.AggregateCount(it.HotspotId)
-			 }).MergeTable();
-
-
-		var returnList = await dicList.LeftJoin(hotListAndOrder, (pp, dd) => pp.DicDataValue == dd.AcceptTypeCode)
-		   .GroupBy((pp, dd) => new
-		   {
-			   HotspotId = dd.HotspotId,
-			   HotspotName = dd.HotspotName,
-			   AcceptTypeCode = pp.DicDataValue,
-			   AcceptType = pp.DicDataName,
-		   })
-		   .OrderBy((pp, dd) => dd.HotspotId)
-		   .Select((pp, dd) => new
-		   {
-			   HotspotId = dd.HotspotId,
-			   HotspotName = dd.HotspotName,
-			   AcceptTypeCode = pp.DicDataValue,
-			   AcceptType = pp.DicDataName,
-			   Count = SqlFunc.AggregateSum(dd.Count)
-		   }).ToPivotTableAsync(q => q.AcceptTypeCode, q => new { q.HotspotName }, q => q.Sum(x => x.Count));
-		//returnList.Rows.RemoveAt(returnList.Rows.Count-1);
-		return returnList;
-	}
+        var hotListAndOrder = hotspotList.LeftJoin(orderList, (it, o) => it.HotspotId == o.HotspotId)
+             .GroupBy((it, o) => new
+             {
+                 it.HotspotId,
+                 it.HotspotName,
+                 AcceptTypeCode = o.AcceptTypeCode,
+             })
+             .OrderBy((it, o) => it.HotspotId)
+             .Select((it, o) => new
+             {
+                 HotspotId = it.HotspotId,
+                 HotspotName = it.HotspotName,
+                 AcceptTypeCode = o.AcceptTypeCode,
+                 Count = SqlFunc.AggregateCount(it.HotspotId)
+             }).MergeTable();
 
-	/// <summary>
-	/// 热点受理类型统计明细
-	/// </summary>
-	/// <param name="dto"></param>
-	/// <returns></returns>
-	public ISugarQueryable<Order> HotspotAndAcceptTypeStatisticsDetail(HotspotAndAcceptTypeStatisticsDetailReq dto)
-	{
-		dto.EndTime = dto.EndTime.AddDays(1).AddSeconds(-1);
-		var query = _orderRepository.Queryable()
-			.Where(x => x.HotspotId.StartsWith(dto.HotspotId) && x.CreationTime >= dto.StartTime && x.CreationTime < dto.EndTime)
-			.WhereIF(!string.IsNullOrEmpty(dto.AcceptTypeCode), x => x.AcceptTypeCode.StartsWith(dto.AcceptTypeCode))
+        var returnList = await dicList.LeftJoin(hotListAndOrder, (pp, dd) => pp.DicDataValue == dd.AcceptTypeCode)
+           .GroupBy((pp, dd) => new
+           {
+               HotspotId = dd.HotspotId,
+               HotspotName = dd.HotspotName,
+               AcceptTypeCode = pp.DicDataValue,
+               AcceptType = pp.DicDataName,
+           })
+           .OrderBy((pp, dd) => dd.HotspotId)
+           .Select((pp, dd) => new
+           {
+               HotspotId = dd.HotspotId,
+               HotspotName = dd.HotspotName,
+               AcceptTypeCode = pp.DicDataValue,
+               AcceptType = pp.DicDataName,
+               Count = SqlFunc.AggregateSum(dd.Count)
+           }).ToPivotListAsync(q => q.AcceptTypeCode, q => new { q.HotspotName, q.HotspotId }, q => q.Sum(x => x.Count));
+
+        var titleList = await _systemDicDataRepository.Queryable().Where(x => x.DicTypeCode == "AcceptType").OrderBy(x => x.Sort).ToListAsync();
+        return (titleList, returnList);
+    }
+
+    /// <summary>
+    /// 热点受理类型统计--导出
+    /// </summary>
+    /// <param name="dto"></param>
+    /// <returns></returns>
+    public async Task<DataTable> HotspotAndAcceptTypeStatisticsExport(HotspotAndAcceptTypeStatisticsReq dto)
+    {
+        dto.EndTime = dto.EndTime.AddDays(1).AddSeconds(-1);
+        var dicList = _systemDicDataRepository.Queryable().Where(x => x.DicTypeCode == "AcceptType").OrderBy(x => x.Sort).MergeTable();
+        var endIndex = (2 * dto.HotspotLevel).ToString();
+        var hotspotList = _hotspotRepository.Queryable().Where(x => SqlFunc.Length(x.Id) == int.Parse(endIndex))
+            .Select(x => new
+            {
+                HotspotId = x.Id,
+                HotspotName = x.HotSpotFullName,
+            }).MergeTable();
+
+        var orderList = _orderRepository.Queryable().Where(x => x.CreationTime >= dto.StartTime && x.CreationTime < dto.EndTime)
+            .Select(x => new
+            {
+                HotspotId = x.HotspotId.Substring(0, int.Parse(endIndex)),
+                AcceptTypeCode = x.AcceptTypeCode,
+            }).MergeTable();
+
+        var hotListAndOrder = hotspotList.LeftJoin(orderList, (it, o) => it.HotspotId == o.HotspotId)
+             .GroupBy((it, o) => new
+             {
+                 it.HotspotId,
+                 it.HotspotName,
+                 AcceptTypeCode = o.AcceptTypeCode,
+             })
+             .OrderBy((it, o) => it.HotspotId)
+             .Select((it, o) => new
+             {
+                 HotspotId = it.HotspotId,
+                 HotspotName = it.HotspotName,
+                 AcceptTypeCode = o.AcceptTypeCode,
+                 Count = SqlFunc.AggregateCount(it.HotspotId)
+             }).MergeTable();
+
+
+        var returnList = await dicList.LeftJoin(hotListAndOrder, (pp, dd) => pp.DicDataValue == dd.AcceptTypeCode)
+           .GroupBy((pp, dd) => new
+           {
+               HotspotId = dd.HotspotId,
+               HotspotName = dd.HotspotName,
+               AcceptTypeCode = pp.DicDataValue,
+               AcceptType = pp.DicDataName,
+           })
+           .OrderBy((pp, dd) => dd.HotspotId)
+           .Select((pp, dd) => new
+           {
+               HotspotId = dd.HotspotId,
+               HotspotName = dd.HotspotName,
+               AcceptTypeCode = pp.DicDataValue,
+               AcceptType = pp.DicDataName,
+               Count = SqlFunc.AggregateSum(dd.Count)
+           }).ToPivotTableAsync(q => q.AcceptTypeCode, q => new { q.HotspotName }, q => q.Sum(x => x.Count));
+        //returnList.Rows.RemoveAt(returnList.Rows.Count-1);
+        return returnList;
+    }
+
+    /// <summary>
+    /// 热点受理类型统计明细
+    /// </summary>
+    /// <param name="dto"></param>
+    /// <returns></returns>
+    public ISugarQueryable<Order> HotspotAndAcceptTypeStatisticsDetail(HotspotAndAcceptTypeStatisticsDetailReq dto)
+    {
+        dto.EndTime = dto.EndTime.AddDays(1).AddSeconds(-1);
+        var query = _orderRepository.Queryable()
+            .Where(x => x.HotspotId.StartsWith(dto.HotspotId) && x.CreationTime >= dto.StartTime && x.CreationTime < dto.EndTime)
+            .WhereIF(!string.IsNullOrEmpty(dto.AcceptTypeCode), x => x.AcceptTypeCode.StartsWith(dto.AcceptTypeCode))
             .OrderByDescending(x => x.CreationTime);
-		return query;
-	}
+        return query;
+    }
 
     /// <summary>
     /// 甄别申请统计
@@ -1701,15 +1827,84 @@ public class OrderApplication : IOrderApplication, IScopeDependency
 	    return query;
     }
 
+    /// <summary>
+    /// 中心受理统计（日期）
+    /// </summary>
+    /// <param name="dto"></param>
+    /// <returns></returns>
+    public ISugarQueryable<OrderCenterAcceptVo> OrderCenterAccept(OrderCenterAcceptPagedRequest dto)
+    {
+	    if (dto.EndTime.HasValue)
+		    dto.EndTime = dto.EndTime.Value.AddDays(1).AddSeconds(-1);
+        var sendBack = _orderSendBackAuditRepository.Queryable()
+            .Where(x => x.State == ESendBackAuditState.End)
+            .GroupBy(x => x.OrderId).Select(x => new { OrderId = x.OrderId } );
+
+		var query = _orderRepository.Queryable()
+            .LeftJoin(sendBack,(d,s)=> d.Id == s.OrderId)
+            .WhereIF(dto.StartTime.HasValue && dto.EndTime.HasValue, d => d.CreationTime >= dto.StartTime && d.CreationTime <= dto.EndTime)
+            .WhereIF(dto.TypeCode != null && dto.TypeCode == 1, d => d.IdentityType == EIdentityType.Citizen)
+            .WhereIF(dto.TypeCode != null && dto.TypeCode == 2, d => d.IdentityType == EIdentityType.Enterprise)
+            .GroupBy(d => d.CreationTime.ToString("yyyy-MM-dd"))
+            .Select((d,s) => new OrderCenterAcceptVo
+            {
+                Time = d.CreationTime.ToString("yyyy-MM-dd"),
+                AcceptNum = SqlFunc.AggregateCount(1),
+                ValidNum  = SqlFunc.AggregateSum(SqlFunc.IIF( d.AcceptType != "无效" , 1, 0)),
+                RepetitionNum = SqlFunc.AggregateSum(SqlFunc.IIF(d.DuplicateIds == null || SqlFunc.JsonArrayLength(d.DuplicateIds) > 0, 1, 0)),
+                InvalidNum = SqlFunc.AggregateSum(SqlFunc.IIF(d.AcceptType == "无效", 1, 0)),
+                HandleNum = SqlFunc.AggregateSum(SqlFunc.IIF(d.Status >= EOrderStatus.Filed, 1, 0)),
+                NoHandleNum = SqlFunc.AggregateSum(SqlFunc.IIF(d.Status < EOrderStatus.Filed, 1, 0)),
+                BackNum = SqlFunc.AggregateSum(SqlFunc.IIF(!string.IsNullOrEmpty(s.OrderId), 1, 0)),
+                DutyDeskNum = SqlFunc.AggregateDistinctCount(d.AcceptorId)
+			});
+		return query;
+    }
+
+    /// <summary>
+    /// 中心受理统计（值班坐席）
+    /// </summary>
+    /// <returns></returns>
+    public ISugarQueryable<OrderCenterAcceptUserVo> OrderCenterAcceptUser(OrderCenterAcceptPagedRequest dto)
+    {
+	    if (dto.EndTime.HasValue)
+		    dto.EndTime = dto.EndTime.Value.AddDays(1).AddSeconds(-1);
+	    var sendBack = _orderSendBackAuditRepository.Queryable()
+		    .Where(x => x.State == ESendBackAuditState.End)
+		    .GroupBy(x => x.OrderId).Select(x => new { OrderId = x.OrderId });
+
+	    var query = _orderRepository.Queryable()
+		    .LeftJoin(sendBack, (d, s) => d.Id == s.OrderId)
+		    .WhereIF(dto.StartTime.HasValue && dto.EndTime.HasValue, d => d.CreationTime >= dto.StartTime && d.CreationTime <= dto.EndTime)
+		    .WhereIF(dto.TypeCode != null && dto.TypeCode == 1, d => d.IdentityType == EIdentityType.Citizen)
+		    .WhereIF(dto.TypeCode != null && dto.TypeCode == 2, d => d.IdentityType == EIdentityType.Enterprise)
+		    .GroupBy(d => d.AcceptorName)
+		    .Select((d, s) => new OrderCenterAcceptUserVo
+			{
+			    AcceptUserName = d.AcceptorName,
+			    AcceptNum = SqlFunc.AggregateCount(1),
+			    ValidNum = SqlFunc.AggregateSum(SqlFunc.IIF(d.AcceptType != "无效", 1, 0)),
+			    RepetitionNum = SqlFunc.AggregateSum(SqlFunc.IIF(d.DuplicateIds == null || SqlFunc.JsonArrayLength(d.DuplicateIds) > 0, 1, 0)),
+			    InvalidNum = SqlFunc.AggregateSum(SqlFunc.IIF(d.AcceptType == "无效", 1, 0)),
+			    HandleNum = SqlFunc.AggregateSum(SqlFunc.IIF(d.Status >= EOrderStatus.Filed, 1, 0)),
+			    NoHandleNum = SqlFunc.AggregateSum(SqlFunc.IIF(d.Status < EOrderStatus.Filed, 1, 0)),
+			    BackNum = SqlFunc.AggregateSum(SqlFunc.IIF(!string.IsNullOrEmpty(s.OrderId), 1, 0))
+		    });
+	    return query;
+    }
+
+
+
+
 	#region private
 
-	/// <summary>
-	/// 接受外部工单（除省平台）
-	/// </summary>
-	/// <param name="dto"></param>
-	/// <param name="cancellationToken"></param>
-	/// <returns></returns>
-	private async Task<AddOrderResponse> ReceiveOrderFromOtherPlatformAsync(AddOrderDto dto, List<FileDto> files,
+    /// <summary>
+    /// 接受外部工单（除省平台）
+    /// </summary>
+    /// <param name="dto"></param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
+    private async Task<AddOrderResponse> ReceiveOrderFromOtherPlatformAsync(AddOrderDto dto, List<FileDto> files,
         ISessionContext current, CancellationToken cancellationToken)
     {
         if (string.IsNullOrEmpty(dto.ExternalId))
@@ -1801,65 +1996,66 @@ public class OrderApplication : IOrderApplication, IScopeDependency
     /// <returns></returns>
     public async Task<List<SendOrderReportOutDto>> SendOrderReportAsync(QuerySendOrderRequest dto)
     {
-            var items = await _workflowTraceRepository.Queryable()
-                .LeftJoin<Workflow>((x, w) => x.WorkflowId == w.Id)
-                //.LeftJoin<WorkflowStepHandler>((x, w, wsh) => x.StepId == wsh.WorkflowStepId && wsh.IsActualHandler == true)
-                .InnerJoin<SchedulingUser>((x, w, su) => x.HandlerId == su.UserId)
-                .Where((x, w, su) => w.ModuleCode == "OrderHandle" && x.BusinessType == EBusinessType.Send && x.Status == EWorkflowStepStatus.Handled)
-                .Where((x, w, su) => x.CreationTime >= dto.StartTime.Value)
-                .Where((x, w, su) => x.CreationTime <= dto.EndTime.Value)
-                .WhereIF(!string.IsNullOrEmpty(dto.UserName), (x, w, su) => su.UserName == dto.UserName)
-                .GroupBy((x, w, su) => new { su.UserId, su.UserName })
-                //.Having((x, w, wsh, su) => SqlFunc.AggregateCount(x.WorkflowId) == 1)
-                .Select((x, w, su) => new BiOrderSendVo
-                {
-                    UserId = su.UserId,
-                    UserName = su.UserName,
-                    SendOrderNum = SqlFunc.AggregateDistinctCount(w.ExternalId),
-                    NoSendOrderNum = SqlFunc.AggregateSum(SqlFunc.IIF(x.HandlerId == null || x.HandlerId == "", 1, 0)),
-                }).ToListAsync();
-
-            var items2 = await _workflowTraceRepository.Queryable()
-                .LeftJoin<Workflow>((x, w) => x.WorkflowId == w.Id)
-                //.LeftJoin<WorkflowStepHandler>((x, w, wfsh) => x.StepId == wfsh.WorkflowStepId && wfsh.IsActualHandler == true)
-                .InnerJoin<SchedulingUser>((x, w, su) => x.HandlerId == su.UserId)
-                .Where((x, w, su) => w.ModuleCode == "OrderHandle" && x.BusinessType == EBusinessType.Send && x.Status == EWorkflowStepStatus.Handled)
-                .Where((x, w, su) => x.CreationTime >= dto.StartTime.Value)
-                .Where((x, w, su) => x.CreationTime <= dto.EndTime.Value)
-                .GroupBy((x, w, su) => x.WorkflowId)
-                .Having((x, w, su) => SqlFunc.AggregateCount(x.WorkflowId) > 1)
-                .Select((x, w, su) => new { Id = x.WorkflowId, CreationTime = SqlFunc.AggregateMin(x.CreationTime) })
-                .MergeTable()
-                .LeftJoin<WorkflowTrace>((a, wt) => a.Id == wt.WorkflowId)
-                .LeftJoin<Workflow>((a, wt, wf) => wt.WorkflowId == wf.Id)
-                //.LeftJoin<WorkflowStepHandler>((a, wt, wf, wsh) => wt.StepId == wsh.WorkflowStepId && wsh.CreationTime == a.CreationTime)
-                .InnerJoin<SchedulingUser>((a, wt, wf, su) => wt.HandlerId == su.UserId)
-                .WhereIF(!string.IsNullOrEmpty(dto.UserName), ((a, wt, wf, su) => su.UserName == dto.UserName))
-                .GroupBy((a, wt, wf, su) => new { su.UserId, su.UserName })
-                .Select((a, wt, wf, su) => new BiOrderSendVo
-                {
-                    UserId = su.UserId,
-                    UserName = su.UserName,
-                    SendOrderNum = 0,
-                    NoSendOrderNum = 0,
-                    ReSendOrderNum = SqlFunc.AggregateDistinctCount(wf.ExternalId),
-                }).ToListAsync();
-
-            var res = (from t1 in items
-                       join t2 in items2 on t1.UserId equals t2.UserId into t1_t2
-                       from item in t1_t2.DefaultIfEmpty()
-                       select new SendOrderReportOutDto
-                       {
-                           UserId = t1.UserId,
-                           UserName = t1.UserName,
-                           SendOrderNum = t1.SendOrderNum,
-                           NoSendOrderNum = t1.NoSendOrderNum,
-                           ReSendOrderNum = t1_t2.Select(x => x.ReSendOrderNum).FirstOrDefault(),
-                           ChainRate = t1_t2.Select(x => x.ReSendOrderNum).FirstOrDefault() > 0 ?
-                                     ((double.Parse(t1.SendOrderNum.ToString()) - double.Parse(t1_t2.Select(x => x.ReSendOrderNum).FirstOrDefault().ToString())) / double.Parse(t1.SendOrderNum.ToString()) * 100).ToString("F2") + "%" : "100.00%",
-                       }).ToList();
+        var items = await _workflowTraceRepository.Queryable()
+            .LeftJoin<Workflow>((x, w) => x.WorkflowId == w.Id)
+            //.LeftJoin<WorkflowStepHandler>((x, w, wsh) => x.StepId == wsh.WorkflowStepId && wsh.IsActualHandler == true)
+            .InnerJoin<SchedulingUser>((x, w, su) => x.HandlerId == su.UserId)
+            .Where((x, w, su) => w.ModuleCode == "OrderHandle" && x.BusinessType == EBusinessType.Send && x.Status == EWorkflowStepStatus.Handled)
+            .Where((x, w, su) => x.CreationTime >= dto.StartTime.Value)
+            .Where((x, w, su) => x.CreationTime <= dto.EndTime.Value)
+            .WhereIF(!string.IsNullOrEmpty(dto.UserName), (x, w, su) => su.UserName == dto.UserName)
+            .GroupBy((x, w, su) => new { su.UserId, su.UserName })
+            //.Having((x, w, wsh, su) => SqlFunc.AggregateCount(x.WorkflowId) == 1)
+            .Select((x, w, su) => new BiOrderSendVo
+            {
+                UserId = su.UserId,
+                UserName = su.UserName,
+                SendOrderNum = SqlFunc.AggregateDistinctCount(w.ExternalId),
+                NoSendOrderNum = SqlFunc.AggregateSum(SqlFunc.IIF(x.HandlerId == null || x.HandlerId == "", 1, 0)),
+            }).ToListAsync();
+
+        var items2 = await _workflowTraceRepository.Queryable()
+            .LeftJoin<Workflow>((x, w) => x.WorkflowId == w.Id)
+            //.LeftJoin<WorkflowStepHandler>((x, w, wfsh) => x.StepId == wfsh.WorkflowStepId && wfsh.IsActualHandler == true)
+            .InnerJoin<SchedulingUser>((x, w, su) => x.HandlerId == su.UserId)
+            .Where((x, w, su) => w.ModuleCode == "OrderHandle" && x.BusinessType == EBusinessType.Send && x.Status == EWorkflowStepStatus.Handled)
+            .Where((x, w, su) => x.CreationTime >= dto.StartTime.Value)
+            .Where((x, w, su) => x.CreationTime <= dto.EndTime.Value)
+            .GroupBy((x, w, su) => x.WorkflowId)
+            .Having((x, w, su) => SqlFunc.AggregateCount(x.WorkflowId) > 1)
+            .Select((x, w, su) => new { Id = x.WorkflowId, CreationTime = SqlFunc.AggregateMin(x.CreationTime) })
+            .MergeTable()
+            .LeftJoin<WorkflowTrace>((a, wt) => a.Id == wt.WorkflowId)
+            .LeftJoin<Workflow>((a, wt, wf) => wt.WorkflowId == wf.Id)
+            //.LeftJoin<WorkflowStepHandler>((a, wt, wf, wsh) => wt.StepId == wsh.WorkflowStepId && wsh.CreationTime == a.CreationTime)
+            .InnerJoin<SchedulingUser>((a, wt, wf, su) => wt.HandlerId == su.UserId)
+            .WhereIF(!string.IsNullOrEmpty(dto.UserName), ((a, wt, wf, su) => su.UserName == dto.UserName))
+            .GroupBy((a, wt, wf, su) => new { su.UserId, su.UserName })
+            .Select((a, wt, wf, su) => new BiOrderSendVo
+            {
+                UserId = su.UserId,
+                UserName = su.UserName,
+                SendOrderNum = 0,
+                NoSendOrderNum = 0,
+                ReSendOrderNum = SqlFunc.AggregateDistinctCount(wf.ExternalId),
+            }).ToListAsync();
+
+        var res = (from t1 in items
+                   join t2 in items2 on t1.UserId equals t2.UserId into t1_t2
+                   from item in t1_t2.DefaultIfEmpty()
+                   select new SendOrderReportOutDto
+                   {
+                       UserId = t1.UserId,
+                       UserName = t1.UserName,
+                       SendOrderNum = t1.SendOrderNum,
+                       NoSendOrderNum = t1.NoSendOrderNum,
+                       ReSendOrderNum = t1_t2.Select(x => x.ReSendOrderNum).FirstOrDefault(),
+                       ChainRate = t1_t2.Select(x => x.ReSendOrderNum).FirstOrDefault() > 0 ?
+                                 ((double.Parse(t1.SendOrderNum.ToString()) - double.Parse(t1_t2.Select(x => x.ReSendOrderNum).FirstOrDefault().ToString())) / double.Parse(t1.SendOrderNum.ToString()) * 100).ToString("F2") + "%" : "100.00%",
+                   }).ToList();
         return res;
     }
 
+
     #endregion
 }

src/Hotline.Repository.SqlSugar/Orders/OrderRepository.cs

@@ -5,6 +5,7 @@ using Hotline.Repository.SqlSugar.Extensions;
 using Hotline.Settings;
 using Hotline.Settings.Hotspots;
 using Hotline.Share.Dtos.CallCenter;
+using Hotline.Share.Dtos.Order;
 using Hotline.Share.Enums.CallCenter;
 using Hotline.Share.Enums.Order;
 using Hotline.Share.Requests;
@@ -18,19 +19,24 @@ using System.Reflection;
 using System.Reflection.Emit;
 using XF.Domain.Authentications;
 using XF.Domain.Dependency;
+using XF.Domain.Repository;
 
 namespace Hotline.Repository.SqlSugar.Orders
 {
     public class OrderRepository : BaseRepositoryWorkflow<Order>, IOrderRepository, IScopeDependency
     {
         private readonly IDataPermissionFilterBuilder _dataPermissionFilterBuilder;
+        private readonly IRepository<OrderSendBackAudit> _orderSendBackAuditRepository;
 
-        public OrderRepository(ISugarUnitOfWork<HotlineDbContext> uow,
-            IDataPermissionFilterBuilder dataPermissionFilterBuilder
-            ) : base(uow, dataPermissionFilterBuilder)
+		public OrderRepository(ISugarUnitOfWork<HotlineDbContext> uow,
+            IDataPermissionFilterBuilder dataPermissionFilterBuilder,
+            IRepository<OrderSendBackAudit> orderSendBackAuditRepository
+			) : base(uow, dataPermissionFilterBuilder)
         {
             _dataPermissionFilterBuilder = dataPermissionFilterBuilder;
-        }
+            _orderSendBackAuditRepository = orderSendBackAuditRepository;
+
+		}
 
         public async Task<string> AddOrderNavAsync(Order order, CancellationToken cancellationToken)
         {
@@ -1045,7 +1051,58 @@ namespace Hotline.Repository.SqlSugar.Orders
             return dt2;
         }
 
-        public ISugarQueryable<SelectOrderId> OrderListUnionAll(ISugarQueryable<SelectOrderId> t1, ISugarQueryable<SelectOrderId> t2)
+        /// <summary>
+        /// 中心受理统计（时间段）
+        /// </summary>
+        /// <returns></returns>
+        public ISugarQueryable<OrderCenterAcceptHourVo> OrderCenterAcceptHour(OrderCenterAcceptPagedRequest dto)
+        {
+	        if (dto.EndTime.HasValue)
+		        dto.EndTime = dto.EndTime.Value.AddDays(1).AddSeconds(-1);
+	        var sendBack = _orderSendBackAuditRepository.Queryable()
+		        .Where(x => x.State == ESendBackAuditState.End)
+		        .GroupBy(x => x.OrderId).Select(x => new { OrderId = x.OrderId });
+
+	        List<int> dts = new();
+	        for (int i = 0; i < 24; i++)
+	        {
+		        dts.Add(i);
+	        }
+
+	        var listHour = Db.Reportable(dts).ToQueryable<int>();
+
+	        var data = Db.Queryable<Order>()
+				.LeftJoin(sendBack, (d, s) => d.Id == s.OrderId)
+		        .WhereIF(dto.StartTime.HasValue && dto.EndTime.HasValue, d => d.CreationTime >= dto.StartTime && d.CreationTime <= dto.EndTime)
+		        .WhereIF(dto.TypeCode != null && dto.TypeCode == 1, d => d.IdentityType == EIdentityType.Citizen)
+		        .WhereIF(dto.TypeCode != null && dto.TypeCode == 2, d => d.IdentityType == EIdentityType.Enterprise)
+		        .GroupBy(d => d.AcceptorName)
+		        .Select((d, s) => new OrderCenterAcceptHourVo
+				{
+			        Hour = d.CreationTime.Hour.ToString(),
+			        AcceptNum = SqlFunc.AggregateCount(1),
+			        ValidNum = SqlFunc.AggregateSum(SqlFunc.IIF(d.AcceptType != "无效", 1, 0)),
+			        RepetitionNum = SqlFunc.AggregateSum(SqlFunc.IIF(d.DuplicateIds == null || SqlFunc.JsonArrayLength(d.DuplicateIds) > 0, 1, 0)),
+			        InvalidNum = SqlFunc.AggregateSum(SqlFunc.IIF(d.AcceptType == "无效", 1, 0)),
+			        HandleNum = SqlFunc.AggregateSum(SqlFunc.IIF(d.Status >= EOrderStatus.Filed, 1, 0)),
+			        NoHandleNum = SqlFunc.AggregateSum(SqlFunc.IIF(d.Status < EOrderStatus.Filed, 1, 0)),
+			        BackNum = SqlFunc.AggregateSum(SqlFunc.IIF(!string.IsNullOrEmpty(s.OrderId), 1, 0))
+		        });
+            var query = listHour.LeftJoin(data, (h, d) => h.ColumnName.ToString() == d.Hour)
+                 .Select((h, d) => new OrderCenterAcceptHourVo
+                 {
+                     Hour = h.ColumnName + ":00 - " + h.ColumnName + ":59",
+                     AcceptNum = d.AcceptNum,
+                     ValidNum = d.ValidNum,
+                     RepetitionNum = d.RepetitionNum,
+                     InvalidNum = d.InvalidNum,
+                     HandleNum = d.HandleNum,
+                     NoHandleNum = d.NoHandleNum,
+                     BackNum = d.BackNum
+                 });
+			return query;
+        }
+		public ISugarQueryable<SelectOrderId> OrderListUnionAll(ISugarQueryable<SelectOrderId> t1, ISugarQueryable<SelectOrderId> t2)
         {
             return Db.UnionAll(t1, t2).Select(it => new SelectOrderId { Id = it.Id }).MergeTable();
         }

src/Hotline.Share/Dtos/Order/OrderBiDto.cs

@@ -1219,4 +1219,71 @@ namespace Hotline.Share.Dtos.Order
 		/// </summary>
 		public int Total => AuditNum + AuditBackNum;
 	}
+
+	public class OrderCenterAcceptVo: OrderCenterBaseVo
+	{
+		/// <summary>
+		/// 日期
+		/// </summary>
+		public string Time { get; set; }
+	}
+
+	public class OrderCenterAcceptUserVo : OrderCenterBaseVo
+	{
+		/// <summary>
+		/// 值班坐席
+		/// </summary>
+		public string AcceptUserName { get; set; }
+	}
+
+	public class OrderCenterAcceptHourVo : OrderCenterBaseVo
+	{
+		/// <summary>
+		/// 时间段
+		/// </summary>
+		public string Hour { get; set; }
+	}
+
+	public class OrderCenterBaseVo
+	{
+		/// <summary>
+		/// 受理总件
+		/// </summary>
+		public int AcceptNum { get; set; }
+
+		/// <summary>
+		/// 有效件
+		/// </summary>
+		public int ValidNum { get; set; }
+
+		/// <summary>
+		/// 重复件
+		/// </summary>
+		public int RepetitionNum { get; set; }
+
+		/// <summary>
+		/// 无效件
+		/// </summary>
+		public int InvalidNum { get; set; }
+
+		/// <summary>
+		/// 已办件
+		/// </summary>
+		public int HandleNum { get; set; }
+
+		/// <summary>
+		/// 待办件
+		/// </summary>
+		public int NoHandleNum { get; set; }
+
+		/// <summary>
+		/// 退回件
+		/// </summary>
+		public int BackNum { get; set; }
+
+		/// <summary>
+		/// 值班坐席
+		/// </summary>
+		public int DutyDeskNum { get; set; }
+	}
 }

src/Hotline.Share/Dtos/Order/OrderVisitDto.cs

@@ -61,7 +61,7 @@ namespace Hotline.Share.Dtos.Order
         public bool? IsEffectiveAiVisit { get; set; }
     }
 
-    public class QueryOrderVisitSourceChannelDto
+    public record QueryOrderPublishStatisticsAllDto : PagedRequest
     { 
         /// <summary>
         /// 开始时间
@@ -72,14 +72,45 @@ namespace Hotline.Share.Dtos.Order
         /// <summary>
         /// 结束时间
         /// </summary>
-        public DateTime? EndTime { get; set; }
+        [Required]
+        public DateTime EndTime { get; set; }
+    }
+
+    public record QueryOrderPublishStatisticsDto : PagedRequest
+    { 
+        /// <summary>
+        /// 开始时间
+        /// </summary>
+        [Required]
+        public DateTime StartTime { get; set; }
+
+        /// <summary>
+        /// 结束时间
+        /// </summary>
+        [Required]
+        public DateTime EndTime { get; set; }
 
         /// <summary>
-        /// 非时间段统计 EndTime 可以不传;0=按日统计, 1=按周统计, 2=按月统计, 3=按时间段统计;
+        /// 归档方式; 10 = 中心归档, 20 = 部门归档;
+        /// 不传查询全部
+        /// </summary>
+        public EProcessType? ProcessType { get; set; }
+    }
+
+
+    public record QueryOrderVisitSourceChannelDto 
+    { 
+        /// <summary>
+        /// 开始时间
+        /// </summary>
+        [Required]
+        public DateTime StartTime { get; set; }
+
+        /// <summary>
+        /// 结束时间
         /// </summary>
         [Required]
-        [Range(0, 3, ErrorMessage = "统计时间类型必须在0-3之间")]
-        public EDateType DateType { get; set; }
+        public DateTime EndTime { get; set; }
     }
 
     public record VisitJudgeQueryReq : PagedKeywordRequest

src/Hotline.Share/Dtos/Order/PublishedDto.cs

@@ -36,6 +36,62 @@ public class PublishedDto
 	public DateTime? LastModificationTime { get; set; }
 }
 
+public class PublishedOrderStatisticsDto
+{ 
+    /// <summary>
+    /// 待发布量
+    /// </summary>
+    public int WaitCount { get; set; }
+
+    /// <summary>
+    /// 公开发布量
+    /// </summary>
+    public int PublicCount { get; set; }
+
+    /// <summary>
+    /// 不公开发布量
+    /// </summary>
+    public int PrivateCount { get; set; }
+
+    /// <summary>
+    /// 总量
+    /// </summary>
+    public int TotalCount { get; set; }
+
+    /// <summary>
+    /// 名字
+    /// </summary>
+    public string Name { get; set; }
+
+    /// <summary>
+    /// 发布时间
+    /// </summary>
+    public DateTime PublishTime { get; set; }
+}
+
+public class QueryPublishedOrderDataDto
+{ 
+    /// <summary>
+    /// 发布人名称
+    /// </summary>
+    public string Name { get; set; }
+
+    /// <summary>
+    /// 发布人ID
+    /// </summary>
+    public string Id { get; set; }
+
+    /// <summary>
+    /// 数量
+    /// </summary>
+    public int Count { get; set; }
+
+    /// <summary>
+    /// 发布时间
+    /// </summary>
+    public DateTime CreationTime { get; set; }
+}
+
 public class PublishDto : OrderDto
 {
     /// <summary>

src/Hotline.Share/Enums/Order/EProcessType.cs

@@ -7,11 +7,13 @@ public enum EProcessType
 {
     /// <summary>
     /// 直接办结
+    /// 中心
     /// </summary>
     Zhiban = 10,
 
     /// <summary>
     /// 交办
+    /// 部门
     /// </summary>
     Jiaoban = 20,
 }

src/Hotline.Share/Requests/PagedKeywordRequest.cs

@@ -742,3 +742,12 @@ public record OrderScreenAuditPagedRequest : PagedKeywordRequest
 	public int? AuditType { get; set; }
 
 }
+
+public record OrderCenterAcceptPagedRequest : PagedKeywordRequest
+{
+	/// <summary>
+	/// 来电/信人身份0：全部 ，1：市民，2：企业
+	/// </summary>
+	public int? TypeCode { get; set; }
+
+}

src/Hotline/Orders/IOrderRepository.cs

@@ -2,6 +2,7 @@
 using Hotline.Share.Requests;
 using SqlSugar;
 using System.Data;
+using Hotline.Share.Dtos.Order;
 using XF.Domain.Repository;
 
 namespace Hotline.Orders
@@ -142,7 +143,14 @@ namespace Hotline.Orders
         /// <param name="dto"></param>
         /// <returns></returns>
         ISugarQueryable<HotspotAndAreaStatisticsDetailDto> AcceptTypeStatisticsByDateDetail(AcceptTypeStatisticsByDateDetailReq dto);
-    }
+
+        /// <summary>
+        /// 中心受理统计（时间段）
+        /// </summary>
+        /// <returns></returns>
+		ISugarQueryable<OrderCenterAcceptHourVo> OrderCenterAcceptHour(OrderCenterAcceptPagedRequest dto);
+
+	}
 
     public interface IOrderScreenRepository : IRepositoryWorkflow<OrderScreen>
     {

src/Hotline/Tools/DateTimeExtensions.cs

@@ -1,47 +0,0 @@
-
-namespace Hotline.Tools;
-public static class DateTimeExtensions
-{
-    /// <summary>
-    /// 获取指定日期所在周的开始时间和结束时间
-    /// </summary>
-    /// <param name="date"></param>
-    /// <returns></returns>
-    public static (DateTime, DateTime) GetWeekStartAndEnd(this DateTime date)
-    {
-        int diff = date.DayOfWeek - DayOfWeek.Monday;
-        if (diff < 0)
-        {
-            diff += 7;
-        }
-
-        var weekStart = date.AddDays(-1 * diff).Date;
-        var weekEnd = weekStart.AddDays(7).AddTicks(-1);
-
-        return (weekStart, weekEnd);
-    }
-
-    /// <summary>
-    /// 获取指定日期所在天的开始时间和结束时间
-    /// </summary>
-    /// <param name="date"></param>
-    /// <returns></returns>
-    public static (DateTime, DateTime) GetDayStartAndEnd(this DateTime date)
-    {
-        var dayStart = date.Date; 
-        var dayEnd = dayStart.AddDays(1).AddTicks(-1); 
-        return (dayStart, dayEnd);
-    }
-
-    /// <summary>
-    /// 获取指定日期所在月的开始时间和结束时间
-    /// </summary>
-    /// <param name="date"></param>
-    /// <returns></returns>
-    public static (DateTime, DateTime) GetMonthStartAndEnd(this DateTime date)
-    {
-        var monthStart = new DateTime(date.Year, date.Month, 1);
-        var monthEnd = monthStart.AddMonths(1).AddTicks(-1);
-        return (monthStart, monthEnd);
-    }
-}