网站首页 网站源码
website
站点相关全部源代码，隐藏了一些关于服务器的信息
using Dpz.Core.Public.ViewModel.RequestEvent;
using Medallion.Threading;
using MongoDB.Driver;

namespace Dpz.Core.Service.V4.Implements;

public class ArticleService(
    IRepository<Article> repository,
    IMediator mediator,
    IMapper mapper,
    ILogger<ArticleService> logger,
    IDistributedLockProvider distributedLockProvider,
    IFusionCache fusionCache,
    IConfiguration configuration
) : AbstractCacheService(fusionCache), IArticleService
{
#pragma warning disable MALinq2001

    protected override string CachePrefixKey => ServiceCacheKeyPrefixes.ArticleService;
    protected override TimeSpan CacheDefaultExpiration => TimeSpan.FromHours(3);

    private readonly IFusionCache _fusionCache = fusionCache;

    /// <summary>
    /// 生成文章浏览量缓存键，形如 {Prefix}:ViewCount:{Id}
    /// </summary>
    private string BuildViewCountCacheKey(string articleId) => $"{ViewCountTag}:{articleId}";

    /// <summary>
    /// 浏览量缓存统一标签，便于批量移除
    /// </summary>
    private string ViewCountTag => CachePrefixKey + ":ViewCount";

    /// <summary>
    /// 生成文章评论数缓存键，形如 {Prefix}:Comment:{Id}
    /// </summary>
    private string BuildCommentCountCacheKey(string articleId) => $"{CommentCountTag}:{articleId}";

    /// <summary>
    /// 评论数缓存统一标签
    /// </summary>
    private string CommentCountTag => CachePrefixKey + ":Comment";

    public async Task<List<VmArticleMini>> GetTopArticlesAsync(int days = -7, uint count = 15)
    {
        if (days > 0)
        {
            throw new ArgumentException("days > 0", nameof(days));
        }
        var cache = await GetOrSetCacheAsync<List<VmArticleMini>>(
            nameof(GetTopArticlesAsync),
            async (_, cancellationToken) =>
            {
                if (
                    !string.Equals(
                        configuration["AgileConfig:env"],
                        "PROD",
                        StringComparison.OrdinalIgnoreCase
                    )
                )
                {
                    var noProdData = await repository
                        .MongodbQueryable.Sample(count)
                        .ToListAsync(cancellationToken);
                    return mapper.Map<List<VmArticleMini>>(noProdData);
                }

                var date = DateTime.Now.AddDays(days);
                var length = (int)count;
                var source = await repository
                    .SearchFor(x => x.CreateTime > date)
                    .OrderByDescending(x => x.ViewCount)
                    .Take(length)
                    .ToListAsync(cancellationToken);
                return mapper.Map<List<VmArticleMini>>(source);
            },
            new { days, count }
        );
        await ApplyViewCountsAsync(cache);
        return cache;
    }

    public async Task<List<VmArticleMini>> GetRandomArticlesAsync(int sample = 8)
    {
        if (sample <= 0)
        {
            throw new ArgumentException("sample <= 0", nameof(sample));
        }
        if (sample > 30)
        {
            throw new ArgumentException("sample > 30", nameof(sample));
        }
        var cache = await GetOrSetCacheAsync<List<VmArticleMini>>(
            nameof(GetRandomArticlesAsync),
            async (_, cancellationToken) =>
            {
                var source = await repository
                    .SearchFor(x => x.Tags.Contains("cnBeta") || x.Tags.Contains("ItHome"))
                    .Sample(sample)
                    .ToListAsync(cancellationToken);
                return mapper.Map<List<VmArticleMini>>(source);
            },
            new { sample }
        );
        await ApplyViewCountsAsync(cache);
        return cache;
    }

    public async Task<List<VmArticleMini>> GetPublishArticlesAsync()
    {
        var cache = await GetOrSetCacheAsync<List<VmArticleMini>>(
            nameof(GetPublishArticlesAsync),
            async (_, cancellationToken) =>
            {
                var source = await repository
                    .SearchFor(x =>
                        (!x.Tags.Contains("cnBeta") && !x.Tags.Contains("ItHome"))
                        || x.CommentCount > 0
                    )
                    .OrderByDescending(x => x.CreateTime)
                    .ToListAsync(cancellationToken);
                return mapper.Map<List<VmArticleMini>>(source);
            }
        );
        await ApplyViewCountsAsync(cache);
        return cache;
    }

    public async Task<IPagedList<VmArticleMini>> GetPagesAsync(
        int pageIndex = 1,
        int pageSize = 20,
        string? title = "",
        string? account = "",
        params string?[]? tags
    )
    {
        var pagedList = await GetOrSetPagedListAsync<VmArticleMini>(
            nameof(GetPagesAsync),
            async _ =>
            {
                var filterEmpty = Builders<Article>.Filter.Empty;
                var filters = new List<FilterDefinition<Article>>();
                if (!string.IsNullOrEmpty(account))
                {
                    var filter = Builders<Article>.Filter.Eq(x => x.Author.Id, account);
                    filters.Add(filter);
                }

                var clearTags =
                    tags?.Where(x => !string.IsNullOrEmpty(x)).Select(x => x!).ToList() ?? [];
                if (clearTags.Count > 0)
                {
                    var filter = Builders<Article>.Filter.AnyIn(x => x.Tags, clearTags);
                    filters.Add(filter);
                }

                if (!string.IsNullOrEmpty(title))
                {
                    var filter = Builders<Article>.Filter.Regex(
                        x => x.Title,
                        new BsonRegularExpression(title, "i")
                    );
                    filters.Add(filter);
                }

                var filterResult =
                    filters.Count > 0 ? Builders<Article>.Filter.And(filters) : filterEmpty;

                var result = await repository
                    .SearchFor(filterResult)
                    .SortByDescending(x => x.CreateTime)
                    .ToPagedListAsync<Article, VmArticleMini>(pageIndex, pageSize);

                return result;
            },
            new
            {
                pageIndex,
                pageSize,
                title,
                account,
                tags,
            }
        );
        await ApplyViewCountsAsync(pagedList);
        return pagedList;
    }

    public async Task<List<string>> GetAllTagsAsync()
    {
        var cache = await GetOrSetCacheAsync<List<string>>(
            nameof(GetAllTagsAsync),
            async (_, cancellationToken) =>
            {
                return await repository
                    .MongodbQueryable.SelectMany(x => x.Tags)
                    .GroupBy(x => x)
                    .Select(x => x.Key)
                    .OrderBy(x => x)
                    .ToListAsync(cancellationToken);
            }
        );
        return cache;
    }

    public async Task<VmArticle?> GetArticleAsync(string? id)
    {
        var cache = await GetOrSetCacheAsync<VmArticle?>(
            nameof(GetArticleAsync),
            async (_, _) =>
            {
                var article = await repository.TryGetAsync(id);
                return article == null ? null : mapper.Map<VmArticle>(article);
            },
            new { id }
        );
        await ApplyViewCountAsync(cache);
        return cache;
    }

    public async Task ViewAsync(string id)
    {
        if (!ObjectId.TryParse(id, out var oid))
        {
            return;
        }

        // 使用 FindOneAndUpdate 原子更新并返回新值
        var filter = Builders<Article>.Filter.Eq(x => x.Id, oid);
        var update = Builders<Article>.Update.Inc(x => x.ViewCount, 1);
        var options = new FindOneAndUpdateOptions<Article, Article>
        {
            ReturnDocument = ReturnDocument.After,
        };

        var updated = await repository.Collection.FindOneAndUpdateAsync(filter, update, options);
        if (updated == null)
        {
            return;
        }

        var newCount = updated.ViewCount;

        // 使用从数据库返回的值更新缓存，避免并发下的覆盖问题
        await SetViewCountCacheAsync(id, newCount);
        await UpdateCachedArticleViewCountAsync(id, newCount);
    }

    public async Task<List<VmArticleMini>> GetLatestAsync(int range = 5)
    {
        if (range <= 0)
        {
            throw new ArgumentException("range <= 0", nameof(range));
        }

        if (range > 200)
        {
            throw new ArgumentException("range > 200", nameof(range));
        }

        var cache = await GetOrSetCacheAsync<List<VmArticleMini>>(
            nameof(GetLatestAsync),
            async (_, cancellationToken) =>
            {
                var source = await repository
                    //.SearchFor(x => true)
                    .MongodbQueryable.OrderByDescending(x => x.CreateTime)
                    .Take(range)
                    .ToListAsync(cancellationToken);
                return mapper.Map<List<VmArticleMini>>(source);
            },
            new { range }
        );
        await ApplyViewCountsAsync(cache);
        return cache;
    }

    public async Task<bool> IsExistsAsync(string title)
    {
        var blog = await repository.SearchFor(x => x.Title == title).FirstOrDefaultAsync();
        return blog != null;
    }

    public async Task<IReadOnlyCollection<string>> NoExistsByFromAsync(
        IReadOnlyCollection<string> feeds
    )
    {
        var filter = Builders<Article>.Filter.In(x => x.From, feeds);
        var exists = await repository.SearchFor(filter).Project(x => x.From).ToListAsync();
        return feeds.Except(exists).ToArray();
    }

    public async Task DeleteAsync(string id)
    {
        if (ObjectId.TryParse(id, out var oid))
        {
            var article = await repository.FindAsync(oid);

            await mediator.Send(new RemoveImagesRequest { Images = article?.ImagesAddress });
            await repository.DeleteAsync(x => x.Id == oid);
            await ClearCacheAsync();
        }
    }

    public async Task DeleteOldCnBetaAsync(int month, int limit)
    {
        if (month <= 0)
        {
            throw new ArgumentException("month no can't <= 0", nameof(month));
        }

        var date = DateTime.Now.AddMonths(-month);
        var list = await repository
            .SearchFor(x =>
                (x.Tags.Contains("cnBeta") || x.Tags.Contains("ItHome"))
                && x.CreateTime < date
                && x.CommentCount == 0
            )
            .OrderBy(x => x.CreateTime)
            .Take(limit)
            .ToListAsync();
        if (!list.Any())
        {
            return;
        }

        await mediator.Send(
            new RemoveImagesRequest
            {
                Images = list.SelectMany(x => x.ImagesAddress ?? []).ToList(),
            }
        );
        var ids = list.Select(x => x.Id);
        await repository.DeleteAsync(x => ids.Contains(x.Id));
        logger.LogInformation("旧数据删除完毕，共删除{Count}篇文章", list.Count);
    }

    public async Task<VmArticle> CreateArticleAsync(VmCreateArticleV4 article, VmUserInfo creator)
    {
        var author = mapper.Map<UserInfo>(creator);

        var htmlContent = article.Markdown.MarkdownToHtml(false);
        var htmlParse = new HtmlParser();
        var document = await htmlParse.ParseDocumentAsync(htmlContent);
        var imageElements = document.GetElementsByTagName("img");

        var entity = new Article
        {
            Author = author,
            HtmlContent = article.Content,
            Title = article.Title,
            Tags = article.Tags,
            Markdown = article.Markdown,
            CommentCount = 0,
            CreateTime = article.PublishTime ?? DateTime.Now,
            From = article.From,
            ImagesAddress = imageElements.GetElementsImageUrls(),
            Introduction = article.Introduction,
            MainImage = imageElements.FirstOrDefault()?.GetAttribute("src"),
            ViewCount = 0,
            LastUpdateTime = DateTime.Now,
            Categories = article.Categories,
            AdWeight = article.AdWeight,
        };

        await using (
            await distributedLockProvider.AcquireLockAsync($"Article.Create.Lock:{entity.Title}")
        )
        {
            if (await IsExistsAsync(entity.Title))
            {
                throw new ExistsException($"《{entity.Title}》已存在");
            }
            await repository.InsertAsync(entity);
        }
        return mapper.Map<VmArticle>(entity);
    }

    public async Task EditArticleAsync(VmEditArticleV4 article, VmUserInfo editor)
    {
        if (!ObjectId.TryParse(article.Id, out var id))
        {
            return;
        }
        var entity = await repository.FindAsync(id);
        if (entity == null)
        {
            return;
        }
        var author = mapper.Map<UserInfo>(editor);
        var request = new EditMarkdownRequest
        {
            Markdown = article.Markdown,
            OriginalMarkdown = entity.Markdown,
        };

        var images = await mediator.Send(request);

        var update = Builders<Article>
            .Update.Set(x => x.Title, article.Title)
            .Set(x => x.Markdown, article.Markdown)
            .Set(x => x.HtmlContent, article.Content)
            .Set(x => x.Tags, article.Tags)
            .Set(x => x.Introduction, article.Introduction)
            .Set(x => x.MainImage, images.FirstOrDefault())
            .Set(x => x.ImagesAddress, images)
            .Set(x => x.Author, author)
            .Set(x => x.LastUpdateTime, DateTime.Now);
        await repository.UpdateAsync(x => x.Id == id, update);
        //await ClearCacheAsync();
        var cacheKey = BuildCacheKey(nameof(GetArticleAsync), new { id = article.Id });
        await _fusionCache.RemoveAsync(cacheKey);
    }

    public async Task<int> GetTotalCountAsync()
    {
        checked
        {
            return (int)
                await repository.Collection.CountDocumentsAsync(FilterDefinition<Article>.Empty);
        }
    }

    public async Task<int> GetTodayCountAsync()
    {
        checked
        {
            var filter = Builders<Article>.Filter.Gte(x => x.CreateTime, DateTime.Now.Date);
            return (int)await repository.Collection.CountDocumentsAsync(filter);
        }
    }

    public async ValueTask ClearCacheAsync()
    {
        var removeTags = new[]
        {
            CachePrefixKey + nameof(GetTopArticlesAsync),
            CachePrefixKey + nameof(GetPagesAsync),
            CachePrefixKey + nameof(GetAllTagsAsync),
            CachePrefixKey + nameof(GetLatestAsync),
            CachePrefixKey + nameof(GetRandomArticlesAsync),
            CachePrefixKey + nameof(GetPublishArticlesAsync),
            ViewCountTag,
            CommentCountTag,
        };

        await _fusionCache.RemoveByTagAsync(removeTags);
    }

    /// <summary>
    /// 将缓存中的最新浏览量、评论数回填到文章列表中
    /// </summary>
    private async Task ApplyViewCountsAsync(IEnumerable<VmArticleMini>? articles)
    {
        if (articles == null)
        {
            return;
        }

        foreach (var article in articles)
        {
            if (string.IsNullOrWhiteSpace(article.Id))
            {
                continue;
            }

            article.ViewCount = await EnsureViewCountCacheAsync(article.Id, article.ViewCount);
            article.CommentCount = await EnsureCommentCountCacheAsync(
                article.Id,
                article.CommentCount
            );
        }
    }

    /// <summary>
    /// 将缓存中的最新浏览量、评论数回填到文章详情中
    /// </summary>
    private async Task ApplyViewCountAsync(VmArticle? article)
    {
        if (article == null || string.IsNullOrWhiteSpace(article.Id))
        {
            return;
        }

        article.ViewCount = await EnsureViewCountCacheAsync(article.Id, article.ViewCount);
        article.CommentCount = await EnsureCommentCountCacheAsync(article.Id, article.CommentCount);
    }

    /// <summary>
    /// 确保浏览量缓存存在，缺失时使用传入值初始化
    /// </summary>
    private async Task<int> EnsureViewCountCacheAsync(string articleId, int fallbackValue)
    {
        var cache = await _fusionCache.TryGetAsync<int>(BuildViewCountCacheKey(articleId));
        if (cache.HasValue)
        {
            return cache.Value;
        }

        await SetViewCountCacheAsync(articleId, fallbackValue);
        return fallbackValue;
    }

    /// <summary>
    /// 写入文章当前浏览量，并带上浏览量相关的缓存标签
    /// </summary>
    private ValueTask SetViewCountCacheAsync(string articleId, int viewCount)
    {
        return _fusionCache.SetAsync(
            BuildViewCountCacheKey(articleId),
            viewCount,
            options => options.SetDuration(CacheDefaultExpiration),
            [CachePrefixKey, ViewCountTag]
        );
    }

    /// <summary>
    /// 确保评论数缓存存在，缺失时使用传入值初始化
    /// </summary>
    private async Task<int> EnsureCommentCountCacheAsync(string articleId, int fallbackValue)
    {
        var cache = await _fusionCache.TryGetAsync<int>(BuildCommentCountCacheKey(articleId));
        if (cache.HasValue)
        {
            return cache.Value;
        }

        await SetCommentCountCacheAsync(articleId, fallbackValue);
        return fallbackValue;
    }

    /// <summary>
    /// 写入文章当前评论数，并带上评论数相关标签
    /// </summary>
    private ValueTask SetCommentCountCacheAsync(string articleId, int commentCount)
    {
        return _fusionCache.SetAsync(
            BuildCommentCountCacheKey(articleId),
            commentCount,
            options => options.SetDuration(CacheDefaultExpiration),
            [CachePrefixKey, CommentCountTag]
        );
    }

    /// <summary>
    /// 更新已缓存的文章详情对象里的浏览量，避免列表与详情不一致
    /// </summary>
    private async Task UpdateCachedArticleViewCountAsync(string articleId, int viewCount)
    {
        var cachedArticle = await TryGetFromCacheAsync<VmArticle?>(
            nameof(GetArticleAsync),
            new { id = articleId }
        );
        if (cachedArticle.HasValue && cachedArticle.Value != null)
        {
            cachedArticle.Value.ViewCount = viewCount;
            await SetCacheAsync(
                nameof(GetArticleAsync),
                cachedArticle.Value,
                new { id = articleId }
            );
        }
    }
}
⚠⚠    以下内容为AI分析的结果，请根据实际情况进行判断。

上述代码是一个 C# 类 ArticleService 的实现，主要用于处理与文章相关的操作。这个类实现了 IArticleService 接口，提供了一系列方法来管理和操作文章数据。以下是对代码中各个部分的详细解释：

1. 类的构造函数

ArticleService 的构造函数接受多个依赖项，包括：

  • IRepository<Article>：用于与文章数据进行交互的仓储接口。
  • IMediator：用于处理请求和发送消息的中介者。
  • IMapper：用于对象映射的工具。
  • ILogger<ArticleService>：用于记录日志的接口。
  • IDistributedLockProvider：用于分布式锁的提供者，确保在创建文章时的线程安全。
  • IHybridCachingProvider：用于缓存的提供者。

2. 主要功能方法

以下是类中定义的一些主要方法及其功能：

  • GetTopArticlesAsync：获取最近 days 天内的最受欢迎的文章，按查看次数排序，返回指定数量的文章。

  • GetRandomArticlesAsync：获取随机的文章，文章标签包含 "cnBeta" 或 "ItHome"，返回指定数量的文章。

  • GetPublishArticlesAsync：获取已发布的文章，过滤掉标签为 "cnBeta" 和 "ItHome" 的文章，或评论数大于零的文章。

  • GetPagesAsync：获取分页的文章列表，支持根据标题、作者和标签进行过滤。

  • GetAllTagsAsync：获取所有文章的标签，按字母顺序排序。

  • GetArticleAsync：根据文章 ID 获取单篇文章的详细信息。

  • ViewAsync：增加文章的查看次数。

  • GetLatestAsync：获取最新的文章，返回指定数量的文章。

  • IsExistsAsync：检查是否存在具有特定标题的文章。

  • NoExistsByFromAsync：检查给定的来源是否存在于文章中，返回不存在的来源。

  • DeleteAsync：根据文章 ID 删除文章，并删除与文章相关的图片。

  • DeleteOldCnBetaAsync：删除旧的 "cnBeta" 或 "ItHome" 标签的文章，条件是创建时间早于指定月份且评论数为零。

  • CreateArticleAsync：创建新文章，解析 Markdown 内容并提取图片地址，确保文章标题唯一。

  • EditArticleAsync：编辑现有文章，更新文章的各个字段，并处理图片的更新。

  • GetTotalCountAsync：获取文章的总数。

  • GetTodayCountAsync：获取今天创建的文章数量。

  • ClearCacheAsync：清除文章相关的缓存。

  • SearchAsync：根据关键词搜索文章，支持在标题和内容中进行正则匹配。

3. 错误处理

在多个方法中，使用了 ArgumentException 来处理无效的参数输入，例如负数或超出范围的值。

4. 日志记录

使用 ILogger 记录操作的日志，例如删除旧数据的数量。

5. 数据库操作

大部分方法使用了 MongoDB 的查询构建器（Builders<Article>）来构建查询条件，并通过 repository 进行异步数据库操作。

总结

ArticleService 类提供了一整套用于管理文章的功能，包括创建、编辑、删除、查询和搜索文章等操作，适用于一个内容管理系统或博客平台。通过依赖注入的方式，类的设计遵循了良好的软件工程原则，便于测试和维护。

loading