api/src/main/java/com/xjrsoft/module/material/service/impl/MaterialTaskServiceImpl.java

package com.xjrsoft.module.material.service.impl;

import cn.dev33.satoken.stp.StpUtil;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.extra.spring.SpringUtil;
import cn.hutool.json.JSONUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.fasterxml.jackson.core.type.TypeReference;
import com.github.yulichang.base.MPJBaseServiceImpl;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import com.xjrsoft.common.constant.GlobalConstant;
import com.xjrsoft.common.enums.DeleteMark;
import com.xjrsoft.common.enums.MaterialCategoryEnum;
import com.xjrsoft.common.exception.MyException;
import com.xjrsoft.common.model.generator.ComponentConfig;
import com.xjrsoft.common.utils.FileZipUtil;
import com.xjrsoft.common.utils.RedisUtil;
import com.xjrsoft.common.utils.VoToColumnUtil;
import com.xjrsoft.module.concat.service.IXjrUserService;
import com.xjrsoft.module.form.dto.FormExecuteAddOrUpdateDto;
import com.xjrsoft.module.form.entity.FormDesignConfig;
import com.xjrsoft.module.form.entity.FormTemplate;
import com.xjrsoft.module.form.mapper.FormTemplateMapper;
import com.xjrsoft.module.form.service.IFormExecuteService;
import com.xjrsoft.module.generator.constant.ComponentTypeConstant;
import com.xjrsoft.module.generator.entity.TableConfig;
import com.xjrsoft.module.generator.utils.GeneratorUtil;
import com.xjrsoft.module.material.dto.*;
import com.xjrsoft.module.material.entity.MaterialTask;
import com.xjrsoft.module.material.entity.MaterialTaskAppendix;
import com.xjrsoft.module.material.entity.MaterialTaskAssign;
import com.xjrsoft.module.material.entity.MaterialType;
import com.xjrsoft.module.material.entity.MaterialTypeAssign;
import com.xjrsoft.module.material.mapper.MaterialTaskAppendixMapper;
import com.xjrsoft.module.material.mapper.MaterialTaskAssignMapper;
import com.xjrsoft.module.material.mapper.MaterialTaskMapper;
import com.xjrsoft.module.material.service.IMaterialTaskAppendixService;
import com.xjrsoft.module.material.service.IMaterialTaskService;
import com.xjrsoft.module.material.service.IMaterialTypeService;
import com.xjrsoft.module.material.vo.*;
import com.xjrsoft.module.organization.dto.WeChatSendMessageDto;
import com.xjrsoft.module.organization.entity.Department;
import com.xjrsoft.module.organization.entity.User;
import com.xjrsoft.module.organization.entity.UserDeptRelation;
import com.xjrsoft.module.organization.entity.UserRoleRelation;
import com.xjrsoft.module.organization.service.IUserService;
import com.xjrsoft.module.organization.service.IWeChatService;
import com.xjrsoft.module.student.entity.BaseStudentSchoolRoll;
import com.xjrsoft.module.system.entity.DictionaryDetail;
import com.xjrsoft.module.system.entity.File;
import com.xjrsoft.module.system.service.IFileService;
import com.xjrsoft.module.teacher.entity.XjrUser;
import com.xjrsoft.module.teacher.vo.XjrUserVo;
import com.xjrsoft.module.workflow.entity.WorkflowSchema;
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;
import java.time.LocalDate;
import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.stream.Collectors;

/**
* @title: 材料提交任务
* @Author baicai
* @Date: 2023-10-31
* @Version 1.0
*/
@Service
@AllArgsConstructor
public class MaterialTaskServiceImpl extends MPJBaseServiceImpl<MaterialTaskMapper, MaterialTask> implements IMaterialTaskService {
    private final MaterialTaskMapper materialTaskMaterialTaskMapper;

    private final MaterialTaskAssignMapper materialTaskMaterialTaskAssignMapper;
    private final MaterialTaskAppendixMapper appendixMapper;

    private final IMaterialTypeService materialTypeService;
    private final IWeChatService weChatService;
    private final IXjrUserService xjrUserService;
    private final IFormExecuteService formExecuteService;

    private final FormTemplateMapper formTemplateMapper;
    private final IFileService fileService;
    private final IUserService userService;
    private final IMaterialTaskAppendixService materialTaskAppendixService;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Long add(AddMaterialTaskDto dto) {
        MaterialTask materialTask = BeanUtil.toBean(dto, MaterialTask.class);

        //梳理提交人
        Map<Long, MaterialTaskAssign> materialTaskAssignMap = new HashMap<>();
        for (MaterialAssignUserDto materialAssignUserDto : dto.getUserList()){
            if(materialAssignUserDto.getUserType() == 1){
                List<XjrUserVo> xjrUserVos = xjrUserService.selectJoinList(XjrUserVo.class,
                        new MPJLambdaWrapper<XjrUser>()
                                .leftJoin(UserDeptRelation.class, UserDeptRelation::getUserId, XjrUser::getId)
                                .leftJoin(UserRoleRelation.class, UserRoleRelation::getUserId, XjrUser::getId)
                                .eq(UserDeptRelation::getDeptId, materialAssignUserDto.getUserId())
                                .eq(UserRoleRelation::getRoleId, 2)
                                .eq(XjrUser::getDeleteMark, DeleteMark.NODELETE.getCode())
                );
                for (XjrUserVo xjrUserVo : xjrUserVos) {
                    materialTaskAssignMap.put(xjrUserVo.getId(), new MaterialTaskAssign(){{
                        setUserId(xjrUserVo.getId());
                        setUserType(1);
                        setUserNumber(xjrUserVo.getUserName());
                        setStatus(1);
                        setExecutiveStatus(1);
                        setSendMessage(dto.getSendMessage());
                    }});
                }
            }else if(materialAssignUserDto.getUserType() == 2){
                List<XjrUserVo> xjrUserVos = xjrUserService.selectJoinList(XjrUserVo.class,
                        new MPJLambdaWrapper<XjrUser>()
                                .leftJoin(BaseStudentSchoolRoll.class, BaseStudentSchoolRoll::getUserId, XjrUser::getId)
                                .eq(BaseStudentSchoolRoll::getClassId, materialAssignUserDto.getUserId())
                                .eq(XjrUser::getDeleteMark, DeleteMark.NODELETE.getCode())
                );
                for (XjrUserVo xjrUserVo : xjrUserVos) {
                    materialTaskAssignMap.put(xjrUserVo.getId(), new MaterialTaskAssign(){{
                        setUserId(xjrUserVo.getId());
                        setUserType(2);
                        setUserNumber(xjrUserVo.getUserName());
                        setStatus(1);
                        setExecutiveStatus(1);
                        setSendMessage(dto.getSendMessage());
                    }});
                }
            }else if(materialAssignUserDto.getUserType() == 3){
                List<MaterialTaskAssignUserVo> materialTaskAssignUserVoList = xjrUserService.selectJoinList(MaterialTaskAssignUserVo.class,
                        new MPJLambdaWrapper<XjrUser>()
                                .select(XjrUser::getId)
                                .selectAs(XjrUser::getUserName, MaterialTaskAssignUserVo::getUserName)
                                .selectAs(UserRoleRelation::getRoleId, MaterialTaskAssignUserVo::getRoleId)
                                .leftJoin(UserRoleRelation.class, UserRoleRelation::getUserId, XjrUser::getId)
                                .eq(XjrUser::getId, materialAssignUserDto.getUserId())
                                .eq(XjrUser::getDeleteMark, DeleteMark.NODELETE.getCode())
                );
                if(materialTaskAssignUserVoList != null && !materialTaskAssignUserVoList.isEmpty()){
                    MaterialTaskAssignUserVo materialTaskAssignUserVo = materialTaskAssignUserVoList.get(0);
                    materialTaskAssignMap.put(materialTaskAssignUserVo.getId(), new MaterialTaskAssign(){{
                        setUserId(materialAssignUserDto.getUserId());
                        setUserType(materialTaskAssignUserVo.getRoleId() == 3 ? 2 : 1);
                        setUserNumber(materialTaskAssignUserVo.getUserName());
                        setStatus(1);
                        setExecutiveStatus(1);
                        setSendMessage(dto.getSendMessage());
                    }});
                }
            }
        }

        List<MaterialTaskAssign> materialTaskAssignList = new ArrayList<>(materialTaskAssignMap.values());

        //新增任务
        materialTask.setStatus(2);
        if(dto.getUserList() != null && !dto.getUserList().isEmpty()){
            materialTask.setAssignPerson(materialTaskAssignList.size());
        }
        materialTaskMaterialTaskMapper.insert(materialTask);

        //新增任务人
        for(MaterialTaskAssign materialTaskAssign : materialTaskAssignList){
            materialTaskAssign.setMaterialTaskId(materialTask.getId());
            materialTaskMaterialTaskAssignMapper.insert(materialTaskAssign);
        }

//        materialTaskMaterialTaskMapper.insert(materialTask);
//        if (materialTask.getMaterialTaskAssignList() != null && materialTask.getMaterialTaskAssignList().size() > 0) {
//            for (MaterialTaskAssign materialTaskAssign : materialTask.getMaterialTaskAssignList()) {
//                materialTaskAssign.setMaterialTaskId(materialTask.getId());
//                materialTaskMaterialTaskAssignMapper.insert(materialTaskAssign);
//            }
//        }
//        for (MaterialTaskAppendix materialTaskAppendix : materialTask.getMaterialTaskAppendixList()) {
//            materialTaskAppendix.setMaterialTaskId(materialTask.getId());
//            materialTaskMaterialTaskAppendixMapper.insert(materialTaskAppendix);
//        }

        return materialTask.getId();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean update(MaterialTask materialTask) {
        materialTaskMaterialTaskMapper.updateById(materialTask);
        //********************************* MaterialTaskAssign  增删改  开始 *******************************************/
        {
            if (materialTask.getMaterialTaskAssignList() != null && materialTask.getMaterialTaskAssignList().size() > 0) {
                // 查出所有子级的id
                List<MaterialTaskAssign> materialTaskAssignList = materialTaskMaterialTaskAssignMapper.selectList(Wrappers.lambdaQuery(MaterialTaskAssign.class).eq(MaterialTaskAssign::getMaterialTaskId, materialTask.getId()).select(MaterialTaskAssign::getId));
                List<Long> materialTaskAssignIds = materialTaskAssignList.stream().map(MaterialTaskAssign::getId).collect(Collectors.toList());
                //原有子表单 没有被删除的主键
                List<Long> materialTaskAssignOldIds = materialTask.getMaterialTaskAssignList().stream().map(MaterialTaskAssign::getId).filter(Objects::nonNull).collect(Collectors.toList());
                //找到需要删除的id
                List<Long> materialTaskAssignRemoveIds = materialTaskAssignIds.stream().filter(item -> !materialTaskAssignOldIds.contains(item)).collect(Collectors.toList());

                for (MaterialTaskAssign materialTaskAssign : materialTask.getMaterialTaskAssignList()) {
                    //如果不等于空则修改
                    if (materialTaskAssign.getId() != null) {
                        materialTaskMaterialTaskAssignMapper.updateById(materialTaskAssign);
                    }
                    //如果等于空 则新增
                    else {
                        //已经不存在的id 删除
                        materialTaskAssign.setMaterialTaskId(materialTask.getId());
                        materialTaskMaterialTaskAssignMapper.insert(materialTaskAssign);
                    }
                }
                //已经不存在的id 删除
                if (materialTaskAssignRemoveIds.size() > 0) {
                    materialTaskMaterialTaskAssignMapper.deleteBatchIds(materialTaskAssignRemoveIds);
                }
            }
        }
        //********************************* MaterialTaskAssign  增删改  结束 *******************************************/

        //********************************* MaterialTaskAppendix  增删改  开始 *******************************************/
        {
            // 查出所有子级的id
            List<MaterialTaskAppendix> materialTaskAppendixList = appendixMapper.selectList(Wrappers.lambdaQuery(MaterialTaskAppendix.class).eq(MaterialTaskAppendix::getMaterialTaskId, materialTask.getId()).select(MaterialTaskAppendix::getId));
            List<Long> materialTaskAppendixIds = materialTaskAppendixList.stream().map(MaterialTaskAppendix::getId).collect(Collectors.toList());
            //原有子表单 没有被删除的主键
            List<Long> materialTaskAppendixOldIds = materialTask.getMaterialTaskAppendixList().stream().map(MaterialTaskAppendix::getId).filter(Objects::nonNull).collect(Collectors.toList());
            //找到需要删除的id
            List<Long> materialTaskAppendixRemoveIds = materialTaskAppendixIds.stream().filter(item -> !materialTaskAppendixOldIds.contains(item)).collect(Collectors.toList());

            for (MaterialTaskAppendix materialTaskAppendix : materialTask.getMaterialTaskAppendixList()) {
                //如果不等于空则修改
                if (materialTaskAppendix.getId() != null) {
                    appendixMapper.updateById(materialTaskAppendix);
                }
                //如果等于空 则新增
                else {
                    //已经不存在的id 删除
                    materialTaskAppendix.setMaterialTaskId(materialTask.getId());
                    appendixMapper.insert(materialTaskAppendix);
                }
            }
            //已经不存在的id 删除
            if (materialTaskAppendixRemoveIds.size() > 0) {
                appendixMapper.deleteBatchIds(materialTaskAppendixRemoveIds);
            }
        }
        //********************************* MaterialTaskAppendix  增删改  结束 *******************************************/

        return true;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean delete(List<Long> ids) {
        materialTaskMaterialTaskMapper.deleteBatchIds(ids);
        materialTaskMaterialTaskAssignMapper.delete(Wrappers.lambdaQuery(MaterialTaskAssign.class).in(MaterialTaskAssign::getMaterialTaskId, ids));
        appendixMapper.delete(Wrappers.lambdaQuery(MaterialTaskAppendix.class).in(MaterialTaskAppendix::getMaterialTaskId, ids));

        return true;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean submited(MaterialTaskAssignAppendixDto materialTaskAssignAppendixDto) {

        if(materialTaskAssignAppendixDto.getMaterialCategory().equals(MaterialCategoryEnum.MT0001.getCode())){
            if (materialTaskAssignAppendixDto.getMaterialTaskAppendixList() != null && materialTaskAssignAppendixDto.getMaterialTaskAppendixList().size() > 0) {

                MaterialTaskAssign materialTaskAssign = materialTaskMaterialTaskAssignMapper.selectByIdDeep(materialTaskAssignAppendixDto.getMaterialTaskAssignId());
                Integer oldStatus = materialTaskAssign.getStatus();
                materialTaskAssign.setStatus(2);

                if (oldStatus == 1) {
                    MaterialTask materialTask = materialTaskMaterialTaskMapper.selectByIdDeep(materialTaskAssign.getMaterialTaskId());

                    LocalDate requiredCompleteTime = materialTask.getRequiredCompleteTime();
                    LocalDate today = LocalDate.now();

                    int comparison = today.compareTo(requiredCompleteTime);
                    if (comparison > 0) {//超时提交
                        materialTaskAssign.setExecutiveStatus(3);
                        materialTask.setTimeDelay(materialTask.getTimeDelay() + 1);
                    } else {//准时提交（包含当天）
                        materialTaskAssign.setExecutiveStatus(2);
                        materialTask.setOnTimePerson(materialTask.getOnTimePerson() + 1);
                    }
                    materialTask.setSubmitedPerson(materialTask.getSubmitedPerson() + 1);
                    materialTaskMaterialTaskMapper.updateById(materialTask);
                }
                materialTaskMaterialTaskAssignMapper.updateById(materialTaskAssign);

                if (oldStatus == 4) { // 重做删除原来的
                    appendixMapper.delete(Wrappers.lambdaQuery(MaterialTaskAppendix.class).eq(MaterialTaskAppendix::getMaterialTaskId, materialTaskAssignAppendixDto.getMaterialTaskAssignId()));
                }

                for (AddMaterialTaskAppendixDto materialTaskAppendixDto : materialTaskAssignAppendixDto.getMaterialTaskAppendixList()) {
                    MaterialTaskAppendix materialTaskAppendix = new MaterialTaskAppendix();
                    materialTaskAppendix.setMaterialTaskId(materialTaskAssignAppendixDto.getMaterialTaskAssignId());
                    materialTaskAppendix.setFileId(materialTaskAppendixDto.getFileId());
                    appendixMapper.insert(materialTaskAppendix);
                }
            }
        }

        if(materialTaskAssignAppendixDto.getMaterialCategory().equals(MaterialCategoryEnum.MT0002.getCode())){
            if (materialTaskAssignAppendixDto.getTemplateId() != null && !materialTaskAssignAppendixDto.getFormData().isEmpty()) {

                MaterialTaskAssign materialTaskAssign = materialTaskMaterialTaskAssignMapper.selectByIdDeep(materialTaskAssignAppendixDto.getMaterialTaskAssignId());
                Integer oldStatus = materialTaskAssign.getStatus();
                materialTaskAssign.setStatus(2);

                //状态 1=未提交 2=待审核 3=通过 4=重做
                if (oldStatus == 1) {
                    MaterialTask materialTask = materialTaskMaterialTaskMapper.selectByIdDeep(materialTaskAssign.getMaterialTaskId());

                    LocalDate requiredCompleteTime = materialTask.getRequiredCompleteTime();
                    LocalDate today = LocalDate.now();

                    int comparison = today.compareTo(requiredCompleteTime);
                    if (comparison > 0) {//超时提交
                        materialTaskAssign.setExecutiveStatus(3);
                        materialTask.setTimeDelay(materialTask.getTimeDelay() + 1);
                    } else {//准时提交（包含当天）
                        materialTaskAssign.setExecutiveStatus(2);
                        materialTask.setOnTimePerson(materialTask.getOnTimePerson() + 1);
                    }
                    materialTask.setSubmitedPerson(materialTask.getSubmitedPerson() + 1);
                    materialTaskMaterialTaskMapper.updateById(materialTask);
                }
                materialTaskMaterialTaskAssignMapper.updateById(materialTaskAssign);

                if (oldStatus == 4) { // 重做删除原来的
                    appendixMapper.delete(Wrappers.lambdaQuery(MaterialTaskAppendix.class).eq(MaterialTaskAppendix::getMaterialTaskId, materialTaskAssignAppendixDto.getMaterialTaskAssignId()));
                }

                long id = formExecuteService.addByTemplateId(new FormExecuteAddOrUpdateDto(){{
                    setReleaseId(materialTaskAssignAppendixDto.getTemplateId());
                    setFormData(materialTaskAssignAppendixDto.getFormData());
                }});

                MaterialTaskAppendix materialTaskAppendix = new MaterialTaskAppendix();
                materialTaskAppendix.setMaterialTaskId(materialTaskAssignAppendixDto.getMaterialTaskAssignId());
                materialTaskAppendix.setFileId(id);
                appendixMapper.insert(materialTaskAppendix);
            }
        }
        return true;
    }

    @Override
    public MaterialTaskVo getInfoById(Long id) {
        MPJLambdaWrapper<MaterialTask> queryWrapper = new MPJLambdaWrapper<>();
        queryWrapper
                .orderByDesc(MaterialTask::getId)
                .eq(MaterialTask::getId, id)
                .select(MaterialTask::getId)
                .selectAs(MaterialType::getName, MaterialTaskVo::getMaterialTypeIdCn)
                .selectAs(MaterialType::getCreateDate, MaterialTaskVo::getCreateDate)
                .selectAs(DictionaryDetail::getName, MaterialTaskVo::getMaterialCategoryCn)
                .select(MaterialTask.class, x -> VoToColumnUtil.fieldsToColumns(MaterialTaskVo.class).contains(x.getProperty()))
                .leftJoin(DictionaryDetail.class, DictionaryDetail::getCode, MaterialTask::getMaterialCategory)
                .leftJoin(MaterialType.class, MaterialType::getId, MaterialTask::getMaterialTypeId);
        MaterialTaskVo materialTaskVo = this.selectJoinOne(MaterialTaskVo.class, queryWrapper);

        if (materialTaskVo == null) {
            return materialTaskVo;
        }

        MaterialTypeVo materialTypeVo = materialTypeService.getInfoById(materialTaskVo.getMaterialTypeId());
        if(materialTypeVo == null){
            return materialTaskVo;
        }
        if(materialTaskVo.getMaterialCategory().equals(MaterialCategoryEnum.MT0001.getCode())){
            materialTaskVo.setFolderId(materialTypeVo.getFolderId());
            materialTaskVo.setFolderIdCn(materialTypeVo.getFolderIdCn());
            materialTaskVo.setFiles(materialTypeVo.getFiles());
        }
        if(materialTaskVo.getMaterialCategory().equals(MaterialCategoryEnum.MT0002.getCode())){
            materialTaskVo.setFormReleaseId(materialTypeVo.getFormReleaseId());
            materialTaskVo.setFormReleaseIdCn(materialTypeVo.getFormReleaseIdCn());
        }


//        MPJLambdaWrapper<MaterialTaskAssign> materialTaskAssignMPJLambdaWrapper = new MPJLambdaWrapper<>();
//        materialTaskAssignMPJLambdaWrapper
//                .orderByDesc(MaterialTaskAssign::getCreateDate)
//                .eq(MaterialTaskAssign::getMaterialTaskId, id)
//                .select(MaterialTask::getId)
//                .selectAs(MaterialType::getName, MaterialTaskVo::getMaterialTypeIdCn)
//                .selectAs(MaterialType::getCreateDate, MaterialTaskVo::getCreateDate)
//                .selectAs(DictionaryDetail::getName, MaterialTaskVo::getMaterialCategoryCn)
//                .select(MaterialTask.class, x -> VoToColumnUtil.fieldsToColumns(MaterialTaskVo.class).contains(x.getProperty()))
//                .leftJoin(DictionaryDetail.class, DictionaryDetail::getCode, MaterialTask::getMaterialCategory)
//                .leftJoin(MaterialType.class, MaterialType::getId, MaterialTask::getMaterialTypeId);
//        MaterialTaskVo materialTaskVo = materialTaskMaterialTaskAssignMapper.selectJoinOne(MaterialTaskVo.class, queryWrapper);

//        List<MaterialTaskAppendixVo> newsAppendixVoList = materialTaskAppendixService.selectJoinList(MaterialTaskAppendixVo.class,
//                new MPJLambdaWrapper<MaterialTaskAppendix>().eq(MaterialTaskAppendix::getMaterialTaskId, id)
//                        .select(MaterialTaskAppendix::getId)
//                        .select(MaterialTaskAppendix.class, x -> VoToColumnUtil.fieldsToColumns(MaterialTaskAppendixVo.class).contains(x.getProperty()))
//                        .leftJoin(File.class, File::getId, MaterialTaskAppendix::getFileId, ext -> ext.selectAs(File::getFileName, MaterialTaskAppendixVo::getFileName)
//                                .selectAs(File::getFolderId, MaterialTaskAppendixVo::getFolderId)
//                                .selectAs(File::getFileUrl, MaterialTaskAppendixVo::getFileUrl))
//        );
//
//        if (newsAppendixVoList.size() > 0) {
//            materialTaskVo.setMaterialTaskAppendixList(newsAppendixVoList);
//        }
        return materialTaskVo;
    }

    @Override
    public MaterialTaskVo getInfoViewById(Long id) {
        MaterialTaskVo materialTaskVo = getInfoById(id);

        MPJLambdaWrapper<MaterialTaskAssign> materialTaskAssignMPJLambdaWrapper = new MPJLambdaWrapper<>();
        materialTaskAssignMPJLambdaWrapper
                .orderByDesc(MaterialTaskAssign::getCreateDate)
                .eq(MaterialTaskAssign::getMaterialTaskId, id)
                .eq(MaterialTaskAssign::getUserId, StpUtil.getLoginIdAsLong());

        MaterialTaskAssign materialTaskAssignVo = materialTaskMaterialTaskAssignMapper
                .selectOne(Wrappers.lambdaQuery(MaterialTaskAssign.class)
                        .eq(MaterialTaskAssign::getMaterialTaskId, id)
                        .eq(MaterialTaskAssign::getUserId, StpUtil.getLoginIdAsLong())
                );

        List<MaterialTaskAppendixVo> newsAppendixVoList = materialTaskAppendixService.selectJoinList(MaterialTaskAppendixVo.class,
                new MPJLambdaWrapper<MaterialTaskAppendix>()
                        .eq(MaterialTaskAppendix::getMaterialTaskId, materialTaskAssignVo.getId())
                        .select(MaterialTaskAppendix::getId)
                        .select(MaterialTaskAppendix.class, x -> VoToColumnUtil.fieldsToColumns(MaterialTaskAppendixVo.class).contains(x.getProperty()))
                        .leftJoin(File.class, File::getId, MaterialTaskAppendix::getFileId, ext -> ext.selectAs(File::getFileName, MaterialTaskAppendixVo::getFileName)
                                .selectAs(File::getFolderId, MaterialTaskAppendixVo::getFolderId)
                                .selectAs(File::getFileUrl, MaterialTaskAppendixVo::getFileUrl))
        );

        if (newsAppendixVoList.size() > 0) {
            materialTaskVo.setMaterialTaskAppendixList(newsAppendixVoList);
        }
        return materialTaskVo;
    }

    @Override
    public void sendMessage(Long materialTaskId) {
        MaterialTask materialTask = this.getById(materialTaskId);
        if(materialTask == null){
            return;
        }

        LambdaQueryWrapper<MaterialTaskAssign> materialTaskAssignLambdaQueryWrapper = new LambdaQueryWrapper<>();
        materialTaskAssignLambdaQueryWrapper
                .orderByDesc(MaterialTaskAssign::getCreateDate)
                .eq(MaterialTaskAssign::getMaterialTaskId, materialTaskId)
                .select(MaterialTaskAssign::getId)
                .select(MaterialTaskAssign.class, x -> VoToColumnUtil.fieldsToColumns(MaterialTaskAssign.class).contains(x.getProperty()));
        List<MaterialTaskAssign> materialTaskAssignList = materialTaskMaterialTaskAssignMapper.selectList(materialTaskAssignLambdaQueryWrapper);

        if(!materialTaskAssignList.isEmpty()){
            materialTask.setMaterialTaskAssignList(materialTaskAssignList);
        }

        CompletableFuture.runAsync(() -> {
            this.sendMessageUtil(materialTask);
        });
    }

    @Override
    public List<MaterialTaskAssignListVo> assignList(MaterialTaskAssignListDto dto) {

        MPJLambdaWrapper<MaterialTaskAssign> queryWrapper = new MPJLambdaWrapper<>();
        queryWrapper
                .select(MaterialTaskAssign::getMaterialTaskId)
                .select(MaterialTaskAssign.class, x -> VoToColumnUtil.fieldsToColumns(MaterialTaskAssign.class).contains(x.getProperty()))
                .selectAs(XjrUser::getName, MaterialTaskAssignListVo::getName)
                .selectAs(XjrUser::getUserName, MaterialTaskAssignListVo::getUserName)
                .selectAs(XjrUser::getUserName, MaterialTaskAssignListVo::getUserNumber)
                .selectAs(Department::getName, MaterialTaskAssignListVo::getDeptName)
                .leftJoin(XjrUser.class, XjrUser::getId, MaterialTaskAssign::getUserId)
                .leftJoin(UserDeptRelation.class, UserDeptRelation::getUserId, MaterialTaskAssign::getUserId)
                .leftJoin(Department.class, Department::getId, UserDeptRelation::getDeptId)
                .eq(MaterialTaskAssign::getMaterialTaskId, dto.getMaterialTaskId())
        ;

        List<MaterialTaskAssignListVo> pageOutput = materialTaskMaterialTaskAssignMapper.selectJoinList(MaterialTaskAssignListVo.class, queryWrapper);

        List<MaterialTaskAppendix> appendixList = appendixMapper.selectJoinList(MaterialTaskAppendix.class,
                new MPJLambdaWrapper<MaterialTaskAppendix>()
                        .select(MaterialTaskAppendix::getMaterialTaskId)
                        .select(MaterialTaskAppendix.class, x -> VoToColumnUtil.fieldsToColumns(MaterialTaskAppendix.class).contains(x.getProperty()))
                        .innerJoin(MaterialTaskAssign.class, MaterialTaskAssign::getId, MaterialTaskAppendix::getMaterialTaskId)
                        .eq(MaterialTaskAssign::getMaterialTaskId, dto.getMaterialTaskId())
        );
        Map<Long, List<MaterialTaskAppendix>> appendixFileMap = appendixList.stream().collect(Collectors.groupingBy(MaterialTaskAppendix::getMaterialTaskId));

        for (MaterialTaskAssignListVo el : pageOutput){
            materialTypeService.handleFileAndTemplate(el, el.getMaterialCategory());
            List<Long> fileIds = appendixFileMap.get(el.getId()).stream().map(MaterialTaskAppendix::getFileId).collect(Collectors.toList());
            List<File> fileList = fileService.list(Wrappers.<File>query().lambda().in(File::getFolderId, fileIds));
            el.setFiles(fileList);
        }

        return pageOutput;
    }

    @Override
    public ByteArrayOutputStream formDataExportQuery(FormDataExportQueryDto dto) {
        //自定义表单数据
        FormTemplate template = formTemplateMapper.selectById(dto.getTemplateId());

        String formJson = template.getFormJson();
        //自定义表单配置
        FormDesignConfig formDesignConfig = JSONUtil.toBean(formJson, FormDesignConfig.class);
        //表关系配置
        List<TableConfig> tableConfigs = formDesignConfig.getTableConfigs();
        //主表
        Optional<TableConfig> mainTable = tableConfigs.stream().filter(TableConfig::getIsMain).findFirst();

        if (mainTable.isPresent()) {
            TableConfig tableConfig = mainTable.get();
            String tableName = tableConfig.getTableName();

            Map<String, List<ComponentConfig>> formComponentListMap = GeneratorUtil.buildFormComponentList(formDesignConfig.getFormJson().getList());
            List<String> fieldsList = new ArrayList<>();
            for (ComponentConfig config : formComponentListMap.get(tableName)) {
                String type = config.getType();
                if (StrUtil.equalsIgnoreCase(type, ComponentTypeConstant.TIME_RANGE) || StrUtil.equalsIgnoreCase(type, ComponentTypeConstant.DATE_RANGE)) {
                    fieldsList.add(config.getBindStartTime());
                    fieldsList.add(config.getBindEndTime());
                } else {
                    fieldsList.add(config.getBindField());
                }
            }

            //return getFormData(tableName, fieldsList, formDesignConfig, dto.getId());
        } else {
            throw new MyException("主表不存在");
        }
        return null;
    }

    @Override
    public byte[] downloadFile(MaterialTaskAssignListDto dto) {

        MPJLambdaWrapper<MaterialTaskAppendix> queryWrapper = new MPJLambdaWrapper<>();
        queryWrapper
                .disableSubLogicDel()
                .distinct()
                .select(MaterialTaskAppendix::getId)
                .select(MaterialTaskAppendix.class, x -> VoToColumnUtil.fieldsToColumns(MaterialTaskAppendix.class).contains(x.getProperty()))
                .innerJoin(MaterialTaskAssign.class, MaterialTaskAssign::getId, MaterialTaskAppendix::getMaterialTaskId)
                .eq(MaterialTaskAssign::getMaterialTaskId, dto.getMaterialTaskId())
                .eq(MaterialTaskAssign::getStatus, dto.getState())
        ;

        List<MaterialTaskAppendix> appendices = appendixMapper.selectJoinList(MaterialTaskAppendix.class, queryWrapper);
        if(appendices.isEmpty()){
            throw new MyException("未能查询到附件");
        }
        List<Long> userIds = appendices.stream().map(MaterialTaskAppendix::getCreateUserId).collect(Collectors.toList());
        List<User> userList = userService.listByIds(userIds);
        Map<Long, User> userMap = userList.stream().collect(Collectors.toMap(User::getId, x -> x));

        Map<String, byte[]> byteAryMap = new HashMap<>();
        MaterialTask task = this.getById(dto.getMaterialTaskId());
        int sortCode = 1;
        for (MaterialTaskAppendix appendix : appendices) {
            List<File> fileList = fileService.list(Wrappers.<File>query().lambda().eq(File::getId, appendix.getFileId()));
            User user = userMap.get(appendix.getCreateUserId());

            for (int i = 0; i < fileList.size(); i++) {
                try {
                    URL url = new URL(fileList.get(i).getFileUrl());
                    URLConnection conn = url.openConnection();
                    InputStream in = conn.getInputStream();
                    ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
                    byte[] buffer = new byte[1024];
                    int bytesRead;
                    while ((bytesRead = in.read(buffer)) != -1) {
                        outputStream.write(buffer, 0, bytesRead);
                    }
                    byte[] byteArray = outputStream.toByteArray();
                    String fileName = sortCode + "-" + user.getName() + "-" + user.getUserName() + "-" + task.getName();
                    if(fileList.size() > 1){
                        fileName += "-" + (i + 1);
                    }
                    fileName += fileList.get(i).getFileType();
                    byteAryMap.put(fileName, byteArray);
                    in.close();
                    outputStream.close();
                    sortCode ++;
                } catch (IOException e) {
                    throw new MyException("文件下载失败", e);
                }
            }
        }

        return FileZipUtil.byteAryMap2Zip(byteAryMap);
    }

    private void sendMessageUtil(MaterialTask materialTask ) {
        IUserService userService = SpringUtil.getBean(IUserService.class);
        RedisUtil redisUtil = SpringUtil.getBean(RedisUtil.class);
        List<User> userList = redisUtil.get(GlobalConstant.USER_CACHE_KEY, new TypeReference<List<User>>() {
        });
        //如果缓存中不存在用户信息，就直接去数据库查询,并保存到缓存中去
        if (userList.size() == 0) {
            userList = userService.list();
            redisUtil.set(GlobalConstant.USER_CACHE_KEY, userList);
        }

        if(materialTask.getCreateUserId() == null){
            return;
        }

        User createUser = userList.stream().filter(u -> materialTask.getCreateUserId().equals(u.getId())).findFirst().orElse(new User());

        for (MaterialTaskAssign materialTaskAssign : materialTask.getMaterialTaskAssignList()) {

            User materialTaskAssignUser = userList.stream().filter(u -> materialTaskAssign.getUserId().equals(u.getId())).findFirst().orElse(new User());

            WeChatSendMessageDto weChatSendMessageDto = new WeChatSendMessageDto();
            weChatSendMessageDto.setUserId(materialTaskAssignUser.getOpenId());
            weChatSendMessageDto.setTemplateId("qmpXORPM1Cocqn503Qa4On6BJhR92UZ00eod2-6IcGo");
            //weChatSendMessageDto.setUrl(StrUtil.format("{}/pages/message/notice/detail?id={}", commonPropertiesConfig.getDomainApp(), id));
            weChatSendMessageDto.setMsgId(materialTask.getId().toString());
            JSONObject data = new JSONObject();

            JSONObject data1 = new JSONObject();
            data1.put("value", materialTask.getName());
            data.put("thing23", data1);

            JSONObject data2 = new JSONObject();
            data2.put("value", createUser.getName());
            data.put("thing29", data2);

            JSONObject data3 = new JSONObject();
            data3.put("value", materialTask.getRequiredCompleteTime());
            data.put("time17", data3);
            weChatSendMessageDto.setContent(data);
            weChatService.sendTemplateMessage(weChatSendMessageDto);
        };
    }
}