KM-Server-Milestone2/src/main/java/com/redxun/knowledge/service/KnowledgeServiceImpl.java

package com.redxun.knowledge.service;

import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.redxun.common.base.db.BaseDao;
import com.redxun.common.base.db.BaseService;
import com.redxun.common.base.db.PageHelper;
import com.redxun.common.base.search.QueryFilter;
import com.redxun.common.model.JPaasUser;
import com.redxun.common.service.impl.SuperServiceImpl;
import com.redxun.common.tool.IdGenerator;
import com.redxun.common.tool.StringUtils;
import com.redxun.dto.user.OsUserDto;
import com.redxun.knowledge.common.UserService;
import com.redxun.knowledge.entity.dao.*;
import com.redxun.knowledge.entity.dto.KnowledgeDto;
import com.redxun.knowledge.entity.vo.KnowledgeApprovalListVo;
import com.redxun.knowledge.entity.vo.KnowledgeApprovalVo;
import com.redxun.knowledge.entity.vo.KnowledgeCategoryAdminVo;
import com.redxun.knowledge.entity.vo.KnowledgeVo;
import com.redxun.knowledge.mapper.*;
import com.redxun.knowledge.utils.DeduplicationUtil;
import com.redxun.knowledge.utils.PageListUtils;
import com.redxun.search.service.SearchService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.*;
import java.util.stream.Collectors;

/**
 * [业务--知识表]业务服务类
 */
@Service
@SuppressWarnings({"all"})
@Slf4j
public class KnowledgeServiceImpl extends SuperServiceImpl<KnowledgeMapper, Knowledge> implements BaseService<Knowledge> {


    @Resource
    private KnowledgeMapper knowledgeMapper;

    @Resource
    private KnowledgeApprovalNodeMapper knowledgeApprovalNodeMapper;

    @Resource
    private KnowledgeApproveMapper knowledgeApproveMapper;

    @Resource
    private UserService userService;

    @Autowired
    private KnowledgeCategoryServiceImpl knowledgeCategoryService;

    @Autowired
    private BannerMapper bannerMapper;

    @Autowired
    private KnowledgeCategoryMapper knowledgeCategoryMapper;

    @Autowired
    private SearchService searchService;


    @Override
    public BaseDao<Knowledge> getRepository() {
        return knowledgeMapper;
    }

    /**
     * 查询全部维基知识
     */
    public List<Knowledge> findAllWiki(String categoryId) {
        QueryWrapper<Knowledge> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("CATEGORY_ID", categoryId);
        queryWrapper.eq("TYPE", 2);
        queryWrapper.eq("APPROVAL_STATUS",5);
        List<Knowledge> knowledgeWikiList = knowledgeMapper.selectList(queryWrapper);
        return knowledgeWikiList;
    }

    /**
     * 新增知识
     * @param knowledgeDto
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    public String create(KnowledgeDto knowledgeDto) {
        if (knowledgeDto != null) {
            Knowledge knowledge = new Knowledge();
            knowledge.setPkId(IdGenerator.getIdStr());
            knowledge.setTitles(knowledgeDto.getTitles());
            knowledge.setCategoryId(knowledgeDto.getCategoryId());
            knowledge.setType(knowledgeDto.getType());
            knowledge.setSummary(knowledgeDto.getSummary());
            knowledge.setAttachment(knowledgeDto.getAttachment());
            knowledge.setAttachmentName(knowledgeDto.getAttachmentName());
            knowledge.setAttachmentType(knowledgeDto.getAttachmentType());
            knowledge.setContent(knowledgeDto.getContent());
            knowledge.setUpdateBy(userService.queryLoginUser());
            //knowledge.setAuthor(knowledgeDto.getAuthor());
            //knowledge.setCreateBy(knowledgeDto.getCreateBy());

            JPaasUser user = userService.queryUser(userService.queryLoginUser());
            if (user != null) {
                knowledge.setAuthor(user.getFullName());
            }

            insert(knowledge);

            // 从知识审批节点表拉取审批节点
            List<KnowledgeApprovalNode> approvalVoList = knowledgeApprovalNodeMapper.selectList(new QueryWrapper<KnowledgeApprovalNode>().eq("IS_DEL", 0).orderByAsc("IS_FINAL", "CREATE_TIME_"));
            if (ObjectUtils.isNotEmpty(approvalVoList)) {
                KnowledgeApprovalNode node;
                for (int index = 0; index < approvalVoList.size(); index++) {
                    node = approvalVoList.get(index);
                    if (node != null) {
                        KnowledgeApprove knowledgeApprove = new KnowledgeApprove();
                        knowledgeApprove.setPkId(IdGenerator.getIdStr());
                        knowledgeApprove.setName(node.getName());
                        knowledgeApprove.setKnowledgerId(knowledge.getPkId());
                        knowledgeApprove.setApproverId(node.getApproverId());
                        knowledgeApprove.setApproverName(node.getApproverName());
                        knowledgeApprove.setApprovalBatch(1);
                        knowledgeApprove.setSort(index + 1);
                        knowledgeApprove.setIsFinal(node.getIsFinal());
                        knowledgeApprove.setCreateBy(userService.queryLoginUser());
                        knowledgeApprove.setCreateTime(new Date());

                        knowledgeApproveMapper.insert(knowledgeApprove);
                    }
                }
            }

            return knowledge.getPkId();
        }

        return "";
    }

    /**
     * 数据回显
     * @param pkId
     * @return
     */
    public KnowledgeVo info(String pkId,Integer flag) {
        Knowledge knowledge = get(pkId);
        if (knowledge == null){
            return null;
        }
        List<KnowledgeApprove> approvalVoList = knowledgeApproveMapper.selectList(new QueryWrapper<KnowledgeApprove>().eq("KNOWLEDGER_ID", pkId).orderByAsc("SORT"));
        List<KnowledgeApprovalVo> approvals = new ArrayList<>();
        // 审核节点
        if (ObjectUtils.isNotEmpty(approvalVoList)) {
            KnowledgeApprove approve = null;
            KnowledgeApprovalVo approvalVo = null;
            boolean isFirstNoneApprove = true;
            for (int index = 0; index < approvalVoList.size(); index++) {
                approve = approvalVoList.get(index);
                approvalVo = new KnowledgeApprovalVo();
                approvalVo.setPkId(approve.getPkId());
                approvalVo.setName(approve.getName());
                approvalVo.setApproverId(approve.getApproverId());
                approvalVo.setApproverName(approve.getApproverName());
                approvalVo.setActualApprover(approve.getActualApprover());
                approvalVo.setActualApproverName(approve.getActualApproverName());
                approvalVo.setApprovalTime(approve.getApprovalTime());
                approvalVo.setSort(approve.getSort());
                approvalVo.setRemark(approve.getRemark());
                // 审核状态 ：提交审核 审核通过 审核驳回
                if (approve.getResult() == null && isFirstNoneApprove) {
                    if (knowledge.getApprovalStatus() == 2 || knowledge.getApprovalStatus() == 4){
                        isFirstNoneApprove = false;
                        approvalVo.setApprovalStatus("");
                    } else {
                        isFirstNoneApprove = false;
                        approvalVo.setApprovalStatus("提交审核");
                    }
                } else {
                    if (approve.getResult() == null) {
                        approvalVo.setApprovalStatus("");
                    } else if (approve.getResult() == 0) {
                        approvalVo.setApprovalStatus("审核驳回");
                    } else if (approve.getResult() == 1) {
                        approvalVo.setApprovalStatus("审核通过");
                    }
                }
                approvals.add(approvalVo);
            }
        }
        KnowledgeVo knowledgeVo = new KnowledgeVo();
        if (knowledge != null) {
            knowledgeVo.setPkId(knowledge.getPkId());
            knowledgeVo.setCategoryId(knowledge.getCategoryId());
            knowledgeVo.setType(knowledge.getType());
            knowledgeVo.setTitles(knowledge.getTitles());
            knowledgeVo.setAuthor(knowledge.getAuthor());
            knowledgeVo.setContent(knowledge.getContent());
            knowledgeVo.setSummary(knowledge.getSummary());
            knowledgeVo.setAttachment(knowledge.getAttachment());
            knowledgeVo.setAttachmentName(knowledge.getAttachmentName());
            knowledgeVo.setCreateTime(knowledge.getCreateTime());
            knowledgeVo.setApprovalStatus(knowledge.getApprovalStatus());
            knowledgeVo.setCreateBy(knowledge.getCreateBy());
            knowledgeVo.setApprovals(approvals);
            knowledgeVo.setViews(knowledge.getViews());
            knowledgeVo.setOrganizationId(knowledge.getOrganizationId());
            knowledgeVo.setKnowledgeCategoryAdminVo(knowledgeCategoryService.findAllParentByCategoryId(knowledge.getCategoryId()));
        }
        if (flag != null && flag == 1){
            // 解析组织架构/职系/职等数据
            Map<String, Object> organizationIdMap = new HashMap<>();
            if (StringUtils.isNotEmpty(knowledge.getOrganizationId())){
                List<Map> mapList = JSON.parseArray(knowledge.getOrganizationId(), Map.class);
                for (int i = 0; i < mapList.size(); i++) {
                    Map maps = mapList.get(i);
                    maps.forEach((k,v) -> organizationIdMap.put((String) k,v));
                }
            }
            // 获取当前登录人的组织架构/职系/职等数据
            OsUserDto osUserDto = userService.queryOsUserDto(userService.queryLoginUser());
            String sequenceCode = osUserDto.getSequenceCode();
            String slyGrade = osUserDto.getSlyGrade();
            String deptId = osUserDto.getDeptId();
            // 如果知识最终审核通过,判断组织架构/职系/职等是否符合(前台判断)
            if (knowledge.getOrganizationId() == null){
                knowledgeMapper.updateViewsById(pkId);
                knowledgeVo.setIsOrganizationId(0);
            } else {
                // 如果职系,职等,组织架构id全部为空
                if (organizationIdMap.get("organizationId") == null && organizationIdMap.get("gradeId") == null &&
                        organizationIdMap.get("gradeLevelId") == null){
                    // 符合条件,增加点击量
                    knowledgeVo.setIsOrganizationId(0);
                    knowledgeMapper.updateViewsById(pkId);
                    return knowledgeVo;
                }
                // 如果职系,职等为空,组织架构id不为空
                if (organizationIdMap.get("organizationId") != null && organizationIdMap.get("gradeId") == null &&
                        organizationIdMap.get("gradeLevelId") == null){
                    // 比较当前用户的组织架构是否符合条件
                    if (deptId.equals(organizationIdMap.get("organizationId"))){
                        // 符合条件,增加点击量
                        knowledgeVo.setIsOrganizationId(0);
                        knowledgeMapper.updateViewsById(pkId);
                        return knowledgeVo;
                    } else {
                        // 没有权限(不增加点击量)
                        knowledgeVo.setIsOrganizationId(1);
                        return null;
                    }
                }

                // 如果组织架构id,职等为空,职系不为空
                if (organizationIdMap.get("organizationId") == null && organizationIdMap.get("gradeId") != null &&
                        organizationIdMap.get("gradeLevelId") == null){
                    // 比较当前用户的职系是否符合条件
                    if (sequenceCode.equals(organizationIdMap.get("gradeId"))){
                        // 符合条件,增加点击量
                        knowledgeVo.setIsOrganizationId(0);
                        knowledgeMapper.updateViewsById(pkId);
                        return knowledgeVo;
                    } else {
                        // 没有权限(不增加点击量)
                        knowledgeVo.setIsOrganizationId(1);
                        return null;
                    }
                }

                // 如果组织架构id,职系为空,职等不为空
                if (organizationIdMap.get("organizationId") == null && organizationIdMap.get("gradeId") == null &&
                        organizationIdMap.get("gradeLevelId") != null){
                    // 比较当前用户的职系是否符合条件
                    if (slyGrade.equals(organizationIdMap.get("gradeLevelId"))){
                        // 符合条件,增加点击量
                        knowledgeVo.setIsOrganizationId(0);
                        knowledgeMapper.updateViewsById(pkId);
                        return knowledgeVo;
                    } else {
                        // 没有权限(不增加点击量)
                        knowledgeVo.setIsOrganizationId(1);
                        return null;
                    }
                }

                // 如果职等为空,组织架构id,职系不为空
                if (organizationIdMap.get("organizationId") != null && organizationIdMap.get("gradeId") != null &&
                        organizationIdMap.get("gradeLevelId") == null){
                    if (deptId.equals(organizationIdMap.get("organizationId")) && sequenceCode.equals(organizationIdMap.get("gradeId"))){
                        // 符合条件,增加点击量
                        knowledgeVo.setIsOrganizationId(0);
                        knowledgeMapper.updateViewsById(pkId);
                        return knowledgeVo;
                    } else {
                        // 没有权限(不增加点击量)
                        knowledgeVo.setIsOrganizationId(1);
                        return null;
                    }
                }

                // 如果职系为空,组织架构id,职等不为空
                if (organizationIdMap.get("organizationId") != null && organizationIdMap.get("gradeId") == null &&
                        organizationIdMap.get("gradeLevelId") != null){
                    if (deptId.equals(organizationIdMap.get("organizationId")) && slyGrade.equals(organizationIdMap.get("gradeLevelId"))){
                        // 符合条件,增加点击量
                        knowledgeVo.setIsOrganizationId(0);
                        knowledgeMapper.updateViewsById(pkId);
                        return knowledgeVo;
                    } else {
                        // 没有权限(不增加点击量)
                        knowledgeVo.setIsOrganizationId(1);
                        return null;
                    }
                }

                // 如果组织架构id为空,职系,职等不为空
                if (organizationIdMap.get("organizationId") == null && organizationIdMap.get("gradeId") != null &&
                        organizationIdMap.get("gradeLevelId") != null){
                    if (sequenceCode.equals(organizationIdMap.get("gradeId")) && slyGrade.equals(organizationIdMap.get("gradeLevelId"))){
                        // 符合条件,增加点击量
                        knowledgeVo.setIsOrganizationId(0);
                        knowledgeMapper.updateViewsById(pkId);
                        return knowledgeVo;
                    } else {
                        // 没有权限(不增加点击量)
                        knowledgeVo.setIsOrganizationId(1);
                        return null;
                    }
                }

                // 如果组织架构id,职系,职等都不为空
                if (organizationIdMap.get("organizationId") != null && organizationIdMap.get("gradeId") != null &&
                        organizationIdMap.get("gradeLevelId") != null){
                    if (deptId.equals(organizationIdMap.get("organizationId")) &&
                            sequenceCode.equals(organizationIdMap.get("gradeId")) &&
                            slyGrade.equals(organizationIdMap.get("gradeLevelId"))){
                        knowledgeVo.setIsOrganizationId(0);
                        // 符合条件,增加点击量
                        knowledgeMapper.updateViewsById(pkId);
                        return knowledgeVo;
                    } else {
                        // 没有权限(不增加点击量)
                        knowledgeVo.setIsOrganizationId(1);
                        return null;
                    }
                }
            }
        }
        return knowledgeVo;
    }

    /**
     * 查看全部知识
     * @param filter
     * @return
     */
    public IPage findAllKnowledge(QueryFilter filter) {
        Map<String, Object> params = PageHelper.constructParams(filter);
        IPage page = knowledgeMapper.findAllKnowledge(filter.getPage(), filter.getParams(), params);
        List<KnowledgeVo> knowledgeVoList = page.getRecords();
        knowledgeVoList.forEach(e -> {
            KnowledgeCategoryAdminVo knowledgeCategoryAdminVo = knowledgeCategoryService.findAllParentByCategoryId(e.getCategoryId());
            e.setKnowledgeCategoryAdminVo(knowledgeCategoryAdminVo);
            e.setOperatorName(userService.queryUser(e.getUpdateBy()).getFullName());
            Map<String, Object> map = userService.querySexAndPhoto(e.getCreateBy());
            e.setParams(map);
        });
        return page;
    }

    /**
     * 删除知识(若关联banner，则无法删除)
     * @param knowledgeId
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    public Boolean deleteKnowledge(String knowledgeId) {
        // 查看是否关联着banner
        Integer count = bannerMapper.selectCount(new QueryWrapper<Banner>().eq("KNOWLEDGE_ID", knowledgeId));
        if (count > 0){
            return false;
        }
        //Knowledge knowledge = knowledgeMapper.selectById(knowledgeId);
        //if (knowledge.getApprovalStatus() == 5){
        //    throw new RuntimeException("知识已通过,删除失败");
        //}
        // 把知识审批表中对应数据删除掉
        knowledgeApproveMapper.deleteByKnowledgeId(knowledgeId);
        knowledgeMapper.deleteKnowledge(knowledgeId);
        // 调用搜索平台删除接口(删除文件)
        String documentId = knowledgeMapper.selectById(knowledgeId).getDocumentId();
        if (StringUtils.isNotEmpty(documentId)){
            searchService.remove(documentId);
        }
        return true;
    }

    /**
     * 修改知识，如当前知识在审核状态，无法修改
     * @param entity
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public int update(Knowledge entity) {
        Knowledge knowledge = this.get(entity.getPkId());
        // 知识为待节点审核状态和待最终审核状态,修改失败;知识为最终审核通过,修改失败
        if (knowledge.getApprovalStatus() == 3 || knowledge.getApprovalStatus() == 1){
            throw new RuntimeException("知识正在审核中,无法修改");
        } else {
            //知识被驳回了,重新修改进行审核(批次加1)
            entity.setApprovalStatus(1);
            entity.setApprovalBatch(knowledge.getApprovalBatch() + 1);
            //删除原有的审批节点
            knowledgeApproveMapper.deleteByKnowledgeId(entity.getPkId());
            //重新拉取审核节点
            List<KnowledgeApprovalNode> approvalVoList = knowledgeApprovalNodeMapper.selectList(new QueryWrapper<KnowledgeApprovalNode>().eq("IS_DEL", 0).orderByAsc("IS_FINAL", "CREATE_TIME_"));
            if (ObjectUtils.isNotEmpty(approvalVoList)) {
                KnowledgeApprovalNode node;
                for (int index = 0; index < approvalVoList.size(); index++) {
                    node = approvalVoList.get(index);
                    if (node != null) {
                        KnowledgeApprove knowledgeApprove = new KnowledgeApprove();
                        knowledgeApprove.setPkId(IdGenerator.getIdStr());
                        knowledgeApprove.setName(node.getName());
                        knowledgeApprove.setKnowledgerId(knowledge.getPkId());
                        knowledgeApprove.setApproverId(node.getApproverId());
                        knowledgeApprove.setApproverName(node.getApproverName());
                        knowledgeApprove.setApprovalBatch(1);
                        knowledgeApprove.setSort(index + 1);
                        knowledgeApprove.setIsFinal(node.getIsFinal());
                        knowledgeApprove.setCreateBy(userService.queryLoginUser());
                        knowledgeApprove.setCreateTime(new Date());

                        knowledgeApproveMapper.insert(knowledgeApprove);
                    }
                }
            }
            // 清空组织架构/职系/职等信息
            entity.setOrganizationId("");
            return this.getRepository().updateById(entity);
        }

    }

    /**
     * 查找待审核的知识(分页查询，超过99条只显示前99条记录)
     * @param filter
     * @return
     */
    public IPage findAllAuditKnowledge(QueryFilter filter) {
        Map<String, Object> params = PageHelper.constructParams(filter);
        List<KnowledgeVo> knowledgeVoList = knowledgeMapper.findAllAuditKnowledge(filter.getParams(), params);
        // 根据知识Id进行数据分组
        Map<String, List<KnowledgeVo>> result =
                knowledgeVoList.stream().collect(Collectors.groupingBy(KnowledgeVo::getKnowledgerId));
        // 结果集
        List<KnowledgeVo> knowledgeVoArrayList = new ArrayList<>();
        // 遍历每组的数据
        Set<Map.Entry<String, List<KnowledgeVo>>> entries = result.entrySet();
        for (Map.Entry<String, List<KnowledgeVo>> entry : entries) {
            List<KnowledgeVo> value = entry.getValue();
            for (int i = 0; i < value.size(); i++) {
                // 判断审批结果是否为null(如果审批结果没有null，证明审批已结束;如果等于0，证明审批没通过)
                if (value.get(i).getResult() == null) {
                    value.get(i).setApprovalsFirst(knowledgeApproveMapper.selectById(value.get(i).getApproveId()));
                    if (i != 0) {
                        // 如果不是第一条数据,取前一条数据的审批时间
                        Date approvalTime = value.get(i - 1).getApprovalTime();
                        value.get(i).setApprovalTime(approvalTime);
                    }
                    // 把该记录加到结果集中
                    knowledgeVoArrayList.add(value.get(i));
                    break;
                }
            }
        }

        // 放入知识分类信息
        List<KnowledgeVo> collect = knowledgeVoArrayList.stream().
                sorted((t1, t2) -> t2.getCreateTime().compareTo(t1.getCreateTime())).collect(Collectors.toList());
        collect.forEach(e -> {
            String categoryId = e.getCategoryId();
            KnowledgeCategoryAdminVo knowledgeCategoryAdminVo = knowledgeCategoryService.findAllParentByCategoryId(categoryId);
            e.setKnowledgeCategoryAdminVo(knowledgeCategoryAdminVo);
        });

        // 判断当前登录人是否可以审核每一条知识
        String userNo = userService.queryLoginUsername();
        String deptId = userService.queryLoginUserDeptId();
        List<KnowledgeVo> collectResult = collect.stream().
                filter(e -> e.getApproverId().equals(userNo) || e.getApproverId().equals(deptId)).collect(Collectors.toList());
        Page pages = PageListUtils.getPages(filter.getPage().getCurrent(), filter.getPage().getSize(), collectResult);
        return pages;
    }

    /**
     * 根据分类id查询工作成果列表和经验案例列表
     * @param filter
     * @return
     */
    public IPage getAllKnowledgeByCategoryId(QueryFilter filter) {
        Map<String, Object> params = PageHelper.constructParams(filter);
        IPage page = knowledgeMapper.getAllKnowledgeByCategoryId(filter.getPage(), filter.getParams(), params);
        List<KnowledgeVo> knowledgeVoList = page.getRecords();
        knowledgeVoList.forEach(e -> {
            KnowledgeCategoryAdminVo knowledgeCategoryAdminVo = knowledgeCategoryService.findAllParentByCategoryId(e.getCategoryId());
            e.setKnowledgeCategoryAdminVo(knowledgeCategoryAdminVo);
        });
        List<KnowledgeVo> result = new ArrayList<>(knowledgeVoList);
        knowledgeVoList.forEach(e -> {
            //把一级分类下的分类的知识加入返回结果集
            KnowledgeCategory knowledgeCategory = knowledgeCategoryMapper.selectById(e.getCategoryId());
            KnowledgeCategoryAdminVo knowledgeCategoryAdminVo = new KnowledgeCategoryAdminVo();
            BeanUtils.copyProperties(knowledgeCategory,knowledgeCategoryAdminVo);
            knowledgeCategoryAdminVo.setLevel(1);
            List<KnowledgeCategoryAdminVo> childrens = knowledgeCategoryService.findChildrens(knowledgeCategoryAdminVo);
            childrens.forEach(children -> {
                List<Knowledge> knowledgeList = this.baseMapper.selectList(new QueryWrapper<Knowledge>().eq("CATEGORY_ID", children.getPkId()));
                List<KnowledgeVo> collect = knowledgeList.stream().map(h -> {
                    KnowledgeVo knowledgeVo = new KnowledgeVo();
                    BeanUtils.copyProperties(h, knowledgeVo);
                    return knowledgeVo;
                }).collect(Collectors.toList());

                collect.forEach(g -> {
                    KnowledgeCategoryAdminVo knowledgeCategoryAdminVos = knowledgeCategoryService.findAllParentByCategoryId(g.getCategoryId());
                    g.setKnowledgeCategoryAdminVo(knowledgeCategoryAdminVos);
                });

                result.addAll(collect);
            });
        });
        // 按照浏览量降序排序
        List<KnowledgeVo> collect = result.stream().
                sorted((t1, t2) -> t2.getViews().compareTo(t1.getViews())).
                map(e -> {
                    Map<String, Object> map = userService.querySexAndPhoto(e.getCreateBy());
                    e.setParams(map);
                    return e;
                }).
                collect(Collectors.toList());
        page.setRecords(collect);
        page.setTotal(collect.size());
        return page;
    }

    /**
     * 获取当前人未审核知识的数量
     * @return
     */
    public Integer getAuditKnowledgeSum() {
        List<KnowledgeVo> knowledgeVoList = knowledgeMapper.countAuditKnowledge();
        // 根据知识Id进行数据分组
        Map<String, List<KnowledgeVo>> result =
                knowledgeVoList.stream().collect(Collectors.groupingBy(KnowledgeVo::getKnowledgerId));
        // 结果集
        List<KnowledgeVo> knowledgeVoArrayList = new ArrayList<>();
        // 遍历每组的数据
        Set<Map.Entry<String, List<KnowledgeVo>>> entries = result.entrySet();
        for (Map.Entry<String, List<KnowledgeVo>> entry : entries) {
            List<KnowledgeVo> value = entry.getValue();
            for (int i = 0; i < value.size(); i++) {
                // 判断审批结果是否为null(如果审批结果没有null，证明审批已结束;如果等于0，证明审批没通过)
                if (value.get(i).getResult() == null) {
                    if (i != 0) {
                        // 如果不是第一条数据,取前一条数据的审批时间
                        Date approvalTime = value.get(i - 1).getApprovalTime();
                        value.get(i).setApprovalTime(approvalTime);
                        // 把该记录加到结果集中
                        knowledgeVoArrayList.add(value.get(i));
                        break;
                    }
                }
            }
        }
        String userNo = userService.queryLoginUsername();
        String deptId = userService.queryLoginUserDeptId();
        List<KnowledgeVo> collectResult = knowledgeVoArrayList.stream().
                filter(e -> e.getApproverId().equals(userNo) || e.getApproverId().equals(deptId)).collect(Collectors.toList());
        if (collectResult.size() >= 99){
            return 99;
        } else if (collectResult.size() <= 0){
            return 0;
        }else {
            return collectResult.size();
        }
    }

    /**
     * 前台获取登录人上传文件数量
     * @return
     */
    public Integer getKnowledgeSum() {
        LambdaQueryWrapper<Knowledge> wrapper = new LambdaQueryWrapper<>();
        String loginUser = userService.queryLoginUser();
        wrapper.eq(Knowledge::getApprovalStatus,5).eq(Knowledge::getCreateBy,loginUser);
        return knowledgeMapper.selectCount(wrapper);
    }
}