部分新功能

heheng

昨天 75960d6e223f8cab9ceb489f6b89f5f08c6db62a

部分新功能

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

对比新文件
@@ -0,0 +1,69 @@
package com.gkhy.exam.admin.controller.web;


import com.gkhy.exam.common.annotation.RepeatSubmit;
import com.gkhy.exam.common.api.CommonResult;
import com.gkhy.exam.system.domain.AnnualMaintenance;
import com.gkhy.exam.system.domain.StandingBook;
import com.gkhy.exam.system.domain.vo.AnnualMaintenanceSaveDTOReq;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import com.gkhy.exam.system.service.AnnualMaintenanceService;

import javax.annotation.Resource;

/**
 * <p>
 * 年度基础设施维护计划主表 前端控制器
 * </p>
 *
 * @author hh
 * @since 2025-07-31 16:12:02
 */
@RestController
@RequestMapping("/system/annualMaintenance")
@Api(tags = "年度基础设施维护计划管理")
public class AnnualMaintenanceController {

    @Resource
    private AnnualMaintenanceService annualMaintenanceService;

    @ApiOperation(value = "年度基础设施维护计划列表(分页)")
    @ApiImplicitParams({
            @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 = "year", dataType = "String", required = false, value = "年"),
    })
    @GetMapping("/selectAnnualMaintenanceList")
    public CommonResult selectAnnualMaintenanceList(AnnualMaintenance annualMaintenance){
        return CommonResult.success(annualMaintenanceService.selectAnnualMaintenanceList(annualMaintenance));
    }
    @RepeatSubmit
    @ApiOperation(value = "新增编辑年度基础设施维护计划")
    @PostMapping("/saveAnnualMaintenance")
    public CommonResult saveAnnualMaintenance(@RequestBody @Validated AnnualMaintenanceSaveDTOReq maintenanceSaveDTOReq){
        return annualMaintenanceService.saveAnnualMaintenance(maintenanceSaveDTOReq);
    }
    @ApiOperation(value = "年度基础设施计划详情")
    @GetMapping("/getAnnualMaintenance")
    @ApiImplicitParams({
            @ApiImplicitParam(paramType = "query", name = "id", dataType = "int", required = true, value = "id"),
    })
    public CommonResult getAnnualMaintenance(@RequestParam Integer id){
        return annualMaintenanceService.getAnnualMaintenance(id);
    }
    @ApiOperation(value = "删除年度基础设施计划")
    @ApiImplicitParams({
            @ApiImplicitParam(paramType = "query", name = "id", dataType = "int", required = true, value = "id"),
    })
    @GetMapping("/deletedAnnualMaintenance")
    public CommonResult deletedAnnualMaintenance(@RequestParam Integer id){
        return annualMaintenanceService.deletedAnnualMaintenance(id);
    }
}

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

对比新文件
@@ -0,0 +1,67 @@
package com.gkhy.exam.admin.controller.web;


import com.gkhy.exam.common.annotation.RepeatSubmit;
import com.gkhy.exam.common.api.CommonResult;
import com.gkhy.exam.system.domain.AnnualMaintenanceEvaluate;
import com.gkhy.exam.system.domain.AnnualMaintenanceRecord;
import com.gkhy.exam.system.service.AnnualMaintenanceEvaluateService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

/**
 * <p>
 * 设备完好评价记录及完整率统计 前端控制器
 * </p>
 *
 * @author hh
 * @since 2025-07-31 16:12:02
 */
@RestController
@RequestMapping("/system/annualMaintenanceEvaluate")
@Api(tags = "设备完好评价记录及完整率统计管理")
public class AnnualMaintenanceEvaluateController {


    @Autowired
    private AnnualMaintenanceEvaluateService annualMaintenanceEvaluateService;

    @ApiOperation(value = "设备完好评价记录及完整率统计管理列表(分页)")
    @ApiImplicitParams({
            @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"),

    })
    @GetMapping("/selectAnnualMaintenanceEvaluateList")
    public CommonResult selectAnnualMaintenanceEvaluateList(AnnualMaintenanceEvaluate annualMaintenanceEvaluate){
        return CommonResult.success(annualMaintenanceEvaluateService.selectAnnualMaintenanceEvaluateList(annualMaintenanceEvaluate));
    }
    @RepeatSubmit
    @ApiOperation(value = "新增编辑设备完好评价记录及完整率统计管理")
    @PostMapping("/saveAnnualMaintenanceEvaluate")
    public CommonResult saveAnnualMaintenanceEvaluate(@RequestBody @Validated AnnualMaintenanceEvaluate annualMaintenanceEvaluate){
        return annualMaintenanceEvaluateService.saveAnnualMaintenanceEvaluate(annualMaintenanceEvaluate);
    }
    @ApiOperation(value = "设备完好评价记录及完整率统计管理详情")
    @GetMapping("/getAnnualMaintenanceEvaluate")
    @ApiImplicitParams({
            @ApiImplicitParam(paramType = "query", name = "id", dataType = "int", required = true, value = "id"),
    })
    public CommonResult getAnnualMaintenanceEvaluate(@RequestParam Integer id){
        return annualMaintenanceEvaluateService.getAnnualMaintenanceEvaluate(id);
    }
    @ApiOperation(value = "删除设备完好评价记录及完整率统计管理")
    @ApiImplicitParams({
            @ApiImplicitParam(paramType = "query", name = "id", dataType = "int", required = true, value = "id"),
    })
    @GetMapping("/deletedAnnualMaintenanceEvaluate")
    public CommonResult deletedAnnualMaintenanceEvaluate(@RequestParam Integer id){
        return annualMaintenanceEvaluateService.deletedAnnualMaintenanceEvaluate(id);
    }
}

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

对比新文件
@@ -0,0 +1,67 @@
package com.gkhy.exam.admin.controller.web;


import com.gkhy.exam.common.annotation.RepeatSubmit;
import com.gkhy.exam.common.api.CommonResult;
import com.gkhy.exam.system.domain.AnnualMaintenance;
import com.gkhy.exam.system.domain.AnnualMaintenanceRecord;
import com.gkhy.exam.system.domain.vo.AnnualMaintenanceSaveDTOReq;
import com.gkhy.exam.system.service.AnnualMaintenanceRecordService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

/**
 * <p>
 * 年度基础设施维护记录表     前端控制器
 * </p>
 *
 * @author hh
 * @since 2025-07-31 16:12:02
 */
@RestController
@RequestMapping("/system/annualMaintenanceRecord")
@Api(tags = "年度基础设施维护记录管理")
public class AnnualMaintenanceRecordController {

    @Autowired
    private AnnualMaintenanceRecordService annualMaintenanceRecordService;

    @ApiOperation(value = "年度基础设施维护记录列表(分页)")
    @ApiImplicitParams({
            @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"),

    })
    @GetMapping("/selectAnnualMaintenanceRecordList")
    public CommonResult selectAnnualMaintenanceRecordList(AnnualMaintenanceRecord annualMaintenanceRecord){
        return CommonResult.success(annualMaintenanceRecordService.selectAnnualMaintenanceRecordList(annualMaintenanceRecord));
    }
    @RepeatSubmit
    @ApiOperation(value = "新增编辑年度基础设施维护记录")
    @PostMapping("/saveAnnualMaintenanceRecord")
    public CommonResult saveAnnualMaintenanceRecord(@RequestBody @Validated AnnualMaintenanceRecord annualMaintenanceRecord){
        return annualMaintenanceRecordService.saveAnnualMaintenanceRecord(annualMaintenanceRecord);
    }
    @ApiOperation(value = "年度基础设施维护记录详情")
    @GetMapping("/getAnnualMaintenanceRecord")
    @ApiImplicitParams({
            @ApiImplicitParam(paramType = "query", name = "id", dataType = "int", required = true, value = "id"),
    })
    public CommonResult getAnnualMaintenanceRecord(@RequestParam Integer id){
        return annualMaintenanceRecordService.getAnnualMaintenanceRecord(id);
    }
    @ApiOperation(value = "删除年度基础设施维护记录")
    @ApiImplicitParams({
            @ApiImplicitParam(paramType = "query", name = "id", dataType = "int", required = true, value = "id"),
    })
    @GetMapping("/deletedAnnualMaintenanceRecord")
    public CommonResult deletedAnnualMaintenanceRecord(@RequestParam Integer id){
        return annualMaintenanceRecordService.deletedAnnualMaintenanceRecord(id);
    }
}

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

对比新文件
@@ -0,0 +1,67 @@
package com.gkhy.exam.admin.controller.web;


import com.gkhy.exam.common.annotation.RepeatSubmit;
import com.gkhy.exam.common.api.CommonResult;
import com.gkhy.exam.system.domain.AnnualMaintenanceEvaluate;
import com.gkhy.exam.system.domain.AnnualMaintenanceService;
import com.gkhy.exam.system.service.AnnualMaintenanceServiceService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

/**
 * <p>
 * 年度基础设施维护保养表     前端控制器
 * </p>
 *
 * @author hh
 * @since 2025-07-31 16:12:02
 */
@RestController
@RequestMapping("/system/annualMaintenanceService")
@Api(tags = "年度基础设施维护保养管理")
public class AnnualMaintenanceServiceController {
    @Autowired
    private AnnualMaintenanceServiceService annualMaintenanceServiceService;



    @ApiOperation(value = "年度基础设施维护保养管理列表(分页)")
    @ApiImplicitParams({
            @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"),

    })
    @GetMapping("/selectAnnualMaintenanceServiceList")
    public CommonResult selectAnnualMaintenanceServiceList(AnnualMaintenanceService annualMaintenanceService){
        return CommonResult.success(annualMaintenanceServiceService.selectAnnualMaintenanceServiceList(annualMaintenanceService));
    }
    @RepeatSubmit
    @ApiOperation(value = "新增编辑年度基础设施维护保养管理")
    @PostMapping("/saveAnnualMaintenanceService")
    public CommonResult saveAnnualMaintenanceService(@RequestBody @Validated AnnualMaintenanceService annualMaintenanceService){
        return annualMaintenanceServiceService.saveAnnualMaintenanceService(annualMaintenanceService);
    }
    @ApiOperation(value = "年度基础设施维护保养管理详情")
    @GetMapping("/getAnnualMaintenanceService")
    @ApiImplicitParams({
            @ApiImplicitParam(paramType = "query", name = "id", dataType = "int", required = true, value = "id"),
    })
    public CommonResult getAnnualMaintenanceService(@RequestParam Integer id){
        return annualMaintenanceServiceService.getAnnualMaintenanceService(id);
    }
    @ApiOperation(value = "删除年度基础设施维护保养管理")
    @ApiImplicitParams({
            @ApiImplicitParam(paramType = "query", name = "id", dataType = "int", required = true, value = "id"),
    })
    @GetMapping("/deletedAnnualMaintenanceService")
    public CommonResult deletedAnnualMaintenanceService(@RequestParam Integer id){
        return annualMaintenanceServiceService.deletedAnnualMaintenanceService(id);
    }
}

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

对比新文件
@@ -0,0 +1,63 @@
package com.gkhy.exam.admin.controller.web;


import com.gkhy.exam.common.annotation.RepeatSubmit;
import com.gkhy.exam.common.api.CommonResult;
import com.gkhy.exam.system.domain.Correction;
import com.gkhy.exam.system.domain.StandingBook;
import com.gkhy.exam.system.service.StandingBookService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

/**
 * <p>
 * 台账 前端控制器
 * </p>
 *
 * @author hh
 * @since 2025-07-31 16:12:02
 */
@RestController
@RequestMapping("/system/standingBook")
@Api(tags = "台账管理")
public class StandingBookController {

    @Autowired
    private StandingBookService standingBookService;

    @ApiOperation(value = "台账列表(分页)")
    @ApiImplicitParams({
            @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"),
    })
    @GetMapping("/selectStandingBookList")
    public CommonResult selectStandingBookList(StandingBook standingBook){
        return CommonResult.success(standingBookService.selectStandingBookList(standingBook));
    }
    @RepeatSubmit
    @ApiOperation(value = "新增台账管理")
    @PostMapping("/saveStandingBook")
    public CommonResult insertStandingBook(@RequestBody @Validated StandingBook standingBook){
        return standingBookService.insertStandingBook(standingBook);
    }
    @ApiOperation(value = "修改台账管理")
    @PostMapping("/updateStandingBook")
    public CommonResult updateStandingBook(@RequestBody @Validated StandingBook standingBook){
        return standingBookService.updateStandingBook(standingBook);
    }
    @ApiOperation(value = "删除台账管理")
    @ApiImplicitParams({
            @ApiImplicitParam(paramType = "query", name = "id", dataType = "int", required = true, value = "id"),
    })
    @GetMapping("/delStandingBook")
    public CommonResult deletedStandingBook(@RequestParam Integer id){
        return standingBookService.deletedStandingBook(id);
    }

}

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

对比新文件
@@ -0,0 +1,111 @@
package com.gkhy.exam.system.domain;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.time.LocalDateTime;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Getter;
import lombok.Setter;

import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;

/**
 * <p>
 * 年度基础设施维护计划主表
 * </p>
 *
 * @author hh
 * @since 2025-07-31 16:12:02
 */
@Getter
@Setter
@TableName("annual_maintenance")
@ApiModel(value = "AnnualMaintenance对象", description = "年度基础设施维护计划主表")
public class AnnualMaintenance implements Serializable {

    private static final long serialVersionUID = 1L;

    @TableId(value = "id", type = IdType.AUTO)
    private Long id;

    @ApiModelProperty("企业id")
    @TableField("company_id")
    @NotNull(message = "企业id不能为空")
    private Integer companyId;

    @ApiModelProperty("名称")
    @TableField("name")
    @NotBlank(message = "名称不能为空")
    private String name;

    @ApiModelProperty("年")
    @TableField("year")
    @NotBlank(message = "年不能为空")
    private String year;

    @ApiModelProperty("编码")
    @TableField("number")
    @NotBlank(message = "编码不能为空")
    private String number;

    @ApiModelProperty("核准人id")
    @TableField("approval_id")
    @NotNull(message = "核准人id不能为空")
    private Long approvalId;

    @ApiModelProperty("核准人")
    @TableField("approval_name")
    @NotBlank(message = "核准人不能为空")
    private String approvalName;

    @ApiModelProperty("审核")
    @TableField("process_id")
    @NotNull(message = "审核不能为空")
    private Long processId;

    @ApiModelProperty("审核人")
    @TableField("process_name")
    @NotBlank(message = "审核人不能为空")
    private String processName;

    @ApiModelProperty("做成")
    @TableField("finish_id")
    @NotNull(message = "做成不能为空")
    private Long finishId;

    @ApiModelProperty("做成人")
    @TableField("finish_name")
    @NotBlank(message = "做成人不能为空")
    private String finishName;

    @ApiModelProperty("删除标志(0为删除，1删除，默认0)")
    @TableField("del_flag")
    private Integer delFlag;

    @ApiModelProperty("创建时间")
    @TableField("create_time")
    private LocalDateTime createTime;

    @ApiModelProperty("创建人")
    @TableField("create_by")
    private String createBy;

    @ApiModelProperty("更新时间")
    @TableField("update_time")
    private LocalDateTime updateTime;

    @ApiModelProperty("更新人")
    @TableField("update_by")
    private String updateBy;

    @ApiModelProperty("乐观锁")
    @TableField("version")
    private Integer version;


}

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

对比新文件
@@ -0,0 +1,95 @@
package com.gkhy.exam.system.domain;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.time.LocalDateTime;
import java.util.List;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Getter;
import lombok.Setter;

import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;

/**
 * <p>
 * 年度基础设施维护计划设备表
 * </p>
 *
 * @author hh
 * @since 2025-07-31 16:12:02
 */
@Getter
@Setter
@TableName("annual_maintenance_device")
@ApiModel(value = "AnnualMaintenanceDevice对象", description = "年度基础设施维护计划设备表")
public class AnnualMaintenanceDevice implements Serializable {

    private static final long serialVersionUID = 1L;

    @TableId(value = "id", type = IdType.AUTO)
    private Long id;

    @TableField("annual_maintenance_id")
    @ApiModelProperty("年度基础设施维护计划id")
    @NotNull(message = "年度基础设施维护计划id不能为空")
    private Long annualMaintenanceId;

    @ApiModelProperty("设备名称")
    @TableField("device_name")
    @NotBlank(message = "设备名称不能为空")
    private String deviceName;

    @ApiModelProperty("型号")
    @TableField("model")
    @NotBlank(message = "型号不能为空")
    private String model;

    @ApiModelProperty("厂内编号")
    @TableField("factory_number")
    @NotBlank(message = "厂内编号不能为空")
    private String factoryNumber;

    @ApiModelProperty("用途")
    @TableField("purpose")
    @NotBlank(message = "用途不能为空")
    private String purpose;

    @ApiModelProperty("部门")
    @TableField("dept_name")
    @NotBlank(message = "部门不能为空")
    private String deptName;

    @ApiModelProperty("删除标志(0为删除，1删除，默认0)")
    @TableField("del_flag")
    private Integer delFlag;

    @ApiModelProperty("创建时间")
    @TableField("create_time")
    private LocalDateTime createTime;

    @ApiModelProperty("创建人")
    @TableField("create_by")
    private String createBy;

    @ApiModelProperty("更新时间")
    @TableField("update_time")
    private LocalDateTime updateTime;

    @ApiModelProperty("更新人")
    @TableField("update_by")
    private String updateBy;

    @ApiModelProperty("乐观锁")
    @TableField("version")
    private Integer version;

    @TableField(exist = false)
    @ApiModelProperty("年度基础设施维护计划设备类型数据表")
    private List<AnnualMaintenanceDeviceType> annualMaintenanceDeviceTypeList;
}

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

对比新文件
@@ -0,0 +1,118 @@
package com.gkhy.exam.system.domain;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.time.LocalDateTime;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Getter;
import lombok.Setter;

import javax.validation.constraints.NotNull;

/**
 * <p>
 * 年度基础设施维护计划设备数据表
 * </p>
 *
 * @author hh
 * @since 2025-07-31 16:12:02
 */
@Getter
@Setter
@TableName("annual_maintenance_device_type")
@ApiModel(value = "AnnualMaintenanceDeviceType对象", description = "年度基础设施维护计划设备数据表")
public class AnnualMaintenanceDeviceType implements Serializable {

    private static final long serialVersionUID = 1L;

    @TableId(value = "id", type = IdType.AUTO)
    private Long id;

    @ApiModelProperty("维护设备表")
    @TableField("annual_maintenance_device_id")
    private Long annualMaintenanceDeviceId;

    @ApiModelProperty("项目类型1、日常类型检点2、一级保养3、二级保养")
    @TableField("project_type")
    @NotNull(message = "项目类型不能为空")
    private Integer projectType;

    @ApiModelProperty("频率1、工作日2、1次/3个月、1次/6个月")
    @TableField("frequency")
    @NotNull(message = "频率不能为空")
    private Integer frequency;

    @ApiModelProperty("1月")
    @TableField("jan")
    private String jan;

    @ApiModelProperty("2月")
    @TableField("feb")
    private String feb;

    @ApiModelProperty("3月")
    @TableField("mar")
    private String mar;

    @ApiModelProperty("4月")
    @TableField("apr")
    private String apr;

    @ApiModelProperty("5月")
    @TableField("may")
    private String may;

    @ApiModelProperty("6月")
    @TableField("jun")
    private String jun;

    @ApiModelProperty("7月")
    @TableField("jul")
    private String jul;

    @ApiModelProperty("8月")
    @TableField("aug")
    private String aug;

    @ApiModelProperty("9月")
    @TableField("sep")
    private String sep;

    @ApiModelProperty("10月")
    @TableField("oct")
    private String oct;

    @ApiModelProperty("11月")
    @TableField("nov")
    private String nov;

    @ApiModelProperty("12月")
    @TableField("dec")
    private String dec;

    @ApiModelProperty("删除标志(0为删除，1删除，默认0)")
    @TableField("del_flag")
    private Integer delFlag;

    @ApiModelProperty("创建时间")
    @TableField("create_time")
    private LocalDateTime createTime;

    @ApiModelProperty("创建人")
    @TableField("create_by")
    private String createBy;

    @ApiModelProperty("更新时间")
    @TableField("update_time")
    private LocalDateTime updateTime;

    @ApiModelProperty("更新人")
    @TableField("update_by")
    private String updateBy;


}

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

对比新文件
@@ -0,0 +1,132 @@
package com.gkhy.exam.system.domain;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.time.LocalDateTime;
import java.util.List;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Getter;
import lombok.Setter;

import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull;

/**
 * <p>
 * 设备完好评价记录及完整率统计
 * </p>
 *
 * @author hh
 * @since 2025-07-31 16:12:02
 */
@Getter
@Setter
@TableName("annual_maintenance_evaluate")
@ApiModel(value = "AnnualMaintenanceEvaluate对象", description = "设备完好评价记录及完整率统计")
public class AnnualMaintenanceEvaluate implements Serializable {

    private static final long serialVersionUID = 1L;

    @TableId(value = "id", type = IdType.AUTO)
    private Long id;

    @ApiModelProperty(value = "企业id",required = true)
    @TableField("company_id")
    @NotNull(message = "企业id不能为空")
    private Integer companyId;

    @ApiModelProperty(value ="名称",required = true)
    @TableField("name")
    @NotBlank(message = "名称不能为空")
    private String name;

    @ApiModelProperty(value ="制定日期",required = true)
    @TableField("enactment_date")
    @NotNull(message = "制定日期不能为空")
    private LocalDateTime enactmentDate;

    @ApiModelProperty(value ="修订日期",required = true)
    @TableField("revision_date")
    @NotNull(message = "修订日期不能为空")
    private LocalDateTime revisionDate;

    @ApiModelProperty(value ="编码" ,required = true)
    @TableField("number")
    @NotBlank(message = "编码不能为空")
    private String number;

    @ApiModelProperty(value ="批准人id",required = true)
    @TableField("approval_id")
    @NotNull(message = "批准人id不能为空")
    private Long approvalId;

    @ApiModelProperty(value ="批准人",required = true)
    @TableField("approval_name")
    @NotBlank(message = "批准人不能为空")
    private String approvalName;

    @ApiModelProperty(value ="审核",required = true)
    @TableField("process_id")
    @NotNull(message = "审核不能为空")
    private Long processId;

    @ApiModelProperty(value = "审核人",required = true)
    @TableField("process_name")
    @NotBlank(message = "审核不能为空")
    private String processName;

    @ApiModelProperty(value ="编制")
    @TableField("establishment_id")
    @NotNull(message = "编制不能为空")
    private Long establishmentId;

    @ApiModelProperty(value ="编制人",required = true)
    @TableField("establishment_name")
    @NotBlank(message = "编制不能为空")
    private String establishmentName;

    @ApiModelProperty("删除标志(0为删除，1删除，默认0)")
    @TableField("del_flag")
    private Integer delFlag;

    @ApiModelProperty("创建时间")
    @TableField("create_time")
    private LocalDateTime createTime;

    @ApiModelProperty("创建人")
    @TableField("create_by")
    private String createBy;

    @ApiModelProperty("更新时间")
    @TableField("update_time")
    private LocalDateTime updateTime;

    @ApiModelProperty("更新人")
    @TableField("update_by")
    private String updateBy;

    @ApiModelProperty("乐观锁")
    @TableField("version")
    private Integer version;

    @TableField(exist = false)
    @ApiModelProperty(value = "设备列表",required = true)
    @NotEmpty(message = "设备列表不能为空")
    private List<AnnualMaintenanceEvaluateDevice> annualMaintenanceEvaluateDeviceList;

    @TableField(exist = false)
    @ApiModelProperty(value = "删除的设备列表")
    private List<Long> evaluateDeviceIds;

    @TableField(exist = false)
    @ApiModelProperty(value = "企业名称")
    private String companyName;


}

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

对比新文件
@@ -0,0 +1,103 @@
package com.gkhy.exam.system.domain;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.time.LocalDateTime;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Getter;
import lombok.Setter;

import javax.validation.constraints.NotBlank;

/**
 * <p>
 * 设备完好评价记录及完整率统计设备表
 * </p>
 *
 * @author hh
 * @since 2025-07-31 16:12:02
 */
@Getter
@Setter
@TableName("annual_maintenance_evaluate_device")
@ApiModel(value = "AnnualMaintenanceEvaluateDevice对象", description = "设备完好评价记录及完整率统计设备表")
public class AnnualMaintenanceEvaluateDevice implements Serializable {

    private static final long serialVersionUID = 1L;

    @TableId(value = "id", type = IdType.AUTO)
    private Long id;

    @TableField("annual_maintenance_evaluate_id")
    private Long annualMaintenanceEvaluateId;

    @TableField("device_number")
    @ApiModelProperty(value ="设备编号",required = true)
    @NotBlank(message = "设备编号不能为空")
    private String deviceNumber;

    @ApiModelProperty(value ="设备名称",required = true)
    @TableField("device_name")
    @NotBlank(message = "设备名称不能为空")
    private String deviceName;

    @ApiModelProperty(value ="型号",required = true)
    @TableField("model")
    @NotBlank(message = "型号不能为空")
    private String model;

    @ApiModelProperty(value ="地点",required = true)
    @TableField("location")
    @NotBlank(message = "地点不能为空")
    private String location;

    @ApiModelProperty(value ="用途",required = true)
    @TableField("purpose")
    @NotBlank(message = "用途不能为空")
    private String purpose;

    @ApiModelProperty(value ="使用人",required = true)
    @TableField("use_user")
    @NotBlank(message = "使用人不能为空")
    private String useUser;

    @ApiModelProperty(value ="部门",required = true)
    @TableField("dept_name")
    @NotBlank(message = "部门不能为空")
    private String deptName;

    @ApiModelProperty(value ="结果1、完好2、需整改3、报废",required = true)
    @TableField("result_type")
    @NotBlank(message = "结果不能为空")
    private Integer resultType;

    @ApiModelProperty("删除标志(0为删除，1删除，默认0)")
    @TableField("del_flag")
    private Integer delFlag;

    @ApiModelProperty("创建时间")
    @TableField("create_time")
    private LocalDateTime createTime;

    @ApiModelProperty("创建人")
    @TableField("create_by")
    private String createBy;

    @ApiModelProperty("更新时间")
    @TableField("update_time")
    private LocalDateTime updateTime;

    @ApiModelProperty("更新人")
    @TableField("update_by")
    private String updateBy;

    @ApiModelProperty("乐观锁")
    @TableField("version")
    private Integer version;


}

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

对比新文件
@@ -0,0 +1,192 @@
package com.gkhy.exam.system.domain;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.List;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Getter;
import lombok.NonNull;
import lombok.Setter;

import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull;

import static io.lettuce.core.GeoArgs.Unit.m;

/**
 * <p>
 * 年度基础设施维护记录表	
 * </p>
 *
 * @author hh
 * @since 2025-07-31 16:12:02
 */
@Getter
@Setter
@TableName("annual_maintenance_record")
@ApiModel(value = "AnnualMaintenanceRecord对象", description = "年度基础设施维护记录表    ")
public class AnnualMaintenanceRecord implements Serializable {

    private static final long serialVersionUID = 1L;

    @TableId(value = "id", type = IdType.AUTO)
    private Long id;

    @ApiModelProperty(value = "企业id",required = true)
    @TableField("company_id")
    @NotNull(message = "企业id不能为空")
    private Integer companyId;

    @ApiModelProperty(value = "设备名称",required = true)
    @TableField("device_name")
    @NotBlank(message = "设备名称不能为空")
    private String deviceName;

    @ApiModelProperty(value = "编号",required = true)
    @TableField("number")
    @NotBlank(message = "编号不能为空")
    private String number;

    @ApiModelProperty(value = "故障发生日期",required = true)
    @NotNull(message = "故障发生日期不能为空")
    @TableField("fault_date")
    private LocalDateTime faultDate;

    @ApiModelProperty(value = "维修日期",required = true)
    @TableField("repair_date")
    @NotNull(message = "维修日期不能为空")
    private LocalDateTime repairDate;

    @ApiModelProperty(value = "主管",required = true)
    @TableField("manager_id")
    @NotNull(message = "主管不能为空")
    private Long managerId;

    @ApiModelProperty(value = "主管人",required = true)
    @TableField("manager_name")
    @NotBlank(message = "主管人不能为空")
    private String managerName;

    @ApiModelProperty(value = "故障原因及排除方法",required = true)
    @TableField("fault_cause")
    @NotBlank(message = "故障原因及排除方法不能为空")
    private String faultCause;

    @ApiModelProperty(value = "维修方式1内部2委外",required = true)
    @TableField("maintenance_method")
    @NotNull(message = "维修方式不能为空")
    private Integer maintenanceMethod;

    @ApiModelProperty("委外地点")
    @TableField("outsourcing_location")
    private String outsourcingLocation;

    @ApiModelProperty("维修工时")
    @TableField("repair_time")
    private String repairTime;

    @ApiModelProperty("停机时间")
    @TableField("down_time")
    private LocalDateTime downTime;

    @ApiModelProperty("更换材料")
    @TableField("replace_materials")
    private String replaceMaterials;

    @ApiModelProperty("金额")
    @TableField("money")
    private BigDecimal money;

    @ApiModelProperty("设备科主管")
    @TableField("device_manager_id")
    private Long deviceManagerId;

    @ApiModelProperty("设备科主管名称")
    @TableField("device_manager_name")
    private String deviceManagerName;

    @ApiModelProperty("备注")
    @TableField("remark")
    private String remark;

    @ApiModelProperty("部门验收确认")
    @TableField("acceptance_confirmation")
    private String acceptanceConfirmation;

    @ApiModelProperty(value = "批准人id",required = true)
    @TableField("approval_id")
    @NotNull(message = "批准人不能为空")
    private Long approvalId;

    @ApiModelProperty(value = "批准人",required = true)
    @TableField("approval_name")
    @NotBlank(message = "批准人不能为空")
    private String approvalName;

    @ApiModelProperty(value = "审核",required = true)
    @TableField("process_id")
    @NotNull(message = "审核不能为空")
    private Long processId;

    @ApiModelProperty(value = "审核人",required = true)
    @TableField("process_name")
    @NotBlank(message = "审核人不能为空")
    private String processName;

    @ApiModelProperty(value = "编制",required = true)
    @TableField("establishment_id")
    @NotNull(message = "编制不能为空")
    private Long establishmentId;

    @ApiModelProperty(value = "编制人",required = true)
    @TableField("establishment_name")
    @NotBlank(message = "编制人不能为空")
    private String establishmentName;

    @ApiModelProperty("删除标志(0为删除，1删除，默认0)")
    @TableField("del_flag")
    private Integer delFlag;

    @ApiModelProperty("创建时间")
    @TableField("create_time")
    private LocalDateTime createTime;

    @ApiModelProperty("创建人")
    @TableField("create_by")
    private String createBy;

    @ApiModelProperty("更新时间")
    @TableField("update_time")
    private LocalDateTime updateTime;

    @ApiModelProperty("更新人")
    @TableField("update_by")
    private String updateBy;

    @ApiModelProperty("乐观锁")
    @TableField("version")
    private Integer version;

    @ApiModelProperty("设施操作/管理员列表拼接返回")
    @TableField(exist = false)
    private String manageName;

    @ApiModelProperty("设施操作/管理员，维修人员数组")
    @TableField(exist = false)
    @NotEmpty(message = "设施操作/管理员，维修人员数组不能为空")
    private List<AnnualMaintenanceRecordUser> annualMaintenanceRecordUsers;

    @ApiModelProperty("设施操作/管理员，维修人员删除数组")
    @TableField(exist = false)
    private List<Long> delRecordUserIds;


}

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

对比新文件
@@ -0,0 +1,80 @@
package com.gkhy.exam.system.domain;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.time.LocalDateTime;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Getter;
import lombok.Setter;

import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;

/**
 * <p>
 * 年度基础设施维护记录人员表	
 * </p>
 *
 * @author hh
 * @since 2025-07-31 16:12:02
 */
@Getter
@Setter
@TableName("annual_maintenance_record_user")
@ApiModel(value = "AnnualMaintenanceRecordUser对象", description = "年度基础设施维护记录人员表    ")
public class AnnualMaintenanceRecordUser implements Serializable {

    private static final long serialVersionUID = 1L;

    @TableId(value = "id", type = IdType.AUTO)
    private Long id;

    @ApiModelProperty("设备维护记录id")
    @TableField("annual_maintenance_record_id")
    private Long annualMaintenanceRecordId;

    @ApiModelProperty(value ="人员类型1、设施操作人员2、维修人员",required = true)
    @TableField("user_type")
    @NotNull(message = "人员类型不能为空")
    private Integer userType;

    @ApiModelProperty(value ="人员id",required = true)
    @TableField("user_id")
    @NotNull(message = "人员id不能为空")
    private Long userId;

    @ApiModelProperty(value = "名称",required = true)
    @TableField("user_name")
    @NotBlank(message = "名称不能为空")
    private String userName;

    @ApiModelProperty("删除标志(0为删除，1删除，默认0)")
    @TableField("del_flag")
    private Integer delFlag;

    @ApiModelProperty("创建时间")
    @TableField("create_time")
    private LocalDateTime createTime;

    @ApiModelProperty("创建人")
    @TableField("create_by")
    private String createBy;

    @ApiModelProperty("更新时间")
    @TableField("update_time")
    private LocalDateTime updateTime;

    @ApiModelProperty("更新人")
    @TableField("update_by")
    private String updateBy;

    @ApiModelProperty("乐观锁")
    @TableField("version")
    private Integer version;


}

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

对比新文件
@@ -0,0 +1,100 @@
package com.gkhy.exam.system.domain;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.time.LocalDateTime;
import java.util.List;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import javafx.beans.property.ListProperty;
import lombok.Getter;
import lombok.Setter;

import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;

/**
 * <p>
 * 年度基础设施维护保养表	
 * </p>
 *
 * @author hh
 * @since 2025-07-31 16:12:02
 */
@Getter
@Setter
@TableName("annual_maintenance_service")
@ApiModel(value = "AnnualMaintenanceService对象", description = "年度基础设施维护保养表    ")
public class AnnualMaintenanceService implements Serializable {

    private static final long serialVersionUID = 1L;

    @TableId(value = "id", type = IdType.AUTO)
    private Long id;

    @ApiModelProperty(value = "企业id", required = true)
    @TableField("company_id")
    @NotNull(message = "企业id不能为空")
    private Integer companyId;

    @ApiModelProperty(value ="设备名称", required = true)
    @TableField("device_name")
    @NotBlank(message = "设备名称不能为空")
    private String deviceName;

    @ApiModelProperty(value ="设备编号", required = true)
    @TableField("device_number")
    @NotBlank(message = "设备编号不能为空")
    private String deviceNumber;

    @ApiModelProperty(value ="编号", required = true)
    @TableField("number")
    @NotBlank(message = "编号不能为空")
    private String number;

    @ApiModelProperty("保养结论")
    @TableField("conclusion")
    private String conclusion;

    @ApiModelProperty("删除标志(0为删除，1删除，默认0)")
    @TableField("del_flag")
    private Integer delFlag;

    @ApiModelProperty("创建时间")
    @TableField("create_time")
    private LocalDateTime createTime;

    @ApiModelProperty("创建人")
    @TableField("create_by")
    private String createBy;

    @ApiModelProperty("更新时间")
    @TableField("update_time")
    private LocalDateTime updateTime;

    @ApiModelProperty("更新人")
    @TableField("update_by")
    private String updateBy;

    @ApiModelProperty("乐观锁")
    @TableField("version")
    private Integer version;

    @TableField(exist = false)
    @ApiModelProperty(value = "年度基础设施维护保养内容表",required = true)
    private List<AnnualMaintenanceServiceContent> annualMaintenanceServiceContentList;

    @TableField(exist = false)
    @ApiModelProperty(value = "年度基础设施人员表",required = true)
    private List<AnnualMaintenanceServiceUser> annualMaintenanceServiceUserList;

    @TableField(exist = false)
    @ApiModelProperty(value = "删除的保养人员id")
    private List<Long> delServiceUserIds;


}

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

对比新文件
@@ -0,0 +1,74 @@
package com.gkhy.exam.system.domain;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.time.LocalDateTime;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Getter;
import lombok.Setter;

/**
 * <p>
 * 年度基础设施维护保养内容表	
 * </p>
 *
 * @author hh
 * @since 2025-07-31 16:12:02
 */
@Getter
@Setter
@TableName("annual_maintenance_service_content")
@ApiModel(value = "AnnualMaintenanceServiceContent对象", description = "年度基础设施维护保养内容表    ")
public class AnnualMaintenanceServiceContent implements Serializable {

    private static final long serialVersionUID = 1L;

    @TableId(value = "id", type = IdType.AUTO)
    private Long id;

    @ApiModelProperty("设备维护保养id")
    @TableField("annual_maintenance_service_id")
    private Long annualMaintenanceServiceId;

    @ApiModelProperty("内容编码1-8")
    @TableField("service_type")
    private Integer serviceType;

    @ApiModelProperty("结论")
    @TableField("conclusion")
    private String conclusion;

    @ApiModelProperty("整改措施")
    @TableField("rectification_measures")
    private String rectificationMeasures;

    @ApiModelProperty("删除标志(0为删除，1删除，默认0)")
    @TableField("del_flag")
    private Integer delFlag;

    @ApiModelProperty("创建时间")
    @TableField("create_time")
    private LocalDateTime createTime;

    @ApiModelProperty("创建人")
    @TableField("create_by")
    private String createBy;

    @ApiModelProperty("更新时间")
    @TableField("update_time")
    private LocalDateTime updateTime;

    @ApiModelProperty("更新人")
    @TableField("update_by")
    private String updateBy;

    @ApiModelProperty("乐观锁")
    @TableField("version")
    private Integer version;


}

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

对比新文件
@@ -0,0 +1,85 @@
package com.gkhy.exam.system.domain;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.time.LocalDateTime;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Getter;
import lombok.Setter;

import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;

/**
 * <p>
 * 年度基础设施维护保养人员表	
 * </p>
 *
 * @author hh
 * @since 2025-07-31 16:12:02
 */
@Getter
@Setter
@TableName("annual_maintenance_service_user")
@ApiModel(value = "AnnualMaintenanceServiceUser对象", description = "年度基础设施维护保养人员表    ")
public class AnnualMaintenanceServiceUser implements Serializable {

    private static final long serialVersionUID = 1L;

    @TableId(value = "id", type = IdType.AUTO)
    private Long id;

    @ApiModelProperty("设备维护保养id")
    @TableField("annual_maintenance_service_id")
    private Long annualMaintenanceServiceId;

    @ApiModelProperty(value = "人员类型1、一级保养操作人员2、一级保养检查人员3、二级保养操作人员4、二级保养检查人员",required = true)
    @TableField("user_type")
    @NotNull(message = "人员类型不能为空")
    private Integer userType;

    @ApiModelProperty(value = "人员id", required = true)
    @TableField("user_id")
    @NotNull(message = "人员id不能为空")
    private Long userId;

    @ApiModelProperty(value = "名称",required = true)
    @TableField("user_name")
    @NotBlank(message = "名称不能为空")
    private String userName;

    @ApiModelProperty(value = "日期",required = true)
    @TableField("check_date")
    @NotNull(message = "日期不能为空")
    private LocalDateTime checkDate;

    @ApiModelProperty("删除标志(0为删除，1删除，默认0)")
    @TableField("del_flag")
    private Integer delFlag;

    @ApiModelProperty("创建时间")
    @TableField("create_time")
    private LocalDateTime createTime;

    @ApiModelProperty("创建人")
    @TableField("create_by")
    private String createBy;

    @ApiModelProperty("更新时间")
    @TableField("update_time")
    private LocalDateTime updateTime;

    @ApiModelProperty("更新人")
    @TableField("update_by")
    private String updateBy;

    @ApiModelProperty("乐观锁")
    @TableField("version")
    private Integer version;


}

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

对比新文件
@@ -0,0 +1,123 @@
package com.gkhy.exam.system.domain;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.time.LocalDateTime;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Getter;
import lombok.Setter;

import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;

/**
 * <p>
 * 台账
 * </p>
 *
 * @author hh
 * @since 2025-07-31 16:12:02
 */
@Getter
@Setter
@TableName("standing_book")
@ApiModel(value = "StandingBook对象", description = "台账")
public class StandingBook implements Serializable {

    private static final long serialVersionUID = 1L;

    @TableId(value = "id", type = IdType.AUTO)
    private Long id;

    @ApiModelProperty("企业")
    @TableField("company_id")
    @NotNull(message = "企业不能为空")
    private Long companyId;

    @ApiModelProperty("部门id")
    @TableField("dept_id")
    @NotNull(message = "部门id不能为空")
    private Long deptId;

    @ApiModelProperty("部门")
    @TableField(exist = false)
    private String deptName;

    @ApiModelProperty("名称型号")
    @TableField("model")
    @NotBlank(message = "名称型号不能为空")
    private String model;

    @ApiModelProperty("责任人/使用人")
    @TableField("person_responsible")
    @NotBlank(message = "责任人/使用人不能为空")
    private Long personResponsible;

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

    @ApiModelProperty("编号")
    @TableField("number")
    @NotBlank(message = "编号不能为空")
    private String number;

    @ApiModelProperty("品牌")
    @TableField("brand")
    private String brand;

    @ApiModelProperty("密级/类型")
    @TableField("confidentiality")
    private String confidentiality;

    @ApiModelProperty("状态1.完好2损坏")
    @TableField("status")
    private Integer status;

    @ApiModelProperty("用途")
    @TableField("purpose")
    private String purpose;

    @ApiModelProperty("使用地点")
    @TableField("location")
    private String location;

    @ApiModelProperty("使用情况")
    @TableField("usage")
    private String usage;

    @ApiModelProperty("备注")
    @TableField("remark")
    private String remark;

    @ApiModelProperty("删除标志(0为删除，1删除，默认0)")
    @TableField("del_flag")
    private Integer delFlag;

    @ApiModelProperty("创建时间")
    @TableField("create_time")
    private LocalDateTime createTime;

    @ApiModelProperty("创建人")
    @TableField("create_by")
    private String createBy;

    @ApiModelProperty("更新时间")
    @TableField("update_time")
    private LocalDateTime updateTime;

    @ApiModelProperty("更新人")
    @TableField("update_by")
    private String updateBy;

    @ApiModelProperty("乐观锁")
    @TableField("version")
    private Integer version;


}

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

对比新文件
@@ -0,0 +1,51 @@
package com.gkhy.exam.system.domain.vo;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.gkhy.exam.system.domain.AnnualMaintenanceDeviceType;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import java.util.List;

@Data
@ApiModel(value = "年度基础设施维护计划设备保存参数")
public class AnnualMaintenanceDeviceSaveDTOReq {

    @ApiModelProperty(value ="编辑数据id",required = false)
    private Long id;

    @ApiModelProperty(value = "年度基础设施维护计划id",required = false)
    private Long annualMaintenanceId;

    @ApiModelProperty("设备名称")
    @NotBlank(message = "设备名称不能为空")
    private String deviceName;

    @ApiModelProperty("型号")
    @NotBlank(message = "型号不能为空")
    private String model;

    @ApiModelProperty("厂内编号")
    @NotBlank(message = "厂内编号不能为空")
    private String factoryNumber;

    @ApiModelProperty("用途")
    @NotBlank(message = "用途不能为空")
    private String purpose;

    @ApiModelProperty("部门")
    @NotBlank(message = "部门不能为空")
    private String deptName;

    @ApiModelProperty("删除的数据类型id数组")
    private List<Long> delDeviceTypeIds;

    @ApiModelProperty("年度基础设施维护计划设备类型数据保存参数")
    private List<AnnualMaintenanceDeviceType> annualMaintenanceDeviceTypes;

}

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

对比新文件
@@ -0,0 +1,16 @@
package com.gkhy.exam.system.domain.vo;

import com.gkhy.exam.system.domain.AnnualMaintenance;
import com.gkhy.exam.system.domain.AnnualMaintenanceDevice;
import io.swagger.annotations.ApiModel;
import lombok.Data;

import java.util.List;

@Data
@ApiModel(value = "年度基础设施维护计划信息详情")
public class AnnualMaintenanceInfoRep extends AnnualMaintenance {


    private List<AnnualMaintenanceDevice> annualMaintenanceDeviceList;
}

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

对比新文件
@@ -0,0 +1,70 @@
package com.gkhy.exam.system.domain.vo;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull;
import java.io.Serializable;
import java.util.List;

@Data
@ApiModel(value = "年度基础设施维护计划保存参数")
public class AnnualMaintenanceSaveDTOReq  implements Serializable {
    private static final long serialVersionUID = 1L;
    @ApiModelProperty("编辑数据id")
    private Long id;

    @ApiModelProperty("企业id")
    @NotNull(message = "企业id不能为空")
    private Integer companyId;

    @ApiModelProperty(value ="名称",required = true)
    @NotBlank(message = "名称不能为空")
    private String name;

    @ApiModelProperty(value = "年",required = true)
    @NotBlank(message = "年不能为空")
    private String year;

    @ApiModelProperty(value ="编码",required = true)
    @NotBlank(message = "编码不能为空")
    private String number;

    @ApiModelProperty(value ="核准人id",required = true)
    @NotNull(message = "核准人id不能为空")
    private Long approvalId;

    @ApiModelProperty(value ="核准人",required = true)
    @NotBlank(message = "核准人不能为空")
    private String approvalName;

    @ApiModelProperty(value ="审核",required = true)
    @NotNull(message = "审核不能为空")
    private Long processId;

    @ApiModelProperty(value ="审核人",required = true)
    @NotBlank(message = "审核人不能为空")
    private String processName;

    @ApiModelProperty(value ="做成",required = true)
    @NotNull(message = "做成不能为空")
    private Long finishId;

    @ApiModelProperty(value ="做成人",required = true)
    @NotBlank(message = "做成人不能为空")
    private String finishName;

    @ApiModelProperty("删除的设备数据id数组")
    private List<Long> delDeviceIds;

    @ApiModelProperty(value ="年度基础设施维护计划设备保存参数",required = true)
    @NotEmpty(message = "年度基础设施维护计划设备保存参数不能为空")
    private List<AnnualMaintenanceDeviceSaveDTOReq> annualMaintenanceDeviceSaveDTOReqs;

}

 multi-system/src/main/java/com/gkhy/exam/system/mapper/AnnualMaintenanceDeviceMapper.java

对比新文件
@@ -0,0 +1,18 @@
package com.gkhy.exam.system.mapper;

import com.gkhy.exam.system.domain.AnnualMaintenanceDevice;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;

/**
 * <p>
 * 年度基础设施维护计划设备表 Mapper 接口
 * </p>
 *
 * @author hh
 * @since 2025-07-31 16:12:02
 */
@Mapper
public interface AnnualMaintenanceDeviceMapper extends BaseMapper<AnnualMaintenanceDevice> {

}

 multi-system/src/main/java/com/gkhy/exam/system/mapper/AnnualMaintenanceDeviceTypeMapper.java

对比新文件
@@ -0,0 +1,18 @@
package com.gkhy.exam.system.mapper;

import com.gkhy.exam.system.domain.AnnualMaintenanceDeviceType;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;

/**
 * <p>
 * 年度基础设施维护计划设备数据表 Mapper 接口
 * </p>
 *
 * @author hh
 * @since 2025-07-31 16:12:02
 */
@Mapper
public interface AnnualMaintenanceDeviceTypeMapper extends BaseMapper<AnnualMaintenanceDeviceType> {

}

 multi-system/src/main/java/com/gkhy/exam/system/mapper/AnnualMaintenanceEvaluateDeviceMapper.java

对比新文件
@@ -0,0 +1,25 @@
package com.gkhy.exam.system.mapper;

import com.gkhy.exam.system.domain.AnnualMaintenanceEvaluateDevice;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.gkhy.exam.system.domain.AnnualMaintenanceRecordUser;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;

/**
 * <p>
 * 设备完好评价记录及完整率统计设备表 Mapper 接口
 * </p>
 *
 * @author hh
 * @since 2025-07-31 16:12:02
 */
@Mapper
public interface AnnualMaintenanceEvaluateDeviceMapper extends BaseMapper<AnnualMaintenanceEvaluateDevice> {


    int batchUpdate(List<AnnualMaintenanceEvaluateDevice> list);

    int batchInsert(List<AnnualMaintenanceEvaluateDevice> list);
}

 multi-system/src/main/java/com/gkhy/exam/system/mapper/AnnualMaintenanceEvaluateMapper.java

对比新文件
@@ -0,0 +1,21 @@
package com.gkhy.exam.system.mapper;

import com.gkhy.exam.system.domain.AnnualMaintenanceEvaluate;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;

/**
 * <p>
 * 设备完好评价记录及完整率统计 Mapper 接口
 * </p>
 *
 * @author hh
 * @since 2025-07-31 16:12:02
 */
@Mapper
public interface AnnualMaintenanceEvaluateMapper extends BaseMapper<AnnualMaintenanceEvaluate> {

    List<AnnualMaintenanceEvaluate> getAnnualMaintenanceEvaluate(AnnualMaintenanceEvaluate annualMaintenanceEvaluate);
}

 multi-system/src/main/java/com/gkhy/exam/system/mapper/AnnualMaintenanceMapper.java

对比新文件
@@ -0,0 +1,22 @@
package com.gkhy.exam.system.mapper;

import com.gkhy.exam.system.domain.AnnualMaintenance;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;

/**
 * <p>
 * 年度基础设施维护计划主表 Mapper 接口
 * </p>
 *
 * @author hh
 * @since 2025-07-31 16:12:02
 */
@Mapper
public interface AnnualMaintenanceMapper extends BaseMapper<AnnualMaintenance> {

    List<AnnualMaintenance> getAnnualMaintenances(AnnualMaintenance annualMaintenance);

}

 multi-system/src/main/java/com/gkhy/exam/system/mapper/AnnualMaintenanceRecordMapper.java

对比新文件
@@ -0,0 +1,21 @@
package com.gkhy.exam.system.mapper;

import com.gkhy.exam.system.domain.AnnualMaintenanceRecord;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;

/**
 * <p>
 * 年度基础设施维护记录表     Mapper 接口
 * </p>
 *
 * @author hh
 * @since 2025-07-31 16:12:02
 */
@Mapper
public interface AnnualMaintenanceRecordMapper extends BaseMapper<AnnualMaintenanceRecord> {

    List<AnnualMaintenanceRecord> getAnnualMaintenanceRecord(AnnualMaintenanceRecord annualMaintenanceRecord);
}

 multi-system/src/main/java/com/gkhy/exam/system/mapper/AnnualMaintenanceRecordUserMapper.java

对比新文件
@@ -0,0 +1,23 @@
package com.gkhy.exam.system.mapper;

import com.gkhy.exam.system.domain.AnnualMaintenanceRecordUser;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;

/**
 * <p>
 * 年度基础设施维护记录人员表     Mapper 接口
 * </p>
 *
 * @author hh
 * @since 2025-07-31 16:12:02
 */
@Mapper
public interface AnnualMaintenanceRecordUserMapper extends BaseMapper<AnnualMaintenanceRecordUser> {

    int batchUpdate(List<AnnualMaintenanceRecordUser> list);

    int batchInsert(List<AnnualMaintenanceRecordUser> list);
}

 multi-system/src/main/java/com/gkhy/exam/system/mapper/AnnualMaintenanceServiceContentMapper.java

对比新文件
@@ -0,0 +1,23 @@
package com.gkhy.exam.system.mapper;

import com.gkhy.exam.system.domain.AnnualMaintenanceServiceContent;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.gkhy.exam.system.domain.AnnualMaintenanceServiceUser;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;

/**
 * <p>
 * 年度基础设施维护保养内容表     Mapper 接口
 * </p>
 *
 * @author hh
 * @since 2025-07-31 16:12:02
 */
@Mapper
public interface AnnualMaintenanceServiceContentMapper extends BaseMapper<AnnualMaintenanceServiceContent> {
    int batchInsert(List<AnnualMaintenanceServiceContent> list);

    int batchUpdate(List<AnnualMaintenanceServiceContent> list);
}

 multi-system/src/main/java/com/gkhy/exam/system/mapper/AnnualMaintenanceServiceMapper.java

对比新文件
@@ -0,0 +1,21 @@
package com.gkhy.exam.system.mapper;

import com.gkhy.exam.system.domain.AnnualMaintenanceService;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;

/**
 * <p>
 * 年度基础设施维护保养表     Mapper 接口
 * </p>
 *
 * @author hh
 * @since 2025-07-31 16:12:02
 */
@Mapper
public interface AnnualMaintenanceServiceMapper extends BaseMapper<AnnualMaintenanceService> {

    List<AnnualMaintenanceService> selectAnnualMaintenanceServiceList(AnnualMaintenanceService annualMaintenanceService);
}

 multi-system/src/main/java/com/gkhy/exam/system/mapper/AnnualMaintenanceServiceUserMapper.java

对比新文件
@@ -0,0 +1,23 @@
package com.gkhy.exam.system.mapper;

import com.gkhy.exam.system.domain.AnnualMaintenanceServiceUser;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;

/**
 * <p>
 * 年度基础设施维护保养人员表     Mapper 接口
 * </p>
 *
 * @author hh
 * @since 2025-07-31 16:12:02
 */
@Mapper
public interface AnnualMaintenanceServiceUserMapper extends BaseMapper<AnnualMaintenanceServiceUser> {

    int batchInsert(List<AnnualMaintenanceServiceUser> list);

    int batchUpdate(List<AnnualMaintenanceServiceUser> list);
}

 multi-system/src/main/java/com/gkhy/exam/system/mapper/StandingBookMapper.java

对比新文件
@@ -0,0 +1,22 @@
package com.gkhy.exam.system.mapper;

import com.gkhy.exam.system.domain.StandingBook;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;

/**
 * <p>
 * 台账 Mapper 接口
 * </p>
 *
 * @author hh
 * @since 2025-07-31 16:12:02
 */
@Mapper
public interface StandingBookMapper extends BaseMapper<StandingBook> {

    List<StandingBook> getStandingBooks(StandingBook standingBook);

}

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

对比新文件
@@ -0,0 +1,27 @@
package com.gkhy.exam.system.service;

import com.gkhy.exam.common.api.CommonPage;
import com.gkhy.exam.common.api.CommonResult;
import com.gkhy.exam.system.domain.AnnualMaintenanceEvaluate;
import com.baomidou.mybatisplus.extension.service.IService;
import com.gkhy.exam.system.domain.AnnualMaintenanceRecord;

/**
 * <p>
 * 设备完好评价记录及完整率统计 服务类
 * </p>
 *
 * @author hh
 * @since 2025-07-31 16:12:02
 */
public interface AnnualMaintenanceEvaluateService extends IService<AnnualMaintenanceEvaluate> {

    CommonPage selectAnnualMaintenanceEvaluateList(AnnualMaintenanceEvaluate annualMaintenanceEvaluate);

    CommonResult saveAnnualMaintenanceEvaluate(AnnualMaintenanceEvaluate annualMaintenanceEvaluate);

    CommonResult getAnnualMaintenanceEvaluate(Integer id);

    CommonResult deletedAnnualMaintenanceEvaluate(Integer id);

}

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

对比新文件
@@ -0,0 +1,26 @@
package com.gkhy.exam.system.service;

import com.gkhy.exam.common.api.CommonPage;
import com.gkhy.exam.common.api.CommonResult;
import com.gkhy.exam.system.domain.AnnualMaintenance;
import com.gkhy.exam.system.domain.AnnualMaintenanceRecord;
import com.baomidou.mybatisplus.extension.service.IService;
import com.gkhy.exam.system.domain.vo.AnnualMaintenanceSaveDTOReq;

/**
 * <p>
 * 年度基础设施维护记录表     服务类
 * </p>
 *
 * @author hh
 * @since 2025-07-31 16:12:02
 */
public interface AnnualMaintenanceRecordService extends IService<AnnualMaintenanceRecord> {
    CommonPage selectAnnualMaintenanceRecordList(AnnualMaintenanceRecord annualMaintenanceRecord);

    CommonResult saveAnnualMaintenanceRecord(AnnualMaintenanceRecord annualMaintenanceRecord);

    CommonResult getAnnualMaintenanceRecord(Integer id);

    CommonResult deletedAnnualMaintenanceRecord(Integer id);
}

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

对比新文件
@@ -0,0 +1,28 @@
package com.gkhy.exam.system.service;

import com.gkhy.exam.common.api.CommonPage;
import com.gkhy.exam.common.api.CommonResult;
import com.gkhy.exam.system.domain.AnnualMaintenance;
import com.baomidou.mybatisplus.extension.service.IService;
import com.gkhy.exam.system.domain.AnnualMaintenanceDevice;
import com.gkhy.exam.system.domain.vo.AnnualMaintenanceSaveDTOReq;

/**
 * <p>
 * 年度基础设施维护计划主表 服务类
 * </p>
 *
 * @author hh
 * @since 2025-07-31 16:12:02
 */
public interface AnnualMaintenanceService extends IService<AnnualMaintenance> {


    CommonPage selectAnnualMaintenanceList(AnnualMaintenance annualMaintenance);

    CommonResult saveAnnualMaintenance(AnnualMaintenanceSaveDTOReq annualMaintenanceSaveDTOReq);

    CommonResult getAnnualMaintenance(Integer id);

    CommonResult deletedAnnualMaintenance(Integer id);
}

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

对比新文件
@@ -0,0 +1,25 @@
package com.gkhy.exam.system.service;

import com.gkhy.exam.common.api.CommonPage;
import com.gkhy.exam.common.api.CommonResult;
import com.gkhy.exam.system.domain.AnnualMaintenanceEvaluate;
import com.gkhy.exam.system.domain.AnnualMaintenanceService;
import com.baomidou.mybatisplus.extension.service.IService;

/**
 * <p>
 * 年度基础设施维护保养表     服务类
 * </p>
 *
 * @author hh
 * @since 2025-07-31 16:12:02
 */
public interface AnnualMaintenanceServiceService extends IService<AnnualMaintenanceService> {
    CommonPage selectAnnualMaintenanceServiceList(AnnualMaintenanceService annualMaintenanceService);

    CommonResult saveAnnualMaintenanceService(AnnualMaintenanceService annualMaintenanceService);

    CommonResult getAnnualMaintenanceService(Integer id);

    CommonResult deletedAnnualMaintenanceService(Integer id);
}

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

对比新文件
@@ -0,0 +1,25 @@
package com.gkhy.exam.system.service;

import com.gkhy.exam.common.api.CommonPage;
import com.gkhy.exam.common.api.CommonResult;
import com.gkhy.exam.system.domain.Correction;
import com.gkhy.exam.system.domain.StandingBook;
import com.baomidou.mybatisplus.extension.service.IService;

/**
 * <p>
 * 台账 服务类
 * </p>
 *
 * @author hh
 * @since 2025-07-31 16:12:02
 */
public interface StandingBookService extends IService<StandingBook> {
    CommonPage selectStandingBookList(StandingBook standingBook);

    CommonResult insertStandingBook(StandingBook standingBook);

    CommonResult updateStandingBook(StandingBook standingBook);

    CommonResult deletedStandingBook(Integer id);
}

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

对比新文件
@@ -0,0 +1,154 @@
package com.gkhy.exam.system.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
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.utils.PageUtils;
import com.gkhy.exam.common.utils.SecurityUtils;
import com.gkhy.exam.system.domain.AnnualMaintenanceEvaluate;
import com.gkhy.exam.system.domain.AnnualMaintenanceEvaluateDevice;
import com.gkhy.exam.system.domain.AnnualMaintenanceRecord;
import com.gkhy.exam.system.mapper.AnnualMaintenanceEvaluateDeviceMapper;
import com.gkhy.exam.system.mapper.AnnualMaintenanceEvaluateMapper;
import com.gkhy.exam.system.service.AnnualMaintenanceEvaluateService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * <p>
 * 设备完好评价记录及完整率统计 服务实现类
 * </p>
 *
 * @author hh
 * @since 2025-07-31 16:12:02
 */
@Service
public class AnnualMaintenanceEvaluateServiceImpl extends ServiceImpl<AnnualMaintenanceEvaluateMapper, AnnualMaintenanceEvaluate> implements AnnualMaintenanceEvaluateService {

    @Autowired
    private AnnualMaintenanceEvaluateMapper annualMaintenanceEvaluateMapper;

    @Autowired
    private AnnualMaintenanceEvaluateDeviceMapper annualMaintenanceEvaluateDeviceMapper;

    @Override
    public CommonPage selectAnnualMaintenanceEvaluateList(AnnualMaintenanceEvaluate annualMaintenanceEvaluate) {
        PageUtils.startPage();
        List<AnnualMaintenanceEvaluate> annualMaintenanceEvaluates = annualMaintenanceEvaluateMapper.getAnnualMaintenanceEvaluate(annualMaintenanceEvaluate);
        return CommonPage.restPage(annualMaintenanceEvaluates);
    }

    @Override
    @Transactional
    public CommonResult saveAnnualMaintenanceEvaluate(AnnualMaintenanceEvaluate annualMaintenanceEvaluate) {
        List<AnnualMaintenanceEvaluateDevice> annualMaintenanceEvaluateDeviceList = annualMaintenanceEvaluate.getAnnualMaintenanceEvaluateDeviceList();
        if (ObjectUtils.isEmpty(annualMaintenanceEvaluateDeviceList)){
            return CommonResult.failed("设备列表不能为空");
        }
        boolean isAdd = annualMaintenanceEvaluate.getId() == null;
        int i = 0;
        if (isAdd){
            annualMaintenanceEvaluate.setCreateBy(SecurityUtils.getUsername());
            annualMaintenanceEvaluate.setCreateTime(LocalDateTime.now());
             i = annualMaintenanceEvaluateMapper.insert(annualMaintenanceEvaluate);
        }else {
            annualMaintenanceEvaluate.setUpdateBy(SecurityUtils.getUsername());
            annualMaintenanceEvaluate.setUpdateTime(LocalDateTime.now());
            i = annualMaintenanceEvaluateMapper.updateById(annualMaintenanceEvaluate);
        }
        if (i > 0){
            batchSaveEvaluateDevice(annualMaintenanceEvaluate.getId(), annualMaintenanceEvaluateDeviceList, annualMaintenanceEvaluate.getEvaluateDeviceIds());
            return CommonResult.success("保存成功");
        }

        return CommonResult.failed();
    }

    private void batchSaveEvaluateDevice(Long id, List<AnnualMaintenanceEvaluateDevice> annualMaintenanceEvaluateDeviceList,List<Long> evaluateDeviceIds)
    {
        if (ObjectUtils.isNotEmpty(evaluateDeviceIds)){
            int update = annualMaintenanceEvaluateDeviceMapper.update(new AnnualMaintenanceEvaluateDevice(),
                    new LambdaUpdateWrapper<AnnualMaintenanceEvaluateDevice>().set(AnnualMaintenanceEvaluateDevice::getDelFlag, UserConstant.DEPT_DISABLE)
                            .set(AnnualMaintenanceEvaluateDevice::getUpdateTime, LocalDateTime.now()).set(AnnualMaintenanceEvaluateDevice::getUpdateBy, SecurityUtils.getUsername())
                            .in(AnnualMaintenanceEvaluateDevice::getId, evaluateDeviceIds)
            );
            if (update <= 0){
                throw new RuntimeException("保存年度基础设施维护计划设备失败");
            }
        }

        List<AnnualMaintenanceEvaluateDevice> addData = annualMaintenanceEvaluateDeviceList.stream().filter(annualMaintenanceEvaluateDevice -> annualMaintenanceEvaluateDevice.getId() == null).collect(Collectors.toList());
        if (ObjectUtils.isNotEmpty(addData)){
            addData.forEach(annualMaintenanceEvaluateDevice -> {
                annualMaintenanceEvaluateDevice.setCreateTime(LocalDateTime.now());
                annualMaintenanceEvaluateDevice.setCreateBy(SecurityUtils.getUsername());
                annualMaintenanceEvaluateDevice.setAnnualMaintenanceEvaluateId(id);
            });
            int insert = annualMaintenanceEvaluateDeviceMapper.batchInsert(addData);
            if (insert <= 0){
                throw new RuntimeException("保存年度基础设施维护计划设备失败");
            }
        }

        List<AnnualMaintenanceEvaluateDevice> updateData = annualMaintenanceEvaluateDeviceList.stream().filter(annualMaintenanceEvaluateDevice -> annualMaintenanceEvaluateDevice.getId() != null).collect(Collectors.toList());
        if (ObjectUtils.isNotEmpty(updateData)){
            updateData.forEach(annualMaintenanceEvaluateDevice -> {
                annualMaintenanceEvaluateDevice.setUpdateTime(LocalDateTime.now());
                annualMaintenanceEvaluateDevice.setUpdateBy(SecurityUtils.getUsername());
            });
            int update = annualMaintenanceEvaluateDeviceMapper.batchUpdate(updateData);
            if (update <= 0){
                throw new RuntimeException("保存年度基础设施维护计划设备失败");
            }
        }
    }

    @Override
    public CommonResult getAnnualMaintenanceEvaluate(Integer id) {

        AnnualMaintenanceEvaluate annualMaintenanceEvaluate = annualMaintenanceEvaluateMapper.selectById(id);
        if (ObjectUtils.isNotEmpty(annualMaintenanceEvaluate)){

            List<AnnualMaintenanceEvaluateDevice> annualMaintenanceEvaluateDeviceList = annualMaintenanceEvaluateDeviceMapper.selectList(
                    new LambdaQueryWrapper<AnnualMaintenanceEvaluateDevice>().eq(AnnualMaintenanceEvaluateDevice::getAnnualMaintenanceEvaluateId, id)
                            .eq(AnnualMaintenanceEvaluateDevice::getDelFlag, UserConstant.ENABLE).orderByAsc(AnnualMaintenanceEvaluateDevice::getCreateTime));
            annualMaintenanceEvaluate.setAnnualMaintenanceEvaluateDeviceList(annualMaintenanceEvaluateDeviceList);
        }

        return CommonResult.success(annualMaintenanceEvaluate);
    }

    @Override
    @Transactional
    public CommonResult deletedAnnualMaintenanceEvaluate(Integer id) {

        AnnualMaintenanceEvaluate annualMaintenanceEvaluate = new AnnualMaintenanceEvaluate();
        annualMaintenanceEvaluate.setId(Long.valueOf( id));
        annualMaintenanceEvaluate.setDelFlag(UserConstant.DEPT_DISABLE);
        annualMaintenanceEvaluate.setUpdateBy(SecurityUtils.getUsername());
        annualMaintenanceEvaluate.setUpdateTime(LocalDateTime.now());
        int update = annualMaintenanceEvaluateMapper.updateById(annualMaintenanceEvaluate);
        if (update > 0){
            int update1 = annualMaintenanceEvaluateDeviceMapper.update(new AnnualMaintenanceEvaluateDevice(),
                    new LambdaUpdateWrapper<AnnualMaintenanceEvaluateDevice>().eq(AnnualMaintenanceEvaluateDevice::getAnnualMaintenanceEvaluateId, id)
                            .set(AnnualMaintenanceEvaluateDevice::getDelFlag, UserConstant.DEPT_DISABLE)
                            .set(AnnualMaintenanceEvaluateDevice::getUpdateTime, LocalDateTime.now())
                            .set(AnnualMaintenanceEvaluateDevice::getUpdateBy, SecurityUtils.getUsername()));
            if (update1 <= 0){
                throw new RuntimeException("删除年度基础设施维护计划设备失败");
            }
            return CommonResult.success("删除成功");
        }
        return CommonResult.failed();
    }
}

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

对比新文件
@@ -0,0 +1,193 @@
package com.gkhy.exam.system.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
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.utils.PageUtils;
import com.gkhy.exam.common.utils.SecurityUtils;
import com.gkhy.exam.system.domain.AnnualMaintenanceRecord;
import com.gkhy.exam.system.domain.AnnualMaintenanceRecordUser;
import com.gkhy.exam.system.mapper.AnnualMaintenanceRecordMapper;
import com.gkhy.exam.system.mapper.AnnualMaintenanceRecordUserMapper;
import com.gkhy.exam.system.service.AnnualMaintenanceRecordService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * <p>
 * 年度基础设施维护记录表     服务实现类
 * </p>
 *
 * @author hh
 * @since 2025-07-31 16:12:02
 */
@Service
public class AnnualMaintenanceRecordServiceImpl extends ServiceImpl<AnnualMaintenanceRecordMapper, AnnualMaintenanceRecord> implements AnnualMaintenanceRecordService {

    @Autowired
    private AnnualMaintenanceRecordMapper annualMaintenanceRecordMapper;
    @Autowired
    private AnnualMaintenanceRecordUserMapper annualMaintenanceRecordUserMapper;

    @Override
    public CommonPage selectAnnualMaintenanceRecordList(AnnualMaintenanceRecord annualMaintenanceRecord) {
        PageUtils.startPage();
        List<AnnualMaintenanceRecord> annualMaintenanceRecords = annualMaintenanceRecordMapper.getAnnualMaintenanceRecord(annualMaintenanceRecord);
        return CommonPage.restPage(annualMaintenanceRecords);
    }

    @Override
    @Transactional
    public CommonResult saveAnnualMaintenanceRecord(AnnualMaintenanceRecord annualMaintenanceRecord) {
        List<AnnualMaintenanceRecordUser> annualMaintenanceRecordUsers = annualMaintenanceRecord.getAnnualMaintenanceRecordUsers();
        if (ObjectUtils.isEmpty(annualMaintenanceRecordUsers)){
            return CommonResult.failed("年度基础设施维护记录人员不能为空");
        }
        boolean isAdd = annualMaintenanceRecord.getId() == null;
        int i = 0;
        if (isAdd){
            annualMaintenanceRecord.setCreateBy(SecurityUtils.getUsername());
            annualMaintenanceRecord.setCreateTime(LocalDateTime.now());
            i = annualMaintenanceRecordMapper.insert(annualMaintenanceRecord);
        }else {
            annualMaintenanceRecord.setUpdateBy(SecurityUtils.getUsername());
            annualMaintenanceRecord.setUpdateTime(LocalDateTime.now());
            i = annualMaintenanceRecordMapper.updateById(annualMaintenanceRecord);
        }
        if (i > 0){

            return CommonResult.success();
        }
        return CommonResult.failed();
    }
    private void batchSaveRecordUser(boolean isAdd,Long annualMaintenanceRecordId, List<AnnualMaintenanceRecordUser> annualMaintenanceRecordUsers,List<Long> delRecordUserIds) {
        List<AnnualMaintenanceRecordUser> filteredUsers = annualMaintenanceRecordUsers.stream()
                .filter(user -> 1 == user.getUserType())
                .collect(Collectors.toList());
        Set<Long> userIdSet = filteredUsers.stream()
                .map(AnnualMaintenanceRecordUser::getUserId)
                .collect(Collectors.toSet());
        if (userIdSet.size() != filteredUsers.size()){
            throw new RuntimeException("年度基础设施维护记录操作管理人员重复");
        }
        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(filteredUsers) || ObjectUtils.isEmpty(fixUsers)){
            throw new RuntimeException("年度基础设施维护记录人员或操作管理人员不能为空");
        }

        if (ObjectUtils.isNotEmpty(delRecordUserIds)){

            int update = annualMaintenanceRecordUserMapper.update(new AnnualMaintenanceRecordUser(),
                    new LambdaUpdateWrapper<AnnualMaintenanceRecordUser>().set(AnnualMaintenanceRecordUser::getDelFlag, UserConstant.DEPT_DISABLE)
                            .set(AnnualMaintenanceRecordUser::getUpdateTime, LocalDateTime.now()).set(AnnualMaintenanceRecordUser::getUpdateBy, SecurityUtils.getUsername())
                            .in(AnnualMaintenanceRecordUser::getId, delRecordUserIds)
            );
            if (update <= 0){
                throw new RuntimeException("删除年度基础设施维护记录人员失败");
            }
        }


        if (isAdd){
            annualMaintenanceRecordUsers.forEach(user -> {
                user.setAnnualMaintenanceRecordId(annualMaintenanceRecordId);
                user.setCreateTime(LocalDateTime.now());
                user.setCreateBy(SecurityUtils.getUsername());
            });
            int insert = annualMaintenanceRecordUserMapper.batchInsert(annualMaintenanceRecordUsers);
            if (insert <= 0){
                throw new RuntimeException("保存年度基础设施维护记录人员失败");
            }
        }else {
            List<AnnualMaintenanceRecordUser> addUser = annualMaintenanceRecordUsers.stream()
                    .filter(user -> null == user.getId())
                    .collect(Collectors.toList());
            if (ObjectUtils.isNotEmpty(addUser)){
                addUser.forEach(user -> {
                    user.setAnnualMaintenanceRecordId(annualMaintenanceRecordId);
                    user.setCreateTime(LocalDateTime.now());
                    user.setCreateBy(SecurityUtils.getUsername());
                });
                int insert = annualMaintenanceRecordUserMapper.batchInsert(annualMaintenanceRecordUsers);
                if (insert <= 0){
                    throw new RuntimeException("保存年度基础设施维护记录人员失败");
                }
            }

            List<AnnualMaintenanceRecordUser> updateUser = annualMaintenanceRecordUsers.stream()
                    .filter(user -> null == user.getId())
                    .collect(Collectors.toList());
            if (ObjectUtils.isNotEmpty(updateUser)){
                updateUser.forEach(user -> {
                    user.setUpdateTime(LocalDateTime.now());
                    user.setUpdateBy(SecurityUtils.getUsername());
                });
                int update = annualMaintenanceRecordUserMapper.batchUpdate(updateUser);
                if (update <= 0){
                    throw new RuntimeException("保存年度基础设施维护记录人员失败");
                }
            }

        }



    }


    @Override
    public CommonResult getAnnualMaintenanceRecord(Integer id) {
        AnnualMaintenanceRecord annualMaintenanceRecord = annualMaintenanceRecordMapper.selectById(id);
        if (ObjectUtils.isNotEmpty(annualMaintenanceRecord)){
            List<AnnualMaintenanceRecordUser> annualMaintenanceRecordUsers = annualMaintenanceRecordUserMapper.selectList(
                    new LambdaQueryWrapper<AnnualMaintenanceRecordUser>().eq(AnnualMaintenanceRecordUser::getAnnualMaintenanceRecordId, id)
                            .eq(AnnualMaintenanceRecordUser::getDelFlag, UserConstant.ENABLE).orderByAsc(AnnualMaintenanceRecordUser::getUserType));
            annualMaintenanceRecord.setAnnualMaintenanceRecordUsers(annualMaintenanceRecordUsers);
        }
        return CommonResult.success(annualMaintenanceRecord);
    }

    @Override
    @Transactional
    public CommonResult deletedAnnualMaintenanceRecord(Integer id) {

        AnnualMaintenanceRecord annualMaintenanceRecord = new AnnualMaintenanceRecord();
        annualMaintenanceRecord.setId(Long.valueOf( id));
        annualMaintenanceRecord.setDelFlag(1);
        annualMaintenanceRecord.setUpdateBy(SecurityUtils.getUsername());
        annualMaintenanceRecord.setUpdateTime(LocalDateTime.now());
        int update = annualMaintenanceRecordMapper.updateById(annualMaintenanceRecord);
        if (update > 0){
            AnnualMaintenanceRecordUser annualMaintenanceRecordUser = new AnnualMaintenanceRecordUser();
            annualMaintenanceRecordUser.setDelFlag(1);
            annualMaintenanceRecordUser.setUpdateBy(SecurityUtils.getUsername());
            annualMaintenanceRecordUser.setUpdateTime(LocalDateTime.now());

            LambdaQueryWrapper<AnnualMaintenanceRecordUser> eq = new LambdaQueryWrapper<AnnualMaintenanceRecordUser>().eq(AnnualMaintenanceRecordUser::getAnnualMaintenanceRecordId, id);
            int update1 = annualMaintenanceRecordUserMapper.update(annualMaintenanceRecordUser, eq);
            if (update1 <= 0){
                throw new RuntimeException("删除年度基础设施维护计划人员失败");
            }
            return CommonResult.success();
        }
        return CommonResult.failed();
    }
}

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

对比新文件
@@ -0,0 +1,229 @@
package com.gkhy.exam.system.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
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.utils.PageUtils;
import com.gkhy.exam.common.utils.SecurityUtils;
import com.gkhy.exam.system.domain.AnnualMaintenance;
import com.gkhy.exam.system.domain.AnnualMaintenanceDevice;
import com.gkhy.exam.system.domain.AnnualMaintenanceDeviceType;
import com.gkhy.exam.system.domain.StandardizedQuality;
import com.gkhy.exam.system.domain.vo.AnnualMaintenanceDeviceSaveDTOReq;
import com.gkhy.exam.system.domain.vo.AnnualMaintenanceInfoRep;
import com.gkhy.exam.system.domain.vo.AnnualMaintenanceSaveDTOReq;
import com.gkhy.exam.system.mapper.AnnualMaintenanceDeviceMapper;
import com.gkhy.exam.system.mapper.AnnualMaintenanceDeviceTypeMapper;
import com.gkhy.exam.system.mapper.AnnualMaintenanceMapper;
import com.gkhy.exam.system.service.AnnualMaintenanceService;
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 java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * <p>
 * 年度基础设施维护计划主表 服务实现类
 * </p>
 *
 * @author hh
 * @since 2025-07-31 16:12:02
 */
@Service
public class AnnualMaintenanceServiceImpl extends ServiceImpl<AnnualMaintenanceMapper, AnnualMaintenance> implements AnnualMaintenanceService {


    @Autowired
    private AnnualMaintenanceMapper annualMaintenanceMapper;

    @Autowired
    private AnnualMaintenanceDeviceMapper annualMaintenanceDeviceMapper;

    @Autowired
    private AnnualMaintenanceDeviceTypeMapper annualMaintenanceDeviceTypeMapper;


    @Override
    public CommonPage selectAnnualMaintenanceList(AnnualMaintenance annualMaintenance) {
        PageUtils.startPage();
        List<AnnualMaintenance> annualMaintenances = annualMaintenanceMapper.getAnnualMaintenances(annualMaintenance);
        return CommonPage.restPage(annualMaintenances);
    }

    @Override
    @Transactional
    public CommonResult saveAnnualMaintenance(AnnualMaintenanceSaveDTOReq annualMaintenanceSaveDTOReq) {
        List<AnnualMaintenanceDeviceSaveDTOReq> annualMaintenanceDeviceSaveDTOReqs = annualMaintenanceSaveDTOReq.getAnnualMaintenanceDeviceSaveDTOReqs();
        if (ObjectUtils.isEmpty(annualMaintenanceDeviceSaveDTOReqs)){
            return CommonResult.failed("年度基础设施维护计划设备保存参数不能为空");
        }
        int i = 0;

        AnnualMaintenance annualMaintenance = new AnnualMaintenance();
        BeanUtils.copyProperties(annualMaintenanceSaveDTOReq,annualMaintenance);
        boolean isAdd = annualMaintenance.getId() == null;
        if (isAdd){
            annualMaintenance.setCreateBy(SecurityUtils.getUsername());
            annualMaintenance.setCreateTime(LocalDateTime.now());
            i = annualMaintenanceMapper.insert(annualMaintenance);
        }else {
            annualMaintenance.setUpdateBy(SecurityUtils.getUsername());
            annualMaintenance.setUpdateTime(LocalDateTime.now());
            i = annualMaintenanceMapper.updateById(annualMaintenance);
        }


        if (i > 0){

            batchSaveDevice(annualMaintenance.getId(), annualMaintenanceDeviceSaveDTOReqs,annualMaintenanceSaveDTOReq.getDelDeviceIds());

            return CommonResult.success();
        }

        return CommonResult.failed();
    }


    private void batchSaveDevice(Long annualMaintenanceId, List<AnnualMaintenanceDeviceSaveDTOReq> annualMaintenanceDeviceSaveDTOReqs,List<Long> delDeviceIds) {
        if (ObjectUtils.isNotEmpty(delDeviceIds)){
            int update = annualMaintenanceDeviceMapper.update(new AnnualMaintenanceDevice(),
                    new LambdaUpdateWrapper<AnnualMaintenanceDevice>().set(AnnualMaintenanceDevice::getDelFlag, UserConstant.DEPT_DISABLE)
                            .set(AnnualMaintenanceDevice::getUpdateTime, LocalDateTime.now()).set(AnnualMaintenanceDevice::getUpdateBy, SecurityUtils.getUsername())
                            .in(AnnualMaintenanceDevice::getId, delDeviceIds)
            );
            if (update <= 0){
                throw new RuntimeException("删除年度基础设施维护计划设备失败");
            }
        }
        
        for (AnnualMaintenanceDeviceSaveDTOReq annualMaintenanceDeviceSaveDTOReq : annualMaintenanceDeviceSaveDTOReqs) {
            AnnualMaintenanceDevice annualMaintenanceDevice = new AnnualMaintenanceDevice();
            BeanUtils.copyProperties(annualMaintenanceDeviceSaveDTOReq,annualMaintenanceDevice);
            annualMaintenanceDevice.setAnnualMaintenanceId(annualMaintenanceId);
            if (annualMaintenanceDevice.getId() == null){
                annualMaintenanceDevice.setCreateBy(SecurityUtils.getUsername());
                annualMaintenanceDevice.setCreateTime(LocalDateTime.now());
                int insert = annualMaintenanceDeviceMapper.insert(annualMaintenanceDevice);
                if (insert <= 0){
                    throw new RuntimeException("保存年度基础设施维护计划设备失败");
                }
                
                List<AnnualMaintenanceDeviceType> annualMaintenanceDeviceTypes = annualMaintenanceDeviceSaveDTOReq.getAnnualMaintenanceDeviceTypes();
                if (ObjectUtils.isNotEmpty(annualMaintenanceDeviceTypes)){ 
                    for (AnnualMaintenanceDeviceType annualMaintenanceDeviceType : annualMaintenanceDeviceTypes) { 
                        annualMaintenanceDeviceType.setAnnualMaintenanceDeviceId(annualMaintenanceDevice.getId());
                        annualMaintenanceDeviceType.setCreateBy(SecurityUtils.getUsername());
                        annualMaintenanceDeviceType.setCreateTime(LocalDateTime.now());
                        int insert1 = annualMaintenanceDeviceTypeMapper.insert(annualMaintenanceDeviceType);
                        if (insert1 <= 0){
                            throw new RuntimeException("保存年度基础设施维护计划设备类型失败");
                        }
                    }
                }
            }else {
                annualMaintenanceDevice.setUpdateBy(SecurityUtils.getUsername());
                annualMaintenanceDevice.setUpdateTime(LocalDateTime.now());
                int update = annualMaintenanceDeviceMapper.updateById(annualMaintenanceDevice);
                if (update <= 0){
                    throw new RuntimeException("更新年度基础设施维护计划设备失败");
                }
                List<AnnualMaintenanceDeviceType> annualMaintenanceDeviceTypes = annualMaintenanceDeviceSaveDTOReq.getAnnualMaintenanceDeviceTypes();
                if (ObjectUtils.isNotEmpty(annualMaintenanceDeviceTypes)){ 
                    for (AnnualMaintenanceDeviceType annualMaintenanceDeviceType : annualMaintenanceDeviceTypes) { 
                        annualMaintenanceDeviceType.setAnnualMaintenanceDeviceId(annualMaintenanceDevice.getId());
                        if (annualMaintenanceDeviceType.getId() == null){
                            annualMaintenanceDeviceType.setCreateBy(SecurityUtils.getUsername());
                            annualMaintenanceDeviceType.setCreateTime(LocalDateTime.now());
                            int insert1 = annualMaintenanceDeviceTypeMapper.insert(annualMaintenanceDeviceType);
                            if (insert1 <= 0){
                                throw new RuntimeException("保存年度基础设施维护计划设备类型失败");
                            }
                        }else {
                            annualMaintenanceDeviceType.setUpdateBy(SecurityUtils.getUsername());
                            annualMaintenanceDeviceType.setUpdateTime(LocalDateTime.now());
                            int update1 = annualMaintenanceDeviceTypeMapper.updateById(annualMaintenanceDeviceType);
                            if (update1 <= 0){
                                throw new RuntimeException("更新年度基础设施维护计划设备类型失败");
                            }
                        }
                       
                    }
                }
                
            }
          
          
        }
    }
    @Override
    public CommonResult getAnnualMaintenance(Integer id) {

        AnnualMaintenanceInfoRep annualMaintenanceInfoRep = new AnnualMaintenanceInfoRep();
        AnnualMaintenance annualMaintenance = annualMaintenanceMapper.selectById(id);
        BeanUtils.copyProperties(annualMaintenance,annualMaintenanceInfoRep);
        LambdaQueryWrapper<AnnualMaintenanceDevice> eq = new LambdaQueryWrapper<AnnualMaintenanceDevice>().eq(AnnualMaintenanceDevice::getAnnualMaintenanceId, id)
                .eq(AnnualMaintenanceDevice::getDelFlag, UserConstant.ENABLE).orderByDesc(AnnualMaintenanceDevice::getCreateTime);
        List<AnnualMaintenanceDevice> annualMaintenanceDevices = annualMaintenanceDeviceMapper.selectList(eq);
        if (ObjectUtils.isNotEmpty(annualMaintenanceDevices)){
            for (AnnualMaintenanceDevice annualMaintenanceDevice : annualMaintenanceDevices) {

                List<AnnualMaintenanceDeviceType> annualMaintenanceDeviceTypes =
                        annualMaintenanceDeviceTypeMapper.selectList(new LambdaQueryWrapper<AnnualMaintenanceDeviceType>()
                                .eq(AnnualMaintenanceDeviceType::getAnnualMaintenanceDeviceId, annualMaintenanceDevice.getId())
                                        .eq(AnnualMaintenanceDeviceType::getDelFlag, UserConstant.ENABLE)
                                .orderByAsc(AnnualMaintenanceDeviceType::getProjectType));
                annualMaintenanceDevice.setAnnualMaintenanceDeviceTypeList(annualMaintenanceDeviceTypes);
            }
        }
        annualMaintenanceInfoRep.setAnnualMaintenanceDeviceList(annualMaintenanceDevices);

        return CommonResult.success(annualMaintenanceInfoRep);
    }

    @Override
    @Transactional
    public CommonResult deletedAnnualMaintenance(Integer id) {
        AnnualMaintenance annualMaintenance = new AnnualMaintenance();
        annualMaintenance.setId(Long.valueOf( id));
        annualMaintenance.setDelFlag(1);
        annualMaintenance.setUpdateBy(SecurityUtils.getUsername());
        annualMaintenance.setUpdateTime(LocalDateTime.now());
        int update = annualMaintenanceMapper.updateById(annualMaintenance);
        if (update > 0){
            LambdaQueryWrapper<AnnualMaintenanceDevice> eq = new LambdaQueryWrapper<AnnualMaintenanceDevice>().eq(AnnualMaintenanceDevice::getAnnualMaintenanceId, id).eq(AnnualMaintenanceDevice::getDelFlag, UserConstant.ENABLE);
            List<Long> deviceIds = annualMaintenanceDeviceMapper.selectList(eq).stream().map(AnnualMaintenanceDevice::getId).collect(Collectors.toList());
            if (ObjectUtils.isNotEmpty(deviceIds)){
                AnnualMaintenanceDevice annualMaintenanceDevice = new AnnualMaintenanceDevice();
                annualMaintenanceDevice.setDelFlag(1);
                annualMaintenanceDevice.setUpdateBy(SecurityUtils.getUsername());
                annualMaintenanceDevice.setUpdateTime(LocalDateTime.now());
                int update1 = annualMaintenanceDeviceMapper.update(annualMaintenanceDevice, eq);
                if (update1 > 0){
                    AnnualMaintenanceDeviceType annualMaintenanceDeviceType = new AnnualMaintenanceDeviceType();
                    annualMaintenanceDeviceType.setDelFlag(1);
                    annualMaintenanceDeviceType.setUpdateBy(SecurityUtils.getUsername());
                    annualMaintenanceDeviceType.setUpdateTime(LocalDateTime.now());
                    int update2 = annualMaintenanceDeviceTypeMapper.update(annualMaintenanceDeviceType, new LambdaQueryWrapper<AnnualMaintenanceDeviceType>().in(AnnualMaintenanceDeviceType::getAnnualMaintenanceDeviceId, deviceIds));
                    if (update2 <= 0){
                        throw new RuntimeException("删除数据失败");
                    }
                }
            }else {
                throw new RuntimeException("删除数据失败");
            }

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

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

对比新文件
@@ -0,0 +1,246 @@
package com.gkhy.exam.system.service.impl;

import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
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.utils.PageUtils;
import com.gkhy.exam.common.utils.SecurityUtils;
import com.gkhy.exam.system.domain.*;
import com.gkhy.exam.system.mapper.AnnualMaintenanceServiceContentMapper;
import com.gkhy.exam.system.mapper.AnnualMaintenanceServiceMapper;
import com.gkhy.exam.system.mapper.AnnualMaintenanceServiceUserMapper;
import com.gkhy.exam.system.service.AnnualMaintenanceServiceService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

import static net.sf.jsqlparser.parser.feature.Feature.update;

/**
 * <p>
 * 年度基础设施维护保养表     服务实现类
 * </p>
 *
 * @author hh
 * @since 2025-07-31 16:12:02
 */
@Service
public class AnnualMaintenanceServiceServiceImpl extends ServiceImpl<AnnualMaintenanceServiceMapper, AnnualMaintenanceService> implements AnnualMaintenanceServiceService {

    @Autowired
    private AnnualMaintenanceServiceMapper annualMaintenanceServiceMapper;

    @Autowired
    private AnnualMaintenanceServiceUserMapper annualMaintenanceServiceUserMapper;

    @Autowired
    private AnnualMaintenanceServiceContentMapper annualMaintenanceServiceContentMapper;

    @Override
    public CommonPage selectAnnualMaintenanceServiceList(AnnualMaintenanceService annualMaintenanceService) {
        PageUtils.startPage();
        List<AnnualMaintenanceService> annualMaintenanceServices = annualMaintenanceServiceMapper.selectAnnualMaintenanceServiceList(annualMaintenanceService);
        return CommonPage.restPage(annualMaintenanceServices);
    }

    @Override
    public CommonResult saveAnnualMaintenanceService(AnnualMaintenanceService annualMaintenanceService) {
        List<AnnualMaintenanceServiceContent> annualMaintenanceServiceContentList = annualMaintenanceService.getAnnualMaintenanceServiceContentList();
        List<AnnualMaintenanceServiceUser> annualMaintenanceServiceUserList = annualMaintenanceService.getAnnualMaintenanceServiceUserList();
        if (ObjectUtil.isEmpty(annualMaintenanceServiceContentList) || ObjectUtil.isEmpty(annualMaintenanceServiceUserList)) {
            return CommonResult.failed("请填写保养内容及保养人员数据");
        }
        checkUser(annualMaintenanceServiceUserList);
        boolean isAdd = annualMaintenanceService.getId() == null;
        int i = 0;
        if (isAdd) {
            annualMaintenanceService.setCreateBy(SecurityUtils.getUsername());
            annualMaintenanceService.setCreateTime(LocalDateTime.now());
            i = annualMaintenanceServiceMapper.insert(annualMaintenanceService);
        } else {
            annualMaintenanceService.setUpdateBy(SecurityUtils.getUsername());
            annualMaintenanceService.setUpdateTime(LocalDateTime.now());
            i = annualMaintenanceServiceMapper.updateById(annualMaintenanceService);
        }
        if (i > 0) {
            batchSaveContent(isAdd, annualMaintenanceService.getId(), annualMaintenanceServiceContentList);
            batchSaveUser(annualMaintenanceService.getId(), annualMaintenanceServiceUserList, annualMaintenanceService.getDelServiceUserIds());
            return CommonResult.success();
        }
        return CommonResult.failed();
    }

    private void batchSaveContent(boolean isAdd, Long serviceId, List<AnnualMaintenanceServiceContent> annualMaintenanceServiceContentList) {
        if (isAdd) {
            annualMaintenanceServiceContentList.forEach(content -> {
                content.setAnnualMaintenanceServiceId(serviceId);
                content.setCreateBy(SecurityUtils.getUsername());
                content.setCreateTime(LocalDateTime.now());
            });
            int insert = annualMaintenanceServiceContentMapper.batchInsert(annualMaintenanceServiceContentList);
            if (insert <= 0) {
                throw new RuntimeException("保存保养内容失败");
            }
        } else {
            annualMaintenanceServiceContentList.forEach(content -> {
                content.setUpdateBy(SecurityUtils.getUsername());
                content.setUpdateTime(LocalDateTime.now());
            });
            int update = annualMaintenanceServiceContentMapper.batchUpdate(annualMaintenanceServiceContentList);
            if (update <= 0) {
                throw new RuntimeException("保存保养内容失败");
            }
        }
    }

    private void batchSaveUser(Long serviceId, List<AnnualMaintenanceServiceUser> annualMaintenanceServiceUserList, List<Long> delServiceUserIds) {
        if (ObjectUtil.isNotEmpty(delServiceUserIds)) {
            int update1 = annualMaintenanceServiceUserMapper.update(new AnnualMaintenanceServiceUser(),
                    new LambdaUpdateWrapper<AnnualMaintenanceServiceUser>().set(AnnualMaintenanceServiceUser::getDelFlag, UserConstant.DEPT_DISABLE)
                            .set(AnnualMaintenanceServiceUser::getUpdateTime, LocalDateTime.now()).set(AnnualMaintenanceServiceUser::getUpdateBy, SecurityUtils.getUsername())
                            .in(AnnualMaintenanceServiceUser::getId, delServiceUserIds)
            );
            if (update1 <= 0) {
                throw new RuntimeException("保存失败");
            }
        }

        List<AnnualMaintenanceServiceUser> addUser = annualMaintenanceServiceUserList.stream()
                .filter(user -> null == user.getId())
                .collect(Collectors.toList());
        addUser.forEach(user -> {
            user.setCreateBy(SecurityUtils.getUsername());
            user.setCreateTime(LocalDateTime.now());
            user.setAnnualMaintenanceServiceId(serviceId);
        });
        int i = annualMaintenanceServiceUserMapper.batchInsert(addUser);
        if (i <= 0) {
            throw new RuntimeException("保存失败");
        }

        List<AnnualMaintenanceServiceUser> updateUser = annualMaintenanceServiceUserList.stream()
                .filter(user -> null != user.getId())
                .collect(Collectors.toList());
        updateUser.forEach(user -> {
            user.setUpdateBy(SecurityUtils.getUsername());
            user.setUpdateTime(LocalDateTime.now());
        });
        int update = annualMaintenanceServiceUserMapper.batchUpdate(updateUser);
        if (update <= 0) {
            throw new RuntimeException("保存失败");
        }
    }

    private void checkUser(List<AnnualMaintenanceServiceUser> annualMaintenanceServiceUserList) {

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

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

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

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

    @Override
    public CommonResult getAnnualMaintenanceService(Integer id) {
        AnnualMaintenanceService annualMaintenanceService = annualMaintenanceServiceMapper.selectById(id);
        if (ObjectUtils.isNotEmpty(annualMaintenanceService)) {
            List<AnnualMaintenanceServiceContent> annualMaintenanceServiceContentList = annualMaintenanceServiceContentMapper.selectList(
                    new LambdaQueryWrapper<AnnualMaintenanceServiceContent>().eq(AnnualMaintenanceServiceContent::getAnnualMaintenanceServiceId, id)
                            .eq(AnnualMaintenanceServiceContent::getDelFlag, UserConstant.ENABLE).orderByAsc(AnnualMaintenanceServiceContent::getServiceType));
            annualMaintenanceService.setAnnualMaintenanceServiceContentList(annualMaintenanceServiceContentList);

            List<AnnualMaintenanceServiceUser> annualMaintenanceServiceUserList = annualMaintenanceServiceUserMapper.selectList(
                    new LambdaQueryWrapper<AnnualMaintenanceServiceUser>().eq(AnnualMaintenanceServiceUser::getAnnualMaintenanceServiceId, id)
                            .eq(AnnualMaintenanceServiceUser::getDelFlag, UserConstant.ENABLE).orderByAsc(AnnualMaintenanceServiceUser::getUserType));
            annualMaintenanceService.setAnnualMaintenanceServiceUserList(annualMaintenanceServiceUserList);
        }
        return CommonResult.success(annualMaintenanceService);
    }

    @Override
    @Transactional
    public CommonResult deletedAnnualMaintenanceService(Integer id) {
        AnnualMaintenanceService annualMaintenanceService = new AnnualMaintenanceService();
        annualMaintenanceService.setId(Long.valueOf(id));
        annualMaintenanceService.setDelFlag(UserConstant.DEPT_DISABLE);
        int update = annualMaintenanceServiceMapper.updateById(annualMaintenanceService);
        if (update > 0) {

            int update1 = annualMaintenanceServiceUserMapper.update(new AnnualMaintenanceServiceUser(),
                    new LambdaUpdateWrapper<AnnualMaintenanceServiceUser>().eq(AnnualMaintenanceServiceUser::getAnnualMaintenanceServiceId, id)
                            .set(AnnualMaintenanceServiceUser::getDelFlag, UserConstant.DEPT_DISABLE)
                            .set(AnnualMaintenanceServiceUser::getUpdateTime, LocalDateTime.now())
                            .set(AnnualMaintenanceServiceUser::getUpdateBy, SecurityUtils.getUsername()));
            if (update1 <= 0) {
                throw new RuntimeException("删除失败");
            }
            int update2 = annualMaintenanceServiceContentMapper.update(new AnnualMaintenanceServiceContent(),
                    new LambdaUpdateWrapper<AnnualMaintenanceServiceContent>().eq(AnnualMaintenanceServiceContent::getAnnualMaintenanceServiceId, id)
                            .set(AnnualMaintenanceServiceContent::getDelFlag, UserConstant.DEPT_DISABLE)
                            .set(AnnualMaintenanceServiceContent::getUpdateTime, LocalDateTime.now())
                            .set(AnnualMaintenanceServiceContent::getUpdateBy, SecurityUtils.getUsername())
            );
            if (update2 <= 0) {
                throw new RuntimeException("删除失败");
            }
            return CommonResult.success();
        }
        return CommonResult.failed();
    }
}

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

@@ -48,10 +48,10 @@
    }

    @Override
    public CommonResult updateCorrection(Correction Correction) {
        Correction.setUpdateBy(SecurityUtils.getUsername());
        Correction.setUpdateTime(LocalDateTime.now());
        int insert = correctionMapper.updateById(Correction);
    public CommonResult updateCorrection(Correction correction) {
        correction.setUpdateBy(SecurityUtils.getUsername());
        correction.setUpdateTime(LocalDateTime.now());
        int insert = correctionMapper.updateById(correction);
        if (insert > 0){
            return CommonResult.success();
        }
@@ -60,12 +60,12 @@

    @Override
    public CommonResult deletedCorrection(Integer id) {
        Correction Correction = new Correction();
        Correction.setId(id.longValue());
        Correction.setDelFlag(1);
        Correction.setUpdateBy(SecurityUtils.getUsername());
        Correction.setUpdateTime(LocalDateTime.now());
        int insert = correctionMapper.updateById(Correction);
        Correction correction = new Correction();
        correction.setId(id.longValue());
        correction.setDelFlag(1);
        correction.setUpdateBy(SecurityUtils.getUsername());
        correction.setUpdateTime(LocalDateTime.now());
        int insert = correctionMapper.updateById(correction);
        if (insert > 0){
            return CommonResult.success();
        }

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

对比新文件
@@ -0,0 +1,74 @@
package com.gkhy.exam.system.service.impl;

import com.gkhy.exam.common.api.CommonPage;
import com.gkhy.exam.common.api.CommonResult;
import com.gkhy.exam.common.utils.PageUtils;
import com.gkhy.exam.common.utils.SecurityUtils;
import com.gkhy.exam.system.domain.Correction;
import com.gkhy.exam.system.domain.StandingBook;
import com.gkhy.exam.system.mapper.StandingBookMapper;
import com.gkhy.exam.system.service.StandingBookService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.time.LocalDateTime;
import java.util.List;

/**
 * <p>
 * 台账 服务实现类
 * </p>
 *
 * @author hh
 * @since 2025-07-31 16:12:02
 */
@Service
public class StandingBookServiceImpl extends ServiceImpl<StandingBookMapper, StandingBook> implements StandingBookService {

    @Autowired
    private StandingBookMapper standingBookMapper;
    @Override
    public CommonPage selectStandingBookList(StandingBook standingBook) {
        PageUtils.startPage();
        List<StandingBook> standingBooks = standingBookMapper.getStandingBooks(standingBook);
        return CommonPage.restPage(standingBooks);
    }

    @Override
    public CommonResult insertStandingBook(StandingBook standingBook) {
        standingBook.setCreateBy(SecurityUtils.getUsername());
        standingBook.setCreateTime(LocalDateTime.now());
        int insert = standingBookMapper.insert(standingBook);
        if (insert > 0){
            return CommonResult.success();
        }
        return CommonResult.failed();
    }

    @Override
    public CommonResult updateStandingBook(StandingBook standingBook) {
        standingBook.setUpdateBy(SecurityUtils.getUsername());
        standingBook.setUpdateTime(LocalDateTime.now());
        int insert = standingBookMapper.updateById(standingBook);
        if (insert > 0){
            return CommonResult.success();
        }
        return CommonResult.failed();
    }

    @Override
    public CommonResult deletedStandingBook(Integer id) {

        StandingBook standingBook = new StandingBook();
        standingBook.setId(id.longValue());
        standingBook.setDelFlag(1);
        standingBook.setUpdateBy(SecurityUtils.getUsername());
        standingBook.setUpdateTime(LocalDateTime.now());
        int update = standingBookMapper.updateById(standingBook);
        if (update > 0){
            return CommonResult.success();
        }
        return CommonResult.failed();
    }
}

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

对比新文件
@@ -0,0 +1,5 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.gkhy.exam.system.mapper.AnnualMaintenanceDeviceMapper">

</mapper>

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

对比新文件
@@ -0,0 +1,5 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.gkhy.exam.system.mapper.AnnualMaintenanceDeviceTypeMapper">

</mapper>

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

对比新文件
@@ -0,0 +1,37 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.gkhy.exam.system.mapper.AnnualMaintenanceEvaluateDeviceMapper">

    <insert id="batchInsert">

        insert into annual_maintenance_evaluate_device (annual_maintenance_evaluate_id, device_number, device_name,model,location,purpose,use_user,
        dept_name,result_type,create_time, create_by)
        values
        <foreach collection="list" item="item" separator=",">
            (#{item.annualMaintenanceEvaluateId}, #{deviceNumber}, #{item.deviceName},
            #{item.model}, #{item.location}, #{item.purpose}, #{item.useUser},
            #{item.deptName}, #{item.resultType},
            #{item.createTime}, #{item.createBy})
        </foreach>
    </insert>

    <update id="batchUpdate" parameterType="java.util.List">
        <foreach collection="list" item="item" separator=";">
            update annual_maintenance_evaluate_device
            <trim prefix="SET" suffixOverrides=",">
                <if test="item.deviceNumber != null">device_number = #{item.deviceNumber},</if>
                <if test="item.deviceName != null ">device_name = #{item.deviceName},</if>
                <if test="item.model != null">model = #{item.model},</if>
                <if test="item.location != null">location = #{item.location},</if>
                <if test="item.purpose != null">purpose = #{item.purpose},</if>
                <if test="item.useUser != null">use_user = #{item.useUser},</if>
                <if test="item.deptName != null">dept_name = #{item.deptName},</if>
                <if test="item.resultType != null">result_type = #{item.resultType},</if>
                <if test="item.updateBy != null">update_by = #{item.updateBy},</if>
                <if test="item.updateTime != null">update_time = #{item.updateTime},</if>
            </trim>
            where id = #{item.id}
        </foreach>
    </update>

</mapper>

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

对比新文件
@@ -0,0 +1,16 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.gkhy.exam.system.mapper.AnnualMaintenanceEvaluateMapper">


    <select id="getAnnualMaintenanceEvaluate" resultType="com.gkhy.exam.system.domain.AnnualMaintenanceEvaluate" parameterType="com.gkhy.exam.system.domain.AnnualMaintenanceEvaluate">

        select a.*,b.name as companyName from annual_maintenance_evaluate a
        left join sys_company b on a.company_id = b.id
        where a.del_flag = 0
        <if test="companyId != null">
            and a.company_id = #{companyId}
        </if>
        order by a.create_time desc
    </select>
</mapper>

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

对比新文件
@@ -0,0 +1,18 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.gkhy.exam.system.mapper.AnnualMaintenanceMapper">


    <select id="getAnnualMaintenances" resultType="com.gkhy.exam.system.domain.AnnualMaintenance" parameterType="com.gkhy.exam.system.domain.AnnualMaintenance">

        select * from annual_maintenance where del_flag = 0
        <if test="year != null and year != ''">
            and `year` = #{year}
        </if>

        <if test="companyId != null">
            and company_id = #{companyId}
        </if>
        order by create_time desc
    </select>
</mapper>

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

对比新文件
@@ -0,0 +1,17 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.gkhy.exam.system.mapper.AnnualMaintenanceRecordMapper">


    <select id="getAnnualMaintenanceRecord" parameterType="com.gkhy.exam.system.domain.AnnualMaintenanceRecord" resultType="com.gkhy.exam.system.domain.AnnualMaintenanceRecord" >


        select a.*,
        (select GROUP_CONCAT(user_name) from annual_maintenance_record_user where annual_maintenance_record_id = a.id and del_flag = 0 and user_type = 1 GROUP BY annual_maintenance_record_id ) as manageName
        from annual_maintenance_record a where a.del_flag = 0
        <if test="companyId != null">
            and a.company_id = #{companyId}
        </if>
        order by a.create_time desc
    </select>
</mapper>

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

对比新文件
@@ -0,0 +1,27 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.gkhy.exam.system.mapper.AnnualMaintenanceRecordUserMapper">


    <insert id="batchInsert">

        insert into annual_maintenance_record_user (annual_maintenance_record_id, user_type, user_id, user_name, create_time, create_by)
        values
        <foreach collection="list" item="item" separator=",">
            (#{item.annualMaintenanceRecordId}, #{item.userType}, #{item.userId}, #{item.userName}, #{item.createTime}, #{item.createBy})
        </foreach>
    </insert>

    <update id="batchUpdate" parameterType="java.util.List">
        <foreach collection="list" item="item" separator=";">
            update annual_maintenance_record_user
            <trim prefix="SET" suffixOverrides=",">
                <if test="item.userId != null">user_id = #{item.userId},</if>
                <if test="item.userName != null ">user_name = #{item.userName},</if>
                <if test="item.updateBy != null">update_by = #{item.updateBy},</if>
                <if test="item.updateTime != null">update_time = #{item.updateTime},</if>
            </trim>
            where id = #{item.id}
        </foreach>
    </update>
</mapper>

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

对比新文件
@@ -0,0 +1,28 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.gkhy.exam.system.mapper.AnnualMaintenanceServiceContentMapper">

    <insert id="batchInsert">

        insert into annual_maintenance_service_content (annual_maintenance_service_id, service_type,conclusion,rectification_measures, create_time, create_by)
        values
        <foreach collection="list" item="item" separator=",">
            (#{item.annualMaintenanceServiceId}, #{item.serviceType},
            , #{item.conclusion},#{item.rectificationMeasures},
            #{item.createTime}, #{item.createBy})
        </foreach>
    </insert>

    <update id="batchUpdate" parameterType="java.util.List">
        <foreach collection="list" item="item" separator=";">
            update annual_maintenance_service_content
            <trim prefix="SET" suffixOverrides=",">
                <if test="item.conclusion != null">conclusion = #{item.conclusion},</if>
                <if test="item.rectificationMeasures != null ">rectification_measures = #{item.rectificationMeasures},</if>
                <if test="item.updateBy != null">update_by = #{item.updateBy},</if>
                <if test="item.updateTime != null">update_time = #{item.updateTime},</if>
            </trim>
            where id = #{item.id}
        </foreach>
    </update>
</mapper>

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

对比新文件
@@ -0,0 +1,14 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.gkhy.exam.system.mapper.AnnualMaintenanceServiceMapper">


    <select id="selectAnnualMaintenanceServiceList" parameterType="com.gkhy.exam.system.domain.AnnualMaintenanceService" resultType="com.gkhy.exam.system.domain.AnnualMaintenanceService" >

        select * from annual_maintenance_service where del_flag = 0
        <if test="companyId != null">
            and company_id = #{companyId}
        </if>
        order by create_time desc
    </select>
</mapper>

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

对比新文件
@@ -0,0 +1,27 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.gkhy.exam.system.mapper.AnnualMaintenanceServiceUserMapper">

    <insert id="batchInsert">

        insert into annual_maintenance_service_user (annual_maintenance_service_id, user_id,user_name,user_type,check_date,create_time,create_by) values
        <foreach collection="list" item="item" separator=",">
            (#{item.annualMaintenanceServiceId}, #{item.userId},#{item.userName},#{item.userType},#{item.checkDate},#{item.createTime},#{item.createBy})
        </foreach>
    </insert>

    <update id="batchUpdate" parameterType="java.util.List">
        <foreach collection="list" item="item" separator=";">
            update annual_maintenance_service_user
            <trim prefix="SET" suffixOverrides=",">
                <if test="item.userId != null">user_id = #{item.userId},</if>
                <if test="item.userName != null ">user_name = #{item.userName},</if>
                <if test="item.userType != null">user_type = #{item.userType},</if>
                <if test="item.checkDate != null">check_date = #{item.checkDate},</if>
                <if test="item.updateBy != null">update_by = #{item.updateBy},</if>
                <if test="item.updateTime != null">update_time = #{item.updateTime},</if>
            </trim>
            where id = #{item.id}
        </foreach>
    </update>
</mapper>

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

对比新文件
@@ -0,0 +1,18 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.gkhy.exam.system.mapper.StandingBookMapper">




    <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
                left join sys_dept b on a.dept_id = b.dept_id
        where del_flag = 0
        <if test="companyId != null">
            and a.company_id = #{companyId}
        </if>
        order by a.create_time desc
    </select>

</mapper>