联合丽格

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

@@ -54,14 +54,17 @@ public class HeliPayUtil {
     private String quickPayUrl;
     @Value("${pay.quick-un-url}")
     private String quickUnOrderUrl;
+    @Value("${wx.mcare-app-id}")
+    private String mcareAppId;
 
     // 采美
     private final String publicCode = "wx91c4152b60ca91a3";
     // 联合丽格
-    private final String ligueCode = "wxaa4acc852618da69";
+    //    private final String mcareCode = "wxaa4acc852618da69";
 
     //小程序/公众号线上公用方法 p8 openid在自己方法传
     public AppPayPublicCreateOrderVo setOnlineValue(AppPayPublicCreateOrderVo pay, HeliDto heliDto, String payFlag, HttpHeaders headers) {
+
         String orderId = "";
         // 时间戳
         long time = System.currentTimeMillis() / 1000;
@@ -153,17 +156,17 @@ public class HeliPayUtil {
         pay.setP13_successToUrl(heliDto.getReturnUrl());
         if ("GZH".equals(heliDto.getPayType())) {
             //公众号appid
-            if (1 == heliDto.getOrganizeId()) {
+            if (0 != heliDto.getOrganizeId()) {
                 // 联合丽格
-                pay.setP5_appid(ligueCode);
+                pay.setP5_appid(publicCode);
             } else {
                 pay.setP5_appid(publicCode);
             }
         } else if ("XCX".equals(heliDto.getPayType())) {
             //小程序appid
-            if (1 == heliDto.getOrganizeId()) {
+            if (0 != heliDto.getOrganizeId()) {
                 // 联合丽格
-                pay.setP5_appid(ligueCode);
+                pay.setP5_appid(mcareAppId);
             } else {
                 pay.setP5_appid(miniAppId);
             }

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

@@ -183,8 +183,10 @@ public class ProductService {
      * @param skuIdList     商品Id列表
      */
     public Map<String, Object> computePostage(Integer userId, Integer townId, List<String> skuIdList) {
+        // 用户组织Id
+        Integer organizeId = baseMapper.getOrganizeId(userId);
         // 返回数据初始化
-        Map<String, Object> postageMap = new HashMap<>(3);
+        Map<String, Object> postageMap = new HashMap<>(4);
         // 运费标志：0包邮 -1到付 1遵循运费规则
         int postageFlag = 0;
         // 运费
@@ -205,6 +207,10 @@ public class ProductService {
         if (null != postageFlagList && postageFlagList.size() > 0) {
             for (ProductPostageVo postageVo : postageFlagList) {
                 if (null != postageVo) {
+                    if (7502 == postageVo.getProductId()) {
+                        postageMap.put("coldChain", 700);
+                        continue;
+                    }
                     // 是否是仪器 或 设置了运费到付
                     boolean flag = (null == postageVo.getCommodityType() || 2 == postageVo.getCommodityType() || (null != postageVo.getPostageFlag() && 1 == postageVo.getPostageFlag()));
                     if (flag) {
@@ -220,7 +226,14 @@ public class ProductService {
             }
         }
         // 是否首单（统计订单数）
-        Integer count = baseMapper.countUserOrder(userId);
+        Integer count = null;
+        if (0 == organizeId) {
+            // 采美
+            count = baseMapper.countUserOrder(userId);
+        } else {
+            // 组织 -- 联合丽格无首单优惠
+            count = -1;
+        }
         // 包邮条件：首单 或 包邮（上一步未被设置成不包邮）
         boolean freeFlag = ((null != count && count == 0) || postageFlag == 0);
         if (freeFlag) {

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

@@ -57,6 +57,10 @@ public class WeChatService {
     private String heHeAppId;
     @Value("${wx.hehe-app-secret}")
     private String heHeAppSecret;
+    @Value("${wx.mcare-app-id}")
+    private String mcareAppId;
+    @Value("${wx.mcare-app-secret}")
+    private String mcareAppSecret;
 
     /**
      * 收款通知模板Id
@@ -144,6 +148,12 @@ public class WeChatService {
             log.info("收款工具小程序appId: ---" + receiptAppId);
             // 收款工具小程序appSecret
             requestUrlParam.put("secret", receiptAppSecret);
+        } else if (mode == 3) {
+            // 联合丽格小程序appId
+            requestUrlParam.put("appid", mcareAppId);
+            log.info("联合丽格小程序appId: ---" + mcareAppId);
+            // 联合丽格小程序appSecret
+            requestUrlParam.put("secret", mcareAppSecret);
         } else {
             // 呵呵商城小程序appId
             requestUrlParam.put("appid", heHeAppId);

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

@@ -86,6 +86,19 @@ public class CartClubApi {
         return cartClubService.getUserCartCount(userId);
     }
 
+    /**
+     * 获取购物车商品种类 -- 组织
+     */
+    @ApiOperation("获取购物车数量（旧：/home/modules内）")
+    @ApiImplicitParam(required = true, name = "userId", value = "用户Id")
+    @GetMapping("/cart/organizeCount")
+    public ResponseJson<Integer> getShoppingCartOrganizeCount(Integer userId) {
+        if (null == userId) {
+            return ResponseJson.error("用户Id不能为空！", null);
+        }
+        return cartClubService.getShoppingCartOrganizeCount(userId);
+    }
+
     /**
      * 添加购物车
      *

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

@@ -2,6 +2,7 @@ package com.caimei365.order.controller;
 
 import com.caimei365.order.model.ResponseJson;
 import com.caimei365.order.model.dto.OrderDto;
+import com.caimei365.order.model.dto.VoucherDto;
 import com.caimei365.order.model.vo.*;
 import com.caimei365.order.service.OrderClubService;
 import com.github.pagehelper.PageInfo;
@@ -109,6 +110,17 @@ public class OrderClubApi {
         return orderClubService.getOrderDetail(userId, orderId);
     }
 
+    /**
+     * 添加支付凭证
+     * @param voucherDto
+     * @return
+     */
+    @PostMapping("/insertVoucher")
+    public ResponseJson voucher(VoucherDto voucherDto) {
+
+        return orderClubService.voucher(voucherDto);
+    }
+
     /**
      * 机构最新订单
      */

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

@@ -124,9 +124,6 @@ public class OrderSubmitApi {
         if (3 == submitDto.getCartType() && null == submitDto.getServiceProviderId()) {
             return ResponseJson.error("协销Id不能为空！", null);
         }
-        if (null == submitDto.getOrganizeId()) {
-            return ResponseJson.error("订单类型不能为空！", null);
-        }
         return submitService.generateOrder(submitDto);
     }
 

src/main/java/com/caimei365/order/feign/UserFeign.java

@@ -25,4 +25,16 @@ public interface UserFeign {
      */
     @PostMapping("/user/login/auth/applets")
     String appletsAuthorization(@RequestParam String code, @RequestParam String encryptedData, @RequestParam String iv, @RequestHeader("Referer") String referer);
+
+    /**
+     * 微信小程序授权登录（调用user服务，发送服务间调用POST请求） -- 组织
+     *
+     * @param code          微信code
+     * @param encryptedData 微信加密数据
+     * @param iv            微信加密算法的初始向量
+     * @param referer       HttpHeaders(referer)
+     * @return str
+     */
+    @PostMapping("/user/login/auth/appletsOrganize")
+    String appletsOrganizeAuthorization(@RequestParam String code, @RequestParam String encryptedData, @RequestParam String iv, @RequestHeader("Referer") String referer);
 }

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

@@ -19,11 +19,18 @@ import java.util.List;
 @Mapper
 public interface BaseMapper {
     /**
-     * 获取用户组织Id
+     * 获取用户组织Id -- userId
      * @param userId
      * @return
      */
     Integer getOrganizeId(@Param("userId") Integer userId);
+
+    /**
+     * 获取用户组织Id -- shopOrderId
+     * @param shopOrderId
+     * @return
+     */
+    Integer getOrganizeIdShop(@Param("shopOrderId") Integer shopOrderId);
     /**
      * 供应商名称
      * @param shopId 供应商Id

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

@@ -42,6 +42,13 @@ public interface CartClubMapper {
      * @param userId 用户Id
      */
     List<CartItemVo> getCartProductList(Integer userId);
+
+    /**
+     * 获取购物车商品列表（不区分供应商） - 组织
+     * @param userId
+     * @return
+     */
+    List<CartItemVo> getCartOrganizeProductList(Integer userId);
     /**
      * 获取购物车
      * @param cartDto userId,productId
@@ -81,6 +88,17 @@ public interface CartClubMapper {
      */
     List<CartItemVo> getCartProductsByShopIdAndProductIds(@Param("userId") Integer userId,@Param("shopId")  Integer shopId, @Param("skuIds") List<String> skuIds,@Param("splitCode")String splitCode);
 
+    /**
+     * 根据商品Ids获取购物车已上架商品列表 -- 组织
+     * @param userId
+     * @param shopId
+     * @param organizeId
+     * @param skuIds
+     * @param splitCode
+     * @return
+     */
+    List<CartItemVo> getCartProductsOrganize(@Param("userId") Integer userId,@Param("shopId")  Integer shopId,@Param("organizeId") Integer organizeId, @Param("skuIds") List<String> skuIds,@Param("splitCode")String splitCode);
+
     /**
      * 根据商品id获取已上架商品列表
      * @param shopId
@@ -109,6 +127,12 @@ public interface CartClubMapper {
      * @param skuId
      */
     CartItemVo getCartItemByProductId(Integer skuId);
+    /**
+     * 根据skuId获取下单商品信息 -- 组织
+     * @param skuId
+     * @return
+     */
+    CartItemVo getCartOrganizeProductId(Integer skuId);
 
     List<Integer> findVipCoupon();
     /**

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

@@ -1,6 +1,8 @@
 package com.caimei365.order.mapper;
 
 import com.caimei365.order.model.bo.OrderParamBo;
+import com.caimei365.order.model.dto.VoucherDto;
+import com.caimei365.order.model.dto.VoucherImageDto;
 import com.caimei365.order.model.po.*;
 import com.caimei365.order.model.vo.*;
 import org.apache.ibatis.annotations.Mapper;
@@ -353,4 +355,16 @@ public interface OrderClubMapper {
     List<Sku> findSkus(Integer productId);
 
     List<Sku> getOrganizeSku(@Param("productId") Integer productId);
+
+    List<VoucherPo> getVoucher(@Param("orderId") Integer orderId);
+
+    List<VoucherImageDto> getVoucherImage(@Param("voucherIds") List<Integer> voucherIds);
+
+    void updateVoucher(VoucherDto voucherDto);
+
+    void insertVoucher(VoucherDto voucherDto);
+
+    void updateVoucherImage(VoucherImageDto voucherImageDto);
+
+    void insertVoucherImage(VoucherImageDto voucherImageDto);
 }

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

@@ -48,6 +48,12 @@ public interface SubmitMapper {
      * @param skuId     skuId
      */
     OrderProductPo getProductDetails(Integer skuId);
+    /**
+     * 获取数据库商品信息 --组织
+     *
+     * @param skuId     skuId
+     */
+    OrderProductPo getProductOrganizeDetails(Integer skuId);
 
     /**
      * 抵扣后更新用户余额
@@ -98,6 +104,12 @@ public interface SubmitMapper {
      */
     void updateShopOrderIds(String shopOrderIds, Integer orderId);
 
+    /**
+     * 外部商城sku信息
+     * @param skuId
+     * @return
+     */
+    CmOrganizeSkuPo getOrganizeSkuInfo(@Param("skuId") Integer skuId);
     /**
      * 查询订单增值税发票
      */
@@ -147,6 +159,8 @@ public interface SubmitMapper {
 
     void updateOnlinePayFlag(Integer onlinePayFlag, Integer orderId);
 
+    void updateOnlinePayWays(String onlinePayWays, Integer orderId);
+
     List<OrderShopPo> findShops(List<String> productIdList);
 
     Integer findSplitResult(List<String> productIdList);

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

@@ -24,11 +24,6 @@ public class SubmitDto implements Serializable {
      */
     @ApiModelProperty("机构Id")
     private Integer clubId;
-    /**
-     * 组织Id
-     */
-    @ApiModelProperty("组织id 采美默认为0")
-    private Integer organizeId;
     /**
      * 微信unionId
      */
@@ -120,7 +115,6 @@ public class SubmitDto implements Serializable {
         return "SubmitDto{" +
                 "orderSeen=" + orderSeen +
                 ", clubId=" + clubId +
-                ", organizeId=" + organizeId +
                 ", unionId='" + unionId + '\'' +
                 ", addressId=" + addressId +
                 ", orderSource=" + orderSource +

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

@@ -0,0 +1,31 @@
+package com.caimei365.order.model.dto;
+
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * Description
+ *
+ * @author : Charles
+ * @date : 2023/5/13
+ */
+@Data
+public class VoucherDto {
+    /**
+     * id
+     */
+    private Integer id;
+    /**
+     * 订单Id
+     */
+    private Integer orderId;
+    /**
+     * 备注
+     */
+    private String remarks;
+    /**
+     * 图片信息
+     */
+    private String voucherImgs;
+}

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

@@ -0,0 +1,25 @@
+package com.caimei365.order.model.dto;
+
+import lombok.Data;
+
+/**
+ * Description
+ *
+ * @author : Charles
+ * @date : 2023/5/13
+ */
+@Data
+public class VoucherImageDto {
+    /**
+     * id
+     */
+    private Integer id;
+    /**
+     * 支付凭证Id
+     */
+    private Integer voucherId;
+    /**
+     * 支付凭证img
+     */
+    private String img;
+}

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

@@ -0,0 +1,74 @@
+package com.caimei365.order.model.po;
+
+import lombok.Data;
+
+/**
+ * Description
+ *
+ * @author : Charles
+ * @date : 2023/5/10
+ */
+@Data
+public class CmOrganizeSkuPo {
+    private Integer id;
+    /**
+     * 商品Id
+     */
+    private Integer productId;
+    /**
+     * 外部商城SkuId
+     */
+    private Integer organId;
+    /**
+     * 采美SkuId
+     */
+    private Integer skuId;
+    /**
+     * 外部商城productId
+     */
+    private Integer mallProductId;
+    /**
+     * 外部商城起订量
+     */
+    private Integer minBuyNumber;
+    /**
+     * 外部商城售价
+     */
+    private Double price;
+    /**
+     * 包装规格
+     */
+    private String unit;
+    /**
+     * 机构价
+     */
+    private String clubPrice;
+    /**
+     * 成本类型：1固定成本 2比例成本
+     */
+    private String costCheckFlag;
+    /**
+     * 成本价
+     */
+    private Double costPrice;
+    /**
+     * 比例成本百分比
+     */
+    private Double costProportional;
+    /**
+     * 采美起订量
+     */
+    private Integer cmMinBuyNumber;
+    /**
+     * 分账组织佣金比例
+     */
+    private Integer organizePercent;
+    /**
+     * 分账供应商成本比例
+     */
+    private Integer shopPercent;
+    /**
+     * 分账采美佣金比例
+     */
+    private Integer cmPercent;
+}

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

@@ -30,6 +30,14 @@ public class OrderProductPo implements Serializable {
      * 供应商Id
      */
     private Integer shopId;
+    /**
+     * 组织的商品Id
+     */
+    private Integer organizeProductId;
+    /**
+     * 组织Id
+     */
+    private Integer organizeId;
     /**
      * 商品名称
      */
@@ -234,4 +242,16 @@ public class OrderProductPo implements Serializable {
      * 商品分账号
      */
     private String splitCode;
+    /**
+     * 外部商城付采美佣金比例
+     */
+    private Integer cmPercent;
+    /**
+     * 外部商城付组织佣金比例
+     */
+    private Integer organizePercent;
+    /**
+     * 外部商城付组织供应商佣金比例快照
+     */
+    private Integer shopPercent;
 }

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

@@ -49,6 +49,10 @@ public class OrderShopPo implements Serializable {
      * 订单号
      */
     private Integer orderId;
+    /**
+     * 组织Id
+     */
+    private Integer organizeId;
     /**
      * 订单编号
      */

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

@@ -0,0 +1,36 @@
+package com.caimei365.order.model.po;
+
+import com.caimei365.order.model.dto.VoucherImageDto;
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * Description
+ *
+ * @author : Charles
+ * @date : 2023/5/15
+ */
+@Data
+public class VoucherPo {
+    /**
+     * id
+     */
+    private Integer id;
+    /**
+     * 订单Id
+     */
+    private Integer orderId;
+    /**
+     * 备注
+     */
+    private String remarks;
+    /**
+     * 添加时间
+     */
+    private String addtime;
+    /**
+     * 支付凭证图片信息
+     */
+    private List<VoucherImageDto> imgs;
+}

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

@@ -43,6 +43,10 @@ public class ShopOrderVo implements Serializable {
      * 订单号
      */
     private Integer orderId;
+    /**
+     * 组织Id
+     */
+    private Integer organizeId;
     /**
      * 订单编号
      */

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

@@ -145,6 +145,13 @@ public interface CartClubService {
      */
     ResponseJson<Integer> getUserCartCount(Integer userId);
 
+    /**
+     * 获取机构购物车数量（商品种类数） -- 组织
+     * @param userId
+     * @return
+     */
+    ResponseJson<Integer> getShoppingCartOrganizeCount(Integer userId);
+
     /**
      * 组合商品立即购买
      *

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

@@ -1,6 +1,7 @@
 package com.caimei365.order.service;
 
 import com.caimei365.order.model.ResponseJson;
+import com.caimei365.order.model.dto.VoucherDto;
 import com.caimei365.order.model.vo.*;
 import com.github.pagehelper.PageInfo;
 import org.springframework.http.HttpHeaders;
@@ -46,6 +47,13 @@ public interface OrderClubService {
      * @param orderId    订单Id
      */
     ResponseJson<Map<String, Object>> getOrderDetail(Integer userId, Integer orderId);
+
+    /**
+     * 上传支付凭证
+     * @param voucherDto
+     * @return
+     */
+    ResponseJson voucher(VoucherDto voucherDto);
     /**
      * 机构最新订单
      * @param userId     用户Id

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

@@ -40,6 +40,17 @@ public interface RemoteCallService {
      */
     String appletsAuthorization(String code, String encryptedData, String iv, HttpHeaders headers);
 
+    /**
+     * 微信小程序授权登录（调用user服务，发送服务间调用POST请求） - 组织
+     * @param code              微信code
+     * @param encryptedData     微信加密数据
+     * @param iv                微信加密算法的初始向量
+     * @param headers           HttpHeaders
+     * @param userId            userId
+     * @return
+     */
+    String appletsOrganizeAuthorization(String code, String encryptedData, String iv, HttpHeaders headers, Integer userId);
+
     /**
      * 智能获取物流信息
      *

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

@@ -166,153 +166,175 @@ public class CartClubServiceImpl implements CartClubService {
                     } else {
                         cartItemVo.setSkus(orderClubMapper.getOrganizeSku(cartItemVo.getProductId()));
                     }
-                    // 设置商品图片及税费
-                    boolean taxFlag = productService.setCartItemImgAndTax(cartItemVo);
-                    // 商品可见度： 3:所有人可见，2:普通机构可见，1:会员机构可见，4:仅医美机构可见
-                    Integer visibility = cartItemVo.getVisibility();
-                    boolean visibleFlag = visibility == 3 || visibility == 2 || (visibility == 1 && (finalUserIdentity == 2 || svipUserFlag)) || (visibility == 4 && finalUserClubType == 1);
-                    if (!visibleFlag) {
-                        //不可见商品 不加入失效商品，直接去除
-                        productIterator.remove();
-                    }
-                    // 已上架商品
-                    else if (cartItemVo.getValidFlag() == 2) {
-                        // 设置商品有效
-                        cartItemVo.setStatus(0);
-                        // 默认所有商品未选中状态（前端要求）
-                        cartItemVo.setIsChecked(false);
-                        // 价格可见度： 0公开价格，1不公开价格，2仅对会员机构公开，3仅对医美机构公开
-                        boolean priceVisible = (cartItemVo.getPriceFlag() == 0 || (cartItemVo.getPriceFlag() == 2 && (finalUserIdentity == 2 || svipUserFlag)) || (cartItemVo.getPriceFlag() == 3 && finalUserClubType == 1));
-                        // 是否库存充足  只看所有sku的stock是否为0
-//                        boolean isStocked = (cartItemVo.getStock() != null && cartItemVo.getStock() > 0 && cartItemVo.getStock() >= cartItemVo.getMin() && cartItemVo.getStock() >= cartItemVo.getNumber());
-                        boolean isStocked = orderCommonMapper.findMaxStock(cartItemVo.getProductId()) > 0;
-                        if (priceVisible && isStocked) {
-                            if (1 == cartItemVo.getSvipProductFlag()) {
-                                // 超级会员优惠商品,不参与促销活动（普通机构购买该商品可参与店铺促销）/阶梯价/复购价
-                                // 超级会员设置商品优惠价
-                                productService.setSvipProductPrice(cartItemVo, taxFlag, svipUserFlag);
-                                if (svipUserFlag) {
-                                    // 超级会员设置超级会员优惠总额 + 商品优惠金额
-                                    shopSvipReducedPrice.set(MathUtil.add(shopSvipReducedPrice, cartItemVo.getSvipTotalReducedPrice()).doubleValue());
-                                }
-                            } else {
-                                //失效无库存不统计
-                                totalCount.updateAndGet(v -> v - 1);
-                                kindCount.updateAndGet(v -> v - 1);
-                                // 获取商品促销信息
-                                PromotionsVo promotions = null;
-                                // 没有店铺促销时，商品促销才有效
-                                if (null == shopPromotion) {
-                                    // 获取商品促销信息
-                                    promotions = baseMapper.getPromotionByProductId(cartItemVo.getProductId());
-                                    // 促销活动如果协销不可见直接置空
-                                    if (promotions != null && promotions.getSeen() != null && promotions.getSeen() == 2 && finalUserIdentity == 1) {
-                                        promotions = null;
-                                    }
-                                    /*
-                                     * 设置商品促销优惠
-                                     */
-                                    if (null != promotions) {
-                                        if (1 == promotions.getMode()) {
-                                            promotions.setTouchPrice(baseMapper.getTouchPriceBySku(cartItemVo.getSkuId(), promotions.getId()));
+                    if (0 == organizeId) {
+                        // 设置商品图片及税费
+                        boolean taxFlag = productService.setCartItemImgAndTax(cartItemVo);
+                        // 商品可见度： 3:所有人可见，2:普通机构可见，1:会员机构可见，4:仅医美机构可见
+                        Integer visibility = cartItemVo.getVisibility();
+                        boolean visibleFlag = visibility == 3 || visibility == 2 || (visibility == 1 && (finalUserIdentity == 2 || svipUserFlag)) || (visibility == 4 && finalUserClubType == 1);
+                        if (!visibleFlag) {
+                            //不可见商品 不加入失效商品，直接去除
+                            productIterator.remove();
+                        }
+                        // 已上架商品
+                        else if (cartItemVo.getValidFlag() == 2) {
+                            // 设置商品有效
+                            cartItemVo.setStatus(0);
+                            // 默认所有商品未选中状态（前端要求）
+                            cartItemVo.setIsChecked(false);
+                            // 价格可见度： 0公开价格，1不公开价格，2仅对会员机构公开，3仅对医美机构公开
+                            boolean priceVisible = (cartItemVo.getPriceFlag() == 0 || (cartItemVo.getPriceFlag() == 2 && (finalUserIdentity == 2 || svipUserFlag)) || (cartItemVo.getPriceFlag() == 3 && finalUserClubType == 1));
+                            // 是否库存充足  只看所有sku的stock是否为0
+    //                        boolean isStocked = (cartItemVo.getStock() != null && cartItemVo.getStock() > 0 && cartItemVo.getStock() >= cartItemVo.getMin() && cartItemVo.getStock() >= cartItemVo.getNumber());
+                            boolean isStocked = orderCommonMapper.findMaxStock(cartItemVo.getProductId()) > 0;
+                            if (priceVisible && isStocked) {
+                                    if (1 == cartItemVo.getSvipProductFlag()) {
+                                        // 超级会员优惠商品,不参与促销活动（普通机构购买该商品可参与店铺促销）/阶梯价/复购价
+                                        // 超级会员设置商品优惠价
+                                        productService.setSvipProductPrice(cartItemVo, taxFlag, svipUserFlag);
+                                        if (svipUserFlag) {
+                                            // 超级会员设置超级会员优惠总额 + 商品优惠金额
+                                            shopSvipReducedPrice.set(MathUtil.add(shopSvipReducedPrice, cartItemVo.getSvipTotalReducedPrice()).doubleValue());
                                         }
-                                        // 当前促销活动的价格计算列表
-                                        List<PromotionPriceVo> promotionPriceList = productService.getPromotionProducts(promotions, cartItemVo, taxFlag);
-                                        BigDecimal totalAmount = MathUtil.mul(cartItemVo.getNumber(), cartItemVo.getPrice());
-                                        Double floor = Math.floor(MathUtil.div(totalAmount, promotions.getTouchPrice()).doubleValue());
-                                        // 更新到总促销列表
-                                        productService.updateTotalPromotions(totalPromotions, promotionsIds, promotions, promotionPriceList, floor);
-                                        //单品满减-计算供应商总价/满减金额
-                                        // 叠加优惠计算
-                                        if (promotions.getType() == 1 && promotions.getMode() == 2) {
-                                            if (promotions.getDiscount() != null && promotions.getDiscount() == 1 && floor > 1) {
-                                                //叠加优惠计算
-                                                //叠加倍数
-                                                shopPrice.set(MathUtil.sub(shopPrice.get(), MathUtil.mul(promotions.getReducedPrice(), floor)).doubleValue());
-                                                shopReducedPrice.set(MathUtil.add(shopReducedPrice, MathUtil.mul(promotions.getReducedPrice(), floor)).doubleValue());
-                                            } else {
-                                                // 如果满足促销条件，设置供应商价格-满减金额，满减总额 + 当前促销满减金额
-                                                shopPrice.set(MathUtil.sub(shopPrice.get(), promotions.getReducedPrice()).doubleValue());
-                                                shopReducedPrice.set(MathUtil.add(shopReducedPrice, promotions.getReducedPrice()).doubleValue());
+                                    } else {
+                                        //失效无库存不统计
+                                        totalCount.updateAndGet(v -> v - 1);
+                                        kindCount.updateAndGet(v -> v - 1);
+                                        // 获取商品促销信息
+                                        PromotionsVo promotions = null;
+                                        // 没有店铺促销时，商品促销才有效
+                                        if (null == shopPromotion) {
+                                            // 获取商品促销信息
+                                            promotions = baseMapper.getPromotionByProductId(cartItemVo.getProductId());
+                                            // 促销活动如果协销不可见直接置空
+                                            if (promotions != null && promotions.getSeen() != null && promotions.getSeen() == 2 && finalUserIdentity == 1) {
+                                                promotions = null;
+                                            }
+                                            /*
+                                             * 设置商品促销优惠
+                                             */
+                                            if (null != promotions) {
+                                                if (1 == promotions.getMode()) {
+                                                    promotions.setTouchPrice(baseMapper.getTouchPriceBySku(cartItemVo.getSkuId(), promotions.getId()));
+                                                }
+                                                // 当前促销活动的价格计算列表
+                                                List<PromotionPriceVo> promotionPriceList = productService.getPromotionProducts(promotions, cartItemVo, taxFlag);
+                                                BigDecimal totalAmount = MathUtil.mul(cartItemVo.getNumber(), cartItemVo.getPrice());
+                                                Double floor = Math.floor(MathUtil.div(totalAmount, promotions.getTouchPrice()).doubleValue());
+                                                // 更新到总促销列表
+                                                productService.updateTotalPromotions(totalPromotions, promotionsIds, promotions, promotionPriceList, floor);
+                                                //单品满减-计算供应商总价/满减金额
+                                                // 叠加优惠计算
+                                                if (promotions.getType() == 1 && promotions.getMode() == 2) {
+                                                    if (promotions.getDiscount() != null && promotions.getDiscount() == 1 && floor > 1) {
+                                                        //叠加优惠计算
+                                                        //叠加倍数
+                                                        shopPrice.set(MathUtil.sub(shopPrice.get(), MathUtil.mul(promotions.getReducedPrice(), floor)).doubleValue());
+                                                        shopReducedPrice.set(MathUtil.add(shopReducedPrice, MathUtil.mul(promotions.getReducedPrice(), floor)).doubleValue());
+                                                    } else {
+                                                        // 如果满足促销条件，设置供应商价格-满减金额，满减总额 + 当前促销满减金额
+                                                        shopPrice.set(MathUtil.sub(shopPrice.get(), promotions.getReducedPrice()).doubleValue());
+                                                        shopReducedPrice.set(MathUtil.add(shopReducedPrice, promotions.getReducedPrice()).doubleValue());
+                                                    }
+                                                }
+                                                cartItemVo.setPromotions(promotions);
                                             }
                                         }
-                                        cartItemVo.setPromotions(promotions);
-                                    }
-                                }
-                                if (null != promotions || null != shopPromotion) {
-                                    // 商品处于活动状态
-                                    cartItemVo.setActStatus(1);
-                                    // 关闭阶梯价格，活动优先
-                                    cartItemVo.setLadderFlag(0);
-                                } else {
-                                    if (1 == cartItemVo.getLadderFlag()) {
-                                        // 设置阶梯价
-                                        productService.setCartLadderPrices(cartItemVo, taxFlag);
-                                    } else {
-                                        // 复购价
-                                        Double repurchase = baseMapper.getRepurchasePrice(cartItemVo.getSkuId(), userId);
-                                        if (null != repurchase && repurchase > 0) {
-                                            if (taxFlag) {
-                                                BigDecimal cartItemTax = MathUtil.div(MathUtil.mul(repurchase, cartItemVo.getTaxRate()), 100, 2);
-                                                cartItemVo.setPrice(MathUtil.add(repurchase, cartItemTax).doubleValue());
+                                        if (null != promotions || null != shopPromotion) {
+                                            // 商品处于活动状态
+                                            cartItemVo.setActStatus(1);
+                                            // 关闭阶梯价格，活动优先
+                                            cartItemVo.setLadderFlag(0);
+                                        } else {
+                                            if (1 == cartItemVo.getLadderFlag()) {
+                                                // 设置阶梯价
+                                                productService.setCartLadderPrices(cartItemVo, taxFlag);
                                             } else {
-                                                cartItemVo.setPrice(repurchase);
+                                                // 复购价
+                                                Double repurchase = baseMapper.getRepurchasePrice(cartItemVo.getSkuId(), userId);
+                                                if (null != repurchase && repurchase > 0) {
+                                                    if (taxFlag) {
+                                                        BigDecimal cartItemTax = MathUtil.div(MathUtil.mul(repurchase, cartItemVo.getTaxRate()), 100, 2);
+                                                        cartItemVo.setPrice(MathUtil.add(repurchase, cartItemTax).doubleValue());
+                                                    } else {
+                                                        cartItemVo.setPrice(repurchase);
+                                                    }
+                                                }
                                             }
                                         }
                                     }
+                                // 该供应商下价格累加
+                                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 (0 == organizeId) {
+                                    if (!(1 == cartItemVo.getSvipProductFlag() && svipUserFlag)) {
+                                        // 超级会员购买svip商品不享受店铺促销优惠
+                                        shopPromotionFee.set(MathUtil.add(shopPromotionFee, MathUtil.mul(cartItemVo.getNumber(), cartItemVo.getPrice())).doubleValue());
+                                    }
+                                }
+                                // 该供应商下商品种类 +1
+                                shopKindCount.incrementAndGet();
+                                // 购物车总数量 + 当前商品购买数量
+                                totalCount.updateAndGet(v -> v + cartItemVo.getNumber());
+                            } else {
+                                // 失效商品
+                                if (cartItemVo.getPriceFlag() == 1) {
+                                    // 未公开价格
+                                    cartItemVo.setStatus(6);
+                                } else if (cartItemVo.getPriceFlag() == 2 && finalUserIdentity == 4) {
+                                    // 价格仅会员可见
+                                    cartItemVo.setStatus(5);
+                                } else if (cartItemVo.getPriceFlag() == 3 && finalUserClubType != 1) {
+                                    // 价格仅医美机构可见
+                                    cartItemVo.setStatus(8);
+                                } else if (cartItemVo.getStock() == null || cartItemVo.getStock() == 0) {
+                                    // 售罄
+                                    cartItemVo.setStatus(4);
+                                } else if (cartItemVo.getStock() != null && (cartItemVo.getStock() < cartItemVo.getMin() || cartItemVo.getStock() < cartItemVo.getNumber())) {
+                                    // 库存不足
+                                    cartItemVo.setStatus(7);
                                 }
+                                invalidList.add(cartItemVo);
+                                productIterator.remove();
+                            }
+                        } else {
+                            // 失效商品
+                            if (cartItemVo.getValidFlag() == 0) {
+                                // 后台逻辑删除,已停售
+                                cartItemVo.setStatus(1);
+                                invalidList.add(cartItemVo);
+                            } else if (cartItemVo.getValidFlag() == 10) {
+                                // 已冻结，已丢失
+                                cartItemVo.setStatus(2);
+                                invalidList.add(cartItemVo);
+                            } else if (cartItemVo.getValidFlag() == 3) {
+                                // 已下架
+                                cartItemVo.setStatus(3);
+                                invalidList.add(cartItemVo);
                             }
+                            //隐身商品validFlag = 9 不加入失效商品，直接去除
+                            productIterator.remove();
+                        }
+                    } else {
+                        if (cartItemVo.getValidFlag() == 1) {
+                            // 设置商品有效
+                            cartItemVo.setStatus(0);
                             // 该供应商下价格累加
                             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 (!(1 == cartItemVo.getSvipProductFlag() && svipUserFlag)) {
-                                // 超级会员购买svip商品不享受店铺促销优惠
-                                shopPromotionFee.set(MathUtil.add(shopPromotionFee, MathUtil.mul(cartItemVo.getNumber(), cartItemVo.getPrice())).doubleValue());
-                            }
+
                             // 该供应商下商品种类 +1
                             shopKindCount.incrementAndGet();
                             // 购物车总数量 + 当前商品购买数量
                             totalCount.updateAndGet(v -> v + cartItemVo.getNumber());
                         } else {
-                            // 失效商品
-                            if (cartItemVo.getPriceFlag() == 1) {
-                                // 未公开价格
-                                cartItemVo.setStatus(6);
-                            } else if (cartItemVo.getPriceFlag() == 2 && finalUserIdentity == 4) {
-                                // 价格仅会员可见
-                                cartItemVo.setStatus(5);
-                            } else if (cartItemVo.getPriceFlag() == 3 && finalUserClubType != 1) {
-                                // 价格仅医美机构可见
-                                cartItemVo.setStatus(8);
-                            } else if (cartItemVo.getStock() == null || cartItemVo.getStock() == 0) {
-                                // 售罄
-                                cartItemVo.setStatus(4);
-                            } else if (cartItemVo.getStock() != null && (cartItemVo.getStock() < cartItemVo.getMin() || cartItemVo.getStock() < cartItemVo.getNumber())) {
-                                // 库存不足
-                                cartItemVo.setStatus(7);
-                            }
-                            invalidList.add(cartItemVo);
-                            productIterator.remove();
-                        }
-                    } else {
-                        // 失效商品
-                        if (cartItemVo.getValidFlag() == 0) {
-                            // 后台逻辑删除,已停售
-                            cartItemVo.setStatus(1);
-                            invalidList.add(cartItemVo);
-                        } else if (cartItemVo.getValidFlag() == 10) {
-                            // 已冻结，已丢失
-                            cartItemVo.setStatus(2);
-                            invalidList.add(cartItemVo);
-                        } else if (cartItemVo.getValidFlag() == 3) {
-                            // 已下架
+                            // 设置商品失效
                             cartItemVo.setStatus(3);
                             invalidList.add(cartItemVo);
                         }
-                        //隐身商品validFlag = 9 不加入失效商品，直接去除
-                        productIterator.remove();
                     }
+
                 }
                 cartAllProducts.addAll(productList);
 
@@ -819,6 +841,31 @@ public class CartClubServiceImpl implements CartClubService {
         return ResponseJson.success(cartCount);
     }
 
+    /**
+     * 获取机构购物车数量（商品种类数） -- 组织
+     *
+     * @param userId
+     * @return
+     */
+    @Override
+    public ResponseJson<Integer> getShoppingCartOrganizeCount(Integer userId) {
+        Integer count = 0;
+        if (null == userId) {
+            return ResponseJson.success(count);
+        }
+        // 获取购物车商品列表（不区分供应商）
+        List<CartItemVo> cartList = cartClubMapper.getCartOrganizeProductList(userId);
+        if (null != cartList && cartList.size() > 0) {
+
+            cartList.removeIf(cartItemVo ->
+                    cartItemVo.getValidFlag() == 2
+            );
+            return ResponseJson.success(cartList.size());
+        } else {
+            return ResponseJson.success(count);
+        }
+    }
+
     /**
      * 获取机构购物车数量（商品种类数）
      *
@@ -870,6 +917,8 @@ public class CartClubServiceImpl implements CartClubService {
      */
     @Override
     public ResponseJson<Map<String, Object>> settlementShoppingCart(Integer userId, String skuIds, Integer source) {
+        // 用户组织Id
+        Integer organizeId = baseMapper.getOrganizeId(userId);
         log.info("￥￥￥￥￥￥￥￥￥￥ > 商品结算");
         // 商品种类
         AtomicInteger kindCount = new AtomicInteger(0);
@@ -963,14 +1012,21 @@ public class CartClubServiceImpl implements CartClubService {
                     }
                     // 供应商下商品列表
                     // 过滤保存已上架商品
-                    List<CartItemVo> productList = cartClubMapper.getCartProductsByShopIdAndProductIds(userId, shop.getShopId(), finalIdList, shop.getSplitCode());
+                    List<CartItemVo> productList = null;
+                    if (0 == organizeId) {
+                        productList = cartClubMapper.getCartProductsByShopIdAndProductIds(userId, shop.getShopId(), finalIdList, shop.getSplitCode());
+                    } else {
+                        productList = cartClubMapper.getCartProductsOrganize(userId, shop.getShopId(), organizeId, finalIdList, shop.getSplitCode());
+                    }
                     if (null != productList && productList.size() > 0) {
-                        // 去除不可见商品，visibility商品可见度： 3:所有人可见，2:普通机构可见，1:会员机构可见，4:仅医美机构可见
-                        productList.removeIf(cartItemVo -> !(cartItemVo.getVisibility() == 3 || cartItemVo.getVisibility() == 2 || (cartItemVo.getVisibility() == 1 && (finalUserIdentity == 2 || svipUserFlag)) || (cartItemVo.getVisibility() == 4 && finalUserClubType == 1)));
-                        // 去除价格不可见商品，价格可见度： 0公开价格，1不公开价格，2仅对会员机构公开，3仅对医美机构公开
-                        productList.removeIf(cartItemVo -> !(cartItemVo.getPriceFlag() == 0 || (cartItemVo.getPriceFlag() == 2 && (finalUserIdentity == 2 || svipUserFlag)) || (cartItemVo.getPriceFlag() == 3 && finalUserClubType == 1)));
-                        // 去除库存不足商品
-                        productList.removeIf(cartItemVo -> !(cartItemVo.getStock() != null && cartItemVo.getStock() > 0 && cartItemVo.getStock() >= cartItemVo.getMin() && cartItemVo.getStock() >= cartItemVo.getNumber()));
+                        if (0 == organizeId) {
+                            // 去除不可见商品，visibility商品可见度： 3:所有人可见，2:普通机构可见，1:会员机构可见，4:仅医美机构可见
+                            productList.removeIf(cartItemVo -> !(cartItemVo.getVisibility() == 3 || cartItemVo.getVisibility() == 2 || (cartItemVo.getVisibility() == 1 && (finalUserIdentity == 2 || svipUserFlag)) || (cartItemVo.getVisibility() == 4 && finalUserClubType == 1)));
+                            // 去除价格不可见商品，价格可见度： 0公开价格，1不公开价格，2仅对会员机构公开，3仅对医美机构公开
+                            productList.removeIf(cartItemVo -> !(cartItemVo.getPriceFlag() == 0 || (cartItemVo.getPriceFlag() == 2 && (finalUserIdentity == 2 || svipUserFlag)) || (cartItemVo.getPriceFlag() == 3 && finalUserClubType == 1)));
+                            // 去除库存不足商品
+                            productList.removeIf(cartItemVo -> !(cartItemVo.getStock() != null && cartItemVo.getStock() > 0 && cartItemVo.getStock() >= cartItemVo.getMin() && cartItemVo.getStock() >= cartItemVo.getNumber()));
+                        }
                         // 迭代器设置商品信息
                         for (CartItemVo cartItemVo : productList) {
                             // 设置商品图片及税费
@@ -980,78 +1036,79 @@ public class CartClubServiceImpl implements CartClubService {
                             if (recharge) {
                                 includeRecharge.set(true);
                             }
-
-                            if (1 == cartItemVo.getSvipProductFlag()) {
-                                // 超级会员优惠商品,不参与促销活动（普通机构购买该商品可参与店铺促销）/阶梯价/复购价
-                                // 超级会员设置商品优惠价
-                                productService.setSvipProductPrice(cartItemVo, taxFlag, svipUserFlag);
-                                if (svipUserFlag) {
-                                    // 超级会员设置超级会员优惠总额 + 商品优惠金额
-                                    shopSvipReducedPrice.set(MathUtil.add(shopSvipReducedPrice, cartItemVo.getSvipTotalReducedPrice()).doubleValue());
-                                }
-                            } else {
-                                // 非超级会员优惠商品参与促销活动
-                                // 获取商品促销信息
-                                PromotionsVo promotions = null;
-                                // 没有店铺促销时，商品促销才有效 单品/凑单活动
-                                if (null == shopPromotion) {
-                                    // 获取商品促销信息
-                                    promotions = baseMapper.getPromotionByProductId(cartItemVo.getProductId());
-                                    // 手动获取skuId优惠价
-                                    if (promotions != null && (promotions.getTouchPrice() == null || promotions.getTouchPrice() == 0d)) {
-                                        Double touchPrice = baseMapper.getTouchPriceBySku(cartItemVo.getSkuId(),promotions.getId());
-                                        promotions.setTouchPrice(touchPrice);
+                            if (0 == organizeId) {
+                                if (1 == cartItemVo.getSvipProductFlag()) {
+                                    // 超级会员优惠商品,不参与促销活动（普通机构购买该商品可参与店铺促销）/阶梯价/复购价
+                                    // 超级会员设置商品优惠价
+                                    productService.setSvipProductPrice(cartItemVo, taxFlag, svipUserFlag);
+                                    if (svipUserFlag) {
+                                        // 超级会员设置超级会员优惠总额 + 商品优惠金额
+                                        shopSvipReducedPrice.set(MathUtil.add(shopSvipReducedPrice, cartItemVo.getSvipTotalReducedPrice()).doubleValue());
                                     }
-                                    // 如果促销活动协销不可见，移除促销
-                                    if (promotions != null && promotions.getSeen() != null && promotions.getSeen() == 2 && finalUserIdentity1 == 1) {
-                                        promotions = null;
-                                    }
-                                    /*
-                                     * 设置商品促销优惠
-                                     */
-                                    if (null != promotions) {
-                                        BigDecimal totalAmount = MathUtil.mul(cartItemVo.getNumber(), cartItemVo.getPrice());
-                                        //叠加倍数
-                                        Double floor = Math.floor(MathUtil.div(totalAmount, promotions.getTouchPrice()).doubleValue());
-                                        // 当前促销活动的价格计算列表
-                                        List<PromotionPriceVo> promotionPriceList = productService.getPromotionProducts(promotions, cartItemVo, taxFlag);
-                                        // 更新到总促销列表
-                                        productService.updateTotalPromotions(totalPromotions, promotionsIds, promotions, promotionPriceList, floor);
-                                        //单品满减-计算供应商总价/满减金额
-                                        if (promotions.getType() == 1 && promotions.getMode() == 2) {
-                                            if (MathUtil.compare(totalAmount, promotions.getTouchPrice()) > -1) {
-                                                if (promotions.getDiscount() != null && promotions.getDiscount() == 1 && floor > 1) {
-                                                    //叠加优惠计算
-                                                    shopPrice.set(MathUtil.sub(shopPrice.get(), MathUtil.mul(promotions.getReducedPrice(), floor)).doubleValue());
-                                                    shopReducedPrice.set(MathUtil.add(shopReducedPrice, MathUtil.mul(promotions.getReducedPrice(), floor)).doubleValue());
-                                                } else {
-                                                    // 如果满足促销条件，设置供应商价格-满减金额，满减总额 + 当前促销满减金额
-                                                    shopPrice.set(MathUtil.sub(shopPrice.get(), promotions.getReducedPrice()).doubleValue());
-                                                    shopReducedPrice.set(MathUtil.add(shopReducedPrice, promotions.getReducedPrice()).doubleValue());
+                                } else {
+                                    // 非超级会员优惠商品参与促销活动
+                                    // 获取商品促销信息
+                                    PromotionsVo promotions = null;
+                                    // 没有店铺促销时，商品促销才有效 单品/凑单活动
+                                    if (null == shopPromotion) {
+                                        // 获取商品促销信息
+                                        promotions = baseMapper.getPromotionByProductId(cartItemVo.getProductId());
+                                        // 手动获取skuId优惠价
+                                        if (promotions != null && (promotions.getTouchPrice() == null || promotions.getTouchPrice() == 0d)) {
+                                            Double touchPrice = baseMapper.getTouchPriceBySku(cartItemVo.getSkuId(), promotions.getId());
+                                            promotions.setTouchPrice(touchPrice);
+                                        }
+                                        // 如果促销活动协销不可见，移除促销
+                                        if (promotions != null && promotions.getSeen() != null && promotions.getSeen() == 2 && finalUserIdentity1 == 1) {
+                                            promotions = null;
+                                        }
+                                        /*
+                                         * 设置商品促销优惠
+                                         */
+                                        if (null != promotions) {
+                                            BigDecimal totalAmount = MathUtil.mul(cartItemVo.getNumber(), cartItemVo.getPrice());
+                                            //叠加倍数
+                                            Double floor = Math.floor(MathUtil.div(totalAmount, promotions.getTouchPrice()).doubleValue());
+                                            // 当前促销活动的价格计算列表
+                                            List<PromotionPriceVo> promotionPriceList = productService.getPromotionProducts(promotions, cartItemVo, taxFlag);
+                                            // 更新到总促销列表
+                                            productService.updateTotalPromotions(totalPromotions, promotionsIds, promotions, promotionPriceList, floor);
+                                            //单品满减-计算供应商总价/满减金额
+                                            if (promotions.getType() == 1 && promotions.getMode() == 2) {
+                                                if (MathUtil.compare(totalAmount, promotions.getTouchPrice()) > -1) {
+                                                    if (promotions.getDiscount() != null && promotions.getDiscount() == 1 && floor > 1) {
+                                                        //叠加优惠计算
+                                                        shopPrice.set(MathUtil.sub(shopPrice.get(), MathUtil.mul(promotions.getReducedPrice(), floor)).doubleValue());
+                                                        shopReducedPrice.set(MathUtil.add(shopReducedPrice, MathUtil.mul(promotions.getReducedPrice(), floor)).doubleValue());
+                                                    } else {
+                                                        // 如果满足促销条件，设置供应商价格-满减金额，满减总额 + 当前促销满减金额
+                                                        shopPrice.set(MathUtil.sub(shopPrice.get(), promotions.getReducedPrice()).doubleValue());
+                                                        shopReducedPrice.set(MathUtil.add(shopReducedPrice, promotions.getReducedPrice()).doubleValue());
+                                                    }
                                                 }
                                             }
+                                            cartItemVo.setPromotions(promotions);
                                         }
-                                        cartItemVo.setPromotions(promotions);
                                     }
-                                }
-                                if (null != promotions || null != shopPromotion) {
-                                    // 商品处于活动状态
-                                    cartItemVo.setActStatus(1);
-                                    // 关闭阶梯价格，活动优先
-                                    cartItemVo.setLadderFlag(0);
-                                } else {
-                                    if (cartItemVo.getLadderFlag() == 1) {
-                                        // 设置阶梯价
-                                        productService.setCartLadderPrices(cartItemVo, taxFlag);
+                                    if (null != promotions || null != shopPromotion) {
+                                        // 商品处于活动状态
+                                        cartItemVo.setActStatus(1);
+                                        // 关闭阶梯价格，活动优先
+                                        cartItemVo.setLadderFlag(0);
                                     } else {
-                                        // 复购价
-                                        Double repurchase = baseMapper.getRepurchasePrice(cartItemVo.getSkuId(), userId);
-                                        if (null != repurchase && repurchase > 0) {
-                                            if (taxFlag) {
-                                                BigDecimal cartItemTax = MathUtil.div(MathUtil.mul(repurchase, cartItemVo.getTaxRate()), 100, 2);
-                                                cartItemVo.setPrice(MathUtil.add(repurchase, cartItemTax).doubleValue());
-                                            } else {
-                                                cartItemVo.setPrice(repurchase);
+                                        if (cartItemVo.getLadderFlag() == 1) {
+                                            // 设置阶梯价
+                                            productService.setCartLadderPrices(cartItemVo, taxFlag);
+                                        } else {
+                                            // 复购价
+                                            Double repurchase = baseMapper.getRepurchasePrice(cartItemVo.getSkuId(), userId);
+                                            if (null != repurchase && repurchase > 0) {
+                                                if (taxFlag) {
+                                                    BigDecimal cartItemTax = MathUtil.div(MathUtil.mul(repurchase, cartItemVo.getTaxRate()), 100, 2);
+                                                    cartItemVo.setPrice(MathUtil.add(repurchase, cartItemTax).doubleValue());
+                                                } else {
+                                                    cartItemVo.setPrice(repurchase);
+                                                }
                                             }
                                         }
                                     }
@@ -1060,10 +1117,12 @@ public class CartClubServiceImpl implements CartClubService {
                             // 该供应商下价格累加
                             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 (!(1 == cartItemVo.getSvipProductFlag() && svipUserFlag)) {
-                                // 超级会员购买svip商品不享受店铺促销优惠
-                                shopPromotionFee.set(MathUtil.add(shopPromotionFee, MathUtil.mul(cartItemVo.getNumber(), cartItemVo.getPrice())).doubleValue());
+                            if (0 == organizeId) {
+                                // 该供应商下可参与店铺促销的商品价格累加
+                                if (!(1 == cartItemVo.getSvipProductFlag() && svipUserFlag)) {
+                                    // 超级会员购买svip商品不享受店铺促销优惠
+                                    shopPromotionFee.set(MathUtil.add(shopPromotionFee, MathUtil.mul(cartItemVo.getNumber(), cartItemVo.getPrice())).doubleValue());
+                                }
                             }
                             // 该供应商下商品种类 +1
                             shopKindCount.incrementAndGet();
@@ -1149,12 +1208,15 @@ public class CartClubServiceImpl implements CartClubService {
                 }
             });
             // 删除空数据
+            log.info("shopList===="+shopList);
             shopList.removeIf(shop -> (null == shop || shop.getCount() == 0));
+            log.info("shopList----"+shopList);
 
         }
         // 总促销计算
         // 满减满赠叠加计算
         List<CartShopVo> finalShopList = shopList;
+        log.info("shopList*****"+shopList);
         totalPromotions.forEach(promotions -> {
             // 该促销内商品总价
             double touchPrice = promotions.getProductList().stream().mapToDouble(product -> product.getNumber() * product.getPrice()).sum();
@@ -1650,12 +1712,19 @@ public class CartClubServiceImpl implements CartClubService {
     @Override
     public ResponseJson<Map<String, Object>> buyNowProduct(CartDto cartDto) {
         log.info("￥￥￥￥￥￥￥￥￥￥ > 立即购买");
+        // 用户组织Id
+        Integer organizeId = baseMapper.getOrganizeId(cartDto.getUserId());
         // 供应商信息
         CartShopVo shop = baseMapper.getShopByProductId(cartDto.getProductId());
         if (null == shop) {
             return ResponseJson.error("商品供应商异常！", null);
         }
-        CartItemVo cartItemVo = cartClubMapper.getCartItemByProductId(cartDto.getSkuId());
+        CartItemVo cartItemVo = null;
+        if (0 == organizeId) {
+            cartItemVo = cartClubMapper.getCartItemByProductId(cartDto.getSkuId());
+        } else {
+            cartItemVo = cartClubMapper.getCartOrganizeProductId(cartDto.getSkuId());
+        }
         if (null == cartItemVo) {
             return ResponseJson.error("商品数据异常！", null);
         } else {
@@ -1686,8 +1755,10 @@ public class CartClubServiceImpl implements CartClubService {
             return ResponseJson.error("商品不可见！", null);
         }
         // 价格可见度： 0公开价格，1不公开价格，2仅对会员机构公开，3仅对医美机构公开
-        if (!(cartItemVo.getPriceFlag() == 0 || (cartItemVo.getPriceFlag() == 2 && (userIdentity == 2 || svipUserFlag)) || (cartItemVo.getPriceFlag() == 3 && userClubType == 1))) {
-            return ResponseJson.error("商品价格不可见！", null);
+        if (0 == organizeId) {
+            if (!(cartItemVo.getPriceFlag() == 0 || (cartItemVo.getPriceFlag() == 2 && (userIdentity == 2 || svipUserFlag)) || (cartItemVo.getPriceFlag() == 3 && userClubType == 1))) {
+                return ResponseJson.error("商品价格不可见！", null);
+            }
         }
         cartItemVo.setNumber(cartDto.getProductCount());
         // 库存不足商品
@@ -1716,82 +1787,84 @@ public class CartClubServiceImpl implements CartClubService {
             promotions = null;
         }
         boolean hasGift = false;
-        if (1 == cartItemVo.getSvipProductFlag()) {
-            // 超级会员优惠商品,不参与促销活动（普通机构购买该商品可参与店铺促销）/阶梯价/复购价
-            // 超级会员设置商品优惠价
-            productService.setSvipProductPrice(cartItemVo, taxFlag, svipUserFlag);
-            if (svipUserFlag) {
-                // 超级会员设置超级会员优惠总额 + 商品优惠金额
-                svipReducedPrice.set(MathUtil.add(svipReducedPrice, cartItemVo.getSvipTotalReducedPrice()).doubleValue());
-            }
-        } else {
-            // 没有店铺促销时，商品促销才有效
-            if (null == promotions) {
-                // 获取商品促销信息
-                promotions = baseMapper.getPromotionByProductId(cartItemVo.getProductId());
-                //协销不可见
-                if (promotions != null && promotions.getSeen() != null && promotions.getSeen() == 2 && userIdentity == 1) {
-                    promotions = null;
+        if (0 == organizeId) {
+            if (1 == cartItemVo.getSvipProductFlag()) {
+                // 超级会员优惠商品,不参与促销活动（普通机构购买该商品可参与店铺促销）/阶梯价/复购价
+                // 超级会员设置商品优惠价
+                productService.setSvipProductPrice(cartItemVo, taxFlag, svipUserFlag);
+                if (svipUserFlag) {
+                    // 超级会员设置超级会员优惠总额 + 商品优惠金额
+                    svipReducedPrice.set(MathUtil.add(svipReducedPrice, cartItemVo.getSvipTotalReducedPrice()).doubleValue());
                 }
             } else {
-                shop.setPromotions(promotions);
-            }
-            /*
-             * 设置商品促销优惠
-             */
-            if (null != promotions) {
-                // 当前促销活动的价格计算列表
-                List<PromotionPriceVo> promotionPriceList = productService.getPromotionProducts(promotions, cartItemVo, taxFlag);
-                promotions.setProductList(promotionPriceList);
-                Double totalAmount = MathUtil.mul(cartItemVo.getNumber(), cartItemVo.getPrice()).doubleValue();
-                Double floor = Math.floor(MathUtil.div(totalAmount, promotions.getTouchPrice()).doubleValue());
-                // 满足促销条件
-                if (MathUtil.compare(totalAmount, promotions.getTouchPrice()) >= 0) {
-                    // 满减
-                    if (promotions.getMode() == 2) {
-                        // 总价 - 满减金额
-                        if (promotions.getDiscount() != null && promotions.getDiscount() == 1 && floor > 1) {
-                            totalPrice.set(MathUtil.sub(totalPrice.get(), MathUtil.mul(promotions.getReducedPrice(), floor)).doubleValue());
-                            // 优惠总额 + 满减金额
-                            reducedPrice.set(MathUtil.add(reducedPrice.get(), MathUtil.mul(promotions.getReducedPrice(), floor)).doubleValue());
-                        } else {
-                            totalPrice.set(MathUtil.sub(totalPrice.get(), promotions.getReducedPrice()).doubleValue());
-                            // 优惠总额 + 满减金额
-                            reducedPrice.set(MathUtil.add(reducedPrice.get(), promotions.getReducedPrice()).doubleValue());
-                        }
-                    } else if (promotions.getMode() == 3) {
-                        // 满足满赠
-                        hasGift = true;
-                        List<CartItemVo> giftList = baseMapper.getPromotionGifts(promotions.getId());
-                        //满足叠加
-                        if (promotions.getDiscount() != null && promotions.getDiscount() == 1 && floor > 1) {
-                            Integer in = floor.intValue();
-                            giftList.forEach(g -> g.setNumber(MathUtil.mul(g.getNumber(), in).intValue()));
-                        }
-                        promotions.setGiftList(giftList);
+                // 没有店铺促销时，商品促销才有效
+                if (null == promotions) {
+                    // 获取商品促销信息
+                    promotions = baseMapper.getPromotionByProductId(cartItemVo.getProductId());
+                    //协销不可见
+                    if (promotions != null && promotions.getSeen() != null && promotions.getSeen() == 2 && userIdentity == 1) {
+                        promotions = null;
                     }
+                } else {
+                    shop.setPromotions(promotions);
                 }
-                // 添加到总促销
-                totalPromotions.add(promotions);
-                // 商品处于活动状态
-                cartItemVo.setActStatus(1);
-                // 关闭阶梯价格，活动优先
-                cartItemVo.setLadderFlag(0);
-                cartItemVo.setPromotions(promotions);
-            } else {
-                cartItemVo.setActStatus(0);
-                if (cartItemVo.getLadderFlag() == 1) {
-                    // 设置阶梯价
-                    productService.setCartLadderPrices(cartItemVo, taxFlag);
+                /*
+                 * 设置商品促销优惠
+                 */
+                if (null != promotions) {
+                    // 当前促销活动的价格计算列表
+                    List<PromotionPriceVo> promotionPriceList = productService.getPromotionProducts(promotions, cartItemVo, taxFlag);
+                    promotions.setProductList(promotionPriceList);
+                    Double totalAmount = MathUtil.mul(cartItemVo.getNumber(), cartItemVo.getPrice()).doubleValue();
+                    Double floor = Math.floor(MathUtil.div(totalAmount, promotions.getTouchPrice()).doubleValue());
+                    // 满足促销条件
+                    if (MathUtil.compare(totalAmount, promotions.getTouchPrice()) >= 0) {
+                        // 满减
+                        if (promotions.getMode() == 2) {
+                            // 总价 - 满减金额
+                            if (promotions.getDiscount() != null && promotions.getDiscount() == 1 && floor > 1) {
+                                totalPrice.set(MathUtil.sub(totalPrice.get(), MathUtil.mul(promotions.getReducedPrice(), floor)).doubleValue());
+                                // 优惠总额 + 满减金额
+                                reducedPrice.set(MathUtil.add(reducedPrice.get(), MathUtil.mul(promotions.getReducedPrice(), floor)).doubleValue());
+                            } else {
+                                totalPrice.set(MathUtil.sub(totalPrice.get(), promotions.getReducedPrice()).doubleValue());
+                                // 优惠总额 + 满减金额
+                                reducedPrice.set(MathUtil.add(reducedPrice.get(), promotions.getReducedPrice()).doubleValue());
+                            }
+                        } else if (promotions.getMode() == 3) {
+                            // 满足满赠
+                            hasGift = true;
+                            List<CartItemVo> giftList = baseMapper.getPromotionGifts(promotions.getId());
+                            //满足叠加
+                            if (promotions.getDiscount() != null && promotions.getDiscount() == 1 && floor > 1) {
+                                Integer in = floor.intValue();
+                                giftList.forEach(g -> g.setNumber(MathUtil.mul(g.getNumber(), in).intValue()));
+                            }
+                            promotions.setGiftList(giftList);
+                        }
+                    }
+                    // 添加到总促销
+                    totalPromotions.add(promotions);
+                    // 商品处于活动状态
+                    cartItemVo.setActStatus(1);
+                    // 关闭阶梯价格，活动优先
+                    cartItemVo.setLadderFlag(0);
+                    cartItemVo.setPromotions(promotions);
                 } else {
-                    // 复购价
-                    Double repurchase = baseMapper.getRepurchasePrice(cartItemVo.getSkuId(), cartDto.getUserId());
-                    if (null != repurchase && repurchase > 0) {
-                        if (taxFlag) {
-                            BigDecimal cartItemTax = MathUtil.div(MathUtil.mul(repurchase, cartItemVo.getTaxRate()), 100, 2);
-                            cartItemVo.setPrice(MathUtil.add(repurchase, cartItemTax).doubleValue());
-                        } else {
-                            cartItemVo.setPrice(repurchase);
+                    cartItemVo.setActStatus(0);
+                    if (cartItemVo.getLadderFlag() == 1) {
+                        // 设置阶梯价
+                        productService.setCartLadderPrices(cartItemVo, taxFlag);
+                    } else {
+                        // 复购价
+                        Double repurchase = baseMapper.getRepurchasePrice(cartItemVo.getSkuId(), cartDto.getUserId());
+                        if (null != repurchase && repurchase > 0) {
+                            if (taxFlag) {
+                                BigDecimal cartItemTax = MathUtil.div(MathUtil.mul(repurchase, cartItemVo.getTaxRate()), 100, 2);
+                                cartItemVo.setPrice(MathUtil.add(repurchase, cartItemTax).doubleValue());
+                            } else {
+                                cartItemVo.setPrice(repurchase);
+                            }
                         }
                     }
                 }

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

@@ -151,6 +151,9 @@ public class HeliPayServiceImpl implements HeliPayService {
     @Override
     public ResponseJson<JSONObject> payOnline(HeliDto heliDto, HttpHeaders headers) throws IntrospectionException, InvocationTargetException, IllegalAccessException {
         log.info("--------进入公众号/小程序预创建订单接口----------");
+        // 组织Id
+        Integer organizeId = baseMapper.getOrganizeIdShop(heliDto.getShopOrderId());
+        heliDto.setOrganizeId(organizeId);
         AppPayPublicCreateOrderVo pay = new AppPayPublicCreateOrderVo();
         String splitCode = payOrderMapper.findShopOrderSplitCode(heliDto.getShopOrderId());
         if (StringUtils.isBlank(splitCode)) {
@@ -602,7 +605,12 @@ public class HeliPayServiceImpl implements HeliPayService {
         String openId = null;
         if (null == payParam.getState()) {
             // 小程序微信授权获取登录信息
-            ResponseJson<Map<String, Object>> appletsInfo = weChatService.getInfoMapByApplets(payParam.getCode(), headers, 1);
+            ResponseJson<Map<String, Object>> appletsInfo = null;
+            if (0 == heliDto.getOrganizeId()) {
+                appletsInfo = weChatService.getInfoMapByApplets(payParam.getCode(), headers, 1);
+            } else {
+                appletsInfo = weChatService.getInfoMapByApplets(payParam.getCode(), headers, 3);
+            }
             if (appletsInfo.getCode() == -1) {
                 return null;
             }

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

@@ -7,6 +7,8 @@ import com.caimei365.order.components.ProductService;
 import com.caimei365.order.components.WeChatService;
 import com.caimei365.order.mapper.*;
 import com.caimei365.order.model.ResponseJson;
+import com.caimei365.order.model.dto.VoucherDto;
+import com.caimei365.order.model.dto.VoucherImageDto;
 import com.caimei365.order.model.enums.OrderStatus;
 import com.caimei365.order.model.po.*;
 import com.caimei365.order.model.vo.*;
@@ -23,16 +25,16 @@ import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.http.HttpHeaders;
-import org.springframework.scheduling.annotation.Scheduled;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.util.CollectionUtils;
 
 import javax.annotation.Resource;
-import java.text.ParseException;
 import java.text.SimpleDateFormat;
 import java.util.*;
 import java.util.concurrent.*;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 /**
  * Description
@@ -146,6 +148,12 @@ public class OrderClubServiceImpl implements OrderClubService {
             orderCommonService.getShopOrderData(order);
             // 设置付款金额
             orderCommonService.getDiscernReceiptAndSetOrder(order);
+            // 联合丽格 [待付款]或者线下支付[部分付款] 的主订单 状态
+            if (0 != order.getOrganizeId()) {
+                if (1 == order.getPayStatus() || (2 == order.getPayStatus() && 1 == order.getOnlinePayFlag())) {
+                    order.setStatus(333);
+                }
+            }
         });
         PageInfo<OrderVo> pageInfo = new PageInfo(orderList);
         return ResponseJson.success(pageInfo);
@@ -201,6 +209,11 @@ public class OrderClubServiceImpl implements OrderClubService {
         OrderVo order = new OrderVo();
         // OrderPo -> OrderVo
         BeanUtils.copyProperties(orderPo, order);
+        if (0 != order.getOrganizeId()) {
+            if (1 == order.getPayStatus() || (2 == order.getPayStatus() && 1 == order.getOnlinePayFlag())) {
+                order.setStatus(333);
+            }
+        }
         order.setOrderMark("#" + order.getOrderId() + "#");
         // 设置订单状态
         orderCommonService.setOrderStatus(order);
@@ -302,6 +315,18 @@ public class OrderClubServiceImpl implements OrderClubService {
                 }
             }
         }
+        // 支付凭证
+//        VoucherPo voucherPo = new VoucherPo();
+        List<VoucherPo> voucher = orderClubMapper.getVoucher(orderId);
+        // 支付凭证图片
+        if (null != voucher) {
+            List<Integer> ids = voucher.stream().map(VoucherPo::getId).collect(Collectors.toList());
+            List<VoucherImageDto> voucherImage = orderClubMapper.getVoucherImage(ids);
+            voucher.forEach(v -> {
+                List<VoucherImageDto> imageList = voucherImage.stream().filter(m -> m.getVoucherId().equals(v.getId())).collect(Collectors.toList());
+                v.setImgs(imageList);
+            });
+        }
         Map<String, Object> map = new HashMap<>();
         map.put("order", order);
         map.put("shopOrderList", shopOrderList);
@@ -311,6 +336,7 @@ public class OrderClubServiceImpl implements OrderClubService {
         map.put("discernReceiptList", discernReceiptList);
         map.put("returnedPurchaseList", returnedPurchaseList);
         map.put("clause", clause);
+        map.put("voucher",voucher);
         if (flag) {
             map.put("returnGoodsStutas", 2);
             map.put("helpContent", helpContent);
@@ -321,6 +347,38 @@ public class OrderClubServiceImpl implements OrderClubService {
         return ResponseJson.success(map);
     }
 
+
+    /**
+     * 上传支付凭证
+     *
+     * @param voucherDto
+     * @return
+     */
+    @Override
+    public ResponseJson voucher(VoucherDto voucherDto) {
+        if (null == voucherDto.getOrderId()) {
+            return ResponseJson.error(-1,"订单Id不能为空",null);
+        }
+        // 修改支付凭证
+        orderClubMapper.insertVoucher(voucherDto);
+        // 修改支付凭证图片
+        if (!"".equals(voucherDto.getVoucherImgs())) {
+            if (voucherDto.getVoucherImgs().contains("##")) {
+                String[] split = voucherDto.getVoucherImgs().split("##");
+                for (String str : split) {
+                    VoucherImageDto voucherImageDto = new VoucherImageDto();
+                    voucherImageDto.setVoucherId(voucherDto.getId());
+                    voucherImageDto.setImg(str);
+                    orderClubMapper.insertVoucherImage(voucherImageDto);
+                }
+            }
+        } else {
+            return ResponseJson.error(-1,"请上传支付凭证",null);
+        }
+
+        return ResponseJson.success();
+    }
+
     /**
      * 机构最新订单
      *
@@ -862,12 +920,19 @@ public class OrderClubServiceImpl implements OrderClubService {
      */
     @Override
     public ResponseJson<String> identityOrderShareCode(Integer orderId, Integer userId, Integer serviceProviderId, String code, String encryptedData, String iv, HttpHeaders headers) {
+        // 用户组织Id
+        Integer organizeId = baseMapper.getOrganizeId(userId);
         int orderCount = orderClubMapper.countMainOrderByOrderId(orderId);
         if (0 == orderCount) {
             return ResponseJson.error("订单不存在！", null);
         }
         // 微信小程序授权登录（调用user服务，发送服务间调用POST请求）
-        String loginData = remoteCallService.appletsAuthorization(code, encryptedData, iv, headers);
+        String loginData = null;
+        if (0 == organizeId) {
+            loginData = remoteCallService.appletsAuthorization(code, encryptedData, iv, headers);
+        } else {
+            loginData = remoteCallService.appletsOrganizeAuthorization(code, encryptedData, iv, headers, userId);
+        }
         if (StringUtils.isEmpty(loginData)) {
             return ResponseJson.error("微信授权登录异常！", null);
         }

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

@@ -776,6 +776,9 @@ public class PayOrderServiceImpl implements PayOrderService {
         if (onlinePay != 1) {
             map.put("onlinePayWays", orderCommonMapper.findOnlinePayWays(shopOrderId));
         }
+        if (0 != shop.getOrganizeId()) {
+            map.put("onlinePayWays", orderCommonMapper.findOnlinePayWays(shopOrderId));
+        }
 //        map.put("B2BpayFlag", B2BpayFlag);
         map.put("userName", userName);
         map.put("shopOrder", shop);

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

@@ -4,6 +4,7 @@ import com.alibaba.fastjson.JSONObject;
 import com.caimei365.order.feign.CommodityFeign;
 import com.caimei365.order.feign.ToolsFeign;
 import com.caimei365.order.feign.UserFeign;
+import com.caimei365.order.mapper.BaseMapper;
 import com.caimei365.order.mapper.MessagePushMapper;
 import com.caimei365.order.model.vo.PushMessageUserVo;
 import com.caimei365.order.service.RemoteCallService;
@@ -36,6 +37,8 @@ public class RemoteCallServiceImpl implements RemoteCallService {
     @Resource
     private MessagePushMapper messagePushMapper;
     @Resource
+    private BaseMapper baseMapper;
+    @Resource
     private ToolsFeign toolsFeign;
     @Resource
     private UserFeign userFeign;
@@ -135,6 +138,41 @@ public class RemoteCallServiceImpl implements RemoteCallService {
         return resultData.get();
     }
 
+    /**
+     * 微信小程序授权登录（调用user服务，发送服务间调用POST请求） - 组织
+     *
+     * @param code          微信code
+     * @param encryptedData 微信加密数据
+     * @param iv            微信加密算法的初始向量
+     * @param headers       HttpHeaders
+     * @return
+     */
+    @Override
+    public String appletsOrganizeAuthorization(String code, String encryptedData, String iv, HttpHeaders headers, Integer userId) {
+        // 用户组织Id
+        Integer organizeId = baseMapper.getOrganizeId(userId);
+        AtomicReference<String> resultData = new AtomicReference<>("");
+        // 获取当前微信小程序的环境
+        String referer = headers.getFirst("Referer");
+        try {
+            // 调用 UserFeign 获取物流
+            String jsonStr = "";
+            if (0 != organizeId) {
+                jsonStr = userFeign.appletsOrganizeAuthorization(code, encryptedData, iv, referer);
+            } else {
+                jsonStr = userFeign.appletsAuthorization(code, encryptedData, iv, referer);
+            }
+            JSONObject parseObject = JSONObject.parseObject(jsonStr);
+            if (0 == parseObject.getInteger("code") || -4 == parseObject.getInteger("code")) {
+                // 授权登录成功（游客-4）
+                resultData.set(parseObject.getString("data"));
+            }
+        } catch (Exception e) {
+            log.error("获取微信小程序授权失败:", e);
+        }
+        return resultData.get();
+    }
+
     /**
      * 智能获取物流信息
      *

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

@@ -354,18 +354,21 @@ public class SubmitServiceImpl implements SubmitService {
     }
 
     public ResponseJson<Map<String, Object>> saveOrder(OrderParamBo orderParamBo) {
+        // 用户组织Id
+        Integer organizeId = baseMapper.getOrganizeId(orderParamBo.getUserId());
         log.info("******************** 提交订单逻辑处理 start *******************");
         /**
          * 初始化主订单
          */
         OrderPo mainOrder = new OrderPo();
-        // 订单组织Id
-        mainOrder.setOrganizeId(orderParamBo.getOrganizeId());
         // 订单可见度
         mainOrder.setOrderSeen(orderParamBo.getOrderSeen());
         // 订单来源
         mainOrder.setOrderSource(orderParamBo.getOrderSource());
         // 生成订单号
+        if (0 != organizeId) {
+            orderParamBo.setOrderSource(9);
+        }
         String orderNo = CodeUtil.generateOrderNo(orderParamBo.getOrderSource());
         mainOrder.setOrderNo(orderNo);
         // 用户Id
@@ -396,6 +399,10 @@ public class SubmitServiceImpl implements SubmitService {
             // 2买家确认
             mainOrder.setConfirmFlag(2);
         }
+        if (1 == organizeId) {
+            // 联合丽格订单
+            mainOrder.setOrderType(3);
+        }
         // 抵扣采美豆数量
         mainOrder.setUserBeans(orderParamBo.getOffsetBeans());
         // 默认可以线上支付：0可以 1不可以
@@ -521,6 +528,7 @@ public class SubmitServiceImpl implements SubmitService {
             for (Object productObject : productArr) {
                 JSONObject productTemp = (JSONObject) productObject;
                 Integer skuId = (Integer) productTemp.get("skuId");
+//                Integer organizeProductId = (Integer) productTemp.get("id");
                 Integer productNum = (Integer) productTemp.get("productNum");
                 Integer presentNum = (Integer) productTemp.get("presentNum");
                 Integer productType = (Integer) productTemp.get("productType");
@@ -536,7 +544,12 @@ public class SubmitServiceImpl implements SubmitService {
                 // 赠品数
                 presentCount.updateAndGet(v -> v + presentNum);
                 // 获取数据库商品信息
-                OrderProductPo dbProduct = submitMapper.getProductDetails(skuId);
+                OrderProductPo dbProduct = null;
+                if (0 == organizeId) {
+                    dbProduct = submitMapper.getProductDetails(skuId);
+                } else {
+                    dbProduct = submitMapper.getProductOrganizeDetails(skuId);
+                }
                 OrderProductPo product = new OrderProductPo();
                 BeanUtils.copyProperties(dbProduct, product);
                 log.info("splitcode-----------------------》" + product.getSplitCode());
@@ -559,6 +572,9 @@ public class SubmitServiceImpl implements SubmitService {
                 product.setProductType(productType);
                 product.setSvipPriceFlag(0);
                 product.setSvipReduction(0d);
+                // 组织信息
+                product.setOrganizeId(organizeId);
+
                 // 超级会员优惠商品详情
                 SvipProductPo svipProductPo = submitMapper.getSvipProductDetails(product.getSkuId());
                 // 是否以超级会员优惠价格购买
@@ -694,56 +710,58 @@ public class SubmitServiceImpl implements SubmitService {
                     Double taxFee = MathUtil.mul(discountTax, productNum).doubleValue();
                     if (hasActProductFlag && null != promotions) {
                         // 单品促销
-                        if (promotions.getType() == 1) {
-                            // 是否满足单品优惠条件（满足优惠价或者满减在这里进行设值）
-                            if (promotions.getMode() == 1 || MathUtil.compare(productFee, promotions.getTouchPrice()) >= 0) {
-                                // 满减
-                                if (promotions.getMode() == 2) {
-                                    if (promotions.getDiscount() != null && promotions.getDiscount() == 1) {
-                                        //叠加优惠计算
-                                        //叠加倍数
-                                        Double floor = Math.floor(MathUtil.div(productFee, promotions.getTouchPrice()).doubleValue());
-                                        promotionFullReduction.set(MathUtil.add(promotionFullReduction.get(), MathUtil.mul(promotions.getReducedPrice(), floor)).doubleValue());
-                                        productFee = MathUtil.sub(productFee, MathUtil.mul(promotions.getReducedPrice(), floor)).doubleValue();
-                                    } else {
-                                        // 统计订单总满减金额
-                                        promotionFullReduction.set(MathUtil.add(promotionFullReduction.get(), promotions.getReducedPrice()).doubleValue());
-                                        // 统计单个商品的折后金额
-                                        productFee = MathUtil.sub(productFee, promotions.getReducedPrice()).doubleValue();
+                        if (0 == organizeId) {
+                            if (promotions.getType() == 1) {
+                                // 是否满足单品优惠条件（满足优惠价或者满减在这里进行设值）
+                                if (promotions.getMode() == 1 || MathUtil.compare(productFee, promotions.getTouchPrice()) >= 0) {
+                                    // 满减
+                                    if (promotions.getMode() == 2) {
+                                        if (promotions.getDiscount() != null && promotions.getDiscount() == 1) {
+                                            //叠加优惠计算
+                                            //叠加倍数
+                                            Double floor = Math.floor(MathUtil.div(productFee, promotions.getTouchPrice()).doubleValue());
+                                            promotionFullReduction.set(MathUtil.add(promotionFullReduction.get(), MathUtil.mul(promotions.getReducedPrice(), floor)).doubleValue());
+                                            productFee = MathUtil.sub(productFee, MathUtil.mul(promotions.getReducedPrice(), floor)).doubleValue();
+                                        } else {
+                                            // 统计订单总满减金额
+                                            promotionFullReduction.set(MathUtil.add(promotionFullReduction.get(), promotions.getReducedPrice()).doubleValue());
+                                            // 统计单个商品的折后金额
+                                            productFee = MathUtil.sub(productFee, promotions.getReducedPrice()).doubleValue();
+                                        }
+                                    }
+                                    // 添加到总促销
+                                    if (!promotionsIds.contains(promotions.getId())) {
+                                        promotionsIds.add(promotions.getId());
+                                        promotions.setPromotionsId(promotions.getId());
+                                        promotionList.add(promotions);
                                     }
+                                    product.setOrderPromotionsId(promotions.getId());
                                 }
-                                // 添加到总促销
+                                // 凑单优惠
+                            } else if (promotions.getType() == 2) {
+                                // 商品添加到总促销
+                                PromotionPriceVo promotionPrice = new PromotionPriceVo();
+                                promotionPrice.setProductId(product.getProductId());
+                                promotionPrice.setNumber(productNum);
+                                promotionPrice.setPrice(discountTaxPrice);
+                                if (null == promotions.getProductList()) {
+                                    promotions.setProductList(new ArrayList<>());
+                                }
+                                promotions.getProductList().add(promotionPrice);
                                 if (!promotionsIds.contains(promotions.getId())) {
                                     promotionsIds.add(promotions.getId());
                                     promotions.setPromotionsId(promotions.getId());
                                     promotionList.add(promotions);
+                                } else {
+                                    PromotionsVo finalPromotions = promotions;
+                                    promotionList.forEach(promotionsTemp -> {
+                                        if (finalPromotions.getId().equals(promotionsTemp.getId())) {
+                                            promotionsTemp.getProductList().add(promotionPrice);
+                                        }
+                                    });
                                 }
                                 product.setOrderPromotionsId(promotions.getId());
                             }
-                            // 凑单优惠
-                        } else if (promotions.getType() == 2) {
-                            // 商品添加到总促销
-                            PromotionPriceVo promotionPrice = new PromotionPriceVo();
-                            promotionPrice.setProductId(product.getProductId());
-                            promotionPrice.setNumber(productNum);
-                            promotionPrice.setPrice(discountTaxPrice);
-                            if (null == promotions.getProductList()) {
-                                promotions.setProductList(new ArrayList<>());
-                            }
-                            promotions.getProductList().add(promotionPrice);
-                            if (!promotionsIds.contains(promotions.getId())) {
-                                promotionsIds.add(promotions.getId());
-                                promotions.setPromotionsId(promotions.getId());
-                                promotionList.add(promotions);
-                            } else {
-                                PromotionsVo finalPromotions = promotions;
-                                promotionList.forEach(promotionsTemp -> {
-                                    if (finalPromotions.getId().equals(promotionsTemp.getId())) {
-                                        promotionsTemp.getProductList().add(promotionPrice);
-                                    }
-                                });
-                            }
-                            product.setOrderPromotionsId(promotions.getId());
                         }
                     }
                     // 折后单价
@@ -850,7 +868,13 @@ public class SubmitServiceImpl implements SubmitService {
                 shopProductAmount.set(MathUtil.add(shopProductAmount.get(), product.getShopProductAmount()).doubleValue());
                 // 付供应商税费
                 shopTaxFee.set(MathUtil.add(shopTaxFee.get(), product.getShouldPayTotalTax()).doubleValue());
-
+                if (0 != organizeId) {
+                    // 佣金比例  外部商城sku配置比例
+                    CmOrganizeSkuPo organizeSkuInfo = submitMapper.getOrganizeSkuInfo(skuId);
+                    product.setCmPercent(organizeSkuInfo.getCmPercent());
+                    product.setOrganizePercent(organizeSkuInfo.getOrganizePercent());
+                    product.setShopPercent(organizeSkuInfo.getShopPercent());
+                }
                 // 加入订单商品列表
                 orderProductList.add(product);
                 productIdList.add(product.getProductId().toString());
@@ -861,47 +885,49 @@ public class SubmitServiceImpl implements SubmitService {
                 //有商品无分帐号，走线下
                 onlinePay.set(false);
             }
-            if (null != shopPromotions) {
-                // 是否满足满减满赠
-                if (MathUtil.compare(shopPromotionFee.get(), shopPromotions.getTouchPrice()) >= 0) {
-                    // 是否包含活动商品(受订单未支付自动关闭时间影响)  0 否 1 是
-                    hasActProductFlag = true;
-                    // 满减
-                    if (shopPromotions.getMode() == 2) {
-                        if (shopPromotions.getDiscount() != null && shopPromotions.getDiscount() == 1) {
-                            //叠加优惠计算
-                            //叠加倍数
-                            Double floor = Math.floor(MathUtil.div(shopPromotionFee.get(), shopPromotions.getTouchPrice()).doubleValue());
-                            // 供应商满减金额
-                            shopOrder.setPromotionFullReduction(MathUtil.mul(shopPromotions.getReducedPrice(), floor).doubleValue());
-                            // 统计订单总满减金额
-                            promotionFullReduction.set(MathUtil.add(promotionFullReduction.get(), MathUtil.mul(shopPromotions.getReducedPrice(), floor)).doubleValue());
-                            // 统计店铺商品总金额
-                            shopProductFee.set(MathUtil.sub(shopProductFee.get(), MathUtil.mul(shopPromotions.getReducedPrice(), floor)).doubleValue());
-                            // 统计需要支付金额
-                            needPayAmount.set(MathUtil.sub(needPayAmount.get(), MathUtil.mul(shopPromotions.getReducedPrice(), floor)).doubleValue());
-                            // 统计需要支付金额
-                            shopAmount.set(MathUtil.sub(shopAmount.get(), MathUtil.mul(shopPromotions.getReducedPrice(), floor)).doubleValue());
-                        } else {
-                            // 供应商满减金额
-                            shopOrder.setPromotionFullReduction(shopPromotions.getReducedPrice());
-                            // 统计订单总满减金额
-                            promotionFullReduction.set(MathUtil.add(promotionFullReduction.get(), shopPromotions.getReducedPrice()).doubleValue());
-                            // 统计店铺商品总金额
-                            shopProductFee.set(MathUtil.sub(shopProductFee.get(), shopPromotions.getReducedPrice()).doubleValue());
-                            // 统计需要支付金额
-                            needPayAmount.set(MathUtil.sub(needPayAmount.get(), shopPromotions.getReducedPrice()).doubleValue());
-                            // 统计需要支付金额
-                            shopAmount.set(MathUtil.sub(shopAmount.get(), shopPromotions.getReducedPrice()).doubleValue());
+            if (0 == organizeId) {
+                if (null != shopPromotions) {
+                    // 是否满足满减满赠
+                    if (MathUtil.compare(shopPromotionFee.get(), shopPromotions.getTouchPrice()) >= 0) {
+                        // 是否包含活动商品(受订单未支付自动关闭时间影响)  0 否 1 是
+                        hasActProductFlag = true;
+                        // 满减
+                        if (shopPromotions.getMode() == 2) {
+                            if (shopPromotions.getDiscount() != null && shopPromotions.getDiscount() == 1) {
+                                //叠加优惠计算
+                                //叠加倍数
+                                Double floor = Math.floor(MathUtil.div(shopPromotionFee.get(), shopPromotions.getTouchPrice()).doubleValue());
+                                // 供应商满减金额
+                                shopOrder.setPromotionFullReduction(MathUtil.mul(shopPromotions.getReducedPrice(), floor).doubleValue());
+                                // 统计订单总满减金额
+                                promotionFullReduction.set(MathUtil.add(promotionFullReduction.get(), MathUtil.mul(shopPromotions.getReducedPrice(), floor)).doubleValue());
+                                // 统计店铺商品总金额
+                                shopProductFee.set(MathUtil.sub(shopProductFee.get(), MathUtil.mul(shopPromotions.getReducedPrice(), floor)).doubleValue());
+                                // 统计需要支付金额
+                                needPayAmount.set(MathUtil.sub(needPayAmount.get(), MathUtil.mul(shopPromotions.getReducedPrice(), floor)).doubleValue());
+                                // 统计需要支付金额
+                                shopAmount.set(MathUtil.sub(shopAmount.get(), MathUtil.mul(shopPromotions.getReducedPrice(), floor)).doubleValue());
+                            } else {
+                                // 供应商满减金额
+                                shopOrder.setPromotionFullReduction(shopPromotions.getReducedPrice());
+                                // 统计订单总满减金额
+                                promotionFullReduction.set(MathUtil.add(promotionFullReduction.get(), shopPromotions.getReducedPrice()).doubleValue());
+                                // 统计店铺商品总金额
+                                shopProductFee.set(MathUtil.sub(shopProductFee.get(), shopPromotions.getReducedPrice()).doubleValue());
+                                // 统计需要支付金额
+                                needPayAmount.set(MathUtil.sub(needPayAmount.get(), shopPromotions.getReducedPrice()).doubleValue());
+                                // 统计需要支付金额
+                                shopAmount.set(MathUtil.sub(shopAmount.get(), shopPromotions.getReducedPrice()).doubleValue());
+                            }
                         }
+                        // 添加到总促销
+                        if (!promotionsIds.contains(shopPromotions.getId())) {
+                            promotionsIds.add(shopPromotions.getId());
+                            shopPromotions.setPromotionsId(shopPromotions.getId());
+                            promotionList.add(shopPromotions);
+                        }
+                        shopOrder.setOrderPromotionsId(shopPromotions.getId());
                     }
-                    // 添加到总促销
-                    if (!promotionsIds.contains(shopPromotions.getId())) {
-                        promotionsIds.add(shopPromotions.getId());
-                        shopPromotions.setPromotionsId(shopPromotions.getId());
-                        promotionList.add(shopPromotions);
-                    }
-                    shopOrder.setOrderPromotionsId(shopPromotions.getId());
                 }
             }
             // 佣金 采美应收
@@ -914,6 +940,11 @@ public class SubmitServiceImpl implements SubmitService {
             shopOrder.setSvipShopReduction(svipShopReduction.get());
             // 总价(含税) = totalFee
             shopOrder.setTotalAmount(shopProductFee.get());
+            // 联合丽格无折扣
+            if (1 == organizeId) {
+                // 总价(含税) = totalFee
+                shopOrder.setTotalAmount(shopAmount.get());
+            }
             // 总金额 = 订单商品totalAmount
             shopOrder.setProductAmount(shopAmount.get());
             // 需要支付金额 shouldPayFee +运费
@@ -953,49 +984,51 @@ public class SubmitServiceImpl implements SubmitService {
         } else {
             mainOrder.setSecondHandOrderFlag(0);
         }
-        // 是否包含活动商品(受订单未支付自动关闭时间影响)  0 否 1 是
-        if (!hasActProductFlag) {
-            mainOrder.setHasActProduct(0);
-        } else {
-            mainOrder.setHasActProduct(1);
-            // 促销活动优惠计算
-            Iterator<PromotionsVo> promotionsIterator = promotionList.iterator();
-            while (promotionsIterator.hasNext()) {
-                PromotionsVo promotions = promotionsIterator.next();
-                // 凑单优惠计算（单品与店铺已再前面分开计算了）
-                if (promotions.getType() == 2) {
-                    // 这里计算满减满赠
-                    if (promotions.getMode() == 2 || promotions.getMode() == 3) {
-                        // 实际该促销商品总额
-                        AtomicDouble tempProductFee = new AtomicDouble(0);
-                        promotions.getProductList().forEach(item -> tempProductFee.set(MathUtil.add(tempProductFee.get(), MathUtil.mul(item.getNumber(), item.getPrice())).doubleValue()));
-                        //判断是否达到满减满赠要求
-                        if (MathUtil.compare(tempProductFee.get(), promotions.getTouchPrice()) >= 0) {
-                            if (promotions.getMode() == 2) {
-                                if (promotions.getDiscount() != null && promotions.getDiscount() == 1) {
-                                    //叠加优惠计算
-                                    //叠加倍数
-                                    Double floor = Math.floor(MathUtil.div(tempProductFee.get(), promotions.getTouchPrice()).doubleValue());
-                                    // 满减
-                                    promotionFullReduction.set(MathUtil.add(promotionFullReduction.get(), MathUtil.mul(promotions.getReducedPrice(), floor)).doubleValue());
-                                    // 统计商品总金额
-                                    productTotalFee.set(MathUtil.sub(productTotalFee.get(), MathUtil.mul(promotions.getReducedPrice(), floor)).doubleValue());
-                                } else {
-                                    // 满减
-                                    promotionFullReduction.set(MathUtil.add(promotionFullReduction.get(), promotions.getReducedPrice()).doubleValue());
-                                    // 统计商品总金额
-                                    productTotalFee.set(MathUtil.sub(productTotalFee.get(), promotions.getReducedPrice()).doubleValue());
+        if (0 == organizeId) {
+            // 是否包含活动商品(受订单未支付自动关闭时间影响)  0 否 1 是
+            if (!hasActProductFlag) {
+                mainOrder.setHasActProduct(0);
+            } else {
+                mainOrder.setHasActProduct(1);
+                // 促销活动优惠计算
+                Iterator<PromotionsVo> promotionsIterator = promotionList.iterator();
+                while (promotionsIterator.hasNext()) {
+                    PromotionsVo promotions = promotionsIterator.next();
+                    // 凑单优惠计算（单品与店铺已再前面分开计算了）
+                    if (promotions.getType() == 2) {
+                        // 这里计算满减满赠
+                        if (promotions.getMode() == 2 || promotions.getMode() == 3) {
+                            // 实际该促销商品总额
+                            AtomicDouble tempProductFee = new AtomicDouble(0);
+                            promotions.getProductList().forEach(item -> tempProductFee.set(MathUtil.add(tempProductFee.get(), MathUtil.mul(item.getNumber(), item.getPrice())).doubleValue()));
+                            //判断是否达到满减满赠要求
+                            if (MathUtil.compare(tempProductFee.get(), promotions.getTouchPrice()) >= 0) {
+                                if (promotions.getMode() == 2) {
+                                    if (promotions.getDiscount() != null && promotions.getDiscount() == 1) {
+                                        //叠加优惠计算
+                                        //叠加倍数
+                                        Double floor = Math.floor(MathUtil.div(tempProductFee.get(), promotions.getTouchPrice()).doubleValue());
+                                        // 满减
+                                        promotionFullReduction.set(MathUtil.add(promotionFullReduction.get(), MathUtil.mul(promotions.getReducedPrice(), floor)).doubleValue());
+                                        // 统计商品总金额
+                                        productTotalFee.set(MathUtil.sub(productTotalFee.get(), MathUtil.mul(promotions.getReducedPrice(), floor)).doubleValue());
+                                    } else {
+                                        // 满减
+                                        promotionFullReduction.set(MathUtil.add(promotionFullReduction.get(), promotions.getReducedPrice()).doubleValue());
+                                        // 统计商品总金额
+                                        productTotalFee.set(MathUtil.sub(productTotalFee.get(), promotions.getReducedPrice()).doubleValue());
+                                    }
                                 }
+                            } else {
+                                // 删除不满足条件的凑单促销
+                                promotionsIterator.remove();
                             }
-                        } else {
-                            // 删除不满足条件的凑单促销
-                            promotionsIterator.remove();
                         }
                     }
                 }
+                // 促销满减优惠
+                mainOrder.setPromotionFullReduction(promotionFullReduction.get());
             }
-            // 促销满减优惠
-            mainOrder.setPromotionFullReduction(promotionFullReduction.get());
         }
         // 商品总数量
         mainOrder.setProductCount(productCount.get());
@@ -1059,15 +1092,20 @@ public class SubmitServiceImpl implements SubmitService {
         // 订单总额（商品金额+运费）
         mainOrder.setPayTotalFee(payTotalFee.get());
         // 订单状态
-        if (3 == orderParamBo.getCartType()) {
-            // 协销 状态为 待确认
-            mainOrder.setStatus(0);
+        if (0 == organizeId) {
+            if (3 == orderParamBo.getCartType()) {
+                // 协销 状态为 待确认
+                mainOrder.setStatus(0);
+            } else {
+                // 机构用户 状态为 待收待发
+                mainOrder.setStatus(11);
+                mainOrder.setConfirmTime(curDateStr);
+            }
         } else {
             // 机构用户 状态为 待收待发
             mainOrder.setStatus(11);
             mainOrder.setConfirmTime(curDateStr);
         }
-
         // 是否完成支付(默认不是，只有余额抵扣才算)
         boolean isPaySuccessFlag = false;
         // 余额支付标识，0不使用，1使用
@@ -1146,7 +1184,8 @@ public class SubmitServiceImpl implements SubmitService {
             mainOrder.setClauseId(1);
             mainOrder.setClauseName("无条款");
         }
-
+        // 设置组织Id
+        mainOrder.setOrganizeId(organizeId);
         /**
          * 保存主订单数据，返回订单Id
          */
@@ -1312,6 +1351,8 @@ public class SubmitServiceImpl implements SubmitService {
                     shopOrder.setOrderPromotionsId(promotions.getId());
                 }
             });
+            // 设置组织Id
+            shopOrder.setOrganizeId(organizeId);
             /*
              * 保存子订单
              */
@@ -1355,6 +1396,7 @@ public class SubmitServiceImpl implements SubmitService {
                     orderProduct.setActProduct(1);
                 }
             });
+            orderProduct.setOrganizeId(organizeId);
             /*
              * 保存 订单商品
              */
@@ -1378,7 +1420,7 @@ public class SubmitServiceImpl implements SubmitService {
             /*
              * 机构用户 写入价格库
              */
-            if (3 != orderParamBo.getCartType() && 1 != orderProduct.getSvipPriceFlag()) {
+            if (3 != orderParamBo.getCartType() && 1 != orderProduct.getSvipPriceFlag() && 0 == organizeId) {
                 // 写入复购价格库
                 productService.savePurchasePrice(mainOrder, orderProduct, secondHandOrderFlag, "【提交订单】");
             }
@@ -1495,7 +1537,27 @@ public class SubmitServiceImpl implements SubmitService {
          * onlinePayFlag:0可以 1不可以
          */
         Integer onlinePayFlag = onlinePay.get() ? 0 : 1;
+        // 组织 是否线上判定
+        boolean item = true;
+        if (0 != organizeId) {
+            // 子订单分帐号
+            for (OrderShopPo shopOrder : shopOrderList) {
+                if (StringUtils.isEmpty(shopOrder.getSplitCode()) || StringUtils.isBlank(shopOrder.getSplitCode())) {
+                    item = false;
+                }
+            }
+            if (item) {
+                onlinePayFlag = 0;
+            } else {
+                onlinePayFlag = 1;
+            }
+        }
         submitMapper.updateOnlinePayFlag(onlinePayFlag, mainOrder.getOrderId());
+        // 更新子订单线上支付
+        if(0 != organizeId && item) {
+            String onlinePayWays = "1,2,3,4,5";
+            submitMapper.updateOnlinePayWays(onlinePayWays, mainOrder.getOrderId());
+        }
         /*
          * 保存 订单收货用户信息
          */
@@ -1613,84 +1675,86 @@ public class SubmitServiceImpl implements SubmitService {
         /**
          * 自主下单价格低于1000，倒扣500采美豆
          */
-        try {
-            if (orderParamBo.getCartType() != 3 && payTotalFee.get() < 1000) {
-                if (orderParamBo.getUserBeans() < 0) {
-                    //设置手动回滚事务
-                    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
-                    return ResponseJson.error(-4, "采美豆不足，不能提交订单。建议您前往采美旗下“呵呵商城”小程序购买小额商品。");
-                } else {
-                    //查历史2021.10.27后是否有两个1000以下订单，有return不让下单，没有扣豆子
-                    SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
-                    Date orderTime = format.parse("2021-10-28 10:40:01");
-                    List<Integer> mainOrderIds = submitMapper.findLowOrder(mainOrder.getUserId(), orderTime);
-                    if (mainOrderIds != null && mainOrderIds.size() > 2) {
+        if (0 == organizeId) {
+            try {
+                if (orderParamBo.getCartType() != 3 && payTotalFee.get() < 1000) {
+                    if (orderParamBo.getUserBeans() < 0) {
                         //设置手动回滚事务
                         TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
-                        return ResponseJson.error(-3, "您已有2个采购金额过小的订单，本次不能再进行采购。您可使用微信扫描以下二维码，进入采美旗下“呵呵商城”小程序购买小额商品");
-                    }
-                    if (orderParamBo.getOrderMiniType() == 0) {
-                        if (mainOrderIds != null && mainOrderIds.size() <= 1) {
-                            // 设置手动回滚事务
+                        return ResponseJson.error(-4, "采美豆不足，不能提交订单。建议您前往采美旗下“呵呵商城”小程序购买小额商品。");
+                    } else {
+                        //查历史2021.10.27后是否有两个1000以下订单，有return不让下单，没有扣豆子
+                        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+                        Date orderTime = format.parse("2021-10-28 10:40:01");
+                        List<Integer> mainOrderIds = submitMapper.findLowOrder(mainOrder.getUserId(), orderTime);
+                        if (mainOrderIds != null && mainOrderIds.size() > 2) {
+                            //设置手动回滚事务
                             TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
-                            return ResponseJson.error(-5, "采购金额过小，将扣除500采美豆，建议您使用微信扫描以下二维码，进入采美旗下“呵呵商城”小程序购买小额商品。");
+                            return ResponseJson.error(-3, "您已有2个采购金额过小的订单，本次不能再进行采购。您可使用微信扫描以下二维码，进入采美旗下“呵呵商城”小程序购买小额商品");
+                        }
+                        if (orderParamBo.getOrderMiniType() == 0) {
+                            if (mainOrderIds != null && mainOrderIds.size() <= 1) {
+                                // 设置手动回滚事务
+                                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+                                return ResponseJson.error(-5, "采购金额过小，将扣除500采美豆，建议您使用微信扫描以下二维码，进入采美旗下“呵呵商城”小程序购买小额商品。");
+                            }
                         }
+                        log.info("订单提交状态:" + orderParamBo.getOrderMiniType());
+                        UserBeansHistoryPo beansHistory = new UserBeansHistoryPo();
+                        beansHistory.setUserId(mainOrder.getUserId());
+                        beansHistory.setOrderId(mainOrder.getOrderId());
+                        beansHistory.setBeansType(15);
+                        beansHistory.setType(2);
+                        beansHistory.setNum(500);
+                        beansHistory.setPushStatus(0);
+                        beansHistory.setAddTime(date);
+                        beansHistory.setDelFlag(0);
+                        int beans = baseMapper.findBeans(orderParamBo.getUserId()) - 500;
+                        productService.updateUserBeans(beansHistory, beans, "【价格低于1000，倒扣500采美豆】");
                     }
-                    log.info("订单提交状态:" + orderParamBo.getOrderMiniType());
-                    UserBeansHistoryPo beansHistory = new UserBeansHistoryPo();
-                    beansHistory.setUserId(mainOrder.getUserId());
-                    beansHistory.setOrderId(mainOrder.getOrderId());
-                    beansHistory.setBeansType(15);
-                    beansHistory.setType(2);
-                    beansHistory.setNum(500);
-                    beansHistory.setPushStatus(0);
-                    beansHistory.setAddTime(date);
-                    beansHistory.setDelFlag(0);
-                    int beans = baseMapper.findBeans(orderParamBo.getUserId()) - 500;
-                    productService.updateUserBeans(beansHistory, beans, "【价格低于1000，倒扣500采美豆】");
                 }
-            }
-            if (orderParamBo.getOrderMiniType() != 2) {
-                boolean bol = false;
-                // 机构一级分类
-                String firstClubType = baseMapper.firstClubTypeById(orderParamBo.getClubId());
-                if (!StringUtils.isNotBlank(firstClubType)) {
-                    firstClubType = "0";
-                }
-                // 获取订单商品械字号类型
-                List<String> machineType = baseMapper.machineTypeByID(skuIdList);
-                for (String str : machineType) {
-                    if ("3".equals(str)) {
-                        bol = true;
+                if (orderParamBo.getOrderMiniType() != 2) {
+                    boolean bol = false;
+                    // 机构一级分类
+                    String firstClubType = baseMapper.firstClubTypeById(orderParamBo.getClubId());
+                    if (!StringUtils.isNotBlank(firstClubType)) {
+                        firstClubType = "0";
                     }
-                }
-                if (!"1".equals(firstClubType) && bol) {
+                    // 获取订单商品械字号类型
+                    List<String> machineType = baseMapper.machineTypeByID(skuIdList);
+                    for (String str : machineType) {
+                        if ("3".equals(str)) {
+                            bol = true;
+                        }
+                    }
+                    if (!"1".equals(firstClubType) && bol) {
 //                map.put("code", -1);
-                    // 设置手动回滚事务
-                    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
-                    return ResponseJson.error(-6, "订单内存在械字号三类商品，需要拥有医疗执业许可证的医美机构才能购买。建议升级医美机构后再下单，否则会导致订单退款或影响发货。");
+                        // 设置手动回滚事务
+                        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+                        return ResponseJson.error(-6, "订单内存在械字号三类商品，需要拥有医疗执业许可证的医美机构才能购买。建议升级医美机构后再下单，否则会导致订单退款或影响发货。");
+                    }
                 }
+            } catch (ParseException e) {
+                log.info("自主下单价格低于1000，倒扣500采美豆", e);
             }
-        } catch (ParseException e) {
-            log.info("自主下单价格低于1000，倒扣500采美豆", e);
-        }
-        /*
-         * 保存优惠券使用情况
-         */
-        if (null != orderParamBo.getClubCouponId() && orderParamBo.getClubCouponId() > 0) {
-            // 修改优惠券使用情况
-            if (3 != orderParamBo.getCartType()) {
-                // 自主订单立即确认，协销订单待确认 ，确认订单时才真正使用优惠券
-                orderClubMapper.updateCouponClubStatus(orderParamBo.getClubCouponId(), mainOrder.getOrderId());
+
+            /*
+             * 保存优惠券使用情况
+             */
+            if (null != orderParamBo.getClubCouponId() && orderParamBo.getClubCouponId() > 0) {
+                // 修改优惠券使用情况
+                if (3 != orderParamBo.getCartType()) {
+                    // 自主订单立即确认，协销订单待确认 ，确认订单时才真正使用优惠券
+                    orderClubMapper.updateCouponClubStatus(orderParamBo.getClubCouponId(), mainOrder.getOrderId());
+                }
+                CouponOrderRecordPo orderRecord = new CouponOrderRecordPo();
+                BeanUtils.copyProperties(coupon, orderRecord);
+                orderRecord.setOrderId(mainOrder.getOrderId());
+                orderRecord.setCreateDate(date);
+                // 保存订单优惠券使用记录
+                submitMapper.insertCouponOrderRecord(orderRecord);
             }
-            CouponOrderRecordPo orderRecord = new CouponOrderRecordPo();
-            BeanUtils.copyProperties(coupon, orderRecord);
-            orderRecord.setOrderId(mainOrder.getOrderId());
-            orderRecord.setCreateDate(date);
-            // 保存订单优惠券使用记录
-            submitMapper.insertCouponOrderRecord(orderRecord);
         }
-
         /*
          * 删除购物车
          */
@@ -1744,18 +1808,20 @@ public class SubmitServiceImpl implements SubmitService {
         /*
          * 下单推送(自主订单才推送)
          */
-        if (orderClubMapper.getProductOrder(mainOrder.getOrderId()).contains(6060)) {
-            if (StringUtils.isNotBlank(orderParamBo.getBindMobile()) && 0 == mainOrder.getRebateFlag() && 1 == mainOrder.getOrderType()) {
-                String shortLink = remoteCallService.getShortLink(8, 3, domain + "/user/order/detail.html?orderId=" + mainOrder.getOrderId());
-                String name = orderProductList.get(0).getName();
-                if (name.length() > 10) {
-                    name = name.substring(0, 10);
-                }
-                String content = "您已成功下单“" + name + "...”等" + mainOrder.getProductCount() + "件商品，订单编号：" + mainOrder.getOrderNo() + "，订单等待支付，支付完成后采美将尽快安排发货。" +
-                        "您可关注采美公众号或者访问采美微信小程序和网站查看并支付订单。平台公众号：微信搜索“采美365网”; 微信小程序：微信搜索“采美采购商城”；网址：www.caimei365.com/t/" + shortLink;
-                boolean sendSms = remoteCallService.getSendSms(1, 3, orderParamBo.getBindMobile(), content);
-                if (!sendSms) {
-                    log.info("下单推送失败，orderId>>>>" + mainOrder.getOrderId());
+        if (0 == organizeId) {
+            if (orderClubMapper.getProductOrder(mainOrder.getOrderId()).contains(6060)) {
+                if (StringUtils.isNotBlank(orderParamBo.getBindMobile()) && 0 == mainOrder.getRebateFlag() && 1 == mainOrder.getOrderType()) {
+                    String shortLink = remoteCallService.getShortLink(8, 3, domain + "/user/order/detail.html?orderId=" + mainOrder.getOrderId());
+                    String name = orderProductList.get(0).getName();
+                    if (name.length() > 10) {
+                        name = name.substring(0, 10);
+                    }
+                    String content = "您已成功下单“" + name + "...”等" + mainOrder.getProductCount() + "件商品，订单编号：" + mainOrder.getOrderNo() + "，订单等待支付，支付完成后采美将尽快安排发货。" +
+                            "您可关注采美公众号或者访问采美微信小程序和网站查看并支付订单。平台公众号：微信搜索“采美365网”; 微信小程序：微信搜索“采美采购商城”；网址：www.caimei365.com/t/" + shortLink;
+                    boolean sendSms = remoteCallService.getSendSms(1, 3, orderParamBo.getBindMobile(), content);
+                    if (!sendSms) {
+                        log.info("下单推送失败，orderId>>>>" + mainOrder.getOrderId());
+                    }
                 }
             }
         }

src/main/java/com/caimei365/order/utils/CodeUtil.java

@@ -87,7 +87,7 @@ public class CodeUtil {
 
     /**
      * 生成主订单编号
-     * @param orderSource 订单来源：1WWW、2CRM、4客服[适用后台下单]、5外单[适用后台下单]、6小程序[采美,星范]、7呵呵商城小程序、8维沙小程序
+     * @param orderSource 订单来源：1WWW、2CRM、4客服[适用后台下单]、5外单[适用后台下单]、6小程序[采美,星范]、7呵呵商城小程序、8维沙小程序、9联合丽格
      * @return 主订单编号
      */
     public static String generateOrderNo(Integer orderSource) {
@@ -106,6 +106,8 @@ public class CodeUtil {
             platform = "H";
         } else if (8 == orderSource) {
             platform = "A";
+        } else if (9 == orderSource) {
+            platform = "L";
         } else {
             // 未知来源
             platform = "E";

src/main/resources/mapper/BaseMapper.xml

@@ -4,6 +4,9 @@
     <select id="getOrganizeId" resultType="java.lang.Integer">
         SELECT userOrganizeID FROM USER WHERE userId = #{userId}
     </select>
+    <select id="getOrganizeIdShop" resultType="java.lang.Integer">
+        SELECT organizeID FROM cm_shop_order WHERE shopOrderID = #{shopOrderId}
+    </select>
     <select id="getShopNameById" resultType="java.lang.String">
         SELECT `name`
         FROM shop

src/main/resources/mapper/CartClubMapper.xml

@@ -88,7 +88,7 @@
           and p.shopID = #{shopId}
         ORDER BY c.cm_cartID DESC
     </select>
-    <select id="getCartOrganizeProductsByShopId" resultType="com.caimei365.order.model.vo.CartItemVo">
+        <select id="getCartOrganizeProductsByShopId" resultType="com.caimei365.order.model.vo.CartItemVo">
         SELECT c.cm_cartID                   AS id,
                c.productCount                AS number,
                p.productID                   AS productId,
@@ -102,7 +102,7 @@
                cs.unit                       AS unit,
                cs.stock                      AS stock,
                p.step                        AS step,
-               IFNULL(cs.minBuyNumber,(SELECT buyNum FROM product_ladder_price WHERE skuId=c.skuId ORDER BY buyNum ASC LIMIT 1)) AS MIN,
+               cmps.minBuyNumber AS MIN,
                p.priceFlag,
                IFNULL(cs.ladderPriceFlag, 0) AS ladderFlag,
                p.includedTax                 AS includedTax,
@@ -168,6 +168,52 @@
         </foreach>
         ORDER BY c.cm_cartID DESC
     </select>
+    <select id="getCartProductsOrganize" resultType="com.caimei365.order.model.vo.CartItemVo">
+        SELECT
+        c.skuId AS skuId,
+        c.cm_cartID AS id,
+        c.productCount AS number,
+        p.productID AS productId,
+        p.shopID AS shopId,
+        p.`name` AS `name`,
+        p.mainImage AS image,
+        p.productCode,
+        cmps.price,
+        cmps.price AS originalPrice,
+        cs.unit AS unit,
+        ifnull(cs.stock,0) AS stock,
+        p.step AS step,
+        cmps.minBuyNumber AS min,
+        p.priceFlag,
+        cs.ladderPriceFlag AS ladderFlag,
+        p.includedTax AS includedTax,
+        p.invoiceType AS invoiceType,
+        p.taxPoint AS taxRate,
+        p.productCategory,
+        cmop.validFlag AS validFlag,
+        p.visibility,
+        p.commodityType as commodityType,
+        #         csp.priceType as svipPriceType,
+        #         csp.discount as svipDiscount,
+        #         csp.discountPrice as svipDiscountPrice,
+        p.productType,
+        p.splitCode
+        FROM cm_cart c
+        LEFT JOIN product p ON c.productID = p.productID
+        LEFT JOIN cm_sku cs ON c.skuId = cs.skuId
+        LEFT JOIN cm_mall_organize_products cmop ON cmop.productId = p.productID
+        LEFT JOIN cm_mall_product_sku cmps ON cmps.skuId = cs.skuId
+        WHERE c.userID = #{userId} and p.shopID = #{shopId} and cmop.organizeID = #{organizeId}
+        AND cmop.validFlag='1'
+        <if test="splitCode !=null and splitCode !=''">
+            AND p.splitCode = #{splitCode}
+        </if>
+        AND cs.skuId in
+        <foreach collection="skuIds" open="(" separator="," close=")" item="skuId">
+            #{skuId}
+        </foreach>
+        ORDER BY c.cm_cartID DESC
+    </select>
 
     <select id="getProductsByShopIdAndProductIds" resultType="com.caimei365.order.model.vo.CartItemVo">
         SELECT
@@ -241,6 +287,43 @@
           AND cs.stock <![CDATA[ >= ]]> c.productCount
         ORDER BY c.cm_cartID DESC
     </select>
+    <select id="getCartOrganizeProductList" resultType="com.caimei365.order.model.vo.CartItemVo">
+        SELECT c.skuId            AS skuId,
+               c.cm_cartID        AS id,
+               c.productCount     AS number,
+               p.productID        AS productId,
+               p.shopID           AS shopId,
+               p.`name`           AS `name`,
+               p.mainImage        AS image,
+               p.productCode,
+               cmps.price,
+               cmps.price           AS originalPrice,
+               cs.unit            AS unit,
+               cs.stock           AS stock,
+               p.step             AS step,
+               cmps.minBuyNumber    AS MIN,
+               p.priceFlag,
+               cs.ladderPriceFlag AS ladderFlag,
+               p.includedTax      AS includedTax,
+               p.invoiceType      AS invoiceType,
+               p.taxPoint         AS taxRate,
+               p.productCategory,
+               p.visibility,
+               cmop.validFlag        AS validFlag,
+               p.productType
+        FROM cm_cart c
+                 LEFT JOIN product p ON c.productID = p.productID
+                 LEFT JOIN cm_sku cs ON cs.skuId = c.skuId
+                 LEFT JOIN cm_mall_organize_products cmop ON cmop.productId = c.productID
+                 LEFT JOIN cm_mall_product_sku cmps ON cmps.skuId = c.skuId
+        WHERE -- cmop.validFlag = '1'
+           c.userID = #{userId}
+          AND p.priceFlag != '1'
+          AND cs.stock != '0'
+          AND cmop.organizeId = 4
+          AND cs.stock <![CDATA[ >= ]]> c.productCount
+        ORDER BY c.cm_cartID DESC
+    </select>
     <select id="getCartPo" resultType="com.caimei365.order.model.po.CartPo">
         SELECT c.cm_cartID AS id,
                c.productCount,
@@ -359,6 +442,37 @@
           AND cs.skuId = #{skuId}
     </select>
 
+    <select id="getCartOrganizeProductId" resultType="com.caimei365.order.model.vo.CartItemVo">
+        SELECT cs.skuId,
+               p.productID                  AS productId,
+               p.shopID                     AS shopId,
+               p.`name`                     AS `name`,
+               p.mainImage                  AS image,
+               p.productCode,
+               cmps.price,
+               cmps.price                     AS originalPrice,
+               cs.unit                      AS unit,
+               IFNULL(cs.stock,0)           AS stock,
+               p.step                       AS step,
+               cmps.minBuyNumber AS MIN,
+               p.priceFlag,
+               cs.ladderPriceFlag           AS ladderFlag,
+               p.includedTax                AS includedTax,
+               p.invoiceType                AS invoiceType,
+               p.taxPoint                   AS taxRate,
+               p.productCategory,
+               p.validFlag                  AS validFlag,
+               p.visibility,
+               p.commodityType              AS commodityType,
+               p.productType,
+               p.returnGoodsStutas
+        FROM cm_mall_product_sku cmps
+                 LEFT JOIN cm_sku cs ON cmps.skuId = cs.skuId
+                 LEFT JOIN product p ON p.productID = cs.productId
+        WHERE p.validFlag = '2'
+          AND cs.skuId = #{skuId}
+    </select>
+
     <select id="findVipCoupon" resultType="java.lang.Integer">
         select couponId
         from cm_svip_coupon

src/main/resources/mapper/OrderClubMapper.xml

@@ -152,6 +152,7 @@
     <select id="getMainOrderByOrderId" resultType="com.caimei365.order.model.po.OrderPo">
         SELECT ifnull(orderSeen, 0) AS orderSeen,
                orderID              AS orderId,
+               organizeID           AS organizeId,
                shopOrderIds,
                orderSource,
                orderNo,
@@ -311,6 +312,7 @@
     </select>
     <select id="getOrderList" resultType="com.caimei365.order.model.vo.OrderVo">
         SELECT
+        organizeID as organizeId,
         ifnull(orderSeen,0) AS orderSeen,
         orderID AS orderId,
         shopOrderIds,
@@ -753,9 +755,49 @@
         ORDER BY price ASC
     </select>
     <select id="getOrganizeSku" resultType="com.caimei365.order.model.vo.Sku">
-        SELECT skuId, minBuyNumber, price
-        FROM cm_mall_product_sku
-        WHERE productId = #{productId}
-        ORDER BY price ASC
+        SELECT distinct cmps.skuId, cmps.minBuyNumber, cmps.price,
+            cs.normalPrice,
+            cs.costPrice,
+            ifnull(cs.ladderPriceFlag,0) as ladderPriceFlag,
+            cs.costCheckFlag,
+            cs.costProportional,
+            cs.stock,
+            cs.unit
+        FROM cm_mall_product_sku cmps
+        left join cm_sku cs on cmps.skuId = cs.skuId
+        WHERE cmps.productId = #{productId}
+        ORDER BY cmps.price ASC
+    </select>
+    <select id="getVoucher" resultType="com.caimei365.order.model.po.VoucherPo">
+        SELECT id, orderId, remarks, addtime FROM cm_order_payment_voucher WHERE orderId = #{orderId}
+    </select>
+    <select id="getVoucherImage" resultType="com.caimei365.order.model.dto.VoucherImageDto">
+        SELECT id, voucherId, image as img FROM cm_voucher_image
+        <where>
+            <if test="voucherIds.size()>0">
+                voucherId in
+                <foreach collection="voucherIds" item="voucherId" open="(" separator="," close=")">
+                    #{voucherId}
+                </foreach>
+            </if>
+        </where>
     </select>
+    <update id="updateVoucher">
+        update cm_order_payment_voucher
+        set remarks = #{remarks}
+        where id = #{id}
+    </update>
+    <insert id="insertVoucher" parameterType="com.caimei365.order.model.dto.VoucherDto" keyProperty="id" useGeneratedKeys="true">
+        insert into cm_order_payment_voucher (orderId, remarks, addtime)
+        values (#{orderId},#{remarks},now())
+    </insert>
+    <update id="updateVoucherImage">
+        update cm_voucher_image
+        set image = #{image}
+        where id = #{id}
+    </update>
+    <insert id="insertVoucherImage">
+        insert into cm_voucher_image (voucherId, image)
+        values (#{voucherId},#{img})
+    </insert>
 </mapper>

src/main/resources/mapper/OrderCommonMapper.xml

@@ -627,6 +627,7 @@
         SELECT cop.shopOrderID                  AS shopOrderId,
                cop.shopOrderNo,
                cop.orderID                      AS orderId,
+               cop.organizeID                   as organizeId,
                cop.orderNo,
                cop.shopID                       AS shopId,
                cop.note,

src/main/resources/mapper/SubmitMapper.xml

@@ -29,14 +29,14 @@
     </insert>
     <insert id="insertShopOrder" keyColumn="shopOrderID" keyProperty="shopOrderId"
             parameterType="com.caimei365.order.model.po.OrderShopPo" useGeneratedKeys="true">
-        INSERT INTO cm_shop_order (onlinePayWays, shopOrderNo, orderID, orderNo, shopID, note, userID, clubID, orderType,
+        INSERT INTO cm_shop_order (onlinePayWays, shopOrderNo, orderID, orderNo, organizeID, shopID, note, userID, clubID, orderType,
                                    spID, orderPromotionsId, promotionFullReduction, svipShopReduction, brokerage,
                                    canRefundAmount, itemCount,
                                    totalAmount, productAmount, needPayAmount, shopProductAmount, shopPostFee,
                                    shopTaxFee,
                                    shouldPayShopAmount, orderTime, orderSubmitType, splitFlag, payStatus,
                                    payedShopAmount, splitCode, realPay, eachDiscount, receiptStatus)
-        VALUES (#{onlinePayWays}, #{shopOrderNo}, #{orderId}, #{orderNo}, #{shopId}, #{note}, #{userId}, #{clubId}, #{orderType},
+        VALUES (#{onlinePayWays}, #{shopOrderNo}, #{orderId}, #{orderNo}, #{organizeId}, #{shopId}, #{note}, #{userId}, #{clubId}, #{orderType},
                 #{spId}, #{orderPromotionsId}, #{promotionFullReduction}, #{svipShopReduction}, #{brokerage},
                 #{canRefundAmount}, #{itemCount},
                 #{totalAmount}, #{productAmount}, #{needPayAmount}, #{shopProductAmount}, #{shopPostFee}, #{shopTaxFee},
@@ -45,7 +45,7 @@
     </insert>
     <insert id="insertOrderProduct" keyColumn="orderProductID" keyProperty="orderProductId"
             parameterType="com.caimei365.order.model.po.OrderProductPo" useGeneratedKeys="true">
-        INSERT INTO cm_order_product (orderID, orderNo, shopOrderID, shopOrderNo, orderPromotionsId, productId, shopId,
+        INSERT INTO cm_order_product (orderID, orderNo, shopOrderID, shopOrderNo, organizeProductID,organizeID, orderPromotionsId, productId, shopId,
                                       name,
                                       productImage, price, shopName, costPrice, normalPrice, ladderPriceFlag,
                                       discountPrice, discount,
@@ -57,8 +57,8 @@
                                       cmFee,
                                       payStatus, buyAgainFlag, notOutStore, isActProduct, productType, svipPriceFlag,
                                       svipPriceType,
-                                      svipDiscount, svipReduction,skuID)
-        VALUES (#{orderId}, #{orderNo}, #{shopOrderId}, #{shopOrderNo}, #{orderPromotionsId}, #{productId}, #{shopId},
+                                      svipDiscount, svipReduction,skuID, cmPercent, organizePercent, shopPercent)
+        VALUES (#{orderId}, #{orderNo}, #{shopOrderId}, #{shopOrderNo}, #{organizeProductId}, #{organizeId}, #{orderPromotionsId}, #{productId}, #{shopId},
                 #{name},
                 #{image}, #{price}, #{shopName}, #{costPrice}, #{normalPrice}, #{ladderPriceFlag},
                 #{discountPrice}, #{discount},
@@ -69,7 +69,7 @@
                 #{shopProductAmount}, #{singleShopFee}, #{shopFee}, #{singleOtherFee}, #{otherFee}, #{singleCmFee},
                 #{cmFee},
                 #{payStatus}, #{buyAgainFlag}, #{notOutStore}, #{actProduct}, #{productType}, #{svipPriceFlag},
-                #{svipPriceType}, #{svipDiscount}, #{svipReduction},#{skuId})
+                #{svipPriceType}, #{svipDiscount}, #{svipReduction},#{skuId}, #{cmPercent}, #{organizePercent}, #{shopPercent})
     </insert>
     <insert id="insertOrderPromotions" keyColumn="id" keyProperty="id"
             parameterType="com.caimei365.order.model.vo.PromotionsVo" useGeneratedKeys="true">
@@ -148,6 +148,32 @@
         SET onlinePayFlag = #{onlinePayFlag}
         WHERE orderID = #{orderId}
     </update>
+    <update id="updateOnlinePayWays">
+        UPDATE cm_shop_order
+        SET onlinePayWays = #{onlinePayWays}
+        WHERE orderID = #{orderId}
+    </update>
+    <select id="getOrganizeSkuInfo" resultType="com.caimei365.order.model.po.CmOrganizeSkuPo">
+        SELECT
+            cmps.id,
+            cmps.productId,
+            cmps.id,
+            cmps.skuId,
+            cmps.minBuyNumber,
+            cmps.price,
+            cs.unit,
+            cs.price as clubPrice,
+            cs.costCheckFlag as costCheckFlag,
+            cs.costPrice as costPrice,
+            cs.costProportional as costProportional,
+            cs.minBuyNumber AS cmMinBuyNumber,
+            cmps.organizePercent,
+            cmps.shopPercent,
+            cmps.cmPercent
+        FROM cm_mall_product_sku cmps
+                 LEFT JOIN cm_sku cs ON cmps.skuId = cs.skuId
+            where cmps.skuId = #{skuId}
+    </select>
     <select id="getOrderInvoice" resultType="com.caimei365.order.model.po.InvoicePo">
         SELECT id,
                orderId,
@@ -206,6 +232,32 @@
         LEFT JOIN cm_sku cs on p.productID = cs.productId
         WHERE cs.skuId = #{skuId}
     </select>
+    <select id="getProductOrganizeDetails" resultType="com.caimei365.order.model.po.OrderProductPo">
+        SELECT cs.skuId                   AS skuId,
+               p.productID                AS productId,
+               p.shopID                   AS shopId,
+               p.`name`                   AS `name`,
+               p.mainImage                AS image,
+               cmop.id as organizeProductId,
+               cmps.price,
+               cs.costPrice,
+               IFNULL(cs.costCheckFlag, 1) AS costCheckFlag,
+               cs.costProportional,
+               p.productCategory,
+               cs.ladderPriceFlag,
+               p.includedTax,
+               p.invoiceType,
+               p.taxPoint                 AS taxRate,
+               cs.unit                     AS productUnit,
+               cs.normalPrice,
+               p.supplierTaxPoint         AS shopTaxRate,
+               p.splitCode as splitCode
+        FROM product p
+                 LEFT JOIN cm_sku cs on p.productID = cs.productId
+                 LEFT JOIN cm_mall_organize_products cmop ON cmop.productId = p.productID
+                 LEFT JOIN cm_mall_product_sku cmps ON cmps.skuId = cs.skuId
+        WHERE cs.skuId = #{skuId}
+    </select>
     <select id="getClauseNameById" resultType="java.lang.String">
         SELECT `name`
         FROM bp_clause