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

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Hotline.Identity.Roles;
using Hotline.Orders;
using Hotline.Repository.SqlSugar.DataPermissions;
using Hotline.Repository.SqlSugar.Extensions;
using Hotline.Settings;
using Hotline.Settings.TimeLimits;
using Hotline.Share.Consts;
using Hotline.Share.Dtos.Order;
using Hotline.Share.Enums.Order;
using SqlSugar;
using XF.Domain.Dependency;
using XF.Domain.Exceptions;
using XF.Domain.Repository;

namespace Hotline.Repository.SqlSugar.Orders
{
    public class OrderRepository : BaseRepositoryWorkflow<Order>, IOrderRepository, IScopeDependency
    {
        private readonly IDataPermissionFilterBuilder _dataPermissionFilterBuilder;
        private readonly ITimeLimitDomainService _timeLimitDomainService;

		public OrderRepository(ISugarUnitOfWork<HotlineDbContext> uow,
            IDataPermissionFilterBuilder dataPermissionFilterBuilder,
            ITimeLimitDomainService timeLimitDomainService
			) : base(uow, dataPermissionFilterBuilder)
        {
            _dataPermissionFilterBuilder = dataPermissionFilterBuilder;
            _timeLimitDomainService = timeLimitDomainService;

		}

        public async Task<string> AddOrderNavAsync(Order order, CancellationToken cancellationToken)
        {
            if (order.OrderType == EOrderType.MarketSupervisionBy12315)
            {
                //弥补AddNav方法没有自动指派到创建人
                order.AssignToCreator(_dataPermissionFilterBuilder.DataPermissionManager);

                if (order.AcceptTypeCode == AcceptTypeConst.TouSu)
                {
                    order.OrderComplain.InitDatePermission(_dataPermissionFilterBuilder.DataPermissionManager);
                    await AddNav(order).Include(d => d.OrderComplain).ExecuteCommandAsync();
                }
                else if (order.AcceptTypeCode == AcceptTypeConst.JuBao)
                {
                    order.OrderReport.InitDatePermission(_dataPermissionFilterBuilder.DataPermissionManager);
                    await AddNav(order).Include(d => d.OrderReport).ExecuteCommandAsync();
                }
                else
                {
                    throw UserFriendlyException.SameMessage("12315工单不支持该受理类型");
                }
            }
            else
            {
                await AddAsync(order, cancellationToken);
            }
            return order.Id;
        }

        public async Task UpdateOrderNavAsync(Order order, CancellationToken cancellationToken)
        {
            await UpdateAsync(order, cancellationToken);
            if (order.OrderType == EOrderType.MarketSupervisionBy12315)
            {
                if (order.AcceptTypeCode == AcceptTypeConst.TouSu)
                {
                    await Db.Insertable<OrderComplain>(order.OrderComplain).ExecuteCommandAsync();
                }
                else if (order.AcceptTypeCode == AcceptTypeConst.JuBao)
                {
                    await Db.Insertable<OrderReport>(order.OrderReport).ExecuteCommandAsync();
                }
                else
                {
                    throw UserFriendlyException.SameMessage("12315工单不支持该受理类型");
                }
            }
        }

        public async Task RemoveOrderComplainAsync(OrderComplain orderComplain, CancellationToken cancellationToken)
        {
            await Db.Deleteable(orderComplain).ExecuteCommandAsync();
        }

        public async Task RemoveOrderReportAsync(OrderReport orderReport, CancellationToken cancellationToken)
        {
            await Db.Deleteable(orderReport).ExecuteCommandAsync();
        }

        /// <summary>
        /// 即将超期列表
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="AboutToExpireNum"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task<List<AboutToExpireDto>> GetAboutToExpireAsync(AboutToExpireListDto dto,int AboutToExpireNum, CancellationToken cancellationToken)
        {
            DateTime stTime = _timeLimitDomainService.WorkDay(DateTime.Now);
            var oders = await Db.Queryable<Order>()
                .WhereIF(dto.IsProvince.HasValue, x => x.IsProvince == dto.IsProvince)
                .WhereIF(!string.IsNullOrEmpty(dto.No), x => x.No == dto.No)
                .WhereIF(!string.IsNullOrEmpty(dto.Title), x => x.Title.Contains(dto.Title!))
                .Where(x=> x.ExpiredTime != null && stTime <= x.ExpiredTime.Value)
                .Where(x => x.ExpiredTime != null && (x.ExpiredTime.Value - stTime).TotalHours <= AboutToExpireNum)
                .Where(x=>x.Status== EOrderStatus.Handling || x.Status == EOrderStatus.Countersigning)
                .Select(x => new AboutToExpireDto()
                {
                    IntervalText = _timeLimitDomainService.CalcTimeInterval(stTime, x.ExpiredTime!.Value, false)
                }, true).ToListAsync();
            return oders;
        }

        /// <summary>
        /// 已超期列表
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task<List<AboutToExpireDto>> GetToExpireAsync(AboutToExpireListDto dto, CancellationToken cancellationToken)
        {
	        DateTime stTime = _timeLimitDomainService.WorkDay(DateTime.Now);
	        var oders = await Db.Queryable<Order>()
		        .WhereIF(dto.IsProvince.HasValue, x => x.IsProvince == dto.IsProvince)
		        .WhereIF(!string.IsNullOrEmpty(dto.No), x => x.No == dto.No)
		        .WhereIF(!string.IsNullOrEmpty(dto.Title), x => x.Title.Contains(dto.Title!))
		        .Where(x => x.ExpiredTime != null && stTime > x.ExpiredTime.Value)
				.Where(x => x.Status != EOrderStatus.Handling && x.Status != EOrderStatus.Countersigning)
				.Select(x => new AboutToExpireDto()
		        {
			        IntervalText = _timeLimitDomainService.CalcTimeInterval(stTime, x.ExpiredTime!.Value, false)
		        }, true).ToListAsync();
	        return oders;
        }

        /// <summary>
        /// 工单词库批量删除
        /// </summary>
        /// <param name="ids"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task RemoveOrderWrodBatchAsync(List<string> ids, CancellationToken cancellationToken) { 
           await  Db.Deleteable<OrderWord>().In(x=>x.Id,ids).ExecuteCommandAsync(cancellationToken);
        }


        /// <summary>
        /// 工单观察批量删除
        /// </summary>
        /// <param name="ids"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task RemoveOrderObserveBatchAsync(List<string> ids, CancellationToken cancellationToken)
        {
	        await Db.Deleteable<OrderObserve>().In(x => x.Id, ids).ExecuteCommandAsync(cancellationToken);
        }

	}
}