Merge remote-tracking branch 'origin/developerD' into developer

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

@@ -213,7 +213,7 @@ public class ProductService {
             postageMap.put("postage", 0.00d);
             return postageMap;
         }
-        // 获取商品运费 （商品数据库 0包邮 2默认（遵循运费模板） 2到付 ）
+        // 获取商品运费 （商品数据库 0包邮 1默认遵循运费模板 2到付 ）
         List<ProductPostageVo> postageFlagList = null;
         if (0 == organizeId) {
             postageFlagList = baseMapper.getPostageFlagList(skuIdList);
@@ -304,6 +304,103 @@ 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包邮 1 遵循运费模板 2到付 ）
+        List<ProductPostageVo> 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

@@ -391,4 +391,75 @@ public class OrderClubApi {
         }
         return orderClubService.getShopBankAccount(shopId);
     }
+
+    /**
+     * 分享订单 生成分享吗 供应商给机构下单
+     * @param shopOrderId
+     * @return
+     */
+    @ApiOperation("分享订单 生成分享吗 供应商给机构下单")
+    @ApiImplicitParam(required = true, name = "shoporderId", value = "子订单Id")
+    @GetMapping("/getShopOrderShareCode")
+    public ResponseJson<Map<String, Object>> getShopOrderShareCode(Integer shopOrderId) {
+        if (null == shopOrderId) {
+            return ResponseJson.error(-1, "子订单Id不能为空", null);
+        }
+        return orderClubService.getShopOrderShareCode(shopOrderId);
+    }
+
+    /**
+     * 分享订单，校验分享码
+     */
+    @ApiOperation("分享订单，校验分享码; 供应商给机构下单分享校验")
+    @ApiImplicitParams({
+            @ApiImplicitParam(required = true, name = "shopOrderId", value = "子订单Id"),
+            @ApiImplicitParam(required = true, name = "shareCode", value = "分享码")
+    })
+    @GetMapping("/shop/code/check")
+    public ResponseJson<Integer> 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
+     * @return
+     */
+    @ApiOperation("分享订单校验成功、返回子订单数据")
+    @ApiImplicitParam(required = true, name = "shopOrderId", value = "子订单Id")
+    @GetMapping("/getShopOrderById")
+    public ResponseJson<Map<String, Object>> getShopOrderById(Integer shopOrderId){
+        if (null == shopOrderId) {
+            return ResponseJson.error(-1, "子订单Id不能为空", null);
+        }
+        return orderClubService.getShopOrderById(shopOrderId);
+    }
+
+    /**
+     * 机构确认订单
+     * @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 orderClubService.confirmShopOrder(shopOrderId, userId);
+    }
 }

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

@@ -182,4 +182,26 @@ public class OrderSubmitApi {
         return submitService.updateOrder(orderProducts.getOrderProducts());
     }
 
+    /**
+     * 供应商给机构下单
+     * @param submitDto
+     * @return
+     */
+    @ApiOperation("供应商给机构下单")
+    @PostMapping("/shopGenerateOrder")
+    public ResponseJson shopGenerateOrder( SubmitDto submitDto) {
+        if (null == submitDto.getCartType()) {
+            return ResponseJson.error("购买类型不能为空！", 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

@@ -47,20 +47,22 @@ public class ShipApi {
             @ApiImplicitParam(required = false, name = "shopOrderNo", value = "订单编号"),
             @ApiImplicitParam(required = false, name = "receiver", value = "买家名称(收货人)"),
             @ApiImplicitParam(required = false, name = "refundStatus", value = "退款状态"),
+            @ApiImplicitParam(required = false, name = "orderType", 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 orderType, 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, orderType, receiptStatus, organizeId, orderStatus, pageNum, pageSize);
     }
 
     /**
@@ -460,4 +462,42 @@ public class ShipApi {
     public void downFile(Integer fileId, HttpServletRequest request, HttpServletResponse response) throws IOException {
         shipService.downFile(fileId, request, response);
     }
+
+    /**
+     * 供应商给机构下单 结算--联合丽格
+     * @param shopId
+     * @param productInfo
+     * @return
+     */
+    @ApiOperation("供应商给机构下单 结算--联合丽格")
+    @ApiImplicitParams({
+            @ApiImplicitParam(required = false, name = "shopId", value = "供应商Id"),
+            @ApiImplicitParam(required = false, name = "cityId", value = "地址"),
+            @ApiImplicitParam(required = false, name = "productInfo", value = "商品信息 json"),
+    })
+    @GetMapping("/settlement")
+    public ResponseJson<Map<String, Object>> settlementShop(Integer shopId, Integer cityId, String productInfo){
+        if (null == shopId) {
+            return ResponseJson.error("供应商Id不能为空！", null);
+        }
+        if (StringUtils.isEmpty(productInfo) || StringUtils.isBlank(productInfo)) {
+            return ResponseJson.error("商品信息不能为空！", null);
+        }
+        return shipService.settlementShop(shopId, cityId, productInfo);
+    }
+
+    /**
+     * 供应商取消待确认订单 -- 联合丽格
+     * @param shopOrderId
+     * @return
+     */
+    @ApiOperation("供应商取消待确认订单 -- 联合丽格")
+    @ApiImplicitParam(required = true, name = "shopOrderId", value = "子订单Id")
+    @GetMapping("/cancelOrder")
+    public ResponseJson cancelOrder(Integer shopOrderId) {
+        if (null == shopOrderId) {
+            return ResponseJson.error(-1, "子订单Id不能为空！", null);
+        }
+        return shipService.cancelOrder(shopOrderId);
+    }
 }

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

@@ -497,4 +497,36 @@ 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);
+
+    /**
+     * 确认订单、关联订单用户信息
+     * @param orderId
+     * @param userId
+     * @param clubId
+     */
+    void updateOrderInfoById(@Param("orderId") Integer orderId, @Param("userId") Integer userId, @Param("clubId") Integer clubId);
+
+    /**
+     * 填充订单收货地址用户信息
+     */
+    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 orderType, Integer receiptStatus, Integer organizeId, Integer orderStatus);
     /**
      * 供应商结算列表
      */
@@ -303,4 +303,35 @@ 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<Integer> skuIds,@Param("splitCode")String splitCode);
+
+    /**
+     * 商城sku信息
+     * @param skuId
+     * @return
+     */
+    CmOrganizeSkuPo getOrganizeSkuInfo(@Param("skuId") Integer skuId, @Param("organizeId") Integer organizeId);
+
+    /**
+     * 供应商取消未确认订单
+     * @param shopOrderId
+     * @param note
+     */
+    void deleteShopOrder(@Param("shopOrderId") Integer shopOrderId, @Param("note") String note);
 }

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

@@ -205,4 +205,6 @@ public interface SubmitMapper {
     void updateUserMoneyByChange(Integer userId, double change);
 
     void updateShopOrderCoupon(OrderShopPo s);
+
+    AddressVo getAddressById(@Param("provinceId") Integer provinceId, @Param("cityId") Integer cityId, @Param("townId") Integer townId);
 }

src/main/java/com/caimei365/order/model/bo/OrderParamBo.java

@@ -101,6 +101,10 @@ public class OrderParamBo implements Serializable {
      * 当前订单订单商品
      */
     private JSONArray orderInfo;
+    /**
+     * 订单收货地址信息
+     */
+    private JSONObject addressInfo;
     /**
      * 购买类型:（1自主下单(购物车),2自主下单(立即购买)，3协销下单）
      */

src/main/java/com/caimei365/order/model/dto/SubmitDto.java

@@ -34,6 +34,18 @@ public class SubmitDto implements Serializable {
      */
     @ApiModelProperty("收货地址Id")
     private Integer addressId;
+    /**
+     * 收货地址信息：{
+     *         "receiver": ”测试“,    收货人
+     *         "mobile": ”15566548834“,    手机
+     *         "townId": ”55“,    区ID
+     *         "provinceId": ”北京“,    省份名称
+     *         "cityId": ”北京“,    城市名称
+     *         "address": ”北京“,    详细地址
+     *        }
+     */
+    @ApiModelProperty("收货地址信息")
+    private String addressInfo;
     /**
      * 订单来源：1WWW、2CRM、4客服[适用后台下单]、5外单[适用后台下单]、6小程序[采美,星范]、7呵呵商城小程序、8维沙小程序
      */
@@ -122,6 +134,7 @@ public class SubmitDto implements Serializable {
                 ", clubId=" + clubId +
                 ", unionId='" + unionId + '\'' +
                 ", addressId=" + addressId +
+                ", addressInfo='" + addressInfo + '\'' +
                 ", orderSource=" + orderSource +
                 ", cartType=" + cartType +
                 ", serviceProviderId=" + serviceProviderId +

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/model/po/OrderProductPo.java

@@ -58,6 +58,10 @@ public class OrderProductPo implements Serializable {
      * 成本价选中标志：1固定成本 2比例成
      */
     private Integer costCheckFlag;
+    /**
+     * 商品成本价(不含税)
+     */
+    private Double costPriceTax;
     /**
      * 成本价
      */

src/main/java/com/caimei365/order/model/vo/CartItemVo.java

@@ -36,6 +36,10 @@ public class CartItemVo implements Serializable {
      * 购买数量
      */
     private Integer number;
+    /**
+     * 小计金额
+     */
+    private Double totalPrice;
     /**
      * 购物商品效状态：0有效，1后台删除的，2冻结的，3下架，4售罄 >7库存不足，5价格仅会员可见，6未公开价格, 8价格仅医美机构可见
      */

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

@@ -149,4 +149,31 @@ public interface OrderClubService {
      */
     ResponseJson<ShopPo> getShopBankAccount(Integer shopId);
 
+    /**
+     * 分享订单，获取分享码 供应商给机构下单
+     * @param shopOrderId
+     * @return
+     */
+    ResponseJson<Map<String, Object>> getShopOrderShareCode(Integer shopOrderId);
+    /**
+     * 分享订单，校验分享码
+     * @param shopOrderId 订单Id
+     * @param shareCode 分享码
+     */
+    ResponseJson<Integer> checkShopOrderCode(Integer shopOrderId, String shareCode);
+
+    /**
+     * 分享码校验成功、子订单数据
+     * @param shopOrderId
+     * @return
+     */
+    ResponseJson<Map<String, Object>> getShopOrderById(Integer shopOrderId);
+
+    /**
+     * 机构确认订单 -- 供应商给机构下单
+     * @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 orderType, Integer receiptStatus, Integer organizeId, Integer orderStatus, int pageNum, int pageSize);
     /**
      * 供应商结算列表
      * @param shopId         供应商Id
@@ -207,4 +207,20 @@ public interface ShipService {
      * @throws IOException
      */
     void downFile(Integer fileId, HttpServletRequest request, HttpServletResponse response) throws IOException;
+
+    /**
+     * 供应商给机构下单 结算--联合丽格
+     * @param shopId
+     * @param cityId
+     * @param productInfo
+     * @return
+     */
+    ResponseJson<Map<String, Object>> settlementShop(Integer shopId, Integer cityId, String productInfo);
+
+    /**
+     * 供应商取消待确认订单
+     * @param shopOrderId
+     * @return
+     */
+    ResponseJson cancelOrder(Integer shopOrderId);
 }

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

@@ -880,10 +880,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) {
@@ -1174,4 +1174,188 @@ public class OrderClubServiceImpl implements OrderClubService {
         return ResponseJson.success(shop);
     }
 
+    /**
+     * 分享订单，获取分享码 供应商给机构下单
+     *
+     * @param shopOrderId 订单Id
+     */
+    @Override
+    public ResponseJson<Map<String, Object>> getShopOrderShareCode(Integer shopOrderId) {
+
+        Map<String, Object> map = new HashMap<>();
+
+        // 跳转链接
+        String link = domain + "/order-share-login.html?shopOrderId=" + shopOrderId;
+        map.put("link", link);
+        int shopOrderCount = orderClubMapper.countMainShopOrderByOrderId(shopOrderId);
+        if (0 == shopOrderCount) {
+            return ResponseJson.error("订单不存在！", null);
+        }
+        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, 3);
+        // 获取数据库已有分享码
+        OrderShareCodeVo orderCodeVo = orderClubMapper.getShopOrderCodeById(shopOrderId);
+        if (orderCodeVo != null && orderCodeVo.getExpiredTime().compareTo(new Date()) >= 0) {
+            // 旧分享码还未过期，直接返回
+            map.put("shareCode", orderCodeVo.getShareCode());
+            return ResponseJson.success(map);
+        } else if (orderCodeVo != null) {
+            // 如果旧分享码已经过期，删除分享码使用记录
+            orderClubMapper.deleteShopOrderShareCodeRecord(shopOrderId);
+            // 更新数据库的分享码
+            orderCodeVo.setShareCode(shareCode);
+            orderCodeVo.setExpiredTime(calendar.getTime());
+            orderCodeVo.setDelFlag(0);
+            orderClubMapper.updateOrderShareCode(orderCodeVo);
+        } else {
+            // 如果没有分享记录,新增数据库的分享码
+            OrderShareCodeVo newShareCodeVo = new OrderShareCodeVo();
+            newShareCodeVo.setOrderId(shopOrder.getOrderId());
+            newShareCodeVo.setShopOrderId(shopOrderId);
+            newShareCodeVo.setShareCode(shareCode);
+            newShareCodeVo.setExpiredTime(calendar.getTime());
+            newShareCodeVo.setAddTime(new Date());
+            newShareCodeVo.setDelFlag(0);
+            orderClubMapper.insertOrderShareCode(newShareCodeVo);
+        }
+
+        // 新生成的分享码
+        map.put("shareCode", shareCode);
+        return ResponseJson.success(map);
+    }
+
+    /**
+     * 分享订单，校验分享码
+     *
+     * @param shopOrderId   订单Id
+     * @param shareCode     分享码
+     */
+    @Override
+    public ResponseJson<Integer> 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) {
+                return ResponseJson.success(shopOrderId);
+            } else {
+                // 分享码过期
+                return ResponseJson.error("分享码已过期，请联系分享人更新分享码！", null);
+            }
+        } else {
+            return ResponseJson.error("分享码错误！", null);
+        }
+    }
+
+    /**
+     * 分享码校验成功、子订单数据
+     *
+     * @param shopOrderId
+     * @return
+     */
+    @Override
+    public ResponseJson<Map<String, Object>> getShopOrderById(Integer shopOrderId) {
+        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);
+    }
+
+    /**
+     * 机构确认订单 -- 供应商给机构下单
+     *
+     * @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);
+        if (0 != shopOrderInfo.getStatus()) {
+            return ResponseJson.error(-1, "该订单无需再确认！", null);
+        }
+        // 将订单归属到改机构名下 进入系统正常流程
+        shopOrderInfo.setUserId(userId);
+        shopOrderInfo.setClubId(clubId);
+        // 订单状态 已确认
+        shopOrderInfo.setStatus(1);
+        // 修改子订单
+        orderClubMapper.updateShopOrderById(shopOrderInfo);
+        // 修改订单信息
+        orderClubMapper.updateOrderInfoById(shopOrderInfo.getOrderId(), userId, clubId);
+        // 修改订单地址用户信息
+        // 收货地址
+        OrderUserinfoVo userInfo = addressMapper.getOrderUserinfo(shopOrderInfo.getOrderId());
+
+        String userName = baseMapper.getUserNameByUserId(userId);
+        userInfo.setUserId(userId);
+        userInfo.setClubId(clubId);
+        userInfo.setName(userName);
+        userInfo.setOrderId(shopOrderInfo.getOrderId());
+        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;
@@ -39,7 +40,10 @@ 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;
 
@@ -69,6 +73,8 @@ public class ShipServiceImpl implements ShipService {
     @Resource
     private RemoteCallService remoteCallService;
     @Resource
+    private ProductService productService;
+    @Resource
     private OssService ossService;
     @Resource
     private OSSUtils ossUtils;
@@ -91,10 +97,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 orderType, 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, orderType, receiptStatus, organizeId, orderStatus);
         shopOrderList.forEach(shopOrder -> {
             if (null != shopOrder) {
                 setShopOrderInfo(shopOrder);
@@ -1379,4 +1385,311 @@ public class ShipServiceImpl implements ShipService {
             ossService.download(request, response, fileName);
         }
     }
+
+    /**
+     * 供应商给机构下单 结算--联合丽格
+     *
+     * @param shopId
+     * @param cityId
+     * @param productInfo
+     * @return
+     */
+    @Override
+    public ResponseJson<Map<String, Object>> settlementShop(Integer shopId, Integer cityId, String productInfo) {
+        // 用户组织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);
+        // 商品购买数量信息map
+        Map<String, Integer> productInfos = new HashMap<>();
+        // 商品售价信息map
+        Map<String, Double> productPriceInfos = new HashMap<>();
+        // 前端接收商品Id信息
+        List<String> productIdList = new ArrayList<>();
+        //skuIdList
+        List<Integer> skuIdList = new ArrayList<>();
+        // 价格修改异常的商品集合
+        List<CartItemVo> abnormalProductList = new ArrayList<>();
+        // productInfo拆解
+        try {
+            JSONArray productArr = parseArray(productInfo);
+            for (Object o : productArr) {
+                JSONObject product = (JSONObject) o;
+                String productId = product.getString("productId");
+                if (StringUtils.isBlank(productId)) {
+                    return ResponseJson.error(-1, "请选择商品", null);
+                }
+                Integer productCount = product.getInteger("count");
+                if (null == productCount) {
+                    return ResponseJson.error(-1, "请输入商品购买数量", null);
+                }
+                Integer skuId = product.getInteger("skuId");
+                if (null == skuId) {
+                    return ResponseJson.error(-1, "请选择规格", null);
+                }
+                Double price = product.getDouble("price");
+                if (null == price) {
+                    return ResponseJson.error(-1, "请输入价格", null);
+                }
+                productInfos.put(skuId.toString(), productCount);
+                productPriceInfos.put(skuId.toString(), price);
+                productIdList.add(productId);
+                skuIdList.add(skuId);
+            }
+        } catch (Exception e) {
+            log.error("商品信息格式错误", e);
+            return ResponseJson.error("商品信息格式错误！Json字符串格式[{\"id\":4351,\"count\":1,\"skuId:4568,\"price\":100.00},{}]", null);
+        }
+
+        // 商品的分帐号分组的供应商列表
+        // 1带分账号，2不带
+        CartShopVo shop = shipMapper.getCartShopsByShopId(shopId);
+        String helpContent = null;
+        boolean flag = false;
+        if (null != shop) {
+            // 遍历供应商列表
+            List<Integer> 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());
+                // 设置该商品购买数量
+                productList.forEach( p -> {
+                    CmOrganizeSkuPo organizeSkuInfo = shipMapper.getOrganizeSkuInfo(p.getSkuId(), organizeId);
+                    //前端传入修改后商品的价格
+                    double price = productPriceInfos.get(p.getSkuId().toString());
+                    // 该商品成本计算
+                    if (null != organizeSkuInfo) {
+                        // 商品为固定成本
+                        if ( StringUtils.isNotBlank(organizeSkuInfo.getCostCheckFlag()) && "1".equals(organizeSkuInfo.getCostCheckFlag())) {
+                            // 系统商城商品的成本之和
+                            double sysProductPrice = MathUtil.add(organizeSkuInfo.getCostPrice(), MathUtil.add(organizeSkuInfo.getCmCostPrice(), organizeSkuInfo.getOrganizeCostPrice())).doubleValue();
+                            // 系统商品成本之和小于修改的价格，修改价格异常，不允许下单
+                            if (MathUtil.compare(sysProductPrice, price) > 0) {
+                                abnormalProductList.add(p);
+                            }
+                        }
+                    }
+                    p.setPrice(price);
+                    p.setNumber(productInfos.get(p.getSkuId().toString()));
+                });
+                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);
+                        // 阶梯价
+                        if (cartItemVo.getLadderFlag() == 1) {
+                            // 设置阶梯价
+                            productService.setCartLadderPrices(cartItemVo, taxFlag);
+                        }
+                        // 设置商品小计金额
+                        cartItemVo.setTotalPrice(MathUtil.mul(cartItemVo.getNumber(), cartItemVo.getPrice()).doubleValue());
+                        // 该供应商下价格累加
+                        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("shop", shop);
+        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);
+        resultData.put("abnormalProductList", abnormalProductList);
+        // 联合丽格冷链费
+        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);
+    }
+
+    /**
+     * 供应商取消待确认订单
+     *
+     * @param shopOrderId
+     * @return
+     */
+    @Override
+    public ResponseJson cancelOrder(Integer shopOrderId) {
+        ShopOrderVo shopOrder = orderClubMapper.getShopOrderById(shopOrderId);
+        if (null == shopOrder || 0 != shopOrder.getStatus()) {
+            // 非已关闭订单
+            return ResponseJson.error("订单异常！", null);
+        }
+        // 逻辑删除子订单
+        String note = StringUtils.isNotBlank(shopOrder.getNote()) ? shopOrder.getNote() + ", 供应商取消未确认订单" : "供应商取消未确认订单";
+        shipMapper.deleteShopOrder(shopOrderId, note);
+        log.info("【删除订单】>>>>>>>>>逻辑删除子订单(update[cm_shop_order])shopOrderId：" + shopOrderId);
+        // 逻辑删除主订单
+        List<Integer> shopOrderStatus = orderClubMapper.getShopOrderStatus(shopOrder.getOrderId());
+        boolean flag = false;
+        if (shopOrderStatus.stream().allMatch(s -> s == 4)) {
+            flag = true;
+        }
+        if (flag) {
+            orderClubMapper.deleteMainOrder(shopOrder.getOrderId(), "供应商取消未确认订单");
+            log.info("【删除订单】>>>>>>>>>逻辑删除主订单(update[cm_order])orderId：" + shopOrder.getOrderId());
+        }
+        return ResponseJson.success("订单取消成功", null);
+        }
 }

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

@@ -419,10 +419,6 @@ public class SubmitServiceImpl implements SubmitService {
             // 2买家确认
             mainOrder.setConfirmFlag(2);
         }
-        if (1 == organizeId) {
-            // 联合丽格订单
-            mainOrder.setOrderType(3);
-        }
         // 抵扣采美豆数量
         mainOrder.setUserBeans(orderParamBo.getOffsetBeans());
         // 默认可以线上支付：0可以 1不可以
@@ -2229,6 +2225,10 @@ public class SubmitServiceImpl implements SubmitService {
         AtomicReference<Double> shouldPayShopAmount = new AtomicReference<>(0d);
         // 订单商品列表
         List<OrderProductPo> orderProductList = new ArrayList<>();
+        // 能否修改
+        AtomicBoolean isOrder = new AtomicBoolean(false);
+        // 价格修改异常的商品集合
+        List<OrderProductVo> abnormalProductList = new ArrayList<>();
 
         for (OrderProductVo orderProduct : orderProducts) {
             Integer skuId = orderProduct.getSkuId();
@@ -2261,6 +2261,21 @@ public class SubmitServiceImpl implements SubmitService {
             if (null == product) {
                 return ResponseJson.error("订单商品不存在！", null);
             }
+            // 价格修改限制
+            CmOrganizeSkuPo SkuInfo = shipMapper.getOrganizeSkuInfo(skuId, orderProduct.getOrganizeId());
+            // 该商品成本计算
+            if (null != SkuInfo) {
+                // 商品为固定成本
+                if ( StringUtils.isNotBlank(SkuInfo.getCostCheckFlag()) && "1".equals(SkuInfo.getCostCheckFlag())) {
+                    // 系统商城商品的成本之和
+                    double sysProductPrice = MathUtil.add(SkuInfo.getCostPrice(), MathUtil.add(SkuInfo.getCmCostPrice(), SkuInfo.getOrganizeCostPrice())).doubleValue();
+                    // 系统商品成本之和小于修改的价格，修改价格异常，不允许下单
+                    if (MathUtil.compare(sysProductPrice, orderProduct.getPrice()) > 0) {
+                        isOrder.set(true);
+                        abnormalProductList.add(orderProduct);
+                    }
+                }
+            }
 
             // 是否添加税费，不含税商品 开票需添加税费
             boolean taxFlag = false;
@@ -2451,6 +2466,10 @@ public class SubmitServiceImpl implements SubmitService {
             // 加入订单商品列表
             orderProductList.add(product);
         }
+        // 存在不修改商品价格异常商品，不可修改为该价格
+        if (isOrder.get()) {
+            return ResponseJson.error(-1 , "订单商品价格修改异常", abnormalProductList);
+        }
 
         // 佣金 采美应收
         shopOrder.setBrokerage(brokerage.get());
@@ -2514,6 +2533,980 @@ public class SubmitServiceImpl implements SubmitService {
         return ResponseJson.success();
     }
 
+    /**
+     * 生成订单 --- 供应商帮机构下单
+     *
+     * @param submitDto
+     * @return
+     */
+    @Transactional(rollbackFor = Exception.class)
+    @Override
+    public ResponseJson<Map<String, Object>> shopGenerateOrder(SubmitDto submitDto) {
+        log.info("submitDto===" + submitDto);
+
+        JSONArray orderInfo = null;
+        JSONObject payInfo = null;
+        JSONObject orderInvoice = null;
+        JSONObject addressInfo = null;
+        try {
+            orderInfo = parseArray(submitDto.getOrderInfo());
+            payInfo = parseObject(submitDto.getPayInfo());
+            orderInvoice = parseObject(submitDto.getOrderInvoice());
+            addressInfo = parseObject(submitDto.getAddressInfo());
+        } 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);
+        }
+        if (null == addressInfo || addressInfo.isEmpty()) {
+            return ResponseJson.error("地址信息数据异常！", null);
+        }
+        // 打印参数
+        log.info("******************** 【供应商给机构下单】提交订单参数：" + submitDto);
+        // 机构用户
+        OrderParamBo orderParamBo = new OrderParamBo();
+        //订单来源
+        orderParamBo.setOrderSource(submitDto.getOrderSource());
+        //订单商品
+        orderParamBo.setOrderInfo(orderInfo);
+        // 订单地址
+        orderParamBo.setAddressInfo(addressInfo);
+        //订单应付总额
+        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);
+        }
+        orderParamBo.setRebateFlag(0);
+        // 售后条款id
+        Integer clauseId = (Integer) payInfo.get("clauseId");
+        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());
+        /*
+         * 保存订单
+         */
+        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.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);
 
+        // 子订单订单列表
+        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");
+                // 转换价格格式
+                String rate = productTemp.get("price").toString();
+                Double price = Double.parseDouble(rate);
+                productType = (null == productType) ? 0 : productType;
+                if (null == skuId) {
+                    return ResponseJson.error("订单商品数据异常！", null);
+                }
+                if (null == productNum || productNum == 0) {
+                    return ResponseJson.error("商品购买数量异常！", null);
+                }
+                if (null == price) {
+                    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);
+                }
+
+                // 是否添加税费，不含税商品 开票需添加税费
+                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 taxPrice = product.getPrice();
+                // 商品税费
+                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(taxPrice, product.getTaxRate()), 100, 2).doubleValue();
+                    discountTax = MathUtil.div(MathUtil.mul(taxPrice, product.getTaxRate()), 100, 2).doubleValue();
+                } else if (!Integer.valueOf(1).equals(product.getIncludedTax())) {
+                    // 不含税不可开票商品和未知商品，税率置为0
+                    product.setTaxRate(0d);
+                }
+                log.info("productTax===" + productTax);
+                // 商品价格
+                product.setPrice(productPrice);
+                // 商品税后价格
+                Double productTaxPrice = productPrice;
+                // 折后税后单价
+                Double discountTaxPrice = discountPrice;
+                // 折扣率 = 折后单价/机构价
+                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());
+
+        log.info("payTotalFee.get()=------=-=-====" + payTotalFee.get());
+        // 真实支付金额赋值为订单总额
+        payableAmount.set(payTotalFee.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);
+            // 分帐号
+            // 联合丽格
+            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());
+                    });
+                }
+            }
+        }
+
+        /**
+         * 更新主订单的子订单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;
+        // 子订单分帐号
+        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 (item) {
+            String onlinePayWays = "1,2,3,4,5";
+            submitMapper.updateOnlinePayWays(onlinePayWays, mainOrder.getOrderId());
+        }
+        /*
+         * todo 保存 订单收货用户信息 下单时没有用户信息
+         */
+        JSONObject addressinfo = orderParamBo.getAddressInfo();
+        try {
+            // 获取地址信息
+            Integer provinceId = (Integer) addressinfo.get("provinceId");
+            Integer cityId = (Integer) addressinfo.get("cityId");
+            Integer townId = (Integer) addressinfo.get("townId");
+            AddressVo address = submitMapper.getAddressById(provinceId, cityId, townId);
+            //保存地址信息
+            OrderUserInfoPo userInfo = new OrderUserInfoPo();
+            userInfo.setOrderId(mainOrder.getOrderId());
+            userInfo.setReceiver((String) addressinfo.get("receiver"));
+            userInfo.setMobile((String) addressinfo.get("mobile"));
+            userInfo.setTownId(townId);
+            userInfo.setProvince(address.getProvince());
+            userInfo.setCity(address.getCity());
+            userInfo.setTown(address.getTown());
+            userInfo.setAddress((String) addressinfo.get("address"));
+            // 保存 订单收货用户信息
+            submitMapper.insertOrderUserInfo(userInfo);
+            log.info("【提交订单】>>>>>>>>>>>>>>>>>>>>>>>>>>保存订单用户地址(insert[bp_order_userinfo])orderId：" + mainOrder.getOrderId());
+        } catch ( Exception e) {
+            e.printStackTrace();
+            //设置手动回滚事务
+            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("shopOrderId", shopOrderList.get(0).getShopOrderId());
+        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

@@ -253,6 +253,7 @@
             cso.orderID AS orderId,
             IFNULL(cso.organizeID, 0) AS organizeId,
             IFNULL(cso.isColdChina, 0) AS isColdChina,
+            cso.orderType,
             cso.orderNo,
             cso.shopID AS shopId,
             cso.note,
@@ -1147,4 +1148,41 @@
     <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
+            orderId,
+            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="updateOrderInfoById">
+        update cm_order
+        set status = 11,
+            userId = #{userId},
+            clubId = #{clubId}
+        where orderId = #{orderId}
+    </update>
+
+    <update id="updateOrderUserInfoById">
+        update bp_order_userinfo
+        set userId = #{userId},
+            clubId = #{clubId},
+            name = #{name}
+        where orderId = #{orderId}
+    </update>
 </mapper>

src/main/resources/mapper/ShipMapper.xml

@@ -164,6 +164,9 @@
             <if test="refundStatus != null">
                 and a.refundStatus = #{refundStatus}
             </if>
+            <if test="orderType != null">
+                and a.orderType = #{orderType}
+            </if>
             <if test="receiptStatus != null">
                 and a.receiptStatus = #{receiptStatus}
             </if>
@@ -173,8 +176,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>
@@ -249,6 +261,7 @@
             cso.shopOrderNo,
             cso.orderID AS orderId,
             cso.orderNo,
+            cso.orderType,
             cso.shopID AS shopId,
             cso.organizeID as organizeId,
             IFNULL(cso.isColdChina, 0) AS isColdChina,
@@ -276,7 +289,7 @@
             cso.orderTime,
             cso.orderSubmitType,
             cso.payStatus,
-            cso.settlestatus,
+            ifnull(cso.settlestatus, 1) as settlestatus,
             ifnull(cso.sendOutStatus, 1) as sendOutStatus,
             ifnull(cso.receiptStatus, 1) as receiptStatus,
             ifnull(cso.orderStatusFlag, 1) as orderStatusFlag,
@@ -587,4 +600,82 @@
             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
+        distinct 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,
+        cs.ladderPriceFlag           AS ladderFlag,
+        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.returnGoodsStutas
+        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>
+        <if test="skuIds.size()>0">
+            AND cs.skuId in
+            <foreach collection="skuIds" open="(" separator="," close=")" item="skuId">
+                #{skuId}
+            </foreach>
+        </if>
+        ORDER BY cs.skuId DESC
+    </select>
+
+    <select id="getOrganizeSkuInfo" resultType="com.caimei365.order.model.po.CmOrganizeSkuPo">
+        SELECT distinct cs.skuId,
+                        cs.productId,
+                        cs.minBuyNumber,
+                        cs.price,
+                        cs.unit,
+                        cs.stock,
+                        ifnull(copi.costCheckFlag, 1)   as costCheckFlag,
+                        IFnull(cs.costPrice, 0)         as costPrice,
+                        IFNULL(cs.organizeCostPrice, 0) AS organizeCostPrice,
+                        IFNULL(cs.cmCostPrice, 0)       AS cmCostPrice,
+                        ifnull(cs.organizePercent, 0)   as organizePercent,
+                        ifnull(cs.shopPercent, 0)       as shopPercent,
+                        ifnull(cs.cmPercent, 0)         as cmPercent
+        FROM cm_sku cs
+                 LEFT JOIN cm_organize_product_info copi ON cs.productId = copi.productId
+        WHERE cs.skuId = #{skuId}
+          AND cs.organizeId = #{organizeId}
+          AND copi.organizeId = #{organizeId}
+    </select>
+
+    <update id="deleteShopOrder">
+        UPDATE cm_shop_order
+        SET delFlag=1,
+            note = #{note}
+        WHERE shopOrderID = #{shopOrderId}
+    </update>
 </mapper>

src/main/resources/mapper/SubmitMapper.xml

@@ -501,6 +501,8 @@
         set price                   = #{price},
             discountPrice           = #{price},
             costPrice               = #{costPrice},
+            organizeCostPrice       = #{organizeCostPrice},
+            cmCostPrice             = #{cmCostPrice},
             totalAmount             = #{totalAmount},
             totalFee                = #{totalFee},
             shouldPayFee            = #{shouldPayFee},
@@ -573,4 +575,28 @@
             shouldPayShopAmount = #{shouldPayShopAmount}
         where shopOrderId = #{shopOrderId}
     </update>
+
+    <select id="getAddressById" resultType="com.caimei365.order.model.vo.AddressVo">
+        SELECT
+               t.name       AS town,
+               c.name       AS city,
+               c.cityID     AS cityId,
+               p.name       AS province,
+               p.provinceID AS provinceId
+        FROM town t
+                 LEFT JOIN city c ON c.cityID = t.cityID
+                 LEFT JOIN province p ON p.provinceID = c.provinceID
+        <where>
+            <if test="provinceId != null and townId == null">
+                and p.provinceID = #{provinceId}
+            </if>
+            <if test="cityId != null and townId == null">
+                and c.cityID = #{cityId}
+            </if>
+            <if test="townId != null">
+                and t.townID = #{townId}
+            </if>
+        </where>
+        LIMIT 1
+    </select>
 </mapper>