修改修复问题

heheng

2025-09-30 fafdd541995d0f094692eeebd744caf6e246fb2e

修改修复问题

 multi-admin/src/main/java/com/gkhy/exam/admin/controller/web/InternalKnowledgeController.java

@@ -35,6 +35,7 @@
            @ApiImplicitParam(paramType = "query", name = "pageNum", dataType = "int", required = false, value = "当前页,默认1"),
            @ApiImplicitParam(paramType = "query", name = "pageSize", dataType = "int", required = false, value = "每页数目,默认10"),
            @ApiImplicitParam(paramType = "query", name = "companyId", dataType = "int", required = false, value = "公司id"),
            @ApiImplicitParam(paramType = "query", name = "knowledgeType", dataType = "int", required = false, value = "1、体系2、项目3、其他 4、技术文件 5、知识产权 6、质量服务标准"),
    })
    @GetMapping("/selectInternalKnowledgeList")
    public CommonResult selectInternalKnowledgeList(InternalKnowledge internalKnowledge){

 multi-system/src/main/java/com/gkhy/exam/system/domain/AnnualVerificationDevice.java

@@ -94,5 +94,11 @@
    @TableField("version")
    private Integer version;

    @ApiModelProperty("检定证书")
    @TableField("certificate")
    private String certificate;

    @ApiModelProperty("检定证书名称")
    @TableField("certificate_name")
    private String certificateName;
}

 multi-system/src/main/java/com/gkhy/exam/system/domain/AnnualVerificationPlan.java

@@ -78,11 +78,11 @@
    @NotNull(message = "审核日期不能为空")
    private LocalDateTime processTime;

    @ApiModelProperty("检定证书")
    @ApiModelProperty(value = "检定证书",hidden = true)
    @TableField("certificate")
    private String certificate;

    @ApiModelProperty("检定证书名称")
    @ApiModelProperty(value = "检定证书名称",hidden = true)
    @TableField("certificate_name")
    private String certificateName;


 multi-system/src/main/java/com/gkhy/exam/system/domain/InternalKnowledge.java

@@ -43,7 +43,7 @@
    @NotBlank(message = "名称不能为空")
    private String name;

    @ApiModelProperty(value ="1、体系2、项目3、其他",required = true)
    @ApiModelProperty(value ="1、体系2、项目3、其他 4、技术文件 5、知识产权 6、质量服务标准",required = true)
    @TableField("knowledge_type")
    @NotNull(message = "类型不能为空")
    private Integer knowledgeType;

 multi-system/src/main/java/com/gkhy/exam/system/domain/StandingBook.java

@@ -57,6 +57,10 @@
    @NotNull(message = "责任人/使用人不能为空")
    private Long personResponsible;

    @ApiModelProperty(value = "责任人/使用人名称")
    @TableField(exist = false)
    private String personResponsibleName;

    @ApiModelProperty("设备类型1生成设备2办公自动化设备")
    @TableField("device_type")
    @NotNull(message = "设备类型不能为空")

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

@@ -6,6 +6,7 @@
import com.gkhy.exam.common.api.CommonPage;
import com.gkhy.exam.common.api.CommonResult;
import com.gkhy.exam.common.constant.UserConstant;
import com.gkhy.exam.common.exception.ApiException;
import com.gkhy.exam.common.utils.PageUtils;
import com.gkhy.exam.common.utils.SecurityUtils;
import com.gkhy.exam.system.domain.AnnualMaintenanceEvaluate;
@@ -83,7 +84,7 @@
                            .in(AnnualMaintenanceEvaluateDevice::getId, evaluateDeviceIds)
            );
            if (update <= 0){
                throw new RuntimeException("保存年度基础设施维护计划设备失败");
                throw new ApiException("保存年度基础设施维护计划设备失败");
            }
        }

@@ -96,7 +97,7 @@
            });
            int insert = annualMaintenanceEvaluateDeviceMapper.batchInsert(addData);
            if (insert <= 0){
                throw new RuntimeException("保存年度基础设施维护计划设备失败");
                throw new ApiException("保存年度基础设施维护计划设备失败");
            }
        }

@@ -108,7 +109,7 @@
            });
            int update = annualMaintenanceEvaluateDeviceMapper.batchUpdate(updateData);
            if (update <= 0){
                throw new RuntimeException("保存年度基础设施维护计划设备失败");
                throw new ApiException("保存年度基础设施维护计划设备失败");
            }
        }
    }
@@ -145,7 +146,7 @@
                            .set(AnnualMaintenanceEvaluateDevice::getUpdateTime, LocalDateTime.now())
                            .set(AnnualMaintenanceEvaluateDevice::getUpdateBy, SecurityUtils.getUsername()));
            if (update1 <= 0){
                throw new RuntimeException("删除年度基础设施维护计划设备失败");
                throw new ApiException("删除年度基础设施维护计划设备失败");
            }
            return CommonResult.success("删除成功");
        }

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

@@ -6,6 +6,7 @@
import com.gkhy.exam.common.api.CommonPage;
import com.gkhy.exam.common.api.CommonResult;
import com.gkhy.exam.common.constant.UserConstant;
import com.gkhy.exam.common.exception.ApiException;
import com.gkhy.exam.common.utils.PageUtils;
import com.gkhy.exam.common.utils.SecurityUtils;
import com.gkhy.exam.system.domain.AnnualMaintenanceRecord;
@@ -78,19 +79,23 @@
                .map(AnnualMaintenanceRecordUser::getUserId)
                .collect(Collectors.toSet());
        if (userIdSet.size() != filteredUsers.size()){
            throw new RuntimeException("年度基础设施维护记录操作管理人员重复");
            throw new ApiException("年度基础设施维护记录操作管理人员重复");
        }
        //维修员
        List<AnnualMaintenanceRecordUser> fixUsers = annualMaintenanceRecordUsers.stream()
                .filter(user -> 2 == user.getUserType())
                .collect(Collectors.toList());
        Set<Long> fixUserIdSet = fixUsers.stream()
                .map(AnnualMaintenanceRecordUser::getUserId)
                .collect(Collectors.toSet());
        if (fixUserIdSet.size() != fixUsers.size()){
            throw new RuntimeException("年度基础设施维护记录人员重复");
        if (!ObjectUtils.isEmpty(fixUsers)){
            Set<Long> fixUserIdSet = fixUsers.stream()
                    .map(AnnualMaintenanceRecordUser::getUserId)
                    .collect(Collectors.toSet());
            if (fixUserIdSet.size() != fixUsers.size()){
                throw new ApiException("年度基础设施维护记录人员重复");
            }
        }
        if (ObjectUtils.isEmpty(filteredUsers) || ObjectUtils.isEmpty(fixUsers)){
            throw new RuntimeException("年度基础设施维护记录人员或操作管理人员不能为空");

        if (ObjectUtils.isEmpty(filteredUsers) ){
            throw new ApiException("年度基础设施维护记录操作管理人员不能为空");
        }

        if (ObjectUtils.isNotEmpty(delRecordUserIds)){
@@ -101,7 +106,7 @@
                            .in(AnnualMaintenanceRecordUser::getId, delRecordUserIds)
            );
            if (update <= 0){
                throw new RuntimeException("删除年度基础设施维护记录人员失败");
                throw new ApiException("删除年度基础设施维护记录人员失败");
            }
        }

@@ -114,7 +119,7 @@
            });
            int insert = annualMaintenanceRecordUserMapper.batchInsert(annualMaintenanceRecordUsers);
            if (insert <= 0){
                throw new RuntimeException("保存年度基础设施维护记录人员失败");
                throw new ApiException("保存年度基础设施维护记录人员失败");
            }
        }else {
            List<AnnualMaintenanceRecordUser> addUser = annualMaintenanceRecordUsers.stream()
@@ -128,7 +133,7 @@
                });
                int insert = annualMaintenanceRecordUserMapper.batchInsert(addUser);
                if (insert <= 0){
                    throw new RuntimeException("保存年度基础设施维护记录人员失败");
                    throw new ApiException("保存年度基础设施维护记录人员失败");
                }
            }

@@ -142,7 +147,7 @@
                });
                int update = annualMaintenanceRecordUserMapper.batchUpdate(updateUser);
                if (update <= 0){
                    throw new RuntimeException("保存年度基础设施维护记录人员失败");
                    throw new ApiException("保存年度基础设施维护记录人员失败");
                }
            }


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

@@ -7,6 +7,7 @@
import com.gkhy.exam.common.api.CommonPage;
import com.gkhy.exam.common.api.CommonResult;
import com.gkhy.exam.common.constant.UserConstant;
import com.gkhy.exam.common.exception.ApiException;
import com.gkhy.exam.common.utils.PageUtils;
import com.gkhy.exam.common.utils.SecurityUtils;
import com.gkhy.exam.system.domain.AnnualMaintenance;
@@ -102,7 +103,7 @@
                            .in(AnnualMaintenanceDevice::getId, delDeviceIds)
            );
            if (update <= 0){
                throw new RuntimeException("删除年度基础设施维护计划设备失败");
                throw new ApiException("删除年度基础设施维护计划设备失败");
            }
        }
        
@@ -115,7 +116,7 @@
                annualMaintenanceDevice.setCreateTime(LocalDateTime.now());
                int insert = annualMaintenanceDeviceMapper.insert(annualMaintenanceDevice);
                if (insert <= 0){
                    throw new RuntimeException("保存年度基础设施维护计划设备失败");
                    throw new ApiException("保存年度基础设施维护计划设备失败");
                }
                
                List<AnnualMaintenanceDeviceType> annualMaintenanceDeviceTypes = annualMaintenanceDeviceSaveDTOReq.getAnnualMaintenanceDeviceTypes();
@@ -126,7 +127,7 @@
                        annualMaintenanceDeviceType.setCreateTime(LocalDateTime.now());
                        int insert1 = annualMaintenanceDeviceTypeMapper.insert(annualMaintenanceDeviceType);
                        if (insert1 <= 0){
                            throw new RuntimeException("保存年度基础设施维护计划设备类型失败");
                            throw new ApiException("保存年度基础设施维护计划设备类型失败");
                        }
                    }
                }
@@ -135,7 +136,7 @@
                annualMaintenanceDevice.setUpdateTime(LocalDateTime.now());
                int update = annualMaintenanceDeviceMapper.updateById(annualMaintenanceDevice);
                if (update <= 0){
                    throw new RuntimeException("更新年度基础设施维护计划设备失败");
                    throw new ApiException("更新年度基础设施维护计划设备失败");
                }
                List<AnnualMaintenanceDeviceType> annualMaintenanceDeviceTypes = annualMaintenanceDeviceSaveDTOReq.getAnnualMaintenanceDeviceTypes();
                if (ObjectUtils.isNotEmpty(annualMaintenanceDeviceTypes)){ 
@@ -146,14 +147,14 @@
                            annualMaintenanceDeviceType.setCreateTime(LocalDateTime.now());
                            int insert1 = annualMaintenanceDeviceTypeMapper.insert(annualMaintenanceDeviceType);
                            if (insert1 <= 0){
                                throw new RuntimeException("保存年度基础设施维护计划设备类型失败");
                                throw new ApiException("保存年度基础设施维护计划设备类型失败");
                            }
                        }else {
                            annualMaintenanceDeviceType.setUpdateBy(SecurityUtils.getUsername());
                            annualMaintenanceDeviceType.setUpdateTime(LocalDateTime.now());
                            int update1 = annualMaintenanceDeviceTypeMapper.updateById(annualMaintenanceDeviceType);
                            if (update1 <= 0){
                                throw new RuntimeException("更新年度基础设施维护计划设备类型失败");
                                throw new ApiException("更新年度基础设施维护计划设备类型失败");
                            }
                        }
                       
@@ -215,11 +216,11 @@
                    annualMaintenanceDeviceType.setUpdateTime(LocalDateTime.now());
                    int update2 = annualMaintenanceDeviceTypeMapper.update(annualMaintenanceDeviceType, new LambdaQueryWrapper<AnnualMaintenanceDeviceType>().in(AnnualMaintenanceDeviceType::getAnnualMaintenanceDeviceId, deviceIds));
                    if (update2 <= 0){
                        throw new RuntimeException("删除数据失败");
                        throw new ApiException("删除数据失败");
                    }
                }
            }else {
                throw new RuntimeException("删除数据失败");
                throw new ApiException("删除数据失败");
            }

            return CommonResult.success();

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

@@ -7,6 +7,7 @@
import com.gkhy.exam.common.api.CommonPage;
import com.gkhy.exam.common.api.CommonResult;
import com.gkhy.exam.common.constant.UserConstant;
import com.gkhy.exam.common.exception.ApiException;
import com.gkhy.exam.common.utils.PageUtils;
import com.gkhy.exam.common.utils.SecurityUtils;
import com.gkhy.exam.system.domain.*;
@@ -90,7 +91,7 @@
            });
            int insert = annualMaintenanceServiceContentMapper.batchInsert(annualMaintenanceServiceContentList);
            if (insert <= 0) {
                throw new RuntimeException("保存保养内容失败");
                throw new ApiException("保存保养内容失败");
            }
        } else {
            annualMaintenanceServiceContentList.forEach(content -> {
@@ -99,7 +100,7 @@
            });
            int update = annualMaintenanceServiceContentMapper.batchUpdate(annualMaintenanceServiceContentList);
            if (update <= 0) {
                throw new RuntimeException("保存保养内容失败");
                throw new ApiException("保存保养内容失败");
            }
        }
    }
@@ -112,7 +113,7 @@
                            .in(AnnualMaintenanceServiceUser::getId, delServiceUserIds)
            );
            if (update1 <= 0) {
                throw new RuntimeException("保存失败");
                throw new ApiException("保存失败");
            }
        }

@@ -127,7 +128,7 @@
            });
            int i = annualMaintenanceServiceUserMapper.batchInsert(addUser);
            if (i <= 0) {
                throw new RuntimeException("保存失败");
                throw new ApiException("保存失败");
            }
        }

@@ -142,7 +143,7 @@
            });
            int update = annualMaintenanceServiceUserMapper.batchUpdate(updateUser);
            if (update <= 0) {
                throw new RuntimeException("保存失败");
                throw new ApiException("保存失败");
            }
        }

@@ -154,52 +155,52 @@
                .filter(user -> 1 == user.getUserType())
                .collect(Collectors.toList());
        if (ObjectUtil.isEmpty(filteredUsers)) {
            throw new RuntimeException("请填写一级保养操作人员");
            throw new ApiException("请填写一级保养操作人员");
        }
        Set<Long> userIdSet = filteredUsers.stream()
                .map(AnnualMaintenanceServiceUser::getUserId)
                .collect(Collectors.toSet());
        if (userIdSet.size() != filteredUsers.size()) {
            throw new RuntimeException("一级保养操作人员重复");
            throw new ApiException("一级保养操作人员重复");
        }

        List<AnnualMaintenanceServiceUser> filteredUsers2 = annualMaintenanceServiceUserList.stream()
                .filter(user -> 2 == user.getUserType())
                .collect(Collectors.toList());
        if (ObjectUtil.isEmpty(filteredUsers2)) {
            throw new RuntimeException("请填写一级保养检查人员");
            throw new ApiException("请填写一级保养检查人员");
        }
        Set<Long> userIdSet2 = filteredUsers2.stream()
                .map(AnnualMaintenanceServiceUser::getUserId)
                .collect(Collectors.toSet());
        if (userIdSet2.size() != filteredUsers2.size()) {
            throw new RuntimeException("一级保养检查人员重复");
            throw new ApiException("一级保养检查人员重复");
        }

        List<AnnualMaintenanceServiceUser> filteredUsers3 = annualMaintenanceServiceUserList.stream()
                .filter(user -> 3 == user.getUserType())
                .collect(Collectors.toList());
        if (ObjectUtil.isEmpty(filteredUsers3)) {
            throw new RuntimeException("请填写二级保养操作人员");
            throw new ApiException("请填写二级保养操作人员");
        }
        Set<Long> userIdSet3 = filteredUsers3.stream()
                .map(AnnualMaintenanceServiceUser::getUserId)
                .collect(Collectors.toSet());
        if (userIdSet3.size() != filteredUsers3.size()) {
            throw new RuntimeException("二级保养操作人员重复");
            throw new ApiException("二级保养操作人员重复");
        }

        List<AnnualMaintenanceServiceUser> filteredUsers4 = annualMaintenanceServiceUserList.stream()
                .filter(user -> 4 == user.getUserType())
                .collect(Collectors.toList());
        if (ObjectUtil.isEmpty(filteredUsers4)) {
            throw new RuntimeException("请填写二级保养检查人员");
            throw new ApiException("请填写二级保养检查人员");
        }
        Set<Long> userIdSet4 = filteredUsers4.stream()
                .map(AnnualMaintenanceServiceUser::getUserId)
                .collect(Collectors.toSet());
        if (userIdSet4.size() != filteredUsers4.size()) {
            throw new RuntimeException("二级保养检查人员重复");
            throw new ApiException("二级保养检查人员重复");
        }
    }

@@ -235,7 +236,7 @@
                            .set(AnnualMaintenanceServiceUser::getUpdateTime, LocalDateTime.now())
                            .set(AnnualMaintenanceServiceUser::getUpdateBy, SecurityUtils.getUsername()));
            if (update1 <= 0) {
                throw new RuntimeException("删除失败");
                throw new ApiException("删除失败");
            }
            int update2 = annualMaintenanceServiceContentMapper.update(new AnnualMaintenanceServiceContent(),
                    new LambdaUpdateWrapper<AnnualMaintenanceServiceContent>().eq(AnnualMaintenanceServiceContent::getAnnualMaintenanceServiceId, id)
@@ -244,7 +245,7 @@
                            .set(AnnualMaintenanceServiceContent::getUpdateBy, SecurityUtils.getUsername())
            );
            if (update2 <= 0) {
                throw new RuntimeException("删除失败");
                throw new ApiException("删除失败");
            }
            return CommonResult.success();
        }

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

@@ -6,6 +6,7 @@
import com.gkhy.exam.common.api.CommonPage;
import com.gkhy.exam.common.api.CommonResult;
import com.gkhy.exam.common.constant.UserConstant;
import com.gkhy.exam.common.exception.ApiException;
import com.gkhy.exam.common.utils.PageUtils;
import com.gkhy.exam.common.utils.SecurityUtils;
import com.gkhy.exam.system.domain.AnnualVerificationDevice;
@@ -55,12 +56,27 @@
        if (ObjectUtils.isEmpty(annualVerificationDevices)){
            return CommonResult.failed("保存参数不能为空");
        }

        LambdaQueryWrapper<AnnualVerificationPlan> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(AnnualVerificationPlan::getDelFlag, UserConstant.ENABLE);
        queryWrapper.eq(AnnualVerificationPlan::getCompanyId, annualVerificationPlan.getCompanyId());
        int i = 0;
        if (annualVerificationPlan.getId() == null){
            queryWrapper.eq(AnnualVerificationPlan::getYear, annualVerificationPlan.getYear());
            Long l = annualVerificationPlanMapper.selectCount(queryWrapper);
            if (l > 0){
                return CommonResult.failed("该年度计划已存在");
            }
            annualVerificationPlan.setCreateBy(SecurityUtils.getUsername());
            annualVerificationPlan.setCreateTime(LocalDateTime.now());
            i = annualVerificationPlanMapper.insert(annualVerificationPlan);
        }else {
            queryWrapper.eq(AnnualVerificationPlan::getYear, annualVerificationPlan.getYear());
            queryWrapper.ne(AnnualVerificationPlan::getId, annualVerificationPlan.getId());
            Long l = annualVerificationPlanMapper.selectCount(queryWrapper);
            if (l > 0){
                return CommonResult.failed("该年度计划已存在");
            }
            annualVerificationPlan.setUpdateTime(LocalDateTime.now());
            annualVerificationPlan.setUpdateBy(SecurityUtils.getUsername());
            i = annualVerificationPlanMapper.updateById(annualVerificationPlan);
@@ -79,7 +95,7 @@
                            .in(AnnualVerificationDevice::getId, delData)
            );
            if (update <= 0){
                throw new RuntimeException("操作失败");
                throw new ApiException("操作失败");
            }
        }
        annualVerificationDevices.forEach(annualVerificationDevice -> {

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

@@ -6,6 +6,7 @@
import com.gkhy.exam.common.api.CommonPage;
import com.gkhy.exam.common.api.CommonResult;
import com.gkhy.exam.common.domain.entity.SysDept;
import com.gkhy.exam.common.exception.ApiException;
import com.gkhy.exam.common.utils.PageUtils;
import com.gkhy.exam.common.utils.SecurityUtils;
import com.gkhy.exam.system.domain.InternalAuditCheck;
@@ -102,7 +103,7 @@
                Set<Long> collect = internalAuditCheckPeople.stream().map(InternalAuditCheckPerson::getAuditUserId)
                        .collect(Collectors.toSet());
                if (collect.size() != internalAuditCheckPeople.size()){
                    throw new RuntimeException("受审人员重复");
                    throw new ApiException("受审人员重复");
                }
                LambdaQueryWrapper<InternalAuditCheckPerson> queryWrapper = new LambdaQueryWrapper<>();
                queryWrapper.eq(InternalAuditCheckPerson::getAuditId, internalAuditCheck.getId());

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

@@ -6,6 +6,7 @@
import com.gkhy.exam.common.api.CommonPage;
import com.gkhy.exam.common.api.CommonResult;
import com.gkhy.exam.common.constant.UserConstant;
import com.gkhy.exam.common.exception.ApiException;
import com.gkhy.exam.common.utils.PageUtils;
import com.gkhy.exam.common.utils.SecurityUtils;
import com.gkhy.exam.system.domain.OutsourcedReview;
@@ -77,7 +78,7 @@
                            .set(OutsourcedReviewSubsidiary::getUpdateTime, LocalDateTime.now()).set(OutsourcedReviewSubsidiary::getUpdateBy, SecurityUtils.getUsername())
            );
            if (update <= 0){
                throw new RuntimeException("操作失败");
                throw new ApiException("操作失败");
            }
        }
        outsourcedReviewSubsidiaryList.forEach(outsourcedReviewSubsidiary -> {

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

@@ -49,7 +49,7 @@
        boolean admin = SecurityUtils.isAdmin(SecurityUtils.getUserId());
        if (!SecurityUtils.adminUser()){
            if (quality.getCompanyId()==null){
                throw new RuntimeException("非管理员操作，查询条件不可为空");
                throw new ApiException("非管理员操作，查询条件不可为空");
            }
        }
        PageUtils.startPage();

 multi-system/src/main/resources/mapper/system/InternalKnowledgeMapper.xml

@@ -6,6 +6,12 @@
        <if test="companyId!=null ">
            and company_id = #{companyId}
        </if>
        <if test="name!=null ">
            and name like concat('%',#{name},'%')
        </if>
        <if test="knowledgeType!=null ">
            and knowledge_type = #{knowledgeType}
        </if>
        ORDER BY create_time desc
    </select>
</mapper>

 multi-system/src/main/resources/mapper/system/StandingBookMapper.xml

@@ -6,8 +6,9 @@


    <select id="getStandingBooks" parameterType="com.gkhy.exam.system.domain.StandingBook" resultType="com.gkhy.exam.system.domain.StandingBook">
            select a.*,b.dept_name as deptName from standing_book a
            select a.*,b.dept_name as deptName,c.name as personResponsibleName from standing_book a
                left join sys_dept b on a.dept_id = b.dept_id
                left join sys_user c on a.person_responsible = c.id
        where a.del_flag = 0
        <if test="companyId != null">
            and a.company_id = #{companyId}