Masuit.MyBlogs/src/Masuit.MyBlogs.Core/Infrastructure/Services/PostService.cs

using System.Collections.Frozen;
using AngleSharp;
using AngleSharp.Dom;
using AngleSharp.Html.Parser;
using AutoMapper;
using AutoMapper.QueryableExtensions;
using Masuit.LuceneEFCore.SearchEngine;
using Masuit.LuceneEFCore.SearchEngine.Interfaces;
using Masuit.MyBlogs.Core.Infrastructure.Repository.Interface;
using Masuit.Tools.Html;
using PanGu;
using PanGu.HighLight;
using System.Reflection;
using System.Text.RegularExpressions;
using EFCoreSecondLevelCacheInterceptor;
using FreeRedis;
using Configuration = AngleSharp.Configuration;

namespace Masuit.MyBlogs.Core.Infrastructure.Services;

public sealed class PostService(IPostRepository repository, ISearchEngine<DataContext> searchEngine, ILuceneIndexSearcher searcher, IRedisClient cacheManager, ICategoryRepository categoryRepository, IMapper mapper, IPostTagsRepository postTagsRepository) : BaseService<Post>(repository, searchEngine, searcher), IPostService
{
    /// <summary>
    /// 文章高亮关键词处理
    /// </summary>
    /// <param name="p"></param>
    /// <param name="keyword"></param>
    public async Task Highlight(Post p, string keyword)
    {
        try
        {
            var simpleHtmlFormatter = new SimpleHTMLFormatter("<span style='color:red;background-color:yellow;font-size: 1.1em;font-weight:700;'>", "</span>");
            var highlighter = new Highlighter(simpleHtmlFormatter, new Segment()) { FragmentSize = int.MaxValue };
            keyword = Regex.Replace(keyword, @"<|>|\(|\)|\{|\}|\[|\]", " ");
            var keywords = Searcher.CutKeywords(keyword);
            var context = BrowsingContext.New(Configuration.Default);
            var document = await context.OpenAsync(req => req.Content(p.Content));
            var elements = document.DocumentElement.GetElementsByTagName("p");
            foreach (var e in elements)
            {
                for (var index = 0; index < e.ChildNodes.Length; index++)
                {
                    var node = e.ChildNodes[index];
                    bool handled = false;
                    foreach (var s in keywords)
                    {
                        string frag;
                        if (!handled && node.TextContent.Contains(s, StringComparison.CurrentCultureIgnoreCase) && !string.IsNullOrEmpty(frag = highlighter.GetBestFragment(s, node.TextContent)))
                        {
                            switch (node)
                            {
                                case IElement el:
                                    el.InnerHtml = frag;
                                    handled = true;
                                    break;

                                case IText t:
                                    var parser = new HtmlParser();
                                    var parseDoc = parser.ParseDocument(frag).Body;
                                    e.ReplaceChild(parseDoc, t);
                                    handled = true;
                                    break;
                            }
                        }
                    }
                }
            }
            p.Content = document.Body.InnerHtml;
        }
        catch
        {
            // ignored
        }
    }

    public SearchResult<PostDto> SearchPage(Expression<Func<Post, bool>> whereBase, int page, int size, string keyword)
    {
        var cacheKey = $"search:{keyword}:{page}:{size}";
        return cacheManager.GetOrAdd(cacheKey, () =>
        {
            var searchResult = SearchEngine.ScoredSearch<Post>(BuildSearchOptions(page, size, keyword));
            var entities = searchResult.Results.Where(s => s.Entity.Status == Status.Published).DistinctBy(s => s.Entity.Id).ToList();
            var ids = entities.Select(s => s.Entity.Id).ToArray();
            var dic = GetQuery(whereBase.And(p => ids.Contains(p.Id) && p.LimitMode != RegionLimitMode.OnlyForSearchEngine)).ProjectTo<PostDto>(mapper.ConfigurationProvider).ToFrozenDictionary(p => p.Id);
            var posts = entities.Where(s => dic.ContainsKey(s.Entity.Id)).Select(s => dic[s.Entity.Id]).ToList();
            var simpleHtmlFormatter = new SimpleHTMLFormatter("<span style='color:red;background-color:yellow;font-size: 1.1em;font-weight:700;'>", "</span>");
            var highlighter = new Highlighter(simpleHtmlFormatter, new Segment()) { FragmentSize = 200 };
            var keywords = Searcher.CutKeywords(keyword);
            HighlightSegment(posts, keywords, highlighter);
            SolvePostsCategory(posts);
            return new SearchResult<PostDto>()
            {
                Results = posts,
                Elapsed = searchResult.Elapsed,
                Total = searchResult.TotalHits
            };
        }, TimeSpan.FromMinutes(10));
    }

    public void SolvePostsCategory(IList<PostDto> posts)
    {
        var cids = posts.Select(p => p.CategoryId).Distinct().ToArray();
        var categories = categoryRepository.GetQuery(c => cids.Contains(c.Id)).Include(c => c.Parent).ToFrozenDictionary(c => c.Id);
        posts.ForEach(p => p.Category = mapper.Map<CategoryDto_P>(categories[p.CategoryId]));
    }

    /// <summary>
    /// 高亮截取处理
    /// </summary>
    /// <param name="posts"></param>
    /// <param name="keywords"></param>
    /// <param name="highlighter"></param>
    private static void HighlightSegment(IList<PostDto> posts, List<string> keywords, Highlighter highlighter)
    {
        foreach (var p in posts)
        {
            p.Content = p.Content.RemoveHtmlTag();
            foreach (var s in keywords)
            {
                string frag;
                if (p.Title.Contains(s) && !string.IsNullOrEmpty(frag = highlighter.GetBestFragment(s, p.Title)))
                {
                    p.Title = frag;
                    break;
                }
            }

            bool handled = false;
            foreach (var s in keywords)
            {
                string frag;
                if (p.Content.Contains(s) && !string.IsNullOrEmpty(frag = highlighter.GetBestFragment(s, p.Content)))
                {
                    p.Content = frag;
                    handled = true;
                    break;
                }
            }

            if (p.Content.Length > 200 && !handled)
            {
                p.Content = p.Content[..200];
            }
        }
    }

    private static SearchOptions BuildSearchOptions(int page, int size, string keyword)
    {
        keyword = Regex.Replace(keyword, @":\s+", ":");
        var fields = new List<string>();
        var newkeywords = new List<string>();
        foreach (var item in keyword.Split(' ', '　').Where(s => s.Contains(new[] { ":", "：" })))
        {
            var part = item.Split(':', '：');
            var field = typeof(Post).GetProperty(part[0], BindingFlags.IgnoreCase)?.Name;
            if (!string.IsNullOrEmpty(field))
            {
                fields.Add(field);
            }

            newkeywords.Add(part[1]);
        }

        var searchOptions = fields.Any() ? new SearchOptions(newkeywords.Join(" "), page, size, fields.Join(",")) : new SearchOptions(keyword, page, size, typeof(Post));
        if (keyword.Contains(new[] { " ", ",", ";" }))
        {
            searchOptions.Score = 0.3f;
        }

        return searchOptions;
    }

    /// <summary>
    /// 文章所有tag
    /// </summary>
    /// <returns></returns>
    public FrozenDictionary<string, int> GetTags()
    {
        return postTagsRepository.GetAll(t => t.Count, false).Cacheable().ToFrozenDictionary(g => g.Name, g => g.Count);
    }

    /// <summary>
    /// 添加实体并保存
    /// </summary>
    /// <param name="t">需要添加的实体</param>
    /// <returns>添加成功</returns>
    public override Post AddEntitySaved(Post t)
    {
        t = base.AddEntity(t);
        SearchEngine.SaveChanges(t.Status == Status.Published);
        return t;
    }

    /// <summary>
    /// 添加实体并保存（异步）
    /// </summary>
    /// <param name="t">需要添加的实体</param>
    /// <returns>添加成功</returns>
    public override Task<int> AddEntitySavedAsync(Post t)
    {
        base.AddEntity(t);
        return SearchEngine.SaveChangesAsync(t.Status == Status.Published);
    }

    /// <summary>
    /// 根据ID删除实体并保存
    /// </summary>
    /// <param name="id">实体id</param>
    /// <returns>删除成功</returns>
    public override bool DeleteById(int id)
    {
        DeleteEntity(GetById(id));
        return SearchEngine.SaveChanges() > 0;
    }

    /// <summary>
    /// 根据ID删除实体并保存（异步）
    /// </summary>
    /// <param name="id">实体id</param>
    /// <returns>删除成功</returns>
    public override Task<int> DeleteByIdAsync(int id)
    {
        base.DeleteById(id);
        return SearchEngine.SaveChangesAsync();
    }

    /// <summary>
    /// 删除多个实体并保存（异步）
    /// </summary>
    /// <param name="list">实体集合</param>
    /// <returns>删除成功</returns>
    public override Task<int> DeleteEntitiesSavedAsync(IEnumerable<Post> list)
    {
        base.DeleteEntities(list);
        return SearchEngine.SaveChangesAsync();
    }

    /// <summary>
    /// 根据条件删除实体
    /// </summary>
    /// <param name="where">查询条件</param>
    /// <returns>删除成功</returns>
    public override int DeleteEntitySaved(Expression<Func<Post, bool>> where)
    {
        base.DeleteEntity(where);
        return SearchEngine.SaveChanges();
    }

    /// <summary>
    /// 删除实体并保存
    /// </summary>
    /// <param name="t">需要删除的实体</param>
    /// <returns>删除成功</returns>
    public override bool DeleteEntitySaved(Post t)
    {
        base.DeleteEntity(t);
        return SearchEngine.SaveChanges() > 0;
    }

    /// <summary>
    /// 根据条件删除实体
    /// </summary>
    /// <param name="where">查询条件</param>
    /// <returns>删除成功</returns>
    public override Task<int> DeleteEntitySavedAsync(Expression<Func<Post, bool>> where)
    {
        base.DeleteEntity(where);
        return SearchEngine.SaveChangesAsync();
    }

    /// <summary>
    /// 统一保存的方法
    /// </summary>
    /// <returns>受影响的行数</returns>
    public int SaveChanges(bool flushIndex)
    {
        return flushIndex ? SearchEngine.SaveChanges() : base.SaveChanges();
    }

    /// <summary>
    /// 统一保存数据
    /// </summary>
    /// <returns>受影响的行数</returns>
    public async Task<int> SaveChangesAsync(bool flushIndex)
    {
        return flushIndex ? await SearchEngine.SaveChangesAsync() : await base.SaveChangesAsync();
    }
}