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

package com.redxun.knowledge.service;

import cn.hutool.core.date.DatePattern;
import cn.hutool.core.date.DateUtil;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.github.xiaoymin.knife4j.spring.configuration.Knife4jHttpBasic;
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.DateUtils;
import com.redxun.common.tool.StringUtils;
import com.redxun.common.utils.ContextUtil;
import com.redxun.dto.user.OsUserDto;
import com.redxun.knowledge.common.MessageService;
import com.redxun.knowledge.common.UserService;
import com.redxun.knowledge.entity.dao.Knowledge;
import com.redxun.knowledge.entity.dao.KnowledgeApprove;
import com.redxun.knowledge.entity.dto.KnowledgeApproveDto;
import com.redxun.knowledge.entity.dto.OrganizationDto;
import com.redxun.knowledge.entity.vo.KnowledgeApprovalListVo;
import com.redxun.knowledge.entity.vo.KnowledgeCategoryAdminVo;
import com.redxun.knowledge.mapper.KnowledgeApproveMapper;
import com.redxun.knowledge.mapper.KnowledgeMapper;
import com.redxun.knowledge.qywexin.QYWechatUtils;
import com.redxun.knowledge.utils.ObjectUtil;
import com.redxun.knowledge.utils.PageListUtils;
import com.redxun.search.service.SearchService;
import com.redxun.search.utils.FileInputStreamUtils;
import com.redxun.search.utils.MD5;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

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

/**
 * [业务--知识审批表]业务服务类
 */
@Service
@Slf4j
public class KnowledgeApproveServiceImpl extends SuperServiceImpl<KnowledgeApproveMapper, KnowledgeApprove> implements BaseService<KnowledgeApprove> {

    @Value("${file.documentUrl}")
    private String documentUrl;

    @Value("${file.downloadUrl}")
    private String downloadUrl;

    @Value("${uploaderHead.male}")
    private String uploaderHeadMale;

    @Value("${uploaderHead.female}")
    private String uploaderHeadFemale;

    @Value("${qywx.approvePage}")
    private String qywxApprovePage;

    @Resource
    private KnowledgeApproveMapper knowledgeApproveMapper;

    @Autowired
    private KnowledgeCategoryServiceImpl knowledgeCategoryService;

    @Autowired
    private KnowledgeMapper knowledgeMapper;

    @Autowired
    private MessageService messageService;

    @Autowired
    private UserService userService;

    @Autowired
    private SearchService searchService;

    @Autowired
    private KnowledgeAgentServiceImpl knowledgeAgentService;

    @Override
    public BaseDao<KnowledgeApprove> getRepository() {
        return knowledgeApproveMapper;
    }

    /**
     * 审核管理列表(分页查询)
     *
     * @param filter
     * @return
     */
    public IPage findAllKnowledgeApprove(QueryFilter filter) {
        Map<String, Object> params = PageHelper.constructParams(filter);
        //查询出全部记录
        List<KnowledgeApprovalListVo> allKnowledgeApprove = knowledgeApproveMapper.findAllKnowledgeApprove(filter.getParams(), params);
        //数据处理
        String userNo = userService.queryLoginUsername();
        List<KnowledgeApprovalListVo> collectList = this.allApproveList(allKnowledgeApprove);
        //查询知识管理员
        List<String> knowledgeManager = knowledgeApproveMapper.findKnowledgeManager();
        String user = userService.queryLoginUser();
        //如果是知识管理员，展示全部 不是 查看自己能审核的记录
        if(!knowledgeManager.contains(user) && !"admin".equals(userNo)){
            //只查看当前登陆人能审核的记录(isAudit=0)
            collectList = collectList.stream().filter(e -> e.getIsAudit() == 0 && (e.getApprovalStatus() == 1 || e.getApprovalStatus() == 3)).collect(Collectors.toList());
            log.info("能审核的数量 -> {}",collectList.size());
        }
        //如果是admin，全部能审核
        if ("admin".equals(userNo)){
            collectList.forEach(e -> e.setIsAudit(0));
        }
        //数据分页
        Page pages = PageListUtils.getPages(filter.getPage().getCurrent(), filter.getPage().getSize(), collectList);
        List<KnowledgeApprovalListVo> collect = pages.getRecords();
        //组织架构信息解析
        collect.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.getApproverId()).getFullName());
            }
        });
        return pages;
    }

    /**
     * 未分页前全部审核记录
     * @param allKnowledgeApprove
     * @return
     */
    public List<KnowledgeApprovalListVo> allApproveList(List<KnowledgeApprovalListVo> allKnowledgeApprove){
        // 根据知识Id进行数据分组
        Map<String, List<KnowledgeApprovalListVo>> result =
                allKnowledgeApprove.stream().collect(Collectors.groupingBy(KnowledgeApprovalListVo::getKnowledgerId));
        // 结果集
        List<KnowledgeApprovalListVo> knowledgeApprovalListVoList = new ArrayList<>();
        // 遍历每组的数据
        Set<Map.Entry<String, List<KnowledgeApprovalListVo>>> entries = result.entrySet();
        for (Map.Entry<String, List<KnowledgeApprovalListVo>> entry : entries) {
            List<KnowledgeApprovalListVo> value = entry.getValue();
            for (int i = 0; i < value.size(); i++) {
                // 如果是最终审核通过,直接放入记录
                // && value.get(i).getIsFinal() == 1
                if (value.get(i).getApprovalStatus() == 5) {
                    knowledgeApprovalListVoList.add(value.get(i));
                    break;
                }
                // 判断审批结果是否为null(如果审批结果没有null，证明审批已结束;如果等于0，证明审批没通过)
                if (value.get(i).getResult() == null || value.get(i).getResult() == 0) {
                    if (i != 0) {
                        // 如果不是第一条数据,取前一条数据的审批时间
                        Date approvalTime = value.get(i - 1).getApprovalTime();
                        value.get(i).setApprovalTime(approvalTime);
                    }
                    // 把该记录加到结果集中
                    knowledgeApprovalListVoList.add(value.get(i));
                    break;
                }
            }
        }
        //按照时间排序
        List<KnowledgeApprovalListVo> collectList = knowledgeApprovalListVoList.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);  //部门权限字符串
        collectList.forEach(e -> {
            String[] split = e.getApproverId().split(",");
            //处理默认节点有两个领导的情况(默认节点默认在第一位，sort=1)
            if (split.length > 1){
                String approverIdTager = knowledgeAgentService.hasLeaderMore(split);
                e.setApproverId(approverIdTager);
            }
            // 判断是否有代理人，有, approverId赋值代理人
            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) {
                // 不是该部门的人,不能审核
                e.setIsAudit(1);
            } else {
                e.setIsAudit(0);
            }
        });
        return collectList;
    }


    /**
     * 判断是否有代理人且生效中(审核列表使用)
     * @param knowledgeApprovalListVo
     * @return
     */
    private boolean hasTager(KnowledgeApprovalListVo 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;
        }
    }

    /**
     * 知识审核
     *
     * @param entity
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public int update(KnowledgeApprove entity) {
        String userNo = userService.queryLoginUsername();
        String userId = userService.queryLoginUser();
        // 如果审批结论为null,置位空字符串
        if (StringUtils.isEmpty(entity.getRemark())) {
            entity.setRemark("");
        }
        // 当前记录
        KnowledgeApprove knowledgeApprove = knowledgeApproveMapper.selectByIdAndSort(entity.getPkId(), null,null);
        //把最初的审核人记录下来
        String startApproverId = knowledgeApprove.getApproverId();
        // 判断是否重复审核
        if (knowledgeApprove.getResult() != null) {
            return -1;
        }
        //判断是否有代理人 有 approverId赋值为代理人id
        String[] split = knowledgeApprove.getApproverId().split(",");
        //处理默认节点有两个领导的情况(默认节点默认在第一位，sort=1)
        if (split.length > 1){
            String approverIdTager = knowledgeAgentService.hasLeaderMore(split);
            knowledgeApprove.setApproverId(approverIdTager);
            //当前登陆人不在里面，一定为代理人
            if (!startApproverId.contains(userNo)){
                entity.setActualApproverName(userService.queryLoginFullName() + "(代" + knowledgeApprove.getApproverName() + ")");
            }
        }
        boolean hasTager = knowledgeAgentService.hasTager(knowledgeApprove);
        if (hasTager){
            knowledgeApprove.setApproverId(knowledgeApprove.getTagerNo());
            //有代理人，实际审核人赋值特殊处理
            entity.setActualApproverName(userService.queryByUsername(knowledgeApprove.getApproverId()).getFullName() + "(代"
                    + knowledgeApprove.getApproverName() + ")");
        }

        // 判断组织架构(权限)是否变更
        //部门权限字符串
        List<String> deptAuthority = knowledgeApproveMapper.deptAuthority(userId);
        boolean flag = false;
        for (int i = 0; i < deptAuthority.size(); i++) {
            if (deptAuthority.get(i).contains(knowledgeApprove.getApproverId())) {
                flag = true;
                break;
            }
        }
        List<String> approverIdList = Arrays.asList(knowledgeApprove.getApproverId().split(","));
        if (!approverIdList.contains(userNo) && !flag && !"admin".equals(userNo)) {
            // 不是该部门的人,不能审核
            return -2;
        }

        // 查询当前记录的下一条记录(发站内信)
        KnowledgeApprove knowledgeApproveNext = knowledgeApproveMapper.selectByIdAndSort(null, knowledgeApprove.getKnowledgerId(), knowledgeApprove.getSort() + 1);
        // 如果审核节点不是终审节点且知识未通过,修改知识状态为节点驳回 2
        if (knowledgeApprove.getIsFinal() != 1 && entity.getResult() == 0) {
            Knowledge knowledge = new Knowledge();
            knowledge.setPkId(knowledgeApprove.getKnowledgerId());
            knowledge.setApprovalStatus(2);
            knowledgeMapper.updateById(knowledge);
            //给知识创建人发送站内信和企业微信消息
            Knowledge knowledgeEnd = knowledgeMapper.selectById(knowledgeApprove.getKnowledgerId());
            String createBy = knowledgeEnd.getCreateBy();
            sendMessage(createBy, knowledgeEnd.getTitles(), entity.getRemark(), false);
        }
        // 如果审核节点是终审节点且知识未通过,修改知识状态为最终驳回 4
        if (knowledgeApprove.getIsFinal() == 1 && entity.getResult() == 0) {
            Knowledge knowledge = new Knowledge();
            knowledge.setPkId(knowledgeApprove.getKnowledgerId());
            knowledge.setApprovalStatus(4);
            knowledgeMapper.updateById(knowledge);
            //给知识创建人发送站内信和企业微信消息
            Knowledge knowledgeEnd = knowledgeMapper.selectById(knowledgeApprove.getKnowledgerId());
            String createBy = knowledgeEnd.getCreateBy();
            sendMessage(createBy, knowledgeEnd.getTitles(), entity.getRemark(), false);
        }
        // 如果审核节点是终审节点且知识通过,修改知识状态为最终通过 5
        if ((knowledgeApprove.getIsFinal() == 1 || knowledgeApproveNext == null) && entity.getResult() == 1) {
            Knowledge knowledge = new Knowledge();
            knowledge.setPkId(knowledgeApprove.getKnowledgerId());
            knowledge.setApprovalStatus(5);
            knowledgeMapper.updateById(knowledge);
            //给知识创建人发送站内信和企业微信消息
            Knowledge knowledgeEnd = knowledgeMapper.selectById(knowledgeApprove.getKnowledgerId());
            String createBy = knowledgeEnd.getCreateBy();
            sendMessage(createBy, knowledgeEnd.getTitles(), entity.getRemark(), true);
            //把该知识附件信息传入搜索平台
            Knowledge knowledges = knowledgeMapper.selectById(knowledgeApprove.getKnowledgerId());
            // 获取知识上传人头像
            String uploaderHead = null;
            Map<String, Object> map = userService.querySexAndPhoto(knowledges.getCreateBy());
            if (map.get("photo") == null) {
                if (map.get("sex").equals("male")) {
                    uploaderHead = uploaderHeadMale;
                } else {
                    uploaderHead = uploaderHeadFemale;
                }
            } else {
                uploaderHead = downloadUrl + map.get("photo");
            }
            // 判断是否有附件文件
            if (knowledges.getAttachment() != null) {
                // 有文件,截取文件名后缀
                String attachmentName = knowledges.getAttachmentName();
                String[] strArray = attachmentName.split("\\.");
                int suffixIndex = strArray.length - 1;
                String titles = knowledges.getTitles();
                // 拼接新文件名(知识标题 + 文件名后缀)
                String newFileName = titles + "." + strArray[suffixIndex];
                // 文件加密
                String fileStream = FileInputStreamUtils.getInputStreamString(downloadUrl + knowledges.getAttachment());
                String fileMD5 = MD5.encrypt(fileStream);
                searchService.notice(knowledges.getPkId(), knowledges.getDocumentId(), knowledges.getTitles(), knowledges.getAttachmentName(), knowledges.getAttachmentName(),
                        documentUrl + knowledges.getPkId(), downloadUrl + knowledges.getAttachment(), fileMD5,
                        knowledges.getAuthor(),
                        knowledges.getCreateBy(), uploaderHead, knowledges.getSummary(), 1);
            } else {
                // 没有文件,直接传入知识标题
                String titles = knowledges.getTitles();
                searchService.notice(knowledges.getPkId(), knowledges.getDocumentId(), knowledges.getTitles(), titles, "",
                        documentUrl + knowledges.getPkId(), "", "",
                        knowledges.getAuthor(),
                        knowledges.getCreateBy(), uploaderHead, knowledges.getSummary(), 1);
            }
        }
        // 如果当前节点的下个节点为终审节点通过且当前节点审核通过,修改状态为待最终审核
        if (knowledgeApproveNext != null && knowledgeApproveNext.getIsFinal() == 1 && entity.getResult() == 1) {
            Knowledge knowledge = new Knowledge();
            knowledge.setPkId(knowledgeApprove.getKnowledgerId());
            knowledge.setApprovalStatus(3);
            knowledgeMapper.updateById(knowledge);
        }
        // 如果审核通过了,发送短信通知下一个人审核
        if (knowledgeApproveNext != null && entity.getResult() == 1) {
            // 根据工号查询用户id(有代理人用代理人的)
            if (knowledgeAgentService.hasTager(knowledgeApproveNext)){
                knowledgeApproveNext.setApproverId(knowledgeApproveNext.getTagerNo());
            }
            String approverId = knowledgeApproveNext.getApproverId();
            JPaasUser jPaasUser = userService.queryByUsername(approverId);
            if (jPaasUser != null) {
                Knowledge knowledge = knowledgeMapper.selectById(knowledgeApprove.getKnowledgerId());
                sendMessage(jPaasUser.getUserId(), knowledge.getTitles(), knowledge.getCreateBy(), knowledge.getCreateTime());
            }
        }

        // 修改该知识的组织架构信息
        Knowledge knowledge = knowledgeMapper.selectById(knowledgeApprove.getKnowledgerId());
        knowledge.setPkId(knowledge.getPkId());
        if (StringUtils.isNotEmpty(entity.getOrganizationId())){
            knowledge.setOrganizationId(entity.getOrganizationId());
        }
        knowledgeMapper.updateById(knowledge);
        //权限判断完成，把approverId变更回来
        knowledgeApprove.setApproverId(startApproverId);
        return this.getRepository().updateById(entity);
    }

    /**
     * 给知识创建人发送站内信和企业微信消息(知识被驳回时,或者最终节点审核通过时)(flag为true,知识通过;为false,知识不通过)
     *
     * @param createBy,remark,flag
     */
    private void sendMessage(String createBy, String titles, String remark, Boolean flag) {
        String[] qyUser = new  String[]{createBy};
        List<OsUserDto> osUserDtoList = new ArrayList<>();
        //查询用户信息
        OsUserDto osUserDto = userService.queryOsUserDto(createBy);
        osUserDtoList.add(osUserDto);
        // 知识通过
        if (flag) {
            QYWechatUtils.send(qyUser,"您提交的申请已经通过审批！" + "<br>" +
                    "提交内容:" + titles + "<br>" + "审批时间:" + DateUtil.format(new Date(), DatePattern.NORM_DATETIME_PATTERN));
            messageService.sendInnerMsg("您提交的申请已经通过审批！",
                    "提交内容:" + titles + "<br>" +
                            "审批时间:" + DateUtil.format(new Date(), DatePattern.NORM_DATETIME_PATTERN), osUserDtoList);
        } else {
            // 知识不通过
            QYWechatUtils.send(qyUser,"您提交的申请已被驳回！" + "<br>" +
                    "提交内容:" + titles + "<br>" + "审批时间:" + DateUtil.format(new Date(), DatePattern.NORM_DATETIME_PATTERN));
            messageService.sendInnerMsg("您提交的申请已被驳回！",
                    "提交内容:" + titles + "<br>" +
                            "驳回原因:" + remark + "<br>" +
                            "审核人:" + ContextUtil.getCurrentUser().getFullName() + "<br>" +
                            "审批时间:" + DateUtil.format(new Date(), DatePattern.NORM_DATETIME_PATTERN), osUserDtoList);

        }
    }

    /**
     * 给下一节点审核人发消息(不包含部门)(给审批地址)
     *
     * @param
     */
    public void sendMessage(String sender, String titles, String userId, Date date) {
        String[] qyUser = new  String[]{sender};
        List<OsUserDto> osUserDtoList = new ArrayList<>();
        //查询用户信息
        OsUserDto osUserDto = userService.queryOsUserDto(sender);
        osUserDtoList.add(osUserDto);
        // 发消息通过前来审核
        QYWechatUtils.send(qyUser,"您有一条待审核任务，请尽快完成审核！" + "<br>" +
                "审核类型:知识审核" + "<br>" +
                        "提交内容:" + titles + "<br>" +
                        "提交人:" + userService.queryUser(userId).getFullName() + "<br>" +
                        "提交时间:" + DateUtil.format(date, DatePattern.NORM_DATETIME_PATTERN)+ "<br>" +
                        "审批地址:" + "<a href=" + qywxApprovePage + ">查看</a>");
        messageService.sendInnerMsg("您有一条待审核任务，请尽快完成审核！", "审核类型:知识审核" + "<br>" +
                "提交内容:" + titles + "<br>" +
                "提交人:" + userService.queryUser(userId).getFullName() + "<br>" +
                "提交时间:" + DateUtil.format(date, DatePattern.NORM_DATETIME_PATTERN) + "<br>" +
                "审批地址:" + "<a href=" + qywxApprovePage + ">查看</a>", osUserDtoList);
    }
}