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.redxun.common.base.db.BaseDao;
import com.redxun.common.base.db.BaseService;
import com.redxun.common.base.db.PageHelper;
import com.redxun.common.base.entity.IUser;
import com.redxun.common.base.search.QueryFilter;
import com.redxun.common.constant.MBoolean;
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.common.utils.ContextUtil;
import com.redxun.dto.user.OsGroupDto;
import com.redxun.dto.user.OsUserDto;
import com.redxun.knowledge.album.entity.dao.AlbumCatalogueKnowledge;
import com.redxun.knowledge.album.mapper.AlbumCatalogueKnowledgeMapper;
import com.redxun.knowledge.common.MessageService;
import com.redxun.knowledge.common.UserService;
import com.redxun.knowledge.entity.dao.*;
import com.redxun.knowledge.entity.dto.KnowledgeDto;
import com.redxun.knowledge.entity.dto.OrganizationDto;
import com.redxun.knowledge.entity.dto.TransferAuthorDto;
import com.redxun.knowledge.entity.dto.TransferKnowledgeCategoryDto;
import com.redxun.knowledge.entity.vo.*;
import com.redxun.knowledge.map.entity.dao.MapContent;
import com.redxun.knowledge.map.mapper.MapContentMapper;
import com.redxun.knowledge.mapper.*;
import com.redxun.knowledge.utils.ObjectUtil;
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 org.springframework.util.CollectionUtils;

import javax.annotation.Resource;
import java.util.*;
import java.util.concurrent.atomic.AtomicBoolean;
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;

    @Autowired
    private ActionLogMapper actionLogMapper;

    @Autowired
    private MessageService messageService;

    @Autowired
    private KnowledgeApproveServiceImpl knowledgeApproveService;

    @Autowired
    private MapContentMapper mapContentMapper;

    @Autowired
    private AlbumCatalogueKnowledgeMapper albumCatalogueKnowledgeMapper;

    @Autowired
    private KnowledgeApprovalNodeServiceImpl knowledgeApprovalNodeService;

    @Autowired
    private KnowledgeCpMapper knowledgeCpMapper;

    @Autowired
    private KnowledgeAgentServiceImpl knowledgeAgentService;


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

    /**
     * 查询全部维基知识
     */
    public List<Knowledge> findAllWiki(String categoryId) {
        List<Knowledge> knowledgeWikiList = knowledgeMapper.findAllWiki(categoryId);
        return knowledgeWikiList;
    }

    /**
     * 新增知识
     *
     * @param knowledgeDto
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    public String create(KnowledgeDto knowledgeDto,KnowledgeCp knowledgecp) {
        if (knowledgeDto != null && knowledgecp != null){
            throw new RuntimeException("未知错误");
        }
        Knowledge knowledge = new Knowledge();
        IUser users = ContextUtil.getCurrentUser();
        if (knowledgeDto != null) {
            if (Objects.isNull(knowledgeCategoryMapper.selectById(knowledgeDto.getCategoryId())) && knowledgeDto.getIsDraft() == 1){
                throw new RuntimeException("输入的分类不存在,请重新输入");
            }
            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());
            if (knowledgeDto.getIsDraft() != null && knowledgeDto.getIsDraft() == 0){
                knowledge.setApprovalStatus(6);
                knowledge.setApprovalBatch(0);
                knowledge.setIsDraft(0);
            } else {
                knowledge.setApprovalStatus(1);
                knowledge.setApprovalBatch(1);
                knowledge.setIsDraft(1);
            }
            knowledge.setContent(knowledgeDto.getContent());
            knowledge.setCreateDepId(users.getDeptId());
            knowledge.setTenantId(users.getTenantId());
            knowledge.setCompanyId(users.getCompanyId());
            knowledge.setCreateBy(users.getUserId());
            knowledge.setCreateTime(new Date());
            knowledge.setUpdateBy(users.getUserId());
            knowledge.setUpdateTime(new Date());
            knowledge.setDownloadUserId(knowledgeDto.getDownloadUserId());
            knowledge.setDownloadDeptId(knowledgeDto.getDownloadDeptId());
            if (!ObjectUtil.valueAllNull(knowledgeDto.getOrganizationIds())){
                String organizationId = JSON.toJSON(knowledgeDto.getOrganizationIds()).toString();
                knowledge.setOrganizationId(organizationId);
            }
            JPaasUser user = userService.queryUser(userService.queryLoginUser());
            if (user != null) {
                knowledge.setAuthor(user.getFullName());
            }
            insert(knowledge);
        }

        if (knowledgecp != null){
            BeanUtils.copyProperties(knowledgecp,knowledge);
            insert(knowledge);
        }
        // 从知识审批节点表拉取审批节点(不是草稿则拉取)
        if (knowledge.getIsDraft() != null && knowledge.getIsDraft() == 1) {
            List<KnowledgeApprovalNodeVo> approvalVoList = getKnowledgeApprovalNode(knowledge.getCategoryId(),knowledge.getCreateBy());
            if (ObjectUtils.isNotEmpty(approvalVoList)) {
                KnowledgeApprovalNodeVo 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.setUpdateBy(users.getUserId());
                        knowledgeApprove.setSort(index + 1);
                        knowledgeApprove.setIsFinal(node.getIsFinal());
                        knowledgeApprove.setCreateBy(userService.queryLoginUser());
                        knowledgeApprove.setCreateTime(new Date());

                        knowledgeApproveMapper.insert(knowledgeApprove);
                    }
                }
            }
        }
        return knowledge.getPkId();
    }

    /**
     * 拉取审核流程
     * @param category
     * @return
     */
    private List<KnowledgeApprovalNodeVo> getKnowledgeApprovalNode(String category,String userId){
        List<KnowledgeApprovalNodeVo> knowledgeApprovalNodeVoList = knowledgeApprovalNodeService.findAllNodesByCategoryId(category,userId);
        return knowledgeApprovalNodeVoList;
    }

    /**
     * 数据回显
     *
     * @param pkId
     * @return
     */
    public KnowledgeVo info(String pkId, Integer flag) {
        Knowledge knowledge = get(pkId);
        if (knowledge == null) {
            return null;
        }

        if (flag != null && flag == 1 && knowledge.getApprovalStatus() != 5 && !knowledge.getCreateBy().equals(userService.queryLoginUser())){
            throw new RuntimeException("您查看的知识还未完成审核流程!");
        }

        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.setViews(knowledge.getViews());
            knowledgeVo.setDownloadUserId(knowledge.getDownloadUserId());
            knowledgeVo.setDownloadDeptId(knowledge.getDownloadDeptId());
            //组织架构解析后返回
            if (!StringUtils.isEmpty(knowledge.getOrganizationId())){
                OrganizationDto organizationDto = JSON.parseObject(knowledge.getOrganizationId(), OrganizationDto.class);
                knowledgeVo.setOrganizationIds(organizationDto);
            }
            if (!StringUtils.isEmpty(knowledge.getCategoryId())){
                knowledgeVo.setKnowledgeCategoryAdminVo(knowledgeCategoryService.findAllParentByCategoryId(knowledge.getCategoryId()));
            }
            //指定了附件下载权限会判断
            if (StringUtils.isNotEmpty(knowledge.getDownloadUserId()) || StringUtils.isNotEmpty(knowledge.getDownloadDeptId())){
                //附件下载权限
                knowledgeVo.setIsAllowDownload(isAllowDownload(knowledge.getDownloadUserId(),knowledge.getDownloadDeptId()));
                //附件可下载人员或部门字符串复制
                if (StringUtils.isNotEmpty(knowledge.getDownloadUserId())){
                    List<String> fullNameList = knowledgeMapper.selectFullNameByUserIds(knowledge.getDownloadUserId().split(","));
                    knowledgeVo.setDownloadUserName(fullNameList.stream().collect(Collectors.joining(",")));
                }
                if (StringUtils.isNotEmpty(knowledge.getDownloadDeptId())){
                    List<String> fullNameList = knowledgeMapper.selectFullNameByDeptIds(knowledge.getDownloadDeptId().split(","));
                    knowledgeVo.setDownloadDeptName(fullNameList.stream().collect(Collectors.joining(",")));
                }
            } else {
                knowledgeVo.setIsAllowDownload(0);
            }
            if (knowledge.getIsDraft() == 0){
                return knowledgeVo;
            }
        }

        List<KnowledgeApprove> approvalVoList = knowledgeApproveMapper.selectByKnowledgerId(pkId);
        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());
                //待审核记录且有两个领导
                String[] split = approve.getApproverId().split(",");
                if (approve.getResult() == null && split.length > 1){
                    String approverIdTager = knowledgeAgentService.hasLeaderMore(split);
                    approvalVo.setApproverId(approverIdTager);
                }
                //待审核记录且有代理人
                if (approve.getResult() == null && knowledgeAgentService.hasTager(approve)){
                    approvalVo.setApproverId(approve.getTagerNo());
                } else {
                    approvalVo.setApproverId(approve.getApproverId());
                }
                approvalVo.setActualApprover(approve.getActualApprover());
                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("审核通过");
                    }
                }
                //审核人名称赋值(有实际审核人赋值实际审核人，没有赋值待审核人)
                if (approve.getResult() == null){
                    String[] splitFinal = approve.getApproverId().split(",");
                    if (splitFinal.length > 1){
                        String approverNameTager = Arrays.asList(splitFinal).stream().map(h -> userService.queryByUsername(h).getFullName()).collect(Collectors.joining(","));
                        approvalVo.setApproverAndActualName(approverNameTager);
                    } else {
                        if (knowledgeAgentService.hasTager(approve)){
                            approvalVo.setApproverAndActualName(userService.queryByUsername(approvalVo.getApproverId()).getFullName());
                        } else {
                            approvalVo.setApproverAndActualName(approve.getApproverName());
                        }
                    }
                } else {
                    approvalVo.setApproverAndActualName(approve.getActualApproverName());
                }

                approvals.add(approvalVo);
            }
        }
        knowledgeVo.setApprovals(approvals);
        //权限处理(组织架构)(详情需要增加点击量)
        if (flag != null && flag == 1 && knowledgeVo.getApprovalStatus() == 5 && !knowledge.getCreateBy().equals(userService.queryLoginUser())) {
             knowledgeVo = parseOrganization(knowledge.getOrganizationId(), true, knowledgeVo);
        }
        if (knowledgeVo.getIsOrganizationId() != null && knowledgeVo.getIsOrganizationId() == 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 -> {
            if (!StringUtils.isEmpty(e.getCategoryId())) {
                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);

            // 权限处理(组织架构)(列表不需要增加点击量)
            if (e.getApprovalStatus() == 5) {
                e = parseOrganization(e.getOrganizationId(), false, e);
            }
            //登陆人是作者,有权限
            if (e.getCreateBy().equals(userService.queryLoginUser())){
                e.setIsOrganizationId(0);
            }
            //如果知识还没有人进行审核，支持撤回(第一个节点审核结果为空，可撤回)(草稿无法撤回)
            if (!filter.getParams().containsKey("isDraft")){
                String knowledgeId = e.getPkId();
                List<KnowledgeApprove> knowledgeApproveList = knowledgeApproveMapper.selectList(new QueryWrapper<KnowledgeApprove>().eq("KNOWLEDGER_ID", e.getPkId()));
                if(knowledgeApproveList.get(0).getResult() == null){
                    e.setIsWithdraw(0);
                } else {
                    e.setIsWithdraw(1);
                }
            } else {
                e.setIsWithdraw(1);
            }
            //指定了附件下载权限会判断
            if (StringUtils.isNotEmpty(e.getDownloadUserId()) || StringUtils.isNotEmpty(e.getDownloadDeptId())){
                //附件下载权限
                e.setIsAllowDownload(isAllowDownload(e.getDownloadUserId(),e.getDownloadDeptId()));
                //附件可下载人员或部门字符串复制
                if (StringUtils.isNotEmpty(e.getDownloadUserId())){
                    List<String> fullNameList = knowledgeMapper.selectFullNameByUserIds(e.getDownloadUserId().split(","));
                    e.setDownloadUserName(fullNameList.stream().collect(Collectors.joining(",")));
                }
                if (StringUtils.isNotEmpty(e.getDownloadDeptId())){
                    List<String> fullNameList = knowledgeMapper.selectFullNameByDeptIds(e.getDownloadDeptId().split(","));
                    e.setDownloadDeptName(fullNameList.stream().collect(Collectors.joining(",")));
                }
            }

        });
        return page;
    }

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

    /**
     * 修改知识，如当前知识在审核状态，无法修改
     *
     * @param entity
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public int update(Knowledge entity) {
        if (Objects.isNull(knowledgeCategoryMapper.selectById(entity.getCategoryId())) && entity.getIsDraft() == 1){
            throw new RuntimeException("输入的分类不存在,请重新输入");
        }
        Knowledge knowledge = this.get(entity.getPkId());
        //处理组织架构
        if (!ObjectUtil.valueAllNull(entity.getOrganizationIds())){
            String organizationId = JSON.toJSON(entity.getOrganizationIds()).toString();
            entity.setOrganizationId(organizationId);
        }
        // 知识为待节点审核状态和待最终审核状态,修改失败;知识为最终审核通过,修改失败
        if (knowledge.getApprovalStatus() == 3 || knowledge.getApprovalStatus() == 1) {
            return -1;
        } else {
            //是草稿,直接修改数据结束
            if (entity.getIsDraft() != null && entity.getIsDraft() == 0){
                entity.setApprovalStatus(6);
                IUser users = ContextUtil.getCurrentUser();
                entity.setUpdateBy(users.getUserId());
                entity.setUpdateTime(new Date());
                return this.getRepository().updateById(entity);
            }
            //知识被驳回了,重新修改进行审核(批次加1)
            entity.setApprovalStatus(1);
            entity.setViews(0);
            entity.setApprovalBatch(knowledge.getApprovalBatch() + 1);
            entity.setCreateBy(knowledge.getCreateBy());
            entity.setAuthor(knowledge.getAuthor());
            //删除原有的审批节点
            knowledgeApproveMapper.deleteByKnowledgeId(entity.getPkId());
            //重新拉取审核节点
            List<KnowledgeApprovalNodeVo> approvalVoList = getKnowledgeApprovalNode(entity.getCategoryId(),knowledge.getCreateBy());
            if (ObjectUtils.isNotEmpty(approvalVoList)) {
                KnowledgeApprovalNodeVo 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);
                    }
                }
            }
            // 组织架构/职系/职等信息
            if (ObjectUtil.valueAllNull(entity.getOrganizationIds())){
                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> resultList = new ArrayList<>();
        //按照时间排序
        List<KnowledgeVo> collect = knowledgeVoArrayList.stream().
                sorted((t1, t2) -> t2.getCreateTime().compareTo(t1.getCreateTime())).collect(Collectors.toList());
        // 权限判断
        // 判断当前登录人是否可以审核每一条知识
        String userNo = userService.queryLoginUsername();
        String userId = userService.queryLoginUser();
        //部门权限字符串
        List<String> deptAuthority = knowledgeApproveMapper.deptAuthority(userId);
        collect.forEach(e -> {
            String[] split = e.getApproverId().split(",");
            //处理默认节点有两个领导的情况(默认节点默认在第一位，sort=1)
            if (split.length > 1){
                String approverIdTager = knowledgeAgentService.hasLeaderMore(split);
                e.setApproverId(approverIdTager);
            }
            //判断是否有代理人
            if (hasTager(e)){
                e.setApproverId(e.getTagerNo());
            }
            boolean flag = false;
            for (int i = 0; i < deptAuthority.size(); i++) {
                if (deptAuthority.get(i).contains(e.getApproverId())) {
                    flag = true;
                    break;
                }
            }
            List<String> approverIdList = Arrays.asList(e.getApproverId().split(","));
            // 如果有权限
            if (approverIdList.contains(userNo) || flag) {
                resultList.add(e);
            }
        });
        Page pages = PageListUtils.getPages(filter.getPage().getCurrent(), filter.getPage().getSize(), resultList);
        List<KnowledgeVo> records = pages.getRecords();
        records.forEach(e -> {
            //赋值
            String categoryId = e.getCategoryId();
            KnowledgeCategoryAdminVo knowledgeCategoryAdminVo = knowledgeCategoryService.findAllParentByCategoryId(categoryId);
            e.setKnowledgeCategoryAdminVo(knowledgeCategoryAdminVo);
            if (StringUtils.isNotEmpty(e.getOrganizationId())){
                OrganizationDto organizationDto = JSON.parseObject(e.getOrganizationId(), OrganizationDto.class);
                e.setOrganizationIds(organizationDto);
            }
            //处理默认节点有两个领导的情况(默认节点默认在第一位，sort=1)
            String[] split = e.getApproverId().split(",");
            if (split.length > 1){
                String approverNameTager = Arrays.stream(split).map(h -> userService.queryByUsername(h).getFullName()).collect(Collectors.joining(","));
                e.setApproverName(approverNameTager);
            }
            // 判断是否有代理人，有，approverName赋值代理人
            if (hasTager(e)){
                e.setApproverName(userService.queryByUsername(e.getTagerNo()).getFullName());
            }
        });
        return pages;
    }


    //判断是否有代理人
    private boolean hasTager(KnowledgeVo knowledgeApprovalListVo){
        if (StringUtils.isNotEmpty(knowledgeApprovalListVo.getTagerNo())){
            Calendar date = Calendar.getInstance();
            date.setTime(new Date());
            Calendar begin = Calendar.getInstance();
            begin.setTime(knowledgeApprovalListVo.getStartTime());
            Calendar end = Calendar.getInstance();
            end.setTime(knowledgeApprovalListVo.getEndTime());
            return date.after(begin) && date.before(end);
        } else {
            return false;
        }
    }

    /**
     * 根据分类id查询工作成果列表和经验案例列表
     *
     * @param filter
     * @return
     */
    public IPage getAllKnowledgeByCategoryId(QueryFilter filter) {
        IPage page = new Page();
        Map<String, Object> params = PageHelper.constructParams(filter);
        Map<String, Object> map = new HashMap<>();
        // 工作成果下的知识
        String keyword = (String) filter.getParams().get("keyword");
        if (keyword.equals("working")) {
            map.put("categoryId", "40");
            filter.setParams(map);
            page = knowledgeMapper.getAllKnowledgeByCategoryId(filter.getPage(), filter.getParams(), params);
            List<KnowledgeVo> collect = page.getRecords();
            collect.forEach(g -> {
                KnowledgeCategoryAdminVo knowledgeCategoryAdminVos = knowledgeCategoryService.findAllParentByCategoryId(g.getCategoryId());
                g.setKnowledgeCategoryAdminVo(knowledgeCategoryAdminVos);
                Map<String, Object> maps = userService.querySexAndPhoto(g.getCreateBy());
                g.setParams(maps);
                //权限处理(组织架构)(工作成功列表不需要增加点击量)
                g = parseOrganization(g.getOrganizationId(),false,g);
            });
        } else {
            map.put("categoryId", "50");
            filter.setParams(map);
            page = knowledgeMapper.getAllKnowledgeByCategoryId(filter.getPage(), filter.getParams(), params);
            List<KnowledgeVo> collect = page.getRecords();
            collect.forEach(g -> {
                KnowledgeCategoryAdminVo knowledgeCategoryAdminVos = knowledgeCategoryService.findAllParentByCategoryId(g.getCategoryId());
                g.setKnowledgeCategoryAdminVo(knowledgeCategoryAdminVos);
                Map<String, Object> maps = userService.querySexAndPhoto(g.getCreateBy());
                g.setParams(maps);
                //权限处理(组织架构)(工作成功列表不需要增加点击量)
                g = parseOrganization(g.getOrganizationId(),false,g);
            });
        }
        return page;
    }

    /**
     * 获取当前人未审核知识的数量
     *
     * @return
     */
    public Long getAuditKnowledgeSum() {
        //构建查询条件
        QueryFilter queryFilter = new QueryFilter();
        IPage page = this.findAllAuditKnowledge(queryFilter);
        long total = page.getTotal();
        return total;
    }

    /**
     * 前台获取登录人上传文件数量
     *
     * @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);
    }


    /**
     * 向统计表中增加数据(相同数据不增加)
     *
     * @param userId      用户Id
     * @param knowledgeId 知识Id
     */
    private void addCountViews(String userId, String knowledgeId) {
        QueryWrapper<ActionLog> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("USER_ID", userId);
        queryWrapper.eq("KNOWLEDGE_ID", knowledgeId);
        queryWrapper.eq("TYPE", 1);
        List<ActionLog> actionLogList = actionLogMapper.selectList(queryWrapper);
        if (CollectionUtils.isEmpty(actionLogList)) {
            ActionLog actionLog = new ActionLog();
            actionLog.setType(1);
            actionLog.setKnowledgeId(knowledgeId);
            actionLog.setUserId(userId);
            actionLogMapper.insert(actionLog);
        }
    }

    /**
     * 组织架构解析
     * @param organizationId 组织架构信息
     * @param isView 是否需要增加点击量(true 是 false 否)
     * @param KnowledgeVo 知识信息
     */
    private KnowledgeVo parseOrganization(String organizationId, Boolean isView, KnowledgeVo knowledgeVo) {
        OsUserDto osUserDto = userService.queryOsUserDto(userService.queryLoginUser());

        //没有组织架构信息
        if (StringUtils.isEmpty(organizationId)) {
            if (isView) {
                addCountViews(osUserDto.getUserId(), knowledgeVo.getPkId());
            }
            knowledgeVo.setIsOrganizationId(0);
            return knowledgeVo;
        }

        // 解析组织架构/职系/职等数据
        OrganizationDto organizationDto = JSON.parseObject(organizationId, OrganizationDto.class);
        log.info("解析出组织架构信息 -> {}",organizationDto);
        knowledgeVo.setOrganizationIds(organizationDto);
        // 获取当前登录人的组织架构/职系/职等数据
        String sequenceCode = osUserDto.getSequenceCode();
        String slyGrade = osUserDto.getSlyGrade();
        List<String> deptAuthority = knowledgeApproveMapper.deptAuthority(userService.queryLoginUser());
        AtomicBoolean flags = new AtomicBoolean(false);
        if (!CollectionUtils.isEmpty(organizationDto.getOrganizationId())) {
            organizationDto.getOrganizationId().forEach(e -> {
                for (int i = 0; i < deptAuthority.size(); i++) {
                    if (deptAuthority.get(i).contains(e)) {
                        flags.set(true);
                        break;
                    }
                }
            });
        }
        // 如果知识最终审核通过,判断组织架构/职系/职等是否符合(前台判断)

        // 如果职系,职等为空,组织架构id不为空
        if (!CollectionUtils.isEmpty(organizationDto.getOrganizationId()) && CollectionUtils.isEmpty(organizationDto.getGradeId()) &&
                CollectionUtils.isEmpty(organizationDto.getGradeLevelId())) {
            // 比较当前用户的组织架构是否符合条件
            if (flags.get()) {
                // 符合条件,增加点击量
                if (isView) {
                    addCountViews(osUserDto.getUserId(), knowledgeVo.getPkId());
                }
                knowledgeVo.setIsOrganizationId(0);
            } else {
                // 没有权限(不增加点击量)
                knowledgeVo.setIsOrganizationId(1);
            }
        }

        // 如果组织架构id,职等为空,职系不为空
        if (CollectionUtils.isEmpty(organizationDto.getOrganizationId()) && !CollectionUtils.isEmpty(organizationDto.getGradeId()) &&
                CollectionUtils.isEmpty(organizationDto.getGradeLevelId())) {
            // 比较当前用户的职系是否符合条件
            boolean flag = false;
            for (String s : organizationDto.getGradeId()) {
                if (s.contains(sequenceCode)) {
                    flag = true;
                    break;
                }
            }
            if (flag) {
                // 符合条件,增加点击量
                if (isView) {
                    addCountViews(osUserDto.getUserId(), knowledgeVo.getPkId());
                }
                knowledgeVo.setIsOrganizationId(0);
            } else {
                // 没有权限(不增加点击量)
                knowledgeVo.setIsOrganizationId(1);
            }
        }

        // 如果组织架构id,职系为空,职等不为空
        if (CollectionUtils.isEmpty(organizationDto.getOrganizationId()) && CollectionUtils.isEmpty(organizationDto.getGradeId()) &&
                !CollectionUtils.isEmpty(organizationDto.getGradeLevelId())) {
            // 比较当前用户的职等是否符合条件
            if (organizationDto.getGradeLevelId().contains(slyGrade)) {
                // 符合条件,增加点击量
                if (isView) {
                    addCountViews(osUserDto.getUserId(), knowledgeVo.getPkId());
                }
                knowledgeVo.setIsOrganizationId(0);
            } else {
                // 没有权限(不增加点击量)
                knowledgeVo.setIsOrganizationId(1);
            }
        }

        // 如果职等为空,组织架构id,职系不为空
        if (!CollectionUtils.isEmpty(organizationDto.getOrganizationId()) && !CollectionUtils.isEmpty(organizationDto.getGradeId()) &&
                CollectionUtils.isEmpty(organizationDto.getGradeLevelId())) {
            boolean flag = false;
            for (String s : organizationDto.getGradeId()) {
                if (s.contains(sequenceCode)) {
                    flag = true;
                    break;
                }
            }
            if (flags.get() && flag) {
                // 符合条件,增加点击量
                if (isView) {
                    addCountViews(osUserDto.getUserId(), knowledgeVo.getPkId());
                }
                knowledgeVo.setIsOrganizationId(0);
            } else {
                // 没有权限(不增加点击量)
                knowledgeVo.setIsOrganizationId(1);
            }
        }

        // 如果职系为空,组织架构id,职等不为空
        if (!CollectionUtils.isEmpty(organizationDto.getOrganizationId()) && CollectionUtils.isEmpty(organizationDto.getGradeId()) &&
                !CollectionUtils.isEmpty(organizationDto.getGradeLevelId())) {
            if (flags.get() && organizationDto.getGradeLevelId().contains(slyGrade)) {
                // 符合条件,增加点击量
                if (isView) {
                    addCountViews(osUserDto.getUserId(), knowledgeVo.getPkId());
                }
                knowledgeVo.setIsOrganizationId(0);
            } else {
                // 没有权限(不增加点击量)
                knowledgeVo.setIsOrganizationId(1);
            }
        }

        // 如果组织架构id为空,职系,职等不为空
        if (CollectionUtils.isEmpty(organizationDto.getOrganizationId()) && !CollectionUtils.isEmpty(organizationDto.getGradeId()) &&
                !CollectionUtils.isEmpty(organizationDto.getGradeLevelId())) {
            boolean flag = false;
            for (String s : organizationDto.getGradeId()) {
                if (s.contains(sequenceCode)) {
                    flag = true;
                    break;
                }
            }
            if (flag && organizationDto.getGradeLevelId().contains(slyGrade)) {
                // 符合条件,增加点击量
                if (isView) {
                    addCountViews(osUserDto.getUserId(), knowledgeVo.getPkId());
                }
                knowledgeVo.setIsOrganizationId(0);
            } else {
                // 没有权限(不增加点击量)
                knowledgeVo.setIsOrganizationId(1);
            }
        }

        // 如果组织架构id,职系,职等都不为空
        if (!CollectionUtils.isEmpty(organizationDto.getOrganizationId()) && !CollectionUtils.isEmpty(organizationDto.getGradeId()) &&
                !CollectionUtils.isEmpty(organizationDto.getGradeLevelId())) {
            boolean flag = false;
            for (String s : organizationDto.getGradeId()) {
                if (s.contains(sequenceCode)) {
                    flag = true;
                    break;
                }
            }
            if (flags.get() && flag && organizationDto.getGradeLevelId().contains(slyGrade)) {
                // 符合条件,增加点击量
                if (isView) {
                    addCountViews(osUserDto.getUserId(), knowledgeVo.getPkId());
                }
                knowledgeVo.setIsOrganizationId(0);
            } else {
                // 没有权限(不增加点击量)
                knowledgeVo.setIsOrganizationId(1);
            }
        }
        return knowledgeVo;
    }


    /**
     * 转移作者
     * @param transferAuthorDto
     */
    @Transactional(rollbackFor = Exception.class)
    public void transferAuthor(TransferAuthorDto transferAuthorDto) {
        //被转移人
        List<String> authors = transferAuthorDto.getAuthors();
        //准备转移的人
        String arriveAuthor = transferAuthorDto.getArriveAuthor();
        String arriveAuthorName = userService.queryOsUserDto(arriveAuthor).getFullName();
        //转移
        knowledgeMapper.transferAuthor(authors,arriveAuthor,arriveAuthorName);
    }

    /**
     * 被转移人树
     * @param filter
     * @param params
     * @return
     */
    public IPage<OsUser> getAllUsersByGroupId(QueryFilter filter, Map params) {
        String groupId = (String)params.get("groupId");
        if (StringUtils.isNotEmpty(groupId)) {
            if ("curOrg".equals(groupId)) {
                IUser user = ContextUtil.getCurrentUser();
                if (user != null) {
                    groupId = user.getDeptId();
                }
            }

            String[] groupIds = groupId.split(",");
            params.put("groupIds", Arrays.asList(groupIds));
        }

        IPage<OsUser> osUserIPage = knowledgeMapper.getAllUsersByGroupId(filter.getPage(), params);
        String tenantId = ContextUtil.getCurrentTenantId();
        List<OsUser> osList = new ArrayList();
        List<OsUser> osUsers = osUserIPage.getRecords();

        OsUser user;
        for(Iterator var8 = osUsers.iterator(); var8.hasNext(); osList.add(user)) {
            user = (OsUser)var8.next();
            OsGroup deps = this.getMainDeps(user.getUserId(), tenantId);
            if (deps != null) {
                user.setDeptName(deps.getName());
                user.setMainDepId(deps.getGroupId());
            }
        }

        osUserIPage.setRecords(osList);
        return osUserIPage;
    }

    public OsGroup getMainDeps(String userId, String tenantId) {
        List<OsGroup> groups = knowledgeMapper.getByDimIdUserIdRelTypeIdIsMain("1", userId, "1", MBoolean.YES.name(), tenantId);
        return groups.size() > 0 ? (OsGroup)groups.get(0) : null;
    }

    //@Transactional(rollbackFor = Exception.class)
    public List<String> importKnowledge() {
        //查询需要导入的数据(组织架构格式化)
        List<KnowledgeCp> knowledgeCpList = knowledgeCpMapper.selectList(null);
        knowledgeCpList.parallelStream().forEach(e -> {
            if (StringUtils.isNotEmpty(e.getOrganizationId())){
                String s = e.getOrganizationId().replaceAll("\\\\", "");
                e.setOrganizationId(s);
            }
        });
        List<String> pkIdList = new ArrayList<>();
        //取出第一条数据
        knowledgeCpList.stream().limit(100).forEach(e -> {
            String pkId = null;
            try {
                pkId = this.create(null,e);
            } catch (Exception ex){
                pkIdList.add(e.getPkId());
            }
            //导入成功，删除原数据
            if (StringUtils.isNotEmpty(pkId) && e.getPkId().equals(pkId)){
                knowledgeCpMapper.deleteCp(pkId);
            }
        });
        return pkIdList;
    }

    /**
     * 批量修改分类
     * @param transferKnowledgeCategoryDto
     */
    public void transferCategory(TransferKnowledgeCategoryDto transferKnowledgeCategoryDto) {
        //需要转移的知识
        List<String> knowledgeIds = transferKnowledgeCategoryDto.getKnowledgeIds();
        //准备转移到的分类
        String categoryId = transferKnowledgeCategoryDto.getCategoryId();
        //判断知识分类id是否存在
        KnowledgeCategory knowledgeCategory = knowledgeCategoryMapper.selectById(categoryId);
        if (Objects.isNull(knowledgeCategory)){
            throw new RuntimeException("输入的知识分类id不存在");
        }
        //转移
        knowledgeMapper.transferCategory(knowledgeIds,categoryId);
    }

    /**
     * 知识撤回
     * @param knowledgeId
     */
    public void knowledgeWithdraw(String knowledgeId) {
        //判断知识是否被审核过了
        List<KnowledgeApprove> knowledgeApproveList = knowledgeApproveMapper.
                selectList(new QueryWrapper<KnowledgeApprove>().eq("KNOWLEDGER_ID", knowledgeId));
        if (knowledgeApproveList.stream().findFirst().get().getResult() != null){
            throw new RuntimeException("知识被审核过了，无法撤回");
        }
        //撤回(知识审核状态修改为6且进入草稿,审核记录删除)
        Knowledge knowledge = this.get(knowledgeId);
        knowledge.setPkId(knowledgeId);
        knowledge.setApprovalStatus(6);
        knowledge.setIsDraft(0);
        knowledgeMapper.updateById(knowledge);
        knowledgeApproveMapper.deleteByKnowledgeId(knowledgeId);
    }

    /**
     * 判断是否有下载附件权限(有权限 返回0； 没权限 返回1)
     * @return
     */
    private Integer isAllowDownload(String downloadUserId,String downloadDeptId){
        String userId = userService.queryLoginUser();
        String deptId = userService.queryLoginUserDeptId();
        //二者都不为空
        if (StringUtils.isNotEmpty(downloadDeptId) && StringUtils.isNotEmpty(downloadUserId)){
            //可下载部门数组
            List<String> deptAuthority = knowledgeApproveMapper.findAllDeptIdByParent(deptId);
            String[] downloadDeptIdStr = downloadDeptId.split(",");
            boolean flag = false;
            for (int i = 0; i < downloadDeptIdStr.length; i++) {
                if (deptAuthority.contains(downloadDeptIdStr[i])) {
                    flag = true;
                    break;
                }
            }
            List<String> approverIdList = Arrays.asList(downloadUserId.split(","));
            // 如果有权限
            if (!approverIdList.contains(userId) && !flag) {
                // 不是该部门的人,不能查看
                return 1;
            } else {
                return 0;
            }
        } else {
            //可下载部门情况
            if (StringUtils.isNotEmpty(downloadDeptId)){
                //可下载部门数组
                String[] downloadDeptIdStr = downloadDeptId.split(",");
                for (String downloadDeptIds : downloadDeptIdStr) {
                    List<String> deptAuthority = knowledgeApproveMapper.findAllDeptIdByParent(downloadDeptIds);
                    if (deptAuthority.contains(deptId)){
                        return 0;
                    }
                }
            }

            //可下载人员情况
            if (StringUtils.isNotEmpty(downloadUserId)){
                List<String> approverIdList = Arrays.asList(downloadUserId.split(","));
                if (approverIdList.contains(userId)){
                    return 0;
                } else {
                    return 1;
                }

            }
        }
        return 1;
    }
}