修改内审

“djh”

2025-12-03 e32ac074e0cdc07b7551155e2e1c24684857f2b7

 multi-system/src/main/java/com/gkhy/exam/system/service/impl/InternalAuditCheckServiceImpl.java

@@ -10,22 +10,21 @@
import com.gkhy.exam.common.utils.PageUtils;
import com.gkhy.exam.common.utils.SecurityUtils;
import com.gkhy.exam.system.domain.InternalAuditCheck;
import com.gkhy.exam.system.domain.InternalAuditCheckCatalogue;
import com.gkhy.exam.system.domain.InternalAuditCheckContent;
import com.gkhy.exam.system.domain.InternalAuditCheckPerson;
import com.gkhy.exam.system.domain.vo.InternalAuditCheckVo;
import com.gkhy.exam.system.mapper.InternalAuditCheckMapper;
import com.gkhy.exam.system.mapper.InternalAuditCheckPersonMapper;
import com.gkhy.exam.system.mapper.SysDeptMapper;
import com.gkhy.exam.system.mapper.SysUserMapper;
import com.gkhy.exam.system.mapper.*;
import com.gkhy.exam.system.service.InternalAuditCheckService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
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 java.time.LocalDateTime;
import java.util.List;
import java.util.Set;
import java.util.*;
import java.util.stream.Collectors;

/**
@@ -41,8 +40,13 @@

    @Autowired
    private InternalAuditCheckMapper internalAuditCheckMapper;

    @Autowired
    private InternalAuditCheckPersonMapper internalAuditCheckPersonMapper;
    private InternalAuditCheckCatalogueMapper checkCatalogueMapper;

    @Autowired
    private InternalAuditCheckContentMapper checkContentMapper;

    @Autowired
    private SysUserMapper sysUserMapper;
    @Autowired
@@ -51,153 +55,159 @@
    public CommonPage selectInternalAuditCheckList(Integer companyId) {
        PageUtils.startPage();
        List<InternalAuditCheck> internalAuditChecks = internalAuditCheckMapper.selectInternalAuditCheckList(companyId);
        if (!CollectionUtils.isEmpty(internalAuditChecks)) {
            batchLoadCheckDetails(internalAuditChecks);
        }
        return CommonPage.restPage(internalAuditChecks);
    }

    private void batchLoadCheckDetails(List<InternalAuditCheck> checks) {
        //收集所有检查ID
        List<Integer> checkIds = checks.stream()
                .map(InternalAuditCheck::getId)
                .collect(Collectors.toList());

        //批量查询所有目录
        List<InternalAuditCheckCatalogue> allCatalogues = checkCatalogueMapper.selectByCheckIds(checkIds);

        if (CollectionUtils.isEmpty(allCatalogues)) {
            return;
        }

        //收集所有目录ID
        List<Integer> catalogueIds = allCatalogues.stream()
                .map(InternalAuditCheckCatalogue::getId)
                .collect(Collectors.toList());

        //按检查ID分组目录
        Map<Integer, List<InternalAuditCheckCatalogue>> catalogueMap = allCatalogues.stream()
                .collect(Collectors.groupingBy(InternalAuditCheckCatalogue::getCheckId));

        //组装数据
        for (InternalAuditCheck check : checks) {
            List<InternalAuditCheckCatalogue> catalogues = catalogueMap.get(check.getId());
            if (!CollectionUtils.isEmpty(catalogues)) {
                check.setCheckCatalogues(catalogues);
            }
        }
    }

    @Override
    @Transactional
    public CommonResult insertInternalAuditCheck(InternalAuditCheckVo internalAuditCheck) {
        InternalAuditCheck internalAuditCheck1 = new InternalAuditCheck();
        BeanUtils.copyProperties(internalAuditCheck,internalAuditCheck1);
        internalAuditCheck1.setCreateTime(LocalDateTime.now());
        internalAuditCheck1.setCreateBy(SecurityUtils.getUsername());
    public CommonResult insertInternalAuditCheck(InternalAuditCheck internalAuditCheck) {

        int insert = internalAuditCheckMapper.insert(internalAuditCheck1);
        if (insert > 0) {
            if (ObjectUtil.isNotEmpty(internalAuditCheck.getInternalAuditCheckPeople())){
                batchInsert(internalAuditCheck.getInternalAuditCheckPeople(),internalAuditCheck1.getId());
        Map<String, Object> stringObjectHashMap = new HashMap<>();
        stringObjectHashMap.put("dept_id",internalAuditCheck.getDeptId());
        stringObjectHashMap.put("year",internalAuditCheck.getYear());
        stringObjectHashMap.put("company_id",internalAuditCheck.getCompanyId());
        stringObjectHashMap.put("del_flag",0);
        List<InternalAuditCheck> internalAuditChecks = internalAuditCheckMapper.selectByMap(stringObjectHashMap);
        if (!CollectionUtils.isEmpty(internalAuditChecks)){
            return CommonResult.failed("当前部门存在，请勿重复添加");
        }

        internalAuditCheck.setCreateBy(SecurityUtils.getUsername());
        internalAuditCheck.setCreateTime(LocalDateTime.now());
        int insert = internalAuditCheckMapper.insert(internalAuditCheck);
        if (insert <= 0) {
            return CommonResult.failed("新增内审检查失败");
        }
        //处理目录和内容的插入
        List<InternalAuditCheckCatalogue> checkCatalogues = internalAuditCheck.getCheckCatalogues();
        if (CollectionUtils.isEmpty(checkCatalogues)) {
            return CommonResult.success();
        }
        //批量处理目录和内容
        for (InternalAuditCheckCatalogue catalogue : checkCatalogues) {
            catalogue.setCheckId(internalAuditCheck.getId());
        }

        // 批量插入目录
        int catalogueInsertCount = checkCatalogueMapper.insertBatch(checkCatalogues);

        if (catalogueInsertCount != checkCatalogues.size()) {
            throw new RuntimeException("插入目录记录数量不匹配");
        }
        return CommonResult.success();

    }

    @Override
    public CommonResult updateInternalAuditCheck(InternalAuditCheck internalAuditCheck) {
        internalAuditCheck.setUpdateBy(SecurityUtils.getUsername());
        internalAuditCheck.setUpdateTime(LocalDateTime.now());
        int update = internalAuditCheckMapper.updateById(internalAuditCheck);
        if (update>0){
            List<InternalAuditCheckCatalogue> checkCatalogues = internalAuditCheck.getCheckCatalogues();
            if (CollectionUtils.isEmpty(checkCatalogues)) {
                return CommonResult.success();
            }
            for (InternalAuditCheckCatalogue catalogue : checkCatalogues) {
                catalogue.setCheckId(internalAuditCheck.getId());
            }

            // 批量插入目录
             checkCatalogueMapper.updateCheckCatalogues(checkCatalogues);

            return CommonResult.success();
        }
        return CommonResult.failed();
    }

    private void batchInsert(List<InternalAuditCheckPerson> internalAuditCheckPeople,Long auditId) {
        internalAuditCheckPeople.forEach(e -> {
            e.setAuditId(auditId);
            e.setCreateTime(LocalDateTime.now());
            e.setCreateBy(SecurityUtils.getUsername());
        });
        internalAuditCheckPersonMapper.batchInsert(internalAuditCheckPeople);
    }

    private void batchUpdate(List<InternalAuditCheckPerson> internalAuditCheckPeople) {
        internalAuditCheckPeople.forEach(e -> {
            e.setUpdateTime(LocalDateTime.now());
            e.setUpdateBy(SecurityUtils.getUsername());
        });
        internalAuditCheckPersonMapper.batchUpdate(internalAuditCheckPeople);
    }

    @Override
    public CommonResult updateInternalAuditCheck(InternalAuditCheckVo internalAuditCheck) {
        InternalAuditCheck internalAuditCheck1 = new InternalAuditCheck();
        BeanUtils.copyProperties(internalAuditCheck,internalAuditCheck1);
        internalAuditCheck1.setUpdateTime(LocalDateTime.now());
        internalAuditCheck1.setUpdateBy(SecurityUtils.getUsername());

        int update = internalAuditCheckMapper.updateById(internalAuditCheck1);
        if (update > 0) {
            List<InternalAuditCheckPerson> internalAuditCheckPeople = internalAuditCheck.getInternalAuditCheckPeople();
            if (ObjectUtil.isNotEmpty(internalAuditCheckPeople)){
                Set<Long> collect = internalAuditCheckPeople.stream().map(InternalAuditCheckPerson::getAuditUserId)
                        .collect(Collectors.toSet());
                if (collect.size() != internalAuditCheckPeople.size()){
                    throw new ApiException("受审人员重复");
                }
                LambdaQueryWrapper<InternalAuditCheckPerson> queryWrapper = new LambdaQueryWrapper<>();
                queryWrapper.eq(InternalAuditCheckPerson::getAuditId, internalAuditCheck.getId());
                queryWrapper.eq(InternalAuditCheckPerson::getDelFlag, 0);
                List<InternalAuditCheckPerson> internalAuditCheckPeople1 = internalAuditCheckPersonMapper.selectList(queryWrapper);

                List<Long> idsAll = internalAuditCheckPeople1.stream()
                        .map(InternalAuditCheckPerson::getId)
                        .collect(Collectors.toList());


                List<Long> idsUpdate = internalAuditCheckPeople.stream()
                        .map(InternalAuditCheckPerson::getId)
                        .filter(id -> id != null) // 过滤掉 null 值
                        .collect(Collectors.toList());
                if (!idsUpdate.isEmpty() && !idsAll.isEmpty()){
                    //不存在的删除
                    List<Long> result = idsAll.stream()
                            .filter(id -> !idsUpdate.contains(id))
                            .collect(Collectors.toList());
                    if (!result.isEmpty()){
                        batchDel(internalAuditCheck.getId(),result);
                    }
                }



                List<InternalAuditCheckPerson> withId = internalAuditCheckPeople.stream()
                        .filter(e -> e.getId() != null)
                        .collect(Collectors.toList());
                //修改的
                if (!withId.isEmpty()){
                    batchUpdate(withId);
                }

                List<InternalAuditCheckPerson> withoutId = internalAuditCheckPeople.stream()
                        .filter(e -> e.getId() == null)
                        .collect(Collectors.toList());

                //新增的
                if (!withoutId.isEmpty()){
                    batchInsert(withoutId,internalAuditCheck.getId());
                }
            }else {
                batchDel(internalAuditCheck.getId(),null);
            }


            return CommonResult.success(update);
        }
        return CommonResult.failed();
    }

    private void batchDel(Long id,List<Long> ids){
        LambdaQueryWrapper<InternalAuditCheckPerson> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(InternalAuditCheckPerson::getAuditId, id);
        if (ObjectUtil.isNotEmpty(ids)){
            queryWrapper.in(InternalAuditCheckPerson::getId, ids);
        }
        InternalAuditCheckPerson internalAuditCheckPerson = new InternalAuditCheckPerson();
        internalAuditCheckPerson.setDelFlag(1);
        internalAuditCheckPerson.setUpdateTime(LocalDateTime.now());
        internalAuditCheckPerson.setUpdateBy(SecurityUtils.getUsername());
        internalAuditCheckPersonMapper.update(internalAuditCheckPerson,queryWrapper);
    }

    @Override
    @Transactional
    public CommonResult deletedInternalAuditCheck(Integer id) {
        int delete = internalAuditCheckMapper.deleteById(id);
        LambdaQueryWrapper<InternalAuditCheckPerson> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(InternalAuditCheckPerson::getAuditId, id);
        InternalAuditCheckPerson internalAuditCheckPerson = new InternalAuditCheckPerson();
        internalAuditCheckPerson.setDelFlag(1);
        internalAuditCheckPerson.setUpdateTime(LocalDateTime.now());
        internalAuditCheckPerson.setUpdateBy(SecurityUtils.getUsername());
        internalAuditCheckPersonMapper.update(internalAuditCheckPerson,queryWrapper);
        InternalAuditCheck internalAuditCheck = new InternalAuditCheck();
        internalAuditCheck.setId(id);
        internalAuditCheck.setUpdateBy(SecurityUtils.getUsername());
        internalAuditCheck.setUpdateTime(LocalDateTime.now());
        internalAuditCheck.setDelFlag(2);
        int update = internalAuditCheckMapper.updateById(internalAuditCheck);
        return CommonResult.success();
    }

    @Override
    public CommonResult internalAuditCheckInfo(Integer id) {
        InternalAuditCheck internalAuditCheck = internalAuditCheckMapper.selectById(id);
    public CommonResult updateByYearAndDeptId(InternalAuditCheck internalAuditCheck) {

        InternalAuditCheckVo internalAuditCheckVo = new InternalAuditCheckVo();
        BeanUtils.copyProperties(internalAuditCheck,internalAuditCheckVo);
        internalAuditCheckVo.setDeptName(sysDeptMapper.selectDeptById(internalAuditCheck.getDeptId()).getDeptName());
        internalAuditCheckVo.setAuditName(sysUserMapper.selectById(internalAuditCheck.getAuditId()).getName());
        LambdaQueryWrapper<InternalAuditCheckPerson> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(InternalAuditCheckPerson::getAuditId, id);
        queryWrapper.eq(InternalAuditCheckPerson::getDelFlag, 0);
        List<InternalAuditCheckPerson> internalAuditCheckPeople = internalAuditCheckPersonMapper.selectList(queryWrapper);
        internalAuditCheckVo.setInternalAuditCheckPeople(internalAuditCheckPeople);
        internalAuditCheck.setUpdateBy(SecurityUtils.getUsername());
        internalAuditCheck.setUpdateTime(LocalDateTime.now());
        Integer update = internalAuditCheckMapper.updateByYearAndDeptId(internalAuditCheck);
        if (update>0){
            checkCatalogueMapper.updatebyCheckId(internalAuditCheck.getId());
            List<InternalAuditCheckCatalogue> checkCatalogues = internalAuditCheck.getCheckCatalogues();
            for (InternalAuditCheckCatalogue catalogue : checkCatalogues) {
                catalogue.setCheckId(internalAuditCheck.getId());
            }

        return CommonResult.success(internalAuditCheckVo);
            // 批量插入目录
            int catalogueInsertCount = checkCatalogueMapper.saveBatch(checkCatalogues);

            if (catalogueInsertCount != checkCatalogues.size()) {
                throw new RuntimeException("插入目录记录数量不匹配");
            }
        }
        return CommonResult.success();
    }

    @Override
    public List<InternalAuditCheck> selectByMap(Map<String, Object> stringObjectHashMap) {
        return internalAuditCheckMapper.selectByMap(stringObjectHashMap);
    }

//    @Override
//    public CommonResult internalAuditCheckInfo(Integer id) {
//        InternalAuditCheck internalAuditCheck = internalAuditCheckMapper.selectById(id);
//
//        InternalAuditCheckVo internalAuditCheckVo = new InternalAuditCheckVo();
//        BeanUtils.copyProperties(internalAuditCheck,internalAuditCheckVo);
//        internalAuditCheckVo.setDeptName(sysDeptMapper.selectDeptById(internalAuditCheck.getDeptId()).getDeptName());
//        internalAuditCheckVo.setAuditName(sysUserMapper.selectById(internalAuditCheck.getAuditId()).getName());
//        LambdaQueryWrapper<InternalAuditCheckPerson> queryWrapper = new LambdaQueryWrapper<>();
//        queryWrapper.eq(InternalAuditCheckPerson::getAuditId, id);
//        queryWrapper.eq(InternalAuditCheckPerson::getDelFlag, 0);
//        List<InternalAuditCheckPerson> internalAuditCheckPeople = internalAuditCheckPersonMapper.selectList(queryWrapper);
//        internalAuditCheckVo.setInternalAuditCheckPeople(internalAuditCheckPeople);
//
//        return CommonResult.success(internalAuditCheckVo);
//    }
}