二包批量领取 批量作废 批量还原

lyh

5 天以前 24d31b7626451ba24988577572525d7f6a4fa828

二包批量领取 批量作废 批量还原

 lxzn-module-eam-common/src/main/java/org/jeecg/modules/eam/constant/SecondMaintenanceStatusEnum.java

@@ -6,6 +6,7 @@
    WAIT_ADMIN_CONFIRM, //管理员确认
    WAIT_INSPECTOR_CONFIRM, // 检查人确认
    COMPLETE,  //已完成
    ABOLISH, //已作废
    ;

    public static SecondMaintenanceStatusEnum getInstance(String code) {

 lxzn-module-eam-common/src/main/java/org/jeecg/modules/eam/request/EamRepairOrderQuery.java

@@ -1,5 +1,6 @@
package org.jeecg.modules.eam.request;

import com.baomidou.mybatisplus.annotation.TableField;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
@@ -23,7 +24,15 @@
    private static final long serialVersionUID = 7710893031748864058L;



    //列表展示
    @TableField(exist = false)
    private String equipmentCode;
    @TableField(exist = false)
    private String equipmentName;
    @TableField(exist = false)
    private String keyword;
    @TableField(exist = false)
    private String equipmentModel;
    private String column;
    private String order;
}

 lxzn-module-eam-common/src/main/java/org/jeecg/modules/eam/request/EamReportRepairQuery.java

@@ -27,6 +27,11 @@
    private String equipmentCode;

    /**
     * 设备名称
     */
    private String equipmentName;

    /**
     * 开始时间
     */
    private String startTime;

 lxzn-module-eam/src/main/java/org/jeecg/modules/eam/controller/EamSecondMaintenanceOrderController.java

@@ -2,7 +2,9 @@

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
@@ -21,11 +23,11 @@
import org.jeecg.modules.eam.service.IEamSecondMaintenanceOrderService;
import org.jeecg.modules.system.service.ISysBusinessCodeRuleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import java.util.Arrays;
import java.util.List;
import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;

/**
@@ -94,6 +96,119 @@
    }

    /**
     * 批量添加
     * @param requests
     * @return
     */
    @AutoLog(value = "设备二级保养-批量添加")
    @ApiOperation(value = "设备二级保养-批量添加", notes = "设备二级保养-批量添加")
    @PostMapping(value = "/batchAdd")
    public Result<?> batchAdd(@RequestBody List<EamSecondMaintenanceRequest> requests) {
        if (CollectionUtils.isEmpty(requests)) {
            return Result.error("添加的对象列表不能为空！");
        }

        // 记录成功/失败的条目
        List<String> successOrders = new ArrayList<>();
        List<Map<String, Object>> failedItems = new ArrayList<>();

        for (int i = 0; i < requests.size(); i++) {
            EamSecondMaintenanceRequest item = requests.get(i);
            try {
                // 1. 参数校验
                if (item == null) {
                    failedItems.add(createErrorItem(i, "对象为空"));
                    continue;
                }
                if (StrUtil.isEmpty(item.getStandardId())) {
                    failedItems.add(createErrorItem(i, "保养项不能为空"));
                    continue;
                }

                // 2. 生成编码并设置属性
                String codeSeq = businessCodeRuleService.generateBusinessCodeSeq(
                        BusinessCodeConst.SECOND_MAINTENANCE_CODE_RULE);
                item.setOrderNum(codeSeq);
                item.setCreationMethod(OrderCreationMethodEnum.MANUAL.name());

                // 3. 执行添加
                if (eamSecondMaintenanceOrderService.addMaintenance(item)) {
                    successOrders.add(codeSeq);
                } else {
                    failedItems.add(createErrorItem(i, "服务添加失败"));
                }
            } catch (Exception e) {
                failedItems.add(createErrorItem(i, "系统异常: " + e.getMessage()));
            }
        }

        // 4. 构造返回结果
        if (failedItems.isEmpty()) {
            return Result.OK("批量添加成功，共添加" + successOrders.size() + "条记录");
        } else {
            Map<String, Object> result = new HashMap<>();
            result.put("successCount", successOrders.size());
            result.put("failedCount", failedItems.size());
            result.put("failedDetails", failedItems);

            return Result.OK(
                    "部分添加失败（成功" + successOrders.size() + "条，失败" + failedItems.size() + "条）",
                    result
            );
        }
    }

    // 创建错误条目信息
    private Map<String, Object> createErrorItem(int index, String reason) {
        Map<String, Object> error = new HashMap<>();
        error.put("index", index);
        error.put("reason", reason);
        return error;
    }

    /**
     * 创建错误项详情
     * @param id 工单ID
     * @param errorMessage 错误信息
     * @param detail 错误详情
     * @return 错误详情Map
     */
    private Map<String, Object> createErrorItem(String id, String errorMessage, Object detail) {
        Map<String, Object> errorItem = new HashMap<>();
        errorItem.put("id", id);
        errorItem.put("error", errorMessage);
        if (detail != null) {
            errorItem.put("detail", detail);
        }
        return errorItem;
    }

    /**
     * 构建批量操作返回结果
     * @param successCount 成功数量
     * @param failedDetails 失败详情列表
     * @param actionName 操作名称（"作废"或"还原"）
     * @return 统一格式的返回结果
     */
    private Result<?> buildBatchResult(int successCount,
                                       List<Map<String, Object>> failedDetails,
                                       List<String> successIds,
                                       String actionName) {
        Map<String, Object> resultMap = new HashMap<>();
        resultMap.put("successCount", successCount);
        resultMap.put("failedCount", failedDetails.size());
        resultMap.put("successIds", successIds);
        resultMap.put("failedDetails", failedDetails);

        if (failedDetails.isEmpty()) {
            return Result.OK("批量" + actionName + "成功，共" + actionName + " " + successCount + " 条工单！"+resultMap);
        } else {
            return Result.OK("批量" + actionName + "部分成功（成功" + successCount + "条，失败" + failedDetails.size() + "条）"+resultMap.get("failedDetails"));
        }
    }


    /**
     * 编辑
     *
     * @param request
@@ -131,6 +246,167 @@
    }

    /**
     * 通过id作废
     *
     * @param id
     * @return
     */
    @AutoLog(value = "设备二级保养-作废")
    @ApiOperation(value = "设备二级保养-作废", notes = "设备二级保养-作废")
    @DeleteMapping(value = "/abolish")
    public Result<?> abolish(@RequestParam(name = "id", required = true) String id) {
        EamSecondMaintenanceOrder entity = eamSecondMaintenanceOrderService.getById(id);
        if (entity == null) {
            return Result.error("要作废的数据不存在，请刷新重试！");
        }
        if (!SecondMaintenanceStatusEnum.WAIT_MAINTENANCE.name().equals(entity.getMaintenanceStatus())) {
            return Result.error("该状态的数据不允许进行作废！");
        }
        entity.setMaintenanceStatus(SecondMaintenanceStatusEnum.ABOLISH.name());
        eamSecondMaintenanceOrderService.updateById(entity);
        return Result.OK("作废成功!");
    }

    @AutoLog(value = "周保工单-批量作废")
    @ApiOperation(value = "周保工单-批量作废", notes = "周保工单-批量作废")
    @DeleteMapping(value = "/abolishBatch")
    public Result<?> abolishBatch(@RequestParam(name = "ids", required = true) String ids) {
        List<String> list = Arrays.asList(ids.split(","));

        // 记录操作结果
        int successCount = 0;
        List<Map<String, Object>> failedDetails = new ArrayList<>();
        List<String> successIds = new ArrayList<>();

        for (String id : list) {
            try {
                EamSecondMaintenanceOrder entity = eamSecondMaintenanceOrderService.getById(id);
                if (entity == null) {
                    // 记录工单不存在
                    failedDetails.add(createErrorItem(id, "工单不存在", null));
                    continue;
                }

                if (!SecondMaintenanceStatusEnum.WAIT_MAINTENANCE.name().equals(entity.getMaintenanceStatus())) {
                    // 记录状态不符合要求
                    failedDetails.add(createErrorItem(id, "工单状态不满足作废要求", entity.getMaintenanceStatus()));
                    continue;
                }

                entity.setMaintenanceStatus(SecondMaintenanceStatusEnum.ABOLISH.name());
                boolean updateResult = eamSecondMaintenanceOrderService.updateById(entity);

                if (updateResult) {
                    successCount++;
                    successIds.add(id);
                } else {
                    // 记录更新失败
                    failedDetails.add(createErrorItem(id, "更新操作执行失败", entity.getMaintenanceStatus()));
                }
            } catch (Exception e) {
                // 记录系统异常
                failedDetails.add(createErrorItem(id, "系统异常: " + e.getMessage(), null));
            }
        }

        // 构造返回结果
        return buildBatchResult(successCount, failedDetails, successIds, "作废");
    }

    /**
     * 还原作废工单
     * @param id
     * @return
     */
    @AutoLog(value = "设备二级保养-还原作废工单")
    @ApiOperation(value = "设备二级保养-还原作废工单", notes = "设备二级保养-还原作废工单")
    @GetMapping(value = "/restore")
    public Result<?> restore(@RequestParam(name = "id", required = true) String id) {
        EamSecondMaintenanceOrder entity = eamSecondMaintenanceOrderService.getById(id);
        if (entity == null) {
            return Result.error("要还原的作废数据不存在，请刷新重试！");
        }
        if (!SecondMaintenanceStatusEnum.ABOLISH.name().equals(entity.getMaintenanceStatus())) {
            return Result.error("该状态的数据不允许进行还原！");
        }
        //查询当前设备和保养规范id是否有值
        List<EamSecondMaintenanceOrder> eamSecondMaintenanceOrderList=eamSecondMaintenanceOrderService
                .list(new QueryWrapper<EamSecondMaintenanceOrder>().eq("equipment_id",entity.getEquipmentId())
                        .eq("standard_id",entity.getStandardId())
                        .ne("maintenance_status",SecondMaintenanceStatusEnum.ABOLISH.name()));
        if(!eamSecondMaintenanceOrderList.isEmpty()){
            return Result.error("该设备已存在对应二保工单，不允许还原!");
        }
        entity.setMaintenanceStatus(SecondMaintenanceStatusEnum.WAIT_MAINTENANCE.name());
        eamSecondMaintenanceOrderService.updateById(entity);
        return Result.OK("还原成功!");
    }

    /**
     * 批量还原作废工单
     * @param ids
     * @return
     */
    @AutoLog(value = "设备二级保养-批量还原作废工单")
    @ApiOperation(value = "设备二级保养-批量还原作废工单", notes = "设备二级保养-批量还原作废工单")
    @DeleteMapping(value = "/restoreBatch")
    public Result<?> restoreBatch(@RequestParam(name = "ids", required = true) String ids) {
        List<String> list = Arrays.asList(ids.split(","));

        // 记录操作结果
        int successCount = 0;
        List<Map<String, Object>> failedDetails = new ArrayList<>();
        List<String> successIds = new ArrayList<>();

        for (String id : list) {
            try {
                EamSecondMaintenanceOrder entity = eamSecondMaintenanceOrderService.getById(id);
                if (entity == null) {
                    // 记录工单不存在
                    failedDetails.add(createErrorItem(id, "工单不存在", null));
                    continue;
                }

                if (!SecondMaintenanceStatusEnum.ABOLISH.name().equals(entity.getMaintenanceStatus())) {
                    // 记录状态不是已作废
                    failedDetails.add(createErrorItem(id, "工单状态不是已作废", entity.getMaintenanceStatus()));
                    continue;
                }

                // 查询当前设备和保养规范是否存在非作废状态的工单
                List<EamSecondMaintenanceOrder> existingOrders = eamSecondMaintenanceOrderService
                        .list(new QueryWrapper<EamSecondMaintenanceOrder>()
                                .eq("equipment_id", entity.getEquipmentId())
                                .eq("standard_id", entity.getStandardId())
                                .ne("maintenance_status", SecondMaintenanceStatusEnum.ABOLISH.name()));

                if (CollectionUtils.isNotEmpty(existingOrders)) {
                    // 记录存在非作废状态的工单
                    failedDetails.add(createErrorItem(id, "该设备和保养规范已存在非作废状态的工单", existingOrders.size()));
                    continue;
                }

                entity.setMaintenanceStatus(SecondMaintenanceStatusEnum.WAIT_MAINTENANCE.name());
                boolean updateResult = eamSecondMaintenanceOrderService.updateById(entity);

                if (updateResult) {
                    successCount++;
                    successIds.add(id);
                } else {
                    // 记录更新失败
                    failedDetails.add(createErrorItem(id, "更新操作执行失败", entity.getMaintenanceStatus()));
                }
            } catch (Exception e) {
                // 记录系统异常
                failedDetails.add(createErrorItem(id, "系统异常: " + e.getMessage(), null));
            }
        }

        // 构造返回结果
        return buildBatchResult(successCount, failedDetails, successIds, "还原");
    }

    /**
     * 通过id领取
     *
     * @param id
@@ -153,22 +429,50 @@
     * @param ids
     * @return
     */
    @AutoLog(value = "周保工单-批量领取")
    @ApiOperation(value = "周保工单-批量领取", notes = "周保工单-批量领取")
    @AutoLog(value = "设备二级保养-批量领取")
    @ApiOperation(value = "设备二级保养-批量领取", notes = "设备二级保养-批量领取")
    @DeleteMapping(value = "/collectBatch")
    public Result<?> collectBatch(@RequestParam(name = "ids", required = true) String ids) {
        List<String> list = Arrays.asList(ids.split(","));
        AtomicInteger i = new AtomicInteger();
        list.forEach(id -> {
            EamSecondMaintenanceOrder entity = eamSecondMaintenanceOrderService.getById(id);
            if (entity != null && SecondMaintenanceStatusEnum.WAIT_MAINTENANCE.name().equals(entity.getMaintenanceStatus())) {
                boolean b = eamSecondMaintenanceOrderService.collect(id);
                if (b) {
                    i.getAndIncrement();

        // 记录操作结果
        int successCount = 0;
        List<Map<String, Object>> failedDetails = new ArrayList<>();
        List<String> successIds = new ArrayList<>();

        for (String id : list) {
            try {
                EamSecondMaintenanceOrder entity = eamSecondMaintenanceOrderService.getById(id);
                if (entity == null) {
                    // 记录工单不存在
                    failedDetails.add(createErrorItem(id, "工单不存在", null));
                    continue;
                }

                // 状态校验
                if (!SecondMaintenanceStatusEnum.WAIT_MAINTENANCE.name().equals(entity.getMaintenanceStatus())) {
                    failedDetails.add(createErrorItem(id,
                            "工单当前状态不满足领取条件",
                            entity.getMaintenanceStatus()));
                    continue;
                }

                // 执行领取操作
                boolean collectResult = eamSecondMaintenanceOrderService.collect(id);

                if (collectResult) {
                    successCount++;
                    successIds.add(id);
                } else {
                    failedDetails.add(createErrorItem(id, "领取操作执行失败", null));
                }
            } catch (Exception e) {
                failedDetails.add(createErrorItem(id, "系统异常: " + e.getMessage(), null));
            }
        });
        return Result.OK("批量领取成功 " + i.get() + " 条工单！");
        }

        // 构造返回结果（使用与批量作废/还原相同的方法）
        return buildBatchResult(successCount, failedDetails, successIds, "领取");
    }

    /**

 lxzn-module-eam/src/main/java/org/jeecg/modules/eam/service/impl/EamMaintenanceStandardServiceImpl.java

@@ -183,7 +183,7 @@
        //删除标记
        entity.setDelFlag(CommonConstant.DEL_FLAG_0);
        //重复性校验
        EamMaintenanceStandard exist = checkDuplicate(entity.getEquipmentId(), entity.getMaintenanceCategory(), MaintenanceStandardStatusEnum.WAIT_SUBMIT.name());
        EamMaintenanceStandard exist = checkDuplicate(entity.getEquipmentId(), entity.getMaintenanceCategory(), MaintenanceStandardStatusEnum.ABOLISH.name());
        if (exist != null) {
            throw new JeecgBootException("设备标准已存在，不能重复添加！");
        }
@@ -259,7 +259,7 @@
        //删除标记
        newEntity.setDelFlag(CommonConstant.DEL_FLAG_0);
        //重复性校验
        EamMaintenanceStandard exist = checkDuplicate(newEntity.getEquipmentId(), newEntity.getMaintenanceCategory(), MaintenanceStandardStatusEnum.WAIT_SUBMIT.name());
        EamMaintenanceStandard exist = checkDuplicate(newEntity.getEquipmentId(), newEntity.getMaintenanceCategory(), MaintenanceStandardStatusEnum.ABOLISH.name());
        if (exist != null) {
            throw new JeecgBootException("设备标准已存在，不能重复添加！");
        }
@@ -285,7 +285,7 @@
        queryWrapper.eq(EamMaintenanceStandard::getEquipmentId, equipmentId);
        queryWrapper.eq(EamMaintenanceStandard::getMaintenanceCategory, maintenanceCategory);
        queryWrapper.eq(EamMaintenanceStandard::getDelFlag, CommonConstant.DEL_FLAG_0);
        queryWrapper.eq(EamMaintenanceStandard::getStandardStatus, standardStatus);
        queryWrapper.ne(EamMaintenanceStandard::getStandardStatus, standardStatus);
        queryWrapper.orderByDesc(EamMaintenanceStandard::getStandardVersion);

        List<EamMaintenanceStandard> list = eamMaintenanceStandardMapper.selectList(queryWrapper);
@@ -382,6 +382,7 @@
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result<?> auditEamMaintenanceStandard(EamMaintenanceStandardVo eamMaintenanceStandardVo) {
        try {
            // 参数校验
@@ -562,7 +563,7 @@

            // 检查重复
            EamMaintenanceStandard exist = checkDuplicate(eamMaintenanceStandard.getEquipmentId(),
                    eamMaintenanceStandard.getMaintenanceCategory(), MaintenanceStandardStatusEnum.START.name());
                    eamMaintenanceStandard.getMaintenanceCategory(), MaintenanceStandardStatusEnum.ABOLISH.name());
            if (exist != null) {
                return Result.error(name + ": 设备标准已存在，不能重复添加");
            }
@@ -1125,7 +1126,7 @@

                    // 配置类型相关参数
                    configureStandard(standard, type, file);
                    EamMaintenanceStandard exist = checkDuplicate(standard.getEquipmentId(), standard.getMaintenanceCategory(), MaintenanceStandardStatusEnum.START.name());
                    EamMaintenanceStandard exist = checkDuplicate(standard.getEquipmentId(), standard.getMaintenanceCategory(), MaintenanceStandardStatusEnum.ABOLISH.name());
                    if (exist != null) {
                        return Result.error(fileName + ": 设备标准已存在，不能重复添加");
                    }

 lxzn-module-eam/src/main/java/org/jeecg/modules/eam/service/impl/EamSecondMaintenanceOrderServiceImpl.java

@@ -183,6 +183,7 @@
            eamMaintenanceStandardDetailList.forEach(item -> {
                EamSecondMaintenanceOrderDetail detail = new EamSecondMaintenanceOrderDetail();
                BeanUtils.copyProperties(item, detail);
                detail.setId(null);
                detail.setOrderId(order.getId());
                requestTableDetailList.add(detail);
            });