Browse Source

fix order

release_toaliyun_real
xiaohanzi 4 years ago
parent
commit
2eb0d7f99d
23 changed files with 710 additions and 378 deletions
  1. +102
    -1
      mallinkAdmin/src/main/resources/db/migration/V202109070001__order.sql
  2. +14
    -13
      mallinkCApi/src/main/java/com/iformall/controller/WxOrderController.java
  3. +45
    -24
      mallinkCApi/src/main/java/com/iformall/controller/WxPayOrderController.java
  4. +2
    -2
      mallinkSchedule/src/main/java/com/iformall/schedule/OrderExpiringSchedule.java
  5. +4
    -10
      mallinkService/src/main/java/com/iformall/domain/po/WxComposeOrder.java
  6. +3
    -0
      mallinkService/src/main/java/com/iformall/domain/po/WxPayOrder.java
  7. +36
    -0
      mallinkService/src/main/java/com/iformall/enums/EnumComposeOrder.java
  8. +8
    -1
      mallinkService/src/main/java/com/iformall/mapper/WxComposeOrderMapper.java
  9. +2
    -0
      mallinkService/src/main/java/com/iformall/mapper/WxOrderMapper.java
  10. +4
    -0
      mallinkService/src/main/java/com/iformall/service/WxOrderService.java
  11. +3
    -2
      mallinkService/src/main/java/com/iformall/service/WxPayOrderService.java
  12. +4
    -7
      mallinkService/src/main/java/com/iformall/service/helper/WxPayOrderServiceHelper.java
  13. +100
    -18
      mallinkService/src/main/java/com/iformall/service/impl/WxOrderServiceImpl.java
  14. +273
    -164
      mallinkService/src/main/java/com/iformall/service/impl/WxPayOrderServiceImpl.java
  15. +1
    -1
      mallinkService/src/main/java/com/iformall/service/impl/WxRefundOrderServiceImpl.java
  16. +4
    -3
      mallinkService/src/main/java/com/iformall/service/pay/service/pay/PayAdapterService.java
  17. +5
    -4
      mallinkService/src/main/java/com/iformall/service/pay/service/pay/wx/BaseWxPayAdapterService.java
  18. +6
    -5
      mallinkService/src/main/java/com/iformall/service/pay/service/pay/wx/h5/WxH5PayService.java
  19. +46
    -16
      mallinkService/src/main/java/com/iformall/service/pay/service/pay/wx/miniApp/appPay/WxMiniAppPayAdapterService.java
  20. +20
    -11
      mallinkService/src/main/java/com/iformall/service/pay/service/pay/wx/miniApp/maPay/WxMiniMaPayAdapterService.java
  21. +8
    -95
      mallinkService/src/main/resources/mapper/WxComposeOrderMapper.xml
  22. +14
    -0
      mallinkService/src/main/resources/mapper/WxOrderMapper.xml
  23. +6
    -1
      mallinkService/src/main/resources/mapper/WxPayOrderMapper.xml

+ 102
- 1
mallinkAdmin/src/main/resources/db/migration/V202109070001__order.sql View File

@@ -214,4 +214,105 @@ ALTER TABLE wx_order_95 ADD COLUMN `coupon_number` int(8) COMMENT '购买
ALTER TABLE wx_order_96 ADD COLUMN `coupon_number` int(8) COMMENT '购买券数量'; ALTER TABLE wx_order_96 ADD COLUMN `coupon_number` int(8) COMMENT '购买券数量';
ALTER TABLE wx_order_97 ADD COLUMN `coupon_number` int(8) COMMENT '购买券数量'; ALTER TABLE wx_order_97 ADD COLUMN `coupon_number` int(8) COMMENT '购买券数量';
ALTER TABLE wx_order_98 ADD COLUMN `coupon_number` int(8) COMMENT '购买券数量'; ALTER TABLE wx_order_98 ADD COLUMN `coupon_number` int(8) COMMENT '购买券数量';
ALTER TABLE wx_order_99 ADD COLUMN `coupon_number` int(8) COMMENT '购买券数量';
ALTER TABLE wx_order_99 ADD COLUMN `coupon_number` int(8) COMMENT '购买券数量';

ALTER TABLE wx_pay_order_0 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_1 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_2 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_3 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_4 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_5 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_6 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_7 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_8 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_9 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_10 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_11 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_12 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_13 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_14 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_15 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_16 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_17 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_18 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_19 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_20 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_21 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_22 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_23 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_24 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_25 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_26 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_27 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_28 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_29 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_30 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_31 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_32 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_33 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_34 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_35 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_36 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_37 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_38 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_39 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_40 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_41 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_42 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_43 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_44 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_45 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_46 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_47 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_48 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_49 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_50 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_51 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_52 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_53 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_54 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_55 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_56 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_57 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_58 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_59 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_60 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_61 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_62 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_63 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_64 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_65 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_66 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_67 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_68 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_69 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_70 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_71 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_72 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_73 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_74 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_75 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_76 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_77 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_78 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_79 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_80 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_81 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_82 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_83 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_84 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_85 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_86 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_87 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_88 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_89 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_90 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_91 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_92 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_93 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_94 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_95 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_96 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_97 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_98 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';
ALTER TABLE wx_pay_order_99 ADD COLUMN `compose_order` TINYINT(1) COMMENT '是否为组合订单,1-是 0-不是';

+ 14
- 13
mallinkCApi/src/main/java/com/iformall/controller/WxOrderController.java View File

@@ -61,7 +61,7 @@ public class WxOrderController extends BaseController {
@Autowired @Autowired
RedisLock redisLock; RedisLock redisLock;


@ApiOperation(value = "多个券多个数量组合下订单", notes = "[{\"signleOrder\":{\"couponChannelId\":\"String\",\"couponId\":\"String\",\"press\":\"String\",\"orderGroupId\":\"String\",\"formId\":\"String\"},\"count\":8},]")
@ApiOperation(value = "多个券多个数量组合下订单(购物车组合)", notes = "[{\"signleOrder\":{\"couponChannelId\":\"String\",\"couponId\":\"String\",\"press\":\"String\",\"orderGroupId\":\"String\",\"formId\":\"String\"},\"count\":8},]")
@PostMapping("composeSave") @PostMapping("composeSave")
public ResultData saveOrder(@RequestBody List<OrderComposeSaveDto> orderSaveDto) { public ResultData saveOrder(@RequestBody List<OrderComposeSaveDto> orderSaveDto) {
Long memberId; Long memberId;
@@ -70,20 +70,21 @@ public class WxOrderController extends BaseController {
} catch (Exception e) { } catch (Exception e) {
return new ResultData(Result.ERROR,e.getMessage()); return new ResultData(Result.ERROR,e.getMessage());
} }
return wxOrderService.composeSaveOrder(orderSaveDto,memberId,EnumPayWay.PAY_WAY_WECHAT,getTenantInfo());
return wxOrderService.composeSaveOrder(orderSaveDto,memberId,EnumPayWay.PAY_WAY_WECHAT,getTenantInfo());
} }
// @ApiOperation(value = "单个券单个数量下订单", notes = "{\"couponChannelId\":\"String\",\"couponId\":\"String\",\"press\":\"String\",\"orderGroupId\":\"String\",\"formId\":\"String\"}")
// @PostMapping("save")
// public ResultData saveOrder(@RequestBody OrderSaveDto orderSaveDto) {
// Long memberId;
// try {
// memberId = getMemberId();
// } catch (Exception e) {
// return new ResultData(Result.ERROR,e.getMessage());
// }
// return wxOrderService.saveOrder(orderSaveDto,memberId,EnumPayWay.PAY_WAY_WECHAT,getTenantInfo());
// }
@ApiOperation(value = "单个券单个数量下订单,拼团,砍价用", notes = "{\"couponChannelId\":\"String\",\"couponId\":\"String\",\"press\":\"String\",\"orderGroupId\":\"String\",\"formId\":\"String\"}")
@PostMapping("singleSave")
public ResultData saveOrder(@RequestBody OrderSaveDto orderSaveDto) {
Long memberId;
try {
memberId = getMemberId();
} catch (Exception e) {
return new ResultData(Result.ERROR,e.getMessage());
}
return wxOrderService.singleSaveOrder(orderSaveDto,memberId,EnumPayWay.PAY_WAY_WECHAT,getTenantInfo());
}
@ApiOperation(value = "取消订单", notes = "{\"orderId\":\"string\"}") @ApiOperation(value = "取消订单", notes = "{\"orderId\":\"string\"}")
@PostMapping("cancel") @PostMapping("cancel")


+ 45
- 24
mallinkCApi/src/main/java/com/iformall/controller/WxPayOrderController.java View File

@@ -24,10 +24,12 @@ import com.iformall.common.ResultData;
import com.iformall.domain.po.WxAppinfo; import com.iformall.domain.po.WxAppinfo;
import com.iformall.domain.po.WxCUser; import com.iformall.domain.po.WxCUser;
import com.iformall.domain.po.WxCUserBasicInfo; import com.iformall.domain.po.WxCUserBasicInfo;
import com.iformall.domain.po.WxComposeOrder;
import com.iformall.domain.po.WxCoupon; import com.iformall.domain.po.WxCoupon;
import com.iformall.domain.po.WxOrder; import com.iformall.domain.po.WxOrder;
import com.iformall.domain.po.WxPayAccount; import com.iformall.domain.po.WxPayAccount;
import com.iformall.domain.po.WxPayOrder; import com.iformall.domain.po.WxPayOrder;
import com.iformall.enums.EnumComposeOrder;
import com.iformall.enums.EnumCreditLockedStatus; import com.iformall.enums.EnumCreditLockedStatus;
import com.iformall.enums.EnumOrderStatus; import com.iformall.enums.EnumOrderStatus;
import com.iformall.enums.EnumPayStatus; import com.iformall.enums.EnumPayStatus;
@@ -87,17 +89,18 @@ public class WxPayOrderController extends BaseController {
logger.info("orderId不能为空: " + paramMap.toString()); logger.info("orderId不能为空: " + paramMap.toString());
return new ResultData(ErrorCode.SYS_PARAMETER_NOT_NULL.getCode(), "orderId不能为空"); return new ResultData(ErrorCode.SYS_PARAMETER_NOT_NULL.getCode(), "orderId不能为空");
} }
WxCUser user = getWxCUser(); WxCUser user = getWxCUser();
if (!user.basicInfoIs()) { if (!user.basicInfoIs()) {
logger.error("暂未成为会员,请授权手机号"); logger.error("暂未成为会员,请授权手机号");
return new ResultData(ErrorCode.USER_IS_NOT_MEMBER.getCode(), "暂未成为会员,请授权手机号"); return new ResultData(ErrorCode.USER_IS_NOT_MEMBER.getCode(), "暂未成为会员,请授权手机号");
} }

return _create(orderIdStr,user.getUserId(),EnumPayWay.PAY_WAY_WECHAT,user.getAppId(),new PayExtraParam("openId",user.getOpenId()),request);
String composeOrderTag = paramMap.get("composeOrderTag");
return _create(orderIdStr,composeOrderTag,user.getUserId(),EnumPayWay.PAY_WAY_WECHAT,user.getAppId(),new PayExtraParam("openId",user.getOpenId()),request);
} }
private ResultData _create(String orderIdStr,Long userId, EnumPayWay payWay,String appId,PayExtraParam parm,HttpServletRequest request) {
private ResultData _create(String orderIdStr,String compseOrderTag,Long userId, EnumPayWay payWay,String appId,PayExtraParam parm,HttpServletRequest request) {
WxCUserBasicInfo wxCUserBasicInfo = wxCUserBasicInfoService.getById(userId,getFinalTenantId()); WxCUserBasicInfo wxCUserBasicInfo = wxCUserBasicInfoService.getById(userId,getFinalTenantId());
if ( null == wxCUserBasicInfo) { if ( null == wxCUserBasicInfo) {
logger.error("会员用户不存在."+userId); logger.error("会员用户不存在."+userId);
@@ -120,6 +123,9 @@ public class WxPayOrderController extends BaseController {
record.setOrderId(orderId); record.setOrderId(orderId);
try { try {
record.setIp(IPUtil.getIpAddr(request)); record.setIp(IPUtil.getIpAddr(request));
if ((!StringUtils.isBlank(compseOrderTag)) && "1".equals(compseOrderTag)) {
record.setComposeOrder(EnumComposeOrder.YES.getCode());
}
return wxPayOrderService.createPayOrder(appInfo, wxCUserBasicInfo, record, payWay,parm); return wxPayOrderService.createPayOrder(appInfo, wxCUserBasicInfo, record, payWay,parm);
} catch (MallinkException e) { } catch (MallinkException e) {
logger.error("payment wechat, order create error, req 2: " + record.toString() + ", e:" + e.getMessage()); logger.error("payment wechat, order create error, req 2: " + record.toString() + ", e:" + e.getMessage());
@@ -185,28 +191,17 @@ public class WxPayOrderController extends BaseController {
if (null == payOrder) { if (null == payOrder) {
return new ResultData(ErrorCode.PAY_ORDER_ERROR, "未查询到payOrder."); return new ResultData(ErrorCode.PAY_ORDER_ERROR, "未查询到payOrder.");
} }
WxOrder order = wxOrderService.getById(orderId,payOrder.getTenantId());
if (null == order) {
return new ResultData(ErrorCode.PAY_ORDER_ERROR, "未查询到Order["+orderId+"].");
}
WxCoupon wxCoupon = wxCouponService.getById(order.getProductId(),order.getTenantId());
if (null == wxCoupon) {
return new ResultData(ErrorCode.PAY_ORDER_ERROR, "未查询到优惠券[orderId:"+orderId+"].");
}
//拼团的订单,如果查询到是拼团待付款的,则重新查询是否已经真的支付,其他的直接返回订单信息
if (wxPayOrderService.isOrderGroupCoupon(payOrder, wxCoupon)) {
if (!order.getOrderStatus().equals(EnumOrderStatus.ORDER_STATUS_COOPERATING_UNPAID.getCode())) {
return new ResultData(Result.SUCCESS, "支付状态更新成功", order);
}
WxComposeOrder composeOrder = null;
WxOrder order = null;
if ((null != payOrder.getComposeOrder()) && (EnumComposeOrder.YES.getCode().intValue() == payOrder.getComposeOrder().intValue())) {
composeOrder = wxOrderService.getComposeOrder(orderId, payOrder);
}else { }else {
//非拼团的订单,支付成功,关闭订单,撤销支付订单,支付转退款的,直接返回订单信息,其他需要查询真实支付状态
if (payOrder.getPayOrderStatus().equals(EnumPayStatus.PAY_STATUS_SUCCESS.getCode())||
payOrder.getPayOrderStatus().equals(EnumPayStatus.PAY_STATUS_CLOSE.getCode())||
payOrder.getPayOrderStatus().equals(EnumPayStatus.PAY_STATUS_REVERSE.getCode())||
payOrder.getPayOrderStatus().equals(EnumPayStatus.PAY_STATUS_REFUND.getCode())) {
return new ResultData(Result.SUCCESS, "支付状态更新成功", order);
order = wxOrderService.getById(orderId,payOrder.getTenantId());
if (check(orderId, order, payOrder)) {
return new ResultData(Result.SUCCESS, "支付状态更新成功", order);
} }
} }
//查询微信订单状态并更新 //查询微信订单状态并更新
@@ -218,7 +213,7 @@ public class WxPayOrderController extends BaseController {
} }
WxPayAccount payAccount = wxPayAccountService.getById(appInfo.getPayId()); WxPayAccount payAccount = wxPayAccountService.getById(appInfo.getPayId());
try { try {
WxPayOrder wo = wxPayOrderService.handleWxOrderQuery(payOrder, order, appInfo, payAccount, IdWorker.get(),false);
WxPayOrder wo = wxPayOrderService.handleWxOrderQuery(payOrder, composeOrder,order, appInfo, payAccount, IdWorker.get(),false);
if (null != wo) { if (null != wo) {
return new ResultData(Result.SUCCESS, "支付状态更新成功", order); return new ResultData(Result.SUCCESS, "支付状态更新成功", order);
} }
@@ -241,6 +236,32 @@ public class WxPayOrderController extends BaseController {
return new ResultData(ErrorCode.PAY_ORDER_ERROR, "支付状态更新失败3: " + payOrder.toString() + ", e:" + e.getMessage()); return new ResultData(ErrorCode.PAY_ORDER_ERROR, "支付状态更新失败3: " + payOrder.toString() + ", e:" + e.getMessage());
} }
} }
private boolean check(Long orderId,WxOrder order,WxPayOrder payOrder) {
if (null == order) {
throw new MallinkException(ErrorCode.PAY_ORDER_ERROR.getCode(), "未查询到Order["+orderId+"].");
}
WxCoupon wxCoupon = wxCouponService.getById(order.getProductId(),order.getTenantId());
if (null == wxCoupon) {
throw new MallinkException(ErrorCode.PAY_ORDER_ERROR.getCode(), "未查询到优惠券[orderId:"+orderId+"].");
}
//拼团的订单,如果查询到是拼团待付款的,则重新查询是否已经真的支付,其他的直接返回订单信息
if (wxPayOrderService.isOrderGroupCoupon(payOrder, wxCoupon)) {
if (!order.getOrderStatus().equals(EnumOrderStatus.ORDER_STATUS_COOPERATING_UNPAID.getCode())) {
return true;
}
}else {
//非拼团的订单,支付成功,关闭订单,撤销支付订单,支付转退款的,直接返回订单信息,其他需要查询真实支付状态
if (payOrder.getPayOrderStatus().equals(EnumPayStatus.PAY_STATUS_SUCCESS.getCode())||
payOrder.getPayOrderStatus().equals(EnumPayStatus.PAY_STATUS_CLOSE.getCode())||
payOrder.getPayOrderStatus().equals(EnumPayStatus.PAY_STATUS_REVERSE.getCode())||
payOrder.getPayOrderStatus().equals(EnumPayStatus.PAY_STATUS_REFUND.getCode())) {
return true;
}
}
return false;
}


@ApiOperation("分页列表接口") @ApiOperation("分页列表接口")
@GetMapping("/list") @GetMapping("/list")


+ 2
- 2
mallinkSchedule/src/main/java/com/iformall/schedule/OrderExpiringSchedule.java View File

@@ -288,11 +288,11 @@ public class OrderExpiringSchedule {
} }
//Map<String, String> retMap = WxPayOrderServiceHelper.wxOrderPayStatusMap(wxpayOrder, order, appInfo, payAccount); //Map<String, String> retMap = WxPayOrderServiceHelper.wxOrderPayStatusMap(wxpayOrder, order, appInfo, payAccount);
//int status = WxPayOrderServiceHelper.getPayStatusFromMap(retMap, wxpayOrder.getPayOrderNo()); //int status = WxPayOrderServiceHelper.getPayStatusFromMap(retMap, wxpayOrder.getPayOrderNo());
PayQueryAdapterResult payResult = payServiceFactory.getPayAdapterService(wxpayOrder.getPayVendor()).queryPayStatus(wxpayOrder, order, appInfo, payAccount);
PayQueryAdapterResult payResult = payServiceFactory.getPayAdapterService(wxpayOrder.getPayVendor()).queryPayStatus(wxpayOrder, appInfo, payAccount);
//如果是支付成功,并且需要重试成功流程, //如果是支付成功,并且需要重试成功流程,
if (EnumPayStatus.PAY_STATUS_SUCCESS.getCode().intValue() == payResult.getCode()) { if (EnumPayStatus.PAY_STATUS_SUCCESS.getCode().intValue() == payResult.getCode()) {
if (autoReHandle) { if (autoReHandle) {
wxPayOrderService.handleSuccessOrder(wxpayOrder, order, payResult,true);
wxPayOrderService.handleSuccessOrder(wxpayOrder, null, order, payResult, true,true);
} }
return true; return true;
} }


+ 4
- 10
mallinkService/src/main/java/com/iformall/domain/po/WxComposeOrder.java View File

@@ -24,20 +24,14 @@ public class WxComposeOrder extends TenantEntity {


@io.swagger.annotations.ApiModelProperty(value="c端用户id",name="cUserId") @io.swagger.annotations.ApiModelProperty(value="c端用户id",name="cUserId")
private Long cUserId; private Long cUserId;
@io.swagger.annotations.ApiModelProperty(value="0: 付款 1: 退款",name="paymentType")
private Integer paymentType;
@io.swagger.annotations.ApiModelProperty(value="支付金额(分):允许有负数,退款时为负值。",name="payment") @io.swagger.annotations.ApiModelProperty(value="支付金额(分):允许有负数,退款时为负值。",name="payment")
private Integer payment; private Integer payment;
@io.swagger.annotations.ApiModelProperty(value="支付时间",name="paymentTime")
private Date paymentTime;
@io.swagger.annotations.ApiModelProperty(value="订单状态:-1全部;正向交易:0-已下单/待付款;1-已支付;2-已取消(限定时间内未付款)反向交易:3-已退款; 4-退款失败,5-退款失败; 砍价:6-砍价中,7-砍价完成,8-砍价失败",name="orderStatus")
private Integer orderStatus;
@TableField(exist = false)
protected List<Integer> statusS;
@io.swagger.annotations.ApiModelProperty(value="创建时间/砍价开始时间",name="createDate") @io.swagger.annotations.ApiModelProperty(value="创建时间/砍价开始时间",name="createDate")
private Date createDate; private Date createDate;
@io.swagger.annotations.ApiModelProperty(value="更新时间",name="updateDate") @io.swagger.annotations.ApiModelProperty(value="更新时间",name="updateDate")
private Date updateDate; private Date updateDate;
//返回给前端,跟之前的wxorder直接下单做区分
@TableField(exist = false)
private String composeOrderTag = "1";
} }

+ 3
- 0
mallinkService/src/main/java/com/iformall/domain/po/WxPayOrder.java View File

@@ -57,6 +57,9 @@ public class WxPayOrder extends TenantEntity {
@io.swagger.annotations.ApiModelProperty(value="支付后结果来源(0:callback, 1:query)",name="payEndFrom") @io.swagger.annotations.ApiModelProperty(value="支付后结果来源(0:callback, 1:query)",name="payEndFrom")
private Integer payEndFrom; private Integer payEndFrom;


@io.swagger.annotations.ApiModelProperty(value="是否为组合订单,1-是 0-不是",name="composeOrder")
private Integer composeOrder;
@io.swagger.annotations.ApiModelProperty(value="支付后结果来源(0:inside, 1:POS支付)",name="payFrom") @io.swagger.annotations.ApiModelProperty(value="支付后结果来源(0:inside, 1:POS支付)",name="payFrom")
private Integer payFrom; private Integer payFrom;
@io.swagger.annotations.ApiModelProperty(value="支付订单号,来源于POS, inside时,填写couponOrderId",name="posPayOrderId") @io.swagger.annotations.ApiModelProperty(value="支付订单号,来源于POS, inside时,填写couponOrderId",name="posPayOrderId")


+ 36
- 0
mallinkService/src/main/java/com/iformall/enums/EnumComposeOrder.java View File

@@ -0,0 +1,36 @@
package com.iformall.enums;


/**
* @author gongbiao
*/
public enum EnumComposeOrder {

YES(1, "是多券种组合订单"),
NO(0, "非多券种组合订单,如拼团,砍价");

public static EnumComposeOrder getEnum(Integer code) {
for (EnumComposeOrder value : values()) {
if (value.getCode().equals(code)) {
return value;
}
}
return null;
}

private Integer code;
private String message;

EnumComposeOrder(Integer code, String message) {
this.code = code;
this.message = message;
}

public Integer getCode() {
return code;
}

public String getMessage() {
return message;
}
}

+ 8
- 1
mallinkService/src/main/java/com/iformall/mapper/WxComposeOrderMapper.java View File

@@ -2,12 +2,19 @@ package com.iformall.mapper;


import com.iformall.common.CommonMapper; import com.iformall.common.CommonMapper;
import com.iformall.domain.po.WxComposeOrder; import com.iformall.domain.po.WxComposeOrder;

import java.util.List;

import org.apache.ibatis.annotations.Param; import org.apache.ibatis.annotations.Param;


public interface WxComposeOrderMapper extends CommonMapper<WxComposeOrder, Long> { public interface WxComposeOrderMapper extends CommonMapper<WxComposeOrder, Long> {


List<WxComposeOrder> findList(WxComposeOrder order);
Integer countList(WxComposeOrder order);
WxComposeOrder selectById(@Param("id")Long id,@Param("tenantId")String tenantId); WxComposeOrder selectById(@Param("id")Long id,@Param("tenantId")String tenantId);
void updateStatusByOrderGroupId(WxComposeOrder order);
void updateCUserId(WxComposeOrder order);


} }

+ 2
- 0
mallinkService/src/main/java/com/iformall/mapper/WxOrderMapper.java View File

@@ -64,5 +64,7 @@ public interface WxOrderMapper extends CommonMapper<WxOrder, Long> {
void updateOrderGroupStatusByCouponChannelId(WxOrder updateOrder); void updateOrderGroupStatusByCouponChannelId(WxOrder updateOrder);


void updateOrderStatusForGroup(@Param("tenantId")String tenantId); void updateOrderStatusForGroup(@Param("tenantId")String tenantId);
void updateCUserId(WxOrder updateOrder);


} }

+ 4
- 0
mallinkService/src/main/java/com/iformall/service/WxOrderService.java View File

@@ -244,5 +244,9 @@ public interface WxOrderService {
//ResultData saveOrder(OrderSaveDto orderSaveDto,Long cUserId,EnumPayWay payWay,TenantEntity tenantEntity); //ResultData saveOrder(OrderSaveDto orderSaveDto,Long cUserId,EnumPayWay payWay,TenantEntity tenantEntity);
ResultData composeSaveOrder(List<OrderComposeSaveDto> composeOrderSaveDto,Long cUserId,EnumPayWay payWay,TenantEntity tenantEntity); ResultData composeSaveOrder(List<OrderComposeSaveDto> composeOrderSaveDto,Long cUserId,EnumPayWay payWay,TenantEntity tenantEntity);
ResultData singleSaveOrder(OrderSaveDto orderSaveDto,Long cUserId,EnumPayWay payWay,TenantEntity tenantEntity);
WxComposeOrder getComposeOrder(Long orderId,TenantEntity tenantEntity);


} }

+ 3
- 2
mallinkService/src/main/java/com/iformall/service/WxPayOrderService.java View File

@@ -7,6 +7,7 @@ import com.iformall.common.IdWorker;
import com.iformall.common.ResultData; import com.iformall.common.ResultData;
import com.iformall.domain.po.WxAppinfo; import com.iformall.domain.po.WxAppinfo;
import com.iformall.domain.po.WxCUserBasicInfo; import com.iformall.domain.po.WxCUserBasicInfo;
import com.iformall.domain.po.WxComposeOrder;
import com.iformall.domain.po.WxCoupon; import com.iformall.domain.po.WxCoupon;
import com.iformall.domain.po.WxMerchantBUser; import com.iformall.domain.po.WxMerchantBUser;
import com.iformall.domain.po.WxOrder; import com.iformall.domain.po.WxOrder;
@@ -20,9 +21,9 @@ import com.iformall.service.pay.service.pay.entity.PayQueryAdapterResult;


public interface WxPayOrderService { public interface WxPayOrderService {


public void handleSuccessOrder(WxPayOrder oldRecord,WxOrder order,PayQueryAdapterResult queryResult,boolean isScheduleTask);
public void handleSuccessOrder(WxPayOrder oldRecord,WxComposeOrder composeOrder,WxOrder order,PayQueryAdapterResult queryResult,boolean isScheduleTask,boolean composeSingleOrder);
public WxPayOrder handleWxOrderQuery(WxPayOrder oldRecord,WxOrder order,WxAppinfo appInfo,WxPayAccount payAccount,IdWorker idworker,boolean repeatPay);
public WxPayOrder handleWxOrderQuery(WxPayOrder oldRecord,WxComposeOrder composeOrder,WxOrder order,WxAppinfo appInfo,WxPayAccount payAccount,IdWorker idworker,boolean repeatPay);
/** /**
* 创建支付订单 * 创建支付订单


+ 4
- 7
mallinkService/src/main/java/com/iformall/service/helper/WxPayOrderServiceHelper.java View File

@@ -11,6 +11,7 @@ import com.iformall.common.ErrorCode;
import com.iformall.common.Result; import com.iformall.common.Result;
import com.iformall.common.ResultData; import com.iformall.common.ResultData;
import com.iformall.domain.po.WxAppinfo; import com.iformall.domain.po.WxAppinfo;
import com.iformall.domain.po.WxComposeOrder;
import com.iformall.domain.po.WxMerchantBUser; import com.iformall.domain.po.WxMerchantBUser;
import com.iformall.domain.po.WxOrder; import com.iformall.domain.po.WxOrder;
import com.iformall.domain.po.WxPayAccount; import com.iformall.domain.po.WxPayAccount;
@@ -33,17 +34,13 @@ public class WxPayOrderServiceHelper {
/** /**
* 微信订单是否可以支付 * 微信订单是否可以支付
*/ */
public static Map<String, String> wxOrderPayStatusMap(WxPayOrder record,WxOrder order,WxAppinfo appInfo,WxPayAccount payAccount) {
public static Map<String, String> wxOrderPayStatusMap(WxPayOrder record,WxAppinfo appInfo,WxPayAccount payAccount) {
if (record == null) { if (record == null) {
throw new MallinkException(ErrorCode.PAY_ORDER_ERROR.getCode(), "wxPayOrder is null."); throw new MallinkException(ErrorCode.PAY_ORDER_ERROR.getCode(), "wxPayOrder is null.");
} }
if (StringUtils.isBlank(record.getPayOrderNo())) { if (StringUtils.isBlank(record.getPayOrderNo())) {
throw new MallinkException(ErrorCode.PAY_ORDER_ERROR.getCode(), "payOrderNo not found"); throw new MallinkException(ErrorCode.PAY_ORDER_ERROR.getCode(), "payOrderNo not found");
} }
if (order == null) {
throw new MallinkException(ErrorCode.PAY_ORDER_ERROR.getCode(), "Order not found");
}

String response = wechatPayOrderQuery(appInfo, record,payAccount); String response = wechatPayOrderQuery(appInfo, record,payAccount);


logger.info("pay order query, " + record.toString() + ", response: " + response); logger.info("pay order query, " + record.toString() + ", response: " + response);
@@ -128,8 +125,8 @@ public class WxPayOrderServiceHelper {
} }
} }
public static int wxOrderPayStatus(WxPayOrder record,WxOrder order,WxAppinfo appInfo,WxPayAccount payAccount) {
Map<String, String> returnMap = wxOrderPayStatusMap(record,order,appInfo,payAccount);
public static int wxOrderPayStatus(WxPayOrder record,WxAppinfo appInfo,WxPayAccount payAccount) {
Map<String, String> returnMap = wxOrderPayStatusMap(record,appInfo,payAccount);
return getPayStatusFromMap(returnMap,record.getPayOrderNo()); return getPayStatusFromMap(returnMap,record.getPayOrderNo());
} }


+ 100
- 18
mallinkService/src/main/java/com/iformall/service/impl/WxOrderServiceImpl.java View File

@@ -785,12 +785,12 @@ public class WxOrderServiceImpl implements WxOrderService {
} }


try { try {
int num = wxCouponMapper.backInventory(coupon.getId(),coupon.getTenantId(), 1, coupon.getRemainInventory());
int num = wxCouponMapper.backInventory(coupon.getId(),coupon.getTenantId(), updateOrder.getCouponNumber(), coupon.getRemainInventory());
if (num <= 0) { if (num <= 0) {
logger.error("此券加库存失败, couponId: " + couponIdStr); logger.error("此券加库存失败, couponId: " + couponIdStr);
throw new MallinkException(ErrorCode.ORDER_IS_FAIL.getCode(),"券couponId:["+couponIdStr+"]库存回滚失败,更新记录条数小于等于0."); throw new MallinkException(ErrorCode.ORDER_IS_FAIL.getCode(),"券couponId:["+couponIdStr+"]库存回滚失败,更新记录条数小于等于0.");
} }
redisLock.increase(EnumCacheKey.COUPON_STOCK.getMessage()+coupon.getId(), 1);
redisLock.increase(EnumCacheKey.COUPON_STOCK.getMessage()+coupon.getId(), updateOrder.getCouponNumber());
} catch (Exception e) { } catch (Exception e) {
logger.error("数据库更新失败,库存+1失败, e:" + e.getMessage()); logger.error("数据库更新失败,库存+1失败, e:" + e.getMessage());
throw new MallinkException(ErrorCode.DB_FAIL.getCode(), "库存恢复失败"); throw new MallinkException(ErrorCode.DB_FAIL.getCode(), "库存恢复失败");
@@ -1970,11 +1970,9 @@ public class WxOrderServiceImpl implements WxOrderService {
@Transactional(propagation = Propagation.REQUIRED, readOnly = false, rollbackFor = {Exception.class}) @Transactional(propagation = Propagation.REQUIRED, readOnly = false, rollbackFor = {Exception.class})
@Override @Override
public WxComposeOrder saveOrderForCoupon(WxCUserBasicInfo user,List<OrderComposeSaveDto> orderSave,EnumPayWay payWay) { public WxComposeOrder saveOrderForCoupon(WxCUserBasicInfo user,List<OrderComposeSaveDto> orderSave,EnumPayWay payWay) {
WxOrderServiceImpl proxy = (WxOrderServiceImpl) AopContext.currentProxy(); WxOrderServiceImpl proxy = (WxOrderServiceImpl) AopContext.currentProxy();
// 防止同一用户重复下单,1秒内 // 防止同一用户重复下单,1秒内
String key = new StringBuilder().append("saveorder:").append(user.getId()).toString();
String key = new StringBuilder().append("saveComposeOrder:").append(user.getId()).toString();
boolean hasKey = cUserBasicInfoRedisTemplate.hasKey(key); boolean hasKey = cUserBasicInfoRedisTemplate.hasKey(key);
if (hasKey) { if (hasKey) {
logger.error("用户正在下单,请求异常返回,user: {} " + JSON.toJSONString(user)); logger.error("用户正在下单,请求异常返回,user: {} " + JSON.toJSONString(user));
@@ -2021,24 +2019,63 @@ public class WxOrderServiceImpl implements WxOrderService {
return composeOrder; return composeOrder;
} }
@Transactional(propagation = Propagation.REQUIRED, readOnly = false, rollbackFor = {Exception.class})
public WxOrder saveSingleOrderForCoupon(WxCUserBasicInfo user,OrderSaveDto orderSaveDto,WxCoupon coupon,EnumPayWay payWay,int couponNumber) {
WxOrderServiceImpl proxy = (WxOrderServiceImpl) AopContext.currentProxy();
// 防止同一用户重复下单,1秒内
String key = new StringBuilder().append("saveSingleOrder:").append(user.getId()).toString();
boolean hasKey = cUserBasicInfoRedisTemplate.hasKey(key);
if (hasKey) {
logger.error("用户正在下单,请求异常返回,user: {} " + JSON.toJSONString(user));
throw new MallinkException(ErrorCode.SYS_REPEAT_SUBMIT_EXCEPTION);
}
cUserBasicInfoRedisTemplate.opsForValue().set(key, user, 1000, TimeUnit.MILLISECONDS);
// 是否砍价
boolean isPress = orderSaveDto.getPress() != null ? orderSaveDto.getPress() : false;
WxOrder order = null;
if (checkCouponIsFree(coupon)) {
// 免费券
order = proxy.saveFreeOrderForCoupon(null,user, coupon,couponNumber, orderSaveDto.getCouponChannelId(), orderSaveDto.getFormId(), null,payWay);
if (order != null) {
// 6. 下订单完成,发送内部消息
// 下订单完成,发送内部消息
try {
proxy.sendOrderSuccessActionMsg(order);
} catch (Exception e) {
logger.error("内部消息发送失败: " + e.getMessage(),e);
throw new MallinkException(ErrorCode.MSG_INSIDE_ERROR);
}
}
} else {
// 有价券
order = proxy.saveNoFreeOrderForCoupon(null,user, coupon,couponNumber, orderSaveDto.getCouponChannelId(), isPress, orderSaveDto.getOrderGroupId(), orderSaveDto.getFormId());
}
// couponActionLog
// try {
// wxCouponActionLogService.addOne(order, order.getProductId(), order.getOrderNumber(), EnumCouponSendSendType.ACTIVE.getCode(), orderdto.getSignleOrder().getCouponChannelId(),0L);
// } catch (Exception e) {
// // 库存恢复
// stockBack(order);
// logger.error("保存订单:" + e.getMessage());
// throw new MallinkException(ErrorCode.ORDER_SAVE_ERR);
// }
return order;
}
@Transactional(propagation = Propagation.REQUIRED, readOnly = false, rollbackFor = {Exception.class}) @Transactional(propagation = Propagation.REQUIRED, readOnly = false, rollbackFor = {Exception.class})
public WxComposeOrder createWxComposeOrder(WxCUserBasicInfo user,List<OrderComposeSaveDto> orderSave,EnumPayWay payWay) { public WxComposeOrder createWxComposeOrder(WxCUserBasicInfo user,List<OrderComposeSaveDto> orderSave,EnumPayWay payWay) {
WxComposeOrder order =new WxComposeOrder(); WxComposeOrder order =new WxComposeOrder();
final IdWorker idWorker = IdWorker.get(); final IdWorker idWorker = IdWorker.get();
order.setId(idWorker.nextId()); order.setId(idWorker.nextId());
order.setCUserId(user.getId()); order.setCUserId(user.getId());
order.setPaymentType(EnumPayType.PAY_PAYMENT.getCode());
int payment = 0; int payment = 0;
for (OrderComposeSaveDto ocsd : orderSave) { for (OrderComposeSaveDto ocsd : orderSave) {
boolean isPress = ocsd.getSignleOrder().getPress() != null ? ocsd.getSignleOrder().getPress() : false; boolean isPress = ocsd.getSignleOrder().getPress() != null ? ocsd.getSignleOrder().getPress() : false;
payment = payment+getCouponPayment(ocsd.getWxCoupon(), isPress, ocsd.getSignleOrder().getOrderGroupId(),ocsd.getCount()); payment = payment+getCouponPayment(ocsd.getWxCoupon(), isPress, ocsd.getSignleOrder().getOrderGroupId(),ocsd.getCount());
} }
order.setPayment(payment); order.setPayment(payment);
if (payment > 0 ) {
order.setOrderStatus(EnumOrderStatus.ORDER_STATUS_PENDING_PAYMENT.getCode());
}else {
order.setOrderStatus(EnumOrderStatus.ORDER_STATUS_PAYMENT_SUCCESS.getCode());
}
order.setCreateDate(new Date()); order.setCreateDate(new Date());
wxComposeOrderMapper.insert(order); wxComposeOrderMapper.insert(order);
return order; return order;
@@ -2097,6 +2134,7 @@ public class WxOrderServiceImpl implements WxOrderService {
if (null != composeOrder) { if (null != composeOrder) {
record.setComposeOrderId(composeOrder.getId()); record.setComposeOrderId(composeOrder.getId());
} }
record.setCouponNumber(couponNumber);
try { try {
proxy.saveFreeOrder(record, user, coupon); proxy.saveFreeOrder(record, user, coupon);
} catch (Exception e) { } catch (Exception e) {
@@ -2160,6 +2198,7 @@ public class WxOrderServiceImpl implements WxOrderService {
if (null != composeOrder) { if (null != composeOrder) {
record.setComposeOrderId(composeOrder.getId()); record.setComposeOrderId(composeOrder.getId());
} }
record.setCouponNumber(couponNumber);
try { try {
orderNumber = proxy.saveNoFreeOrder(record, user, coupon, isPress); orderNumber = proxy.saveNoFreeOrder(record, user, coupon, isPress);
} catch (Exception e) { } catch (Exception e) {
@@ -2471,9 +2510,44 @@ public class WxOrderServiceImpl implements WxOrderService {
OrderComposeSaveDto ocsd = composeOrderSaveDto.get(i); OrderComposeSaveDto ocsd = composeOrderSaveDto.get(i);
singleOrderCheck(ocsd,ocsd.getSignleOrder(),ocsd.getCount(),wxCUserBasicInfo,payWay,tenantEntity,i+1,singleProduct); singleOrderCheck(ocsd,ocsd.getSignleOrder(),ocsd.getCount(),wxCUserBasicInfo,payWay,tenantEntity,i+1,singleProduct);
} }

WxOrderServiceImpl proxy = (WxOrderServiceImpl) AopContext.currentProxy();
try {
WxComposeOrder order = proxy.saveOrderForCoupon(wxCUserBasicInfo, composeOrderSaveDto, payWay);
return new ResultData(order);
} catch (MallinkException e) {
logger.error("saveOrderForCoupon error.",e);
throw new MallinkException(e.getErrorCode(), e.getMessage());
} catch (Exception e) {
logger.error("saveOrderForCoupon error.",e);
throw new MallinkException(ErrorCode.ORDER_IS_FAIL.getCode(), e.getMessage());
}
}catch(MallinkException me) {
return new ResultData(me.getErrorCode(),me.getMessage());
}catch(Exception e) {
logger.error("composeSaveOrder error.",e);
return new ResultData(ErrorCode.SYS_SERVER_ERROR.getCode(),e.getMessage());
}
}
@Override
public ResultData singleSaveOrder(OrderSaveDto orderSaveDto,Long cUserId,EnumPayWay payWay,TenantEntity tenantEntity) {
logger.info("singleOrderSave: " + orderSaveDto);
try {
WxCUserBasicInfo wxCUserBasicInfo = wxCUserBasicInfoService.getById(cUserId,tenantEntity.getFinalTenantId());
if (wxCUserBasicInfo != null && wxCUserBasicInfo.getStatus().equals(EnumCUserBasicInfoStatus.LOCKED.getCode())) {
logger.info("会员权益被锁定:cUserId:" + cUserId);
return new ResultData(ErrorCode.MEMBER_IS_LOCKED);
}
int couponNumber = 1;
boolean singleNumber = true;
WxCoupon coupon = singleOrderCheck(null,orderSaveDto,couponNumber,wxCUserBasicInfo,payWay,tenantEntity,1,singleNumber);
WxOrderServiceImpl proxy = (WxOrderServiceImpl) AopContext.currentProxy();
try { try {
WxComposeOrder order = this.saveOrderForCoupon(wxCUserBasicInfo, composeOrderSaveDto, payWay);
WxOrder order = proxy.saveSingleOrderForCoupon(wxCUserBasicInfo, orderSaveDto,coupon, payWay,couponNumber);
return new ResultData(order); return new ResultData(order);
} catch (MallinkException e) { } catch (MallinkException e) {
logger.error("saveOrderForCoupon error.",e); logger.error("saveOrderForCoupon error.",e);
@@ -2494,7 +2568,7 @@ public class WxOrderServiceImpl implements WxOrderService {
} }
private void singleOrderCheck(OrderComposeSaveDto ocsd,OrderSaveDto orderSaveDto,int productCount,WxCUserBasicInfo wxCUserBasicInfo,EnumPayWay payWay,TenantEntity tenantEntity,int curindex,boolean singleProduct) {
private WxCoupon singleOrderCheck(OrderComposeSaveDto ocsd,OrderSaveDto orderSaveDto,int productCount,WxCUserBasicInfo wxCUserBasicInfo,EnumPayWay payWay,TenantEntity tenantEntity,int curindex,boolean singleProduct) {
logger.info("OrderSave: " + orderSaveDto); logger.info("OrderSave: " + orderSaveDto);
String premsg = ""; String premsg = "";
if (singleProduct) { if (singleProduct) {
@@ -2519,7 +2593,10 @@ public class WxOrderServiceImpl implements WxOrderService {
if (coupon.getStatus().equals(EnumCouponStatus.COUPON_STATUS_TAKE_OFFF.getCode())) { if (coupon.getStatus().equals(EnumCouponStatus.COUPON_STATUS_TAKE_OFFF.getCode())) {
throw new MallinkException(ErrorCode.COUPON_IS_TAKE_OFF.getCode(),premsg+"【"+coupon.getTitle()+"】已作废"); throw new MallinkException(ErrorCode.COUPON_IS_TAKE_OFF.getCode(),premsg+"【"+coupon.getTitle()+"】已作废");
} }
ocsd.setWxCoupon(coupon);
if (null != ocsd) {
ocsd.setWxCoupon(coupon);
}
//判断是否是拼团订单,如果是拼团订单,判断现在进行中的,和已完成的数量是否超出券的限制 //判断是否是拼团订单,如果是拼团订单,判断现在进行中的,和已完成的数量是否超出券的限制
if (coupon.getType().equals(EnumCouponType.COUPON_GROUP.getCode())) { if (coupon.getType().equals(EnumCouponType.COUPON_GROUP.getCode())) {
@@ -2590,11 +2667,11 @@ public class WxOrderServiceImpl implements WxOrderService {
if (!checkCouponIsFree(coupon)) { if (!checkCouponIsFree(coupon)) {
// 有价,拼团检查 // 有价,拼团检查
if (isOrderGroup(ocsd.getSignleOrder().getOrderGroupId())) {
checkOrderGroup(wxCUserBasicInfo, ocsd.getSignleOrder().getOrderGroupId(),coupon,premsg);
if (isOrderGroup(orderSaveDto.getOrderGroupId())) {
checkOrderGroup(wxCUserBasicInfo, orderSaveDto.getOrderGroupId(),coupon,premsg);
} }
} }
return coupon;
} }


private void couponChannelCheck(OrderSaveDto orderSaveDto, WxCouponChannel wxCouponChannel,String premsg) { private void couponChannelCheck(OrderSaveDto orderSaveDto, WxCouponChannel wxCouponChannel,String premsg) {
@@ -2648,4 +2725,9 @@ public class WxOrderServiceImpl implements WxOrderService {
} }
} }


@Override
public WxComposeOrder getComposeOrder(Long orderId, TenantEntity tenantEntity) {
return wxComposeOrderMapper.selectById(orderId, tenantEntity.getTenantId());
}

} }

+ 273
- 164
mallinkService/src/main/java/com/iformall/service/impl/WxPayOrderServiceImpl.java View File

@@ -103,6 +103,9 @@ public class WxPayOrderServiceImpl implements WxPayOrderService {
@Autowired @Autowired
WxCashOutService cashOutService; WxCashOutService cashOutService;
@Autowired
WxComposeOrderMapper wxComposeOrderMapper;


JSONObject errorMapQuery = JSON.parseObject("{" + JSONObject errorMapQuery = JSON.parseObject("{" +
"\"ORDERNOTEXIST\":{\"detail\":\"此交易订单号不存在\",\"reason\":\"查询系统中不存在此交易订单号\",\"resolution\":\"该API只能查提交支付交易返回成功的订单,请商户检查需要查询的订单号是否正确\"},\n" + "\"ORDERNOTEXIST\":{\"detail\":\"此交易订单号不存在\",\"reason\":\"查询系统中不存在此交易订单号\",\"resolution\":\"该API只能查提交支付交易返回成功的订单,请商户检查需要查询的订单号是否正确\"},\n" +
@@ -111,9 +114,10 @@ public class WxPayOrderServiceImpl implements WxPayOrderService {
//方法必须为public AopContext.currentProxy() //方法必须为public AopContext.currentProxy()
@Transactional(propagation = Propagation.REQUIRED, readOnly = false, rollbackFor = {Exception.class}) @Transactional(propagation = Propagation.REQUIRED, readOnly = false, rollbackFor = {Exception.class})
@Override @Override
public void handleSuccessOrder(WxPayOrder oldRecord,WxOrder order,PayQueryAdapterResult queryResult,boolean isScheduleTask) {
public void handleSuccessOrder(WxPayOrder oldRecord,WxComposeOrder composeOrder,WxOrder order,PayQueryAdapterResult queryResult,boolean isScheduleTask,boolean composeSingleOrder) {
Date curDate = new Date(); Date curDate = new Date();
if (oldRecord.getPayOrderStatus() != EnumPayStatus.PAY_STATUS_SUCCESS.getCode()) { if (oldRecord.getPayOrderStatus() != EnumPayStatus.PAY_STATUS_SUCCESS.getCode()) {
WxPayOrderServiceImpl proxy = (WxPayOrderServiceImpl) AopContext.currentProxy();
//因为此处是处理订单支付成功了但是订单状态为未支付成功的异常状态,库存不应该再扣减 //因为此处是处理订单支付成功了但是订单状态为未支付成功的异常状态,库存不应该再扣减
//更新wxPayOrder //更新wxPayOrder
oldRecord.setPayOrderStatus(EnumPayStatus.PAY_STATUS_SUCCESS.getCode()); oldRecord.setPayOrderStatus(EnumPayStatus.PAY_STATUS_SUCCESS.getCode());
@@ -132,49 +136,60 @@ public class WxPayOrderServiceImpl implements WxPayOrderService {
oldRecord.setUpdateTime(curDate); oldRecord.setUpdateTime(curDate);
wxPayOrderMapper.updateById(oldRecord); wxPayOrderMapper.updateById(oldRecord);
//处理其他信息
WxCoupon wxCoupon = wxCouponMapper.selectById(order.getProductId(),order.getTenantId());
if(wxCoupon != null) {
if (isOrderGroupCoupon(oldRecord, wxCoupon)) {
// 如果是Coupon是拼团, 创建拼团信息, 不创建COUPON_ORDER
try {
wxOrderGroupService.createOrderGroup(order, wxCoupon,isScheduleTask);
} catch (Exception e) {
logger.error("参团失败" + e.getMessage(),e);
order.setOrderStatus(EnumOrderStatus.ORDER_STATUS_COOPERATING_FAILD.getCode());
order.setUpdateDate(new Date());
wxOrderMapper.updateById(order);
throw new MallinkException(ErrorCode.ORDER_GROUP_COOPERATING_FAILD);
}
} else {
// 普通券, 修改订单状态
try {
wxOrderService.couponOrderSuccess(order);
} catch (Exception e) {
logger.error(e.getMessage(),e);
throw new MallinkException(ErrorCode.DB_FAIL.getCode(), "订单更新");
}
// 下订单完成,发送内部消息
try {
wxOrderService.sendOrderSuccessActionMsg(order);
} catch (Exception e) {
logger.error("内部消息发送失败: " + e.getMessage(),e);
throw new MallinkException(ErrorCode.MSG_INSIDE_ERROR);
}
}
}

if (isComposeOrder(oldRecord)) {
//如果是组合订单的单独处理。如定时处理的单个订单
if (composeSingleOrder) {
//处理其他信息
try {
proxy.handleOrderPaySingleOrderSuccess(oldRecord, order, transactionId,isScheduleTask);
}catch(Exception e) {
throw new MallinkException(ErrorCode.SYS_SERVER_ERROR.getCode(),e.getMessage());
}
}else {
if ( null == composeOrder) {
throw new MallinkException(ErrorCode.PAY_ORDER_ERROR.getCode(),"composeOrder is null.");
}
List<WxOrder> orderList = getComposeChildOrders(composeOrder.getId(),oldRecord);
for (WxOrder o : orderList) {
try {
proxy.handleOrderPaySingleOrderSuccess(oldRecord, o, transactionId, isScheduleTask);
}catch(Exception e) {
logger.error("handleSuccessOrder error.",e);
}
}
}
}else {
//处理其他信息
try {
proxy.handleOrderPaySingleOrderSuccess(oldRecord, order, transactionId,isScheduleTask);
}catch(Exception e) {
throw new MallinkException(ErrorCode.SYS_SERVER_ERROR.getCode(),e.getMessage());
}
}
} }
}
private boolean isComposeOrder(WxPayOrder record) {
if ((null != record.getComposeOrder()) && (EnumComposeOrder.YES.getCode().intValue() == record.getComposeOrder().intValue())) {
return true;
}
return false;
}
private List<WxOrder> getComposeChildOrders(Long composeOrderId,TenantEntity tenantEntity) {
WxOrder orderq = new WxOrder();
orderq.setComposeOrderId(composeOrderId);
orderq.updateTenantInfo(tenantEntity);
List<WxOrder> orderList = wxOrderService.findList(orderq);
return orderList;
} }
@Override @Override
public WxPayOrder handleWxOrderQuery(WxPayOrder oldRecord,WxOrder order,WxAppinfo appInfo,WxPayAccount payAccount,IdWorker idworker,boolean repeatPay) {
public WxPayOrder handleWxOrderQuery(WxPayOrder oldRecord,WxComposeOrder composeOrder,WxOrder order,WxAppinfo appInfo,WxPayAccount payAccount,IdWorker idworker,boolean repeatPay) {
PayQueryAdapterResult queryResult = null; PayQueryAdapterResult queryResult = null;
int wxpaystatus = 0; int wxpaystatus = 0;
try { try {
queryResult = payServiceFactory.getPayAdapterService(oldRecord.getPayVendor()).queryPayStatus(oldRecord, order, appInfo, payAccount);
queryResult = payServiceFactory.getPayAdapterService(oldRecord.getPayVendor()).queryPayStatus(oldRecord, appInfo, payAccount);
wxpaystatus = payServiceFactory.getPayAdapterService(oldRecord.getPayVendor()).queryPayStatus(queryResult, oldRecord.getPayOrderNo()); wxpaystatus = payServiceFactory.getPayAdapterService(oldRecord.getPayVendor()).queryPayStatus(queryResult, oldRecord.getPayOrderNo());
} catch (Exception e) { } catch (Exception e) {
logger.error("pay order service handleWxOrderQuery error: " ,e); logger.error("pay order service handleWxOrderQuery error: " ,e);
@@ -184,7 +199,7 @@ public class WxPayOrderServiceImpl implements WxPayOrderService {
if (EnumPayStatus.PAY_STATUS_SUCCESS.getCode()==wxpaystatus) { if (EnumPayStatus.PAY_STATUS_SUCCESS.getCode()==wxpaystatus) {
//直接调用不会触发事务,spring事务基于AOP代理 //直接调用不会触发事务,spring事务基于AOP代理
WxPayOrderServiceImpl proxy = (WxPayOrderServiceImpl) AopContext.currentProxy(); WxPayOrderServiceImpl proxy = (WxPayOrderServiceImpl) AopContext.currentProxy();
proxy.handleSuccessOrder(oldRecord,order,queryResult,false);
proxy.handleSuccessOrder(oldRecord,composeOrder,order,queryResult,false,false);
throw new MallinkException(ErrorCode.PAY_ORDER_EXIST.getCode(),"该订单已经支付,请勿重复支付!"); throw new MallinkException(ErrorCode.PAY_ORDER_EXIST.getCode(),"该订单已经支付,请勿重复支付!");
}else if (EnumPayStatus.PAY_STATUS_REFUND.getCode()==wxpaystatus) { }else if (EnumPayStatus.PAY_STATUS_REFUND.getCode()==wxpaystatus) {
throw new MallinkException(ErrorCode.PAY_ORDER_REFUND.getCode(),"该订单已经退款,无法支付!"); throw new MallinkException(ErrorCode.PAY_ORDER_REFUND.getCode(),"该订单已经退款,无法支付!");
@@ -211,81 +226,123 @@ public class WxPayOrderServiceImpl implements WxPayOrderService {
return null; return null;
} }
@Override @Override
public ResultData createPayOrder(WxAppinfo appInfo, WxCUserBasicInfo user, WxPayOrder record, EnumPayWay payWay,PayExtraParam params) { public ResultData createPayOrder(WxAppinfo appInfo, WxCUserBasicInfo user, WxPayOrder record, EnumPayWay payWay,PayExtraParam params) {
IdWorker idworker = IdWorker.get();

EnumPayShare isShare = EnumPayShare.NO;

try {
/*
* 如果是组合订单(非拼团、砍价),则结算按照主订单来结算。
* //如果是组合订单,则wxPayOrder对应的是WxcomposeOrder.为了兼容之前的,需要把支付相关信息也保存到子订单里面去
* //如果是非组合订单,则wxPayOrder对应的是wxOrder
*/
WxComposeOrder composeOrder = null;
WxOrder order = null;
if (isComposeOrder(record)) {
composeOrder = wxComposeOrderMapper.selectById(record.getOrderId(), appInfo.getTenantId());
if (null == composeOrder) {
logger.error("pay order, order not allow, repaymentReq: " + record.toString() + ", payWay: " + payWay.toString());
throw new MallinkException(ErrorCode.ORDER_IS_NOT_FIND);
}
List<WxOrder> orderList = getComposeChildOrders(composeOrder.getId(),appInfo.getTenantInfo());
for (WxOrder o : orderList) {
checkSinglePayOrder(o, user, payWay);
}
}else {
// 1. check 订单 // 1. check 订单
WxOrder order = wxOrderMapper.selectById(record.getOrderId(),appInfo.getTenantId());
order = wxOrderMapper.selectById(record.getOrderId(),appInfo.getTenantId());
if (order == null) { if (order == null) {
logger.error("pay order, order not allow, repaymentReq: " + record.toString() + ", payWay: " + payWay.toString()); logger.error("pay order, order not allow, repaymentReq: " + record.toString() + ", payWay: " + payWay.toString());
throw new MallinkException(ErrorCode.ORDER_IS_NOT_FIND); throw new MallinkException(ErrorCode.ORDER_IS_NOT_FIND);
} }
if (!order.getOrderGroupId().equals(0L)) {
if (order.getOrderStatus().equals(EnumOrderStatus.ORDER_STATUS_COOPERATING_COMPLETE.getCode())) {
logger.error("支付时拼团已满>>" + order.getOrderGroupId());
throw new MallinkException(ErrorCode.ORDER_GROUP_COOPERATING_FINISHED);
}
WxOrder orderParams = new WxOrder();
orderParams.setOrderGroupId(order.getOrderGroupId());
orderParams.setCUserId(user.getId());
List<Integer> orderstatuslist = new ArrayList<Integer>();
orderstatuslist.add(EnumOrderStatus.ORDER_STATUS_COOPERATING_COMPLETE.getCode());
orderstatuslist.add(EnumOrderStatus.ORDER_STATUS_COOPERATING_UNPAID.getCode());
orderParams.setStatusS(orderstatuslist);
List<WxOrder> olist = wxOrderMapper.findList(orderParams);
if (olist == null || olist.size() <=0 ) {
throw new MallinkException(ErrorCode.ORDER_GROUP_COOPERATING_FAILD.getCode(),"未查询到参团订单[user:"+user.getId()+",groupId:"+order.getOrderGroupId()+"]");
}
if (olist.size() != 1) {
throw new MallinkException(ErrorCode.ORDER_GROUP_COOPERATING_FAILD.getCode(),"参团订单多条[user:"+user.getId()+",groupId:"+order.getOrderGroupId()+"]");
}
WxOrder orderq = olist.get(0);
if (null == orderq) {
throw new MallinkException(ErrorCode.ORDER_GROUP_COOPERATING_FAILD.getCode(),"未查询到参团订单[user:"+user.getId()+",groupId:"+order.getOrderGroupId()+"]");
}
if (orderq.getOrderStatus()==EnumOrderStatus.ORDER_STATUS_COOPERATING.getCode()) {
throw new MallinkException(ErrorCode.ORDER_GROUP_COOPERATING_ATTEND.getCode(),"不能重复参团订单[user:"+user.getId()+",groupId:"+order.getOrderGroupId()+"]");
}
checkSinglePayOrder(order, user, payWay);
}
PayAdapterResult payResult = createPayOrder(appInfo, user, record,composeOrder,order, payWay, params);
if (payResult.isSuccess()) {
return new ResultData(Result.SUCCESS,"创建支付单成功",payResult.getData());
}else {
return new ResultData(ErrorCode.PAY_ORDER_ERROR.getCode(), payResult.getMsg(), payResult.getData());
}
}
private void checkSinglePayOrder(WxOrder order,WxCUserBasicInfo user,EnumPayWay payWay) {
if (!order.getOrderGroupId().equals(0L)) {
if (order.getOrderStatus().equals(EnumOrderStatus.ORDER_STATUS_COOPERATING_COMPLETE.getCode())) {
logger.error("支付时拼团已满>>" + order.getOrderGroupId());
throw new MallinkException(ErrorCode.ORDER_GROUP_COOPERATING_FINISHED);
} }

WxCoupon wxCoupon = wxCouponMapper.selectById(order.getProductId(),order.getTenantId());
if (wxCoupon.getType().equals(EnumCouponType.COUPON_GROUP.getCode()) &&
wxCoupon.getStatus().equals(EnumCouponStatus.COUPON_STATUS_TAKE_OFFF.getCode())) {
logger.error("券已经下架了>>>" + order.getProductId());
throw new MallinkException(ErrorCode.COUPON_CHANNEL_IS_TAKE_OFF);
WxOrder orderParams = new WxOrder();
orderParams.setOrderGroupId(order.getOrderGroupId());
orderParams.setCUserId(user.getId());
List<Integer> orderstatuslist = new ArrayList<Integer>();
orderstatuslist.add(EnumOrderStatus.ORDER_STATUS_COOPERATING_COMPLETE.getCode());
orderstatuslist.add(EnumOrderStatus.ORDER_STATUS_COOPERATING_UNPAID.getCode());
orderParams.setStatusS(orderstatuslist);
List<WxOrder> olist = wxOrderMapper.findList(orderParams);
if (olist == null || olist.size() <=0 ) {
throw new MallinkException(ErrorCode.ORDER_GROUP_COOPERATING_FAILD.getCode(),"未查询到参团订单[user:"+user.getId()+",groupId:"+order.getOrderGroupId()+"]");
} }
if (olist.size() != 1) {
throw new MallinkException(ErrorCode.ORDER_GROUP_COOPERATING_FAILD.getCode(),"参团订单多条[user:"+user.getId()+",groupId:"+order.getOrderGroupId()+"]");
}
WxOrder orderq = olist.get(0);
if (null == orderq) {
throw new MallinkException(ErrorCode.ORDER_GROUP_COOPERATING_FAILD.getCode(),"未查询到参团订单[user:"+user.getId()+",groupId:"+order.getOrderGroupId()+"]");
}
if (orderq.getOrderStatus()==EnumOrderStatus.ORDER_STATUS_COOPERATING.getCode()) {
throw new MallinkException(ErrorCode.ORDER_GROUP_COOPERATING_ATTEND.getCode(),"不能重复参团订单[user:"+user.getId()+",groupId:"+order.getOrderGroupId()+"]");
}
}


if (!wxCoupon.getType().equals(EnumCouponType.COUPON_GROUP.getCode()) && order.getPressEndDate() == null) {
// 非砍价券且非拼团券
if (order.getOrderStatus() == EnumOrderStatus.ORDER_STATUS_PAYMENT_SUCCESS.getCode()) {
WxCoupon wxCoupon = wxCouponMapper.selectById(order.getProductId(),order.getTenantId());
if (wxCoupon.getType().equals(EnumCouponType.COUPON_GROUP.getCode()) &&
wxCoupon.getStatus().equals(EnumCouponStatus.COUPON_STATUS_TAKE_OFFF.getCode())) {
logger.error("券已经下架了>>>" + order.getProductId());
throw new MallinkException(ErrorCode.COUPON_CHANNEL_IS_TAKE_OFF);
}

if (!wxCoupon.getType().equals(EnumCouponType.COUPON_GROUP.getCode()) && order.getPressEndDate() == null) {
// 非砍价券且非拼团券
if (order.getOrderStatus() == EnumOrderStatus.ORDER_STATUS_PAYMENT_SUCCESS.getCode()) {
logger.error("订单已支付: " + order.toString() + " , payWay: " + payWay.toString());
throw new MallinkException(ErrorCode.ORDER_HAD_PAY);
} else if (order.getOrderStatus() == EnumOrderStatus.ORDER_STATUS_OVERTIME_CANCEL.getCode()) {
logger.error("订单已取消: " + order.toString() + " , payWay: " + payWay.toString());
throw new MallinkException(ErrorCode.ORDER_HAD_CANCEL);
} else {
if (order.getOrderStatus() != EnumOrderStatus.ORDER_STATUS_PENDING_PAYMENT.getCode()) {
logger.error("订单已支付: " + order.toString() + " , payWay: " + payWay.toString()); logger.error("订单已支付: " + order.toString() + " , payWay: " + payWay.toString());
throw new MallinkException(ErrorCode.ORDER_HAD_PAY);
} else if (order.getOrderStatus() == EnumOrderStatus.ORDER_STATUS_OVERTIME_CANCEL.getCode()) {
logger.error("订单已取消: " + order.toString() + " , payWay: " + payWay.toString());
throw new MallinkException(ErrorCode.ORDER_HAD_CANCEL);
} else {
if (order.getOrderStatus() != EnumOrderStatus.ORDER_STATUS_PENDING_PAYMENT.getCode()) {
logger.error("订单已支付: " + order.toString() + " , payWay: " + payWay.toString());
throw new MallinkException(ErrorCode.ORDER_IS_NOT_PAY);
}
}
} else if (order.getPressEndDate() != null) {
// 砍价券,只有在过期时无法支付
// 砍价中,原价购买
// 砍价完成,低价购买
if (order.getOrderStatus() == EnumOrderStatus.ORDER_STATUS_PRESS_OVERTIME.getCode()) {
logger.error("砍价已过期: " + order.toString() + " , payWay: " + payWay.toString());
throw new MallinkException(ErrorCode.ORDER_PRESS_IS_OVERTIME);
throw new MallinkException(ErrorCode.ORDER_IS_NOT_PAY);
} }
} }
if (order.getPaymentType() != EnumPayType.PAY_PAYMENT.getCode()) {
return new ResultData(ErrorCode.PAY_ORDER_IS_NOT_PAYMENT);
} else if (order.getPressEndDate() != null) {
// 砍价券,只有在过期时无法支付
// 砍价中,原价购买
// 砍价完成,低价购买
if (order.getOrderStatus() == EnumOrderStatus.ORDER_STATUS_PRESS_OVERTIME.getCode()) {
logger.error("砍价已过期: " + order.toString() + " , payWay: " + payWay.toString());
throw new MallinkException(ErrorCode.ORDER_PRESS_IS_OVERTIME);
} }
}
if (order.getPaymentType() != EnumPayType.PAY_PAYMENT.getCode()) {
throw new MallinkException(ErrorCode.PAY_ORDER_IS_NOT_PAYMENT);
}
}
private PayAdapterResult createPayOrder(WxAppinfo appInfo, WxCUserBasicInfo user,WxPayOrder record,WxComposeOrder composeOrder,WxOrder order, EnumPayWay payWay,PayExtraParam params) {
/**
* 如果composeOrder存在,支付关联composeOrder
* 如果composeOrder不存在,支付关联WxOrder
*/
boolean isComposeOrder = isComposeOrder(record);
Long orderId = order.getId();
if (isComposeOrder) {
orderId = composeOrder.getId();
}
IdWorker idworker = IdWorker.get();
EnumPayShare isShare = EnumPayShare.NO;
try {
WxPayAccount payAccount = wxPayAccountMapper.selectById(appInfo.getPayId()); WxPayAccount payAccount = wxPayAccountMapper.selectById(appInfo.getPayId());
if (payAccount.checkShare()) { if (payAccount.checkShare()) {
isShare = EnumPayShare.YES; isShare = EnumPayShare.YES;
@@ -294,7 +351,7 @@ public class WxPayOrderServiceImpl implements WxPayOrderService {
Date currentDate = new Date(); Date currentDate = new Date();
//一个订单只有一条支付记录。 //一个订单只有一条支付记录。
WxPayOrder orderq = new WxPayOrder(); WxPayOrder orderq = new WxPayOrder();
orderq.setOrderId(record.getOrderId());
orderq.setOrderId(orderId);
List<WxPayOrder> list = wxPayOrderMapper.findList(orderq); List<WxPayOrder> list = wxPayOrderMapper.findList(orderq);
WxPayOrder oldRecord = null; WxPayOrder oldRecord = null;
if (null != list && list.size() > 0) { if (null != list && list.size() > 0) {
@@ -308,7 +365,7 @@ public class WxPayOrderServiceImpl implements WxPayOrderService {
throw new MallinkException(ErrorCode.PAY_ORDER_EXIST); throw new MallinkException(ErrorCode.PAY_ORDER_EXIST);
//如果是支付中的,则调用微信接口查询支付状态 //如果是支付中的,则调用微信接口查询支付状态
}else if (oldRecord.getPayOrderStatus()==EnumPayStatus.PAY_STATUS_WAIT.getCode()) { }else if (oldRecord.getPayOrderStatus()==EnumPayStatus.PAY_STATUS_WAIT.getCode()) {
record = handleWxOrderQuery(oldRecord,order,appInfo,payAccount,idworker,true);
record = handleWxOrderQuery(oldRecord,composeOrder,order,appInfo,payAccount,idworker,true);
if (null == record) { if (null == record) {
throw new MallinkException(ErrorCode.PAY_ORDER_PAYING.getCode(),"订单微信查询支付状态失败!"); throw new MallinkException(ErrorCode.PAY_ORDER_PAYING.getCode(),"订单微信查询支付状态失败!");
} }
@@ -347,6 +404,9 @@ public class WxPayOrderServiceImpl implements WxPayOrderService {
record.setPayVendor(payWay.getCode()); record.setPayVendor(payWay.getCode());
record.setPayOrderStatus(EnumPayStatus.PAY_STATUS_WAIT.getCode()); record.setPayOrderStatus(EnumPayStatus.PAY_STATUS_WAIT.getCode());
record.setShare(isShare.getCode()); record.setShare(isShare.getCode());
if (isComposeOrder) {
record.setComposeOrder(EnumComposeOrder.YES.getCode());
}
if (isShare == EnumPayShare.YES) { if (isShare == EnumPayShare.YES) {
// 分账金额 // 分账金额
int iChargeFee = PayUtils.getPayRate(record.getPayAmount(), payAccount.getRate(), false); int iChargeFee = PayUtils.getPayRate(record.getPayAmount(), payAccount.getRate(), false);
@@ -370,7 +430,7 @@ public class WxPayOrderServiceImpl implements WxPayOrderService {
logger.debug("wxPayRecord md5 before:"+record.toString()); logger.debug("wxPayRecord md5 before:"+record.toString());
String beforemd5 = HashUtil.md5(record.toString()); String beforemd5 = HashUtil.md5(record.toString());
PayAdapterResult payResult = payServiceFactory.getPayAdapterService(payWay.getCode()).pay(payAccount, order, record,isShare,appInfo, currentDate, params);
PayAdapterResult payResult = payServiceFactory.getPayAdapterService(payWay.getCode()).pay(payAccount, composeOrder,order, record,isShare,appInfo, currentDate, params);
String aftermd5 = HashUtil.md5(record.toString()); String aftermd5 = HashUtil.md5(record.toString());
if (beforemd5.equals(aftermd5)) { if (beforemd5.equals(aftermd5)) {
logger.error("支付方式["+payWay.getCode()+"]支付接口【pay】过程中 WxPayOrder 未做更新.record:"+record.toString()); logger.error("支付方式["+payWay.getCode()+"]支付接口【pay】过程中 WxPayOrder 未做更新.record:"+record.toString());
@@ -383,12 +443,7 @@ public class WxPayOrderServiceImpl implements WxPayOrderService {
logger.error("pay order update error: " + record.toString()); logger.error("pay order update error: " + record.toString());
throw new MallinkException(ErrorCode.DB_FAIL); throw new MallinkException(ErrorCode.DB_FAIL);
} }
if (payResult.isSuccess()) {
return new ResultData(Result.SUCCESS, "创建支付订单成功", payResult.getData());
}else {
return new ResultData(ErrorCode.PAY_ORDER_ERROR.getCode(), payResult.getMsg(), payResult.getData());
}
return payResult;
} catch (RuntimeException e) { } catch (RuntimeException e) {
logger.error("createwxpayorder error:",e); logger.error("createwxpayorder error:",e);
throw new MallinkException(ErrorCode.PAY_ORDER_ERROR.getCode(), e.getMessage()); throw new MallinkException(ErrorCode.PAY_ORDER_ERROR.getCode(), e.getMessage());
@@ -479,7 +534,7 @@ public class WxPayOrderServiceImpl implements WxPayOrderService {


logger.debug("wxPayRecord md5 before:"+record.toString()); logger.debug("wxPayRecord md5 before:"+record.toString());
String beforemd5 = HashUtil.md5(record.toString()); String beforemd5 = HashUtil.md5(record.toString());
PayAdapterResult payResult = payServiceFactory.getPayAdapterService(payWay.getCode()).pay(payAccount, order, record,isShare,appInfo, currentDate, params);
PayAdapterResult payResult = payServiceFactory.getPayAdapterService(payWay.getCode()).pay(payAccount, null,order, record,isShare,appInfo, currentDate, params);
String aftermd5 = HashUtil.md5(record.toString()); String aftermd5 = HashUtil.md5(record.toString());
if (beforemd5.equals(aftermd5)) { if (beforemd5.equals(aftermd5)) {
logger.error("支付方式["+payWay.getCode()+"]支付接口【pay】过程中 WxPayOrder 未做更新.record:"+record.toString()); logger.error("支付方式["+payWay.getCode()+"]支付接口【pay】过程中 WxPayOrder 未做更新.record:"+record.toString());
@@ -538,15 +593,10 @@ public class WxPayOrderServiceImpl implements WxPayOrderService {
return new ResultData(ErrorCode.PAY_ORDER_ERROR.getCode(), "payOrder not found"); return new ResultData(ErrorCode.PAY_ORDER_ERROR.getCode(), "payOrder not found");
} }


WxOrder order = wxOrderMapper.selectById(record.getOrderId(),payOrder.getTenantId());
if (order == null) {
return new ResultData(ErrorCode.PAY_ORDER_ERROR.getCode(), "Order not found");
}

WxAppinfo appInfo = wxAppinfoService.getCAppInfo(record,payWay); WxAppinfo appInfo = wxAppinfoService.getCAppInfo(record,payWay);
PayAdapterService payService = payServiceFactory.getPayAdapterService(payWay.getCode()); PayAdapterService payService = payServiceFactory.getPayAdapterService(payWay.getCode());
WxPayAccount payAccount = wxPayAccountMapper.selectById(appInfo.getPayId()); WxPayAccount payAccount = wxPayAccountMapper.selectById(appInfo.getPayId());
PayQueryAdapterResult apiResult = payService.queryPayStatus(record, order, appInfo, payAccount);
PayQueryAdapterResult apiResult = payService.queryPayStatus(record, appInfo, payAccount);
int status = payServiceFactory.getPayAdapterService(payWay.getCode()).queryPayStatus(apiResult, record.getPayOrderNo()); int status = payServiceFactory.getPayAdapterService(payWay.getCode()).queryPayStatus(apiResult, record.getPayOrderNo());
boolean isSuccess = true; boolean isSuccess = true;
String msg = ""; String msg = "";
@@ -574,15 +624,15 @@ public class WxPayOrderServiceImpl implements WxPayOrderService {
}else if (status == EnumPayStatus.PAY_STATUS_ORDER_NOT_EXISTS.getCode().intValue()) { }else if (status == EnumPayStatus.PAY_STATUS_ORDER_NOT_EXISTS.getCode().intValue()) {
isSuccess = false; isSuccess = false;
// 支付订单不存在, 订单失败 // 支付订单不存在, 订单失败
WxOrder updateOrderForMicroPay = new WxOrder();
updateOrderForMicroPay.setId(order.getId());
updateOrderForMicroPay.setOrderStatus(EnumOrderStatus.ORDER_STATUS_OVERTIME_CANCEL.getCode());
try {
wxOrderMapper.updateById(updateOrderForMicroPay);
} catch (Exception e) {
logger.error(e.getMessage());
}
msg = "订单支付渠道支付单不存在。orderId:"+order.getId();
// WxOrder updateOrderForMicroPay = new WxOrder();
// updateOrderForMicroPay.setId(order.getId());
// updateOrderForMicroPay.setOrderStatus(EnumOrderStatus.ORDER_STATUS_OVERTIME_CANCEL.getCode());
// try {
// wxOrderMapper.updateById(updateOrderForMicroPay);
// } catch (Exception e) {
// logger.error(e.getMessage());
// }
msg = "订单支付渠道支付单不存在。payOrder:"+payOrder.getId();
}else { }else {
isSuccess = false; isSuccess = false;
msg = apiResult.getMsg(); msg = apiResult.getMsg();
@@ -761,7 +811,7 @@ public class WxPayOrderServiceImpl implements WxPayOrderService {
} }


@Transactional(propagation = Propagation.REQUIRED, readOnly = false, rollbackFor = {Exception.class}) @Transactional(propagation = Propagation.REQUIRED, readOnly = false, rollbackFor = {Exception.class})
public WxOrder handler(WxPayOrder record, String transactionId,Long cUserId) {
public void handler(WxPayOrder record,WxComposeOrder composeOrder,List<WxOrder> composeChildOrders,WxOrder order, String transactionId,Long cUserId) {
Date currentDate = new Date(); Date currentDate = new Date();
EnumPayStatus payStatus = EnumPayStatus.getEnum(record.getPayOrderStatus()); EnumPayStatus payStatus = EnumPayStatus.getEnum(record.getPayOrderStatus());
// 判断支付状态 // 判断支付状态
@@ -779,29 +829,52 @@ public class WxPayOrderServiceImpl implements WxPayOrderService {
logger.error(e.getMessage()); logger.error(e.getMessage());
throw new MallinkException(ErrorCode.DB_FAIL); throw new MallinkException(ErrorCode.DB_FAIL);
} }
return null;
return ;
} }
if (payStatus != EnumPayStatus.PAY_STATUS_WAIT) { if (payStatus != EnumPayStatus.PAY_STATUS_WAIT) {
logger.info("pay success handle, payOrder " + record.getPayOrderNo() + logger.info("pay success handle, payOrder " + record.getPayOrderNo() +
"is paid success , orderId : " + record.getOrderId()); "is paid success , orderId : " + record.getOrderId());
return null;
}
WxOrder order = wxOrderMapper.selectById(record.getOrderId(),record.getTenantId());
if (order == null) {
logger.error("pay success handle, order " + record.getOrderId() + " not found , payOrderid : " + record.getPayOrderNo());
throw new MallinkException(ErrorCode.ORDER_IS_NOT_FIND);
return;
} }
if (null != cUserId) {
WxOrder __order = new WxOrder();
__order.setId(order.getId());
__order.setCUserId(cUserId);
wxOrderMapper.updateById(__order);
if ((null != record.getComposeOrder()) && (EnumComposeOrder.YES.getCode().intValue() == record.getComposeOrder().intValue()) ) {
if (composeOrder == null) {
logger.error("pay success handle, order " + record.getOrderId() + " not found , payOrderid : " + record.getPayOrderNo());
throw new MallinkException(ErrorCode.ORDER_IS_NOT_FIND);
}
if (null != cUserId) {
composeOrder.setCUserId(cUserId);
wxComposeOrderMapper.updateCUserId(composeOrder);
if (null != composeChildOrders) {
List<Long> ids = new ArrayList<Long>();
for (WxOrder o : composeChildOrders) {
ids.add(o.getId());
}
if (ids.size() > 0 ) {
WxOrder updateOrders = new WxOrder();
updateOrders.setIds(ids);
updateOrders.setCUserId(cUserId);
updateOrders.updateTenantInfo(order);
wxOrderMapper.updateCUserId(updateOrders);
}
}
}
}else {
if (order == null) {
logger.error("pay success handle, order " + record.getOrderId() + " not found , payOrderid : " + record.getPayOrderNo());
throw new MallinkException(ErrorCode.ORDER_IS_NOT_FIND);
}
if (null != cUserId) {
order.setCUserId(cUserId);
wxOrderMapper.updateCUserId(order);
}
} }


// 修改支付订单状态 // 修改支付订单状态
WxPayOrder updateOrder = new WxPayOrder(); WxPayOrder updateOrder = new WxPayOrder();
updateOrder.setId(record.getId()); updateOrder.setId(record.getId());
updateOrder.updateTenantInfo(order);
updateOrder.updateTenantInfo(record);
updateOrder.setOrderId(record.getOrderId()); updateOrder.setOrderId(record.getOrderId());
updateOrder.setUpdateTime(currentDate); updateOrder.setUpdateTime(currentDate);
if (null != cUserId) { if (null != cUserId) {
@@ -815,24 +888,36 @@ public class WxPayOrderServiceImpl implements WxPayOrderService {
logger.error("支付订单数据库更新失败: " + e.getMessage()); logger.error("支付订单数据库更新失败: " + e.getMessage());
throw new MallinkException(ErrorCode.DB_FAIL.getCode(), "支付订单数据库更新失败: " + e.getMessage()); throw new MallinkException(ErrorCode.DB_FAIL.getCode(), "支付订单数据库更新失败: " + e.getMessage());
} }
return order;
} }
@Override @Override
@Transactional(propagation = Propagation.REQUIRED, readOnly = false, rollbackFor = {Exception.class}) @Transactional(propagation = Propagation.REQUIRED, readOnly = false, rollbackFor = {Exception.class})
public void handleOrderPaySuccess(WxPayOrder record, String transactionId) { public void handleOrderPaySuccess(WxPayOrder record, String transactionId) {
WxPayOrderServiceImpl proxy = (WxPayOrderServiceImpl) AopContext.currentProxy(); WxPayOrderServiceImpl proxy = (WxPayOrderServiceImpl) AopContext.currentProxy();
WxOrder order = proxy.handler(record,transactionId,null);
if (null == order ) {
return;
if (isComposeOrder(record)) {
WxComposeOrder composeOrder = wxComposeOrderMapper.selectById(record.getOrderId(), record.getTenantId());
List<WxOrder> orderList = getComposeChildOrders(composeOrder.getId(),record);
proxy.handler(record,composeOrder,orderList,null,transactionId,null);
//组合支付的订单,循环所有子订单
for (WxOrder o : orderList) {
proxy.handleOrderPaySingleOrderSuccess(record, o, transactionId, false);
}
}else {
WxOrder order = wxOrderMapper.selectById(record.getOrderId(),record.getTenantId());
proxy.handler(record,null,null,order,transactionId,null);
proxy.handleOrderPaySingleOrderSuccess(record, order, transactionId,false);
} }
Long productId = order.getProductId();
}
@Transactional(propagation = Propagation.REQUIRED, readOnly = false, rollbackFor = {Exception.class})
public void handleOrderPaySingleOrderSuccess(WxPayOrder record,WxOrder order, String transactionId,boolean isScheduleTask) {
Long productId = order.getProductId();
WxCoupon wxCoupon = wxCouponMapper.selectById(productId,order.getTenantId()); WxCoupon wxCoupon = wxCouponMapper.selectById(productId,order.getTenantId());
if(wxCoupon != null) { if(wxCoupon != null) {
if (isOrderGroupCoupon(record, wxCoupon)) { if (isOrderGroupCoupon(record, wxCoupon)) {
// 如果是Coupon是拼团, 创建拼团信息, 不创建COUPON_ORDER // 如果是Coupon是拼团, 创建拼团信息, 不创建COUPON_ORDER
try { try {
wxOrderGroupService.createOrderGroup(order, wxCoupon,false);
wxOrderGroupService.createOrderGroup(order, wxCoupon,isScheduleTask);
} catch (Exception e) { } catch (Exception e) {
logger.error("参团失败" + e.getMessage()); logger.error("参团失败" + e.getMessage());
order.setOrderStatus(EnumOrderStatus.ORDER_STATUS_COOPERATING_FAILD.getCode()); order.setOrderStatus(EnumOrderStatus.ORDER_STATUS_COOPERATING_FAILD.getCode());
@@ -900,10 +985,8 @@ public class WxPayOrderServiceImpl implements WxPayOrderService {
} }
} }
WxPayOrderServiceImpl proxy = (WxPayOrderServiceImpl) AopContext.currentProxy(); WxPayOrderServiceImpl proxy = (WxPayOrderServiceImpl) AopContext.currentProxy();
WxOrder order = proxy.handler(record,transcationId,basicUserId);
if (null == order) {
return;
}
WxOrder order = wxOrderMapper.selectById(record.getOrderId(),record.getTenantId());
proxy.handler(record, null, null, order, transcationId, basicUserId);
// B端收银台核销券处理, 收银台支付和券支付可能不是同一个人 // B端收银台核销券处理, 收银台支付和券支付可能不是同一个人
WxPayOrder payOrderQ = new WxPayOrder(); WxPayOrder payOrderQ = new WxPayOrder();
payOrderQ.setOrderId(order.getId()); payOrderQ.setOrderId(order.getId());
@@ -1097,16 +1180,7 @@ public class WxPayOrderServiceImpl implements WxPayOrderService {
} }
} }


@Override
@Transactional(propagation = Propagation.REQUIRED, readOnly = false, rollbackFor = {Exception.class})
public void handlePayOrderFail(WxPayOrder record, int status) {
// 判断支付状态
if (record.getPayOrderStatus().equals(EnumPayStatus.PAY_STATUS_WAIT.getCode())) {
logger.error("pay handle, payOrder " + record.getPayOrderNo() +
"is complete, orderId : " + record.getOrderId());
return;
}
WxOrder order = wxOrderMapper.selectById(record.getOrderId(),record.getTenantId());
private void checkSingleOrder(WxOrder order,WxPayOrder record) {
if (order == null) { if (order == null) {
logger.error("pay handle, order " + record.getOrderId() + " not found , payOrderid : " + record.getPayOrderNo()); logger.error("pay handle, order " + record.getOrderId() + " not found , payOrderid : " + record.getPayOrderNo());
throw new MallinkException(ErrorCode.ORDER_IS_NOT_FIND); throw new MallinkException(ErrorCode.ORDER_IS_NOT_FIND);
@@ -1126,7 +1200,36 @@ public class WxPayOrderServiceImpl implements WxPayOrderService {
throw new MallinkException(ErrorCode.PAY_ORDER_NOT_FOUND); throw new MallinkException(ErrorCode.PAY_ORDER_NOT_FOUND);
} }
} }

}
@Override
@Transactional(propagation = Propagation.REQUIRED, readOnly = false, rollbackFor = {Exception.class})
public void handlePayOrderFail(WxPayOrder record, int status) {
// 判断支付状态
if (record.getPayOrderStatus().equals(EnumPayStatus.PAY_STATUS_WAIT.getCode())) {
logger.error("pay handle, payOrder " + record.getPayOrderNo() +
"is complete, orderId : " + record.getOrderId());
return;
}
WxComposeOrder composeOrder = null;
WxOrder order = null;
boolean isComposeOrder = isComposeOrder(record);
List<WxOrder> orderList = null;
if (isComposeOrder) {
composeOrder = wxComposeOrderMapper.selectById(record.getOrderId(), record.getTenantId());
if (composeOrder == null) {
throw new MallinkException(ErrorCode.ORDER_IS_NOT_FIND);
}
orderList = getComposeChildOrders(composeOrder.getId(),record);
for (WxOrder o : orderList) {
checkSingleOrder(o, record);
}
}else {
order = wxOrderMapper.selectById(record.getOrderId(),record.getTenantId());
checkSingleOrder(order, record);
}
if (record.getId() > 0) { if (record.getId() > 0) {
// 有价券 // 有价券
if (EnumPayStatus.PAY_STATUS_FAIL.getCode() == status) { if (EnumPayStatus.PAY_STATUS_FAIL.getCode() == status) {
@@ -1136,7 +1239,7 @@ public class WxPayOrderServiceImpl implements WxPayOrderService {
// 回调未返回,主动检查支付订单状态 // 回调未返回,主动检查支付订单状态
try { try {
WxPayAccount payAccount = wxPayAccountMapper.selectById(appInfo.getPayId()); WxPayAccount payAccount = wxPayAccountMapper.selectById(appInfo.getPayId());
int payStatus = payServiceFactory.getPayAdapterService(record.getPayVendor()).queryPayStatusCode(record, order, appInfo, payAccount);
int payStatus = payServiceFactory.getPayAdapterService(record.getPayVendor()).queryPayStatusCode(record, appInfo, payAccount);
if (payStatus!=EnumPayStatus.PAY_STATUS_SUCCESS.getCode().intValue() && payStatus!=EnumPayStatus.PAY_STATUS_WAIT.getCode().intValue()) { if (payStatus!=EnumPayStatus.PAY_STATUS_SUCCESS.getCode().intValue() && payStatus!=EnumPayStatus.PAY_STATUS_WAIT.getCode().intValue()) {
// 支付订单未成功,返回异常 // 支付订单未成功,返回异常
record.setPayOrderStatus(EnumPayStatus.PAY_STATUS_FAIL.getCode()); record.setPayOrderStatus(EnumPayStatus.PAY_STATUS_FAIL.getCode());
@@ -1173,10 +1276,16 @@ public class WxPayOrderServiceImpl implements WxPayOrderService {
*/ */
} else if (record.getPayOrderStatus() == EnumPayStatus.PAY_STATUS_CANCEL.getCode()) { } else if (record.getPayOrderStatus() == EnumPayStatus.PAY_STATUS_CANCEL.getCode()) {
try { try {
int _count = wxOrderService.updateOrderStatus(order, EnumOrderStatus.ORDER_STATUS_OVERTIME_CANCEL);
if (_count > 1) {
throw new MallinkException(ErrorCode.ORDER_IS_FAIL);
}
if (isComposeOrder && null != orderList) {
for (WxOrder o : orderList) {
wxOrderService.updateOrderStatus(o, EnumOrderStatus.ORDER_STATUS_OVERTIME_CANCEL);
}
}else {
int _count = wxOrderService.updateOrderStatus(order, EnumOrderStatus.ORDER_STATUS_OVERTIME_CANCEL);
if (_count > 1) {
throw new MallinkException(ErrorCode.ORDER_IS_FAIL);
}
}
} catch (Exception e) { } catch (Exception e) {
logger.error(e.getMessage()); logger.error(e.getMessage());
throw new MallinkException(ErrorCode.DB_FAIL); throw new MallinkException(ErrorCode.DB_FAIL);


+ 1
- 1
mallinkService/src/main/java/com/iformall/service/impl/WxRefundOrderServiceImpl.java View File

@@ -197,7 +197,7 @@ public class WxRefundOrderServiceImpl implements WxRefundOrderService {
if (null == payAccount) { if (null == payAccount) {
throw new MallinkException(ErrorCode.PAY_ORDER_QUERY_ERROR.getCode(), "payAccount为空[payId:"+appInfo.getPayId()+"]"); throw new MallinkException(ErrorCode.PAY_ORDER_QUERY_ERROR.getCode(), "payAccount为空[payId:"+appInfo.getPayId()+"]");
} }
int status = WxPayOrderServiceHelper.wxOrderPayStatus(payOrder, wxOrder, appInfo, payAccount);
int status = WxPayOrderServiceHelper.wxOrderPayStatus(payOrder, appInfo, payAccount);
if (EnumPayStatus.PAY_STATUS_SUCCESS.getCode() != status) { if (EnumPayStatus.PAY_STATUS_SUCCESS.getCode() != status) {
return new ResultData(ErrorCode.PAY_ORDER_ERROR.getCode(),"该订单查询微信支付状态为未支付成功,无法退款。"); return new ResultData(ErrorCode.PAY_ORDER_ERROR.getCode(),"该订单查询微信支付状态为未支付成功,无法退款。");
} }


+ 4
- 3
mallinkService/src/main/java/com/iformall/service/pay/service/pay/PayAdapterService.java View File

@@ -5,6 +5,7 @@ import java.util.Date;
import java.util.Map; import java.util.Map;


import com.iformall.domain.po.WxAppinfo; import com.iformall.domain.po.WxAppinfo;
import com.iformall.domain.po.WxComposeOrder;
import com.iformall.domain.po.WxOrder; import com.iformall.domain.po.WxOrder;
import com.iformall.domain.po.WxPayAccount; import com.iformall.domain.po.WxPayAccount;
import com.iformall.domain.po.WxPayOrder; import com.iformall.domain.po.WxPayOrder;
@@ -27,7 +28,7 @@ public interface PayAdapterService {
* @return * @return
* @throws Exception * @throws Exception
*/ */
public PayAdapterResult pay(WxPayAccount payAccount,WxOrder order,WxPayOrder record ,EnumPayShare isShare,WxAppinfo appInfo,Date currentDate, PayExtraParam params) throws Exception;
public PayAdapterResult pay(WxPayAccount payAccount,WxComposeOrder composeOrder,WxOrder order,WxPayOrder record ,EnumPayShare isShare,WxAppinfo appInfo,Date currentDate, PayExtraParam params) throws Exception;


/** /**
* 查询支付结果,调用对应端的API查询支付结果 * 查询支付结果,调用对应端的API查询支付结果
@@ -38,7 +39,7 @@ public interface PayAdapterService {
* @return * @return
* @throws Exception * @throws Exception
*/ */
public PayQueryAdapterResult queryPayStatus(WxPayOrder oldRecord,WxOrder order,WxAppinfo appInfo,WxPayAccount payAccount) throws Exception;
public PayQueryAdapterResult queryPayStatus(WxPayOrder oldRecord,WxAppinfo appInfo,WxPayAccount payAccount) throws Exception;
/** /**
* 根据返回结果对象解析出支付状态 * 根据返回结果对象解析出支付状态
@@ -58,7 +59,7 @@ public interface PayAdapterService {
* @return * @return
* @throws Exception * @throws Exception
*/ */
public int queryPayStatusCode(WxPayOrder oldRecord,WxOrder order,WxAppinfo appInfo,WxPayAccount payAccount) throws Exception;
public int queryPayStatusCode(WxPayOrder oldRecord,WxAppinfo appInfo,WxPayAccount payAccount) throws Exception;
/** /**
* API关闭订单 * API关闭订单


+ 5
- 4
mallinkService/src/main/java/com/iformall/service/pay/service/pay/wx/BaseWxPayAdapterService.java View File

@@ -16,6 +16,7 @@ import com.iformall.common.Result;
import com.iformall.common.ResultData; import com.iformall.common.ResultData;
import com.iformall.domain.po.PosCouponOrderVerify; import com.iformall.domain.po.PosCouponOrderVerify;
import com.iformall.domain.po.WxAppinfo; import com.iformall.domain.po.WxAppinfo;
import com.iformall.domain.po.WxComposeOrder;
import com.iformall.domain.po.WxCouponOrder; import com.iformall.domain.po.WxCouponOrder;
import com.iformall.domain.po.WxOrder; import com.iformall.domain.po.WxOrder;
import com.iformall.domain.po.WxPayAccount; import com.iformall.domain.po.WxPayAccount;
@@ -50,9 +51,9 @@ import me.chanjar.weixin.open.api.WxOpenService;
@Slf4j @Slf4j
public class BaseWxPayAdapterService { public class BaseWxPayAdapterService {


protected PayQueryAdapterResult queryPayStatus(WxPayOrder oldRecord, WxOrder order, WxAppinfo appInfo, WxPayAccount payAccount)
protected PayQueryAdapterResult queryPayStatus(WxPayOrder oldRecord, WxAppinfo appInfo, WxPayAccount payAccount)
throws Exception { throws Exception {
Map<String, String> retMap = WxPayOrderServiceHelper.wxOrderPayStatusMap(oldRecord, order, appInfo, payAccount);
Map<String, String> retMap = WxPayOrderServiceHelper.wxOrderPayStatusMap(oldRecord, appInfo, payAccount);
int code = WxPayOrderServiceHelper.getPayStatusFromMap(retMap,oldRecord.getPayOrderNo()); int code = WxPayOrderServiceHelper.getPayStatusFromMap(retMap,oldRecord.getPayOrderNo());
String msg = WxPayOrderServiceHelper.getPayStatusMsg(retMap, oldRecord.getPayOrderNo()); String msg = WxPayOrderServiceHelper.getPayStatusMsg(retMap, oldRecord.getPayOrderNo());
PayQueryAdapterResult result = new PayQueryAdapterResult(code, msg, retMap,retMap.get("transaction_id"),retMap.get("time_end")); PayQueryAdapterResult result = new PayQueryAdapterResult(code, msg, retMap,retMap.get("transaction_id"),retMap.get("time_end"));
@@ -63,9 +64,9 @@ public class BaseWxPayAdapterService {
return WxPayOrderServiceHelper.getPayStatusFromMap((Map<String, String>) statusObject.getData(),orderOutNo); return WxPayOrderServiceHelper.getPayStatusFromMap((Map<String, String>) statusObject.getData(),orderOutNo);
} }


protected int queryPayStatusCode(WxPayOrder oldRecord, WxOrder order, WxAppinfo appInfo, WxPayAccount payAccount)
protected int queryPayStatusCode(WxPayOrder oldRecord, WxAppinfo appInfo, WxPayAccount payAccount)
throws Exception { throws Exception {
return WxPayOrderServiceHelper.wxOrderPayStatus(oldRecord, order, appInfo, payAccount);
return WxPayOrderServiceHelper.wxOrderPayStatus(oldRecord, appInfo, payAccount);
} }
JSONObject errorMapClose = JSON.parseObject("{" + JSONObject errorMapClose = JSON.parseObject("{" +


+ 6
- 5
mallinkService/src/main/java/com/iformall/service/pay/service/pay/wx/h5/WxH5PayService.java View File

@@ -7,6 +7,7 @@ import java.util.Map;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;


import com.iformall.domain.po.WxAppinfo; import com.iformall.domain.po.WxAppinfo;
import com.iformall.domain.po.WxComposeOrder;
import com.iformall.domain.po.WxOrder; import com.iformall.domain.po.WxOrder;
import com.iformall.domain.po.WxPayAccount; import com.iformall.domain.po.WxPayAccount;
import com.iformall.domain.po.WxPayOrder; import com.iformall.domain.po.WxPayOrder;
@@ -21,16 +22,16 @@ import com.iformall.service.pay.service.pay.wx.BaseWxPayAdapterService;
public class WxH5PayService extends BaseWxPayAdapterService implements CDrivingPayService{ public class WxH5PayService extends BaseWxPayAdapterService implements CDrivingPayService{


@Override @Override
public PayAdapterResult pay(WxPayAccount payAccount, WxOrder order, WxPayOrder record, EnumPayShare isShare,
public PayAdapterResult pay(WxPayAccount payAccount, WxComposeOrder composeOrder,WxOrder order, WxPayOrder record, EnumPayShare isShare,
WxAppinfo appInfo, Date currentDate, PayExtraParam params) throws Exception { WxAppinfo appInfo, Date currentDate, PayExtraParam params) throws Exception {
// TODO Auto-generated method stub // TODO Auto-generated method stub
return null; return null;
} }


@Override @Override
public PayQueryAdapterResult queryPayStatus(WxPayOrder oldRecord, WxOrder order, WxAppinfo appInfo,
public PayQueryAdapterResult queryPayStatus(WxPayOrder oldRecord, WxAppinfo appInfo,
WxPayAccount payAccount) throws Exception { WxPayAccount payAccount) throws Exception {
return super.queryPayStatus(oldRecord, order, appInfo, payAccount);
return super.queryPayStatus(oldRecord, appInfo, payAccount);
} }


@Override @Override
@@ -39,9 +40,9 @@ public class WxH5PayService extends BaseWxPayAdapterService implements CDriving
} }


@Override @Override
public int queryPayStatusCode(WxPayOrder oldRecord, WxOrder order, WxAppinfo appInfo, WxPayAccount payAccount)
public int queryPayStatusCode(WxPayOrder oldRecord, WxAppinfo appInfo, WxPayAccount payAccount)
throws Exception { throws Exception {
return super.queryPayStatusCode(oldRecord, order, appInfo, payAccount);
return super.queryPayStatusCode(oldRecord, appInfo, payAccount);
} }


@Override @Override


+ 46
- 16
mallinkService/src/main/java/com/iformall/service/pay/service/pay/wx/miniApp/appPay/WxMiniAppPayAdapterService.java View File

@@ -13,6 +13,7 @@ import com.iformall.common.ErrorCode;
import com.iformall.common.Result; import com.iformall.common.Result;
import com.iformall.common.ResultData; import com.iformall.common.ResultData;
import com.iformall.domain.po.WxAppinfo; import com.iformall.domain.po.WxAppinfo;
import com.iformall.domain.po.WxComposeOrder;
import com.iformall.domain.po.WxOrder; import com.iformall.domain.po.WxOrder;
import com.iformall.domain.po.WxPayAccount; import com.iformall.domain.po.WxPayAccount;
import com.iformall.domain.po.WxPayOrder; import com.iformall.domain.po.WxPayOrder;
@@ -59,7 +60,7 @@ public class WxMiniAppPayAdapterService extends BaseWxPayAdapterService implemen
"\"NOT_UTF8\":{\"detail\":\"编码格式错误\",\"reason\":\"未使用指定编码格式\",\"resolution\":\"请使用UTF-8编码格式\"}}"); "\"NOT_UTF8\":{\"detail\":\"编码格式错误\",\"reason\":\"未使用指定编码格式\",\"resolution\":\"请使用UTF-8编码格式\"}}");
private WxPayOrderP generateWxPayOrderP(WxPayAccount payAccount, WxOrder order, WxPayOrder record,String openId,String appId,Date currentDate) throws Exception {
private WxPayOrderP generateWxPayOrderP(WxPayAccount payAccount, WxComposeOrder composeOrder,WxOrder order, WxPayOrder record,String openId,String appId,Date currentDate) throws Exception {
// 统一下单 普通商户模式 // 统一下单 普通商户模式
String noncestr = Utility.generate32UUID(); String noncestr = Utility.generate32UUID();
WxPayOrderP wxPayOrderP = new WxPayOrderP(); WxPayOrderP wxPayOrderP = new WxPayOrderP();
@@ -67,14 +68,30 @@ public class WxMiniAppPayAdapterService extends BaseWxPayAdapterService implemen
wxPayOrderP.setAppid(appId); wxPayOrderP.setAppid(appId);
wxPayOrderP.setMch_id(payAccount.getMchId()); wxPayOrderP.setMch_id(payAccount.getMchId());
wxPayOrderP.setNonce_str(noncestr); wxPayOrderP.setNonce_str(noncestr);
wxPayOrderP.setBody(order.getDetail());
if (null != composeOrder) {
wxPayOrderP.setBody("组合商品");
}else {
wxPayOrderP.setBody(order.getDetail());
}
wxPayOrderP.setOut_trade_no(record.getPayOrderNo()); wxPayOrderP.setOut_trade_no(record.getPayOrderNo());
wxPayOrderP.setTotal_fee(order.getPayment());
if (null != composeOrder) {
wxPayOrderP.setTotal_fee(composeOrder.getPayment());
}else {
wxPayOrderP.setTotal_fee(order.getPayment());
}
wxPayOrderP.setSpbill_create_ip(record.getIp()); // 终端IP wxPayOrderP.setSpbill_create_ip(record.getIp()); // 终端IP
wxPayOrderP.setGoods_tag(String.valueOf(order.getProductId()));
if (null != composeOrder) {
wxPayOrderP.setGoods_tag("组合商品");
}else {
wxPayOrderP.setGoods_tag(String.valueOf(order.getProductId()));
}
wxPayOrderP.setNotify_url(payAccount.getPayNotifyUrl()); wxPayOrderP.setNotify_url(payAccount.getPayNotifyUrl());
wxPayOrderP.setTrade_type(WxPay.TradeType.JSAPI.name()); // 终端类型 wxPayOrderP.setTrade_type(WxPay.TradeType.JSAPI.name()); // 终端类型
wxPayOrderP.setProduct_id(String.valueOf(order.getId())); // 订单ID
if (null != composeOrder) {
wxPayOrderP.setProduct_id(String.valueOf(composeOrder.getId())); // 订单ID
}else {
wxPayOrderP.setProduct_id(String.valueOf(order.getId()));
}
wxPayOrderP.setTime_start(Utility.getDataFormatStringYYYYMMDDHHmmss(currentDate)); wxPayOrderP.setTime_start(Utility.getDataFormatStringYYYYMMDDHHmmss(currentDate));
Date futureDate = new Date(); Date futureDate = new Date();
futureDate.setTime(currentDate.getTime() + 15 * 60 * 1000); futureDate.setTime(currentDate.getTime() + 15 * 60 * 1000);
@@ -133,7 +150,7 @@ public class WxMiniAppPayAdapterService extends BaseWxPayAdapterService implemen
private WxPayOrderSP generateWxPayOrderSP(WxPayAccount payAccount, WxOrder order, WxPayOrder record,WxAppinfo appInfo,String openId,String appId,Date currentDate,EnumPayShare isShare) throws Exception {
private WxPayOrderSP generateWxPayOrderSP(WxPayAccount payAccount, WxComposeOrder composeOrder,WxOrder order, WxPayOrder record,WxAppinfo appInfo,String openId,String appId,Date currentDate,EnumPayShare isShare) throws Exception {
String noncestr = Utility.generate32UUID(); String noncestr = Utility.generate32UUID();
WxPayOrderSP wxPayOrderSP = new WxPayOrderSP(); WxPayOrderSP wxPayOrderSP = new WxPayOrderSP();
wxPayOrderSP.setSub_openid(openId); wxPayOrderSP.setSub_openid(openId);
@@ -142,14 +159,27 @@ public class WxMiniAppPayAdapterService extends BaseWxPayAdapterService implemen
wxPayOrderSP.setSub_appid(appId); wxPayOrderSP.setSub_appid(appId);
wxPayOrderSP.setSub_mch_id(payAccount.getSubMchId()); wxPayOrderSP.setSub_mch_id(payAccount.getSubMchId());
wxPayOrderSP.setNonce_str(noncestr); wxPayOrderSP.setNonce_str(noncestr);
wxPayOrderSP.setBody(order.getDetail());
if (null != composeOrder) {
wxPayOrderSP.setBody("组合商品");
}else {
wxPayOrderSP.setBody(order.getDetail());
}
wxPayOrderSP.setOut_trade_no(record.getPayOrderNo()); wxPayOrderSP.setOut_trade_no(record.getPayOrderNo());
wxPayOrderSP.setTotal_fee(order.getPayment().toString());
if (null != composeOrder) {
wxPayOrderSP.setTotal_fee(composeOrder.getPayment().toString());
}else {
wxPayOrderSP.setTotal_fee(order.getPayment().toString());
}
wxPayOrderSP.setSpbill_create_ip(record.getIp()); // 终端IP wxPayOrderSP.setSpbill_create_ip(record.getIp()); // 终端IP
wxPayOrderSP.setGoods_tag(String.valueOf(order.getProductId())); // 券ID wxPayOrderSP.setGoods_tag(String.valueOf(order.getProductId())); // 券ID
wxPayOrderSP.setNotify_url(payAccount.getPayNotifyUrl()); wxPayOrderSP.setNotify_url(payAccount.getPayNotifyUrl());
wxPayOrderSP.setTrade_type(WxPay.TradeType.JSAPI.name()); // 终端类型 wxPayOrderSP.setTrade_type(WxPay.TradeType.JSAPI.name()); // 终端类型
wxPayOrderSP.setProduct_id(String.valueOf(order.getProductId())); // 券ID
if (null != composeOrder) {
wxPayOrderSP.setProduct_id("组合商品"); // 券ID
}else {
wxPayOrderSP.setProduct_id(String.valueOf(order.getProductId()));
}
wxPayOrderSP.setTime_start(Utility.getDataFormatStringYYYYMMDDHHmmss(currentDate)); wxPayOrderSP.setTime_start(Utility.getDataFormatStringYYYYMMDDHHmmss(currentDate));
Date futureDate = new Date(); Date futureDate = new Date();
futureDate.setTime(currentDate.getTime() + 15 * 60 * 1000); futureDate.setTime(currentDate.getTime() + 15 * 60 * 1000);
@@ -212,7 +242,7 @@ public class WxMiniAppPayAdapterService extends BaseWxPayAdapterService implemen
@Override @Override
public PayAdapterResult pay(WxPayAccount payAccount, WxOrder order, WxPayOrder record,EnumPayShare isShare,WxAppinfo appInfo,Date currentDate, PayExtraParam params) throws Exception {
public PayAdapterResult pay(WxPayAccount payAccount, WxComposeOrder composeOrder,WxOrder order, WxPayOrder record,EnumPayShare isShare,WxAppinfo appInfo,Date currentDate, PayExtraParam params) throws Exception {
if (null == params ) { if (null == params ) {
throw new MallinkException(ErrorCode.SYS_PARAMETER_NOT_NULL.getCode(),"openId为空"); throw new MallinkException(ErrorCode.SYS_PARAMETER_NOT_NULL.getCode(),"openId为空");
} }
@@ -222,7 +252,7 @@ public class WxMiniAppPayAdapterService extends BaseWxPayAdapterService implemen
} }
//普通商户模式 //普通商户模式
if (payAccount.getType() == EnumPayMode.MCH.getCode()) { if (payAccount.getType() == EnumPayMode.MCH.getCode()) {
WxPayOrderP wxPayOrderP = generateWxPayOrderP(payAccount,order,record,openId,appInfo.getAppId(),currentDate);
WxPayOrderP wxPayOrderP = generateWxPayOrderP(payAccount,composeOrder,order,record,openId,appInfo.getAppId(),currentDate);
String response = WxPay.pushOrder(BeanUtils.toStringMap(wxPayOrderP)); String response = WxPay.pushOrder(BeanUtils.toStringMap(wxPayOrderP));
log.info("pay order, wechat pushOrder, " + wxPayOrderP.toString() + ", response: " + response.toString()); log.info("pay order, wechat pushOrder, " + wxPayOrderP.toString() + ", response: " + response.toString());
Map<String, String> returnMap = WxPayment.xmlToMap(response); Map<String, String> returnMap = WxPayment.xmlToMap(response);
@@ -230,7 +260,7 @@ public class WxMiniAppPayAdapterService extends BaseWxPayAdapterService implemen
} else { } else {
// 统一下单 // 服务商模式 // 统一下单 // 服务商模式
WxPayOrderSP wxPayOrderSP = generateWxPayOrderSP(payAccount,order,record,appInfo,openId,appInfo.getAppId(),currentDate,isShare);
WxPayOrderSP wxPayOrderSP = generateWxPayOrderSP(payAccount,composeOrder,order,record,appInfo,openId,appInfo.getAppId(),currentDate,isShare);
String response = WxPay.pushOrder(BeanUtils.toStringMap(wxPayOrderSP)); String response = WxPay.pushOrder(BeanUtils.toStringMap(wxPayOrderSP));
log.info("pay order, wechat pushOrder, " + wxPayOrderSP.toString() + ", response: " + response.toString()); log.info("pay order, wechat pushOrder, " + wxPayOrderSP.toString() + ", response: " + response.toString());
Map<String, String> returnMap = WxPayment.xmlToMap(response); Map<String, String> returnMap = WxPayment.xmlToMap(response);
@@ -239,9 +269,9 @@ public class WxMiniAppPayAdapterService extends BaseWxPayAdapterService implemen
} }


@Override @Override
public PayQueryAdapterResult queryPayStatus(WxPayOrder oldRecord, WxOrder order, WxAppinfo appInfo,
public PayQueryAdapterResult queryPayStatus(WxPayOrder oldRecord, WxAppinfo appInfo,
WxPayAccount payAccount) throws Exception { WxPayAccount payAccount) throws Exception {
return super.queryPayStatus(oldRecord, order, appInfo, payAccount);
return super.queryPayStatus(oldRecord,appInfo, payAccount);
} }


@Override @Override
@@ -250,9 +280,9 @@ public class WxMiniAppPayAdapterService extends BaseWxPayAdapterService implemen
} }


@Override @Override
public int queryPayStatusCode(WxPayOrder oldRecord, WxOrder order, WxAppinfo appInfo, WxPayAccount payAccount)
public int queryPayStatusCode(WxPayOrder oldRecord, WxAppinfo appInfo, WxPayAccount payAccount)
throws Exception { throws Exception {
return super.queryPayStatusCode(oldRecord, order, appInfo, payAccount);
return super.queryPayStatusCode(oldRecord, appInfo, payAccount);
} }


@Override @Override


+ 20
- 11
mallinkService/src/main/java/com/iformall/service/pay/service/pay/wx/miniApp/maPay/WxMiniMaPayAdapterService.java View File

@@ -12,6 +12,7 @@ import com.iformall.common.IdWorker;
import com.iformall.domain.po.WxAppinfo; import com.iformall.domain.po.WxAppinfo;
import com.iformall.domain.po.WxCUser; import com.iformall.domain.po.WxCUser;
import com.iformall.domain.po.WxCUserBasicInfo; import com.iformall.domain.po.WxCUserBasicInfo;
import com.iformall.domain.po.WxComposeOrder;
import com.iformall.domain.po.WxMall; import com.iformall.domain.po.WxMall;
import com.iformall.domain.po.WxOrder; import com.iformall.domain.po.WxOrder;
import com.iformall.domain.po.WxPayAccount; import com.iformall.domain.po.WxPayAccount;
@@ -45,7 +46,7 @@ import me.chanjar.weixin.common.error.WxErrorException;
@Service @Service
public class WxMiniMaPayAdapterService extends BaseWxPayAdapterService implements CPassivePayService{ public class WxMiniMaPayAdapterService extends BaseWxPayAdapterService implements CPassivePayService{


private WxMicroPayOrderP generateWxMicroPayOrderP(WxPayAccount payAccount, WxOrder order, WxPayOrder record, EnumPayShare isShare,
private WxMicroPayOrderP generateWxMicroPayOrderP(WxPayAccount payAccount, WxComposeOrder composeOrder,WxOrder order, WxPayOrder record, EnumPayShare isShare,
WxAppinfo appInfo, Date currentDate,String bAppId,String bUserPhone) throws Exception { WxAppinfo appInfo, Date currentDate,String bAppId,String bUserPhone) throws Exception {
String noncestr = Utility.generate32UUID(); String noncestr = Utility.generate32UUID();
WxMicroPayOrderP wxPayOrderP = new WxMicroPayOrderP(); WxMicroPayOrderP wxPayOrderP = new WxMicroPayOrderP();
@@ -53,7 +54,11 @@ public class WxMiniMaPayAdapterService extends BaseWxPayAdapterService implement
wxPayOrderP.setMch_id(payAccount.getMchId()); wxPayOrderP.setMch_id(payAccount.getMchId());
wxPayOrderP.setDevice_info(bUserPhone); wxPayOrderP.setDevice_info(bUserPhone);
wxPayOrderP.setNonce_str(noncestr); wxPayOrderP.setNonce_str(noncestr);
wxPayOrderP.setBody(order.getDetail());
if (null != composeOrder) {
wxPayOrderP.setBody("组合商品");
}else {
wxPayOrderP.setBody(order.getDetail());
}
wxPayOrderP.setOut_trade_no(record.getPayOrderNo()); wxPayOrderP.setOut_trade_no(record.getPayOrderNo());
wxPayOrderP.setTotal_fee(record.getPayAmount()); wxPayOrderP.setTotal_fee(record.getPayAmount());
wxPayOrderP.setSpbill_create_ip(record.getIp()); // 终端IP wxPayOrderP.setSpbill_create_ip(record.getIp()); // 终端IP
@@ -99,7 +104,7 @@ public class WxMiniMaPayAdapterService extends BaseWxPayAdapterService implement
} }
private WxMicroPayOrderSP generateWxMicroPayOrderSP(WxPayAccount payAccount, WxOrder order, WxPayOrder record, EnumPayShare isShare,
private WxMicroPayOrderSP generateWxMicroPayOrderSP(WxPayAccount payAccount, WxComposeOrder composeOrder,WxOrder order,WxPayOrder record, EnumPayShare isShare,
WxAppinfo appInfo, Date currentDate,String bUserPhone) throws Exception { WxAppinfo appInfo, Date currentDate,String bUserPhone) throws Exception {
String noncestr = Utility.generate32UUID(); String noncestr = Utility.generate32UUID();
WxMicroPayOrderSP wxPayOrderSP = new WxMicroPayOrderSP(); WxMicroPayOrderSP wxPayOrderSP = new WxMicroPayOrderSP();
@@ -109,7 +114,11 @@ public class WxMiniMaPayAdapterService extends BaseWxPayAdapterService implement
wxPayOrderSP.setSub_mch_id(payAccount.getSubMchId()); wxPayOrderSP.setSub_mch_id(payAccount.getSubMchId());
wxPayOrderSP.setDevice_info(bUserPhone); wxPayOrderSP.setDevice_info(bUserPhone);
wxPayOrderSP.setNonce_str(noncestr); wxPayOrderSP.setNonce_str(noncestr);
wxPayOrderSP.setBody(order.getDetail());
if (null != composeOrder) {
wxPayOrderSP.setBody("组合商品");
}else {
wxPayOrderSP.setBody(order.getDetail());
}
wxPayOrderSP.setOut_trade_no(record.getPayOrderNo()); wxPayOrderSP.setOut_trade_no(record.getPayOrderNo());
wxPayOrderSP.setTotal_fee(record.getPayAmount()); wxPayOrderSP.setTotal_fee(record.getPayAmount());
wxPayOrderSP.setSpbill_create_ip(record.getIp()); wxPayOrderSP.setSpbill_create_ip(record.getIp());
@@ -161,7 +170,7 @@ public class WxMiniMaPayAdapterService extends BaseWxPayAdapterService implement
@Override @Override
public PayAdapterResult pay(WxPayAccount payAccount, WxOrder order, WxPayOrder record, EnumPayShare isShare,
public PayAdapterResult pay(WxPayAccount payAccount, WxComposeOrder composeOrder,WxOrder order, WxPayOrder record, EnumPayShare isShare,
WxAppinfo appInfo, Date currentDate, PayExtraParam params) throws Exception { WxAppinfo appInfo, Date currentDate, PayExtraParam params) throws Exception {
if (payAccount.getType() == EnumPayMode.MCH.getCode()) { if (payAccount.getType() == EnumPayMode.MCH.getCode()) {
// 扫码支付 普通商户模式 // 扫码支付 普通商户模式
@@ -174,7 +183,7 @@ public class WxMiniMaPayAdapterService extends BaseWxPayAdapterService implement
throw new MallinkException(ErrorCode.SYS_PARAMETER_NOT_NULL.getCode(),"bUserPhone 不能为空"); throw new MallinkException(ErrorCode.SYS_PARAMETER_NOT_NULL.getCode(),"bUserPhone 不能为空");
} }
WxMicroPayOrderP wxPayOrderP = generateWxMicroPayOrderP(payAccount, order, record, isShare, appInfo, currentDate, bAppId, bUserPhone);
WxMicroPayOrderP wxPayOrderP = generateWxMicroPayOrderP(payAccount, composeOrder,order, record, isShare, appInfo, currentDate, bAppId, bUserPhone);
String response = WxPay.micropay(BeanUtils.toStringMap(wxPayOrderP)); String response = WxPay.micropay(BeanUtils.toStringMap(wxPayOrderP));
log.info("pay order, wechat micropay, " + wxPayOrderP.toString() + ", response: " + response.toString()); log.info("pay order, wechat micropay, " + wxPayOrderP.toString() + ", response: " + response.toString());
Map<String, String> returnMap = WxPayment.xmlToMap(response); Map<String, String> returnMap = WxPayment.xmlToMap(response);
@@ -187,7 +196,7 @@ public class WxMiniMaPayAdapterService extends BaseWxPayAdapterService implement
if (StringUtils.isBlank(bUserPhone)) { if (StringUtils.isBlank(bUserPhone)) {
throw new MallinkException(ErrorCode.SYS_PARAMETER_NOT_NULL.getCode(),"bUserPhone 不能为空"); throw new MallinkException(ErrorCode.SYS_PARAMETER_NOT_NULL.getCode(),"bUserPhone 不能为空");
} }
WxMicroPayOrderSP wxPayOrderSP = generateWxMicroPayOrderSP(payAccount, order, record, isShare, appInfo, currentDate, bUserPhone);
WxMicroPayOrderSP wxPayOrderSP = generateWxMicroPayOrderSP(payAccount, composeOrder,order, record, isShare, appInfo, currentDate, bUserPhone);
String response = WxPay.micropay(BeanUtils.toStringMap(wxPayOrderSP)); String response = WxPay.micropay(BeanUtils.toStringMap(wxPayOrderSP));
log.info("pay order, wechat micropay, " + wxPayOrderSP.toString() + ", response: " + response.toString()); log.info("pay order, wechat micropay, " + wxPayOrderSP.toString() + ", response: " + response.toString());
Map<String, String> returnMap = WxPayment.xmlToMap(response); Map<String, String> returnMap = WxPayment.xmlToMap(response);
@@ -226,9 +235,9 @@ public class WxMiniMaPayAdapterService extends BaseWxPayAdapterService implement
} }


@Override @Override
public PayQueryAdapterResult queryPayStatus(WxPayOrder oldRecord, WxOrder order, WxAppinfo appInfo,
public PayQueryAdapterResult queryPayStatus(WxPayOrder oldRecord, WxAppinfo appInfo,
WxPayAccount payAccount) throws Exception { WxPayAccount payAccount) throws Exception {
return super.queryPayStatus(oldRecord, order, appInfo, payAccount);
return super.queryPayStatus(oldRecord,appInfo, payAccount);
} }


@Override @Override
@@ -237,9 +246,9 @@ public class WxMiniMaPayAdapterService extends BaseWxPayAdapterService implement
} }


@Override @Override
public int queryPayStatusCode(WxPayOrder oldRecord, WxOrder order, WxAppinfo appInfo, WxPayAccount payAccount)
public int queryPayStatusCode(WxPayOrder oldRecord, WxAppinfo appInfo, WxPayAccount payAccount)
throws Exception { throws Exception {
return super.queryPayStatusCode(oldRecord, order, appInfo, payAccount);
return super.queryPayStatusCode(oldRecord, appInfo, payAccount);
} }


@Override @Override


+ 8
- 95
mallinkService/src/main/resources/mapper/WxComposeOrderMapper.xml View File

@@ -6,16 +6,13 @@
<result column="tenant_id" jdbcType="VARCHAR" property="tenantId"/> <result column="tenant_id" jdbcType="VARCHAR" property="tenantId"/>
<result column="parent_tenant_id" jdbcType="VARCHAR" property="parentTenantId" /> <result column="parent_tenant_id" jdbcType="VARCHAR" property="parentTenantId" />
<result column="c_user_id" jdbcType="BIGINT" property="cUserId"/> <result column="c_user_id" jdbcType="BIGINT" property="cUserId"/>
<result column="payment_type" jdbcType="INTEGER" property="paymentType"/>
<result column="payment" jdbcType="INTEGER" property="payment"/> <result column="payment" jdbcType="INTEGER" property="payment"/>
<result column="payment_time" jdbcType="TIMESTAMP" property="paymentTime"/>
<result column="order_status" jdbcType="INTEGER" property="orderStatus"/>
<result column="create_date" jdbcType="TIMESTAMP" property="createDate"/> <result column="create_date" jdbcType="TIMESTAMP" property="createDate"/>
<result column="update_date" jdbcType="TIMESTAMP" property="updateDate"/> <result column="update_date" jdbcType="TIMESTAMP" property="updateDate"/>
</resultMap> </resultMap>


<sql id="allColumns"> <sql id="allColumns">
`id`,`tenant_id`,`parent_tenant_id`,`c_user_id`,`payment_type`,`payment`,`payment_time`,`order_status`,`create_date`,`update_date`
`id`,`tenant_id`,`parent_tenant_id`,`c_user_id`,`payment`,`create_date`,`update_date`
</sql> </sql>


<sql id="dynamicWhereConditions"> <sql id="dynamicWhereConditions">
@@ -36,29 +33,10 @@
and `c_user_id` = #{cUserId} and `c_user_id` = #{cUserId}
</if> </if>


<if test=" null != paymentType ">
and `payment_type` = #{paymentType}
</if>

<if test=" null != payment "> <if test=" null != payment ">
and `payment` = #{payment} and `payment` = #{payment}
</if> </if>


<if test=" null != paymentTime ">
and `payment_time` = #{paymentTime}
</if>

<if test=" null != orderStatus ">
and `order_status` = #{orderStatus}
</if>

<if test=" null != statusS ">
and `order_status` in
<foreach collection="statusS" index="index" item="sItem" open="(" separator="," close=")">
#{sItem}
</foreach>
</if>

<if test=" null != ids "> <if test=" null != ids ">
and id in and id in
<foreach collection="ids" index="index" item="idItem" open="(" separator="," close=")"> <foreach collection="ids" index="index" item="idItem" open="(" separator="," close=")">
@@ -69,88 +47,23 @@
</sql> </sql>


<select id="selectById" parameterType="java.util.HashMap" resultMap="BaseResultMap"> <select id="selectById" parameterType="java.util.HashMap" resultMap="BaseResultMap">
select <include refid="allColumns"/> from wx_order where id =#{id} and tenant_id=#{tenantId}
select <include refid="allColumns"/> from wx_compose_order where id =#{id} and tenant_id=#{tenantId}
</select> </select>


<select id="findList" parameterType="com.iformall.domain.po.WxOrder" resultMap="BaseResultMap">
<select id="findList" parameterType="com.iformall.domain.po.WxComposeOrder" resultMap="BaseResultMap">
select select
<include refid="allColumns"/> <include refid="allColumns"/>
from wx_order
from wx_compose_order
<include refid="dynamicWhereConditions"/> <include refid="dynamicWhereConditions"/>
</select> </select>


<select id="countList" parameterType="com.iformall.domain.po.WxOrder" resultType="java.lang.Integer">
select count(1) from wx_order
<select id="countList" parameterType="com.iformall.domain.po.WxComposeOrder" resultType="java.lang.Integer">
select count(1) from wx_compose_order
<include refid="dynamicWhereConditions"/> <include refid="dynamicWhereConditions"/>
</select> </select>

<select id="countCouponConditionType1" parameterType="com.iformall.domain.po.WxOrder" resultType="java.lang.Integer">
select count(*) from wx_order o,wx_coupon c
where o.product_id = c.id
and c.conditions is not null
/*and JSON_EXTRACT(c.conditions, '$.type') = 1*/
<if test=" null != cUserId ">
and o.c_user_id = #{cUserId}
</if>

<if test=" null != tenantId and '' != tenantId">
and o.`tenant_id` = #{tenantId}
</if>
<if test=" null != parentTenantId and '' != parentTenantId">
and o.`parent_tenant_id` = #{parentTenantId}
</if>

<if test=" null != type ">
and o.type = #{type}
</if>

<if test=" null != statusS ">
and o.order_status in
<foreach collection="statusS" index="index" item="sItem" open="(" separator="," close=")">
#{sItem}
</foreach>
</if>

</select>



<select id="selectDetailOfPress" parameterType="com.iformall.domain.po.WxOrder" resultMap="PressVoDetailResultMap">
select
<include refid="allOrderPressDetailColumns"/>
FROM wx_order o
left join wx_coupon c ON o.product_id = c.id
left join wx_coupon_order co on o.id = co.order_id
where o.product_id = c.id
<if test="cUserId != null">
and o.c_user_id = #{cUserId}
</if>
<if test=" null != tenantId and '' != tenantId">
and o.`tenant_id` = #{tenantId}
</if>
<if test=" null != parentTenantId and '' != parentTenantId">
and o.`parent_tenant_id` = #{parentTenantId}
</if>
<if test="id != null">
and o.id = #{id}
</if>

</select>
<update id="updateStatusByOrderGroupId" parameterType="com.iformall.domain.po.WxOrder">
update wx_order set order_status=#{orderStatus}
where order_group_id=#{orderGroupId} and order_status=10
<if test=" null != tenantId and '' != tenantId">
and `tenant_id` = #{tenantId}
</if>
<if test=" null != parentTenantId and '' != parentTenantId">
and `parent_tenant_id` = #{parentTenantId}
</if>
</update>
<update id="updateOrderStatusForGroup" parameterType="java.util.HashMap">
update wx_order set order_status=12 where `type`=0 and tenant_id = #{tenantId} and order_status in(10,15) and now()>press_end_date
<update id="updateCUserId" parameterType="com.iformall.domain.po.WxComposeOrder">
update wx_compose_order set `c_user_id` = #{cUserId} where id =#{id} and tenant_id=#{tenantId}
</update> </update>


</mapper> </mapper>

+ 14
- 0
mallinkService/src/main/resources/mapper/WxOrderMapper.xml View File

@@ -1002,5 +1002,19 @@
<update id="updateOrderStatusForGroup" parameterType="java.util.HashMap"> <update id="updateOrderStatusForGroup" parameterType="java.util.HashMap">
update wx_order set order_status=12 where `type`=0 and tenant_id = #{tenantId} and order_status in(10,15) and now()>press_end_date update wx_order set order_status=12 where `type`=0 and tenant_id = #{tenantId} and order_status in(10,15) and now()>press_end_date
</update> </update>
<update id="updateCUserId" parameterType="com.iformall.domain.po.WxOrder">
update wx_order set c_user_id= #{cUserId} where tenant_id = #{tenantId}
<if test=" null != id ">
and id = #{id}
</if>
<if test=" null != ids ">
and id in
<foreach collection="ids" index="index" item="idItem" open="(" separator="," close=")">
#{idItem}
</foreach>
</if>
</update>


</mapper> </mapper>

+ 6
- 1
mallinkService/src/main/resources/mapper/WxPayOrderMapper.xml View File

@@ -29,6 +29,7 @@
<result column="pos_payment_type" jdbcType="INTEGER" property="posPaymentType"/> <result column="pos_payment_type" jdbcType="INTEGER" property="posPaymentType"/>
<result column="pos_pay_order_no" jdbcType="INTEGER" property="posPayOrderNo"/> <result column="pos_pay_order_no" jdbcType="INTEGER" property="posPayOrderNo"/>
<result column="pos_pay_des" jdbcType="INTEGER" property="posPayDes"/> <result column="pos_pay_des" jdbcType="INTEGER" property="posPayDes"/>
<result column="compose_order" jdbcType="INTEGER" property="composeOrder"/>
</resultMap> </resultMap>


<sql id="allColumns"> <sql id="allColumns">
@@ -36,7 +37,7 @@
`auth_code`,`ip`,`pay_amount`,`pay_time_start`,`pay_time_end`, `auth_code`,`ip`,`pay_amount`,`pay_time_start`,`pay_time_end`,
`prepay_id`,`transaction_id`,`pay_vendor`,`pay_order_no`, `prepay_id`,`transaction_id`,`pay_vendor`,`pay_order_no`,
`pay_order_status`,`share`,`share_amount`,`rate_amount`,`fail_reason`, `pay_order_status`,`share`,`share_amount`,`rate_amount`,`fail_reason`,
`pos_pay_order_id`,`pos_pay_order_time`,`pos_payment_type`,`pos_pay_order_no`,`pos_pay_des`
`pos_pay_order_id`,`pos_pay_order_time`,`pos_payment_type`,`pos_pay_order_no`,`pos_pay_des`,`compose_order`
</sql> </sql>


<sql id="dynamicWhereConditions"> <sql id="dynamicWhereConditions">
@@ -133,6 +134,10 @@
<if test=" null != posPayOrderNo "> <if test=" null != posPayOrderNo ">
and `pos_pay_order_no` = #{posPayOrderNo} and `pos_pay_order_no` = #{posPayOrderNo}
</if> </if>
<if test=" null != composeOrder ">
and `compose_order` = #{composeOrder}
</if>
<if test=" null != ids "> <if test=" null != ids ">
and id in and id in
<foreach collection="ids" index="index" item="idItem" open="(" separator="," close=")"> <foreach collection="ids" index="index" item="idItem" open="(" separator="," close=")">


Loading…
Cancel
Save