hotline/src/Hotline/KnowledgeBase/KnowledgeDomainService.cs

using Hotline.FlowEngine.Workflows;
using Hotline.Settings;
using Hotline.Share.Dtos.Knowledge;
using Hotline.Share.Enums.KnowledgeBase;
using MapsterMapper;
using SqlSugar;
using XF.Domain.Dependency;
using XF.Domain.Exceptions;

namespace Hotline.KnowledgeBase
{
    public class KnowledgeDomainService : IKnowledgeDomainService, IScopeDependency
    {
        private readonly IKnowledgeRepository _knowledgeRepository;
        private readonly IKnowledgeTempRepository _knowledgeTempRepository;
        private readonly IMapper _mapper;
        private readonly IKnowledgePVRepository _knowledgePVRepository;
        private readonly IKnowledgeWorkFlowRepository _knowledgeWorkFlowRepository;
        private readonly IWorkflowDomainService _workflowDomainService;
        private readonly IKnowledgeApplyRepository _knowledgeApplyRepository;

        /// <summary>
        /// 
        /// </summary>
        /// <param name="knowledgeRepository"></param>
        /// <param name="knowledgeTempRepository"></param>
        /// <param name="mapper"></param>
        /// <param name="knowledgePVRepository"></param>
        /// <param name="knowledgeWorkFlowRepository"></param>
        /// <param name="workflowDomainService"></param>
        public KnowledgeDomainService(IKnowledgeRepository knowledgeRepository, IKnowledgeTempRepository knowledgeTempRepository, IMapper mapper, IKnowledgePVRepository knowledgePVRepository, IKnowledgeWorkFlowRepository knowledgeWorkFlowRepository
           , IWorkflowDomainService workflowDomainService, IKnowledgeApplyRepository knowledgeApplyRepository)
        {
            _knowledgeRepository = knowledgeRepository;
            _mapper = mapper;
            _knowledgeTempRepository = knowledgeTempRepository;
            _knowledgePVRepository = knowledgePVRepository;
            _knowledgeWorkFlowRepository = knowledgeWorkFlowRepository;
            _workflowDomainService = workflowDomainService;
            _knowledgeApplyRepository = knowledgeApplyRepository;
        }

        /// <summary>
        /// 知识库-查询详情-增加浏览量
        /// </summary>
        /// <param name="Id"></param>
        /// <returns></returns>
        public async Task<Knowledge> KnowledgeInfo(string Id, CancellationToken cancellationToken)
        {
            var know = await _knowledgeRepository.GetAsync(Id, cancellationToken);
            if (know is null)
                throw UserFriendlyException.SameMessage("知识查询失败！");
            return know;
        }

        /// <summary>
        /// 浏览记录写入
        /// </summary>
        /// <param name="know"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task KnowledgePvIncreaseAsync(Knowledge know, CancellationToken cancellationToken)
        {
            //写入浏览记录
            KnowledgePv knowledgePv = new()
            {
                CreationTime = DateTime.Now,
                KnowledgeCode = know.Code
            };
            //浏览记录写入
            await _knowledgePVRepository.AddAsync(knowledgePv, cancellationToken);

            //修改浏览量
            know.PageView++;
            //修改点击量
            await _knowledgeRepository.UpdateAsync(know, cancellationToken);
        }

        /// <summary>
        /// 知识审批主表
        /// </summary>
        /// <param name="knowId">知识Id</param>
        /// <param name="workFlowId">流程ID</param>
        /// <param name="eKnowledgeApplyType">申请类型</param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task<string> AddWorkFlow(string knowId, string workFlowId, EKnowledgeApplyType eKnowledgeApplyType, CancellationToken cancellationToken)
        {
            KnowledgeWorkFlow workFlow = new()
            {
                KnowledgeId = knowId,
                WorkflowModuleStatus = eKnowledgeApplyType,
                WorkFlowApplyStatus = EKnowledgeWorkFlowStatus.Auditing,
                WorkflowId = workFlowId
            };
            return await _knowledgeWorkFlowRepository.AddAsync(workFlow, cancellationToken);
        }

        /// <summary>
        /// 修改流程ID
        /// </summary>
        /// <param name="knowledgeId"></param>
        /// <param name="workFlowId"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task UpdateWorkFlowId(string knowledgeId, string workFlowId, CancellationToken cancellationToken)
        {
            var knowledge = await _knowledgeRepository.GetAsync(knowledgeId, cancellationToken);
            knowledge.WorkflowId = workFlowId;
            await _knowledgeRepository.UpdateAsync(knowledge, cancellationToken);
        }

        /// <summary>
        /// 知识库-新增
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public async Task<string> KnowledgeAdd(AddKnowledgeDto dto, CancellationToken cancellationToken)
        {
            var kn = _mapper.Map<Knowledge>(dto);
            //知识草稿ID如果不为空，则表示是草稿箱的数据
            if (!string.IsNullOrEmpty(dto.Code))
            {
                //移除草稿箱数据
                await _knowledgeTempRepository.RemoveAsync(p => p.Code == dto.Code, false, cancellationToken);
            }
            //如果草稿箱不存在数据，也就是Code为空，从新生成Code
            if (string.IsNullOrEmpty(kn.Code))
                kn.Code = Convert.ToInt64((DateTime.Now - new DateTime(1970, 1, 1, 0, 0, 0, 0)).TotalSeconds).ToString();
            kn.Status = EKnowledgeStatus.Auditing;
            var knowledgeId = await _knowledgeRepository.AddAsync(kn, cancellationToken);
            if (!string.IsNullOrEmpty(dto.Applies))
            {
                var apply = await _knowledgeApplyRepository.GetAsync(p => p.Id == dto.Applies, cancellationToken);
                if (apply != null)
                {
                    apply.KnowledgeId = knowledgeId;
                    await _knowledgeApplyRepository.UpdateAsync(apply, cancellationToken);
                }
            }

            return knowledgeId;
        }

        /// <summary>
        /// 知识库-修改
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public async Task<string> KnowledgeUpdate(UpdateKnowledgeDto dto, CancellationToken cancellationToken)
        {
            //知识修改逻辑
            //如果可以修改，此条数据不动，重新写入一条新数据，知识编号不变，版本号+1，审批通过以后在数据交换

            var know = await _knowledgeRepository.GetAsync(dto.Id, cancellationToken);
            if (know is null || know.IsDeleted)
                throw UserFriendlyException.SameMessage("无效知识");
            //审批中数据不能处理
            if (know.Status == EKnowledgeStatus.Auditing)
                throw UserFriendlyException.SameMessage("审批中数据不能修改");

            var knowledge = _mapper.Map<Knowledge>(dto);
            knowledge.Code = know.Code;
            knowledge.PageView = know.PageView;
            knowledge.Status = EKnowledgeStatus.Auditing;
            knowledge.Id = "";
            knowledge.Version = 0;

            var knowledgeId = await _knowledgeRepository.AddAsync(knowledge, cancellationToken);
            if (!string.IsNullOrEmpty(dto.Applies))
            {
                var apply = await _knowledgeApplyRepository.GetAsync(p => p.Id == dto.Applies, cancellationToken);
                if (apply != null)
                {
                    apply.KnowledgeId = knowledgeId;
                    await _knowledgeApplyRepository.UpdateAsync(apply, cancellationToken);
                }
            }

            //新增一条数据
            return knowledgeId;

        }

        /// <summary>
        /// 撤销
        /// </summary>
        /// <param name="workFlowId"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task KnowledgeRevoke(string workFlowId, CancellationToken cancellationToken)
        {
            var knowWorkFlow = await _knowledgeWorkFlowRepository.GetAsync(p => p.WorkflowId == workFlowId, cancellationToken);
            if (knowWorkFlow is null)
                throw UserFriendlyException.SameMessage("无效知识审批");
            if (knowWorkFlow.WorkFlowApplyStatus != EKnowledgeWorkFlowStatus.Auditing)
                throw UserFriendlyException.SameMessage("只有审批中的知识才能撤回！");

            knowWorkFlow.WorkFlowApplyStatus = EKnowledgeWorkFlowStatus.Revoke;
            await _knowledgeWorkFlowRepository.UpdateAsync(knowWorkFlow);

            switch (knowWorkFlow.WorkflowModuleStatus)
            {
                case EKnowledgeApplyType.Add:
                case EKnowledgeApplyType.Update:
                    //查询知识
                    var knowledge = await _knowledgeRepository.GetAsync(p => p.WorkflowId == workFlowId, cancellationToken);
                    if (knowledge != null)
                    {
                        //将知识保存到草稿箱
                        var tempKnow = _mapper.Map<KnowledgeTemp>(knowledge);
                        await _knowledgeTempRepository.AddAsync(tempKnow, cancellationToken);

                        knowledge.Status = EKnowledgeStatus.Revert;
                        //删除现有知识
                        await _knowledgeRepository.UpdateAsync(knowledge, cancellationToken);
                    }
                    break;
            }
            //调用终止流程
            await _workflowDomainService.TerminateAsync(workFlowId, cancellationToken);
        }

        /// <summary>
        /// 获取关键词
        /// </summary>
        /// <returns></returns>
        public async Task<List<string>> GetKeyWord()
        {
            var temp = await _knowledgeRepository
              .Queryable()
              .Where(p => p.IsDeleted == false && p.Status == EKnowledgeStatus.OnShelf)
              .Select((p) => new
              {
                  index = SqlFunc.RowNumber($"{p.Version} desc ", $"{p.Code}"),
                  p.Version,
                  p.PageView,
                  p.Keywords
              })
           //将结果合并成一个表
           .MergeTable()
           //取第一条数据
           .Where(d => d.index == 1 && d.Keywords != null && d.Keywords != "")
           //根据点击量在排序
           .OrderByDescending(p => p.PageView)
           .Take(10)//取前10条
           .ToListAsync();

            //将数据组装到集合
            List<string> strList = new();
            temp.ForEach(p =>
            {
                if (!string.IsNullOrEmpty(p.Keywords))
                    strList.AddRange(p.Keywords.Split(',').ToList());//添加数据
            });

            //取10条数据返回
            return strList.Distinct().Take(10).ToList();
        }

        /// <summary>
        /// 流程审批完成，处理知识状态
        /// </summary>
        /// <param name="workflow"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        /// <exception cref="UserFriendlyException"></exception>
        public async Task EndWorkKnowledge(Workflow workflow, CancellationToken cancellationToken)
        {
            var knowledge = await _knowledgeRepository.GetAsync(p => p.WorkflowId == workflow.Id, cancellationToken);
            if (knowledge == null)
                throw new UserFriendlyException($"知识查询失败, workflowId: {workflow.Id}", "无效流程编号");

            //修改主表审批状态
            var workFlow = await _knowledgeWorkFlowRepository.GetAsync(p => p.WorkflowId == workflow.Id, cancellationToken);
            if (workFlow != null)
            {
                workFlow.HandleTime = DateTime.Now;
                workFlow.WorkFlowApplyStatus = EKnowledgeWorkFlowStatus.Success;
                await _knowledgeWorkFlowRepository.UpdateAsync(workFlow, cancellationToken);
            }
            switch (workflow.ModuleCode)
            {
                case WorkflowModuleConsts.KnowledgeAdd://新增
                    //修改知识状态为已上架
                    knowledge.Status = EKnowledgeStatus.OnShelf;
                    knowledge.OnShelfTime = System.DateTime.Now;
                    await _knowledgeRepository.UpdateAsync(knowledge, cancellationToken);
                    break;
                case WorkflowModuleConsts.KnowledgeUpdate://修改
                    //处理知识版本号
                    //根据Code查询目前使用的版本号，版本号+1
                    var oldKnowledge = await _knowledgeRepository
                        .Queryable()
                        .Where(p => p.Code == knowledge.Code && p.Status != EKnowledgeStatus.Auditing && p.Status != EKnowledgeStatus.Failed && p.IsDeleted == false)
                        .OrderByDescending(p => p.Version)
                        .Take(1)
                        .FirstAsync();
                    if (oldKnowledge == null)
                        knowledge.Version = 1;
                    else
                        knowledge.Version = oldKnowledge.Version + 1;
                    //修改知识状态为已上架
                    knowledge.Status = EKnowledgeStatus.OnShelf;
                    knowledge.OnShelfTime = System.DateTime.Now;
                    await _knowledgeRepository.UpdateAsync(knowledge, cancellationToken);
                    break;

                case WorkflowModuleConsts.KnowledgeDelete://删除
                    //知识先下架，在删除                                       
                    knowledge.Status = EKnowledgeStatus.OffShelf;
                    knowledge.OffShelfTime = System.DateTime.Now;
                    knowledge.WorkflowId = workflow.Id;
                    await _knowledgeRepository.UpdateAsync(knowledge, cancellationToken);
                    //删除知识
                    await _knowledgeRepository.RemoveAsync(p => p.Code == knowledge.Code, true, cancellationToken);
                    break;
            }
        }

    }
}