金牛：1.自动导单到代服系统自动创建好订单

   2.数据分拣功能按钮
   3.创建代服ERP运单功能按钮
   4.自动发货定时任务功能
   5.自动获取物流状态定时任务功能
   6.导入发货，列表数据导出按钮
   7.取消订单，退还积分功能
   8.导入订单状态修改按钮

fs-admin/src/main/java/com/fs/his/controller/FsIntegralOrderController.java

@@ -1,6 +1,8 @@
 package com.fs.his.controller;
 
+import cn.hutool.core.bean.BeanUtil;
 import cn.hutool.core.util.StrUtil;
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import com.fs.common.annotation.Log;
 import com.fs.common.core.controller.BaseController;
 import com.fs.common.core.domain.AjaxResult;
@@ -10,21 +12,29 @@ import com.fs.common.enums.BusinessType;
 import com.fs.common.utils.CloudHostUtils;
 import com.fs.common.utils.StringUtils;
 import com.fs.common.utils.poi.ExcelUtil;
+import com.fs.his.domain.FsDfAccount;
 import com.fs.his.domain.FsIntegralOrder;
+import com.fs.his.domain.FsIntegralOrderDf;
 import com.fs.his.domain.FsStoreOrder;
 import com.fs.his.dto.ExpressInfoDTO;
 import com.fs.his.enums.ShipperCodeEnum;
+import com.fs.his.mapper.FsIntegralOrderMapper;
+import com.fs.his.param.BatchCreateErpOrderParam;
+import com.fs.his.param.BatchSetErpOrderParam;
+import com.fs.his.vo.*;
 import com.fs.his.param.FsIntegralOrderParam;
-import com.fs.his.service.IFsExpressService;
-import com.fs.his.service.IFsIntegralOrderService;
-import com.fs.his.service.IFsStoreOrderService;
+import com.fs.his.service.*;
 import com.fs.utils.OrderContextHolder;
-import com.fs.his.vo.*;
+import io.swagger.annotations.ApiOperation;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.transaction.annotation.Transactional;
 import org.springframework.web.bind.annotation.*;
 import org.springframework.web.multipart.MultipartFile;
 
+import java.text.ParseException;
+import java.time.LocalDateTime;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 
@@ -48,6 +58,16 @@ public class FsIntegralOrderController extends BaseController
 
     @Autowired
     private IFsStoreOrderService fsStoreOrderService;
+
+
+    @Autowired
+    private IFsIntegralOrderDfService integralOrderDfService;
+
+    @Autowired
+    private IFsDfAccountService fsDfAccountService;
+    @Autowired
+    private FsIntegralOrderMapper integralOrderMapper;
+
     /**
      * 查询积分商品订单列表
      */
@@ -56,6 +76,18 @@ public class FsIntegralOrderController extends BaseController
     public TableDataInfo list(FsIntegralOrderParam fsIntegralOrder)
     {
         startPage();
+        if (CloudHostUtils.hasCloudHostName("金牛明医")){
+            /*目前只有金牛有状态为6的查询，其他项目避免使用6状态码*/
+            if (fsIntegralOrder.getStatus() != null && fsIntegralOrder.getStatus().equals("6")) {
+                fsIntegralOrder.setStatus("1");
+                fsIntegralOrder.setIsPush(0);
+            }
+            List<FsIntegralOrderListVO> list = fsIntegralOrderService.selectFsIntegralOrderListByJn(fsIntegralOrder);
+            for (FsIntegralOrderListVO vo : list) {
+                vo.setUserPhone(decryptAutoPhoneMk(vo.getUserPhone()));
+            }
+            return getDataTable(list);
+        }
         List<FsIntegralOrderListVO> list = fsIntegralOrderService.selectFsIntegralOrderListVO(fsIntegralOrder);
         for (FsIntegralOrderListVO vo : list) {
             vo.setUserPhone(decryptAutoPhoneMk(vo.getUserPhone()));
@@ -71,6 +103,16 @@ public class FsIntegralOrderController extends BaseController
     @GetMapping("/export")
     public AjaxResult export(FsIntegralOrder fsIntegralOrder)
     {
+        if (CloudHostUtils.hasCloudHostName("金牛明医")&&fsIntegralOrder.getStatus() != null && fsIntegralOrder.getStatus().equals(6)) {
+            /*目前只有金牛有状态为6的查询，其他项目避免使用6状态码*/
+            FsIntegralOrderParam param = new FsIntegralOrderParam();
+            BeanUtil.copyProperties(fsIntegralOrder, param);
+            param.setStatus("1");
+            param.setIsPush(0);
+            List<FsIntegralOrderListVO> fsIntegralOrderListVOS = fsIntegralOrderService.selectFsIntegralOrderListByJn(param);
+            ExcelUtil<FsIntegralOrderListVO> util = new ExcelUtil<>(FsIntegralOrderListVO.class);
+            return util.exportExcel(new ArrayList<>(fsIntegralOrderListVOS), "积分商品订单数据");
+        }
         return fsIntegralOrderService.export(fsIntegralOrder);
     }
     /**
@@ -218,4 +260,134 @@ public class FsIntegralOrderController extends BaseController
     public AjaxResult finishOrder(@PathVariable("orderCode") String orderCode) {
         return toAjax(fsIntegralOrderService.finishOrder(orderCode));
     }
+
+    @ApiOperation("批量设置订单账户")
+    @Log(title = "积分商品订单", businessType = BusinessType.UPDATE)
+//    @PreAuthorize("@ss.hasPermi('his:storeOrder:createErpOrder')")
+    @PostMapping(value = "/batchSetErpOrder")
+    @Transactional(rollbackFor = Exception.class)
+    public R batchSetErpOrder(@RequestBody BatchSetErpOrderParam param)
+    {
+        String nickName = getLoginUser().getUser().getNickName();
+        String loginAccount = param.getLoginAccount();
+        if (StringUtils.isBlank(loginAccount)){
+            return R.error("未选择erp账户");
+        }
+        FsIntegralOrderDf df = getDFInfo(loginAccount);
+        if (df.getLoginAccount() == null){
+            return R.error("未查询到所选erp账户");
+        }
+        List<Long> orderIds = param.getOrderIds();
+        List<FsIntegralOrder> list = null;
+        if (!orderIds.isEmpty()) {
+            list = fsIntegralOrderService.selectFsIntegralOrderByOrderIds(orderIds);
+//            orderIds = list.stream().map(FsIntegralOrder::getOrderId).collect(Collectors.toList());
+        }else{
+            return R.ok();
+        }
+        if (list.isEmpty())
+            return R.ok();
+        List<String> erpPhones = param.getErpPhones();
+        int[] index = {0}; // 使用数组模拟可变引用
+        list.forEach(item->{
+            df.setOrderId(item.getOrderId());
+            df.setOrderCode(item.getOrderCode());
+            if (!erpPhones.isEmpty()) {
+                int currentIndex = index[0] % erpPhones.size(); // 循环使用
+                df.setErpPhone(erpPhones.get(currentIndex));
+                index[0]++; // 顺序递增
+            }
+            FsIntegralOrder order = new FsIntegralOrder();
+            //更新一下积分订单的loginaccount这个字段
+            order.setOrderId(item.getOrderId());
+            order.setLoginAccount(df.getLoginAccount());
+            fsIntegralOrderService.updateFsIntegralOrder(order);
+            FsIntegralOrderDf temp = integralOrderDfService.getOne(Wrappers.<FsIntegralOrderDf>lambdaQuery().eq(FsIntegralOrderDf::getOrderId,item.getOrderId()));
+            df.setParcelQuantity(param.getParcelQuantity());
+//            df.setErpPhone(param.getErpPhone().trim());
+            if (temp != null){
+                df.setUpdateTime(LocalDateTime.now());
+                integralOrderDfService.updateById(df);
+            } else {
+                integralOrderDfService.insertFsIntegralOrderDf(df);
+            }
+            //积分订单操作日志暂定
+        });
+        return R.ok();
+    }
+
+//    @Log(title = "手动推管易", businessType = BusinessType.INSERT)
+    @ApiOperation("批量创建ERP订单")
+//    @PreAuthorize("@ss.hasPermi('his:storeOrder:createErpOrder')")
+    @Log(title = "积分商品订单", businessType = BusinessType.UPDATE)
+    @PostMapping(value = "/batchCreateErpOrder")
+    public R batchCreateErpOrder(@RequestBody BatchCreateErpOrderParam param) throws ParseException {
+//        String nickName = getLoginUser().getUser().getNickName();
+        String loginAccount = param.getLoginAccount();
+        if (StringUtils.isBlank(loginAccount)){
+            return R.error("未选择推送erp账户");
+        }
+        FsIntegralOrderDf df = getDFInfo(loginAccount);
+        if (df.getLoginAccount() == null){
+            return R.error("未查询到所选erp账户");
+        }
+        List<Long> orderIds = param.getOrderIds();
+        List<String> erpPhones = param.getErpPhones();
+        int[] index = {0}; // 使用数组模拟可变引用
+        if (!orderIds.isEmpty()) {
+            List<FsIntegralOrder> orders = integralOrderMapper.selectList(Wrappers.<FsIntegralOrder>lambdaQuery().in(FsIntegralOrder::getOrderId, orderIds));
+            for (FsIntegralOrder order : orders) {
+                df.setOrderId(order.getOrderId());
+                df.setOrderCode(order.getOrderCode());
+                FsIntegralOrderDf temp = integralOrderDfService.getBaseMapper().selectById(order.getOrderId());
+                //如果是没有代服表数据，就用传过来的df账号，如果有就不更新df数据直接拿之前的数据创建erp
+                if (temp == null){
+                    if (!erpPhones.isEmpty()) {
+                        int currentIndex = index[0] % erpPhones.size(); // 循环使用
+                        df.setErpPhone(erpPhones.get(currentIndex));
+                        index[0]++; // 顺序递增
+                    }
+                    df.setParcelQuantity(param.getParcelQuantity()); //设置包裹数量
+                    integralOrderDfService.getBaseMapper().insert(df);
+                    order.setLoginAccount(df.getLoginAccount());
+                    integralOrderMapper.updateById(order);
+                    //日志表，待定
+                }
+                fsIntegralOrderService.createErpOrder(order.getOrderId());
+            }
+        }
+        return R.ok("推送成功");
+    }
+
+    @Log(title = "导入修改订单", businessType = BusinessType.IMPORT)
+    @PostMapping("/importOrderStatusData")
+    public AjaxResult importOrderStatusData(MultipartFile file) throws Exception
+    {
+        ExcelUtil<FsIntegralOrderExcelVO> util = new ExcelUtil<>(FsIntegralOrderExcelVO.class);
+        List<FsIntegralOrderExcelVO> list = util.importExcel(file.getInputStream());
+        String message = fsIntegralOrderService.importOrderStatusData(list);
+        return AjaxResult.success(message);
+    }
+
+    @GetMapping("/importUpdateOrderTemplate")
+    public AjaxResult importUpdateOrderTemplate()
+    {
+        ExcelUtil<FsIntegralOrderExcelVO> util = new ExcelUtil<>(FsIntegralOrderExcelVO.class);
+        return util.importTemplateExcel("修改订单");
+    }
+    private FsIntegralOrderDf getDFInfo(String loginAccount) {
+        //查询订单账户 判断是否存在该订单账户
+        FsDfAccount erpAccount = fsDfAccountService.selectFsDfAccountByAccount(loginAccount);
+        FsIntegralOrderDf df = new FsIntegralOrderDf();
+        if (erpAccount != null){
+            //添加df记录
+            df.setAppKey(erpAccount.getDfAppKey());
+            df.setAppSecret(erpAccount.getDfAppsecret());
+            df.setLoginAccount(loginAccount);
+            df.setMonthlyCard(erpAccount.getMonthlyCard());
+            df.setExpressProductCode(erpAccount.getExpressProductCode());
+            df.setStatus(0);
+        }
+        return df;
+    }
 }

fs-admin/src/main/java/com/fs/his/param/BatchCreateErpOrderParam.java

@@ -0,0 +1,12 @@
+package com.fs.his.param;
+
+import lombok.Data;
+
+import java.util.List;
+@Data
+public class BatchCreateErpOrderParam {
+    private List<Long> orderIds;
+    private String loginAccount;
+    private Integer parcelQuantity; //包裹数量
+    private List<String> erpPhones;
+}

fs-admin/src/main/java/com/fs/his/param/BatchSetErpOrderParam.java

@@ -0,0 +1,13 @@
+package com.fs.his.param;
+
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class BatchSetErpOrderParam {
+    private List<Long> orderIds;
+    private String loginAccount;
+    private Integer parcelQuantity; //包裹数量
+    private List<String> erpPhones;
+}

fs-admin/src/main/java/com/fs/his/task/Task.java

@@ -6,6 +6,7 @@ import com.alibaba.fastjson.JSON;
 import com.baomidou.mybatisplus.core.conditions.Wrapper;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import com.fs.common.core.redis.RedisCache;
 import com.fs.common.service.impl.SmsServiceImpl;
 import com.fs.common.utils.DateUtils;
@@ -68,6 +69,7 @@ import com.fs.sop.service.IQwSopTempVoiceService;
 import com.fs.system.domain.SysConfig;
 import com.fs.system.mapper.SysConfigMapper;
 import com.fs.system.service.ISysConfigService;
+import com.fs.utils.OrderContextHolder;
 import com.google.gson.Gson;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
@@ -212,6 +214,8 @@ public class Task {
 
     @Autowired
     private ThreadPoolTaskExecutor threadPoolTaskExecutor;
+    @Autowired
+    private FsIntegralOrderMapper fsIntegralOrderMapper;
 
     /**
      * sop任务token消耗统计
@@ -684,6 +688,65 @@ public class Task {
         }
     }
 
+    @Autowired
+    private FsIntegralOrderDfMapper integralOrderDfMapper;
+
+
+    /**
+     * 创建了erp的订单，但是等待回调修改物流状态的定时任务
+     * */
+    public void deliveryIntegralOp() {
+        IErpOrderService erpOrderService = getErpService();
+        //查询没有物流字段但是创建过的，如果有则把待发货状态改成待收货
+        List<FsIntegralOrderDf> integralDf = integralOrderDfMapper.selectByIsPush();
+        if (integralDf.isEmpty()) {
+            log.info("⏹️ 没有需要推送的订单明细，流程结束");
+            return;
+        }
+        log.info("📊 查询到 {} 条未查询的订单明细", integralDf.size());
+        //只判断类型，给个对象
+        OrderContextHolder.setIntegralOrder(new FsIntegralOrder());
+        for (FsIntegralOrderDf df : integralDf) {
+            log.info("🔄 开始处理订单明细，订单号: {}, orderId: {}", df.getOrderCode(), df.getOrderId());
+            ErpOrderQueryRequert request = new ErpOrderQueryRequert();
+            request.setCode(df.getOrderCode());
+            erpOrderService.getOrder(request);
+        }
+        OrderContextHolder.clear();
+    }
+    /**
+     * 对待收货的订单，定时去更新物流状态
+     * */
+    public void getIntegralOrderDeliveryStatus() {
+        /*erp物流流程：
+        1.请求顺丰接口添加物流订单
+        2.修改df推送标识为1
+        3.查询订单结果更新order，或者回滚df表*/
+        //目的是查询创建成功erp的订单，应该在第三部之后改动的数据来作为查询条件；即为待收货订单and拥有deliverySn的数据；
+        List<FsIntegralOrder> orders = fsIntegralOrderMapper.selectList(Wrappers.<FsIntegralOrder>lambdaQuery().eq(FsIntegralOrder::getStatus, 2).isNotNull(FsIntegralOrder::getDeliverySn));
+        IErpOrderService erpOrderService = getErpService();
+        List<CompletableFuture<Void>> futures = new ArrayList<>();
+        for (FsIntegralOrder order : orders) {
+            // 创建局部final变量副本
+            final FsIntegralOrder currentOrder = order;
+            FsStoreOrder order1 = new FsStoreOrder();
+            order1.setDeliverySn(currentOrder.getDeliverySn());
+            order1.setOrderCode(currentOrder.getOrderCode());
+
+            // 异步执行，使用局部变量副本
+            CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
+                OrderContextHolder.setIntegralOrder(currentOrder);
+                try {
+                    erpOrderService.getOrderDeliveryStatus(order1);
+                } finally {
+                    OrderContextHolder.clear();
+                }
+            });
+            futures.add(future);
+        }
+        CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join();
+    }
+
     public void deliveryOpScrm()
     {
         IErpOrderService erpOrderService = getErpService();

fs-service/src/main/java/com/fs/erp/domain/ErpOrder.java

@@ -34,4 +34,5 @@ public class ErpOrder {
     List<ErpOrderPayment> payments;
 
     String buyer_account;
+    Boolean isIntegralOrder;
 }

fs-service/src/main/java/com/fs/erp/service/impl/DfOrderServiceImpl.java

@@ -1,5 +1,6 @@
 package com.fs.erp.service.impl;
 
+import cn.hutool.core.convert.Convert;
 import cn.hutool.core.util.ObjectUtil;
 import cn.hutool.core.util.StrUtil;
 import cn.hutool.http.HttpUtil;
@@ -7,6 +8,7 @@ import cn.hutool.json.JSONObject;
 import cn.hutool.json.JSONUtil;
 import com.alibaba.fastjson.JSON;
 import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import com.fs.common.core.redis.RedisCache;
 import com.fs.common.event.TemplateBean;
 import com.fs.common.event.TemplateEvent;
@@ -15,6 +17,7 @@ import com.fs.common.utils.DateUtils;
 import com.fs.company.service.ICompanyService;
 import com.fs.erp.domain.ErpDeliverys;
 import com.fs.erp.domain.ErpOrder;
+import com.fs.erp.domain.ErpOrderItem;
 import com.fs.erp.domain.ErpRefundOrder;
 import com.fs.erp.dto.*;
 import com.fs.erp.dto.df.*;
@@ -30,6 +33,7 @@ import com.fs.his.enums.FsStoreOrderStatusEnum;
 import com.fs.his.mapper.*;
 import com.fs.his.param.FsStoreOrderSalesParam;
 import com.fs.his.service.IFsExpressService;
+import com.fs.his.service.IFsIntegralOrderService;
 import com.fs.his.service.IFsStoreOrderLogsService;
 import com.fs.his.service.IFsStoreOrderService;
 import com.fs.his.utils.ConfigUtil;
@@ -69,6 +73,7 @@ import org.springframework.stereotype.Service;
 
 import java.io.IOException;
 import java.math.BigDecimal;
+import java.time.LocalDateTime;
 import java.util.*;
 import java.util.concurrent.atomic.AtomicBoolean;
 
@@ -147,10 +152,14 @@ public class DfOrderServiceImpl implements IErpOrderService {
     private IFastGptRoleService fastGptRoleService;
     @Autowired
     private WxWorkService wxWorkService;
+    @Autowired
+    private FsIntegralOrderMapper fsIntegralOrderMapper;
 
 
     @Override
     public ErpOrderResponse addOrder(ErpOrder order) {
+        if (order.getIsIntegralOrder())
+            return getErpIntegralOrderResponse(order);
         return getErpOrderResponse(order);
     }
 
@@ -335,7 +344,8 @@ public class DfOrderServiceImpl implements IErpOrderService {
         return erpDeliverysResponse;
     }
 
-
+    @Autowired
+    private FsIntegralOrderDfMapper integralOrderDfMapper;
     /**
      * 目前仅查询下单用户
      *
@@ -347,20 +357,40 @@ public class DfOrderServiceImpl implements IErpOrderService {
         ErpOrderQueryResponse response = new ErpOrderQueryResponse();
         String orderNumber = requset.getCode();
         if (StrUtil.isNotBlank(orderNumber)) {
-            FsStoreOrder order = fsStoreOrderMapper.selectFsStoreOrderByOrderCode(orderNumber);
-            if (order != null) {
-                //获取下单账户
-                FsStoreOrderDf df = fsStoreOrderDfMapper.selectFsStoreOrderDfByOrderId(order.getOrderId());
-                if (df == null) {
-                    return null;
+            //金牛积分商品的逻辑
+            if (OrderContextHolder.hasIntegralOrder()) {
+                FsIntegralOrder order = fsIntegralOrderMapper.selectOne(Wrappers.<FsIntegralOrder>lambdaQuery().eq(FsIntegralOrder::getOrderCode, orderNumber));
+                if (order != null) {
+                    //获取下单账户
+                    FsIntegralOrderDf df = integralOrderDfMapper.selectOne(Wrappers.<FsIntegralOrderDf>lambdaQuery().eq(FsIntegralOrderDf::getOrderId,order.getOrderId()));
+                    if (df == null) {
+                        return null;
+                    }
+                    Long dfAccountId = getSFAccountIndex(order.getOrderId());
+                    if (dfAccountId != null) {
+                        Map<String, Object> orderResultQueryParam = new HashMap<>();
+                        orderResultQueryParam.put("orderNumber", orderNumber);
+                        orderResultQueryParam.put("exInterfaceType", df.getStatus());
+                        getIntegralOrderResult(orderResultQueryParam, dfAccountId);
+                        return response;
+                    }
                 }
-                Long dfAccountId = getSFAccountIndex(order.getOrderId());
-                if (dfAccountId != null) {
-                    Map<String, Object> orderResultQueryParam = new HashMap<>();
-                    orderResultQueryParam.put("orderNumber", orderNumber);
-                    orderResultQueryParam.put("exInterfaceType", df.getStatus());
-                    getOrderResult(orderResultQueryParam, dfAccountId);
-                    return response;
+            }else {
+                FsStoreOrder order = fsStoreOrderMapper.selectFsStoreOrderByOrderCode(orderNumber);
+                if (order != null) {
+                    //获取下单账户
+                    FsStoreOrderDf df = fsStoreOrderDfMapper.selectFsStoreOrderDfByOrderId(order.getOrderId());
+                    if (df == null) {
+                        return null;
+                    }
+                    Long dfAccountId = getSFAccountIndex(order.getOrderId());
+                    if (dfAccountId != null) {
+                        Map<String, Object> orderResultQueryParam = new HashMap<>();
+                        orderResultQueryParam.put("orderNumber", orderNumber);
+                        orderResultQueryParam.put("exInterfaceType", df.getStatus());
+                        getOrderResult(orderResultQueryParam, dfAccountId);
+                        return response;
+                    }
                 }
             }
             response.setErrorDesc("该订单不存在/顺丰账户不存在");
@@ -430,7 +460,11 @@ public class DfOrderServiceImpl implements IErpOrderService {
             if ("运单不存在".equals(dfApiResponse.getMsg())) {
 
                 //查看原来物流状态
-                cancelOrder(order);
+                if (OrderContextHolder.hasIntegralOrder()) {
+                    cancelOrder(OrderContextHolder.getIntegralOrder());
+                }else {
+                    cancelOrder(order);
+                }
                 log.info("代服管家 getOrderDeliveryStatus: {}", response);
                 return;
             }
@@ -489,18 +523,39 @@ public class DfOrderServiceImpl implements IErpOrderService {
                         Map<String, Object> config = (Map<String, Object>) JSON.parse(sysConfig.getConfigValue());
                         Object isUpdateOrder = config.get("isUpdateOrder");
                         if (isUpdateOrder == null || "1".equals(isUpdateOrder.toString())) {
+                            if (OrderContextHolder.hasIntegralOrder()) {
+                                FsIntegralOrder integralOrder = OrderContextHolder.getIntegralOrder();
+                                //积分订单修改状态已完成
+                                integralOrder.setStatus(3);//设置已完成状态
+                                int i = fsIntegralOrderMapper.updateById(integralOrder);
+                                log.info("积分订单编号{}完成订单，更新条数{}",integralOrder.getOrderCode(),i);
+                            }else {
+//                                fsStoreOrderService.getGoods(order.getOrderId(), "物流自动");
                             fsStoreOrderService.getGoods(orderId, "物流自动");
+                            }
                         }
                         break;
                     case 10:
                         //取消订单
                         String mailNumber = temp.getMailNumber();
-                        List<FsStoreOrder> fsStoreOrders = fsStoreOrderMapper.selectFsStoreOrderListByDeliverySn(mailNumber);
-                        if (fsStoreOrders != null && !fsStoreOrders.isEmpty()) {
-                            fsStoreOrders.forEach(tempOrder -> {
-                                cancelOrder(order);
-                                log.info("代服管家 订单取消成功: {}", response);
-                            });
+                        if (OrderContextHolder.hasIntegralOrder()) {
+                            List<FsIntegralOrder> orders = fsIntegralOrderMapper.selectList(Wrappers.<FsIntegralOrder>lambdaQuery().eq(FsIntegralOrder::getDeliverySn, mailNumber));
+                            if (orders != null && !orders.isEmpty()) {
+                                orders.forEach(tempOrder->{
+                                    log.info("订单状态查询取消订单{}",tempOrder.getOrderCode());
+                                    cancelOrder(tempOrder);
+                                    log.info("代服管家 订单取消成功: {}", response);
+                                });
+
+                            }
+                        }else {
+                            List<FsStoreOrder> fsStoreOrders = fsStoreOrderMapper.selectFsStoreOrderListByDeliverySn(mailNumber);
+                            if (fsStoreOrders != null && !fsStoreOrders.isEmpty()) {
+                                fsStoreOrders.forEach(tempOrder -> {
+                                    cancelOrder(order);
+                                    log.info("代服管家 订单取消成功: {}", response);
+                                });
+                            }
                         }
                         break;
                 }
@@ -514,9 +569,18 @@ public class DfOrderServiceImpl implements IErpOrderService {
                 }
 
 
-                fsStoreOrderMap.setDeliveryStatus(deliveryStatus); //物流状态：0-暂无轨迹信息 1-已揽收 2-在途中,3-签收,4-问题件
-                fsStoreOrderMap.setDeliveryType(stateEx);
-                fsStoreOrderMapper.updateFsStoreOrder(fsStoreOrderMap);
+                if (OrderContextHolder.hasIntegralOrder()){
+                    //加积分订单的字段，然后在这里更新它
+                    FsIntegralOrder integralOrder = OrderContextHolder.getIntegralOrder();
+                    integralOrder.setDeliveryStatus(deliveryStatus);
+                    integralOrder.setDeliveryType(stateEx);
+                    int i = fsIntegralOrderMapper.updateById(integralOrder);
+                    log.info("更新订单{}物流状态为{}and{}更新条数{}",integralOrder.getOrderCode(),deliveryStatus,stateEx,i);
+                }else {
+                    fsStoreOrderMap.setDeliveryStatus(deliveryStatus); //物流状态：0-暂无轨迹信息 1-已揽收 2-在途中,3-签收,4-问题件
+                    fsStoreOrderMap.setDeliveryType(stateEx);
+                    fsStoreOrderMapper.updateFsStoreOrder(fsStoreOrderMap);
+                }
             }
         } catch (IOException e) {
             e.printStackTrace();
@@ -704,7 +768,6 @@ public class DfOrderServiceImpl implements IErpOrderService {
     }
 
     private void cancelOrder(FsStoreOrder order) {
-        Long orderId = order.getOrderId();
         Integer deliveryStatus = order.getDeliveryStatus();
         if (deliveryStatus == null || deliveryStatus == 0) {
             //没有物流信息
@@ -713,26 +776,55 @@ public class DfOrderServiceImpl implements IErpOrderService {
             order.setExtendOrderId("");
             order.setDeliverySn("");
             fsStoreOrderMapper.updateFsStoreOrder(order);
-            fsStoreOrderLogsService.create(orderId, FsStoreOrderLogEnum.UPDATE_ORDER_DF.getValue(),
+            fsStoreOrderLogsService.create(order.getOrderId(), FsStoreOrderLogEnum.UPDATE_ORDER_DF.getValue(),
                     "运单不存在," + FsStoreOrderLogEnum.UPDATE_ORDER_DF.getDesc());
         } else {
             //有物流信息->售后处理
             //取消订单
             FsStoreOrderSalesParam afterSalesParam = new FsStoreOrderSalesParam();
-            afterSalesParam.setOrderId(orderId);
+            afterSalesParam.setOrderId(order.getOrderId());
             afterSalesParam.setReasons("代服管家取消订单");
             afterSalesParam.setOperator("代服管家");
             fsStoreOrderService.afterSales(afterSalesParam);
-            fsStoreOrderLogsService.create(orderId, FsStoreOrderLogEnum.REFUND_ORDER_DF.getValue(),
+            fsStoreOrderLogsService.create(order.getOrderId(), FsStoreOrderLogEnum.REFUND_ORDER_DF.getValue(),
                     "运单不存在," + FsStoreOrderLogEnum.REFUND_ORDER_DF.getDesc());
         }
         FsStoreOrderDf df = new FsStoreOrderDf();
-        df.setOrderId(orderId);
+        df.setOrderId(order.getOrderId());
         df.setStatus(2);
         df.setUpdateTime(new Date());
         fsStoreOrderDfMapper.updateFsStoreOrderDf(df);
     }
 
+    @Autowired
+    private IFsIntegralOrderService integralOrderService;
+    /**
+     * 积分订单商品取消订单逻辑
+     * */
+    private void cancelOrder(FsIntegralOrder order) {
+        //进入这个方法代表查询不到物流信息
+        Integer deliveryStatus = order.getDeliveryStatus();
+        //这个if进入代表调用代服创建运单失败，修改推送标识，由定时任务重新推送erp
+        if (deliveryStatus == null || deliveryStatus == 0) {
+            log.info("推送失败积分订单id：{}",order.getOrderId());
+            //没有物流信息
+            //修改订单状态 方便后续重新发货，让机器重新去
+            order.setStatus(1);//设置待发货状态
+            order.setDeliverySn("");
+            integralOrderMapper.updateById(order);
+        } else {
+            log.info("积分订单物流被取消，退款积分订单{}",order.getOrderCode());
+            //以前查询到过物流信息，现在查不到，物流被人为取消
+            integralOrderService.mandatoryRefunds(order.getOrderCode());
+        }
+        log.info("取消订单代服记录更新id{}",order.getOrderCode());
+        FsIntegralOrderDf df = new FsIntegralOrderDf();
+        df.setOrderId(order.getOrderId());
+        df.setStatus(2);
+        df.setIsPush(0);
+        integralOrderDfMapper.updateById(df);
+    }
+
     private void cancelOrderScrm(FsStoreOrderScrm order) {
         Integer deliveryStatus = order.getDeliveryStatus();
         if (deliveryStatus == null || deliveryStatus == 0) {
@@ -866,6 +958,53 @@ public class DfOrderServiceImpl implements IErpOrderService {
         return new ErpOrderResponse();
     }
 
+    @Autowired
+    private FsIntegralOrderMapper integralOrderMapper;
+
+    private ErpOrderResponse getErpIntegralOrderResponse(ErpOrder order){
+        FsIntegralOrder fsIntegralOrder = integralOrderMapper.selectOne(Wrappers.<FsIntegralOrder>lambdaQuery().eq(FsIntegralOrder::getOrderCode, order.getPlatform_code()));
+        if (fsIntegralOrder == null) {
+            return null;
+        }
+        Long dfAccountId = getSFAccountIndex(fsIntegralOrder.getOrderId());
+        //1.获取请求参数
+        ExternalOrderRequestVo vo = getCreateOrderRequestParam(order, fsIntegralOrder, dfAccountId);
+        if (vo == null) {
+            return null;
+        }
+        try {
+            Map<String, Object> map = JSON.parseObject(JSON.toJSONString(vo), Map.class);
+            //2.请求
+            log.info("开始推送订单,参数: {}", JSON.toJSONString(map));
+            String response = client.execute(RequestUrlEnum.CREAT_ORDER, map, dfAccountId);
+            DFApiResponse dfApiResponse = JSON.parseObject(response, DFApiResponse.class);
+            //3.处理请求结果
+            if (dfApiResponse != null && "ok".equals(dfApiResponse.getCode())) {
+                //存储订单推送用的哪个账户
+                FsIntegralOrderDf df = addDfOrder(fsIntegralOrder, dfAccountId);
+                log.info("订单推送成功: {}", response);
+                //可以回调 也可以查询订单
+                Map<String, Object> orderResultQueryParam = new HashMap<>();
+                orderResultQueryParam.put("orderNumber", order.getPlatform_code());
+                orderResultQueryParam.put("exInterfaceType", df.getStatus());
+                try {
+                    getIntegralOrderResult(orderResultQueryParam, dfAccountId);
+                } catch (Exception e) {
+                    log.info("推送订单完成，查询订单问题{}", e.getMessage());
+                }
+                ErpOrderResponse erpOrderResponse = new ErpOrderResponse();
+                erpOrderResponse.setCode(order.getPlatform_code());
+                erpOrderResponse.setSuccess(true);
+                return erpOrderResponse;
+            } else {
+                throw new RuntimeException(String.format("订单推送失败,原因: %s", dfApiResponse.getMsg()));
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return new ErpOrderResponse();
+    }
+
     private @NotNull FsStoreOrderDf addDfOrderScrm(FsStoreOrderScrm fsStoreOrder, Long dfAccountId) {
         FsStoreOrderDf df = new FsStoreOrderDf();
         df.setOrderId(fsStoreOrder.getId());
@@ -918,6 +1057,38 @@ public class DfOrderServiceImpl implements IErpOrderService {
         return df;
     }
 
+    private @NotNull FsIntegralOrderDf addDfOrder(FsIntegralOrder fsIntegralOrder, Long dfAccountId){
+//        FsStoreOrderDf df = new FsStoreOrderDf();
+        FsIntegralOrderDf df = new FsIntegralOrderDf();
+        df.setOrderId(fsIntegralOrder.getOrderId());
+        df.setOrderCode(fsIntegralOrder.getOrderCode());
+        FsDfAccount dfAccount = fsDfAccountMapper.selectFsDfAccountById(dfAccountId);
+        df.setAppKey(dfAccount.getDfAppKey());
+        df.setAppSecret(dfAccount.getDfAppsecret());
+        df.setLoginAccount(dfAccount.getLoginAccount());
+        df.setMonthlyCard(dfAccount.getMonthlyCard());
+        df.setExpressProductCode(dfAccount.getExpressProductCode());
+        df.setTotalPrice(fsIntegralOrder.getPayMoney());
+//        df.setPlatformPrice(fsStoreOrder.getPayPrice());
+        df.setPlatformPrice(BigDecimal.ZERO);
+        df.setStatus(1);
+        df.setIsPush(1);//已经创建过erp订单标识
+        //查询是否存在
+//        FsStoreOrderDf temp = fsStoreOrderDfMapper.selectFsStoreOrderDfByOrderId(df.getOrderId());
+        FsIntegralOrderDf temp = integralOrderDfMapper.selectById(df.getOrderId());
+        if (temp != null) {
+            //修改
+//            df.setUpdateTime(DateUtils.getNowDate());
+//            fsStoreOrderDfMapper.updateFsStoreOrderDf(df);
+            df.setUpdateTime(LocalDateTime.now());
+            integralOrderDfMapper.updateById(df);
+        } else {
+            df.setUpdateTime(LocalDateTime.now());
+            integralOrderDfMapper.insert(df);
+        }
+        return df;
+    }
+
     /**
      * 通用erpOrderScrm获取创建订单参数
      *
@@ -1131,6 +1302,109 @@ public class DfOrderServiceImpl implements IErpOrderService {
         return vo;
     }
 
+    @Autowired
+    private FsIntegralGoodsMapper fsIntegralGoodsMapper;
+
+    private ExternalOrderRequestVo getCreateOrderRequestParam(ErpOrder order, FsIntegralOrder fsIntegralOrder, Long dfAccountId) {
+        ExternalOrderRequestVo vo = new ExternalOrderRequestVo();
+        FsDfAccount dfAccount = fsDfAccountMapper.selectFsDfAccountById(dfAccountId);
+        if (dfAccount == null) {
+            return null;
+        }
+        String loginAccount = dfAccount.getLoginAccount();
+        vo.setMonthlyCard(dfAccount.getMonthlyCard()); //月结卡号
+        vo.setExpressProductCode(dfAccount.getExpressProductCode()); //物流产品编码
+
+
+        vo.setLoginAccount(loginAccount); //代服系统登录账号
+        String callBackUrl = dfAccount.getCallBackUrl();
+//        if (StringUtils.isNotBlank(callBackUrl)) {//TODO:到时候写完了回调接口这里写死或者放配置里面
+//            vo.setCallBackUrl(callBackUrl); //订单下单后异步通知地址
+//        }
+//        FsStoreOrderDf temp = fsStoreOrderDfMapper.selectFsStoreOrderDfByOrderId(fsStoreOrder.getOrderId());
+        FsIntegralOrderDf temp = integralOrderDfMapper.selectById(fsIntegralOrder.getOrderId());
+        if (temp != null) {
+            vo.setParcelQuantity(temp.getParcelQuantity());//包裹数量
+        }
+
+        vo.setOrderNumber(order.getPlatform_code()); //订单号（不能重复）
+
+        int orderPayMethod = 1;//默认在线支付，这个只有积分支付
+//        BigDecimal couponPrice = fsIntegralOrder.getCouponPrice();
+//        if (couponPrice == null) {
+        BigDecimal couponPrice = BigDecimal.ZERO;
+//        }
+
+//        if (ObjectUtil.equal(1, fsIntegralOrder.getPayType())) {
+//            //在线支付
+//            orderPayMethod = 1;
+//        } else { // 如果是线上付款
+//            orderPayMethod = 2;
+//            // 货到付款金额 = 订单剩余支付金额
+//            vo.setCollectingMoney(fsIntegralOrder.getPayRemain().doubleValue());
+//            vo.setCollectionCardNumber(dfAccount.getMonthlyCard()); // 就是月结账号
+//        }
+        //订单付款方式 1:在线支付 2:货到付款
+        //如果填了2，代收金额必须大于0，代收卡号必填
+        vo.setOrderPayMethod(orderPayMethod);
+
+//        vo.setConsignmentNumber(Integer.valueOf(Math.toIntExact(fsIntegralOrder.getTotalNum()))); //托寄物数量 必填
+        vo.setConsignmentNumber(1);
+        vo.setBuyerMessage(fsIntegralOrder.getRemark()); //买家留言
+
+        vo.setSenderName(dfAccount.getSenderName()); //寄件人
+        vo.setSenderPhone(dfAccount.getSenderPhone()); //寄件人手机
+        vo.setSenderProvince(dfAccount.getSenderProvince());//寄件人省
+        vo.setSenderCity(dfAccount.getSenderCity());//寄件人市
+        vo.setSenderDistrict(dfAccount.getSenderDistrict());//寄件人区
+        vo.setSenderAddress(dfAccount.getSenderAddress());//寄件人地址
+        vo.setReceiverName(order.getReceiver_name());//收件人
+        vo.setReceiverPhone(order.getReceiver_mobile()); //收件人手机
+        vo.setReceiverTelephone(order.getReceiver_phone());//收件人电话 否
+        vo.setReceiverProvince(order.getReceiver_province()); //收件人省
+        vo.setReceiverCity(order.getReceiver_city()); //收件人市
+        vo.setReceiverDistrict(order.getReceiver_district()); //收件人区
+        vo.setReceiverAddress(order.getReceiver_address()); // 收件人地址
+        vo.setExpressPayMethod(1); //物流付款方式 1:寄付月结 2:寄付现结 3:收方付 4:第三方付
+        //订单sku集合
+        StringBuilder consignmentStr = new StringBuilder();
+//        List<FsStoreOrderItem> items = fsStoreOrderItemMapper.selectFsStoreOrderItemListByOrderId(fsStoreOrder.getOrderId());
+        List<ErpOrderItem> items = order.getDetails();
+        if (items != null && items.size() > 0) {
+            ArrayList<ExteriorOrderSkuVo> orderSkus = new ArrayList<>();
+            items.forEach(item -> {
+                ExteriorOrderSkuVo skuVo = new ExteriorOrderSkuVo();
+//                FsStoreProduct product = fsStoreProductMapper.selectFsStoreProductById(item.getProductId());
+                FsIntegralGoods goods = fsIntegralGoodsMapper.selectFsIntegralGoodsByGoodsId(Convert.toLong(item.getOid()));
+                Asserts.check(ObjectUtils.isNotNull(goods), "该产品不存在! 产品id: {} ", item.getOid());
+                skuVo.setProductName(goods.getGoodsName()); //商品名称
+//                com.alibaba.fastjson.JSONObject jsonObject = JSON.parseObject(item.getJsonInfo());
+                skuVo.setSkuCode("默认"); //sku编码
+                skuVo.setProductCode(goods.getBarCode()); //商品编号
+                skuVo.setAttributeNames("默认"); //商品规格，格式：颜色：红色，尺寸：L码....以此类推
+                skuVo.setProductNumber(Math.toIntExact(item.getQty())); //商品预定数量
+                skuVo.setPrice(Convert.toDouble(item.getPrice())); //商品单价
+
+//                skuVo.setAdjustAmount(0d); //调整金额
+                // 优惠
+                skuVo.setSubAmount(Convert.toDouble(item.getPrice()) * item.getQty());
+
+                //组装寄托物
+                consignmentStr.append(goods.getGoodsName()).append("*").append(item.getQty()).append(",");
+                orderSkus.add(skuVo);
+            });
+            if (consignmentStr.length() > 0) {
+                consignmentStr.deleteCharAt(consignmentStr.length() - 1);
+            }
+            if (consignmentStr.length() > 100) {
+                consignmentStr.delete(consignmentStr.length() - 4, consignmentStr.length());
+                consignmentStr.append("...");
+            }
+            vo.setOrderSkus(orderSkus);
+            vo.setConsignment(consignmentStr.toString()); //寄托物 必填
+        }
+        return vo;
+    }
 
     /**
      * 获取账户索引 后续添加规则
@@ -1213,6 +1487,59 @@ public class DfOrderServiceImpl implements IErpOrderService {
         }
     }
 
+    private void getIntegralOrderResult(Map<String, Object> map, Long dfAccountId){
+        try {
+            String status = map.get("exInterfaceType").toString();
+            log.info("开始查询订单结果,参数为: {}", JSON.toJSONString(map));
+            String response = client.execute(RequestUrlEnum.ORDER_RESULT, map, dfAccountId);
+            DFApiResponse dfApiResponse = JSON.parseObject(response, DFApiResponse.class);
+            if (dfApiResponse != null && "ok".equals(dfApiResponse.getCode())) {
+                log.info("查询订单结果,结果: {}", JSON.toJSONString(dfApiResponse));
+                Object result = dfApiResponse.getResult();
+                if (result != null) {
+                    String jsonString = JSON.toJSONString(result);
+                    //下单
+                    if ("1".equals(status)) {
+                        //下单结果
+                        BspOrderResponseWrapper bspOrderResponse = JSONUtil.toBean(jsonString, BspOrderResponseWrapper.class);
+                        if (bspOrderResponse != null) {
+                            String failMsg = bspOrderResponse.getFailMsg();
+                            if (StringUtils.isNotBlank(failMsg)) {
+                                if (failMsg.equals("暂未结果, 请稍后再查")) {
+                                    return;
+                                }
+                                //下单失败 返回未推送状态
+                                String orderNumber = bspOrderResponse.getOrderNumber();
+                                try {
+                                    rollBackIntegralOrder(orderNumber, failMsg);
+                                } catch (Exception e) {
+                                    log.info("{}订单获取运单失败，订单状态回滚失败，失败原因：{}，失败信息为：{}", orderNumber,e.getMessage(),failMsg);
+                                }
+                            } else {
+                                setIntegralExpress(bspOrderResponse);
+                            }
+                        }
+                    } else if ("2".equals(status)) {
+                        //取消订单
+                        DFCancelOrderResultResponse cancelResponse = JSONUtil.toBean(jsonString, DFCancelOrderResultResponse.class);
+                        if (cancelResponse != null) {
+                            if (cancelResponse.getIsCancelSuss() == 1) {
+                                log.info("查询订单取消成功,返回结果{}", JSON.toJSONString(cancelResponse));
+                            } else {
+                                log.info("查询订单取消失败,返回结果{}", JSON.toJSONString(cancelResponse));
+                            }
+                        }
+                    }
+                }
+
+            } else {
+                log.info(String.format("查询订单失败,原因: %s", dfApiResponse.getMsg()));
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
     private void getOrderScrmResult(Map<String, Object> map, Long dfAccountId) {
         try {
             String status = map.get("exInterfaceType").toString();
@@ -1282,6 +1609,17 @@ public class DfOrderServiceImpl implements IErpOrderService {
         //推送失败消息
     }
 
+    private void rollBackIntegralOrder(String orderNumber, String failMsg){
+        //积分的回退不用修改扩展id，定时任务准备使用df表的ispush字段来查询
+        FsIntegralOrderDf df = integralOrderDfMapper.selectOne(Wrappers.<FsIntegralOrderDf>lambdaQuery().eq(FsIntegralOrderDf::getOrderCode, orderNumber));
+        df.setStatus(0); //回到默认
+        df.setFailMsg(failMsg); //失败消息
+        df.setUpdateTime(LocalDateTime.now());
+        df.setIsPush(0);
+        integralOrderDfMapper.updateById(df);
+        log.info("{}订单获取运单失败，失败信息为：{}", orderNumber,failMsg);
+    }
+
     private void rollBackOrderScrm(String orderNumber, String failMsg) {
         FsStoreOrderScrm fsStoreOrder = fsStoreOrderScrmMapper.selectFsStoreOrderByOrderCode(orderNumber);
         FsStoreOrderScrm tempOrder = new FsStoreOrderScrm();
@@ -1372,6 +1710,60 @@ public class DfOrderServiceImpl implements IErpOrderService {
         }
     }
 
+    private void setIntegralExpress(BspOrderResponseWrapper bspResponse){
+        String orderNumber = bspResponse.getOrderNumber();
+        //快递单号
+        String mailNumber = bspResponse.getMailNumber();
+        //快递名字
+        BspOrderResponse bspOrderResponse = bspResponse.getBspResponse();
+        if (bspOrderResponse != null) {
+            AtomicBoolean flag = new AtomicBoolean(false);
+            List<OrderResponse> list = bspOrderResponse.getBody();
+            if (list != null && !list.isEmpty()) {
+                for (OrderResponse orderResponse : list) {
+                    List<RlsInfo> rlsInfo = orderResponse.getRlsInfo();
+                    if (rlsInfo != null && !rlsInfo.isEmpty()) {
+                        for (RlsInfo info : rlsInfo) {
+                            List<RlsDetail> rlsDetails = info.getRlsDetail();
+                            if (rlsDetails != null && !rlsDetails.isEmpty()) {
+                                for (RlsDetail rlsDetail : rlsDetails) {
+                                    String proCode = rlsDetail.getProCode();
+                                    if (StringUtils.isNotBlank(proCode)) {
+//                                        FsStoreOrder order = fsStoreOrderMapper.selectFsStoreOrderByOrderCode(orderNumber);
+                                        FsIntegralOrder order = fsIntegralOrderMapper.selectOne(Wrappers.<FsIntegralOrder>lambdaQuery().eq(FsIntegralOrder::getOrderCode, orderNumber));
+                                        if (order != null && order.getStatus() == 1) {//等于待发货
+                                            order.setDeliverySn(mailNumber);
+                                            order.setDeliveryName(proCode);
+                                            order.setDeliveryCode("SF");
+                                            order.setStatus(2);//修改积分订单为待收货状态
+                                            order.setDeliveryTime(DateUtils.getNowDate()); //更新发货时间
+                                            fsIntegralOrderMapper.updateById(order);
+//                                            fsStoreOrderLogsService.create(order.getOrderId(), FsStoreOrderLogEnum.DELIVERY_GOODS.getValue(), FsStoreOrderLogEnum.DELIVERY_GOODS.getDesc());
+//                                            redisCache.deleteObject(DELIVERY+":"+order.getOrderCode());
+//                                            if (order.getCompanyId() != null && order.getCompanyId() > 0) {
+//                                                companyService.subtractCompanyMoney(order);
+//                                            }积分商品没有这个
+                                            flag.set(true);
+                                        }
+                                        break;
+                                    }
+                                }
+
+                            }
+                            if (flag.get()) {
+                                break;
+                            }
+                        }
+
+                    }
+                    if (flag.get()) {
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
     /**
      * 顺丰会有自己的轨迹推送 不使用快递鸟(代服务管家设置推送地址)
      *

fs-service/src/main/java/com/fs/his/domain/FsIntegralOrder.java

@@ -1,5 +1,8 @@
 package com.fs.his.domain;
 
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
 import com.fasterxml.jackson.annotation.JsonFormat;
 import com.fs.common.annotation.Excel;
 import com.fs.common.core.domain.BaseEntity;
@@ -16,11 +19,12 @@ import java.util.Date;
  * @date 2023-11-02
  */
 @Data
-public class FsIntegralOrder extends BaseEntity
+public class FsIntegralOrder
 {
     private static final long serialVersionUID = 1L;
 
     /** id */
+    @TableId
     private Long orderId;
 
     /** 订单编号 */
@@ -47,9 +51,10 @@ public class FsIntegralOrder extends BaseEntity
     @Excel(name = "商品信息")
     private String itemJson;
 
+    @TableField(exist = false)
     @Excel(name = "商品名称")
     private String goodsName;
-
+    @TableField(exist = false)
     @Excel(name = "原价")
     private BigDecimal otPrice;
 
@@ -73,7 +78,7 @@ public class FsIntegralOrder extends BaseEntity
     @Excel(name = "支付类型 1积分 2现金 3积分+现金")
     private Integer payType;
 
-    /** 1：待发货；2：待收货；3：已完成 4待支付 5取消 */
+    /** 1：待发货；2：待收货；3：已完成 4待支付 -1取消 */
     @Excel(name = "状态",dictType="sys_integral_order_status")
     private Integer status;
     @Excel(name = "商品编号")
@@ -116,4 +121,13 @@ public class FsIntegralOrder extends BaseEntity
 
     private String loginAccount;
 
+    private String remark;
+
+    private Date createTime;
+    @TableField(exist = false)
+    private Date updateTime;
+
+    private Integer deliveryStatus;
+
+    private String deliveryType;
 }

fs-service/src/main/java/com/fs/his/domain/FsIntegralOrderDf.java

@@ -0,0 +1,73 @@
+package com.fs.his.domain;
+
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.fs.common.annotation.Excel;
+import lombok.Data;
+import com.fs.common.core.domain.BaseEntity;
+import lombok.EqualsAndHashCode;
+
+/**
+ * 【请填写功能名称】对象 fs_integral_order_df
+ *
+ * @author fs
+ * @date 2025-11-11
+ */
+@Data
+public class FsIntegralOrderDf{
+
+    @TableId
+    /** 订单id */
+    private Long orderId;
+
+    /** 订单编号 */
+    @Excel(name = "订单编号")
+    private String orderCode;
+
+    /** $column.columnComment */
+    @Excel(name = "订单编号")
+    private String appKey;
+
+    /** $column.columnComment */
+    @Excel(name = "订单编号")
+    private String appSecret;
+
+    /** $column.columnComment */
+    @Excel(name = "订单编号")
+    private String loginAccount;
+
+    /** 顺丰月结账户 */
+    @Excel(name = "顺丰月结账户")
+    private String monthlyCard;
+
+    /** 物流产品编码:1-顺丰标快，2-顺丰标快（陆运）,204-陆运微小件,231-陆运包裹,208-特惠专配 */
+    @Excel(name = "物流产品编码:1-顺丰标快，2-顺丰标快", readConverterExp = "陆=运")
+    private String expressProductCode;
+
+    /** 订单总价 */
+    @Excel(name = "订单总价")
+    private BigDecimal totalPrice;
+
+    /** 平台收款 */
+    @Excel(name = "平台收款")
+    private BigDecimal platformPrice;
+
+    /** 0:默认 1下单 2取消订单 */
+    @Excel(name = "0:默认 1下单 2取消订单")
+    private Integer status;
+
+    /** 失败原因 */
+    @Excel(name = "失败原因")
+    private String failMsg;
+
+    /** 包裹数量 */
+    @Excel(name = "包裹数量")
+    private Integer parcelQuantity;
+
+    private LocalDateTime updateTime;
+    private LocalDateTime createTime;
+    private String erpPhone;
+    private Integer isPush;
+}

fs-service/src/main/java/com/fs/his/mapper/FsIntegralOrderDfMapper.java

@@ -0,0 +1,64 @@
+package com.fs.his.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.fs.his.domain.FsIntegralOrderDf;
+
+import java.util.List;
+
+/**
+ * 【请填写功能名称】Mapper接口
+ *
+ * @author fs
+ * @date 2025-11-11
+ */
+public interface FsIntegralOrderDfMapper extends BaseMapper<FsIntegralOrderDf> {
+    /**
+     * 查询【请填写功能名称】
+     *
+     * @param orderId 【请填写功能名称】主键
+     * @return 【请填写功能名称】
+     */
+    FsIntegralOrderDf selectFsIntegralOrderDfByOrderId(Long orderId);
+
+    /**
+     * 查询【请填写功能名称】列表
+     *
+     * @param fsIntegralOrderDf 【请填写功能名称】
+     * @return 【请填写功能名称】集合
+     */
+    List<FsIntegralOrderDf> selectFsIntegralOrderDfList(FsIntegralOrderDf fsIntegralOrderDf);
+
+    /**
+     * 新增【请填写功能名称】
+     *
+     * @param fsIntegralOrderDf 【请填写功能名称】
+     * @return 结果
+     */
+    int insertFsIntegralOrderDf(FsIntegralOrderDf fsIntegralOrderDf);
+
+    /**
+     * 修改【请填写功能名称】
+     *
+     * @param fsIntegralOrderDf 【请填写功能名称】
+     * @return 结果
+     */
+    int updateFsIntegralOrderDf(FsIntegralOrderDf fsIntegralOrderDf);
+
+    /**
+     * 删除【请填写功能名称】
+     *
+     * @param orderId 【请填写功能名称】主键
+     * @return 结果
+     */
+    int deleteFsIntegralOrderDfByOrderId(Long orderId);
+
+    /**
+     * 批量删除【请填写功能名称】
+     *
+     * @param orderIds 需要删除的数据主键集合
+     * @return 结果
+     */
+    int deleteFsIntegralOrderDfByOrderIds(Long[] orderIds);
+
+    List<FsIntegralOrderDf> selectByIsPush();
+}

fs-service/src/main/java/com/fs/his/mapper/FsIntegralOrderMapper.java

@@ -1,6 +1,8 @@
 package com.fs.his.mapper;
 
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import com.fs.his.domain.FsIntegralOrder;
+import com.fs.his.domain.FsIntegralOrderDf;
 import com.fs.his.param.FsIntegralOrderListUParam;
 import com.fs.his.param.FsIntegralOrderParam;
 import com.fs.his.vo.FsIntegralOrderListUVO;
@@ -17,7 +19,7 @@ import java.util.List;
  * @author fs
  * @date 2023-11-02
  */
-public interface FsIntegralOrderMapper
+public interface FsIntegralOrderMapper extends BaseMapper<FsIntegralOrder>
 {
     /**
      * 查询积分商品订单
@@ -110,4 +112,8 @@ public interface FsIntegralOrderMapper
     int cancelOrder(@Param("orderId") Long orderId);
 
     int finishOrder(@Param("orderId") Long orderId,@Param("oldStatus") Integer status);
+
+    List<FsIntegralOrder> findOrderByIds(@Param("orderIds") List<Long> orderIds);
+
+    List<FsIntegralOrderListVO> selectFsIntegralOrderListJn(FsIntegralOrderParam fsIntegralOrder);
 }

fs-service/src/main/java/com/fs/his/param/FsIntegralOrderParam.java

@@ -100,4 +100,8 @@ public class FsIntegralOrderParam {
      * 销售公司ID
      * **/
     private Long companyId;
+
+    private String loginAccount;
+
+    private Integer isPush;
 }

fs-service/src/main/java/com/fs/his/service/IFsIntegralOrderDfService.java

@@ -0,0 +1,62 @@
+package com.fs.his.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.fs.his.domain.FsIntegralOrderDf;
+
+import java.util.List;
+
+/**
+ * 【请填写功能名称】Service接口
+ *
+ * @author fs
+ * @date 2025-11-11
+ */
+public interface IFsIntegralOrderDfService extends IService<FsIntegralOrderDf> {
+    /**
+     * 查询【请填写功能名称】
+     *
+     * @param orderId 【请填写功能名称】主键
+     * @return 【请填写功能名称】
+     */
+    FsIntegralOrderDf selectFsIntegralOrderDfByOrderId(Long orderId);
+
+    /**
+     * 查询【请填写功能名称】列表
+     *
+     * @param fsIntegralOrderDf 【请填写功能名称】
+     * @return 【请填写功能名称】集合
+     */
+    List<FsIntegralOrderDf> selectFsIntegralOrderDfList(FsIntegralOrderDf fsIntegralOrderDf);
+
+    /**
+     * 新增【请填写功能名称】
+     *
+     * @param fsIntegralOrderDf 【请填写功能名称】
+     * @return 结果
+     */
+    int insertFsIntegralOrderDf(FsIntegralOrderDf fsIntegralOrderDf);
+
+    /**
+     * 修改【请填写功能名称】
+     *
+     * @param fsIntegralOrderDf 【请填写功能名称】
+     * @return 结果
+     */
+    int updateFsIntegralOrderDf(FsIntegralOrderDf fsIntegralOrderDf);
+
+    /**
+     * 批量删除【请填写功能名称】
+     *
+     * @param orderIds 需要删除的【请填写功能名称】主键集合
+     * @return 结果
+     */
+    int deleteFsIntegralOrderDfByOrderIds(Long[] orderIds);
+
+    /**
+     * 删除【请填写功能名称】信息
+     *
+     * @param orderId 【请填写功能名称】主键
+     * @return 结果
+     */
+    int deleteFsIntegralOrderDfByOrderId(Long orderId);
+}

fs-service/src/main/java/com/fs/his/service/IFsIntegralOrderService.java

@@ -5,11 +5,9 @@ import com.fs.common.core.domain.R;
 import com.fs.his.domain.FsIntegralOrder;
 import com.fs.his.enums.PaymentMethodEnum;
 import com.fs.his.param.*;
-import com.fs.his.vo.FsIntegralOrderListUVO;
-import com.fs.his.vo.FsIntegralOrderListVO;
-import com.fs.his.vo.FsIntegralOrderPVO;
-import com.fs.his.vo.FsStoreProductDeliverExcelVO;
+import com.fs.his.vo.*;
 
+import java.text.ParseException;
 import java.util.List;
 
 /**
@@ -70,6 +68,8 @@ public interface IFsIntegralOrderService
 
     List<FsIntegralOrderListVO> selectFsIntegralOrderListVO(FsIntegralOrderParam fsIntegralOrder);
 
+    List<FsIntegralOrderListVO> selectFsIntegralOrderListByJn(FsIntegralOrderParam fsIntegralOrder);
+
     int sendGoods(FsIntegralOrder fsIntegralOrder);
 
     List<FsIntegralOrderListUVO> selectFsIntegralOrderListUVO(FsIntegralOrderListUParam param);
@@ -109,4 +109,10 @@ public interface IFsIntegralOrderService
     int mandatoryRefunds(String orderCode);
 
     int finishOrder(String orderCode);
+
+    List<FsIntegralOrder> selectFsIntegralOrderByOrderIds(List<Long> orderIds);
+
+    void createErpOrder(Long orderId) throws ParseException;
+
+    String importOrderStatusData(List<FsIntegralOrderExcelVO> list);
 }

fs-service/src/main/java/com/fs/his/service/impl/FsIntegralOrderDfServiceImpl.java

@@ -0,0 +1,93 @@
+package com.fs.his.service.impl;
+
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.fs.common.utils.DateUtils;
+import com.fs.his.domain.FsIntegralOrderDf;
+import com.fs.his.mapper.FsIntegralOrderDfMapper;
+import com.fs.his.service.IFsIntegralOrderDfService;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+/**
+ * 【请填写功能名称】Service业务层处理
+ *
+ * @author fs
+ * @date 2025-11-11
+ */
+@Service
+public class FsIntegralOrderDfServiceImpl extends ServiceImpl<FsIntegralOrderDfMapper, FsIntegralOrderDf> implements IFsIntegralOrderDfService {
+
+    /**
+     * 查询【请填写功能名称】
+     *
+     * @param orderId 【请填写功能名称】主键
+     * @return 【请填写功能名称】
+     */
+    @Override
+    public FsIntegralOrderDf selectFsIntegralOrderDfByOrderId(Long orderId)
+    {
+        return baseMapper.selectFsIntegralOrderDfByOrderId(orderId);
+    }
+
+    /**
+     * 查询【请填写功能名称】列表
+     *
+     * @param fsIntegralOrderDf 【请填写功能名称】
+     * @return 【请填写功能名称】
+     */
+    @Override
+    public List<FsIntegralOrderDf> selectFsIntegralOrderDfList(FsIntegralOrderDf fsIntegralOrderDf)
+    {
+        return baseMapper.selectFsIntegralOrderDfList(fsIntegralOrderDf);
+    }
+
+    /**
+     * 新增【请填写功能名称】
+     *
+     * @param fsIntegralOrderDf 【请填写功能名称】
+     * @return 结果
+     */
+    @Override
+    public int insertFsIntegralOrderDf(FsIntegralOrderDf fsIntegralOrderDf)
+    {
+        return baseMapper.insertFsIntegralOrderDf(fsIntegralOrderDf);
+    }
+
+    /**
+     * 修改【请填写功能名称】
+     *
+     * @param fsIntegralOrderDf 【请填写功能名称】
+     * @return 结果
+     */
+    @Override
+    public int updateFsIntegralOrderDf(FsIntegralOrderDf fsIntegralOrderDf)
+    {
+        return baseMapper.updateFsIntegralOrderDf(fsIntegralOrderDf);
+    }
+
+    /**
+     * 批量删除【请填写功能名称】
+     *
+     * @param orderIds 需要删除的【请填写功能名称】主键
+     * @return 结果
+     */
+    @Override
+    public int deleteFsIntegralOrderDfByOrderIds(Long[] orderIds)
+    {
+        return baseMapper.deleteFsIntegralOrderDfByOrderIds(orderIds);
+    }
+
+    /**
+     * 删除【请填写功能名称】信息
+     *
+     * @param orderId 【请填写功能名称】主键
+     * @return 结果
+     */
+    @Override
+    public int deleteFsIntegralOrderDfByOrderId(Long orderId)
+    {
+        return baseMapper.deleteFsIntegralOrderDfByOrderId(orderId);
+    }
+}

fs-service/src/main/java/com/fs/his/service/impl/FsIntegralOrderServiceImpl.java

@@ -6,6 +6,9 @@ import cn.hutool.core.util.IdUtil;
 import cn.hutool.core.util.ObjectUtil;
 import cn.hutool.core.util.StrUtil;
 import cn.hutool.json.JSONUtil;
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
 import com.baomidou.mybatisplus.core.conditions.Wrapper;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
@@ -15,27 +18,32 @@ import com.fs.common.core.domain.R;
 import com.fs.common.core.redis.RedisCache;
 import com.fs.common.exception.CustomException;
 import com.fs.common.exception.ServiceException;
-import com.fs.common.utils.DateUtils;
-import com.fs.common.utils.StringUtils;
+import com.fs.common.utils.*;
 import com.fs.common.utils.poi.ExcelUtil;
+import com.fs.company.domain.Company;
+import com.fs.company.domain.CompanyDept;
 import com.fs.company.domain.CompanyUser;
 import com.fs.company.mapper.CompanyUserMapper;
+import com.fs.company.service.ICompanyDeptService;
+import com.fs.company.service.ICompanyService;
+import com.fs.company.service.ICompanyUserService;
+import com.fs.config.cloud.CloudHostProper;
 import com.fs.core.utils.OrderCodeUtils;
+import com.fs.erp.domain.ErpOrder;
+import com.fs.erp.domain.ErpOrderItem;
+import com.fs.erp.domain.ErpOrderPayment;
+import com.fs.erp.dto.ErpOrderResponse;
+import com.fs.erp.service.IErpOrderService;
+import com.fs.his.config.FsSysConfig;
 import com.fs.his.domain.*;
-import com.fs.his.enums.BusinessTypeEnum;
-import com.fs.his.enums.FsUserIntegralLogTypeEnum;
-import com.fs.his.enums.PaymentMethodEnum;
+import com.fs.his.dto.ErpRemarkDTO;
+import com.fs.his.enums.*;
 import com.fs.his.mapper.*;
 import com.fs.his.param.*;
-import com.fs.his.service.IFsIntegralCartService;
-import com.fs.his.service.IFsIntegralOrderService;
-import com.fs.his.service.IFsStorePaymentService;
-import com.fs.his.service.IFsUserIntegralLogsService;
+import com.fs.his.service.*;
+import com.fs.his.utils.ConfigUtil;
 import com.fs.his.utils.PhoneUtil;
-import com.fs.his.vo.FsIntegralOrderListUVO;
-import com.fs.his.vo.FsIntegralOrderListVO;
-import com.fs.his.vo.FsIntegralOrderPVO;
-import com.fs.his.vo.FsStoreProductDeliverExcelVO;
+import com.fs.his.vo.*;
 import com.fs.qw.domain.QwUser;
 import com.fs.qw.mapper.QwUserMapper;
 import com.fs.tzBankPay.doman.PayType;
@@ -47,14 +55,23 @@ import org.apache.commons.collections.CollectionUtils;
 import org.redisson.api.RObjectAsync;
 import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.transaction.interceptor.TransactionAspectSupport;
 
+import java.io.Serializable;
 import java.math.BigDecimal;
+import java.sql.Timestamp;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
 import java.time.LocalDateTime;
+import java.time.ZoneId;
 import java.util.*;
 import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+
+import static com.fs.his.utils.PhoneUtil.*;
 
 /**
  * 积分商品订单Service业务层处理
@@ -96,6 +113,54 @@ public class FsIntegralOrderServiceImpl implements IFsIntegralOrderService
     @Autowired
     private IFsIntegralCartService cartService;
 
+    @Autowired
+    @Qualifier("erpOrderServiceImpl")
+    private IErpOrderService gyOrderService;
+
+    @Autowired
+    @Qualifier("wdtErpOrderServiceImpl")
+    private IErpOrderService wdtOrderService;
+
+    @Autowired
+    @Qualifier("hzOMSErpOrderServiceImpl")
+    private IErpOrderService hzOMSOrderService;
+
+    @Autowired
+    @Qualifier("dfOrderServiceImpl")
+    private IErpOrderService dfOrderService;
+
+    @Autowired
+    @Qualifier("JSTErpOrderServiceImpl")
+    private IErpOrderService jSTOrderService;
+    @Autowired
+    @Qualifier("k9OrderScrmServiceImpl")
+    private IErpOrderService k9OrderService;
+    @Autowired
+    private FsIntegralOrderDfMapper fsIntegralOrderDfMapper;
+
+    @Autowired
+    private ConfigUtil configUtil;
+
+    @Autowired
+    private CloudHostProper cloudHostProper;
+
+    @Autowired
+    private ICompanyService companyService;
+
+    @Autowired
+    private ICompanyUserService companyUserService;
+
+    @Autowired
+    private ICompanyDeptService companyDeptService;
+
+    @Autowired
+    private IFsExpressService expressService;
+
+    @Autowired
+    private IFsIntegralOrderDfService integralOrderDfService;
+
+    @Autowired
+    private IFsUserAddressService fsUserAddressService;
     /**
      * 查询积分商品订单
      *
@@ -142,6 +207,16 @@ public class FsIntegralOrderServiceImpl implements IFsIntegralOrderService
     @Override
     public int updateFsIntegralOrder(FsIntegralOrder fsIntegralOrder)
     {
+        FsIntegralOrder order = fsIntegralOrderMapper.selectById(fsIntegralOrder.getOrderId());
+        //当前状态
+        Integer status = order.getStatus();
+        if (fsIntegralOrder.getStatus().equals(2)){
+            throw new CustomException("积分订单无法修改为待支付状态");
+        }
+        if (fsIntegralOrder.getStatus().equals(2)&&StrUtil.isBlank(fsIntegralOrder.getDeliverySn())) {
+            throw new CustomException("修改为待发货时，请填写物流单号");
+        }
+        //其他逻辑，目前暂定这个
         return fsIntegralOrderMapper.updateFsIntegralOrder(fsIntegralOrder);
     }
 
@@ -174,6 +249,11 @@ public class FsIntegralOrderServiceImpl implements IFsIntegralOrderService
         return fsIntegralOrderMapper.selectFsIntegralOrderListVO(fsIntegralOrder);
     }
 
+    @Override
+    public List<FsIntegralOrderListVO> selectFsIntegralOrderListByJn(FsIntegralOrderParam fsIntegralOrder) {
+        return fsIntegralOrderMapper.selectFsIntegralOrderListJn(fsIntegralOrder);
+    }
+
     @Override
     public int sendGoods(FsIntegralOrder fsIntegralOrder) {
 
@@ -408,6 +488,9 @@ public class FsIntegralOrderServiceImpl implements IFsIntegralOrderService
                 if (o==null){
                 throw new CustomException("没有此订单");
                 }
+//                if (StrUtil.isBlank(o.getLoginAccount())&&CloudHostUtils.hasCloudHostName("金牛明医")) {
+//                    throw new CustomException("订单未分拣");
+//                }
                 if (o.getStatus()!=1){
                     throw new CustomException("订单状态不为待发货");
                 }
@@ -434,6 +517,11 @@ public class FsIntegralOrderServiceImpl implements IFsIntegralOrderService
                 order.setStatus(2);
 
                 int i = fsIntegralOrderMapper.updateFsIntegralOrder(order);
+                FsIntegralOrderDf df = new FsIntegralOrderDf();//和创建erp的按钮接口数据操作保持一致，修改df记录，订单状态修改为待收货。
+                df.setOrderId(order.getOrderId());
+                df.setIsPush(1);
+                df.setStatus(1);
+                fsIntegralOrderDfMapper.updateById(df);//有就更新，没有也不影响。目前金牛在使用代服表。
                 successNum++;
                 successMsg.append("<br/>" + successNum + "、订单编号 " + vo.getOrderCode() + " 导入成功");
 
@@ -662,6 +750,8 @@ public class FsIntegralOrderServiceImpl implements IFsIntegralOrderService
         if (null==fsIntegralOrder){
             throw new ServiceException("订单不存在");
         }
+        log.info("用户：{}退款订单编号：{}，退还积分{}", SecurityUtils.getLoginUser().getUser().getNickName(),fsIntegralOrder.getOrderCode(),fsIntegralOrder.getIntegral());
+        //物流退单操作
         //用户说自己去对接物流，不必校验是否发货。
 //        if (fsIntegralOrder.getStatus()!=1){
 //            throw new ServiceException("订单已发货或已完成");
@@ -684,7 +774,6 @@ public class FsIntegralOrderServiceImpl implements IFsIntegralOrderService
             fsUserIntegralLogs.setBusinessType(2);
             fsUserIntegralLogs.setStatus(0);
             i = fsUserIntegralLogsMapper.insertFsUserIntegralLogs(fsUserIntegralLogs);
-            //todo:库存是否需要退还，待定
         }
         return i;
     }
@@ -703,6 +792,319 @@ public class FsIntegralOrderServiceImpl implements IFsIntegralOrderService
         return fsIntegralOrderMapper.finishOrder(fsIntegralOrder.getOrderId(), fsIntegralOrder.getStatus());
     }
 
+    @Override
+    public List<FsIntegralOrder> selectFsIntegralOrderByOrderIds(List<Long> orderIds) {
+        if (CollectionUtils.isEmpty(orderIds)) {
+            return Collections.emptyList();
+        }
+        return fsIntegralOrderMapper.findOrderByIds(orderIds);
+    }
+
+
+    @Override
+//    @Transactional(rollbackFor = Exception.class)
+    public void createErpOrder(Long orderId) throws ParseException {
+        //判断是否开启erp
+        FsSysConfig sysConfig = configUtil.getSysConfig();
+        Integer erpOpen = sysConfig.getErpOpen();
+        if (erpOpen == null || erpOpen == 0) {
+            return;
+        }
+        //判断erp类型
+        Integer erpType = sysConfig.getErpType();
+        if (erpType == null) {
+            return;
+        }
+        IErpOrderService erpOrderService = null;
+        ErpOrder erpOrder = new ErpOrder();
+        erpOrder.setShop_code(sysConfig.getErpShopCode());
+        if (erpType == 1) {
+            //管易
+            erpOrderService = gyOrderService;
+        } else if (erpType == 2) {
+            //旺店通
+            erpOrderService = wdtOrderService;
+        } else if (erpType == 3) {
+            //瀚智OMS
+            erpOrderService = hzOMSOrderService;
+        } else if (erpType == 4) {
+            //代服
+            erpOrderService = dfOrderService;
+        } else if (erpType == 5) {
+            //聚水潭
+            erpOrderService = jSTOrderService;
+            erpOrder.setShop_code(sysConfig.getErpJstShopCode());
+        }else if (erpType == 6) {
+            erpOrderService = k9OrderService;
+        } else {
+            return;
+        }
+        FsIntegralOrder order = fsIntegralOrderMapper.selectOne(Wrappers.<FsIntegralOrder>lambdaQuery().eq(FsIntegralOrder::getOrderId, orderId));
+        if (order == null || !order.getStatus().equals(1)) {//1.待发货状态，只有待发货的订单可以创建erp订单
+            return;
+        }
+        if (order.getCompanyId() != null) {
+            erpOrder.setVip_code(order.getUserId().toString() + order.getCompanyId().toString());
+        } else {
+            erpOrder.setVip_code(order.getUserId().toString());
+        }
+        erpOrder.setPlatform_code(order.getOrderCode());
+
+        erpOrder.setBuyer_account(order.getUserName());
+        erpOrder.setSeller_memo(order.getRemark());
+        List<ErpOrderPayment> payments = new ArrayList<>();
+        ErpOrderPayment payment = new ErpOrderPayment();
+        payment.setPay_type_code("weixin");
+        payment.setPayment(order.getPayMoney().doubleValue());
+        if (order.getPayTime() != null) {
+            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+            String timeString = sdf.format(Date.from((order.getPayTime().atZone(ZoneId.systemDefault()).toInstant())));
+            Date date = sdf.parse(timeString); // 时间格式转为时间戳
+            long timeLong = date.getTime();
+            payment.setPaytime(new Timestamp(timeLong));
+        }
+        payments.add(payment);
+
+        //物流代收都发 互联网医院顺丰
+        if (!("金牛明医".equals(cloudHostProper.getCompanyName()))) {
+            //由于积分商品的字段缺失，没有剩余金额，默认为0，固定走下面逻辑，注释掉if判断，删除else代码。
+//            if (order.getPayRemain().compareTo(new BigDecimal(0)) == 0) {
+                //没有物流代收
+                //大于100发发顺丰云配
+                if (order.getPayMoney().compareTo(new BigDecimal(100)) > 0) {
+                    //发互联网医院SF.0235488558_241101
+                    FsExpress express = expressService.selectFsExpressByOmsCode("SF.0235488558_241101");
+                    erpOrder.setExpress_code(express.getOmsCode());
+                    order.setDeliveryName(express.getName());
+                    order.setDeliveryCode(express.getCode());
+                } else {
+                    //发ztpdd
+                    FsExpress express = expressService.selectFsExpressByOmsCode("CDYJFYD.400011111705_241230");
+                    erpOrder.setExpress_code(express.getOmsCode());
+                    order.setDeliveryName(express.getName());
+                    order.setDeliveryCode(express.getCode());
+                }
+//            }
+        }
+
+        erpOrder.setPayments(payments);
+        if (order.getCompanyId() != null) {
+            Company company = companyService.selectCompanyById(order.getCompanyId());
+            if (company != null) {
+                erpOrder.setSeller_memo(company.getCompanyName());
+            }
+        }
+        if (order.getCompanyUserId() != null) {
+            CompanyUser companyUser = companyUserService.selectCompanyUserById(order.getCompanyUserId());
+            if (companyUser != null) {
+                CompanyDept dept = companyDeptService.selectCompanyDeptById(companyUser.getDeptId());
+                if (dept != null) {
+                    List<String> names = companyDeptService.selectCompanyDeptNamesByIds(dept.getAncestors());
+                    if (names != null && names.size() > 0) {
+                        //写备注
+                        erpOrder.setSeller_memo(erpOrder.getSeller_memo() + "-" + StringUtils.join(names, ",") + "," + dept.getDeptName());
+                    }
+                }
+                erpOrder.setSeller_memo(erpOrder.getSeller_memo() + "-" + companyUser.getNickName());
+            }
+        }
+        ErpRemarkDTO remarkDTO = new ErpRemarkDTO();
+        remarkDTO.setTotalPrice(BigDecimal.ZERO);//order.getTotalPrice()积分订单没有这个字段，写0
+        remarkDTO.setPayPrice(BigDecimal.ZERO);//order.getPayPrice()积分订单没有这个字段，写0
+        remarkDTO.setDeliveryMoney(BigDecimal.ZERO);//order.getPayDelivery()积分订单没有这个字段，写0
+        remarkDTO.setPayMoney(order.getPayMoney());
+        remarkDTO.setCouponMoney(BigDecimal.ZERO);//order.getDiscountMoney()积分订单没有这个字段，写0
+        remarkDTO.setOrderId(order.getOrderCode());
+        remarkDTO.setYdMoney(BigDecimal.ZERO);//order.getPayPrice().subtract(order.getPayMoney().subtract(order.getPayDelivery()))积分订单没有这个字段，写0
+        if (order.getPayTime() != null) {
+            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+            String format = sdf.format(Date.from((order.getPayTime().atZone(ZoneId.systemDefault()).toInstant())));
+            remarkDTO.setPayTime(format);
+        }
+        erpOrder.setSeller_memo(erpOrder.getSeller_memo() + JSONUtil.toJsonStr(remarkDTO));
+        erpOrder.setOrder_type_code("order");
+        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+        erpOrder.setDeal_datetime(sdf.format(new Date()));
+
+        FsStoreOrderItem itemMap = new FsStoreOrderItem();
+        itemMap.setOrderId(order.getOrderId());
+        String itemJson = order.getItemJson();
+        JSONArray jsonArray = JSON.parseArray(itemJson);
+        List<ErpOrderItem> details = new ArrayList<>();
+        jsonArray.forEach(obj -> {
+            JSONObject jsonObject = (JSONObject) obj;
+            ErpOrderItem item = new ErpOrderItem();
+            item.setOid(jsonObject.getString("goodsId"));
+            item.setItem_code(jsonObject.getString("barCode").trim());//商品编码
+            item.setPrice(jsonObject.getString("otPrice"));//市场价
+            item.setQty(jsonObject.getInteger("num"));//数量
+            item.setRefund(0);
+            details.add(item);
+        });
+        erpOrder.setDetails(details);
+        erpOrder.setReceiver_name(order.getUserName().replaceAll("[^\\u4e00-\\u9fa5a-zA-Z0-9]", ""));
+
+        //推送人电话查询，默认使用df表的erpphone
+
+        FsIntegralOrderDf integralDfAccount = integralOrderDfService.getBaseMapper().selectById(order.getOrderId());
+        String phone = null;
+        if (StringUtils.isNotBlank(integralDfAccount.getErpPhone())) {
+            phone = integralDfAccount.getErpPhone();
+        } else {
+            if (order.getUserPhone().length() > 11) {
+                phone = decryptPhone(order.getUserPhone());
+            } else {
+                phone = order.getUserPhone();
+            }
+        }
+        if (phone.length() > 11) {
+            erpOrder.setReceiver_phone(phone);
+        } else {
+            erpOrder.setReceiver_mobile(phone);
+        }
+        String[] address = order.getUserAddress().split(" ");
+        try{
+            if (address.length < 3) {
+                String kdnAddress = fsUserAddressService.getKdnAddress(order.getUserAddress());
+                Map<String, Object> addDAta = (Map<String, Object>) com.alibaba.fastjson.JSON.parse(kdnAddress);
+                Map<String, String> add = (Map<String, String>) addDAta.get("Data");
+                erpOrder.setReceiver_province(add.get("ProvinceName"));
+                erpOrder.setReceiver_city(add.get("CityName"));
+                erpOrder.setReceiver_district(add.get("ExpAreaName"));
+                erpOrder.setReceiver_address(add.get("StreetName") + add.get("Address"));
+            } else {
+                erpOrder.setReceiver_province(address[0]);
+                erpOrder.setReceiver_city(address[1]);
+                erpOrder.setReceiver_district(address[2]);
+                //处理地址多空隔问题
+                if (address.length > 3) {
+                    StringBuffer addrs = new StringBuffer();
+                    for (int i = 3; i < address.length; i++) {
+                        addrs.append(address[i]);
+                    }
+                    erpOrder.setReceiver_address(addrs.toString());
+                } else if (address.length == 3) {
+                    erpOrder.setReceiver_address(address[2]);
+                }
+            }
+        }catch (Exception e){
+            log.error("地址错误：{}",e);
+            throw new CustomException("地址格式不对请正确写入详细地址！！");
+        }
+        erpOrder.setReceiver_address(erpOrder.getReceiver_address().replace("+", "加"));
+        erpOrder.setReceiver_address(erpOrder.getReceiver_address().replace("\n", ""));
+        erpOrder.setIsIntegralOrder(true);
+
+        ErpOrderResponse response = erpOrderService.addOrder(erpOrder);
+        log.info("ErpCreate:" + order.getOrderCode() + ":" + JSONUtil.toJsonStr(response));
+//        if (Boolean.TRUE.equals(response.getSuccess())) {
+//            //支付成功后 将订单号写入待发货的REDIS中
+////            redisCache.setCacheObject("delivery" + ":" + response.getCode(), order.getOrderCode());
+//            //更新推送标识
+//            integralDfAccount.setIsPush(1);
+//            integralOrderDfService.getBaseMapper().updateById(integralDfAccount);
+//        }
+    }
+
+    @Override
+    public String importOrderStatusData(List<FsIntegralOrderExcelVO> list) {
+        if (StringUtils.isNull(list) || list.isEmpty()) {
+            throw new ServiceException("导入数据不能为空！");
+        }
+        int successNum = 0;
+        int failureNum = 0;
+        StringBuilder successMsg = new StringBuilder();
+        StringBuilder failureMsg = new StringBuilder();
+        for (FsIntegralOrderExcelVO vo : list) {
+            try {
+                //1.必填参数
+                ExcelUtils.validateRequiredFields(vo, list.indexOf(vo) + 1); // 传入行号
+
+                FsIntegralOrder order = fsIntegralOrderMapper.selectOne(Wrappers.<FsIntegralOrder>lambdaQuery().eq(FsIntegralOrder::getOrderCode, vo.getOrderCode()));
+                if (order ==null){
+                    failureNum++;
+                    String msg = "<br/>" + failureNum + "、订单编号 " + vo.getOrderCode() + " 导入失败：";
+                    failureMsg.append(msg).append("订单不存在");
+                    continue;
+                }
+                FsIntegralOrder param = new FsIntegralOrder(); //修改订单的参数
+                param.setOrderCode(vo.getOrderCode());
+                param.setOrderId(order.getOrderId());
+                if ("6".equals(vo.getStatus())) {
+                    failureNum++;
+                    String msg = "<br/>" + failureNum + "、订单编号 " + vo.getOrderCode() + " 导入失败：";
+                    failureMsg.append(msg).append("该状态不支持修改为待推送");
+                    continue;
+                }
+                if ("-1".equals(vo.getStatus())) {
+                    failureNum++;
+                    String msg = "<br/>" + failureNum + "、订单编号 " + vo.getOrderCode() + " 导入失败：";
+                    failureMsg.append(msg).append("该状态不支持修改为退款中，需要手动申请退款");
+                    continue;
+                }
+                if ("-2".equals(vo.getStatus())) {
+                    failureNum++;
+                    String msg = "<br/>" + failureNum + "、订单编号 " + vo.getOrderCode() + " 导入失败：";
+                    failureMsg.append(msg).append("该状态不支持修改为退款中，需要审核完成退款");
+                    continue;
+                }
+
+                Integer status = order.getStatus();
+
+                if (StringUtils.isNotBlank(vo.getStatus())){
+                    param.setStatus(Integer.valueOf(vo.getStatus()));
+                    status = Integer.valueOf(vo.getStatus());
+                }
+                /**
+                 * 地址和电话仅待推送可以修改,积分没有代付款的订单
+                 */
+                String userAddress = vo.getUserAddress();
+                String userPhone = vo.getUserPhone();
+                if (StringUtils.isNotBlank(userAddress) || StringUtils.isNotBlank(userPhone)){
+                    if (Objects.equals(FsStoreOrderStatusEnum.STATUS_6.getValue(), status)) {
+                        param.setUserAddress(userAddress.isEmpty()?null:userAddress);
+                        param.setUserPhone(userPhone.isEmpty()?null:userPhone);
+                    } else {
+                        failureNum++;
+                        String msg = "<br/>" + failureNum + "、订单编号 " + vo.getOrderCode() + " 修改失败：";
+                        failureMsg.append(msg).append("该状态不支持修改收货人地址或电话");
+                        continue;
+                    }
+                }
+                param.setDeliveryStatus((vo.getDeliveryStatus()==null|| vo.getDeliveryStatus().isEmpty())?null:Integer.valueOf(vo.getDeliveryStatus()));
+                param.setDeliveryType(vo.getDeliveryType().isEmpty()?null:vo.getDeliveryType());
+                param.setUpdateTime(DateUtils.getNowDate());
+
+                //修改订单金额
+//                BigDecimal payRemain = vo.getPayRemain();
+//                if (payRemain != null){
+//                    if (!payRemain.equals(order.getPayRemain())){
+//                        BigDecimal payMoney = order.getPayMoney(); //实收金额
+//                        param.setPayPrice(payMoney.add(payRemain)); //应收金额
+//                        param.setPayRemain(vo.getPayRemain());
+//                    }
+//                }
+                fsIntegralOrderMapper.updateById(param);
+
+                successNum++;
+                successMsg.append("<br/>").append(successNum).append("、订单编号 ").append(vo.getOrderCode()).append(" 修改成功");
+
+            } catch (Exception e) {
+
+                failureNum++;
+                String msg = "<br/>" + failureNum + "、订单编号 " + vo.getOrderCode() + " 修改失败：";
+                failureMsg.append(msg).append(e.getMessage());
+            }
+        }
+        if (failureNum > 0) {
+            failureMsg.insert(0, "很抱歉，导入失败！共 " + failureNum + " 条数据格式不正确，错误如下：");
+            throw new ServiceException(failureMsg.toString());
+        } else {
+            successMsg.insert(0, "恭喜您，数据已全部导入成功！共 " + successNum + " 条，数据如下：");
+        }
+        return successMsg.toString();
+    }
+
     /**
      * 处理手机号脱敏
      */

fs-service/src/main/java/com/fs/his/vo/FsIntegralOrderExcelVO.java

@@ -0,0 +1,32 @@
+package com.fs.his.vo;
+
+import com.fs.common.annotation.Excel;
+import lombok.Data;
+
+@Data
+public class FsIntegralOrderExcelVO {
+    @Excel(name = "药品订单号",required = true)
+    private String orderCode;
+
+    @Excel(name = "订单状态",dictType = "sys_integral_order_status")
+    private String status;
+
+//    @Excel(name = "物流代收金额")
+//    private BigDecimal payRemain;
+
+    /** 物流状态 */
+    @Excel(name = "物流状态",dictType = "sys_store_order_delivery_status")
+    private String deliveryStatus;
+
+    /** 物流跟踪状态 */
+    @Excel(name = "物流跟踪状态",dictType = "sys_delivery_type")
+    private String deliveryType;
+
+    /** shou */
+    @Excel(name = "收货人电话")
+    private String userPhone;
+    /** 详情地址 */
+    @Excel(name = "详情地址(例：广东省 韶关市 仁化县 亨特中心22楼)使用空格分割")
+    private String userAddress;
+
+}

fs-service/src/main/java/com/fs/his/vo/FsIntegralOrderListVO.java

@@ -2,8 +2,10 @@ package com.fs.his.vo;
 
 import com.fasterxml.jackson.annotation.JsonFormat;
 import com.fs.common.annotation.Excel;
+import com.fs.common.utils.BigDecimalUtil;
 import lombok.Data;
 
+import java.math.BigDecimal;
 import java.util.Date;
 
 @Data
@@ -76,4 +78,10 @@ public class FsIntegralOrderListVO {
      * 销售公司ID
      * **/
     private Long companyId;
+
+    private BigDecimal payMoney;
+
+    private String erpPhone;
+
+    private String loginAccount;
 }

fs-service/src/main/java/com/fs/his/vo/FsIntegralOrderPVO.java

@@ -3,6 +3,7 @@ package com.fs.his.vo;
 import com.fasterxml.jackson.annotation.JsonFormat;
 import com.fs.common.annotation.Excel;
 import com.fs.common.core.domain.BaseEntity;
+import com.fs.his.config.IntegralConfig;
 import lombok.Data;
 
 import java.util.Date;
@@ -76,4 +77,8 @@ public class FsIntegralOrderPVO extends BaseEntity
     private String phone;
 
     private String loginAccount;
+
+    private String deliveryType;
+
+    private Integer deliveryStatus;
 }

fs-service/src/main/resources/mapper/his/FsIntegralOrderDfMapper.xml

@@ -0,0 +1,127 @@
+<?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.fs.his.mapper.FsIntegralOrderDfMapper">
+
+    <resultMap type="FsIntegralOrderDf" id="FsIntegralOrderDfResult">
+        <result property="orderId"    column="order_id"    />
+        <result property="orderCode"    column="order_code"    />
+        <result property="appKey"    column="app_key"    />
+        <result property="appSecret"    column="app_secret"    />
+        <result property="loginAccount"    column="login_account"    />
+        <result property="monthlyCard"    column="monthly_card"    />
+        <result property="expressProductCode"    column="express_product_code"    />
+        <result property="totalPrice"    column="total_price"    />
+        <result property="platformPrice"    column="platform_price"    />
+        <result property="status"    column="status"    />
+        <result property="createTime"    column="create_time"    />
+        <result property="updateTime"    column="update_time"    />
+        <result property="failMsg"    column="fail_msg"    />
+        <result property="parcelQuantity"    column="parcel_quantity"    />
+        <result property="erpPhone"    column="erp_phone"    />
+        <result property="isPush"    column="is_push"    />
+    </resultMap>
+
+    <sql id="selectFsIntegralOrderDfVo">
+        select order_id, order_code, app_key, app_secret, login_account, monthly_card, express_product_code, total_price, platform_price, status, create_time, update_time, fail_msg, parcel_quantity, is_push from fs_integral_order_df
+    </sql>
+
+    <select id="selectFsIntegralOrderDfList" parameterType="FsIntegralOrderDf" resultMap="FsIntegralOrderDfResult">
+        <include refid="selectFsIntegralOrderDfVo"/>
+        <where>
+            <if test="orderCode != null  and orderCode != ''"> and order_code = #{orderCode}</if>
+            <if test="appKey != null  and appKey != ''"> and app_key = #{appKey}</if>
+            <if test="appSecret != null  and appSecret != ''"> and app_secret = #{appSecret}</if>
+            <if test="loginAccount != null  and loginAccount != ''"> and login_account = #{loginAccount}</if>
+            <if test="monthlyCard != null  and monthlyCard != ''"> and monthly_card = #{monthlyCard}</if>
+            <if test="expressProductCode != null  and expressProductCode != ''"> and express_product_code = #{expressProductCode}</if>
+            <if test="totalPrice != null "> and total_price = #{totalPrice}</if>
+            <if test="platformPrice != null "> and platform_price = #{platformPrice}</if>
+            <if test="status != null "> and status = #{status}</if>
+            <if test="failMsg != null  and failMsg != ''"> and fail_msg = #{failMsg}</if>
+            <if test="parcelQuantity != null "> and parcel_quantity = #{parcelQuantity}</if>
+        </where>
+    </select>
+
+    <select id="selectFsIntegralOrderDfByOrderId" parameterType="Long" resultMap="FsIntegralOrderDfResult">
+        <include refid="selectFsIntegralOrderDfVo"/>
+        where order_id = #{orderId}
+    </select>
+    <select id="selectByIsPush" resultType="com.fs.his.domain.FsIntegralOrderDf">
+        SELECT fiod.*
+        FROM fs_integral_order_df fiod
+                 INNER JOIN fs_integral_order fio ON fio.order_id = fiod.order_id
+        WHERE fiod.is_push = 1
+          AND fio.delivery_sn IS NULL
+    </select>
+
+    <insert id="insertFsIntegralOrderDf" parameterType="FsIntegralOrderDf">
+        insert into fs_integral_order_df
+        <trim prefix="(" suffix=")" suffixOverrides=",">
+            <if test="orderId != null">order_id,</if>
+            <if test="orderCode != null">order_code,</if>
+            <if test="appKey != null and appKey != ''">app_key,</if>
+            <if test="appSecret != null and appSecret != ''">app_secret,</if>
+            <if test="loginAccount != null and loginAccount != ''">login_account,</if>
+            <if test="monthlyCard != null and monthlyCard != ''">monthly_card,</if>
+            <if test="expressProductCode != null">express_product_code,</if>
+            <if test="totalPrice != null">total_price,</if>
+            <if test="platformPrice != null">platform_price,</if>
+            <if test="status != null">status,</if>
+            <if test="createTime != null">create_time,</if>
+            <if test="updateTime != null">update_time,</if>
+            <if test="failMsg != null">fail_msg,</if>
+            <if test="parcelQuantity != null">parcel_quantity,</if>
+            <if test="erpPhone != null">erp_phone,</if>
+        </trim>
+        <trim prefix="values (" suffix=")" suffixOverrides=",">
+            <if test="orderId != null">#{orderId},</if>
+            <if test="orderCode != null">#{orderCode},</if>
+            <if test="appKey != null and appKey != ''">#{appKey},</if>
+            <if test="appSecret != null and appSecret != ''">#{appSecret},</if>
+            <if test="loginAccount != null and loginAccount != ''">#{loginAccount},</if>
+            <if test="monthlyCard != null and monthlyCard != ''">#{monthlyCard},</if>
+            <if test="expressProductCode != null">#{expressProductCode},</if>
+            <if test="totalPrice != null">#{totalPrice},</if>
+            <if test="platformPrice != null">#{platformPrice},</if>
+            <if test="status != null">#{status},</if>
+            <if test="createTime != null">#{createTime},</if>
+            <if test="updateTime != null">#{updateTime},</if>
+            <if test="failMsg != null">#{failMsg},</if>
+            <if test="parcelQuantity != null">#{parcelQuantity},</if>
+            <if test="erpPhone != null">#{erpPhone},</if>
+        </trim>
+    </insert>
+
+    <update id="updateFsIntegralOrderDf" parameterType="FsIntegralOrderDf">
+        update fs_integral_order_df
+        <trim prefix="SET" suffixOverrides=",">
+            <if test="orderCode != null">order_code = #{orderCode},</if>
+            <if test="appKey != null and appKey != ''">app_key = #{appKey},</if>
+            <if test="appSecret != null and appSecret != ''">app_secret = #{appSecret},</if>
+            <if test="loginAccount != null and loginAccount != ''">login_account = #{loginAccount},</if>
+            <if test="monthlyCard != null and monthlyCard != ''">monthly_card = #{monthlyCard},</if>
+            <if test="expressProductCode != null">express_product_code = #{expressProductCode},</if>
+            <if test="totalPrice != null">total_price = #{totalPrice},</if>
+            <if test="platformPrice != null">platform_price = #{platformPrice},</if>
+            <if test="status != null">status = #{status},</if>
+            <if test="createTime != null">create_time = #{createTime},</if>
+            <if test="updateTime != null">update_time = #{updateTime},</if>
+            <if test="failMsg != null">fail_msg = #{failMsg},</if>
+            <if test="parcelQuantity != null">parcel_quantity = #{parcelQuantity},</if>
+        </trim>
+        where order_id = #{orderId}
+    </update>
+
+    <delete id="deleteFsIntegralOrderDfByOrderId" parameterType="Long">
+        delete from fs_integral_order_df where order_id = #{orderId}
+    </delete>
+
+    <delete id="deleteFsIntegralOrderDfByOrderIds" parameterType="String">
+        delete from fs_integral_order_df where order_id in
+        <foreach item="orderId" collection="array" open="(" separator="," close=")">
+            #{orderId}
+        </foreach>
+    </delete>
+</mapper>

fs-service/src/main/resources/mapper/his/FsIntegralOrderMapper.xml

@@ -56,6 +56,80 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
         <include refid="selectFsIntegralOrderVo"/>
         where order_id = #{orderId}
     </select>
+    <select id="findOrderByIds" resultType="com.fs.his.domain.FsIntegralOrder">
+        SELECT * FROM fs_integral_order
+        WHERE order_id IN
+        <foreach collection="orderIds" item="orderId" open="(" close=")" separator=",">
+            #{orderId}
+        </foreach>
+    </select>
+    <select id="selectFsIntegralOrderListJn" resultType="com.fs.his.vo.FsIntegralOrderListVO">
+        SELECT
+        fio.order_id,
+        fio.order_code,
+        fio.user_id,
+        fio.user_name,
+        fio.user_phone,
+        fio.user_address,
+        fio.item_json,
+        fio.integral,
+        fio.pay_money,
+        fio.is_pay,
+        fio.pay_time,
+        fio.pay_type,
+        fio.`STATUS`,
+        fio.delivery_code,
+        fio.delivery_name,
+        fio.delivery_sn,
+        fio.delivery_time,
+        fio.create_time,
+        fio.qw_user_id,
+        fio.company_user_id,
+        fio.company_id,
+        fio.remark,
+        fio.login_account,
+        fiod.erp_phone
+        FROM
+        fs_integral_order fio
+        LEFT JOIN fs_integral_order_df fiod
+        ON fiod.order_id = fio.order_id
+        WHERE
+        1 = 1
+        <!-- 订单编码精确查询 -->
+        <if test="orderCode != null and orderCode != ''"> AND fio.order_code = #{orderCode} </if>
+        <!-- 用户名模糊查询 -->
+        <if test="userName != null and userName != ''"> AND fio.user_name LIKE CONCAT('%', #{userName}, '%') </if>
+        <!-- 用户手机号精确查询 -->
+        <if test="userPhone != null and userPhone != ''"> AND fio.user_phone = #{userPhone} </if>
+        <!-- 积分精确查询 -->
+        <if test="integral != null and integral != ''"> AND fio.integral = #{integral} </if>
+        <!-- 支付金额精确查询 -->
+        <if test="payMoney != null and payMoney != ''"> AND fio.pay_money = #{payMoney} </if>
+        <!-- 支付状态精确查询 -->
+        <if test="isPay != null and isPay != ''"> AND fio.is_pay = #{isPay} </if>
+        <!-- 支付时间精确查询 -->
+        <if test="payTime != null and payTime != ''"> AND fio.pay_time = #{payTime} </if>
+        <!-- 支付类型精确查询 -->
+        <if test="payType != null and payType != ''"> AND fio.pay_type = #{payType} </if>
+        <!-- 订单状态精确查询 -->
+        <if test="status != null and status != ''"> AND fio.status = #{status} </if>
+        <!-- 快递单号模糊查询 -->
+        <if test="deliverySn != null and deliverySn != ''"> AND fio.delivery_sn LIKE CONCAT('%', #{deliverySn}, '%') </if>
+        <!-- 企微用户ID精确查询 -->
+        <if test="qwUserId != null and qwUserId != ''"> AND fio.qw_user_id = #{qwUserId} </if>
+        <!-- 公司用户ID精确查询 -->
+        <if test="companyUserId != null and companyUserId != ''"> AND fio.company_user_id = #{companyUserId} </if>
+        <!-- 公司ID精确查询 -->
+        <if test="companyId != null and companyId != ''"> AND fio.company_id = #{companyId} </if>
+        <!-- 创建时间范围查询（开始时间） -->
+        <if test="sTime != null"> AND DATE(fio.create_time) &gt;= DATE(#{sTime}) </if>
+        <!-- 创建时间范围查询（结束时间） -->
+        <if test="eTime != null"> AND DATE(fio.create_time) &lt;= DATE(#{eTime}) </if>
+        <if test="loginAccount != null and loginAccount !=''"> AND fio.login_account = #{loginAccount} </if>
+        <if test="isPush != null"> AND COALESCE(fiod.is_push, 0) = 0 </if>
+        ORDER BY
+        fio.order_id DESC
+    </select>
 
     <insert id="insertFsIntegralOrder" parameterType="FsIntegralOrder" useGeneratedKeys="true" keyProperty="orderId">
         insert into fs_integral_order