Root / src / Dpz.Core.Service / RepositoryServiceImpl / TimelineService.cs
using Dpz.Core.Public.ViewModel.RequestEvent;

namespace Dpz.Core.Service.RepositoryServiceImpl;

public class TimelineService(
    IRepository<Timeline> repository,
    IMapper mapper,
    IMediator mediator,
    IFusionCache fusionCache
) : AbstractCacheService(fusionCache), ITimelineService
{
    public async Task<List<VmTimeline>> GetTimelinesAsync(string account)
    {
        return await GetOrSetCacheAsync<List<VmTimeline>>(
            nameof(GetTimelinesAsync),
            async (_, cancellationToken) =>
            {
                var list = await repository
                    .SearchFor(x => x.Author.Id == account)
                    .OrderByDescending(x => x.Date)
                    .ThenByDescending(x => x.CreateTime)
                    .ToListAsync(cancellationToken);
                return mapper.Map<List<VmTimeline>>(list);
            },
            new { account }
        );
    }

    public async Task SaveAsync(VmTimeline viewModel)
    {
        var entity = mapper.Map<Timeline>(viewModel);
        if (entity == null)
        {
            throw new ArgumentException("viewModel is null", nameof(viewModel));
        }

        if (entity.Id != ObjectId.Empty)
        {
            entity = await repository.TryGetAsync(viewModel.Id);
            if (entity == null)
            {
                return;
            }

            var request = new EditMarkdownRequest
            {
                Markdown = viewModel.Content,
                OriginalMarkdown = entity.Content,
            };
            await mediator.Send(request);

            var update = Builders<Timeline>
                .Update.Set(x => x.Title, viewModel.Title)
                .Set(x => x.Content, viewModel.Content)
                .Set(x => x.Date, viewModel.Date)
                .Set(x => x.More, viewModel.More)
                .Set(x => x.LastUpdateTime, DateTime.Now);
            await repository.UpdateAsync(x => x.Id == entity.Id, update);
            await RemoveByPrefixAsync();
            return;
        }

        await repository.InsertAsync(entity);
        await RemoveByPrefixAsync();
    }

    public async Task DeleteAsync(params string[] id)
    {
        var ids = id.Select(x => ObjectId.TryParse(x, out var oid) ? oid : (ObjectId?)null)
            .Where(x => x.HasValue)
            .Select(x => x!.Value)
            .ToList();
        var filter = Builders<Timeline>.Filter.In(x => x.Id, ids);
        var list = await repository.SearchFor(filter).ToListAsync();
        var contents = list.Select(x => x.Content).ToList();
        await mediator.Send(new DeleteMarkdownRequest { Markdown = contents });
        await repository.DeleteAsync(filter);
        await RemoveByPrefixAsync();
    }

    public async Task<IPagedList<VmTimeline>> GetPageAsync(
        int pageIndex,
        int pageSize,
        string? content = null,
        string? account = null
    )
    {
        return await GetOrSetPagedListAsync(
            nameof(GetPageAsync),
            async _ =>
            {
                var predicate = repository.SearchFor(x => true);
                if (!string.IsNullOrEmpty(content))
                {
                    predicate = predicate.Where(x =>
                        x.Title.Contains(content) || x.Content.Contains(content)
                    );
                }

                if (!string.IsNullOrEmpty(account))
                {
                    predicate = predicate.Where(x => x.Author.Id == account);
                }

                return await predicate
                    .OrderByDescending(x => x.Date)
                    .ToPagedListAsync<Timeline, VmTimeline>(pageIndex, pageSize);
            },
            new
            {
                pageIndex,
                pageSize,
                content,
                account,
            }
        );
    }

    public async Task<VmTimeline?> FindAsync(string id)
    {
        return await GetOrSetCacheAsync<VmTimeline?>(
            nameof(FindAsync),
            async (_, _) =>
            {
                var entity = await repository.TryGetAsync(id);
                return entity == null ? null : mapper.Map<VmTimeline>(entity);
            },
            new { id }
        );
    }
    
    protected override TimeSpan CacheDefaultExpiration => TimeSpan.FromDays(7);
}
⚠⚠    以下内容为AI分析的结果，请根据实际情况进行判断。

上述代码定义了一个名为 TimelineService 的类，它实现了 ITimelineService 接口，提供了一系列与时间线（Timeline）相关的服务。这个类主要用于处理时间线的 CRUD（创建、读取、更新、删除）操作，并且与数据库交互。以下是对每个方法的详细解释：

1. GetTimelinesAsync(string account)

  • 功能: 根据给定的账户 ID 获取该账户的所有时间线。
  • 实现:
    • 使用 repository 查询时间线，筛选出作者 ID 匹配的记录。
    • 按照时间（Date）和创建时间（CreateTime）降序排列。
    • 将查询结果映射到 VmTimeline 视图模型列表并返回。

2. SaveAsync(VmTimeline viewModel)

  • 功能: 保存时间线的视图模型（VmTimeline），可以是插入新记录或更新现有记录。
  • 实现:
    • 将视图模型映射到 Timeline 实体。
    • 如果实体 ID 不为空，表示是更新操作：
      • 首先尝试获取现有实体。
      • 如果实体存在，发送一个 EditMarkdownRequest 请求以处理 Markdown 内容的编辑。
      • 使用 MongoDB 的更新构建器更新实体的各个字段。
    • 如果实体 ID 为空，则插入新实体。

3. DeleteAsync(params string[] id)

  • 功能: 根据给定的 ID 删除时间线记录。
  • 实现:
    • 将字符串 ID 转换为 ObjectId，并过滤掉无效的 ID。
    • 查询数据库以获取要删除的时间线记录。
    • 收集这些记录的内容，并发送 DeleteMarkdownRequest 请求以处理 Markdown 内容的删除。
    • 从数据库中删除这些时间线记录。

4. GetPageAsync(int pageIndex, int pageSize, string? content = null, string? account = null)

  • 功能: 分页获取时间线记录，可以根据内容和账户进行过滤。
  • 实现:
    • 创建一个查询谓词，初始为所有记录。
    • 如果提供了内容，则添加条件以匹配标题或内容。
    • 如果提供了账户，则添加条件以匹配作者 ID。
    • 最后，按日期降序排列，并将结果分页返回。

5. FindAsync(string id)

  • 功能: 根据 ID 查找单个时间线记录。
  • 实现:
    • 使用 repository 尝试获取指定 ID 的时间线实体。
    • 如果找到实体，则将其映射到 VmTimeline 视图模型并返回；如果未找到，则返回 null。

总结

TimelineService 类提供了对时间线数据的全面管理，包括获取、保存、删除和查找时间线记录的功能。它利用了仓储模式（Repository Pattern）与映射器（Mapper）来简化数据访问和转换，同时使用中介者模式（Mediator Pattern）来处理与 Markdown 内容相关的请求。