设备模块后端调整：档案修订保存时自动同步生成本年度校准、核查、保养计划明细（校准计划时间取有效期前一个月，核查、保养取下次日期前一个月）；设备新增保养...

吴羡

3 天以前 62cd9d30a8995f11be78aeb49815e7f7d4a11506

设备模块后端调整：档案修订保存时自动同步生成本年度校准、核查、保养计划明细（校准计划时间取有效期前一个月，核查、保养取下次日期前一个月）；设备新增保养、核查日期与周期字段；设备树查询改为全部/设备/计量器具分类；新增检测员角色人员查询接口；导入模板移除所属部门列

 cnas-device/src/main/java/com/ruoyi/device/excel/upload/DeviceImport.java

@@ -20,9 +20,6 @@
    @ExcelProperty("校准有效期*(yyyy-MM-dd)")
    private String activationDate;

    @ExcelProperty("所属部门*")
    private String laboratoryName;

    @ExcelProperty("当前状态*")
    private String deviceStatus;


 cnas-device/src/main/java/com/ruoyi/device/pojo/Device.java

@@ -46,6 +46,7 @@
    private LocalDateTime acquisitionDate;

    @Schema(description = "校准有效日期")
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private LocalDateTime activationDate;

    @Schema(description = "管理人Id")
@@ -64,11 +65,35 @@
    private String calibrationServices;

    @Schema(description = "最近校准日期")
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private LocalDateTime lastCalibrationDate;

    @Schema(description = "下次校准日期")
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private LocalDateTime nextCalibrationDate;

    @Schema(description = "最近保养日期")
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private LocalDateTime lastMaintenanceDate;

    @Schema(description = "下次保养日期")
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private LocalDateTime nextMaintenanceDate;

    @Schema(description = "保养周期(月)")
    private String maintenanceCycle;

    @Schema(description = "最近核查日期")
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private LocalDateTime lastExamineDate;

    @Schema(description = "下次核查日期")
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private LocalDateTime nextExamineDate;

    @Schema(description = "核查周期(月)")
    private String examineCycle;

    @Schema(description = "设备类型")
    private String largeCategory;


 cnas-device/src/main/java/com/ruoyi/device/pojo/DeviceMaintenancePlanDetails.java

@@ -6,6 +6,7 @@
import lombok.Setter;

import java.io.Serializable;
import java.time.LocalDate;
import java.time.LocalDateTime;

/**
@@ -43,6 +44,9 @@
    @Schema(description = "保养周期")
    private String maintenanceIntervals;

    @Schema(description = "计划保养时间")
    private LocalDate maintenanceDate;

    @Schema(description = "创建人")
    @TableField(fill = FieldFill.INSERT)
    private Integer createUser;

 cnas-device/src/main/java/com/ruoyi/device/service/impl/DeviceServiceImpl.java

@@ -17,13 +17,19 @@
import com.ruoyi.basic.pojo.StructureItemParameter;
import com.ruoyi.common.core.domain.Result;
import com.ruoyi.common.core.domain.entity.SysDictData;
import com.ruoyi.common.core.domain.entity.SysDept;
import com.ruoyi.common.core.domain.entity.User;
import com.ruoyi.common.utils.QueryWrappers;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.device.dto.*;
import com.ruoyi.device.excel.upload.DeviceImport;
import com.ruoyi.device.mapper.CollectBridgeMapper;
import com.ruoyi.device.mapper.DeviceCalibrationPlanDetailMapper;
import com.ruoyi.device.mapper.DeviceCalibrationPlanMapper;
import com.ruoyi.device.mapper.DeviceExaminePlanDetailsMapper;
import com.ruoyi.device.mapper.DeviceExaminePlanMapper;
import com.ruoyi.device.mapper.DeviceMaintenanceMapper;
import com.ruoyi.device.mapper.DeviceMaintenancePlanDetailsMapper;
import com.ruoyi.device.mapper.DeviceMaintenancePlanMapper;
import com.ruoyi.device.mapper.DeviceMapper;
import com.ruoyi.device.mapper.DeviceMetricRecordMapper;
import com.ruoyi.device.pojo.*;
@@ -36,7 +42,6 @@
import com.ruoyi.inspect.pojo.InsProduct;
import com.ruoyi.inspect.util.HackLoopTableRenderPolicy;
import com.ruoyi.system.mapper.SysDictDataMapper;
import com.ruoyi.system.mapper.SysDeptMapper;
import com.ruoyi.system.mapper.UserMapper;
import lombok.AllArgsConstructor;
import org.apache.logging.log4j.util.Strings;
@@ -68,8 +73,6 @@

    private UserMapper userMapper;

    private SysDeptMapper sysDeptMapper;

    private SysDictDataMapper sysDictDataMapper;

    private StructureItemParameterMapper structureItemParameterMapper;
@@ -85,6 +88,18 @@
    private DeviceMaintenanceMapper deviceMaintenanceMapper;

    private CollectBridgeMapper collectBridgeMapper;

    private DeviceCalibrationPlanMapper deviceCalibrationPlanMapper;

    private DeviceCalibrationPlanDetailMapper deviceCalibrationPlanDetailMapper;

    private DeviceExaminePlanMapper deviceExaminePlanMapper;

    private DeviceExaminePlanDetailsMapper deviceExaminePlanDetailsMapper;

    private DeviceMaintenancePlanMapper deviceMaintenancePlanMapper;

    private DeviceMaintenancePlanDetailsMapper deviceMaintenancePlanDetailsMapper;

    @Override
    public IPage<DeviceDto> selectDeviceParameter(Page page, DeviceDto itemParameter, Boolean laboratoryNameIsNull) {
@@ -105,8 +120,154 @@
    @Transactional(rollbackFor = Exception.class)
    @Override
    public int upDeviceParameter(Device itemParameter) {
        int rows = deviceMapper.updateById(itemParameter);
        // 档案修订填写了校准有效期和校准周期后，自动同步到设备校准计划
        Device device = deviceMapper.selectById(itemParameter.getId());
        if (device != null && device.getActivationDate() != null && StringUtils.isNotBlank(device.getCalibrationDate())) {
            syncCalibrationPlanDetail(device);
        }
        // 档案修订填写了核查信息后，自动同步到设备核查计划
        if (device != null && device.getNextExamineDate() != null && StringUtils.isNotBlank(device.getExamineCycle())) {
            syncExaminePlanDetail(device);
        }
        // 档案修订填写了保养信息后，自动同步到设备保养计划
        if (device != null && device.getNextMaintenanceDate() != null && StringUtils.isNotBlank(device.getMaintenanceCycle())) {
            syncMaintenancePlanDetail(device);
        }
        return rows;
    }

        return deviceMapper.updateById(itemParameter);
    /**
     * 把设备同步到今年的设备校准计划明细：本年计划校准时间 = 校准有效期前一个月
     */
    private void syncCalibrationPlanDetail(Device device) {
        String planYear = String.valueOf(LocalDate.now().getYear());
        DeviceCalibrationPlan plan = deviceCalibrationPlanMapper.selectOne(Wrappers.<DeviceCalibrationPlan>lambdaQuery()
                .eq(DeviceCalibrationPlan::getPlanYear, planYear)
                .and(w -> w.isNull(DeviceCalibrationPlan::getRatifyStatus).or().ne(DeviceCalibrationPlan::getRatifyStatus, 1))
                .orderByDesc(DeviceCalibrationPlan::getPlanId)
                .last("limit 1"));
        if (plan == null) {
            plan = new DeviceCalibrationPlan();
            plan.setPlanName(planYear + "年度设备校准计划");
            plan.setPlanYear(planYear);
            plan.setWriteUserId(SecurityUtils.getUserId().intValue());
            plan.setWriteTime(LocalDateTime.now());
            deviceCalibrationPlanMapper.insert(plan);
        }

        DeviceCalibrationPlanDetail detail = deviceCalibrationPlanDetailMapper.selectOne(Wrappers.<DeviceCalibrationPlanDetail>lambdaQuery()
                .eq(DeviceCalibrationPlanDetail::getPlanId, plan.getPlanId())
                .eq(DeviceCalibrationPlanDetail::getDeviceId, device.getId())
                .last("limit 1"));
        boolean isInsert = detail == null;
        if (isInsert) {
            detail = new DeviceCalibrationPlanDetail();
            detail.setPlanId(plan.getPlanId());
            detail.setDeviceId(device.getId());
        }
        String deviceName = device.getDeviceName() == null ? "" : device.getDeviceName();
        if (StringUtils.isNotBlank(device.getSpecificationModel())) {
            deviceName = deviceName + " " + device.getSpecificationModel();
        }
        detail.setDeviceName(deviceName);
        detail.setDeviceAmount("1");
        detail.setDeviceNumber(device.getManagementNumber());
        detail.setVerificationUnit(device.getCalibrationServices());
        detail.setVerificationCycles(device.getCalibrationDate());
        detail.setLastDate(device.getLastCalibrationDate() == null ? null : device.getLastCalibrationDate().toLocalDate());
        detail.setPlanDate(device.getActivationDate().toLocalDate().minusMonths(1));
        if (isInsert) {
            deviceCalibrationPlanDetailMapper.insert(detail);
        } else {
            deviceCalibrationPlanDetailMapper.updateById(detail);
        }
    }

    /**
     * 把设备同步到今年的设备核查计划明细：核查时间 = 下次核查日期前一个月
     */
    private void syncExaminePlanDetail(Device device) {
        String planYear = String.valueOf(LocalDate.now().getYear());
        DeviceExaminePlan plan = deviceExaminePlanMapper.selectOne(Wrappers.<DeviceExaminePlan>lambdaQuery()
                .eq(DeviceExaminePlan::getPlanYear, planYear)
                .and(w -> w.isNull(DeviceExaminePlan::getRatifyStatus).or().ne(DeviceExaminePlan::getRatifyStatus, 1))
                .orderByDesc(DeviceExaminePlan::getPlanId)
                .last("limit 1"));
        if (plan == null) {
            plan = new DeviceExaminePlan();
            plan.setPlanName(planYear + "年度设备核查计划");
            plan.setPlanYear(planYear);
            plan.setWriteUserId(SecurityUtils.getUserId().intValue());
            plan.setWriteTime(LocalDateTime.now());
            deviceExaminePlanMapper.insert(plan);
        }

        DeviceExaminePlanDetails detail = deviceExaminePlanDetailsMapper.selectOne(Wrappers.<DeviceExaminePlanDetails>lambdaQuery()
                .eq(DeviceExaminePlanDetails::getPlanId, plan.getPlanId())
                .eq(DeviceExaminePlanDetails::getDeviceId, device.getId())
                .last("limit 1"));
        boolean isInsert = detail == null;
        if (isInsert) {
            detail = new DeviceExaminePlanDetails();
            detail.setPlanId(plan.getPlanId());
            detail.setDeviceId(device.getId());
        }
        String deviceName = device.getDeviceName() == null ? "" : device.getDeviceName();
        if (StringUtils.isNotBlank(device.getSpecificationModel())) {
            deviceName = deviceName + " " + device.getSpecificationModel();
        }
        detail.setDeviceName(deviceName);
        detail.setDeviceNumber(device.getManagementNumber());
        detail.setCheckTime(device.getNextExamineDate().toLocalDate().minusMonths(1).toString());
        if (isInsert) {
            deviceExaminePlanDetailsMapper.insert(detail);
        } else {
            deviceExaminePlanDetailsMapper.updateById(detail);
        }
    }

    /**
     * 把设备同步到今年的设备保养计划明细：计划保养时间 = 下次保养日期前一个月
     */
    private void syncMaintenancePlanDetail(Device device) {
        String planYear = String.valueOf(LocalDate.now().getYear());
        DeviceMaintenancePlan plan = deviceMaintenancePlanMapper.selectOne(Wrappers.<DeviceMaintenancePlan>lambdaQuery()
                .eq(DeviceMaintenancePlan::getPlanYear, planYear)
                .and(w -> w.isNull(DeviceMaintenancePlan::getStatus).or().ne(DeviceMaintenancePlan::getStatus, 1))
                .orderByDesc(DeviceMaintenancePlan::getMaintenancePlanId)
                .last("limit 1"));
        if (plan == null) {
            plan = new DeviceMaintenancePlan();
            plan.setPlanName(planYear + "年度设备保养计划");
            plan.setPlanYear(planYear);
            Integer userId = SecurityUtils.getUserId().intValue();
            User user = userMapper.selectById(userId);
            plan.setCompilerId(userId);
            if (user != null) {
                plan.setCompiler(user.getName());
            }
            plan.setDatePreparation(LocalDateTime.now());
            deviceMaintenancePlanMapper.insert(plan);
        }

        DeviceMaintenancePlanDetails detail = deviceMaintenancePlanDetailsMapper.selectOne(Wrappers.<DeviceMaintenancePlanDetails>lambdaQuery()
                .eq(DeviceMaintenancePlanDetails::getMaintenancePlanId, plan.getMaintenancePlanId())
                .eq(DeviceMaintenancePlanDetails::getDeviceId, device.getId())
                .last("limit 1"));
        boolean isInsert = detail == null;
        if (isInsert) {
            detail = new DeviceMaintenancePlanDetails();
            detail.setMaintenancePlanId(plan.getMaintenancePlanId());
            detail.setDeviceId(device.getId());
        }
        detail.setMaintenanceIntervals(device.getMaintenanceCycle());
        detail.setMaintenanceDate(device.getNextMaintenanceDate().toLocalDate().minusMonths(1));
        if (isInsert) {
            deviceMaintenancePlanDetailsMapper.insert(detail);
        } else {
            deviceMaintenancePlanDetailsMapper.updateById(detail);
        }
    }

    @Override
@@ -560,9 +721,6 @@
                        .select(Device::getDeviceName, Device::getSpecificationModel, Device::getManagementNumber))
                .stream().map(d -> deviceKey(d.getDeviceName(), d.getSpecificationModel(), d.getManagementNumber())).collect(Collectors.toSet());

        Map<String, List<SysDept>> departmentMap = sysDeptMapper.selectDeptList(new SysDept()).stream()
                .filter(item -> StringUtils.isNotBlank(item.getDeptName()))
                .collect(Collectors.groupingBy(item -> item.getDeptName().trim()));
        Map<String, List<User>> userMap = userMapper.selectList(Wrappers.<User>lambdaQuery()
                        .isNotNull(User::getName).select(User::getId, User::getName))
                .stream().collect(Collectors.groupingBy(item -> item.getName().trim()));
@@ -580,18 +738,11 @@
                throw new RuntimeException("第" + rowNumber + "行：仪器名称“" + deviceName + "”+规格型号“" + specificationModel + "”+管理编号“" + managementNumber + "”已存在");
            }

            String laboratoryName = required(row.getLaboratoryName(), rowNumber, "所属部门");
            List<SysDept> departments = departmentMap.get(laboratoryName);
            if (CollectionUtils.isEmpty(departments) || departments.size() > 1) {
                throw new RuntimeException("第" + rowNumber + "行：所属部门“" + laboratoryName + "”不存在或不唯一");
            }

            Device device = new Device();
            device.setDeviceName(deviceName);
            device.setSpecificationModel(specificationModel);
            device.setManagementNumber(managementNumber);
            device.setActivationDate(parseDate(row.getActivationDate()));
            device.setSubordinateDepartmentsId(departments.get(0).getDeptId().intValue());
            device.setDeviceStatus(Integer.valueOf(dictValue(statusMap, row.getDeviceStatus(), rowNumber, "当前状态", true)));
            device.setCalibrationDate(required(row.getCalibrationDate(), rowNumber, "校准周期(月)"));
            device.setEnDeviceName(trim(row.getEnDeviceName()));

 cnas-device/src/main/java/com/ruoyi/device/service/impl/DeviceStateServiceImpl.java

@@ -73,7 +73,7 @@
            Laboratory laboratory = laboratoryMapper.selectOne(Wrappers.<Laboratory>lambdaQuery()
                    .eq(Laboratory::getLaboratoryNumber, largeCategory)
                    .select(Laboratory::getLaboratoryName));
            laboratoryName = laboratory.getLaboratoryName();
            laboratoryName = laboratory != null ? laboratory.getLaboratoryName() : "";
        } else {
            laboratoryName = "";
        }

 cnas-device/src/main/resources/mapper/DeviceMapper.xml

@@ -130,13 +130,7 @@
    <resultMap id="treeDeviceDto" type="map">
        <result property="label" column="laboratory_name"/>
        <result property="value" column="value" />
        <collection property="children" resultMap="storagePointMap" javaType="List"/>
    </resultMap>

    <resultMap id="storagePointMap" type="map">
        <result property="value" column="value"/>
        <result property="label" column="storage_point"/>
        <collection property="children" resultMap="deviceNameMap" javaType="List"/>
        <collection property="children" resultMap="deviceNameMap" javaType="List" notNullColumn="id"/>
    </resultMap>

    <resultMap id="deviceNameMap" type="map">
@@ -144,24 +138,32 @@
        <result property="label" column="device_name"/>
        <result property="activationDate" column="activation_date"/>
        <result property="managementNumber" column="management_number"/>
        <result property="storagePoint" column="storage_point"/>
    </resultMap>

    <select id="treeDevice" resultMap="treeDeviceDto">
        select
        c.laboratory_name,
        d.id,
        case when sd.dept_name is null || sd.dept_name ='' then '其他' else sd.dept_name end as laboratory_name,
        case when d.storage_point is null || d.storage_point ='' then '其他' else d.storage_point end as storage_point,
        d.device_name,
        d.management_number,
        null as value,
        d.activation_date
        from device d
        LEFT JOIN sys_dept sd ON sd.dept_id = d.subordinate_departments_id AND sd.del_flag = '0'
        d.storage_point,
        d.activation_date,
        null as value
        from (
            select 1 as sort_no, '全部' as laboratory_name
            union all
            select 2 as sort_no, '设备' as laboratory_name
            union all
            select 3 as sort_no, '计量器具' as laboratory_name
        ) c
        left join device d on c.sort_no = 1 or d.large_category = c.laboratory_name
        <where>
            <if test="deviceName!=null and deviceName!=''">
                and device_name like concat('%',#{deviceName},'%')
                and d.device_name like concat('%',#{deviceName},'%')
            </if>
        </where>
        order by c.sort_no, d.id
    </select>

    <select id="selectDeviceByCode" resultType="com.ruoyi.device.dto.DeviceDto">

 ruoyi-system/src/main/java/com/ruoyi/system/mapper/UserMapper.java

@@ -53,6 +53,12 @@
    List<User> selectQualityUserList();

    /**
     * 获取检测员角色人员信息
     * @return
     */
    List<User> selectInspectorUserList();

    /**
     * 获取当前登录用户部门下的所有用户
     * @param userId
     * @return

 ruoyi-system/src/main/java/com/ruoyi/system/service/impl/UserServiceImpl.java

@@ -41,6 +41,8 @@
                    return baseMapper.selectQualityUserList();
                case "2":
                    return baseMapper.selectDepartmentLimsUserList(SecurityUtils.getUserId().intValue());
                case "3":
                    return baseMapper.selectInspectorUserList();
            }

        }

 ruoyi-system/src/main/resources/mapper/system/UserMapper.xml

@@ -83,6 +83,29 @@
        group by u1.id
    </select>

    <!-- 获取检测员角色人员信息 -->
    <select id="selectInspectorUserList" resultType="com.ruoyi.common.core.domain.entity.User">
        select u1.id,
               u1.account,
               u1.name,
               u1.name_en,
               u1.email,
               u1.phone,
               u1.company,
               u1.is_custom,
               u1.signature_url,
               u1.picture_url,
               u1.depart_lims_id
        from user u1
                 left join sys_user_role sur on sur.user_id = u1.id
                 left join sys_role r on r.role_id = sur.role_id and r.role_name = '检测员'
        where r.role_id is not null
          and u1.status = '0'
          and u1.del_flag = '0'
          and u1.id != 1
        group by u1.id
    </select>

    <!-- 获取当前登录用户部门下的所有用户 -->
    <select id="selectDepartmentLimsUserList" resultType="com.ruoyi.common.core.domain.entity.User">
        select id,