回退操作,根据历史表回退

ship-module-trade/ship-module-trade-biz/src/main/java/com/yc/ship/module/trade/dal/mysql/order/TradeDetailBaseMapper.java

@@ -51,4 +51,6 @@ public interface TradeDetailBaseMapper extends BaseMapperX<TradeDetailBaseDO> {
     @TenantIgnore
     void updateDeleted(@Param("orderId") Long orderId, @Param("deleted")  int deleted);
 
-}
+    @TenantIgnore
+    void deleteAllByOrderId(@Param("orderId") Long orderId);
+}

ship-module-trade/ship-module-trade-biz/src/main/java/com/yc/ship/module/trade/dal/mysql/order/TradeDetailMapper.java

@@ -198,4 +198,8 @@ public interface TradeDetailMapper extends BaseMapperX<TradeDetailDO> {
      * @return
      */
     List<OrderTotalSpuVO> selectOrderSpuStatsByOrderIds(@Param("orderIds") List<Long> orderIds);
+
+
+    @TenantIgnore
+    void deleteAllByOrderId(@Param("orderId") Long orderId);
 }

ship-module-trade/ship-module-trade-biz/src/main/java/com/yc/ship/module/trade/dal/mysql/order/TradeOrderCountryMapper.java

@@ -4,6 +4,7 @@ import com.yc.ship.framework.mybatis.core.mapper.BaseMapperX;
 import com.yc.ship.framework.mybatis.core.query.LambdaQueryWrapperX;
 import com.yc.ship.framework.tenant.core.aop.TenantIgnore;
 import com.yc.ship.module.trade.dal.dataobject.order.TradeOrderCountryDO;
+import org.apache.ibatis.annotations.Delete;
 import org.apache.ibatis.annotations.Mapper;
 import org.apache.ibatis.annotations.Param;
 import org.apache.ibatis.annotations.Update;
@@ -31,4 +32,8 @@ public interface TradeOrderCountryMapper extends BaseMapperX<TradeOrderCountryDO
     @Update("UPDATE trade_order_country SET deleted = #{deleted},update_time = now() WHERE order_id = #{orderId}")
     @TenantIgnore
     void updateDeleted(@Param("orderId") Long orderId, @Param("deleted")  int deleted);
-}
+
+    @Delete("delete from trade_order_country where order_id = #{orderId}")
+    @TenantIgnore
+    void deleteAllByOrderId(Long orderId);
+}

ship-module-trade/ship-module-trade-biz/src/main/java/com/yc/ship/module/trade/dal/mysql/order/TradeOrderFloorMapper.java

@@ -3,6 +3,7 @@ package com.yc.ship.module.trade.dal.mysql.order;
 import com.yc.ship.framework.mybatis.core.mapper.BaseMapperX;
 import com.yc.ship.framework.tenant.core.aop.TenantIgnore;
 import com.yc.ship.module.trade.dal.dataobject.order.TradeOrderFloorDO;
+import org.apache.ibatis.annotations.Delete;
 import org.apache.ibatis.annotations.Mapper;
 import org.apache.ibatis.annotations.Param;
 import org.apache.ibatis.annotations.Update;
@@ -17,4 +18,8 @@ public interface TradeOrderFloorMapper extends BaseMapperX<TradeOrderFloorDO> {
     @Update("UPDATE trade_order_floor SET deleted = #{deleted},update_time = now(), sync_status = '0' WHERE order_id = #{orderId}")
     @TenantIgnore
     void updateDeleted(@Param("orderId") Long orderId, @Param("deleted")  int deleted);
-}
+
+    @Delete("delete from trade_order_floor where order_id = #{orderId}")
+    @TenantIgnore
+    void deleteAllByOrderId(@Param("orderId") Long orderId);
+}

ship-module-trade/ship-module-trade-biz/src/main/java/com/yc/ship/module/trade/dal/mysql/order/TradeOrderRoomModelMapper.java

@@ -52,4 +52,7 @@ public interface TradeOrderRoomModelMapper extends BaseMapperX<TradeOrderRoomMod
      * @return
      */
     List<OrderTotalRoomModelVO> selectOrderRoomModelStatsByOrderIds(@Param("orderIds") List<Long> orderIds);
-}
+
+    @TenantIgnore
+    void deleteAllByOrderId(@Param("orderId") Long orderId);
+}

ship-module-trade/ship-module-trade-biz/src/main/java/com/yc/ship/module/trade/dal/mysql/order/TradeOrderTotalMapper.java

@@ -4,10 +4,7 @@ import com.yc.ship.framework.mybatis.core.mapper.BaseMapperX;
 import com.yc.ship.framework.mybatis.core.query.LambdaQueryWrapperX;
 import com.yc.ship.framework.tenant.core.aop.TenantIgnore;
 import com.yc.ship.module.trade.dal.dataobject.order.TradeOrderTotalDO;
-import org.apache.ibatis.annotations.Mapper;
-import org.apache.ibatis.annotations.Param;
-import org.apache.ibatis.annotations.Select;
-import org.apache.ibatis.annotations.Update;
+import org.apache.ibatis.annotations.*;
 
 import java.util.List;
 
@@ -36,4 +33,8 @@ public interface TradeOrderTotalMapper extends BaseMapperX<TradeOrderTotalDO> {
     @Select("select * from trade_order_total where old_order_id = #{orderId} limit 1")
     @TenantIgnore
     TradeOrderTotalDO selectByOrderId(@Param("orderId") Long orderId);
-}
+
+    @Delete("delete from trade_order_total where old_order_id = #{orderId}")
+    @TenantIgnore
+    void deleteAllByOrderId(@Param("orderId") Long orderId);
+}

ship-module-trade/ship-module-trade-biz/src/main/java/com/yc/ship/module/trade/dal/mysql/order/TradeOrderUserMapper.java

@@ -4,6 +4,7 @@ package com.yc.ship.module.trade.dal.mysql.order;
 import com.yc.ship.framework.mybatis.core.mapper.BaseMapperX;
 import com.yc.ship.framework.tenant.core.aop.TenantIgnore;
 import com.yc.ship.module.trade.dal.dataobject.order.TradeOrderUserDO;
+import org.apache.ibatis.annotations.Delete;
 import org.apache.ibatis.annotations.Mapper;
 import org.apache.ibatis.annotations.Param;
 import org.apache.ibatis.annotations.Update;
@@ -19,4 +20,7 @@ public interface TradeOrderUserMapper extends BaseMapperX<TradeOrderUserDO> {
     @TenantIgnore
     void updateDeleted(@Param("orderId") Long orderId, @Param("deleted")  int deleted);
 
-}
+    @Delete("delete from trade_order_user where order_id = #{orderId}")
+    @TenantIgnore
+    void deleteAllByOrderId(@Param("orderId") Long orderId);
+}

ship-module-trade/ship-module-trade-biz/src/main/java/com/yc/ship/module/trade/dal/mysql/order/TradeVisitorMapper.java

@@ -125,4 +125,7 @@ public interface TradeVisitorMapper extends BaseMapperX<TradeVisitorDO> {
     }
 
     IPage<VisitorRespVO> selectVisitorPage(IPage<VisitorRespVO> page, @Param("vo") VisitorPageReqVO vo);
-}
+
+    @TenantIgnore
+    void deleteAllByOrderId(@Param("orderId") Long orderId);
+}

ship-module-trade/ship-module-trade-biz/src/main/java/com/yc/ship/module/trade/service/otc/impl/OtcTradeOrderServiceImpl.java

@@ -38,6 +38,32 @@ import com.yc.ship.framework.security.core.util.SecurityFrameworkUtils;
 import com.yc.ship.framework.tenant.core.aop.TenantIgnore;
 import com.yc.ship.framework.tenant.core.context.TenantContextHolder;
 import com.yc.ship.framework.tenant.core.util.TenantUtils;
+import com.yc.ship.module.his.dal.dataobject.tradedetail.HisTradeDetailDO;
+import com.yc.ship.module.his.dal.dataobject.tradedetailbase.HisTradeDetailBaseDO;
+import com.yc.ship.module.his.dal.dataobject.tradeorder.HisTradeOrderDO;
+import com.yc.ship.module.his.dal.dataobject.tradeordercountry.HisTradeOrderCountryDO;
+import com.yc.ship.module.his.dal.dataobject.tradeorderfloor.HisTradeOrderFloorDO;
+import com.yc.ship.module.his.dal.dataobject.tradeorderroommodel.HisTradeOrderRoomModelDO;
+import com.yc.ship.module.his.dal.dataobject.tradeordertotal.HisTradeOrderTotalDO;
+import com.yc.ship.module.his.dal.dataobject.tradeorderuser.HisTradeOrderUserDO;
+import com.yc.ship.module.his.dal.dataobject.tradevisitor.HisTradeVisitorDO;
+import com.yc.ship.module.his.dal.mysql.tradedetail.HisTradeDetailMapper;
+import com.yc.ship.module.his.dal.mysql.tradedetailbase.HisTradeDetailBaseMapper;
+import com.yc.ship.module.his.dal.mysql.tradeorder.HisTradeOrderMapper;
+import com.yc.ship.module.his.dal.mysql.tradeordercountry.HisTradeOrderCountryMapper;
+import com.yc.ship.module.his.dal.mysql.tradeorderfloor.HisTradeOrderFloorMapper;
+import com.yc.ship.module.his.dal.mysql.tradeorderroommodel.HisTradeOrderRoomModelMapper;
+import com.yc.ship.module.his.dal.mysql.tradeordertotal.HisTradeOrderTotalMapper;
+import com.yc.ship.module.his.dal.mysql.tradeorderuser.HisTradeOrderUserMapper;
+import com.yc.ship.module.his.dal.mysql.tradevisitor.HisTradeVisitorMapper;
+import com.yc.ship.module.his.service.tradedetail.HisTradeDetailService;
+import com.yc.ship.module.his.service.tradedetailbase.HisTradeDetailBaseService;
+import com.yc.ship.module.his.service.tradeordercountry.HisTradeOrderCountryService;
+import com.yc.ship.module.his.service.tradeorderfloor.HisTradeOrderFloorService;
+import com.yc.ship.module.his.service.tradeorderroommodel.HisTradeOrderRoomModelService;
+import com.yc.ship.module.his.service.tradeordertotal.HisTradeOrderTotalService;
+import com.yc.ship.module.his.service.tradeorderuser.HisTradeOrderUserService;
+import com.yc.ship.module.his.service.tradevisitor.HisTradeVisitorService;
 import com.yc.ship.module.infra.api.config.ConfigApi;
 import com.yc.ship.module.marketing.api.policy.PolicyApi;
 import com.yc.ship.module.member.api.address.MemberAddressApi;
@@ -106,8 +132,7 @@ import com.yc.ship.module.trade.framework.common.ThreadLocalUtil;
 import com.yc.ship.module.trade.framework.common.TradeOrderLogUtils;
 import com.yc.ship.module.trade.framework.mq.TradePublishUtils;
 import com.yc.ship.module.trade.service.invoice.InvoiceService;
-import com.yc.ship.module.trade.service.order.TradeOrderRepositoryService;
-import com.yc.ship.module.trade.service.order.TradeOrderService;
+import com.yc.ship.module.trade.service.order.*;
 import com.yc.ship.module.trade.service.otc.OtcTradeOrderService;
 import com.yc.ship.module.trade.service.pay.TradeOrderPayService;
 import com.yc.ship.module.trade.service.refund.TradeRefundRepositoryService;
@@ -181,12 +206,20 @@ public class OtcTradeOrderServiceImpl implements OtcTradeOrderService {
     @Resource
     private TradeOrderMapper tradeOrderMapper;
     @Resource
+    private HisTradeOrderMapper hisTradeOrderMapper;
+    @Resource
     private TradeOrderUserMapper tradeOrderUserMapper;
     @Resource
+    private HisTradeOrderUserMapper hisTradeOrderUserMapper;
+    @Resource
     private TradeDetailMapper tradeDetailMapper;
     @Resource
+    private HisTradeDetailMapper hisTradeDetailMapper;
+    @Resource
     private TradeDetailBaseMapper tradeDetailBaseMapper;
     @Resource
+    private HisTradeDetailBaseMapper hisTradeDetailBaseMapper;
+    @Resource
     private ContractMapper contractMapper;
     @Resource
     private InsuranceMapper insuranceMapper;
@@ -212,18 +245,28 @@ public class OtcTradeOrderServiceImpl implements OtcTradeOrderService {
 
     @Resource
     private TradeOrderTotalMapper tradeOrderTotalMapper;
+    @Resource
+    private HisTradeOrderTotalMapper hisTradeOrderTotalMapper;
 
     @Resource
     private TradeOrderCountryMapper tradeOrderCountryMapper;
+    @Resource
+    private HisTradeOrderCountryMapper hisTradeOrderCountryMapper;
 
     @Resource
     private TradeOrderRoomModelMapper tradeOrderRoomModelMapper;
+    @Resource
+    private HisTradeOrderRoomModelMapper hisTradeOrderRoomModelMapper;
 
     @Resource
     private TradeVisitorMapper tradeVisitorMapper;
+    @Resource
+    private HisTradeVisitorMapper hisTradeVisitorMapper;
 
     @Resource
     private TradeOrderFloorMapper tradeOrderFloorMapper;
+    @Resource
+    private HisTradeOrderFloorMapper hisTradeOrderFloorMapper;
 
     @Resource
     private VoyageService voyageService;
@@ -503,28 +546,44 @@ public class OtcTradeOrderServiceImpl implements OtcTradeOrderService {
             tradeOrderAuditDO.setOrderId(tradeOrderDO.getId());
             tradeOrderAuditMapper.insert(tradeOrderAuditDO);
             //审核 不通过还原到修改前订单
-            List<TradeOrderDO> tradeOrderDoList = tradeOrderMapper.queryOrderByLast(tradeOrderDO.getOrderNo());
-            if (tradeOrderDoList != null && !tradeOrderDoList.isEmpty()) {
-                TradeOrderDO lastTradeOrder = tradeOrderDoList.get(0);
-                tradeOrderMapper.updateOrderDeleted(orderId, 1);
-                tradeOrderMapper.updateOrderDeleted(lastTradeOrder.getId(), 0);
-                tradeOrderUserMapper.updateDeleted(orderId, 1);
-                tradeOrderUserMapper.updateDeleted(lastTradeOrder.getId(), 0);
-                tradeDetailMapper.updateDeleted(orderId, 1);
-                tradeDetailMapper.updateDeleted(lastTradeOrder.getId(), 0);
-                tradeDetailBaseMapper.updateDeleted(orderId, 1);
-                tradeDetailBaseMapper.updateDeleted(lastTradeOrder.getId(), 0);
-                tradeVisitorMapper.updateDeleted(orderId, 1);
-                tradeVisitorMapper.updateDeleted(lastTradeOrder.getId(), 0);
-                tradeOrderCountryMapper.updateDeleted(orderId, 1);
-                tradeOrderCountryMapper.updateDeleted(lastTradeOrder.getId(), 0);
-                tradeOrderRoomModelMapper.updateDeleted(orderId, 1);
-                tradeOrderRoomModelMapper.updateDeleted(lastTradeOrder.getId(), 0);
-                tradeOrderFloorMapper.updateDeleted(orderId, 1);
-                tradeOrderFloorMapper.updateDeleted(lastTradeOrder.getId(), 0);
-                tradeOrderTotalMapper.updateDeleted(orderId, 1);
-                tradeOrderTotalMapper.updateDeleted(lastTradeOrder.getId(), 0);
 
+//            List<TradeOrderDO> tradeOrderDoList = tradeOrderMapper.queryOrderByLast(tradeOrderDO.getOrderNo());
+            HisTradeOrderDO lastTradeOrder = hisTradeOrderMapper.selectOne(new LambdaQueryWrapper<HisTradeOrderDO>()
+                    .eq(HisTradeOrderDO::getId, orderId)
+                    .eq(HisTradeOrderDO::getCurrentVersion, 1)
+            );
+
+
+//            if (tradeOrderDoList != null && !tradeOrderDoList.isEmpty()) {
+            if (lastTradeOrder != null) {
+//                TradeOrderDO lastTradeOrder = tradeOrderDoList.get(0);
+//                tradeOrderMapper.updateOrderDeleted(orderId, 1);
+//                tradeOrderMapper.updateOrderDeleted(lastTradeOrder.getId(), 0);
+//                tradeOrderUserMapper.updateDeleted(orderId, 1);
+//                tradeOrderUserMapper.updateDeleted(lastTradeOrder.getId(), 0);
+//                tradeDetailMapper.updateDeleted(orderId, 1);
+//                tradeDetailMapper.updateDeleted(lastTradeOrder.getId(), 0);
+//                tradeDetailBaseMapper.updateDeleted(orderId, 1);
+//                tradeDetailBaseMapper.updateDeleted(lastTradeOrder.getId(), 0);
+//                tradeVisitorMapper.updateDeleted(orderId, 1);
+//                tradeVisitorMapper.updateDeleted(lastTradeOrder.getId(), 0);
+//                tradeOrderCountryMapper.updateDeleted(orderId, 1);
+//                tradeOrderCountryMapper.updateDeleted(lastTradeOrder.getId(), 0);
+//                tradeOrderRoomModelMapper.updateDeleted(orderId, 1);
+//                tradeOrderRoomModelMapper.updateDeleted(lastTradeOrder.getId(), 0);
+//                tradeOrderFloorMapper.updateDeleted(orderId, 1);
+//                tradeOrderFloorMapper.updateDeleted(lastTradeOrder.getId(), 0);
+//                tradeOrderTotalMapper.updateDeleted(orderId, 1);
+//                tradeOrderTotalMapper.updateDeleted(lastTradeOrder.getId(), 0);
+                rollbackOrderDataVersion(orderId);
+                rollbackOrderUserDataVersion(orderId);
+                rollbackOrderDetailDataVersion(orderId);
+                rollbackOrderDetailBaseDataVersion(orderId);
+                rollbackOrderTotalDataVersion(orderId);
+                rollbackOrderCountryDataVersion(orderId);
+                rollbackOrderRoomModelDataVersion(orderId);
+                rollbackOrderVisitorDataVersion(orderId);
+                rollbackOrderFloorDataVersion(orderId);
 
                 ReduceStockReqDTO reqDTO = new ReduceStockReqDTO();
                 reqDTO.setOldOrderId(tradeOrderDO.getId());
@@ -574,6 +633,510 @@ public class OtcTradeOrderServiceImpl implements OtcTradeOrderService {
         return CommonResult.success("审核成功");
     }
 
+    @Transactional(rollbackFor = Exception.class)
+    public void rollbackOrderDataVersion(Long orderId){
+        //首先把旧数据删除
+        tradeOrderMapper.deleteOrderById(orderId);
+
+        // ====================== 【关键1】加锁查询：锁住当前版本行 ======================
+        // FOR UPDATE 行锁 → 并发请求会排队，绝对安全
+        HisTradeOrderDO lastVersion = hisTradeOrderMapper.selectOne(new LambdaQueryWrapper<HisTradeOrderDO>()
+                .eq(HisTradeOrderDO::getId, orderId)
+                .eq(HisTradeOrderDO::getCurrentVersion, 1)
+                .last("FOR UPDATE") // 加行锁，其他线程阻塞等待
+        );
+
+        if (lastVersion == null) {
+            log.error("无可用回退版本");
+            return;
+        }
+
+        // 【锁已生效】下面所有操作都是单线程执行，不会并发冲突
+        // ====================== 2. 主表回退（直接把回退版本插入） ======================
+        TradeOrderDO a = new TradeOrderDO();
+        BeanUtils.copyProperties(lastVersion, a);
+        a.setSyncStatus("0");
+        int updateMain = tradeOrderMapper.insert(a);
+        if (!(updateMain ==1)) {
+            throw new RuntimeException("主表回退失败");
+        }
+
+        // ====================== 3. 查询【再上一版】 ======================
+        HisTradeOrderDO preVersion = hisTradeOrderMapper.selectOne(new LambdaQueryWrapper<HisTradeOrderDO>()
+                .eq(HisTradeOrderDO::getId, orderId)
+                .lt(HisTradeOrderDO::getVersion, lastVersion.getVersion())
+                .orderByDesc(HisTradeOrderDO::getVersion)
+                .last("LIMIT 1")
+        );
+
+        // ====================== 【关键2】原子更新所有current（绝对安全） ======================
+        if (preVersion != null) {
+            // 原子SQL：只有preVersion置1，其余全部置0
+            hisTradeOrderMapper.update(new LambdaUpdateWrapper<HisTradeOrderDO>()
+                    .eq(HisTradeOrderDO::getId, orderId)
+                    .setSql("current_version = IF(his_id = " + preVersion.getHisId() + ", 1, 0)")
+            );
+        } else {
+            // 已到最早版本 → 全部置0
+            hisTradeOrderMapper.update(new LambdaUpdateWrapper<HisTradeOrderDO>()
+                    .eq(HisTradeOrderDO::getId, orderId)
+                    .set(HisTradeOrderDO::getCurrentVersion, 0)
+            );
+        }
+    }
+
+    @Transactional(rollbackFor = Exception.class)
+    public void rollbackOrderUserDataVersion(Long orderId){
+
+        tradeOrderUserMapper.deleteAllByOrderId(orderId);
+        //首先把旧数据删除
+        // ====================== 【关键1】加锁查询：锁住当前版本行 ======================
+        // FOR UPDATE 行锁 → 并发请求会排队，绝对安全
+
+        List<HisTradeOrderUserDO> lastVersionList = hisTradeOrderUserMapper.selectList(new LambdaQueryWrapper<HisTradeOrderUserDO>()
+                .eq(HisTradeOrderUserDO::getOrderId, orderId)
+                .eq(HisTradeOrderUserDO::getCurrentVersion, 1)
+                .last("FOR UPDATE") // 加行锁，其他线程阻塞等待
+        );
+
+        if (lastVersionList == null ||  lastVersionList.isEmpty()) {
+            log.error("tradeOrderUser无可用回退版本");
+            return;
+        }
+        for (HisTradeOrderUserDO lastVersion : lastVersionList) {
+            Long dataId = lastVersion.getId();
+            // 【锁已生效】下面所有操作都是单线程执行，不会并发冲突
+            // ====================== 2. 主表回退（直接把上版本插进去） ======================
+            TradeOrderUserDO a = new TradeOrderUserDO();
+            BeanUtils.copyProperties(lastVersion, a);
+            a.setSyncStatus("0");
+            int updateMain = tradeOrderUserMapper.insert(a);
+            if (!(updateMain ==1)) {
+                throw new RuntimeException("主表回退失败");
+            }
+
+            // ====================== 3. 查询【再上一版】 ======================
+            HisTradeOrderUserDO preVersion = hisTradeOrderUserMapper.selectOne(new LambdaQueryWrapper<HisTradeOrderUserDO>()
+                    .eq(HisTradeOrderUserDO::getId, dataId)
+                    .lt(HisTradeOrderUserDO::getVersion, lastVersion.getVersion())
+                    .orderByDesc(HisTradeOrderUserDO::getVersion)
+                    .last("LIMIT 1")
+            );
+
+            // ====================== 【关键2】原子更新所有current（绝对安全） ======================
+            if (preVersion != null) {
+                // 原子SQL：只有preVersion置1，其余全部置0
+                hisTradeOrderUserMapper.update(new LambdaUpdateWrapper<HisTradeOrderUserDO>()
+                        .eq(HisTradeOrderUserDO::getId, dataId)
+                        .setSql("current_version = IF(his_id = " + preVersion.getHisId() + ", 1, 0)")
+                );
+            } else {
+                // 已到最早版本 → 全部置0
+                hisTradeOrderUserMapper.update(new LambdaUpdateWrapper<HisTradeOrderUserDO>()
+                        .eq(HisTradeOrderUserDO::getId, dataId)
+                        .set(HisTradeOrderUserDO::getCurrentVersion, 0)
+                );
+            }
+        }
+
+
+    }
+
+    @Transactional(rollbackFor = Exception.class)
+    public void rollbackOrderDetailDataVersion(Long orderId){
+        //首先把旧数据删除
+        tradeDetailMapper.deleteAllByOrderId(orderId);
+
+        // ====================== 【关键1】加锁查询：锁住当前版本行 ======================
+        // FOR UPDATE 行锁 → 并发请求会排队，绝对安全
+
+        List<HisTradeDetailDO> lastVersionList = hisTradeDetailMapper.selectList(new LambdaQueryWrapper<HisTradeDetailDO>()
+                .eq(HisTradeDetailDO::getOrderId, orderId)
+                .eq(HisTradeDetailDO::getCurrentVersion, 1)
+                .last("FOR UPDATE") // 加行锁，其他线程阻塞等待
+        );
+
+        if (lastVersionList == null ||  lastVersionList.isEmpty()) {
+            log.error("tradeDetail无可用回退版本");
+            return;
+        }
+        for (HisTradeDetailDO lastVersion : lastVersionList) {
+            Long dataId = lastVersion.getId();
+            // 【锁已生效】下面所有操作都是单线程执行，不会并发冲突
+            // ====================== 2. 主表回退（直接把上版本插进去） ======================
+            TradeDetailDO a = new TradeDetailDO();
+            BeanUtils.copyProperties(lastVersion, a);
+            a.setSyncStatus("0");
+            int updateMain = tradeDetailMapper.insert(a);
+            if (!(updateMain ==1)) {
+                throw new RuntimeException("主表回退失败");
+            }
+
+            // ====================== 3. 查询【再上一版】 ======================
+            HisTradeDetailDO preVersion = hisTradeDetailMapper.selectOne(new LambdaQueryWrapper<HisTradeDetailDO>()
+                    .eq(HisTradeDetailDO::getId, dataId)
+                    .lt(HisTradeDetailDO::getVersion, lastVersion.getVersion())
+                    .orderByDesc(HisTradeDetailDO::getVersion)
+                    .last("LIMIT 1")
+            );
+
+            // ====================== 【关键2】原子更新所有current（绝对安全） ======================
+            if (preVersion != null) {
+                // 原子SQL：只有preVersion置1，其余全部置0
+                hisTradeDetailMapper.update(new LambdaUpdateWrapper<HisTradeDetailDO>()
+                        .eq(HisTradeDetailDO::getId, dataId)
+                        .setSql("current_version = IF(his_id = " + preVersion.getHisId() + ", 1, 0)")
+                );
+            } else {
+                // 已到最早版本 → 全部置0
+                hisTradeDetailMapper.update(new LambdaUpdateWrapper<HisTradeDetailDO>()
+                        .eq(HisTradeDetailDO::getId, dataId)
+                        .set(HisTradeDetailDO::getCurrentVersion, 0)
+                );
+            }
+        }
+
+
+    }
+
+    @Transactional(rollbackFor = Exception.class)
+    public void rollbackOrderDetailBaseDataVersion(Long orderId){
+        //首先把旧数据删除
+        tradeDetailBaseMapper.deleteAllByOrderId(orderId);
+
+        // ====================== 【关键1】加锁查询：锁住当前版本行 ======================
+        // FOR UPDATE 行锁 → 并发请求会排队，绝对安全
+
+        List<HisTradeDetailBaseDO> lastVersionList = hisTradeDetailBaseMapper.selectList(new LambdaQueryWrapper<HisTradeDetailBaseDO>()
+                .eq(HisTradeDetailBaseDO::getOrderId, orderId)
+                .eq(HisTradeDetailBaseDO::getCurrentVersion, 1)
+                .last("FOR UPDATE") // 加行锁，其他线程阻塞等待
+        );
+
+        if (lastVersionList == null ||  lastVersionList.isEmpty()) {
+            log.error("tradeDetailBase无可用回退版本");
+            return;
+        }
+        for (HisTradeDetailBaseDO lastVersion : lastVersionList) {
+            Long dataId = lastVersion.getId();
+            // 【锁已生效】下面所有操作都是单线程执行，不会并发冲突
+            // ====================== 2. 主表回退（直接把上版本插进去） ======================
+            TradeDetailBaseDO a = new TradeDetailBaseDO();
+            BeanUtils.copyProperties(lastVersion, a);
+//            a.setSyncStatus("0");
+            int updateMain = tradeDetailBaseMapper.insert(a);
+            if (!(updateMain ==1)) {
+                throw new RuntimeException("主表回退失败");
+            }
+
+            // ====================== 3. 查询【再上一版】 ======================
+            HisTradeDetailBaseDO preVersion = hisTradeDetailBaseMapper.selectOne(new LambdaQueryWrapper<HisTradeDetailBaseDO>()
+                    .eq(HisTradeDetailBaseDO::getId, dataId)
+                    .lt(HisTradeDetailBaseDO::getVersion, lastVersion.getVersion())
+                    .orderByDesc(HisTradeDetailBaseDO::getVersion)
+                    .last("LIMIT 1")
+            );
+
+            // ====================== 【关键2】原子更新所有current（绝对安全） ======================
+            if (preVersion != null) {
+                // 原子SQL：只有preVersion置1，其余全部置0
+                hisTradeDetailBaseMapper.update(new LambdaUpdateWrapper<HisTradeDetailBaseDO>()
+                        .eq(HisTradeDetailBaseDO::getId, dataId)
+                        .setSql("current_version = IF(his_id = " + preVersion.getHisId() + ", 1, 0)")
+                );
+            } else {
+                // 已到最早版本 → 全部置0
+                hisTradeDetailBaseMapper.update(new LambdaUpdateWrapper<HisTradeDetailBaseDO>()
+                        .eq(HisTradeDetailBaseDO::getId, dataId)
+                        .set(HisTradeDetailBaseDO::getCurrentVersion, 0)
+                );
+            }
+        }
+
+
+    }
+
+    @Transactional(rollbackFor = Exception.class)
+    public void rollbackOrderTotalDataVersion(Long orderId){
+        //首先把旧数据删除
+        tradeOrderTotalMapper.deleteAllByOrderId(orderId);
+
+        // ====================== 【关键1】加锁查询：锁住当前版本行 ======================
+        // FOR UPDATE 行锁 → 并发请求会排队，绝对安全
+
+        List<HisTradeOrderTotalDO> lastVersionList = hisTradeOrderTotalMapper.selectList(new LambdaQueryWrapper<HisTradeOrderTotalDO>()
+                .eq(HisTradeOrderTotalDO::getOldOrderId, orderId)
+                .eq(HisTradeOrderTotalDO::getCurrentVersion, 1)
+                .last("FOR UPDATE") // 加行锁，其他线程阻塞等待
+        );
+
+        if (lastVersionList == null ||  lastVersionList.isEmpty()) {
+            log.error("tradeOrderTotal无可用回退版本");
+            return;
+        }
+        for (HisTradeOrderTotalDO lastVersion : lastVersionList) {
+            Long dataId = lastVersion.getId();
+            // 【锁已生效】下面所有操作都是单线程执行，不会并发冲突
+            // ====================== 2. 主表回退（直接把上版本插进去） ======================
+            TradeOrderTotalDO a = new TradeOrderTotalDO();
+            BeanUtils.copyProperties(lastVersion, a);
+            a.setSyncStatus("0");
+            int updateMain = tradeOrderTotalMapper.insert(a);
+            if (!(updateMain ==1)) {
+                throw new RuntimeException("主表回退失败");
+            }
+            // ====================== 3. 查询【再上一版】 ======================
+            HisTradeOrderTotalDO preVersion = hisTradeOrderTotalMapper.selectOne(new LambdaQueryWrapper<HisTradeOrderTotalDO>()
+                    .eq(HisTradeOrderTotalDO::getId, dataId)
+                    .lt(HisTradeOrderTotalDO::getVersion, lastVersion.getVersion())
+                    .orderByDesc(HisTradeOrderTotalDO::getVersion)
+                    .last("LIMIT 1")
+            );
+            // ====================== 【关键2】原子更新所有current（绝对安全） ======================
+            if (preVersion != null) {
+                // 原子SQL：只有preVersion置1，其余全部置0
+                hisTradeOrderTotalMapper.update(new LambdaUpdateWrapper<HisTradeOrderTotalDO>()
+                        .eq(HisTradeOrderTotalDO::getId, dataId)
+                        .setSql("current_version = IF(his_id = " + preVersion.getHisId() + ", 1, 0)")
+                );
+            } else {
+                // 已到最早版本 → 全部置0
+                hisTradeOrderTotalMapper.update(new LambdaUpdateWrapper<HisTradeOrderTotalDO>()
+                        .eq(HisTradeOrderTotalDO::getId, dataId)
+                        .set(HisTradeOrderTotalDO::getCurrentVersion, 0)
+                );
+            }
+        }
+    }
+
+    @Transactional(rollbackFor = Exception.class)
+    public void rollbackOrderCountryDataVersion(Long orderId){
+        //首先把旧数据删除
+        tradeOrderCountryMapper.deleteAllByOrderId(orderId);
+
+        // ====================== 【关键1】加锁查询：锁住当前版本行 ======================
+        // FOR UPDATE 行锁 → 并发请求会排队，绝对安全
+
+        List<HisTradeOrderCountryDO> lastVersionList = hisTradeOrderCountryMapper.selectList(new LambdaQueryWrapper<HisTradeOrderCountryDO>()
+                .eq(HisTradeOrderCountryDO::getOrderId, orderId)
+                .eq(HisTradeOrderCountryDO::getCurrentVersion, 1)
+                .last("FOR UPDATE") // 加行锁，其他线程阻塞等待
+        );
+
+        if (lastVersionList == null ||  lastVersionList.isEmpty()) {
+            log.error("tradeOrderCountry无可用回退版本");
+            return;
+        }
+        for (HisTradeOrderCountryDO lastVersion : lastVersionList) {
+            Long dataId = lastVersion.getId();
+            // 【锁已生效】下面所有操作都是单线程执行，不会并发冲突
+            // ====================== 2. 主表回退（直接把上版本插进去） ======================
+            TradeOrderCountryDO a = new TradeOrderCountryDO();
+            BeanUtils.copyProperties(lastVersion, a);
+            a.setSyncStatus("0");
+            int updateMain = tradeOrderCountryMapper.insert(a);
+            if (!(updateMain ==1)) {
+                throw new RuntimeException("主表回退失败");
+            }
+
+            // ====================== 3. 查询【再上一版】 ======================
+            HisTradeOrderCountryDO preVersion = hisTradeOrderCountryMapper.selectOne(new LambdaQueryWrapper<HisTradeOrderCountryDO>()
+                    .eq(HisTradeOrderCountryDO::getId, dataId)
+                    .lt(HisTradeOrderCountryDO::getVersion, lastVersion.getVersion())
+                    .orderByDesc(HisTradeOrderCountryDO::getVersion)
+                    .last("LIMIT 1")
+            );
+
+            // ====================== 【关键2】原子更新所有current（绝对安全） ======================
+            if (preVersion != null) {
+                // 原子SQL：只有preVersion置1，其余全部置0
+                hisTradeOrderCountryMapper.update(new LambdaUpdateWrapper<HisTradeOrderCountryDO>()
+                        .eq(HisTradeOrderCountryDO::getId, dataId)
+                        .setSql("current_version = IF(his_id = " + preVersion.getHisId() + ", 1, 0)")
+                );
+            } else {
+                // 已到最早版本 → 全部置0
+                hisTradeOrderCountryMapper.update(new LambdaUpdateWrapper<HisTradeOrderCountryDO>()
+                        .eq(HisTradeOrderCountryDO::getId, dataId)
+                        .set(HisTradeOrderCountryDO::getCurrentVersion, 0)
+                );
+            }
+        }
+
+
+    }
+
+    @Transactional(rollbackFor = Exception.class)
+    public void rollbackOrderRoomModelDataVersion(Long orderId){
+        //首先把旧数据删除
+        tradeOrderRoomModelMapper.deleteAllByOrderId(orderId);
+
+        // ====================== 【关键1】加锁查询：锁住当前版本行 ======================
+        // FOR UPDATE 行锁 → 并发请求会排队，绝对安全
+
+        List<HisTradeOrderRoomModelDO> lastVersionList = hisTradeOrderRoomModelMapper.selectList(new LambdaQueryWrapper<HisTradeOrderRoomModelDO>()
+                .eq(HisTradeOrderRoomModelDO::getOrderId, orderId)
+                .eq(HisTradeOrderRoomModelDO::getCurrentVersion, 1)
+                .last("FOR UPDATE") // 加行锁，其他线程阻塞等待
+        );
+
+        if (lastVersionList == null ||  lastVersionList.isEmpty()) {
+            log.error("tradeOrderRoomModel无可用回退版本");
+            return;
+        }
+        for (HisTradeOrderRoomModelDO lastVersion : lastVersionList) {
+            Long dataId = lastVersion.getId();
+            // 【锁已生效】下面所有操作都是单线程执行，不会并发冲突
+            // ====================== 2. 主表回退（直接把上版本插进去） ======================
+            TradeOrderRoomModelDO a = new TradeOrderRoomModelDO();
+            BeanUtils.copyProperties(lastVersion, a);
+            a.setSyncStatus("0");
+            int updateMain = tradeOrderRoomModelMapper.insert(a);
+            if (!(updateMain ==1)) {
+                throw new RuntimeException("主表回退失败");
+            }
+
+            // ====================== 3. 查询【再上一版】 ======================
+            HisTradeOrderRoomModelDO preVersion = hisTradeOrderRoomModelMapper.selectOne(new LambdaQueryWrapper<HisTradeOrderRoomModelDO>()
+                    .eq(HisTradeOrderRoomModelDO::getId, dataId)
+                    .lt(HisTradeOrderRoomModelDO::getVersion, lastVersion.getVersion())
+                    .orderByDesc(HisTradeOrderRoomModelDO::getVersion)
+                    .last("LIMIT 1")
+            );
+
+            // ====================== 【关键2】原子更新所有current（绝对安全） ======================
+            if (preVersion != null) {
+                // 原子SQL：只有preVersion置1，其余全部置0
+                hisTradeOrderRoomModelMapper.update(new LambdaUpdateWrapper<HisTradeOrderRoomModelDO>()
+                        .eq(HisTradeOrderRoomModelDO::getId, dataId)
+                        .setSql("current_version = IF(his_id = " + preVersion.getHisId() + ", 1, 0)")
+                );
+            } else {
+                // 已到最早版本 → 全部置0
+                hisTradeOrderRoomModelMapper.update(new LambdaUpdateWrapper<HisTradeOrderRoomModelDO>()
+                        .eq(HisTradeOrderRoomModelDO::getId, dataId)
+                        .set(HisTradeOrderRoomModelDO::getCurrentVersion, 0)
+                );
+            }
+        }
+
+
+    }
+
+    @Transactional(rollbackFor = Exception.class)
+    public void rollbackOrderVisitorDataVersion(Long orderId){
+        //首先把旧数据删除
+        tradeVisitorMapper.deleteAllByOrderId(orderId);
+
+        // ====================== 【关键1】加锁查询：锁住当前版本行 ======================
+        // FOR UPDATE 行锁 → 并发请求会排队，绝对安全
+
+        List<HisTradeVisitorDO> lastVersionList = hisTradeVisitorMapper.selectList(new LambdaQueryWrapper<HisTradeVisitorDO>()
+                .eq(HisTradeVisitorDO::getOrderId, orderId)
+                .eq(HisTradeVisitorDO::getCurrentVersion, 1)
+                .last("FOR UPDATE") // 加行锁，其他线程阻塞等待
+        );
+
+        if (lastVersionList == null ||  lastVersionList.isEmpty()) {
+            log.error("tradeVisitor无可用回退版本");
+            return;
+        }
+        for (HisTradeVisitorDO lastVersion : lastVersionList) {
+            Long dataId = lastVersion.getId();
+            // 【锁已生效】下面所有操作都是单线程执行，不会并发冲突
+            // ====================== 2. 主表回退（直接把上版本插进去） ======================
+            TradeVisitorDO a = new TradeVisitorDO();
+            BeanUtils.copyProperties(lastVersion, a);
+            a.setSyncStatus("0");
+            int updateMain = tradeVisitorMapper.insert(a);
+            if (!(updateMain ==1)) {
+                throw new RuntimeException("主表回退失败");
+            }
+
+            // ====================== 3. 查询【再上一版】 ======================
+            HisTradeVisitorDO preVersion = hisTradeVisitorMapper.selectOne(new LambdaQueryWrapper<HisTradeVisitorDO>()
+                    .eq(HisTradeVisitorDO::getId, dataId)
+                    .lt(HisTradeVisitorDO::getVersion, lastVersion.getVersion())
+                    .orderByDesc(HisTradeVisitorDO::getVersion)
+                    .last("LIMIT 1")
+            );
+
+            // ====================== 【关键2】原子更新所有current（绝对安全） ======================
+            if (preVersion != null) {
+                // 原子SQL：只有preVersion置1，其余全部置0
+                hisTradeVisitorMapper.update(new LambdaUpdateWrapper<HisTradeVisitorDO>()
+                        .eq(HisTradeVisitorDO::getId, dataId)
+                        .setSql("current_version = IF(his_id = " + preVersion.getHisId() + ", 1, 0)")
+                );
+            } else {
+                // 已到最早版本 → 全部置0
+                hisTradeVisitorMapper.update(new LambdaUpdateWrapper<HisTradeVisitorDO>()
+                        .eq(HisTradeVisitorDO::getId, dataId)
+                        .set(HisTradeVisitorDO::getCurrentVersion, 0)
+                );
+            }
+        }
+
+
+    }
+
+    @Transactional(rollbackFor = Exception.class)
+    public void rollbackOrderFloorDataVersion(Long orderId){
+        //首先把旧数据删除
+        tradeOrderFloorMapper.deleteAllByOrderId(orderId);
+
+        // ====================== 【关键1】加锁查询：锁住当前版本行 ======================
+        // FOR UPDATE 行锁 → 并发请求会排队，绝对安全
+
+        List<HisTradeOrderFloorDO> lastVersionList = hisTradeOrderFloorMapper.selectList(new LambdaQueryWrapper<HisTradeOrderFloorDO>()
+                .eq(HisTradeOrderFloorDO::getOrderId, orderId)
+                .eq(HisTradeOrderFloorDO::getCurrentVersion, 1)
+                .last("FOR UPDATE") // 加行锁，其他线程阻塞等待
+        );
+
+        if (lastVersionList == null ||  lastVersionList.isEmpty()) {
+            log.error("tradeOrderFloor无可用回退版本");
+            return;
+        }
+        for (HisTradeOrderFloorDO lastVersion : lastVersionList) {
+            Long dataId = lastVersion.getId();
+            // 【锁已生效】下面所有操作都是单线程执行，不会并发冲突
+            // ====================== 2. 主表回退（直接把上版本插进去） ======================
+            TradeOrderFloorDO a = new TradeOrderFloorDO();
+            BeanUtils.copyProperties(lastVersion, a);
+            a.setSyncStatus("0");
+            int updateMain = tradeOrderFloorMapper.insert(a);
+            if (!(updateMain ==1)) {
+                throw new RuntimeException("主表回退失败");
+            }
+
+            // ====================== 3. 查询【再上一版】 ======================
+            HisTradeOrderFloorDO preVersion = hisTradeOrderFloorMapper.selectOne(new LambdaQueryWrapper<HisTradeOrderFloorDO>()
+                    .eq(HisTradeOrderFloorDO::getId, dataId)
+                    .lt(HisTradeOrderFloorDO::getVersion, lastVersion.getVersion())
+                    .orderByDesc(HisTradeOrderFloorDO::getVersion)
+                    .last("LIMIT 1")
+            );
+
+            // ====================== 【关键2】原子更新所有current（绝对安全） ======================
+            if (preVersion != null) {
+                // 原子SQL：只有preVersion置1，其余全部置0
+                hisTradeOrderFloorMapper.update(new LambdaUpdateWrapper<HisTradeOrderFloorDO>()
+                        .eq(HisTradeOrderFloorDO::getId, dataId)
+                        .setSql("current_version = IF(his_id = " + preVersion.getHisId() + ", 1, 0)")
+                );
+            } else {
+                // 已到最早版本 → 全部置0
+                hisTradeOrderFloorMapper.update(new LambdaUpdateWrapper<HisTradeOrderFloorDO>()
+                        .eq(HisTradeOrderFloorDO::getId, dataId)
+                        .set(HisTradeOrderFloorDO::getCurrentVersion, 0)
+                );
+            }
+        }
+
+
+    }
+
     @Override
     @TradeOrderLog(operateType = TradeOrderOperateTypeEnum.CANCEL_AUDIT)
     @TenantIgnore
@@ -770,27 +1333,44 @@ public class OtcTradeOrderServiceImpl implements OtcTradeOrderService {
             return CommonResult.error(ORDER_NOT_EXIST);
         }
         //撤回还原到修改前订单
-        List<TradeOrderDO> tradeOrderDoList = tradeOrderMapper.queryOrderByLast(tradeOrderDO.getOrderNo());
-        if (tradeOrderDoList != null && !tradeOrderDoList.isEmpty()) {
-            TradeOrderDO lastTradeOrder = tradeOrderDoList.get(0);
-            tradeOrderMapper.updateOrderDeleted(orderId, 1);
-            tradeOrderMapper.updateOrderDeleted(lastTradeOrder.getId(), 0);
-            tradeOrderUserMapper.updateDeleted(orderId, 1);
-            tradeOrderUserMapper.updateDeleted(lastTradeOrder.getId(), 0);
-            tradeDetailMapper.updateDeleted(orderId, 1);
-            tradeDetailMapper.updateDeleted(lastTradeOrder.getId(), 0);
-            tradeDetailBaseMapper.updateDeleted(orderId, 1);
-            tradeDetailBaseMapper.updateDeleted(lastTradeOrder.getId(), 0);
-            tradeVisitorMapper.updateDeleted(orderId, 1);
-            tradeVisitorMapper.updateDeleted(lastTradeOrder.getId(), 0);
-            tradeOrderCountryMapper.updateDeleted(orderId, 1);
-            tradeOrderCountryMapper.updateDeleted(lastTradeOrder.getId(), 0);
-            tradeOrderRoomModelMapper.updateDeleted(orderId, 1);
-            tradeOrderRoomModelMapper.updateDeleted(lastTradeOrder.getId(), 0);
-            tradeOrderFloorMapper.updateDeleted(orderId, 1);
-            tradeOrderFloorMapper.updateDeleted(lastTradeOrder.getId(), 0);
-            tradeOrderTotalMapper.updateDeleted(orderId, 1);
-            tradeOrderTotalMapper.updateDeleted(lastTradeOrder.getId(), 0);
+
+//            List<TradeOrderDO> tradeOrderDoList = tradeOrderMapper.queryOrderByLast(tradeOrderDO.getOrderNo());
+        HisTradeOrderDO lastTradeOrder = hisTradeOrderMapper.selectOne(new LambdaQueryWrapper<HisTradeOrderDO>()
+                .eq(HisTradeOrderDO::getId, orderId)
+                .eq(HisTradeOrderDO::getCurrentVersion, 1)
+        );
+
+
+//            if (tradeOrderDoList != null && !tradeOrderDoList.isEmpty()) {
+        if (lastTradeOrder != null) {
+//                TradeOrderDO lastTradeOrder = tradeOrderDoList.get(0);
+//                tradeOrderMapper.updateOrderDeleted(orderId, 1);
+//                tradeOrderMapper.updateOrderDeleted(lastTradeOrder.getId(), 0);
+//                tradeOrderUserMapper.updateDeleted(orderId, 1);
+//                tradeOrderUserMapper.updateDeleted(lastTradeOrder.getId(), 0);
+//                tradeDetailMapper.updateDeleted(orderId, 1);
+//                tradeDetailMapper.updateDeleted(lastTradeOrder.getId(), 0);
+//                tradeDetailBaseMapper.updateDeleted(orderId, 1);
+//                tradeDetailBaseMapper.updateDeleted(lastTradeOrder.getId(), 0);
+//                tradeVisitorMapper.updateDeleted(orderId, 1);
+//                tradeVisitorMapper.updateDeleted(lastTradeOrder.getId(), 0);
+//                tradeOrderCountryMapper.updateDeleted(orderId, 1);
+//                tradeOrderCountryMapper.updateDeleted(lastTradeOrder.getId(), 0);
+//                tradeOrderRoomModelMapper.updateDeleted(orderId, 1);
+//                tradeOrderRoomModelMapper.updateDeleted(lastTradeOrder.getId(), 0);
+//                tradeOrderFloorMapper.updateDeleted(orderId, 1);
+//                tradeOrderFloorMapper.updateDeleted(lastTradeOrder.getId(), 0);
+//                tradeOrderTotalMapper.updateDeleted(orderId, 1);
+//                tradeOrderTotalMapper.updateDeleted(lastTradeOrder.getId(), 0);
+            rollbackOrderDataVersion(orderId);
+            rollbackOrderUserDataVersion(orderId);
+            rollbackOrderDetailDataVersion(orderId);
+            rollbackOrderDetailBaseDataVersion(orderId);
+            rollbackOrderTotalDataVersion(orderId);
+            rollbackOrderCountryDataVersion(orderId);
+            rollbackOrderRoomModelDataVersion(orderId);
+            rollbackOrderVisitorDataVersion(orderId);
+            rollbackOrderFloorDataVersion(orderId);
 
             ReduceStockReqDTO reqDTO = new ReduceStockReqDTO();
             reqDTO.setOldOrderId(tradeOrderDO.getId());

ship-module-trade/ship-module-trade-biz/src/main/resources/mapper/order/TradeDetailBaseMapper.xml

@@ -166,4 +166,7 @@
         UPDATE trade_detail_base SET deleted = #{deleted},update_time = now() WHERE order_id = #{orderId}
     </update>
 
-</mapper>
+    <delete id="deleteAllByOrderId">
+        delete from trade_detail_base where order_id = #{orderId}
+    </delete>
+</mapper>

ship-module-trade/ship-module-trade-biz/src/main/resources/mapper/order/TradeDetailMapper.xml

@@ -58,8 +58,8 @@
             <result property="platSupplierOrderId" column="plat_supplier_order_id"/>
         </collection>
     </resultMap>
-    
-    
+
+
     <select id="selectTradeDetailWithBase" resultMap="tradeDetailMap">
         select td.*,tdb.id detail_base_id,tdb.detail_id,tdb.product_base_id,tdb.product_base_name,tdb.product_base_type,tdb.product_resource_id,tdb.product_resource_name,tdb.supplier_product_id,tdb.supplier_id,
         tdb.supplier_name,tdb.is_system_direct,tdb.use_status,tdb.check_status base_check_status,tdb.verify_time base_verify_time,tdb.price base_price,tdb.usage_count,tdb.product_resource_price,tdb.project_id,tdb.project_name,
@@ -1440,4 +1440,8 @@
     <update id="updateDeleted">
         UPDATE trade_detail SET deleted = #{deleted},update_time = now(), sync_status = '0' WHERE order_id = #{orderId}
     </update>
+
+    <delete id="deleteAllByOrderId">
+        delete from trade_detail where order_id = #{orderId}
+    </delete>
 </mapper>

ship-module-trade/ship-module-trade-biz/src/main/resources/mapper/order/TradeOrderRoomModelMapper.xml

@@ -254,5 +254,7 @@
         ORDER BY a1.room_model_id asc,a1.floor asc
     </select>
 
-
-</mapper>
+    <delete id="deleteAllByOrderId">
+        delete from trade_order_room_model where order_id = #{orderId}
+    </delete>
+</mapper>

ship-module-trade/ship-module-trade-biz/src/main/resources/mapper/order/TradeVisitorMapper.xml

@@ -527,4 +527,8 @@
 
         order by t1.create_time asc
     </select>
+
+    <delete id="deleteAllByOrderId">
+        delete from trade_visitor where order_id = #{orderId}
+    </delete>
 </mapper>