供应商给机构下单

src/main/java/com/caimei365/order/components/ProductService.java

@@ -304,6 +304,107 @@ public class ProductService {
         return postageMap;
     }
 
+    /**
+     * 计算运费
+     *
+     * @param cityId    地区市Id
+     * @param num       购买数量
+     * @param amount    购买商品金额
+     * @param skuIdList 商品Id列表
+     */
+    public Map<String, Object> computeShopPostage(Integer cityId, Integer num, Double amount, List<String> skuIdList) {
+        // 用户组织Id
+        Integer organizeId = 4;
+        // 返回数据初始化
+        Map<String, Object> postageMap = new HashMap<>(5);
+        // 运费标志：0包邮 1到付 2使用运费模板
+        int postageFlag = 0;
+        // 运费
+        AtomicDouble postage = new AtomicDouble(0);
+        // 获取商品运费 （商品数据库 0包邮 2默认（遵循运费模板） 2到付 ）
+        List<ProductPostageVo> postageFlagList = null;
+        if (0 == organizeId) {
+            postageFlagList = baseMapper.getPostageFlagList(skuIdList);
+        } else {
+            postageFlagList = baseMapper.getPostageFlagOrganizeList(skuIdList);
+        }
+        List<Integer> commodityTypeList = null;
+        if (null != postageFlagList && postageFlagList.size() > 0) {
+            commodityTypeList = postageFlagList.stream().map(ProductPostageVo::getCommodityType).collect(Collectors.toList());
+            for (ProductPostageVo postageVo : postageFlagList) {
+                if (null != postageVo) {
+                    // 设置了运费到付
+                    if ((null != postageVo.getPostageFlag() && 2 == postageVo.getPostageFlag())) {
+                        // 到付
+                        postageFlag = 2;
+                    } else if (null != postageVo.getPostageFlag() && 0 == postageVo.getPostageFlag()) {
+                        // 包邮
+                        postageFlag = 0;
+                    } else {
+                        // 使用运费模板
+                        postageFlag = 1;
+                        if (null == postageVo.getFreightTemplateId()) {
+                            // 商品运费规则异常
+                            postageMap.put("postageFlag", 999);
+                            return postageMap;
+                        } else {
+                            Integer freightTemplate = baseMapper.getFreightTemplate(postageVo.getFreightTemplateId());
+                            if (null == freightTemplate) {
+                                // 商品运费规则异常
+                                postageMap.put("postageFlag", 999);
+                                return postageMap;
+                            }
+                            FreightRuleVo freightRule = baseMapper.getFreightRule(postageVo.getFreightTemplateId(), cityId);
+                            if (null != freightRule) {
+                                postage.set(MathUtil.add(postage.get(), freightRule.getFreightAmount()).doubleValue());
+                                // 含有包邮的规则
+                                if (1 == freightRule.getFreeType()) {
+                                    if (0 == freightRule.getFreeCondition()) {
+                                        // 满足数量 包邮
+                                        if (num >= freightRule.getProductNum()) {
+                                            postage.set(MathUtil.sub(postage.get(), 0).doubleValue());
+                                            postageFlag = 0;
+                                        }
+                                    } else {
+                                        // 满足金额 包邮
+                                        if (amount >= freightRule.getAllAmount()) {
+                                            postage.set(MathUtil.sub(postage.get(), 0).doubleValue());
+                                            postageFlag = 0;
+                                        }
+                                    }
+                                }
+                            } else {
+                                // 未选择地区包邮
+                                postageFlag = 0;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        // 商品包邮
+        if (0 == postageFlag) {
+            // 包邮
+            postage.set(0d);
+        }
+        // 偏远地区 获取地址的 省地址
+        Integer province = baseMapper.getProvince(cityId);
+        // 是否首单（统计订单数）
+        Integer count = -1;
+        // 首单包邮条件：首单 且 不包含仪器 且不包含偏远地区
+        boolean freeFlag = ((null != count && count == 0) && (null != commodityTypeList && !commodityTypeList.contains(2))
+                && (null != province && !provinceList.contains(province)));
+        if (freeFlag) {
+            // 包邮
+            postageFlag = 0;
+            postage.set(0d);
+
+        }
+        postageMap.put("postageFlag", postageFlag);
+        postageMap.put("postage", postage.get());
+        return postageMap;
+    }
+
     /**
      * 更新复购价格库
      *

src/main/java/com/caimei365/order/controller/OrderClubApi.java

@@ -365,4 +365,45 @@ public class OrderClubApi {
         }
         return orderClubService.getShopBankAccount(shopId);
     }
+
+    /**
+     * 分享订单，校验分享码
+     */
+    @ApiOperation("分享订单，校验分享码; 供应商给机构下单分享校验")
+    @ApiImplicitParams({
+            @ApiImplicitParam(required = true, name = "shopOrderId", value = "子订单Id"),
+            @ApiImplicitParam(required = true, name = "shareCode", value = "分享码")
+    })
+    @GetMapping("/shop/code/check")
+    public ResponseJson<Map<String, Object>> checkShopOrderCode(Integer shopOrderId, String shareCode) {
+        if (null == shopOrderId) {
+            return ResponseJson.error(-1, "订单Id不能为空！", null);
+        }
+        if (StringUtils.isEmpty(shareCode)) {
+            return ResponseJson.error(-1, "分享码不能为空！", null);
+        }
+        return orderClubService.checkShopOrderCode(shopOrderId, shareCode);
+    }
+
+    /**
+     * 机构确认订单
+     * @param shopOrderId
+     * @param userId
+     * @return
+     */
+    @ApiOperation("机构确认订单 -- 供应商给机构下单")
+    @ApiImplicitParams({
+            @ApiImplicitParam(required = true, name = "shopOrderId", value = "子订单Id"),
+            @ApiImplicitParam(required = true, name = "userId", value = "用户Id")
+    })
+    @GetMapping("/confirmShopOrder")
+    public ResponseJson<Map<String, Object>> confirmShopOrder(Integer shopOrderId, Integer userId) {
+        if (null == shopOrderId) {
+            return ResponseJson.error(-1, "子订单Id不能为空", null);
+        }
+        if (null == userId) {
+            return ResponseJson.error(-1, "用户Id不能为空", null);
+        }
+        return null;
+    }
 }

src/main/java/com/caimei365/order/controller/OrderSubmitApi.java

@@ -161,4 +161,29 @@ public class OrderSubmitApi {
         return submitService.updateOrder(orderProducts.getOrderProducts());
     }
 
+    /**
+     * 供应商给机构下单
+     * @param submitDto
+     * @return
+     */
+    @ApiOperation("供应商给机构下单")
+    @PostMapping("/shopGenerateOrder")
+    public ResponseJson shopGenerateOrder(@RequestBody SubmitDto submitDto) {
+        if (null == submitDto.getCartType()) {
+            return ResponseJson.error("购买类型不能为空！", null);
+        }
+        if (null == submitDto.getAddressId()) {
+            return ResponseJson.error("收货地址Id不能为空！", null);
+        }
+        if (StringUtils.isEmpty(submitDto.getOrderInfo())) {
+            return ResponseJson.error("订单商品数据不能为空！", null);
+        }
+        if (StringUtils.isEmpty(submitDto.getPayInfo())) {
+            return ResponseJson.error("订单金额数据不能为空！", null);
+        }
+        if (StringUtils.isEmpty(submitDto.getOrderInvoice())) {
+            return ResponseJson.error("发票信息数据不能为空！", null);
+        }
+        return submitService.shopGenerateOrder(submitDto);
+    }
 }

src/main/java/com/caimei365/order/controller/ShipApi.java

@@ -49,18 +49,19 @@ public class ShipApi {
             @ApiImplicitParam(required = false, name = "refundStatus", value = "退款状态"),
             @ApiImplicitParam(required = false, name = "receiptStatus", value = "收款状态"),
             @ApiImplicitParam(required = false, name = "organizeId", value = "订单来源"),
+            @ApiImplicitParam(required = false, name = "orderStatus", value = "订单类型"),
             @ApiImplicitParam(required = false, name = "pageNum", value = "页码"),
             @ApiImplicitParam(required = false, name = "pageSize", value = "每页数量")
     })
     @GetMapping("/list")
-    public ResponseJson<PageInfo<ShopOrderVo>> getShopOrderList(Integer shopId, Integer sendOutStatus, Integer payStatus,
-                                                                String shopOrderNo, String receiver, Integer refundStatus, Integer receiptStatus, Integer organizeId,
+    public ResponseJson<PageInfo<ShopOrderVo>> getShopOrderList(Integer shopId, Integer sendOutStatus, Integer payStatus, String shopOrderNo,
+                                                                String receiver, Integer refundStatus, Integer receiptStatus, Integer organizeId, Integer orderStatus,
                                                                 @RequestParam(value = "pageNum", defaultValue = "1") int pageNum,
                                                                 @RequestParam(value = "pageSize", defaultValue = "10") int pageSize) {
         if (null == shopId) {
             return ResponseJson.error("供应商Id不能为空！", null);
         }
-        return shipService.getShopOrderList(shopId, sendOutStatus, payStatus, shopOrderNo, receiver, refundStatus, receiptStatus, organizeId, pageNum, pageSize);
+        return shipService.getShopOrderList(shopId, sendOutStatus, payStatus, shopOrderNo, receiver, refundStatus, receiptStatus, organizeId, orderStatus, pageNum, pageSize);
     }
 
     /**
@@ -460,4 +461,27 @@ public class ShipApi {
     public void downFile(Integer fileId, HttpServletRequest request, HttpServletResponse response) throws IOException {
         shipService.downFile(fileId, request, response);
     }
+
+    /**
+     * 供应商给机构下单 结算--联合丽格
+     * @param shopId
+     * @param skuIds
+     * @return
+     */
+    @ApiOperation("供应商给机构下单 结算--联合丽格")
+    @ApiImplicitParams({
+            @ApiImplicitParam(required = false, name = "shopId", value = "供应商Id"),
+            @ApiImplicitParam(required = false, name = "cityId", value = "地址"),
+            @ApiImplicitParam(required = false, name = "skuIds", value = "skuIds,逗号隔开"),
+    })
+    @GetMapping("/settlement")
+    public ResponseJson<Map<String, Object>> settlementShop(Integer shopId, Integer cityId, String skuIds){
+        if (null == shopId) {
+            return ResponseJson.error("供应商Id不能为空！", null);
+        }
+        if (StringUtils.isEmpty(skuIds)) {
+            return ResponseJson.error("skuId集合不能为空！", null);
+        }
+        return shipService.settlementShop(shopId, cityId, skuIds);
+    }
 }

src/main/java/com/caimei365/order/mapper/OrderClubMapper.java

@@ -497,4 +497,28 @@ public interface OrderClubMapper {
      * @return
      */
     ShopPo getShopCmBankAccount(@Param("shopId") Integer shopId);
+
+    /**
+     * 根据用户 id 获取机构id
+     * @param userId
+     * @return
+     */
+    Integer getClubByUserId(@Param("userId") Integer userId);
+    /**
+     * 根据子订单Id查询子订单信息
+     * @param shopOrderId
+     * @return
+     */
+    ShopOrderVo getShopOrderInfo(@Param("shopOrderId") Integer shopOrderId);
+
+    /**
+     * 确认订单、关联用户
+     * @param shopOrderVo
+     */
+    void updateShopOrderById(ShopOrderVo shopOrderVo);
+
+    /**
+     * 填充订单收货地址用户信息
+     */
+    void updateOrderUserInfoById(OrderUserinfoVo orderUserinfoVo);
 }

src/main/java/com/caimei365/order/mapper/ShipMapper.java

@@ -21,7 +21,7 @@ public interface ShipMapper {
     /**
      * 机构订单列表
      */
-    List<ShopOrderVo> getShopOrderList(Integer shopId, Integer sendOutStatus, Integer payStatus, String shopOrderNo, String receiver, Integer refundStatus, Integer receiptStatus, Integer organizeId);
+    List<ShopOrderVo> getShopOrderList(Integer shopId, Integer sendOutStatus, Integer payStatus, String shopOrderNo, String receiver, Integer refundStatus, Integer receiptStatus, Integer organizeId, Integer orderStatus);
     /**
      * 供应商结算列表
      */
@@ -303,4 +303,21 @@ public interface ShipMapper {
      * @param o
      */
     void insertFile(OssFileDto o);
+
+    /**
+     * 据供应商Id获取供应商
+     * @param shopId
+     * @return
+     */
+    CartShopVo getCartShopsByShopId(@Param("shopId")  Integer shopId);
+
+    /**
+     * 商品信息
+     * @param shopId
+     * @param organizeId
+     * @param skuIds
+     * @param splitCode
+     * @return
+     */
+    List<CartItemVo> getProductsOrganize(@Param("shopId")  Integer shopId,@Param("organizeId") Integer organizeId, @Param("skuIds") List<String> skuIds,@Param("splitCode")String splitCode);
 }

src/main/java/com/caimei365/order/model/po/OrderPo.java

@@ -30,7 +30,7 @@ public class OrderPo implements Serializable {
      */
     private Integer organizeId;
     /**
-     * 订单来源：1WWW、2CRM、4客服[适用后台下单]、5外单[适用后台下单]、6小程序[采美,星范]、7呵呵商城小程序、8维沙小程序
+     * 订单来源：1WWW、2CRM、4客服[适用后台下单]、5外单[适用后台下单]、6小程序[采美,星范]、7呵呵商城小程序、8维沙小程序、9联合丽格
      */
     private Integer orderSource;
     /**

src/main/java/com/caimei365/order/service/OrderClubService.java

@@ -148,4 +148,18 @@ public interface OrderClubService {
      */
     ResponseJson<ShopPo> getShopBankAccount(Integer shopId);
 
+    /**
+     * 分享订单，校验分享码
+     * @param shopOrderId 订单Id
+     * @param shareCode 分享码
+     */
+    ResponseJson<Map<String, Object>> checkShopOrderCode(Integer shopOrderId, String shareCode);
+
+    /**
+     * 机构确认订单 -- 供应商给机构下单
+     * @param shopOrderId
+     * @param userId
+     * @return
+     */
+    ResponseJson<Map<String, Object>> confirmShopOrder(Integer shopOrderId, Integer userId);
 }

src/main/java/com/caimei365/order/service/ShipService.java

@@ -30,7 +30,7 @@ public interface ShipService {
      * @param pageNum        页码
      * @param pageSize       每页数量
      */
-    ResponseJson<PageInfo<ShopOrderVo>> getShopOrderList(Integer shopId, Integer sendOutStatus, Integer payStatus, String shopOrderNo, String receiver, Integer refundStatus, Integer receiptStatus, Integer organizeId, int pageNum, int pageSize);
+    ResponseJson<PageInfo<ShopOrderVo>> getShopOrderList(Integer shopId, Integer sendOutStatus, Integer payStatus, String shopOrderNo, String receiver, Integer refundStatus, Integer receiptStatus, Integer organizeId, Integer orderStatus, int pageNum, int pageSize);
     /**
      * 供应商结算列表
      * @param shopId         供应商Id
@@ -207,4 +207,12 @@ public interface ShipService {
      * @throws IOException
      */
     void downFile(Integer fileId, HttpServletRequest request, HttpServletResponse response) throws IOException;
+
+    /**
+     * 供应商给机构下单 结算--联合丽格
+     * @param shopId
+     * @param skuIds
+     * @return
+     */
+    ResponseJson<Map<String, Object>> settlementShop(Integer shopId, Integer cityId, String skuIds);
 }

src/main/java/com/caimei365/order/service/SubmitService.java

@@ -34,4 +34,11 @@ public interface SubmitService {
     ResponseJson<Map<String, Object>> generateRechargeOrder(RechargeDto rechargeDto);
 
     ResponseJson updateOrder(List<OrderProductVo> orderProducts);
+
+    /**
+     * 生成订单 --- 供应商帮机构下单
+     * @param submitDto
+     * @return
+     */
+    ResponseJson<Map<String, Object>> shopGenerateOrder(SubmitDto submitDto);
 }

src/main/java/com/caimei365/order/service/impl/OrderClubServiceImpl.java

@@ -912,10 +912,10 @@ public class OrderClubServiceImpl implements OrderClubService {
         ShopOrderVo shopOrder = orderClubMapper.getShopOrderById(shopOrderId);
         // 生成分享码
         String shareCode = RandomStringUtils.random(4, false, true);
-        // 过期时间
+        // 过期时间 有效时间72小时
         Calendar calendar = Calendar.getInstance();
         calendar.setTime(new Date());
-        calendar.add(Calendar.DATE, 1);
+        calendar.add(Calendar.DATE, 3);
         // 获取数据库已有分享码
         OrderShareCodeVo orderCodeVo = orderClubMapper.getShopOrderCodeById(shopOrderId);
         if (orderCodeVo != null && orderCodeVo.getExpiredTime().compareTo(new Date()) >= 0) {
@@ -1162,4 +1162,114 @@ public class OrderClubServiceImpl implements OrderClubService {
         return ResponseJson.success(shop);
     }
 
+    /**
+     * 分享订单，校验分享码
+     *
+     * @param shopOrderId   订单Id
+     * @param shareCode     分享码
+     */
+    @Override
+    public ResponseJson<Map<String, Object>> checkShopOrderCode(Integer shopOrderId, String shareCode) {
+
+        int shopOrderCount = orderClubMapper.countMainShopOrderByOrderId(shopOrderId);
+        if (0 == shopOrderCount) {
+            return ResponseJson.error("订单不存在！", null);
+        }
+        // 根据订单Id获取分享码
+        OrderShareCodeVo orderCodeVo = orderClubMapper.getShopOrderCodeById(shopOrderId);
+        if (null == orderCodeVo) {
+            return ResponseJson.error("该订单没有生成分享码！", null);
+        }
+        // 校验分享码
+        if (orderCodeVo.getShareCode().equals(shareCode)) {
+            if (orderCodeVo.getExpiredTime().compareTo(new Date()) > 0) {
+                // 返回
+                ShopOrderVo shopOrder = orderClubMapper.getShopOrderById(shopOrderId);
+                if (null == shopOrder) {
+                    return ResponseJson.error("该订单不存在！", null);
+                }
+                shopOrder.setOrderMark("#" + shopOrder.getShopOrderId() + "#");
+                // 设置订单状态
+                orderCommonService.setShopOrderStatus(shopOrder);
+                // 设置子订单信息
+                orderCommonService.setShopOrderInfo(shopOrder);
+                // 设置子订单付款金额
+                orderCommonService.getDiscernReceiptAndSetShoporder(shopOrder);
+                // 子订单列表
+                AtomicDouble expensesOfTaxation = new AtomicDouble(0d);
+                List<OrderProductVo> orderProductList = shopOrder.getOrderProductList();
+                orderProductList.forEach(orderProduct -> {
+
+                    // 总税费
+                    expensesOfTaxation.set(MathUtil.add(expensesOfTaxation.get(), orderProduct.getTotalAddedValueTax()).doubleValue());
+                    //判断商品价格是否含税
+                    boolean taxFlag = (Integer.valueOf(1).equals(orderProduct.getIncludedTax()) || (Integer.valueOf(0).equals(orderProduct.getIncludedTax()) && (Integer.valueOf(1).equals(orderProduct.getInvoiceType()) || Integer.valueOf(2).equals(orderProduct.getInvoiceType()))));
+                    if (taxFlag) {
+                        orderProduct.setIncludedTaxFlag(2);
+                    } else if (Integer.valueOf(0).equals(orderProduct.getIncludedTax()) && Integer.valueOf(3).equals(orderProduct.getInvoiceType())) {
+                        orderProduct.setIncludedTaxFlag(1);
+                    } else {
+                        orderProduct.setIncludedTaxFlag(3);
+                    }
+                });
+                // 收货地址
+                OrderUserinfoVo userInfo = addressMapper.getOrderUserinfo(shopOrder.getOrderId());
+                // 发票信息
+                InvoiceVo invoice = null;
+                if (null != shopOrder.getInvoiceFlag() && shopOrder.getInvoiceFlag() > 0) {
+                    invoice = orderCommonMapper.getOrderInvoice(shopOrder.getOrderId());
+                }
+                Map<String, Object> map = new HashMap<>();
+                map.put("shopOrder", shopOrder);
+                map.put("orderInvoice", invoice);
+                map.put("userInfo", userInfo);
+                return ResponseJson.success(map);
+            } else {
+                // 分享码过期
+                return ResponseJson.error("分享码已过期，请联系分享人更新分享码！", null);
+            }
+        } else {
+            return ResponseJson.error("分享码错误！", null);
+        }
+    }
+
+    /**
+     * 机构确认订单 -- 供应商给机构下单
+     *
+     * @param shopOrderId
+     * @param userId
+     * @return
+     */
+    @Override
+    public ResponseJson<Map<String, Object>> confirmShopOrder(Integer shopOrderId, Integer userId) {
+        int shopOrderCount = orderClubMapper.countMainShopOrderByOrderId(shopOrderId);
+        if (0 == shopOrderCount) {
+            return ResponseJson.error("订单不存在！", null);
+        }
+        // 用户信息
+        Integer clubId = orderClubMapper.getClubByUserId(userId);
+        if (null == clubId) {
+            return ResponseJson.error(-1, "该用户暂未注册成为机构", null);
+        }
+        // 子订单信息
+        ShopOrderVo shopOrderInfo = orderClubMapper.getShopOrderInfo(shopOrderId);
+        // 将订单归属到改机构名下 进入系统正常流程
+        shopOrderInfo.setUserId(userId);
+        shopOrderInfo.setClubId(clubId);
+        // 订单状态 已确认
+        shopOrderInfo.setStatus(1);
+        // 修改子订单
+        orderClubMapper.updateShopOrderById(shopOrderInfo);
+        // 修改订单地址用户信息
+        // 收货地址
+        OrderUserinfoVo userInfo = addressMapper.getOrderUserinfo(shopOrderInfo.getOrderId());
+        userInfo.setUserId(userId);
+        userInfo.setClubId(clubId);
+        orderClubMapper.updateOrderUserInfoById(userInfo);
+
+        Map<String, Object> map = new HashMap<>();
+        map.put("mag", "确认订单成功");
+        return ResponseJson.success(map);
+    }
+
 }

src/main/java/com/caimei365/order/service/impl/ShipServiceImpl.java

@@ -4,6 +4,7 @@ import com.alibaba.fastjson.JSONArray;
 import com.alibaba.fastjson.JSONObject;
 import com.caimei365.order.components.OrderCommonService;
 import com.caimei365.order.components.OssService;
+import com.caimei365.order.components.ProductService;
 import com.caimei365.order.components.WeChatService;
 import com.caimei365.order.mapper.*;
 import com.caimei365.order.model.ResponseJson;
@@ -36,9 +37,13 @@ import javax.servlet.http.HttpServletResponse;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
+import java.math.BigDecimal;
 import java.text.SimpleDateFormat;
 import java.util.*;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import static com.alibaba.fastjson.JSON.parseArray;
 
@@ -68,6 +73,8 @@ public class ShipServiceImpl implements ShipService {
     @Resource
     private RemoteCallService remoteCallService;
     @Resource
+    private ProductService productService;
+    @Resource
     private OssService ossService;
     @Resource
     private OSSUtils ossUtils;
@@ -87,10 +94,10 @@ public class ShipServiceImpl implements ShipService {
      * @param pageSize      每页数量
      */
     @Override
-    public ResponseJson<PageInfo<ShopOrderVo>> getShopOrderList(Integer shopId, Integer sendOutStatus, Integer payStatus, String shopOrderNo, String receiver, Integer refundStatus, Integer receiptStatus, Integer organizeId, int pageNum, int pageSize) {
+    public ResponseJson<PageInfo<ShopOrderVo>> getShopOrderList(Integer shopId, Integer sendOutStatus, Integer payStatus, String shopOrderNo, String receiver, Integer refundStatus, Integer receiptStatus, Integer organizeId, Integer orderStatus, int pageNum, int pageSize) {
         // 分页请求数据
         PageHelper.startPage(pageNum, pageSize);
-        List<ShopOrderVo> shopOrderList = shipMapper.getShopOrderList(shopId, sendOutStatus, payStatus, shopOrderNo, receiver, refundStatus, receiptStatus, organizeId);
+        List<ShopOrderVo> shopOrderList = shipMapper.getShopOrderList(shopId, sendOutStatus, payStatus, shopOrderNo, receiver, refundStatus, receiptStatus, organizeId, orderStatus);
         shopOrderList.forEach(shopOrder -> {
             if (null != shopOrder) {
                 setShopOrderInfo(shopOrder);
@@ -1344,4 +1351,219 @@ public class ShipServiceImpl implements ShipService {
             ossService.download(request, response, fileName);
         }
     }
+
+    /**
+     * 供应商给机构下单 结算--联合丽格
+     *
+     * @param shopId
+     * @param skuIds
+     * @return
+     */
+    @Override
+    public ResponseJson<Map<String, Object>> settlementShop(Integer shopId, Integer cityId, String skuIds) {
+        // 用户组织Id
+        Integer organizeId = 4;
+        log.info("￥￥￥￥￥￥￥￥￥￥ > 商品结算");
+        // 商品种类
+        AtomicInteger kindCount = new AtomicInteger(0);
+        // 商品总数量
+        AtomicInteger totalCount = new AtomicInteger(0);
+        // 统计商品总金额
+        AtomicDouble totalPrice = new AtomicDouble(0);
+        // 统计总促销满减
+        AtomicDouble reducedPrice = new AtomicDouble(0);
+        // 统计总超级会员优惠
+        AtomicDouble svipReducedPrice = new AtomicDouble(0);
+        // 统计总划线价
+        AtomicDouble totalOriginalPrice = new AtomicDouble(0);
+        // 促销活动（总）
+        List<PromotionsVo> totalPromotions = new ArrayList<>();
+        // 是否包含充值商品，默认false
+        AtomicBoolean includeRecharge = new AtomicBoolean(false);
+        //所有的商品数据
+        List<CartItemVo> totalProductList = new ArrayList<>();
+        // 促销活动Id集合，用于合并促销活动
+        List<Integer> promotionsIds = new ArrayList<>();
+        // 供应商Id集合，用户判断赠品供应商是否在当前供应商中
+        List<Integer> shopIds = new ArrayList<>();
+        // 运费模板是否异常
+        AtomicInteger templateFlag = new AtomicInteger(0);
+
+        // 前端接收商品Id信息
+        List<String> skuIdList = new ArrayList<>();
+        if (skuIds.contains(",")) {
+            skuIdList = Stream.of(skuIds.split(",")).collect(Collectors.toList());
+        } else {
+            skuIdList.add(skuIds);
+        }
+
+        // 购物车商品的分帐号分组的供应商列表
+        // 1带分账号，2不带
+        CartShopVo shop = shipMapper.getCartShopsByShopId(shopId);
+        String helpContent = null;
+        boolean flag = false;
+        if (null != shop) {
+            // 遍历供应商列表
+            List<String> finalIdList = skuIdList;//购物车商品skuId列表
+            if (null != shop) {
+                // 该供应商下商品种类
+                AtomicInteger shopKindCount = new AtomicInteger(0);
+                // 该供应商总价
+                AtomicDouble shopPrice = new AtomicDouble(0);
+                // 该供应商下参与店铺促销的商品总价
+                AtomicDouble shopPromotionFee = new AtomicDouble(0);
+                // 该供应商满减金额（供应商满减，单品满减）
+                AtomicDouble shopReducedPrice = new AtomicDouble(0);
+                // 该供应商svip优惠金额
+                AtomicDouble shopSvipReducedPrice = new AtomicDouble(0);
+                // 该供应商划线价
+                AtomicDouble shopOriginalPrice = new AtomicDouble(0);
+                // 运费方式 0 包邮 1 到付 2 运费模板
+                List<Integer> shopPostageFlag = new ArrayList<>();
+                // 运费
+                AtomicDouble shopPostage = new AtomicDouble(0);
+
+                // 供应商下商品列表
+                // 过滤保存已上架商品
+                List<CartItemVo> productList = shipMapper.getProductsOrganize(shop.getShopId(), organizeId, finalIdList, shop.getSplitCode());
+                if (null != productList && productList.size() > 0) {
+
+                    // 是否包含需要冷链运输商品
+                    List<Integer> collect = productList.stream().map(CartItemVo::getProductId).collect(Collectors.toList());
+                    if (collect.stream().allMatch(c -> c == 7881)) {
+                        shop.setDesignatedFlag(1);
+                    } else if (!collect.contains(7881)) {
+                        shop.setDesignatedFlag(2);
+                    } else {
+                        shop.setDesignatedFlag(3);
+                    }
+                    // 冷链费
+                    Double coldChain = 0d;
+                    // 迭代器设置商品信息
+                    for (CartItemVo cartItemVo : productList) {
+                        // 设置商品运费
+                        if (7881 == cartItemVo.getProductId()) {
+                            if (cartItemVo.getNumber() >= 100) {
+                                coldChain = 0d;
+                            } else {
+                                coldChain = baseMapper.getFreightAmount(cartItemVo.getProductId());
+                                // shop.setPostageFlag(1);
+                            }
+                        }
+                        // 设置商品图片及税费
+                        boolean taxFlag = productService.setCartItemImgAndTax(cartItemVo);
+                        // 该供应商下价格累加
+                        shopPrice.set(MathUtil.add(shopPrice, MathUtil.mul(cartItemVo.getNumber(), cartItemVo.getPrice())).doubleValue());
+                        shopOriginalPrice.set(MathUtil.add(shopOriginalPrice.get(), MathUtil.mul(cartItemVo.getNumber(), cartItemVo.getOriginalPrice())).doubleValue());
+
+                        // 设置商品运费
+                        if (null != cityId) {
+                            List<String> cartSkuIds = new ArrayList<>();
+                            cartSkuIds.add(cartItemVo.getSkuId().toString());
+                            Map<String, Object> postageMap = productService.computeShopPostage(cityId, cartItemVo.getNumber(), MathUtil.mul(cartItemVo.getNumber(), cartItemVo.getPrice()).doubleValue(), cartSkuIds);
+                            Integer postageFlag = (Integer) postageMap.get("postageFlag");
+                            shopPostageFlag.add(postageFlag);
+                            if (999 == postageFlag) {
+                                templateFlag.set(-1);
+                            } else {
+                                Double postage = (Double) postageMap.get("postage");
+                                shopPostage.set(MathUtil.add(shopPostage.get(), postage).doubleValue());
+                                log.info("shopPostage.get()======"+shopPostage.get());
+                            }
+                        }
+                        // 该供应商下商品种类 +1
+                        shopKindCount.incrementAndGet();
+                        // 总数量 + 当前商品购买数量
+                        totalCount.updateAndGet(v -> v + cartItemVo.getNumber());
+                    }
+                    // 运费方式
+                    if (shopPostageFlag.contains(1)) {
+                        shop.setPostageFlag(1);
+                    } else if (!shopPostageFlag.contains(1) && shopPostageFlag.contains(2)) {
+                        shop.setPostageFlag(2);
+                    } else {
+                        shop.setPostageFlag(0);
+                    }
+                    shop.setPostage(shopPostage.get());
+                    // 运费
+                    // 包邮或者到付 冷链费为 0
+                    coldChain = 0 == shop.getPostage() ? 0 : coldChain;
+                    shop.setPostage(MathUtil.sub(shop.getPostage(), coldChain).doubleValue());
+                    shop.setColdChain(coldChain);
+                    if (0 != coldChain) {
+                        shop.setIsColdChina(true);
+                    } else {
+                        shop.setIsColdChina(false);
+                    }
+                    log.info("shop.getPostage()******"+shop.getPostage());
+                    // 供应商总金额
+                    shopPrice.set(MathUtil.add(MathUtil.add(shopPrice.get(), shop.getPostage()),coldChain).doubleValue());
+                    if (shopKindCount.get() > 0) {
+                        // 供应商商品
+                        shop.setCartList(productList);
+                        // 供应商总价
+                        shop.setTotalPrice(shopPrice.get());
+                        // 供应商总优惠
+                        shop.setReducedPrice(shopReducedPrice.get());
+                        // 供应商总超级会员优惠
+                        shop.setSvipReducedPrice(shopSvipReducedPrice.get());
+                        // 供应商划线价
+                        shop.setOriginalPrice(shopOriginalPrice.get());
+                        // 添加供应商Id集合
+                        shopIds.add(shop.getShopId());
+                        // 计算总价
+                        totalPrice.set(MathUtil.add(totalPrice, shop.getTotalPrice()).doubleValue());
+                        // 优惠总额
+                        reducedPrice.set(MathUtil.add(reducedPrice, shop.getReducedPrice()).doubleValue());
+                        // 超级会员优惠总额
+                        svipReducedPrice.set(MathUtil.add(svipReducedPrice, shop.getSvipReducedPrice()).doubleValue());
+                        // 总划线价
+                        totalOriginalPrice.set(MathUtil.add(totalOriginalPrice, shop.getOriginalPrice()).doubleValue());
+                        // 商品种类
+                        kindCount.updateAndGet(v -> v + shopKindCount.get());
+                    }
+                    totalProductList.addAll(productList);
+                }
+                // 供应商下商品种类
+                shop.setCount(shopKindCount.get());
+            }
+
+        }
+
+
+        // 包装返回数据
+        Map<String, Object> resultData = new HashMap<>();
+        resultData.put("kindCount", kindCount);
+        resultData.put("totalCount", totalCount);
+        resultData.put("totalPrice", totalPrice);
+        resultData.put("reducedPrice", reducedPrice);
+        resultData.put("templateFlag", templateFlag.get());
+        resultData.put("svipReducedPrice", svipReducedPrice);
+        resultData.put("totalOriginalPrice", totalOriginalPrice);
+        // 联合丽格冷链费
+        double coldChain = 0.00d;
+        if (null != totalProductList) {
+            for (CartItemVo cart :totalProductList) {
+                if (7881 == cart.getProductId()) {
+                    if (cart.getNumber() >= 100) {
+                        coldChain = 0.00d;
+                    } else {
+                        coldChain = baseMapper.getFreightAmount(cart.getProductId());
+                    }
+                    break;
+                } else {
+                    coldChain = 0.00d;
+                }
+            }
+        }
+        resultData.put("coldChain", coldChain);
+        if (flag) {
+            resultData.put("returnGoodsStutas", 2);
+            resultData.put("helpContent", helpContent);
+        } else {
+            resultData.put("returnGoodsStutas", 1);
+            resultData.put("helpContent", null);
+        }
+        return ResponseJson.success(resultData);
+    }
 }

src/main/java/com/caimei365/order/service/impl/SubmitServiceImpl.java

@@ -2464,6 +2464,995 @@ public class SubmitServiceImpl implements SubmitService {
         return ResponseJson.success();
     }
 
+    /**
+     * 生成订单 --- 供应商帮机构下单
+     *
+     * @param submitDto
+     * @return
+     */
+    @Override
+    public ResponseJson<Map<String, Object>> shopGenerateOrder(SubmitDto submitDto) {
+        log.info("submitDto===" + submitDto);
+
+        // 用户组织Id
+        JSONArray orderInfo = null;
+        JSONObject payInfo = null;
+        JSONObject orderInvoice = null;
+        try {
+            orderInfo = parseArray(submitDto.getOrderInfo());
+            payInfo = parseObject(submitDto.getPayInfo());
+            orderInvoice = parseObject(submitDto.getOrderInvoice());
+        } catch (Exception e) {
+            log.error("订单参数解析异常try-catch:", e);
+            return ResponseJson.error("订单参数解析异常！", null);
+        }
+        if (null == orderInfo || orderInfo.isEmpty()) {
+            return ResponseJson.error("订单商品数据异常！", null);
+        }
+        if (null == payInfo || payInfo.isEmpty()) {
+            return ResponseJson.error("订单金额数据异常！", null);
+        }
+        if (null == orderInvoice || orderInvoice.isEmpty()) {
+            return ResponseJson.error("发票信息数据异常！", null);
+        }
+        // 打印参数
+        log.info("******************** 【供应商给机构下单】提交订单参数：" + submitDto);
+        // 机构用户
+        OrderParamBo orderParamBo = new OrderParamBo();
+        //订单来源
+        orderParamBo.setOrderSource(submitDto.getOrderSource());
+        //订单商品
+        orderParamBo.setOrderInfo(orderInfo);
+        //订单应付总额
+        String orderShouldPayFee = (String) payInfo.get("orderShouldPayFee");
+        orderParamBo.setOrderShouldPayFee(Double.parseDouble(orderShouldPayFee));
+        // 发票类型 0不开发票 1普通发票 2增值税发票
+        Integer invoiceType = (Integer) orderInvoice.get("type");
+        if (null == invoiceType) {
+            return ResponseJson.error("发票类型不能为空！", null);
+        }
+        orderParamBo.setInvoiceType(invoiceType);
+            // 联合丽格*/
+        if (1 == invoiceType || 2 == invoiceType) {
+            InvoicePo invoice = new InvoicePo();
+            String invoiceTitle = (String) orderInvoice.get("invoiceTitle");
+            if (StringUtils.isEmpty(invoiceTitle)) {
+                return ResponseJson.error("发票抬头信息不正确！", null);
+            }
+            invoice.setType(invoiceType);
+            invoice.setInvoiceTitle(invoiceTitle);
+            String corporationTaxNum = (String) orderInvoice.get("corporationTaxNum");
+            if (1 == invoiceType) {
+                // 普通发票：发票类型、发票内容（商品明细）、抬头(公司名称)、纳税人识别号[普通发票的公司]
+                Integer invoiceTitleType = (Integer) orderInvoice.get("invoiceTitleType");
+                String registeredAddress = (String) orderInvoice.get("registeredAddress");
+                String registeredPhone = (String) orderInvoice.get("registeredPhone");
+                String openBank = (String) orderInvoice.get("openBank");
+                String bankAccountNo = (String) orderInvoice.get("bankAccountNo");
+                // 抬头类型
+                Integer headingType = (Integer) orderInvoice.get("headingType");
+                if (0 != headingType) {
+                    if (StringUtils.isEmpty(corporationTaxNum)) {
+                        return ResponseJson.error("纳税人识别号信息不正确！", null);
+                    }
+                }
+                invoice.setCorporationTaxNum(corporationTaxNum);
+                invoice.setHeadingType(headingType);
+                invoice.setInvoiceTitleType(invoiceTitleType);
+                invoice.setRegisteredAddress(registeredAddress);
+                invoice.setRegisteredPhone(registeredPhone);
+                invoice.setOpenBank(openBank);
+                invoice.setBankAccountNo(bankAccountNo);
+            }
+            if (2 == invoiceType) {
+                // 增值税发票：发票类型、发票、抬头(公司名称)、纳税人识别号、注册地址、注册电话、开户银行、开户银行账户
+                String registeredAddress = (String) orderInvoice.get("registeredAddress");
+                String registeredPhone = (String) orderInvoice.get("registeredPhone");
+                String openBank = (String) orderInvoice.get("openBank");
+                String bankAccountNo = (String) orderInvoice.get("bankAccountNo");
+                if (StringUtils.isEmpty(registeredAddress) || StringUtils.isEmpty(registeredPhone) || StringUtils.isEmpty(openBank) || StringUtils.isEmpty(bankAccountNo)) {
+                    return ResponseJson.error("发票信息不完整！", null);
+                }
+                invoice.setCorporationTaxNum(corporationTaxNum);
+                invoice.setRegisteredAddress(registeredAddress);
+                invoice.setRegisteredPhone(registeredPhone);
+                invoice.setOpenBank(openBank);
+                invoice.setBankAccountNo(bankAccountNo);
+            }
+            orderParamBo.setOrderInvoice(invoice);
+        }
+        // 返佣订单标识 0非返佣订单，1返佣订单,2普通订单含有返佣服务费
+        Integer rebateFlag = (Integer) payInfo.get("rebateFlag");
+        // rebateflag=2时，有rebateFee
+        if (null != rebateFlag && 2 == rebateFlag) {
+            String re = (String) payInfo.get("rebateFee");
+            Double rebateFee = Double.parseDouble(re);
+            orderParamBo.setRebateFee(rebateFee);
+        }
+        orderParamBo.setRebateFlag(rebateFlag);
+        // 售后条款id
+        Integer clauseId = (Integer) payInfo.get("clauseId");
+        Integer isColdChina = (Integer) payInfo.get("isColdChina");
+        orderParamBo.setClauseId(clauseId);
+        // 购买类型:（1自主下单,2直接购买 3协销下单）
+        orderParamBo.setCartType(submitDto.getCartType());
+        // 下单人
+        Integer buyUserId = null;
+
+        /**
+         * todo 协销下单, 联合丽格供应商帮机构下的那没有协销信息 协销取固定官方协销
+        */
+        Integer spUserId = submitMapper.getServiceProviderUserId(1342);
+        if (null != spUserId && spUserId > 0) {
+            buyUserId = spUserId;
+        } else {
+            return ResponseJson.error("协销用户异常！", null);
+        }
+        orderParamBo.setBuyUserId(buyUserId);
+        orderParamBo.setServiceProviderId(submitDto.getServiceProviderId());
+        orderParamBo.setAddressId(submitDto.getAddressId());
+        orderParamBo.setClubCouponId(submitDto.getClubCouponId());
+        orderParamBo.setOrderSeen(submitDto.getOrderSeen());
+        orderParamBo.setOrderMiniType(submitDto.getOrderMiniType());
+        orderParamBo.setIsColdChain(isColdChina);
+        /*
+         * 保存订单
+         */
+        return saveShopOrder(orderParamBo);
+    }
+
+    public ResponseJson<Map<String, Object>> saveShopOrder(OrderParamBo orderParamBo) {
+        // 用户组织Id： 联合丽格
+        Integer organizeId = 4;
+        log.info("******************** 提交订单逻辑处理 start *******************");
+        /**
+         * 初始化主订单
+         */
+        OrderPo mainOrder = new OrderPo();
+        // 订单可见度
+        mainOrder.setOrderSeen(orderParamBo.getOrderSeen());
+        // 订单来源
+        mainOrder.setOrderSource(orderParamBo.getOrderSource());
+        // 生成订单号 联合丽格订单
+        orderParamBo.setOrderSource(9);
+        String orderNo = CodeUtil.generateOrderNo(orderParamBo.getOrderSource());
+        mainOrder.setOrderNo(orderNo);
+        // 用户Id、机构Id 为空； 下单人id 为供应商用户id
+        mainOrder.setUserId(null);
+        mainOrder.setClubId(null);
+        mainOrder.setBuyUserId(orderParamBo.getBuyUserId());
+        // 订单提交时间
+        Date date = new Date();
+        String curDateStr = (new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")).format(date);
+        mainOrder.setOrderTime(curDateStr);
+        mainOrder.setUpdateDate(curDateStr);
+        // 订单状态 0 有效  其它无效
+        mainOrder.setDelFlag(0);
+        //协销下单 协销id固定
+        mainOrder.setSpId(orderParamBo.getServiceProviderId());
+        // 协销订单
+        mainOrder.setOrderType(0);
+        // 3:协销帮会所下单
+        mainOrder.setOrderSubmitType(3);
+        // 订单未确认
+        mainOrder.setConfirmFlag(0);
+        // 联合丽格订单
+        mainOrder.setOrderType(3);
+        // 抵扣采美豆数量
+        mainOrder.setUserBeans(0);
+        // 默认可以线上支付：0可以 1不可以
+        mainOrder.setOnlinePayFlag(0);
+        // 默认订单可以拆分：1可拆分 0不可拆分
+        mainOrder.setSplitFlag(1);
+        // 默认订单未支付：未支付0 已支付1
+        mainOrder.setPayFlag(0);
+        // 默认待向买家收款：1待收款、2部分收款、3已收款
+        mainOrder.setReceiptStatus(1);
+        // 默认未付款供应商：1待付款、2部分付款、3已付款
+        mainOrder.setPayStatus(1);
+        // 默认有成本
+        mainOrder.setZeroCostFlag(0);
+        // 发货状态：1待发货、2部分发货、3已发货
+        mainOrder.setSendOutStatus(1);
+        // 退货退款类型：0未发生退款、1部分退、2全部退
+        mainOrder.setRefundType(0);
+        // 未确认付款供应商
+        mainOrder.setAffirmPaymentFlag(0);
+        // 是否开发票
+        mainOrder.setInvoiceFlag(orderParamBo.getInvoiceType());
+
+        /**
+         * 整理订单商品信息
+         */
+        // 商品总数量
+        AtomicInteger productCount = new AtomicInteger(0);
+        // 赠品数量
+        AtomicInteger presentCount = new AtomicInteger(0);
+        // 促销赠品数量
+        AtomicInteger promotionalGiftsCount = new AtomicInteger(0);
+        // 促销满减优惠
+        AtomicDouble promotionFullReduction = new AtomicDouble(0);
+        // 超级会员优惠
+        AtomicDouble svipFullReduction = new AtomicDouble(0);
+        // 商品总金额 （商品单价乘以数量，再加上税费）
+        AtomicDouble productTotalFee = new AtomicDouble(0);
+        // 订单总额（小计金额减去经理折扣后，再加上运费[默认0])
+        AtomicDouble payTotalFee = new AtomicDouble(0);
+        // 真实支付金额（订单总额减去抵扣的账户余额）
+        AtomicDouble payableAmount = new AtomicDouble(0);
+        // 余额支付金额
+        AtomicDouble balancePayFee = new AtomicDouble(0);
+        // 总运费
+        AtomicDouble postageFee = new AtomicDouble(0);
+        // 统计销量用
+        JSONArray salesInfo = new JSONArray();
+
+        // 二手订单标记（二手订单不能同正常商品下单，只能单个商品立即购买下单）
+        boolean secondHandOrderFlag = false;
+        // 是否包含活动商品
+        boolean hasActProductFlag = false;
+        // 是否能线上支付
+        AtomicBoolean onlinePay = new AtomicBoolean(true);
+        // 用余额线下
+        if (null != orderParamBo.getBalancePayFlag() && 1 == orderParamBo.getBalancePayFlag()) {
+            onlinePay.set(false);
+        }
+        //促销活动ids
+        List<Integer> promotionsIds = new ArrayList<>();
+        // 促销活动信息
+        List<PromotionsVo> promotionList = new ArrayList<>();
+        // 订单商品列表
+        List<OrderProductPo> orderProductList = new ArrayList<>();
+        List<String> productIdList = new ArrayList<>();
+        List<String> skuIdList = new ArrayList<>();
+
+        // 余额抵扣金额
+        AtomicReference<Double> balance = new AtomicReference(0);
+        if (1 == orderParamBo.getBalancePayFlag()) {
+            balance.set(orderParamBo.getAbleUserMoney());
+        }
+        // 子订单订单列表
+        List<OrderShopPo> shopOrderList = new ArrayList<>();
+        JSONArray orderInfo = orderParamBo.getOrderInfo();
+        for (Object infoObject : orderInfo) {
+            JSONObject shopInfo = (JSONObject) infoObject;
+            Integer shopId = (Integer) shopInfo.get("shopId");
+            String shopNote = (String) shopInfo.get("note");
+            String postageString = (String) shopInfo.get("postage");
+            Integer postageFlag = (Integer) shopInfo.get("postageFlag");
+            Integer isColdChinaShop = (Integer) shopInfo.get("isColdChina");
+            if (null == shopId) {
+                return ResponseJson.error("供应商数据异常！", null);
+            }
+            JSONArray productArr = (JSONArray) shopInfo.get("productInfo");
+            if (null == productArr) {
+                return ResponseJson.error("订单商品数据异常！", null);
+            }
+            if (1252 == shopId) {
+                secondHandOrderFlag = true;
+            }
+            // 运费方式为空： 赠品 包邮
+            postageFlag = null == postageFlag ? 0 : postageFlag;
+            log.info("postageFlag*****************" + postageFlag);
+            // 运费
+            Double postage = 0d;
+            // 在 运费类型为有运费时 运费生效
+            if (null != postageFlag && 1 == postageFlag) {
+                postage = Double.parseDouble(postageString);
+            }
+            // 供应商名称
+            String shopName = baseMapper.getShopNameById(shopId);
+            /*
+             * 初始化子订单
+             */
+            OrderShopPo shopOrder = new OrderShopPo();
+            shopOrder.setPromotionFullReduction(0d);
+            shopOrder.setShopId(shopId);
+            shopOrder.setShopName(shopName);
+            shopOrder.setNote(shopNote);
+            // 是否勾选冷链运输费
+            shopOrder.setIsColdChina(isColdChinaShop);
+            // 供应商帮机构下单没有用户id和机构id 为空
+            shopOrder.setUserId(null);
+            shopOrder.setClubId(null);
+            if (3 == orderParamBo.getCartType()) {
+                /**
+                 * todo 协销订单，在添加保存时子订单的协销Id 暂时保持固定id
+                 */
+                shopOrder.setSpId(1342);
+            }
+            // 商品总数量
+            AtomicInteger shopProductCount = new AtomicInteger(0);
+            // 佣金 =  应付采美
+            AtomicDouble brokerage = new AtomicDouble(0);
+            // 需要支付金额
+            AtomicDouble needPayAmount = new AtomicDouble(0);
+            // 商品总金额
+            AtomicDouble shopAmount = new AtomicDouble(0);
+            // 付供应商 商品费
+            AtomicDouble shopProductAmount = new AtomicDouble(0);
+            // 付供应商税费
+            AtomicDouble shopTaxFee = new AtomicDouble(0);
+
+            // 商品费
+            AtomicDouble shopProductFee = new AtomicDouble(0);
+            // 供应商下参与店铺促销的商品总价
+            AtomicDouble shopPromotionFee = new AtomicDouble(0);
+            // 供应商超级会员优惠
+            AtomicDouble svipShopReduction = new AtomicDouble(0);
+
+            // 遍历所有商品
+            for (Object productObject : productArr) {
+                JSONObject productTemp = (JSONObject) productObject;
+                Integer skuId = (Integer) productTemp.get("skuId");
+                Integer productNum = (Integer) productTemp.get("productNum");
+                Integer presentNum = (Integer) productTemp.get("presentNum");
+                Integer productType = (Integer) productTemp.get("productType");
+                Double price = (Double) productTemp.get("price");
+                productType = (null == productType) ? 0 : productType;
+                if (null == skuId) {
+                    return ResponseJson.error("订单商品数据异常！", null);
+                }
+                if (null == productNum || productNum == 0) {
+                    return ResponseJson.error("商品购买数量异常！", null);
+                }
+                // 统计商品总数量
+                productCount.updateAndGet(v -> v + productNum);
+                // 赠品数
+                presentCount.updateAndGet(v -> v + presentNum);
+                // 获取数据库商品信息
+                OrderProductPo dbProduct = submitMapper.getProductOrganizeDetails(skuId);
+
+                OrderProductPo product = new OrderProductPo();
+                BeanUtils.copyProperties(dbProduct, product);
+                log.info("splitcode-----------------------》" + product.getSplitCode());
+                if (null == product) {
+                    return ResponseJson.error("订单商品不存在！", null);
+                }
+
+                // 是否二手商品
+                if (null != product.getProductCategory() && 2 == product.getProductCategory()) {
+                    secondHandOrderFlag = true;
+                }
+                // 是否添加税费，不含税商品 开票需添加税费
+                boolean taxFlag = (Integer.valueOf(0).equals(product.getIncludedTax()) && (Integer.valueOf(1).equals(product.getInvoiceType()) || Integer.valueOf(2).equals(product.getInvoiceType())));
+
+                Double shopTax = 0d;
+                // 图片路径
+                String image = ImageUtil.getImageUrl("product", product.getImage(), domain);
+                product.setImage(image);
+                product.setShopName(shopName);
+                product.setNum(productNum);
+                product.setPresentNum(presentNum);
+                product.setProductType(productType);
+                product.setSvipPriceFlag(0);
+                product.setSvipReduction(0d);
+                // 组织信息
+                product.setOrganizeId(organizeId);
+
+                // 超级会员优惠商品详情
+                SvipProductPo svipProductPo = submitMapper.getSvipProductDetails(product.getSkuId());
+                // 是否以超级会员优惠价格购买
+                boolean svipPriceFlag = null != svipProductPo && 1 == svipProductPo.getSvipProductFlag() && orderParamBo.getSvipUserFlag();
+
+                // 不是赠品，获取商品购买价格(超级会员优惠商品价格>>>活动价格>>>阶梯价格>>>复购价格库>>>商品原始价)
+                Double productPrice = price;
+                Double itemPrice = price;
+                Double discountPrice = price;
+                // 商品税费
+                Double productTax = 0d;
+                Double discountTax = 0d;
+
+                // 计算单价
+                if (MathUtil.compare(discountPrice, BigDecimal.ZERO) == 0) {
+                    return ResponseJson.error("商品购买价格不能为0！", null);
+                }
+                // 不含税可开票商品计算税费
+                if (null == product.getTaxRate() || product.getTaxRate() <= 0) {
+                    product.setTaxRate(0d);
+                }
+                if (taxFlag) {
+                    productTax = MathUtil.div(MathUtil.mul(productPrice, product.getTaxRate()), 100, 2).doubleValue();
+                    discountTax = MathUtil.div(MathUtil.mul(discountPrice, product.getTaxRate()), 100, 2).doubleValue();
+                } else if (!Integer.valueOf(1).equals(product.getIncludedTax())) {
+                    // 不含税不可开票商品和未知商品，税率置为0
+                    product.setTaxRate(0d);
+                }
+                log.info("productTax===" + productTax);
+                // 商品价格
+                if (Integer.valueOf(0).equals(product.getIncludedTax())) {
+                    if (null != product.getTaxRate() && product.getTaxRate() > 0d) {
+                        product.setPrice(MathUtil.add(productPrice, MathUtil.mul(productPrice, MathUtil.div(product.getTaxRate(), 100, 2))).doubleValue());
+                    }
+                } else {
+                    product.setPrice(productPrice);
+                }
+                // 商品税后价格
+                Double productTaxPrice = MathUtil.add(productPrice, productTax).doubleValue();
+                // 折后税后单价
+                Double discountTaxPrice = MathUtil.add(discountPrice, discountTax).doubleValue();
+                // 折扣率 = 折后单价/机构价
+                Double discountRate = MathUtil.mul(MathUtil.div(discountTaxPrice, productTaxPrice), 100).doubleValue();
+                // 单个商品的金额
+                Double productAmount = MathUtil.mul(productTaxPrice, productNum).doubleValue();
+                // 单个商品的折后金额
+                Double productFee = MathUtil.mul(discountTaxPrice, productNum).doubleValue();
+                // 不包含单品满减的商品金额
+                Double realProductFee = productFee;
+                // 单个商品总税费
+                Double taxFee = MathUtil.mul(discountTax, productNum).doubleValue();
+                // 商品售价还原
+                productPrice = itemPrice;
+                product.setPrice(productPrice);
+                // 折后单价
+                product.setDiscountPrice(discountTaxPrice);
+                // 折扣率 = 折后单价/机构价
+                product.setDiscount(discountRate);
+
+                // 单个商品的金额
+                product.setTotalAmount(productAmount);
+                // 单个商品的折后金额
+                product.setTotalFee(productFee);
+                product.setShouldPayFee(productFee);
+                product.setRealProductFee(realProductFee);
+                // 税费
+                product.setAddedValueTax(discountTax);
+                product.setTotalAddedValueTax(taxFee);
+                // 销量
+                JSONObject salesObject = new JSONObject();
+                salesObject.put("productId", product.getProductId());
+                salesObject.put("productCount", product.getNum());
+                salesInfo.add(salesObject);
+
+                // 成本价
+                Double costPrice = null;
+                /**
+                 * 判断是否选中固定成本价
+                 * 固定成本、比例成本都需要计算税费
+                 */
+                if (null != product.getCostPrice() && 1 == product.getCostCheckFlag() && product.getCostPrice() >= 0d) {
+                    // 通过售价*比例得到成本价
+                    double costTax = 0d;
+                    if (taxFlag) {
+                        costTax = MathUtil.div(MathUtil.mul(product.getCostPrice(), product.getTaxRate()), 100, 2).doubleValue();
+                    }
+                    costPrice = MathUtil.add(product.getCostPrice(), costTax).doubleValue();
+                }
+                // 判断是否选中比例成本价
+                if (null != product.getCostProportional() && 2 == product.getCostCheckFlag() && product.getCostProportional() > 0d) {
+                    // 通过售价*比例得到成本价
+                    /*double discountTax = 0d;
+                    if (taxFlag) {
+                        discountTax = MathUtil.div(MathUtil.mul(product.getDiscountPrice(), product.getTaxRate()), 100, 2).doubleValue();
+                    }*/
+                    costPrice = MathUtil.div(MathUtil.mul(product.getDiscountPrice(), product.getCostProportional()), 100, 2).doubleValue();
+                }
+                if (null == costPrice) {
+                    return ResponseJson.error("订单商品成本异常！", null);
+                }
+                product.setCostPrice(costPrice);
+                // 付供应商税费
+                if (null == product.getShopTaxRate() || product.getShopTaxRate() <= 0) {
+                    product.setShopTaxRate(product.getTaxRate());
+                }
+                if (taxFlag) {
+                    shopTax = MathUtil.div(MathUtil.mul(MathUtil.div(costPrice, MathUtil.div(MathUtil.add(product.getTaxRate(), 100), 100)), product.getShopTaxRate()), 100, 2).doubleValue();
+                } else if (!Integer.valueOf(1).equals(product.getIncludedTax())) {
+                    // 不含税不可开票商品和未知商品，税率置为0
+                    product.setShopTaxRate(0d);
+                }
+                // 单个付供应商税费
+                product.setSingleShouldPayTotalTax(shopTax);
+                // 单个商品付供应商总税费
+                product.setShouldPayTotalTax(MathUtil.mul(shopTax, productNum).doubleValue());
+                // 付供应商 商品费=成本价*(购买数量  + 赠品数量)
+                Double costAmount = MathUtil.mul(costPrice, MathUtil.add(productNum, presentNum)).doubleValue();
+                product.setShopProductAmount(costAmount);
+                log.info("product.getShopProductAmount()***" + product.getShopProductAmount());
+                //应付供应商(单)=成本价+供应商税费(单)
+                Double singleShopFee = MathUtil.add(product.getCostPrice(), shopTax).doubleValue();
+                product.setSingleShopFee(singleShopFee);
+                // 应付供应商(总)=应付供应商(单) * 商品数量
+                Double shopFee = MathUtil.add(product.getCostPrice(), shopTax).doubleValue();
+                product.setShopFee(shopFee);
+                // 付第三方，默认0
+                product.setOtherFee(0d);
+                product.setSingleOtherFee(0d);
+                //应付采美(单)=单价+机构税费(单)-(成本(单)+供应商税费(单))
+                Double singleCmFee = MathUtil.sub(MathUtil.add(BigDecimal.valueOf(product.getPrice()), product.getAddedValueTax()), MathUtil.add(product.getCostPrice(), shopTax)).doubleValue();
+                product.setSingleCmFee(singleCmFee);
+                // 应付采美(总)=应付采美(单)*商品数量
+                Double cmFee = MathUtil.mul(singleCmFee, productNum).doubleValue();
+                product.setCmFee(cmFee);
+                // 默认未支付
+                product.setPayStatus(0);
+                // 默认非再次购买商品
+                product.setBuyAgainFlag(0);
+                // 未出库数量
+                product.setNotOutStore(productNum);
+                /*
+                 * 子订单金额计算
+                 */
+                // 供应商商品数量
+                shopProductCount.set(shopProductCount.get() + product.getNum());
+                // 佣金 = 应付采美
+                brokerage.set(MathUtil.add(brokerage.get(), product.getCmFee()).doubleValue());
+                // 需要支付金额 shouldPayFee +运费
+                needPayAmount.set(MathUtil.add(needPayAmount.get(), product.getShouldPayFee()).doubleValue());
+                // 统计 总金额 包括税费
+                shopProductFee.set(MathUtil.add(shopProductFee.get(), product.getTotalFee()).doubleValue());
+                // 统计子订单内可参与店铺促销的商品总金额
+                if (!svipPriceFlag) {
+                    // 超级会员购买优惠商品，不能参与店铺促销
+                    shopPromotionFee.set(MathUtil.add(shopPromotionFee.get(), product.getTotalFee()).doubleValue());
+                }
+                // 商品总金额
+                shopAmount.set(MathUtil.add(shopAmount.get(), product.getTotalAmount()).doubleValue());
+                // 付供应商 商品费
+                log.info("shopProductAmount.get()" + shopProductAmount.get());
+                log.info("product.getShopProductAmount()" + product.getShopProductAmount());
+                shopProductAmount.set(MathUtil.add(shopProductAmount.get(), product.getShopProductAmount()).doubleValue());
+                // 付供应商税费
+                shopTaxFee.set(MathUtil.add(shopTaxFee.get(), product.getShouldPayTotalTax()).doubleValue());
+                // 成本 | 佣金比例  商城sku 成本 | 配置比例
+                CmOrganizeSkuPo organizeSkuInfo = submitMapper.getOrganizeSkuInfo(skuId, organizeId);
+                if (StringUtils.isNotEmpty(organizeSkuInfo.getCostCheckFlag()) && "1".equals(organizeSkuInfo.getCostCheckFlag())) {
+                    // 固定成本
+                    if (taxFlag) {
+                        organizeSkuInfo.setOrganizeCostPrice(MathUtil.add(organizeSkuInfo.getOrganizeCostPrice(), MathUtil.div(MathUtil.mul(organizeSkuInfo.getOrganizeCostPrice(), product.getTaxRate()), 100)).doubleValue());
+                        organizeSkuInfo.setCmCostPrice(MathUtil.add(organizeSkuInfo.getCmCostPrice(), MathUtil.div(MathUtil.mul(organizeSkuInfo.getCmCostPrice(), product.getTaxRate()), 100)).doubleValue());
+                    }
+                    product.setOrganizeCostPrice(organizeSkuInfo.getOrganizeCostPrice());
+                    product.setCmCostPrice(organizeSkuInfo.getCmCostPrice());
+                }
+                if (StringUtils.isNotEmpty(organizeSkuInfo.getCostCheckFlag()) && "2".equals(organizeSkuInfo.getCostCheckFlag())) {
+                    // 比例成本
+                    product.setOrganizeCostPrice(MathUtil.div(MathUtil.mul(product.getPrice(), organizeSkuInfo.getOrganizePercent()), 100).doubleValue());
+                    product.setCmCostPrice(MathUtil.div(MathUtil.mul(product.getPrice(), organizeSkuInfo.getCmPercent()), 100).doubleValue());
+
+                    product.setCmPercent(organizeSkuInfo.getCmPercent());
+                    product.setOrganizePercent(organizeSkuInfo.getOrganizePercent());
+                    product.setShopPercent(organizeSkuInfo.getShopPercent());
+                }
+                // 加入订单商品列表
+                // 商品价格设置为 折后价格
+                // product.setPrice(product.getDiscountPrice());
+                orderProductList.add(product);
+                productIdList.add(product.getProductId().toString());
+                skuIdList.add(product.getSkuId().toString());
+            }
+            // 设置运费
+            if (1 == postageFlag && 0 == mainOrder.getUserBeans()) {
+                shopOrder.setShopPostFee(postage);
+            }
+            // 需要支付金额 shouldPayFee +运费
+            needPayAmount.set(MathUtil.add(needPayAmount.get(), postage).doubleValue());
+            log.info("postage=-***====" + postage);
+            // 统计总运费
+            postageFee.set(MathUtil.add(postageFee.get(), postage).doubleValue());
+            log.info("统计总运费+--+-+-" + postageFee.get());
+            Integer count = submitMapper.findSplitResult(productIdList);
+            if (count > 0) {
+                //有商品无分帐号，走线下
+                onlinePay.set(false);
+            }
+            // 佣金 采美应收
+            shopOrder.setBrokerage(brokerage.get());
+            // 可退款金额 = 余额抵扣金额
+            shopOrder.setCanRefundAmount(needPayAmount.get());
+            // 购买商品数
+            shopOrder.setItemCount(shopProductCount.get());
+            // 超级会员优惠金额
+            shopOrder.setSvipShopReduction(svipShopReduction.get());
+            // 总价(含税) = totalFee + 运费
+            shopOrder.setTotalAmount(MathUtil.add(shopProductFee.get(), postage).doubleValue());
+            // 总金额 = 订单商品totalAmount
+            shopOrder.setProductAmount(shopAmount.get());
+            // 需要支付金额 shouldPayFee +运费
+            shopOrder.setNeedPayAmount(needPayAmount.get());
+            // 付供应商 商品费=成本价*(购买数量  + 赠品数量)
+            shopOrder.setShopProductAmount(shopProductAmount.get());
+            // 付给供应商税费
+            shopOrder.setShopTaxFee(shopTaxFee.get());
+            // 付供应商 = 商品费 + 运费
+            // 版本不加 税费
+            shopOrder.setShouldPayShopAmount(MathUtil.add(shopProductAmount.get(), postageFee.get()).doubleValue());
+            // 付给供应商运费
+            // shopOrder.setShopPostFee(0d);
+            // 已付供应商金额
+            shopOrder.setPayedShopAmount(0d);
+            // (付款供应商)付款状态：1待付款、2部分付款、3已付款
+            shopOrder.setPayStatus(1);
+            // 协销订单
+            shopOrder.setOrderType(0);
+            // 余额支付标识，0不使用，1使用
+            log.info("balance.get()=====" + balance.get());
+            // 不使用余额支付
+            shopOrder.setUseBalanceFlag(0);
+            // 余额抵扣金额
+            shopOrder.setAccountAmount(0d);
+            log.info("shopOrder.getAccountAmount()====" + shopOrder.getAccountAmount());
+            // 运费标记
+            shopOrder.setShopPostFlag(postageFlag);
+            // 添加到子订单列表
+            shopOrderList.add(shopOrder);
+            // 统计商品总金额
+            productTotalFee.set(MathUtil.add(productTotalFee.get(), shopProductFee.get()).doubleValue());
+        }
+        if (orderProductList.isEmpty()) {
+            return ResponseJson.error("订单商品数据异常！", null);
+        }
+        // 设置是否是二手订单
+        mainOrder.setSecondHandOrderFlag(0);
+        // 商品总数量
+        mainOrder.setProductCount(productCount.get());
+        // 赠品数量
+        mainOrder.setPresentCount(presentCount.get());
+        //促销赠品数量
+        mainOrder.setPromotionalGiftsCount(promotionalGiftsCount.get());
+        /**
+         * 处理优惠券
+         */
+        Double couponAmount = 0d;
+        mainOrder.setCouponAmount(couponAmount);
+        // 订单总额 = 商品费 + 运费
+        log.info("总运费" + postageFee.get());
+        payTotalFee.set(MathUtil.add(productTotalFee.get(), postageFee.get()).doubleValue());
+        log.info("payTotalFee.get()=------=-=-====" + payTotalFee.get());
+        // 订单总额 -= 优惠券金额
+        payTotalFee.set(MathUtil.sub(payTotalFee.get(), couponAmount).doubleValue());
+        // 超级会员优惠
+        mainOrder.setSvipFullReduction(svipFullReduction.get());
+        // 商品总额
+        mainOrder.setProductTotalFee(productTotalFee.get());
+        mainOrder.setOrderTotalFee(productTotalFee.get());
+        // 订单总额（商品金额+运费）-- 冷链运输费
+        mainOrder.setPayTotalFee(payTotalFee.get());
+        // 订单状态 协销 状态为 待确认
+        mainOrder.setStatus(0);
+        // 余额支付金额
+        mainOrder.setBalancePayFee(balancePayFee.get());
+        // 实际支付金额(商品金额+运费-余额抵扣)
+        mainOrder.setPayableAmount(payableAmount.get());
+
+        // 是否返佣订单
+        Integer rebateFlag = (null == orderParamBo.getRebateFlag() ? 0 : orderParamBo.getRebateFlag());
+        mainOrder.setRebateFlag(rebateFlag);
+        if (2 == rebateFlag) {
+            mainOrder.setRebateFee(orderParamBo.getRebateFee());
+        }
+
+        log.info("订单总额" + payTotalFee.get());
+        // 判断前端传入orderShouldPayFee订单应付金额,和后台计算应付金额对比
+        log.info("【提交订单】>>>>>后台计算payableAmount:" + payableAmount.get() + " ,前端传入orderShouldPayFee:" + orderParamBo.getOrderShouldPayFee());
+        int compare = MathUtil.compare(orderParamBo.getOrderShouldPayFee(), payableAmount.get());
+        if (compare != 0) {
+            // 设置手动回滚事务
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            return ResponseJson.error("订单付款金额不正确！", null);
+        }
+        // 售后条款
+        Integer clauseId = orderParamBo.getClauseId();
+        String clauseName = null;
+        if (null != clauseId && clauseId > 0) {
+            clauseName = submitMapper.getClauseNameById(clauseId);
+        }
+        if (StringUtils.isNotEmpty(clauseName)) {
+            mainOrder.setClauseId(clauseId);
+            mainOrder.setClauseName(clauseName);
+        } else {
+            mainOrder.setClauseId(1);
+            mainOrder.setClauseName("无条款");
+        }
+        // 设置组织Id
+        mainOrder.setOrganizeId(organizeId);
+        if (null == mainOrder.getUserId()) {
+            // 设置手动回滚事务
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            return ResponseJson.error("用户Id为空！", null);
+        }
+        // 根据用户 Id 查询机构 Id
+        Integer clubId = submitMapper.getClubId(mainOrder.getUserId());
+        mainOrder.setClubId(clubId);
+
+        /**
+         * 保存主订单数据，返回订单Id
+         */
+        submitMapper.insertMainOrder(mainOrder);
+        log.info("【提交订单】>>>>>>>>>>>>>>>>>>>>>>>>>>新增主订单(insert[cm_order])orderId：" + mainOrder.getOrderId());
+
+        /**
+         * 线上单分摊优惠
+         */
+        if (presentCount.get() > 0) {
+            //有赠品不能线上，赠品成本无法分账
+            onlinePay.set(false);
+        }
+        if (onlinePay.get()) {
+//            //在店铺满减算完之后重新根据商品的splitCode排shopOrderList
+            List<OrderShopPo> shops = submitMapper.findShops(productIdList);
+//            //子订单分多子订单，满减分摊到原子订单分开的子订单，无满减重算佣金/应付
+//            //重组订单
+//            shopOrderList = findSplitShopOrder(orderProductList, shopOrderList, shops, orderParamBo);
+            for (OrderShopPo shop : shops) {
+                shopOrderList.forEach(s -> {
+                    if (s.getShopId().equals(shop.getShopId())) {
+                        s.setSplitCode(shop.getSplitCode());
+                    }
+                });
+            }
+            // 按分摊前的佣金排序
+            shopOrderList.sort((o1, o2) -> o2.getOldBrokerage().compareTo(o1.getOldBrokerage()));
+            // 前面子订单的分摊优惠总和
+            /**
+             * todo 当前版本为子订单下单，且优惠仅存在供应商优惠，优惠金额应从供应商成本扣除，暂时去除均摊优惠逻辑
+             */
+            //无优惠金额
+            shopOrderList.forEach(so -> {
+//                //不包含优惠的真实支付金额=子订单应付？
+//                double realPay = so.getNeedPayAmount();
+//                so.setRealPay(realPay);
+//                so.setEachDiscount(0d);
+                double bro = so.getBrokerage();
+//                so.setRealPay(realPay);
+//                so.setEachDiscount(0d);
+                //成本>实付不能线上
+                if (bro < 0) {
+                    onlinePay.set(false);
+                } else {
+                    double WXCharge = MathUtil.mul(so.getRealPay(), 0.0065, 2).doubleValue();
+                    double QuickCharge = MathUtil.mul(so.getRealPay(), 0.006, 2).doubleValue();
+                    double AliCharge = MathUtil.mul(so.getRealPay(), 0.0025, 2).doubleValue();
+                    double B2CCharge = MathUtil.mul(so.getRealPay(), 0.002, 2).doubleValue();
+                    //佣金和手续费比较,佣金>手续费则可以走当前支付渠道
+                    //支持子订单佣金小于最小手续费时，也能进行线上支付，此时不限制支付方式(佣金大于最大手续费或小于最小手续费支持全渠道付款)
+                    String payWays = "";
+                    payWays += bro >= WXCharge ? "1" : "";
+                    payWays += bro >= AliCharge ? ",2" : "";
+                    payWays += bro >= B2CCharge ? ",3" : "";
+                    payWays += bro >= 10 ? ",4" : "";
+                    payWays += bro >= QuickCharge ? ",5" : "";
+                    //小于所有的情况下线下补手续费，开放所有渠道
+                    if ("".equals(payWays)) {
+                        payWays = "1,2,3,4,5";
+                    }
+                    so.setOnlinePayWays(payWays);
+                }
+                log.info("线上重排子订单--------------------------" + so);
+            });
+        }
+        /*
+         * 整理 子订单信息cm_shop_order
+         */
+        AtomicReference<String> shopOrderIds = new AtomicReference<>();
+        AtomicInteger shopOrderIndex = new AtomicInteger(1);
+        shopOrderList.forEach(shopOrder -> {
+            shopOrder.setOrderId(mainOrder.getOrderId());
+            shopOrder.setOrderNo(mainOrder.getOrderNo());
+            shopOrder.setOrderTime(mainOrder.getOrderTime());
+            shopOrder.setOrderSubmitType(mainOrder.getOrderSubmitType());
+            // 子订单状态
+            if (0 == mainOrder.getStatus()) {
+                shopOrder.setShopStatus(0);
+            } else {
+                shopOrder.setShopStatus(1);
+                // 普通订单 订单默认已确认
+                shopOrder.setConfirmTime(curDateStr);
+            }
+            // 生成子订单编号
+            StringBuilder shopOrderNo = new StringBuilder();
+            shopOrderNo.append(mainOrder.getOrderNo());
+            if (shopOrderIndex.get() < 10) {
+                shopOrderNo.append("0");
+            }
+            shopOrderNo.append(shopOrderIndex.get());
+            shopOrderIndex.incrementAndGet();
+            shopOrder.setShopOrderNo(shopOrderNo.toString());
+            // 订单能否拆分 1 为可拆分, 0为不可拆分
+            if (shopOrder.getItemCount() > 1) {
+                shopOrder.setSplitFlag(1);
+            } else {
+                shopOrder.setSplitFlag(0);
+            }
+            // 设置订单促销Id
+            promotionList.forEach(promotions -> {
+                if (promotions.getPromotionsId().equals(shopOrder.getOrderPromotionsId())) {
+                    shopOrder.setOrderPromotionsId(promotions.getId());
+                }
+            });
+            // 设置组织Id
+            shopOrder.setOrganizeId(organizeId);
+            // 分帐号
+            if (0 != organizeId) {
+                // 联合丽格
+                shopOrder.setRealPay(shopOrder.getNeedPayAmount());
+            }
+            shopOrder.setClubId(clubId);
+            /*
+             * 保存子订单
+             */
+            log.info("shopOrderStatus======" + shopOrder.getShopStatus());
+            submitMapper.insertShopOrder(shopOrder);
+            log.info("【提交订单】>>>>>>>>>>>>>>>>>>>>>>>>>>新增子订单(insert[cm_shop_order])shopOrderId：" + shopOrder.getShopOrderId() + "，orderId：" + mainOrder.getOrderId());
+            // 收集子订单Id字符串
+            if (StringUtils.isEmpty(shopOrderIds.get())) {
+                shopOrderIds.set(shopOrder.getShopOrderId().toString());
+            } else {
+                shopOrderIds.set(shopOrderIds.get() + "," + shopOrder.getShopOrderId());
+            }
+        });
+
+        /**
+         * 订单商品分子订单cm_order_product
+         */
+        for (OrderProductPo orderProduct : orderProductList) {
+            // 设置商品订单Id
+            orderProduct.setOrderId(mainOrder.getOrderId());
+            orderProduct.setOrderNo(mainOrder.getOrderNo());
+            // 设置商品子订单Id
+            shopOrderList.forEach(shopOrder -> {
+                //能线上的一定有分账号，按分账号分子订单
+                if (onlinePay.get()) {
+                    //可以线上的情况下，子订单的商户号和商品的一致分到一个子订单
+                    if (orderProduct.getShopId().equals(shopOrder.getShopId()) && orderProduct.getSplitCode().equals(shopOrder.getSplitCode())) {
+                        orderProduct.setShopOrderId(shopOrder.getShopOrderId());
+                        orderProduct.setShopOrderNo(shopOrder.getShopOrderNo());
+                    }
+                } else {
+                    if (orderProduct.getShopId().equals(shopOrder.getShopId())) {
+                        orderProduct.setShopOrderId(shopOrder.getShopOrderId());
+                        orderProduct.setShopOrderNo(shopOrder.getShopOrderNo());
+                    }
+                }
+            });
+            // 设置订单商品促销Id
+            promotionList.forEach(promotions -> {
+                if (promotions.getPromotionsId().equals(orderProduct.getOrderPromotionsId())) {
+                    orderProduct.setOrderPromotionsId(promotions.getId());
+                    orderProduct.setActProduct(1);
+                }
+            });
+            orderProduct.setOrganizeId(organizeId);
+            /*
+             * 保存 订单商品
+             */
+            submitMapper.insertOrderProduct(orderProduct);
+            log.info("【提交订单】>>>>>>>>>>>>>>>>>>>>>>>>>>保存订单商品(insert[cm_order_product])OrderProductId：" + orderProduct.getOrderProductId() + "，orderId：" + mainOrder.getOrderId());
+            /*
+             * 保存 订单阶梯价格
+             */
+            if (orderProduct.getLadderPriceFlag() == 1) {
+                // 使用阶梯价格的订单商品保存下单时的阶梯价格列表
+                List<LadderPriceVo> ladderPrices = orderProduct.getLadderPrices();
+                if (null != ladderPrices && ladderPrices.size() > 0) {
+                    ladderPrices.forEach(ladderPriceVo -> {
+                        ladderPriceVo.setOrderProductId(orderProduct.getOrderProductId());
+                        ladderPriceVo.setCreateDate(date);
+                        submitMapper.insertLadderPrices(ladderPriceVo);
+                        log.info("【提交订单】>>>>>>>>>>>>>>>>>>>>>>>>>>保存订单阶梯价格(insert[order_product_ladder_price])id：" + ladderPriceVo.getId() + "，orderId：" + mainOrder.getOrderId());
+                    });
+                }
+            }
+            /*
+             * 机构用户 写入价格库
+             */
+            if (3 != orderParamBo.getCartType() && 1 != orderProduct.getSvipPriceFlag() && 0 == organizeId) {
+                // 写入复购价格库
+                productService.savePurchasePrice(mainOrder, orderProduct, secondHandOrderFlag, "【提交订单】");
+            }
+        }
+
+        /**
+         * 更新主订单的子订单Id信息,如:1000,1002
+         */
+        if (StringUtils.isNotEmpty(shopOrderIds.get())) {
+            mainOrder.setShopOrderIds(shopOrderIds.get());
+            submitMapper.updateShopOrderIds(shopOrderIds.get(), mainOrder.getOrderId());
+        } else {
+            // 设置手动回滚事务
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            return ResponseJson.error("生成子订单异常！", null);
+        }
+        /**
+         * 更新主订单线上支付按钮
+         * onlinePayFlag:0可以 1不可以
+         */
+        Integer onlinePayFlag = onlinePay.get() ? 0 : 1;
+        // 组织 是否线上判定
+        boolean item = true;
+        if (0 != organizeId) {
+            // 子订单分帐号
+            for (OrderShopPo shopOrder : shopOrderList) {
+                if (StringUtils.isEmpty(shopOrder.getSplitCode()) || StringUtils.isBlank(shopOrder.getSplitCode())) {
+                    item = false;
+                }
+            }
+            if (item) {
+                onlinePayFlag = 0;
+            } else {
+                onlinePayFlag = 1;
+            }
+        }
+        submitMapper.updateOnlinePayFlag(onlinePayFlag, mainOrder.getOrderId());
+        // 更新子订单线上支付
+        if (0 != organizeId && item) {
+            String onlinePayWays = "1,2,3,4,5";
+            submitMapper.updateOnlinePayWays(onlinePayWays, mainOrder.getOrderId());
+        }
+        /*
+         * todo 保存 订单收货用户信息 下单时没有用户信息
+         */
+        AddressVo address = submitMapper.getAddressDetailById(orderParamBo.getAddressId());
+        if (null != address) {
+            String userName = baseMapper.getUserNameByUserId(mainOrder.getUserId());
+            //保存地址信息
+            OrderUserInfoPo userInfo = new OrderUserInfoPo();
+            userInfo.setOrderId(mainOrder.getOrderId());
+            userInfo.setClubId(mainOrder.getClubId());
+            userInfo.setUserId(mainOrder.getUserId());
+            userInfo.setName(userName);
+            userInfo.setReceiver(address.getReceiver());
+            userInfo.setMobile(address.getMobile());
+            userInfo.setTownId(address.getTownId());
+            userInfo.setProvince(address.getProvince());
+            userInfo.setCity(address.getCity());
+            userInfo.setTown(address.getTown());
+            userInfo.setAddress(address.getAddress());
+            // 保存 订单收货用户信息
+            submitMapper.insertOrderUserInfo(userInfo);
+            log.info("【提交订单】>>>>>>>>>>>>>>>>>>>>>>>>>>保存订单用户地址(insert[bp_order_userinfo])orderId：" + mainOrder.getOrderId());
+        } else {
+            //设置手动回滚事务
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            return ResponseJson.error("订单地址异常！", null);
+        }
+
+        /*
+         * 保存发票信息
+         */
+        if (1 == orderParamBo.getInvoiceType() || 2 == orderParamBo.getInvoiceType()) {
+            /*
+             * 更新订单增值税发票
+             */
+            InvoicePo orderInvoice = submitMapper.getOrderInvoice(mainOrder.getOrderId());
+            if (null != orderInvoice && null != orderInvoice.getId()) {
+                // 更新
+                BeanUtils.copyProperties(orderParamBo.getOrderInvoice(), orderInvoice);
+                orderInvoice.setOrderId(mainOrder.getOrderId());
+                submitMapper.updateOrderInvoice(orderInvoice);
+                log.info("【提交订单】>>>>>>>>>>>>>>>>>>>>>>>>>>更新订单发票信息(update[bp_order_invoice])orderId：" + mainOrder.getOrderId());
+            } else {
+                // 新增
+                orderInvoice = new InvoicePo();
+                BeanUtils.copyProperties(orderParamBo.getOrderInvoice(), orderInvoice);
+                orderInvoice.setOrderId(mainOrder.getOrderId());
+                //  保存 订单发票信息
+                submitMapper.insertOrderInvoice(orderInvoice);
+                log.info("【提交订单】>>>>>>>>>>>>>>>>>>>>>>>>>>保存订单发票信息(insert[bp_order_invoice])orderId：" + mainOrder.getOrderId());
+            }
 
+            log.info("******************** 供应商给机构下单 -- 提交订单逻辑处理 end *******************");
+        }
+        /*
+         * 构造返回参数
+         */
+        Map<String, Object> info = new HashMap<>();
+        info.put("orderId", mainOrder.getOrderId());
+        info.put("orderNo", mainOrder.getOrderNo());
+        info.put("orderMark", "#" + mainOrder.getOrderId() + "#");
+        //应付订单金额
+        info.put("payTotalFee", mainOrder.getPayTotalFee());
+        //线上线下按钮onlinePayFlag:0线上，1线下
+        info.put("onlinePayFlag", onlinePayFlag);
+        //真实需要付款金额
+        info.put("payableAmount", mainOrder.getPayableAmount());
+        //2提交成功(未支付)
+        info.put("code", 2);
+        info.put("msg", "提交成功但未支付!");
+        // 统计销量
+        remoteCallService.productSaleUpdate(salesInfo.toString());
+        // 返回结果
+        return ResponseJson.success("操作成功!", info);
+    }
 }
 

src/main/resources/mapper/OrderClubMapper.xml

@@ -1147,4 +1147,31 @@
     <select id="getShopCmBankAccount" resultType="com.caimei365.order.model.po.ShopPo">
         SELECT shopId, name, cmBankAccount as bankAccount, cmBankAccountName as bankAccountName, cmBankName as bankName FROM shop WHERE shopId = #{shopId}
     </select>
+
+    <select id="getClubByUserId" resultType="java.lang.Integer">
+        select clubId from club where userId = #{userId}
+    </select>
+
+    <select id="getShopOrderInfo" resultType="com.caimei365.order.model.vo.ShopOrderVo">
+        SELECT
+            shopOrderId,
+            shopStatus as status
+        FROM cm_shop_order
+        WHERE shopOrderId = #{shopOrderId}
+    </select>
+
+    <update id="updateShopOrderById">
+        update cm_shop_order
+        set shopStatus = #{status},
+            userId = #{userId},
+            clubId = #{clubId}
+        where shopOrderId = #{shopOrderId}
+    </update>
+    <update id="updateOrderUserInfoById">
+        update bp_order_userinfo
+        set shopStatus = #{status},
+            userId = #{userId},
+            clubId = #{clubId}
+        where shopOrderId = #{shopOrderId}
+    </update>
 </mapper>

src/main/resources/mapper/ShipMapper.xml

@@ -173,8 +173,17 @@
             <if test="receiver != null and receiver != ''">
                 AND ou.shouHuoRen like concat('%',#{receiver},'%')
             </if>
+            <if test="orderStatus != null">
+                <if test="orderStatus == 1">
+                    and a.orderType = 1
+                </if>
+                <if test="orderStatus == 2">
+                    and a.orderType = 0
+                    and a.organizeId = 4
+                </if>
+            </if>
             AND a.delFlag='0'
-            AND a.shopStatus not in (0, 4)
+            AND a.shopStatus != 4
             AND a.delFlag='0'
             AND a.shopID=#{shopId}
         </where>
@@ -587,4 +596,51 @@
             createDate  = #{createDate}
         WHERE id = #{id}
     </update>
+
+    <select id="getCartShopsByShopId" resultType="com.caimei365.order.model.vo.CartShopVo">
+        SELECT s.shopID AS shopId,
+               s.name   AS shopName,
+               s.logo   AS shopLogo
+        FROM shop s
+        WHERE s.shopId = #{shopId}
+        LIMIT 1
+    </select>
+
+    <select id="getProductsOrganize" resultType="com.caimei365.order.model.vo.CartItemVo">
+        SELECT
+        cs.skuId as skuId,
+        p.productID AS productId,
+        p.shopID AS shopId,
+        p.`name` AS `name`,
+        p.mainImage AS image,
+        p.productCode,
+        cs.price,
+        cs.price AS originalPrice,
+        cs.unit AS unit,
+        p.step AS step,
+        cs.minBuyNumber AS min,
+        p.priceFlag,
+        p.includedTax AS includedTax,
+        p.invoiceType AS invoiceType,
+        p.taxPoint AS taxRate,
+        p.productCategory,
+        copi.validFlag AS validFlag,
+        p.visibility,
+        p.commodityType as commodityType,
+        p.productType,
+        p.splitCode
+        FROM cm_sku cs
+        LEFT JOIN product p ON cs.productId = p.productId
+        left join cm_organize_product_info copi on copi.productId = p.productId
+        WHERE p.shopID = #{shopId} and cs.organizeID = #{organizeId} and copi.organizeID = #{organizeId}
+        AND copi.validFlag='2'
+        <if test="splitCode !=null and splitCode !=''">
+            AND p.splitCode = #{splitCode}
+        </if>
+        AND cs.skuId in
+        <foreach collection="skuIds" open="(" separator="," close=")" item="skuId">
+            #{skuId}
+        </foreach>
+        ORDER BY cs.skuId DESC
+    </select>
 </mapper>