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

using Hotline.Caching.Interfaces;
using Hotline.FlowEngine.Workflows;
using Hotline.Orders;
using Hotline.Repository.SqlSugar.DataPermissions;
using Hotline.Repository.SqlSugar.Extensions;
using Hotline.Repository.SqlSugar.Ts;
using Hotline.Settings.TimeLimits;
using Hotline.Share.Dtos;
using Hotline.Share.Dtos.FlowEngine.Workflow;
using Hotline.Share.Dtos.Order;
using Hotline.Share.Enums.Order;
using Hotline.Tools;
using MapsterMapper;
using SqlSugar;
using XF.Domain.Constants;
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 ITimeLimitDomainService _timeLimitDomainService;
        private readonly IMapper _mapper;
        private readonly ISystemSettingCacheManager _systemSettingCacheManager;
        private readonly IRepository<OrderWord> _orderWrodRepository;
        private readonly IRepositoryTextSearch<OrderTs> _repositoryts;

		public OrderRepository(ISugarUnitOfWork<HotlineDbContext> uow,
            IDataPermissionFilterBuilder dataPermissionFilterBuilder,
            ITimeLimitDomainService timeLimitDomainService,
            IMapper mapper,
            ISystemSettingCacheManager systemSettingCacheManager,
            IRepository<OrderWord> orderWrodRepository,
            IRepositoryTextSearch<OrderTs> repositoryts
			) : base(uow, dataPermissionFilterBuilder)
        {
            _dataPermissionFilterBuilder = dataPermissionFilterBuilder;
            _timeLimitDomainService = timeLimitDomainService;
            _mapper = mapper;
            _systemSettingCacheManager = systemSettingCacheManager;
            _orderWrodRepository = orderWrodRepository;
            _repositoryts = repositoryts;
		}

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

            await AddNav(order).Include(d => d.OrderExtension).ExecuteCommandAsync();
            
            return order.Id;
        }

        /// <summary>
		/// 即将超期列表
		/// </summary>
		/// <param name="dto"></param>
		/// <param name="cancellationToken"></param>
		/// <returns></returns>
		public async Task<PagedDto<OrderDto>> GetAboutToExpireAsync(AboutToExpireListDto dto, CancellationToken cancellationToken)
		{
			var setting = _systemSettingCacheManager.GetSetting(SettingConstants.OrderAboutToExpire);
            var value = setting?.SettingValue[0];
            value = string.IsNullOrEmpty(value) ? "0" : value;
			DateTime stTime = DateTime.Now.AddDays(int.Parse(value));
			stTime = _timeLimitDomainService.WorkDay(DateTime.Now);
			DateTime stTime2 = _timeLimitDomainService.WorkDay(DateTime.Now);
			var (total, items) = await Db.Queryable<Order>()
				.WhereIF(dto.IsProvince.HasValue, x => x.IsProvince == dto.IsProvince)
				.WhereIF(!string.IsNullOrEmpty(dto.Keyword), x => x.Title.Contains(dto.Keyword!) || x.No.Contains(dto.Keyword!))
				.Where(x => x.ExpiredTime != null &&
				x.Status != EOrderStatus.Filed && x.Status != EOrderStatus.Published && x.Status != EOrderStatus.Visited && stTime >= x.ExpiredTime.Value && stTime2 <= x.ExpiredTime.Value)
				.OrderByDescending(x => x.CreationTime)
				.ToPagedListAsync(dto.PageIndex, dto.PageSize, cancellationToken);
			return new PagedDto<OrderDto>(total, _mapper.Map<IReadOnlyList<OrderDto>>(items));
		}

		/// <summary>
		/// 即将超期节点列表
		/// </summary>
		/// <param name="dto"></param>
		/// <param name="cancellationToken"></param>
		/// <returns></returns>
		//public async Task<PagedDto<WorkflowOrderDto>> GetAboutToExpireNodeAsync(AboutToExpireListDto dto, CancellationToken cancellationToken)
		//{
		//	var setting = _systemSettingCacheManager.GetSetting(SettingConstants.OrderAboutToExpire);
		//	var value = setting?.SettingValue[0];
		//	value = string.IsNullOrEmpty(value) ? "0" : value;
		//	DateTime stTime = DateTime.Now.AddDays(int.Parse(value));
		//	stTime = _timeLimitDomainService.WorkDay(DateTime.Now);
		//	DateTime stTime2 = _timeLimitDomainService.WorkDay(DateTime.Now);
		//	RefAsync<int> total = 0;
		//	var items = await Db.Queryable<Workflow>()
		//		.LeftJoin<Order>((x, o) => x.ExternalId == o.Id)
		//		.Where(x => x.ModuleCode == "OrderHandle")
		//		.WhereIF(dto.IsProvince.HasValue, (x, o) => o.IsProvince == dto.IsProvince)
		//		.WhereIF(!string.IsNullOrEmpty(dto.Keyword), (x, o) => o.Title.Contains(dto.Keyword!) || o.No.Contains(dto.Keyword!))
		//		.Where((x, o) => (int)x.Status < 20 && stTime >= x.ExpiredTime && stTime2 <= x.ExpiredTime)
		//		.Select((x, o) => new WorkflowOrder { Order = o }, true)
		//		.OrderByDescending(x => x.CreationTime)
		//		.ToPageListAsync(dto.PageIndex, dto.PageSize, total, cancellationToken);
		//	return new PagedDto<WorkflowOrderDto>(total, _mapper.Map<IReadOnlyList<WorkflowOrderDto>>(items));
		//}

		/// <summary>
		/// 已超期列表
		/// </summary>
		/// <param name="dto"></param>
		/// <param name="cancellationToken"></param>
		/// <returns></returns>
		public async Task<PagedDto<OrderDto>> GetToExpireAsync(AboutToExpireListDto dto, CancellationToken cancellationToken)
        {
            DateTime stTime = _timeLimitDomainService.WorkDay(DateTime.Now);
			var (total, items) = await Db.Queryable<Order>()
		        .WhereIF(dto.IsProvince.HasValue, x => x.IsProvince == dto.IsProvince)
		        .WhereIF(!string.IsNullOrEmpty(dto.Keyword), x => x.Title.Contains(dto.Keyword!) || x.No.Contains(dto.Keyword!))
				//.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 && 
                (((x.Status == EOrderStatus.Filed || x.Status == EOrderStatus.Published || x.Status == EOrderStatus.Visited) &&  x.FiledTime >= x.ExpiredTime ) ||
                ((x.Status != EOrderStatus.Filed && x.Status != EOrderStatus.Published && x.Status != EOrderStatus.Visited) && stTime >= x.ExpiredTime.Value)))
				.OrderByDescending(x => x.CreationTime)
		        .ToPagedListAsync(dto.PageIndex, dto.PageSize, cancellationToken);
			return new PagedDto<OrderDto>(total, _mapper.Map<IReadOnlyList<OrderDto>>(items));
		}

   //     /// <summary>
   //     /// 已超期节点列表
   //     /// </summary>
   //     /// <param name="dto"></param>
   //     /// <param name="cancellationToken"></param>
   //     /// <returns></returns>
   //     public async Task<PagedDto<WorkflowOrderDto>> GetToExpireNodeAsync(AboutToExpireListDto dto, CancellationToken cancellationToken)
   //     {
	  //      DateTime stTime = _timeLimitDomainService.WorkDay(DateTime.Now);
			//RefAsync<int> total = 0;
			//var  items= await Db.Queryable<Workflow>()
   //             .LeftJoin<Order>((x,o)=>x.ExternalId == o.Id)
   //             .Where(x => x.ModuleCode == "OrderHandle")
   //             .WhereIF(dto.IsProvince.HasValue, (x, o) => o.IsProvince == dto.IsProvince)
   //             .WhereIF(!string.IsNullOrEmpty(dto.Keyword), (x, o) => o.Title.Contains(dto.Keyword!) || o.No.Contains(dto.Keyword!))
   //             .Where((x,o) => (((int)x.Status >= 20 && x.EndTime >= x.ExpiredTime) || ((int)x.Status < 20 && stTime >= x.ExpiredTime)))
   //             .Select((x, o) => new WorkflowOrder { Order = o }, true)
   //             .OrderByDescending(x => x.CreationTime)
   //             .ToPageListAsync(dto.PageIndex, dto.PageSize, total, cancellationToken);
	  //      return new PagedDto<WorkflowOrderDto>(total, _mapper.Map<IReadOnlyList<WorkflowOrderDto>>(items));
   //     }

		/// <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);
        }

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

        /// <summary>
        /// 工单关键字分词
        /// </summary>
        /// <param name="inputStr"></param>
        /// <returns></returns>
        public async Task OrderParticiple(string inputStr,string orderId, CancellationToken cancellationToken) {
            var words =await _orderWrodRepository.Queryable().Where(x => x.IsEnable == 1 && x.Classify.Contains("普通标签")).Select(x=>x.Tag).ToListAsync(cancellationToken);
            var res = new List<string>();
            if(words.Any()) res = ParticipleTool.SegMMDouble(inputStr, ref words);
			var participles = await _orderWrodRepository.Queryable().In(x=>x.Tag,res).ToListAsync(cancellationToken);
			if (participles.Any())
			{
				//关键词
				var tags = participles.Select(x=>x.Tag).ToList();
                var tagsStr = string.Join(",", tags); 
                await Db.Updateable<Order>().SetColumns(x=>x.TagNames == tagsStr).Where(x=>x.Id == orderId).ExecuteCommandAsync(cancellationToken);
				List<string> synonyms = participles.Select(x => x.Synonym).ToList();
                if (synonyms.Any()) 
                {
                    var synonymsStr =  string.Join(",", synonyms);
					synonyms = synonymsStr.Split(",").Distinct().ToList();
					tags.AddRange(synonyms);
				}
                var vector = await Db.Queryable<OrderTs>().Where(x=>x.Id == orderId).ToListAsync(cancellationToken);
                if (vector.Any()) await _repositoryts.UpdateVectorAsync(orderId, tags, cancellationToken);
                else await _repositoryts.AddVectorAsync(orderId, DateTime.Now, tags, cancellationToken);
			}
		}

        public async Task OrderScreenRevisionVisit(string VisitId, bool canHandle, CancellationToken cancellationToken) {

            await Db.Updateable<OrderVisit>().SetColumns(x => x.IsCanHandle == canHandle).Where(x=>x.Id == VisitId).ExecuteCommandAsync(cancellationToken);
        }

        public async Task FileAsync(Order order, CancellationToken cancellationToken)
        {
			await Db.Updateable<Order>().SetColumns(x=>x.FileJson == order.FileJson).Where(x=>x.Id == order.Id).ExecuteCommandAsync(cancellationToken);
		}
	}
}