add 删除轨迹

src/SJZY.Track.Application.Contract/Dtos/ProvideServices/DeleteOrderInput.cs

@@ -3,3 +3,11 @@
 public class DeleteOrderInput : OrderNoInfo
 {
 }
+
+public class DeleteTrackInput : OrderNoInfo
+{
+    /// <summary>
+    /// 轨迹code
+    /// </summary>
+    public List<string> TrackCodes { get; set; } = new();
+}

src/SJZY.Track.Application.Contract/Events/TrackDeleteEvent.cs

@@ -0,0 +1,24 @@
+namespace SJZY.Track.Application.Contract.Events;
+
+public class TrackDeleteEvent
+{
+    /// <summary>
+    /// 订单id
+    /// </summary>
+    public int OrderId { get; set; }
+
+    /// <summary>
+    /// 轨迹代码
+    /// </summary>
+    public List<string> TrackCodes { get; set; } = null!;
+
+    /// <summary>
+    /// 子系统id
+    /// </summary>
+    public int SubSystemId { get; set; }
+    
+    /// <summary>
+    /// 上游子系统id
+    /// </summary>
+    public int UpSubSystemId { get; set; }
+}

src/SJZY.Track.Application/EventHandlers/TrackDeleteEventHandler.cs

@@ -0,0 +1,67 @@
+using DotNetCore.CAP;
+using SJZY.Expand.ABP.Core.PublicMethords;
+using SJZY.Track.Application.Contract.Events;
+using SJZY.Track.Domain.Aggregates.OrderAggregate;
+using SJZY.Track.Domain.Aggregates.TrackDetailsAggregate;
+using SJZY.Track.Domain.Queries;
+using Volo.Abp.DependencyInjection;
+
+namespace SJZY.Track.Application.EventHandlers;
+
+public class TrackDeleteEventHandler: ITransientDependency, ICapSubscribe
+{
+    private readonly IOrderRepository _orderRepository;
+    private readonly IProvideQueries _provideQueries;
+    private readonly ITrackDetailsRepository _trackDetailsRepository;
+    private readonly ICapPublisher _capPublisher;
+
+    public TrackDeleteEventHandler(IProvideQueries provideQueries, ITrackDetailsRepository trackDetailsRepository, IOrderRepository orderRepository, ICapPublisher capPublisher)
+    {
+        _provideQueries = provideQueries;
+        _trackDetailsRepository = trackDetailsRepository;
+        _orderRepository = orderRepository;
+        _capPublisher = capPublisher;
+    }
+
+    [CapSubscribe(GlobalConst.TrackUpsertSubscribe)]
+    public async Task ConsumerAsync(TrackDeleteEvent @event)
+    {
+        // 不同子系统需要做内容映射
+        if (@event.UpSubSystemId != 0 && @event.UpSubSystemId != @event.SubSystemId)
+        {
+            var mapCodes = await _provideQueries
+                .MapTrackCodesAsync(@event.UpSubSystemId, @event.SubSystemId, @event.TrackCodes.ToArray());
+
+            if (mapCodes.Count == 0)
+            {
+                //throw new BusinessException(message: "订单跨子系统，未配置内容映射，请联系管理员");
+                return;
+            }
+
+            @event.TrackCodes = mapCodes;
+        }
+        
+        await DeleteTrackAsync(@event);
+    }
+
+    private async Task DeleteTrackAsync(TrackDeleteEvent @event)
+    {
+        // 删除轨迹
+        await _trackDetailsRepository.DeleteTrackAsync(@event.OrderId, @event.TrackCodes);
+        
+        // 根据订单关联关系异步向下刷
+        var linkedOrders = await _orderRepository.GetLinkedOrdersAsync(@event.OrderId);
+        foreach (var linkedOrder in linkedOrders)
+        {
+            var nextEvent = new TrackDeleteEvent
+            {
+                OrderId = linkedOrder.OrderId,
+                TrackCodes = @event.TrackCodes,
+                SubSystemId = linkedOrder.SubSystemId,
+                UpSubSystemId = @event.SubSystemId
+            };
+           
+            await _capPublisher.PublishAsync(GlobalConst.TrackDeleteSubscribe, nextEvent);
+        }
+    }
+}

src/SJZY.Track.Application/EventHandlers/TrackUpsertEventHandler.cs

@@ -33,10 +33,11 @@ public class TrackUpsertEventHandler : ITransientDependency, ICapSubscribe
     public async Task ConsumerAsync(TrackUpsertEvent @event)
     {
         // 不同子系统需要做内容映射
-        if (@event.UpSubSystemId != @event.SubSystemId)
+        if (@event.UpSubSystemId != 0 && @event.UpSubSystemId != @event.SubSystemId)
         {
-            var mapCode = await _provideQueries
+            var mapCode = (await _provideQueries
-                .MapTrackContentCodeAsync(@event.UpSubSystemId, @event.SubSystemId, @event.TrackCode);
+                    .MapTrackCodesAsync(@event.UpSubSystemId, @event.SubSystemId, @event.TrackCode))
+                .FirstOrDefault();
 
             if (mapCode == default)
             {
@@ -50,7 +51,7 @@ public class TrackUpsertEventHandler : ITransientDependency, ICapSubscribe
         await UpsertTrackAsync(@event);
     }
 
-    internal async Task UpsertTrackAsync(TrackUpsertEvent @event)
+    private async Task UpsertTrackAsync(TrackUpsertEvent @event)
     {
         // 不存在则新增轨迹，存在则更新
         var track = await _trackDetailsRepository.GetFirstOrDefaultAsync(@event.OrderId, @event.TrackCode);
@@ -65,6 +66,7 @@ public class TrackUpsertEventHandler : ITransientDependency, ICapSubscribe
                 //throw new BusinessException(message: $"订单：{@event.OrderNo} 所绑定的模板，没有一条内容可以匹配轨迹代码：{@event.TrackCode}");
                 return;
             }
+
             orderIsCompleted = trackContent.IsCompleted;
 
             track = new TrackDetailsIndex

src/SJZY.Track.Application/Services/ProvideServices/OrderService.cs

@@ -20,7 +20,7 @@ public class OrderService : ApplicationService
     )
     {
         _orderRepository = orderRepository;
-        this._trackDetailsRepository=trackDetailsRepository;
+        _trackDetailsRepository = trackDetailsRepository;
     }
 
     /// <summary>

src/SJZY.Track.Application/Services/ProvideServices/TrackService.cs

@@ -1,7 +1,8 @@
-using SJZY.Track.Application.Contract.Dtos.ProvideServices;
+using DotNetCore.CAP;
+using SJZY.Track.Application.Contract.Dtos.ProvideServices;
 using SJZY.Track.Application.Contract.Events;
-using SJZY.Track.Application.EventHandlers;
 using SJZY.Track.Domain.Aggregates.OrderAggregate;
+using SJZY.Track.Domain.Queries;
 
 namespace SJZY.Track.Application.Services.ProvideServices;
 
@@ -12,12 +13,14 @@ namespace SJZY.Track.Application.Services.ProvideServices;
 public class TrackService : ApplicationService
 {
     private readonly IOrderRepository _orderRepository;
-    private readonly TrackUpsertEventHandler _trackUpsertEventHandler;
+    private readonly IProvideQueries _provideQueries;
+    private readonly ICapPublisher _capPublisher;
 
-    public TrackService(IOrderRepository orderRepository, TrackUpsertEventHandler trackUpsertEventHandler)
+    public TrackService(IOrderRepository orderRepository, IProvideQueries provideQueries, ICapPublisher capPublisher)
     {
         _orderRepository = orderRepository;
-        _trackUpsertEventHandler = trackUpsertEventHandler;
+        _provideQueries = provideQueries;
+        _capPublisher = capPublisher;
     }
 
     /// <summary>
@@ -45,7 +48,45 @@ public class TrackService : ApplicationService
         @event.SubSystemId = order.SubSystemId;
         @event.IsPushCompleted = order.IsPushCompleted;
         @event.CustomId = order.CustomId;
-        await _trackUpsertEventHandler.UpsertTrackAsync(@event);
+        await _capPublisher.PublishAsync(GlobalConst.TrackUpsertSubscribe, @event);
+        return true;
+    }
+
+    /// <summary>
+    /// 删除轨迹
+    /// </summary>
+    /// <param name="input"></param>
+    /// <returns></returns>
+    /// <exception cref="BusinessException"></exception>
+    [HttpPost("Track/Delete")]
+    public async Task<bool> DeleteTrackAsync(DeleteTrackInput input)
+    {
+        var order = await _orderRepository.GetFirstAsync(x =>
+            x.OrderType == input.OrderType && x.OrderNo == input.OrderNo, x => new
+        {
+            x.Id, x.SubSystemId, x.IsPushCompleted, x.CustomId
+        });
+        if (order == default)
+        {
+            throw new BusinessException(message: $"订单：{input.OrderNo}不存在");
+        }
+
+        var codes = await _provideQueries.GetCanDeleteTrackCodesAsync(order.Id, input.TrackCodes);
+
+        if (codes.Count == 0)
+        {
+            throw new BusinessException(message: "没有一个轨迹代码是可删的");
+        }
+
+        // 删除轨迹
+        var @event = new TrackDeleteEvent
+        {
+            OrderId = order.Id,
+            TrackCodes = codes,
+            SubSystemId = order.SubSystemId,
+        };
+        await _capPublisher.PublishAsync(GlobalConst.TrackUpsertSubscribe, @event);
+
         return true;
     }
 }

src/SJZY.Track.Domain/Aggregates/TrackDetailsAggregate/ITrackDetailsRepository.cs

@@ -4,7 +4,7 @@ namespace SJZY.Track.Domain.Aggregates.TrackDetailsAggregate;
 
 public interface ITrackDetailsRepository
 {
-    Task<TrackDetailsIndex?> GetFirstOrDefaultAsync(int orderId, string inputTrackCode);
+    Task<TrackDetailsIndex?> GetFirstOrDefaultAsync(int orderId, string trackCode);
 
     Task UpsertAsync(TrackDetailsIndex index);
 
@@ -12,4 +12,12 @@ public interface ITrackDetailsRepository
 
     Task<(List<TrackDetailsIndex> list, long total)> GetListAsync(TrackDetailsQueryInput input);
     Task<List<TrackDetailsIndex>> GetListAsync(int orderId);
+    
+    /// <summary>
+    /// 删除轨迹
+    /// </summary>
+    /// <param name="orderId"></param>
+    /// <param name="trackCodes"></param>
+    /// <returns></returns>
+    Task DeleteTrackAsync(int orderId, List<string> trackCodes);
 }

src/SJZY.Track.Domain/Dtos/TrackDetails/MatchTrackContentsDto.cs

@@ -0,0 +1,14 @@
+namespace SJZY.Track.Domain.Dtos.TrackDetails;
+
+public class MatchTrackContentsDto
+{
+    /// <summary>
+    /// 轨迹代码
+    /// </summary>
+    public string TrackCode { get; set; } = null!;
+
+    /// <summary>
+    /// 是否支持删除
+    /// </summary>
+    public bool IsCanDelete { get; set; }
+}

src/SJZY.Track.Domain/GlobalConst.cs

@@ -12,6 +12,11 @@ public class GlobalConst
     /// </summary>
     public const string TrackUpsertSubscribe = "SJZY.Track.TrackUpsert";
     
+    /// <summary>
+    /// 轨迹删除 mq订阅名称
+    /// </summary>
+    public const string TrackDeleteSubscribe = "SJZY.Track.TrackDelete";
+
     /// <summary>
     /// 接口通批量轨迹刷新订阅
     /// </summary>

src/SJZY.Track.Domain/Queries/IProvideQueries.cs

@@ -33,14 +33,22 @@ public interface IProvideQueries
     /// <returns></returns>
     Task<MatchTrackContentDto?> MatchTrackContentAsync(int orderId, string code);
     
+    /// <summary>
+    /// 获取可删除的订单轨迹代码
+    /// </summary>
+    /// <param name="orderId"></param>
+    /// <param name="trackCodes"></param>
+    /// <returns></returns>
+    Task<List<string>> GetCanDeleteTrackCodesAsync(int orderId, List<string> trackCodes);
+
     /// <summary>
     /// 根据子系统内容映射，得到映射后的轨迹code
     /// </summary>
     /// <param name="upSubSystemId"></param>
     /// <param name="subSystemId"></param>
-    /// <param name="trackCode"></param>
+    /// <param name="trackCodes"></param>
     /// <returns></returns>
-    Task<string?> MapTrackContentCodeAsync(int upSubSystemId, int subSystemId, string trackCode);
+    Task<List<string>> MapTrackCodesAsync(int upSubSystemId, int subSystemId, params string[] trackCodes);
 
     /// <summary>
     /// 获取服务商模板配置

src/SJZY.Track.Repository/Queries/ProvideQueries.cs

@@ -80,13 +80,24 @@ public class ProvideQueries : ISugarRepository, IProvideQueries,
             .FirstAsync();
     }
 
-    public async Task<string?> MapTrackContentCodeAsync(int upSubSystemId, int subSystemId, string trackCode)
+    public async Task<List<string>> GetCanDeleteTrackCodesAsync(int orderId, List<string> trackCodes)
+    {
+        return await Context.Queryable<OrderTemplateEntity>()
+            .LeftJoin<TrackTemplateContentEntity>((x, a) => x.TrackTemplateId == a.TrackTemplateId && a.IsCanDelete)
+            .LeftJoin<TrackContentEntity>((x, a, b) => a.TrackContentId == b.Id)
+            .Where((x, a, b) => x.OrderId == orderId
+                                && trackCodes.Contains(b.Code))
+            .Select((x, a, b) => b.Code)
+            .ToListAsync();
+    }
+
+    public async Task<List<string>> MapTrackCodesAsync(int upSubSystemId, int subSystemId, params string[] trackCodes)
     {
         return await Context.Queryable<TrackContentMapEntity>()
             .Where(x => x.SubSystemId == upSubSystemId && x.MapSubSystemId == subSystemId &&
-                        x.TrackContentCode == trackCode)
+                        trackCodes.Contains(x.TrackContentCode))
             .Select(x => x.MapTrackContentCode)
-            .FirstAsync();
+            .ToListAsync();
     }
 
     public async Task<List<TrackPullContentConfigVO>> GetPullContentConfigsAsync(int serviceProviderId)

src/SJZY.Track.Repository/Repositories/TrackDetailsRepository.cs

@@ -22,6 +22,7 @@ internal class TrackDetailsRepository : ElasticSearchContextAbstract<TrackDetail
             .Query(q =>
                 q.Term(t => t.Field(f => f.OrderId).Value(orderId))
                 && q.Term(t => t.Field(f => f.TrackCode).Value(trackCode))
+                && q.Term(t => t.Field(f => f.IsDeleted).Value(true))
             )
         );
 
@@ -62,7 +63,9 @@ internal class TrackDetailsRepository : ElasticSearchContextAbstract<TrackDetail
                 q.Terms(t => t
                     .Field(f => f.OrderNo)
                     .Terms(orderNos))
-                && q.Term(f => f.OrderType, orderType))
+                && q.Term(f => f.OrderType, orderType)
+                && q.Term(t => t.Field(f => f.IsDeleted).Value(true))
+            )
         );
 
         return data.Documents.ToList();
@@ -78,11 +81,27 @@ internal class TrackDetailsRepository : ElasticSearchContextAbstract<TrackDetail
                 .Field(f => f.TrackPlace)
                 .Field(f => f.TrackTime)
                 .Field(f => f.TraceTimeZone)
-             )).Query(q => q.Terms(t => t.Field(f => f.OrderId).Terms(orderId))));
+            )).Query(q =>
+                q.Terms(t => t.Field(f => f.OrderId).Terms(orderId))
+                && q.Term(t => t.Field(f => f.IsDeleted).Value(true))
+            )
+        );
 
         return data?.Documents?.ToList();
     }
 
+    public async Task DeleteTrackAsync(int orderId, List<string> trackCodes)
+    {
+        await Context.UpdateByQueryAsync<TrackDetailsIndex>(x => x
+            .Query(
+                q =>
+                    q.Term(t => t.OrderId, orderId)
+                    && q.Terms(t => t.Field(f => f.TrackCode).Terms(trackCodes)))
+            .Script(s => s
+                .Source("ctx._source.IsDeleted = true"))
+        );
+    }
+
     public async Task<(List<TrackDetailsIndex> list, long total)> GetListAsync(TrackDetailsQueryInput input)
     {
         if (input.OrderNos.Count < 1) return default;
@@ -91,9 +110,12 @@ internal class TrackDetailsRepository : ElasticSearchContextAbstract<TrackDetail
         var finalSize = input.PageSize > 500 ? 500 : input.PageSize;
 
         var data = await Context.SearchAsync<TrackDetailsIndex>(x => x
-                .Query(q => q.Terms(t => t
+                .Query(q =>
+                    q.Terms(t => t
                         .Field(f => f.OrderNo)
-                    .Terms(distinctOrderNumbers)))
+                        .Terms(distinctOrderNumbers))
+                    && q.Term(t => t.Field(f => f.IsDeleted).Value(true))
+                )
                 .Sort(s => s.Field(f => f.CreateTime, SortOrder.Descending))
                 .From((input.PageIndex - 1) * input.PageSize)
                 .Size(finalSize)