自动化任务

src/main/java/com/gaotao/modules/autoWareHourceHaian/entity/HaiAnArchiveCountParam.java

@@ -0,0 +1,21 @@
+package com.gaotao.modules.autoWareHourceHaian.entity;
+
+import lombok.Data;
+
+/**
+ * @author rqrq
+ * @Description 海安归档存储过程通用参数实体（单计数输出），用于替代Map传参并承载keepCount/archivedCount - rqrq
+ */
+@Data
+public class HaiAnArchiveCountParam {
+
+    /**
+     * 保留条数（入参）：表示主表按ID倒序保留的最新记录数量，对应存储过程参数@KeepCount - rqrq
+     */
+    private Integer keepCount;
+
+    /**
+     * 归档数量（出参）：存储过程执行后返回的实际归档/删除记录数，对应参数@ArchivedCount - rqrq
+     */
+    private Integer archivedCount;
+}

src/main/java/com/gaotao/modules/autoWareHourceHaian/entity/HaiAnArchiveTransportTaskParam.java

@@ -0,0 +1,26 @@
+package com.gaotao.modules.autoWareHourceHaian.entity;
+
+import lombok.Data;
+
+/**
+ * @author rqrq
+ * @Description 海安运输任务归档存储过程参数实体，承载主表/子表双输出计数，避免Service层使用Map字段编排 - rqrq
+ */
+@Data
+public class HaiAnArchiveTransportTaskParam {
+
+    /**
+     * 保留条数（入参）：主任务表haian_wms_transport_task按ID倒序保留的最新记录数，对应@KeepCount - rqrq
+     */
+    private Integer keepCount;
+
+    /**
+     * 主表归档数量（出参）：归档后从haian_wms_transport_task删除的记录数，对应@ArchivedTaskCount - rqrq
+     */
+    private Integer archivedTaskCount;
+
+    /**
+     * 子表归档数量（出参）：归档后从haian_wms_transport_task_detail删除的记录数，对应@ArchivedDetailCount - rqrq
+     */
+    private Integer archivedDetailCount;
+}

src/main/java/com/gaotao/modules/autoWareHourceHaian/mapper/HaiAnDataArchiveMapper.java

@@ -0,0 +1,37 @@
+package com.gaotao.modules.autoWareHourceHaian.mapper;
+
+import com.gaotao.modules.autoWareHourceHaian.entity.HaiAnArchiveCountParam;
+import com.gaotao.modules.autoWareHourceHaian.entity.HaiAnArchiveTransportTaskParam;
+import org.apache.ibatis.annotations.Mapper;
+
+/**
+ * @author rqrq
+ * @Description 海安数据归档Mapper，专门调用haian_前缀归档存储过程，避免主库归档与海安归档混用 - rqrq
+ */
+@Mapper
+public interface HaiAnDataArchiveMapper {
+
+    /**
+     * @author rqrq
+     * @Description 调用haian_ArchiveInterfaceCallLog过程归档海安接口日志 - rqrq
+     */
+    void callHaiAnArchiveInterfaceCallLog(HaiAnArchiveCountParam param);
+
+    /**
+     * @author rqrq
+     * @Description 调用haian_ArchiveWcsCallbackPalletScan过程归档海安WCS扫描回调 - rqrq
+     */
+    void callHaiAnArchiveWcsCallbackPalletScan(HaiAnArchiveCountParam param);
+
+    /**
+     * @author rqrq
+     * @Description 调用haian_ArchiveWcsCallbackTask过程归档海安WCS任务回调 - rqrq
+     */
+    void callHaiAnArchiveWcsCallbackTask(HaiAnArchiveCountParam param);
+
+    /**
+     * @author rqrq
+     * @Description 调用haian_ArchiveWmsTransportTask过程归档海安运输任务主子表 - rqrq
+     */
+    void callHaiAnArchiveWmsTransportTask(HaiAnArchiveTransportTaskParam param);
+}

src/main/java/com/gaotao/modules/autoWareHourceHaian/service/HaiAnDataArchiveService.java

@@ -0,0 +1,32 @@
+package com.gaotao.modules.autoWareHourceHaian.service;
+
+/**
+ * @author rqrq
+ * @Description 海安数据归档服务接口，统一封装haian_前缀存储过程调用并向调度器暴露归档能力 - rqrq
+ */
+public interface HaiAnDataArchiveService {
+
+    /**
+     * @author rqrq
+     * @Description 归档海安接口调用日志（haian_interface_call_log -> haian_interface_call_log_history） - rqrq
+     */
+    int archiveHaiAnInterfaceCallLog(int keepCount);
+
+    /**
+     * @author rqrq
+     * @Description 归档海安WCS栈板扫描回调（haian_wcs_callback_pallet_scan -> history） - rqrq
+     */
+    int archiveHaiAnWcsCallbackPalletScan(int keepCount);
+
+    /**
+     * @author rqrq
+     * @Description 归档海安WCS任务回调（haian_wcs_callback_task -> history） - rqrq
+     */
+    int archiveHaiAnWcsCallbackTask(int keepCount);
+
+    /**
+     * @author rqrq
+     * @Description 归档海安运输任务主子表（haian_wms_transport_task/detail -> history） - rqrq
+     */
+    int archiveHaiAnWmsTransportTask(int keepCount);
+}

src/main/java/com/gaotao/modules/autoWareHourceHaian/service/impl/HaiAnDataArchiveServiceImpl.java

@@ -0,0 +1,122 @@
+package com.gaotao.modules.autoWareHourceHaian.service.impl;
+
+import com.gaotao.modules.autoWareHourceHaian.entity.HaiAnArchiveCountParam;
+import com.gaotao.modules.autoWareHourceHaian.entity.HaiAnArchiveTransportTaskParam;
+import com.gaotao.modules.autoWareHourceHaian.mapper.HaiAnDataArchiveMapper;
+import com.gaotao.modules.autoWareHourceHaian.service.HaiAnDataArchiveService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * @author rqrq
+ * @Description 海安数据归档服务实现，统一通过haian_前缀存储过程执行主表到history表迁移，避免海安归档误调用老链路过程 - rqrq
+ */
+@Service
+public class HaiAnDataArchiveServiceImpl implements HaiAnDataArchiveService {
+
+    @Autowired
+    private HaiAnDataArchiveMapper haiAnDataArchiveMapper;
+
+    /**
+     * @author rqrq
+     * @Description 归档海安接口调用日志：按keepCount保留最新记录，其余通过过程迁移到history并删除原表 - rqrq
+     * @param keepCount 保留记录数，按id倒序保留最新N条 - rqrq
+     * @return 归档删除条数 - rqrq
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public int archiveHaiAnInterfaceCallLog(int keepCount) {
+        System.out.println("开始归档haian_interface_call_log数据 - rqrq，保留最新" + keepCount + "条");
+        try {
+            HaiAnArchiveCountParam param = new HaiAnArchiveCountParam();
+            param.setKeepCount(keepCount);
+            param.setArchivedCount(0);
+            // 调用海安接口日志归档存储过程，关键入参为keepCount；若调用失败会导致主表历史数据持续堆积 - rqrq
+            haiAnDataArchiveMapper.callHaiAnArchiveInterfaceCallLog(param);
+            int archivedCount = param.getArchivedCount() == null ? 0 : param.getArchivedCount();
+            System.out.println("haian_interface_call_log归档完成 - rqrq，归档数量=" + archivedCount);
+            return archivedCount;
+        } catch (Exception e) {
+            System.out.println("归档haian_interface_call_log失败 - rqrq：" + e.getMessage());
+            throw new RuntimeException("归档haian_interface_call_log失败：" + e.getMessage(), e);
+        }
+    }
+
+    /**
+     * @author rqrq
+     * @Description 归档海安WCS栈板扫描回调：按keepCount保留最新记录，历史数据迁移至history - rqrq
+     * @param keepCount 保留记录数，按id倒序保留最新N条 - rqrq
+     * @return 归档删除条数 - rqrq
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public int archiveHaiAnWcsCallbackPalletScan(int keepCount) {
+        System.out.println("开始归档haian_wcs_callback_pallet_scan数据 - rqrq，保留最新" + keepCount + "条");
+        try {
+            HaiAnArchiveCountParam param = new HaiAnArchiveCountParam();
+            param.setKeepCount(keepCount);
+            param.setArchivedCount(0);
+            // 调用海安扫描回调归档存储过程，关键入参为keepCount；若失败会影响回调主表查询性能 - rqrq
+            haiAnDataArchiveMapper.callHaiAnArchiveWcsCallbackPalletScan(param);
+            int archivedCount = param.getArchivedCount() == null ? 0 : param.getArchivedCount();
+            System.out.println("haian_wcs_callback_pallet_scan归档完成 - rqrq，归档数量=" + archivedCount);
+            return archivedCount;
+        } catch (Exception e) {
+            System.out.println("归档haian_wcs_callback_pallet_scan失败 - rqrq：" + e.getMessage());
+            throw new RuntimeException("归档haian_wcs_callback_pallet_scan失败：" + e.getMessage(), e);
+        }
+    }
+
+    /**
+     * @author rqrq
+     * @Description 归档海安WCS任务回调：按keepCount保留最新记录，历史数据迁移至history - rqrq
+     * @param keepCount 保留记录数，按id倒序保留最新N条 - rqrq
+     * @return 归档删除条数 - rqrq
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public int archiveHaiAnWcsCallbackTask(int keepCount) {
+        System.out.println("开始归档haian_wcs_callback_task数据 - rqrq，保留最新" + keepCount + "条");
+        try {
+            HaiAnArchiveCountParam param = new HaiAnArchiveCountParam();
+            param.setKeepCount(keepCount);
+            param.setArchivedCount(0);
+            // 调用海安任务回调归档存储过程，关键入参为keepCount；若失败会导致回调任务表膨胀并拖慢消费查询 - rqrq
+            haiAnDataArchiveMapper.callHaiAnArchiveWcsCallbackTask(param);
+            int archivedCount = param.getArchivedCount() == null ? 0 : param.getArchivedCount();
+            System.out.println("haian_wcs_callback_task归档完成 - rqrq，归档数量=" + archivedCount);
+            return archivedCount;
+        } catch (Exception e) {
+            System.out.println("归档haian_wcs_callback_task失败 - rqrq：" + e.getMessage());
+            throw new RuntimeException("归档haian_wcs_callback_task失败：" + e.getMessage(), e);
+        }
+    }
+
+    /**
+     * @author rqrq
+     * @Description 归档海安运输任务主子表：同事务先归档detail再归档主表，再按同阈值分批删除原数据 - rqrq
+     * @param keepCount 保留主任务表最新记录数（通过主表id阈值控制主子表归档范围） - rqrq
+     * @return 主表归档删除条数 - rqrq
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public int archiveHaiAnWmsTransportTask(int keepCount) {
+        System.out.println("开始归档haian_wms_transport_task及明细数据 - rqrq，保留最新" + keepCount + "条");
+        try {
+            HaiAnArchiveTransportTaskParam param = new HaiAnArchiveTransportTaskParam();
+            param.setKeepCount(keepCount);
+            param.setArchivedTaskCount(0);
+            param.setArchivedDetailCount(0);
+            // 调用海安运输任务归档存储过程，关键入参为主表keepCount；若失败会导致主子表历史任务持续累积 - rqrq
+            haiAnDataArchiveMapper.callHaiAnArchiveWmsTransportTask(param);
+            int archivedTaskCount = param.getArchivedTaskCount() == null ? 0 : param.getArchivedTaskCount();
+            int archivedDetailCount = param.getArchivedDetailCount() == null ? 0 : param.getArchivedDetailCount();
+            System.out.println("haian_wms_transport_task及明细归档完成 - rqrq，归档任务数=" + archivedTaskCount + "，明细数=" + archivedDetailCount);
+            return archivedTaskCount;
+        } catch (Exception e) {
+            System.out.println("归档haian_wms_transport_task失败 - rqrq：" + e.getMessage());
+            throw new RuntimeException("归档haian_wms_transport_task失败：" + e.getMessage(), e);
+        }
+    }
+}

src/main/java/com/gaotao/modules/autoWareHourceHaian/task/HaianAutoTaskScheduler.java

@@ -152,6 +152,8 @@ public class HaianAutoTaskScheduler {
             log.info("=== 海安IFS移库队列处理完成 - rqrq：总数={}, 成功={}, 失败={} ===",
                     queueList.size(), successCount, failCount);
         } catch (Exception e) {
+            // 记录任务级失败到sys_error_log，关键业务键传站点54，避免仅控制台日志导致定时任务异常无法追溯 - rqrq
+            ErrorLogUtils.logException("54", "海安立库", "海安IFS移库队列定时任务", "scheduleIfsPalletMoveQueue", e);
             log.error("=== 海安IFS移库队列定时任务执行失败 - rqrq ===", e);
         }
     }

src/main/java/com/gaotao/modules/autoWareHourceHaian/task/HaianDataArchiveScheduler.java

@@ -0,0 +1,111 @@
+package com.gaotao.modules.autoWareHourceHaian.task;
+
+import com.gaotao.common.utils.ErrorLogUtils;
+import com.gaotao.modules.autoWareHourceHaian.service.HaiAnDataArchiveService;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+
+/**
+ * @author rqrq
+ * @Description 海安数据归档定时任务：复刻老DataArchiveScheduler风格并按10:30起每3分钟错峰执行，归档haian_*_history链路 - rqrq
+ */
+@Slf4j
+@Component
+public class HaianDataArchiveScheduler {
+
+    @Autowired
+    private HaiAnDataArchiveService haiAnDataArchiveService;
+
+    /**
+     * 海安归档总开关：false时全部任务不执行 - rqrq
+     */
+    @Value("${scheduler.haianDataArchive.enabled:false}")
+    private boolean enabled;
+
+    /**
+     * @author rqrq
+     * @Description 定时任务：归档海安接口调用日志（10:30执行） - rqrq
+     */
+    @Scheduled(cron = "${scheduler.haianDataArchive.interfaceCallLog.cron:0 30 10 * * ?}")
+    public void archiveHaiAnInterfaceCallLog() {
+        // 执行前校验总开关，避免在联调环境误归档主数据 - rqrq
+        if (!enabled) {
+            return;
+        }
+        log.info("=== 开始归档海安接口调用日志数据 - rqrq ===");
+        try {
+            // 调用海安归档服务处理接口日志，关键参数keepCount=2000；失败将导致日志主表体量持续增长 - rqrq
+            int archivedCount = haiAnDataArchiveService.archiveHaiAnInterfaceCallLog(2000);
+            log.info("=== 海安接口调用日志归档完成 - rqrq：归档数量={} ===", archivedCount);
+        } catch (Exception e) {
+            ErrorLogUtils.logException("54", "海安数据归档", "海安接口调用日志", "", e);
+            log.error("=== 海安接口调用日志归档失败 - rqrq ===", e);
+        }
+    }
+
+    /**
+     * @author rqrq
+     * @Description 定时任务：归档海安WCS回调栈板扫描数据（10:33执行） - rqrq
+     */
+    @Scheduled(cron = "${scheduler.haianDataArchive.wcsCallbackPalletScan.cron:0 33 10 * * ?}")
+    public void archiveHaiAnWcsCallbackPalletScan() {
+        // 执行前校验总开关，避免在联调环境误归档主数据 - rqrq
+        if (!enabled) {
+            return;
+        }
+        log.info("=== 开始归档海安WCS回调栈板扫描数据 - rqrq ===");
+        try {
+            // 调用海安归档服务处理扫描回调，关键参数keepCount=2000；失败会影响回调查询与排障效率 - rqrq
+            int archivedCount = haiAnDataArchiveService.archiveHaiAnWcsCallbackPalletScan(2000);
+            log.info("=== 海安WCS回调栈板扫描归档完成 - rqrq：归档数量={} ===", archivedCount);
+        } catch (Exception e) {
+            ErrorLogUtils.logException("54", "海安数据归档", "海安WCS回调栈板扫描", "", e);
+            log.error("=== 海安WCS回调栈板扫描归档失败 - rqrq ===", e);
+        }
+    }
+
+    /**
+     * @author rqrq
+     * @Description 定时任务：归档海安WCS回调任务数据（10:36执行） - rqrq
+     */
+    @Scheduled(cron = "${scheduler.haianDataArchive.wcsCallbackTask.cron:0 36 10 * * ?}")
+    public void archiveHaiAnWcsCallbackTask() {
+        // 执行前校验总开关，避免在联调环境误归档主数据 - rqrq
+        if (!enabled) {
+            return;
+        }
+        log.info("=== 开始归档海安WCS回调任务数据 - rqrq ===");
+        try {
+            // 调用海安归档服务处理回调任务，关键参数keepCount=2000；失败会造成回调任务主表长期膨胀 - rqrq
+            int archivedCount = haiAnDataArchiveService.archiveHaiAnWcsCallbackTask(2000);
+            log.info("=== 海安WCS回调任务归档完成 - rqrq：归档数量={} ===", archivedCount);
+        } catch (Exception e) {
+            ErrorLogUtils.logException("54", "海安数据归档", "海安WCS回调任务", "", e);
+            log.error("=== 海安WCS回调任务归档失败 - rqrq ===", e);
+        }
+    }
+
+    /**
+     * @author rqrq
+     * @Description 定时任务：归档海安运输任务主子表（10:39执行） - rqrq
+     */
+    @Scheduled(cron = "${scheduler.haianDataArchive.wmsTransportTask.cron:0 39 10 * * ?}")
+    public void archiveHaiAnWmsTransportTask() {
+        // 执行前校验总开关，避免在联调环境误归档主数据 - rqrq
+        if (!enabled) {
+            return;
+        }
+        log.info("=== 开始归档海安WMS运输任务数据 - rqrq ===");
+        try {
+            // 调用海安归档服务处理主子任务，关键参数keepCount=2000；失败会导致主子任务表体量增长并拖慢历史检索 - rqrq
+            int archivedCount = haiAnDataArchiveService.archiveHaiAnWmsTransportTask(2000);
+            log.info("=== 海安WMS运输任务归档完成 - rqrq：归档任务数量={} ===", archivedCount);
+        } catch (Exception e) {
+            ErrorLogUtils.logException("54", "海安数据归档", "海安WMS运输任务", "", e);
+            log.error("=== 海安WMS运输任务归档失败 - rqrq ===", e);
+        }
+    }
+}

src/main/java/com/gaotao/modules/autoWareHourceHaian/task/HaianWcsSchedule.java

@@ -79,6 +79,8 @@ public class HaianWcsSchedule {
                 }
             }
         } catch (Exception e) {
+            // 记录任务级异常到sys_error_log，按反馈站点写业务键，避免批次查询失败只留本地日志 - rqrq
+            ErrorLogUtils.logException(feedbackSite, "海安立库", "海安AGV回调定时任务", "scheduleAgvFeedback", e);
             log.error("=== 海安AGV回调定时任务执行失败 - rqrq，site={} ===", feedbackSite, e);
         }
         log.info("=== 海安AGV回调业务处理完成 - rqrq，site={} ===", feedbackSite);
@@ -127,6 +129,8 @@ public class HaianWcsSchedule {
             log.info("=== 海安WCS出入库回调处理完成 - rqrq：总数={}, 成功={}, 失败={}，site={} ===",
                     list.size(), successCount, failCount, callbackSite);
         } catch (Exception e) {
+            // 记录任务级异常到sys_error_log，按回调站点写业务键，便于定位整批次消费失败 - rqrq
+            ErrorLogUtils.logException(callbackSite, "海安立库", "海安WCS出入库回调定时任务", "scheduleHaianWcsTaskProcessing", e);
             log.error("=== 海安WCS出入库回调定时任务执行失败 - rqrq，site={} ===", callbackSite, e);
         }
     }
@@ -175,6 +179,8 @@ public class HaianWcsSchedule {
             log.info("=== 海安WCS栈板扫描回调处理完成 - rqrq：总数={}, 成功={}, 失败={}，site={} ===",
                     list.size(), successCount, failCount, callbackSite);
         } catch (Exception e) {
+            // 记录任务级异常到sys_error_log，按回调站点写业务键，避免扫描回调批次异常丢失 - rqrq
+            ErrorLogUtils.logException(callbackSite, "海安立库", "海安WCS栈板扫描回调定时任务", "scheduleInventoryDiscrepancyProcessing", e);
             log.error("=== 海安WCS栈板扫描回调定时任务执行失败 - rqrq，site={} ===", callbackSite, e);
         }
     }

src/main/resources/application.yml

@@ -167,6 +167,16 @@ scheduler:
     feedback-site: '54'  # 海安AGV回调消费站点，默认54 - rqrq
     callback-enabled: false  # 海安WCS回调消费开关（控制scheduleHaianWcsTaskProcessing/scheduleInventoryDiscrepancyProcessing） - rqrq
     callback-site: '54'  # 海安WCS出入库回调消费站点，默认54 - rqrq
+  haianDataArchive:
+    enabled: false  # 海安归档任务总开关（控制HaianDataArchiveScheduler.java） - rqrq
+    interfaceCallLog:
+      cron: '0 30 10 * * ?'  # 错峰第1个任务：10:30归档haian_interface_call_log - rqrq
+    wcsCallbackPalletScan:
+      cron: '0 33 10 * * ?'  # 错峰第2个任务：10:33归档haian_wcs_callback_pallet_scan - rqrq
+    wcsCallbackTask:
+      cron: '0 36 10 * * ?'  # 错峰第3个任务：10:36归档haian_wcs_callback_task - rqrq
+    wmsTransportTask:
+      cron: '0 39 10 * * ?'  # 错峰第4个任务：10:39归档haian_wms_transport_task(+detail) - rqrq
   # 数据归档任务配置 - rqrq
   dataArchive:
     enabled: false  # 数据归档任务总开关（控制DataArchiveScheduler.java的所有定时任务，默认关闭）

src/main/resources/mapper/autoWareHourceHaian/HaiAnDataArchiveMapper.xml

@@ -0,0 +1,45 @@
+<?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.gaotao.modules.autoWareHourceHaian.mapper.HaiAnDataArchiveMapper">
+
+    <!-- rqrq - 调用haian_ArchiveInterfaceCallLog归档海安接口日志 -->
+    <select id="callHaiAnArchiveInterfaceCallLog"
+            parameterType="com.gaotao.modules.autoWareHourceHaian.entity.HaiAnArchiveCountParam"
+            statementType="CALLABLE">
+        {call haian_ArchiveInterfaceCallLog(
+            #{keepCount, mode=IN, jdbcType=INTEGER},
+            #{archivedCount, mode=OUT, jdbcType=INTEGER}
+        )}
+    </select>
+
+    <!-- rqrq - 调用haian_ArchiveWcsCallbackPalletScan归档海安WCS栈板扫描回调 -->
+    <select id="callHaiAnArchiveWcsCallbackPalletScan"
+            parameterType="com.gaotao.modules.autoWareHourceHaian.entity.HaiAnArchiveCountParam"
+            statementType="CALLABLE">
+        {call haian_ArchiveWcsCallbackPalletScan(
+            #{keepCount, mode=IN, jdbcType=INTEGER},
+            #{archivedCount, mode=OUT, jdbcType=INTEGER}
+        )}
+    </select>
+
+    <!-- rqrq - 调用haian_ArchiveWcsCallbackTask归档海安WCS回调任务 -->
+    <select id="callHaiAnArchiveWcsCallbackTask"
+            parameterType="com.gaotao.modules.autoWareHourceHaian.entity.HaiAnArchiveCountParam"
+            statementType="CALLABLE">
+        {call haian_ArchiveWcsCallbackTask(
+            #{keepCount, mode=IN, jdbcType=INTEGER},
+            #{archivedCount, mode=OUT, jdbcType=INTEGER}
+        )}
+    </select>
+
+    <!-- rqrq - 调用haian_ArchiveWmsTransportTask归档海安运输任务主子表 -->
+    <select id="callHaiAnArchiveWmsTransportTask"
+            parameterType="com.gaotao.modules.autoWareHourceHaian.entity.HaiAnArchiveTransportTaskParam"
+            statementType="CALLABLE">
+        {call haian_ArchiveWmsTransportTask(
+            #{keepCount, mode=IN, jdbcType=INTEGER},
+            #{archivedTaskCount, mode=OUT, jdbcType=INTEGER},
+            #{archivedDetailCount, mode=OUT, jdbcType=INTEGER}
+        )}
+    </select>
+</mapper>