Merge remote-tracking branch 'origin/S02-轨迹中台' into S02-轨迹中台

# Conflicts:
#	src/SJZY.Track.Application/Services/TrackPush/TrackPushCacheService.cs

src/SJZY.Track.Application.Contract/Services/ITrackPushCacheService.cs

@@ -4,13 +4,6 @@ namespace SJZY.Track.Application.Contract.Services;
 
 public interface ITrackPushCacheService
 {
-    /// <summary>
-    /// 判断客户是否需要推送
-    /// </summary>
-    /// <param name="customId"></param>
-    /// <returns></returns>
-    Task<bool> IsPushAsync(int customId);
-
     /// <summary>
     /// 获取服务商拉取配置
     /// </summary>
@@ -39,9 +32,11 @@ public interface ITrackPushCacheService
         int? trackContentId);
 
     /// <summary>
-    /// 更新缓存
+    /// 设置推送配置缓存
     /// </summary>
-    /// <param name="customId"></param>
+    /// <param name="id"></param>
-    /// <param name="isPush"></param>
+    /// <param name="subSystemId">子系统id</param>
-    Task UpdateAsync(int customId, bool isPush);
+    /// <param name="customId">客户id</param>
+    /// <returns></returns>
+    Task<List<TrackPushContentConfigDto>> SetPushContentConfigsAsync(int? id = null, int? subSystemId = null, int? customId = null);
 }

src/SJZY.Track.Application/AutoMapper/TrackPushAutoMapperProfile.cs

@@ -1,4 +1,5 @@
 using AutoMapper;
+using SJZY.Track.Application.Contract.Dtos.ProvideServices;
 using SJZY.Track.Application.Contract.Dtos.TrackPush;
 using SJZY.Track.Domain.Aggregates.TrackPullAggregate;
 using SJZY.Track.Domain.Aggregates.TrackPushAggregate;
@@ -14,5 +15,7 @@ public class TrackPushAutoMapperProfile : Profile
         CreateMap<EditTrackPushConfigInput, TrackPushPullParamsConfigEntity>(MemberList.None).Ignore(dest => dest.Id)
             .ForMember(dest => dest.IsPush, opt => opt.MapFrom(source => true));
         CreateMap<EditTrackPushContentInput, TrackPushContentConfigEntity>(MemberList.None);
+        CreateMap<TrackPushContentConfigEntity, TrackPushContentConfigDto>(MemberList.None)
+            .ForMember(dest => dest.OrderType, opt => opt.MapFrom(source => source.OrderNoType));
     }
 }

src/SJZY.Track.Application/Services/TrackPull/TrackPullCacheService.cs

@@ -4,10 +4,11 @@ using SJZY.Track.Application.Contract.Dtos.TrackPull;
 using SJZY.Track.Application.Contract.Services;
 using SJZY.Track.Domain.Aggregates.TrackPullAggregate;
 using SJZY.Track.Domain.Dtos.TrackPull;
+using Volo.Abp.DependencyInjection;
 
 namespace SJZY.Track.Application.Services.TrackPull;
 
-public class TrackPullCacheService : ApplicationService, ITrackPullCacheService
+public class TrackPullCacheService : ApplicationService, ITrackPullCacheService, ITransientDependency
 {
     private readonly ITrackPullConfigRepository _trackPullConfigRepository;
 
@@ -59,6 +60,7 @@ public class TrackPullCacheService : ApplicationService, ITrackPullCacheService
 
         var trackPullConfigEntity = await _trackPullConfigRepository.GetFirstAsync(exp);
         if (trackPullConfigEntity == null) return data;
+
         var trackPullConfigDetail = await _trackPullConfigRepository.GetDetailAsync(trackPullConfigEntity.Id);
         if (trackPullConfigDetail is null) return data;
         var trackPullContentList = await _trackPullConfigRepository.GetContentListCacheAsync(trackPullConfigEntity.Id);
@@ -72,7 +74,7 @@ public class TrackPullCacheService : ApplicationService, ITrackPullCacheService
 
         await RedisHelper.Client.SetAsync(
             TrackPullContentKey(trackPullConfigEntity.SubSystemId, trackPullConfigEntity.ServiceProviderId), data,
-            86400);
+            (int)TimeSpan.FromDays(1).TotalSeconds);
 
         return data;
     }

src/SJZY.Track.Application/Services/TrackPull/TrackPullService.cs

@@ -212,16 +212,21 @@ public class TrackPullService : ApplicationService, ITransientDependency
                     ObjectMapper.Map(input, oldTrackPullContentEntity);
 
                     await _trackPullConfigRepository.UpdateContentAsync(oldTrackPullContentEntity);
-                    await _trackPullCacheService.SetPullConfigAsync(input.TrackPullConfigId);
+                    await _trackPullCacheService.SetPullConfigAsync(oldTrackPullContentEntity.TrackPullConfigId);
 
                     break;
                 }
 
             case OptionTypeNoNull.删除:
+                {
+                    var oldTrackPullContentEntity = await _trackPullConfigRepository.GetContentByIdAsync(input.Id!.Value) ??
+                                        throw new BusinessException(message: _stringLocalizer["NotFindData"]);
 
                     await _trackPullConfigRepository.SoftDeleteContentAsync(x => x.Id == input.Id);
+                    await _trackPullCacheService.SetPullConfigAsync(oldTrackPullContentEntity.TrackPullConfigId);
 
                     break;
+                }
 
             default:
                 throw new BusinessException(message: _stringLocalizer[SjzyBasicLocalization.Validation_IsInEnum,

src/SJZY.Track.Application/Services/TrackPush/TrackPushCacheService.cs

@@ -2,30 +2,30 @@
 using SJZY.Track.Application.Contract.Dtos.ProvideServices;
 using SJZY.Track.Application.Contract.Services;
 using SJZY.Track.Domain.Aggregates.TrackPushAggregate;
-using SJZY.Track.Domain.Queries;
+using System.Linq.Expressions;
 using Volo.Abp.DependencyInjection;
 
 namespace SJZY.Track.Application.Services.TrackPush;
 
-public class TrackPushCacheService : ITrackPushCacheService, ITransientDependency
+public class TrackPushCacheService : ApplicationService, ITrackPushCacheService, ITransientDependency
 {
-    private readonly IBasicQuery<TrackPushConfigEntity> _trackPushConfigQuery;
+    private readonly ITrackPushConfigRepository _trackPushConfigRepository;
 
-    private string RedisKey(int customId) => $"{GlobalConst.TrackPushKeyPrefix}:{customId}";
+    private string TrackPushContentKey(int subSystemId, int customId) => $"{GlobalConst.TrackPushKeyPrefix}:{subSystemId}:{customId}";
 
-    public TrackPushCacheService(IBasicQuery<TrackPushConfigEntity> trackPushConfigQuery)
+    public TrackPushCacheService(ITrackPushConfigRepository trackPushConfigRepository)
     {
-        _trackPushConfigQuery = trackPushConfigQuery;
+        _trackPushConfigRepository = trackPushConfigRepository;
     }
 
-    public Task<bool> IsPushAsync(int customId)
+    [NonAction]
+    public async Task<List<TrackPushContentConfigDto>> GetPushContentConfigsAsync(int subSystemId, int customId)
     {
-        throw new NotImplementedException();
+        var data = await RedisHelper.Client.GetAsync<List<TrackPushContentConfigDto>>(TrackPushContentKey(subSystemId, customId));
-    }
 
-    public Task<List<TrackPushContentConfigDto>> GetPushContentConfigsAsync(int subSystemId, int customId)
+        data ??= await SetPushContentConfigsAsync(subSystemId: subSystemId, customId: customId);
-    {
+
-        throw new NotImplementedException();
+        return data;
     }
     
     public Task<TrackPushContentConfigDto> GetPushContentConfigAsync(int subSystemId, int customId, int trackContentId)
@@ -33,14 +33,46 @@ public class TrackPushCacheService : ITrackPushCacheService, ITransientDependenc
         throw new NotImplementedException();
     }
 
-    public Task<TrackPushContentConfigDto?> InferNextPushContentOrNullAsync(int subSystemId, int customId,
+    [NonAction]
-        int? trackContentId)
+    public async Task<TrackPushContentConfigDto?> InferNextPushContentOrNullAsync(int subSystemId, int customId, int? trackContentId)
     {
-        throw new NotImplementedException();
+        var data = await GetPushContentConfigsAsync(subSystemId, customId);
+
+        if (trackContentId.HasValue)
+        {
+            if (data.Count > 1 && data.Any(x => x.TrackContentId == trackContentId))
+            {
+                int index = data.FindIndex(x => x.TrackContentId == trackContentId);
+                int nextIndex = (index + 1) % data.Count; // 计算下一个索引，处理最后一个元素的情况
+
+                return data[nextIndex];
+            }
+            else return null;
+        }
+        else return data.FirstOrDefault();
     }
 
-    public async Task UpdateAsync(int customId, bool isPush)
+    [NonAction]
+    public async Task<List<TrackPushContentConfigDto>> SetPushContentConfigsAsync(int? id = null, int? subSystemId = null, int? customId = null)
     {
-        await RedisHelper.Client.SetAsync(RedisKey(customId), isPush);
+        var data = new List<TrackPushContentConfigDto>();
+        Expression<Func<TrackPushConfigEntity, bool>> exp = x => true;
+        if (id.HasValue) exp = x => x.Id == id;
+        else if (subSystemId.HasValue && customId.HasValue)
+            exp = x => x.SubSystemId == subSystemId && x.CustomId == customId;
+
+        var trackPushConfigEntity = await _trackPushConfigRepository.GetFirstAsync(exp);
+        if (trackPushConfigEntity == null) return data;
+
+        var trackPushContentList = await _trackPushConfigRepository.GetContentListAsync(x => x.TrackPushConfigId == trackPushConfigEntity.Id);
+        if (trackPushContentList.Count == 0) return data;
+
+        trackPushContentList = trackPushContentList.OrderBy(x => x.Sort).ToList();
+
+        data = ObjectMapper.Map<List<TrackPushContentConfigEntity>, List<TrackPushContentConfigDto>>(trackPushContentList);
+
+        await RedisHelper.Client.SetAsync(TrackPushContentKey(trackPushConfigEntity.SubSystemId, trackPushConfigEntity.CustomId), data, (int)TimeSpan.FromDays(1).TotalSeconds);
+
+        return data;
     }
 }

src/SJZY.Track.Application/Services/TrackPush/TrackPushService.cs

@@ -94,8 +94,7 @@ public class TrackPushService : ApplicationService
         if (input.Options != OptionTypeNoNull.删除)
         {
             Expression<Func<TrackPushConfigEntity, bool>> isAnyExp = x =>
-                x.SubSystemId == input.SubSystemId && x.CustomId == input.CustomId &&
+                x.SubSystemId == input.SubSystemId && x.CustomId == input.CustomId;
-                x.ServiceProviderId == input.ServiceProviderId;
             if (input.Options == OptionTypeNoNull.修改) isAnyExp = isAnyExp.And(x => x.Id != input.Id);
 
             if (await _trackPushConfigRepository.IsAnyAsync(isAnyExp))
@@ -117,8 +116,6 @@ public class TrackPushService : ApplicationService
                         trackPushParamsEntity.PullOrPushConfigId = id;
                         await _trackPullConfigRepository.InsertParamsAsync(trackPushParamsEntity);
 
-                    if (input.IsAutoPush!.Value) await _trackPushCacheService.IsPushAsync(input.CustomId!.Value);
-
                         ts.Complete();
                     }
                 }
@@ -143,9 +140,6 @@ public class TrackPushService : ApplicationService
                         await _trackPushConfigRepository.UpdateAsync(oldTrackPushEntity);
                         await _trackPullConfigRepository.UpdateParamsAsync(oldTrackPushParamsEntity);
 
-                    await _trackPushCacheService.UpdateAsync(oldCustomId, false);
-                    if (input.IsAutoPush!.Value) await _trackPushCacheService.IsPushAsync(input.CustomId!.Value);
-
                         ts.Complete();
                     }
                 }
@@ -162,7 +156,6 @@ public class TrackPushService : ApplicationService
                         await _trackPullConfigRepository.SoftDeleteParamsAsync(x =>
                             x.PullOrPushConfigId == input.Id && x.IsPush);
                         await _trackPushConfigRepository.SoftDeleteContentAsync(x => x.TrackPushConfigId == input.Id);
-                    await _trackPushCacheService.UpdateAsync(oldTrackPushEntity.CustomId, false);
 
                         ts.Complete();
                     }
@@ -223,6 +216,7 @@ public class TrackPushService : ApplicationService
                     entity.Sort = maxSort + 1;
 
                     await _trackPushConfigRepository.InsertContentAsync(entity);
+                    await _trackPushCacheService.SetPushContentConfigsAsync(input.TrackPushConfigId);
 
                     break;
                 }
@@ -235,6 +229,7 @@ public class TrackPushService : ApplicationService
                     ObjectMapper.Map(input, entity);
 
                     await _trackPushConfigRepository.UpdateContentAsync(entity);
+                    await _trackPushCacheService.SetPushContentConfigsAsync(entity.TrackPushConfigId);
 
                     break;
                 }
@@ -247,13 +242,14 @@ public class TrackPushService : ApplicationService
                     using (var ts = TransactionScopeHelper.Create())
                     {
                         await _trackPushConfigRepository.SoftDeleteContentAsync(x => x.Id == input.Id);
-
                         await _trackPushConfigRepository.UpdateContentAsync(x => x.Sort == x.Sort - 1,
                             x => x.TrackPushConfigId == entity.TrackPushConfigId && x.Sort > entity.Sort);
 
                         ts.Complete();
                     }
 
+                    await _trackPushCacheService.SetPushContentConfigsAsync(entity.TrackPushConfigId);
+
                     break;
                 }
 
@@ -282,7 +278,11 @@ public class TrackPushService : ApplicationService
             item.Sort = input.SortInfo.Single(x => x.Key == item.Id.ToString()).Value;
         });
 
+        if (trackPushContentEntities.Count > 0)
+        {
             await _trackPushConfigRepository.UpdateContentRangeAsync(trackPushContentEntities);
+            await _trackPushCacheService.SetPushContentConfigsAsync(trackPushContentEntities[0].TrackPushConfigId);
+        }
 
         return true;
     }