Skip to content

O
order-group
Commit df89149b by shuhu.hou@freemud.cn
Options

Merge branch 'feature/20200423_订单oms逆向流程'

parents f8f5ed8f 91070139
Showing with 1569 additions and 358 deletions
assortment-ordercenter-sdk/src/main/java/com/freemud/sdk/api/assortment/order/adapter/OrderSdkAdapter.java
......@@ -86,6 +86,46 @@ public class OrderSdkAdapter {
return orderDeliveryRequest;
}
/**
* 拒单request
* @param operator
* @param reason
* @param refundStatus
* @param refundId
* @param orderBean
* @return
*/
public CancelOrderRequest getCancelOrderRequest(String operator,String reason,PayRefundStatus refundStatus,String refundId,QueryOrdersResponse.DataBean.OrderBean orderBean){
CancelOrderRequest var1 = new CancelOrderRequest();
var1.setPartnerId(orderBean.getCompanyId());
var1.setOrderId(orderBean.getOid());
var1.setReason(reason);
if (orderBean.getStatus() == 1) {
var1.setAfterSalesType(AfterSalesType.PARTNER_REJECT);
} else {
var1.setAfterSalesType(AfterSalesType.SYSTEM_CANCEL);
}
var1.setTrackingNo(UUID.randomUUID().toString());
var1.setRefundSerialNo(refundId);
// 退款状态为退款中：event为5，默认做【创建】+【同意并退货完成】，售后单状态【已退货】
//退款状态为退款完成：event为4，默认做【创建】+【同意并退款完成】，售后单状态为【完成】
var1.setCreateEvent(PayRefundStatus.SUCCESS.equals(refundStatus) ? AfterSalesOrderCreateEventEnum.REFUND_COMPLETE.getCreateEvent() : AfterSalesOrderCreateEventEnum.RETURN_COMPLETE.getCreateEvent());
var1.setOperator(operator);
return var1;
}
public CancelOrderRequest getRejectRefundRequest(String operator,String reason,QueryOrdersResponse.DataBean.OrderBean orderBean){
CancelOrderRequest var1 = new CancelOrderRequest();
var1.setOrderId(orderBean.getOid());
var1.setReason(reason);
var1.setPartnerId(orderBean.getCompanyId());
if (orderBean.getRefundList() != null && orderBean.getRefundList().size() != 0) {
//新订单服务需要售后单code
var1.setAfterSalesCode(orderBean.getRefundList().get(orderBean.getRefundList().size() - 1).getRid());
}
var1.setOperator(operator);
return var1;
}
public CancelOrderRequest convent2CancelOrderRequest(String orderId, String partnerId, AfterSalesType afterSalesType,
String reason, String trackingNo, Long refund_id) {
CancelOrderRequest cancelOrderRequest = new CancelOrderRequest();
......@@ -103,6 +143,21 @@ public class OrderSdkAdapter {
return cancelOrderRequest;
}
public BaseQueryOrderRequest getRefundAgreeRequest(String refund_id,String reason,String operator, QueryOrdersResponse.DataBean.OrderBean orderBean){
BaseQueryOrderRequest var1 = new BaseQueryOrderRequest();
var1.setPartnerId(orderBean.getCompanyId());
var1.setOrderId(orderBean.getOid());
var1.setTrackingNo(LogThreadLocal.getTrackingNo());
var1.setRefundSerialNo(refund_id);
var1.setReason(reason);
var1.setOperator(operator);
if (orderBean.getRefundList() != null && orderBean.getRefundList().size() != 0) {
//新订单服务需要售后单code
var1.setAfterSalesCode(orderBean.getRefundList().get(orderBean.getRefundList().size() - 1).getRid());
}
return var1;
}
/**
* 老订单服务创建订单对象 转换成 新订单服务请求对象
*/
......
assortment-ordercenter-sdk/src/main/java/com/freemud/sdk/api/assortment/order/enums/AfterSalesOrderCreateEventEnum.java 0 → 100644
package com.freemud.sdk.api.assortment.order.enums;
/**
* All rights Reserved, Designed By www.freemud.cn
*
* @version V1.0
* @Title: AfterSalesCreateEvent
* @Package com.freemud.application.sdk.api.ordercenter.enums
* @Description:
* @author: jiaxin.liu
* @date: 2019/5/29 14:04
* @Copyright: 2019 www.freemud.cn Inc. All rights reserved.
* 注意：本内容仅限于上海非码科技内部传阅，禁止外泄以及用于其他的商业目
*/
public enum AfterSalesOrderCreateEventEnum {
AGREE_AFTER_SALES(1,"同意售后"),
REFUND_COMPLETE(4,"退款完成"),
RETURN_COMPLETE(5,"退货完成");
private Integer createEvent;
private String desc;
AfterSalesOrderCreateEventEnum(Integer createEvent, String desc){
this.createEvent = createEvent;
this.desc = desc;
}
public Integer getCreateEvent() {
return createEvent;
}
public void setCreateEvent(Integer createEvent) {
this.createEvent = createEvent;
}
public String getDesc() {
return desc;
}
public void setDesc(String desc) {
this.desc = desc;
}
}
assortment-ordercenter-sdk/src/main/java/com/freemud/sdk/api/assortment/order/enums/PayRefundStatus.java 0 → 100644
package com.freemud.sdk.api.assortment.order.enums;
/**
* All rights Reserved, Designed By www.freemud.cn
*
* @version V1.0
* @Title: PayRefundStatus
* @Package cn.freemud.enums
* @Description:
* @author: jiaxin.liu
* @date: 2019/5/27 15:09
* @Copyright: 2019 www.freemud.cn Inc. All rights reserved.
* 注意：本内容仅限于上海非码科技内部传阅，禁止外泄以及用于其他的商业目
*/
public enum PayRefundStatus {
SUCCESS(1,"退款成功"),
FAIL(2,"退款失败"),
RUNNING(4,"退款中");
private Integer code;
private String desc;
PayRefundStatus(Integer code, String desc) {
this.code = code;
this.desc = desc;
}
public static PayRefundStatus getByCode(Integer code) {
if (code == null) {
return null;
}
for (PayRefundStatus payStatus : values()) {
if (payStatus.getCode().equals(code)) {
return payStatus;
}
}
return null;
}
public Integer getCode() {
return code;
}
public void setCode(Integer code) {
this.code = code;
}
public String getDesc() {
return desc;
}
public void setDesc(String desc) {
this.desc = desc;
}
}
order-application-service/pom.xml
......@@ -30,7 +30,7 @@
<dependency>
<groupId>com.freemud.application.service.sdk</groupId>
<artifactId>structure-center-sdk</artifactId>
<version>1.2.1-SNAPSHOT</version>
<version>1.2.2.RELEASE</version>
</dependency>
<dependency>
<artifactId>couponcenter-sdk</artifactId>
......
order-management/pom.xml
......@@ -38,6 +38,12 @@
<scope>provided</scope>
</dependency>
<dependency>
<artifactId>assortment-data-manager</artifactId>
<groupId>com.freemud.sdk.api.assortment</groupId>
<version>4.3.0.RELEASE</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>com.freemud.application.service.sdk</groupId>
<artifactId>takeawaycenter-sdk</artifactId>
<version>1.2.3-SNAPSHOT</version>
......@@ -50,9 +56,15 @@
<scope>provided</scope>
</dependency>
<dependency>
<groupId>com.freemud.sdk.api.assortment</groupId>
<artifactId>assortment-payment-sdk</artifactId>
<version>2.4.1-SNAPSHOT</version>
<scope>provided</scope>
</dependency>
<dependency>
<artifactId>structure-center-sdk</artifactId>
<groupId>com.freemud.application.service.sdk</groupId>
<version>1.2-SNAPSHOT</version>
<version>1.2.2.RELEASE</version>
<scope>provided</scope>
</dependency>
<dependency>
......
order-management/src/main/java/cn/freemud/management/adapter/MessagePushAdapter.java
package cn.freemud.management.adapter;
import cn.freemud.management.enums.MessageCenterCmdType;
import cn.freemud.management.enums.OperateType;
import com.alibaba.fastjson.JSONObject;
import com.freemud.application.sdk.api.ordercenter.request.OrderExtInfoDto;
......@@ -36,6 +37,32 @@ public class MessagePushAdapter {
return pushMessageNoticeDto;
}
public PushMessageNoticeDto convent2PushMessageNoticeDto1(QueryOrdersResponse.DataBean.OrderBean order) {
PushMessageNoticeDto pushMessageNoticeDto = new PushMessageNoticeDto();
pushMessageNoticeDto.setPartnerId(order.getCompanyId());
pushMessageNoticeDto.setStoreId(order.getShopId());
pushMessageNoticeDto.setTargetId(order.getUserId());
pushMessageNoticeDto.setTargetType(2);
pushMessageNoticeDto.setCmd(MessageCenterCmdType.JIEDAN_DAYIN_TIXING.getCmd());
pushMessageNoticeDto.setTtl(0);
pushMessageNoticeDto.setVer("1");
PushMessageNoticeDto.Message message = new PushMessageNoticeDto.Message();
message.setType(1);
PushMessageNoticeDto.Message.Content content = new PushMessageNoticeDto.Message.Content();
content.setOid(order.getOid());
OrderExtInfoDto extInfo = JSONObject.parseObject(order.getExtInfo(), OrderExtInfoDto.class);
if (extInfo != null) {
content.setFromAppId(extInfo.getFromAppId());
}
//content.setDeliveryStatus(deliveryStatus);
content.setPickUpGoodsNo(order.getOtherCode());
content.setUserId(order.getUserId());
content.setOrderState(order.getStatus());
message.setContent(content);
pushMessageNoticeDto.setData(JSONObject.toJSONString(message));
return pushMessageNoticeDto;
}
public MessageTemplateRequest<MessagePushOrderTemplateRequest> convent2MessageTemplateRequest(QueryOrdersResponse.DataBean.OrderBean order, String reason, OperateType opType) {
OrderExtInfoDto extInfo = JSONObject.parseObject(order.getExtInfo(), OrderExtInfoDto.class);
if (extInfo==null){
......
order-management/src/main/java/cn/freemud/management/adapter/PaymentSdkAdapter.java 0 → 100644
package cn.freemud.management.adapter;
import com.alibaba.fastjson.JSONObject;
import com.freemud.application.sdk.api.base.SDKCommonBaseContextWare;
import com.freemud.application.sdk.api.ordercenter.request.OrderExtInfoDto;
import com.freemud.sdk.api.assortment.order.response.order.QueryOrdersResponse;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
/**
* All rights Reserved, Designed By www.freemud.cn
*
* @version V1.0
* @Title: PaymentSdkAdapter
* @Package cn.freemud.management.adapter
* @Description:
* @author: shuhu.hou
* @date: 2020/4/24 11:45
* @Copyright: 2020 www.freemud.cn Inc. All rights reserved.
* 注意：本内容仅限于上海非码科技内部传阅，禁止外泄以及用于其他的商业目
*/
@Component
public class PaymentSdkAdapter {
@Value("${saas.refund.notify.callback}")
private String refundNotifyCallback;
public com.freemud.sdk.api.assortment.payment.request.OrderRefundRequest getOrderRefundRequest(QueryOrdersResponse.DataBean.OrderBean orderBean) {
com.freemud.sdk.api.assortment.payment.request.OrderRefundRequest refundRequestDTO = new com.freemud.sdk.api.assortment.payment.request.OrderRefundRequest();
refundRequestDTO.setPartnerId(orderBean.getCompanyId());
refundRequestDTO.setStoreId(orderBean.getShopId());
refundRequestDTO.setOrgTransId(orderBean.getOid());
refundRequestDTO.setRefundAmount(orderBean.getAmount().longValue());
refundRequestDTO.setNotifyUrl(refundNotifyCallback);
OrderExtInfoDto orderExtInfoDto = JSONObject.parseObject(orderBean.getExtInfo(), OrderExtInfoDto.class);
refundRequestDTO.setAppId(orderExtInfoDto.getAppid());
refundRequestDTO.setOrgPayFmId(orderBean.getPayVoucher());
refundRequestDTO.setOpenid(orderExtInfoDto.getOpenid());
refundRequestDTO.setRefundId(getRefundSerialNo());
return refundRequestDTO;
}
private Long getRefundSerialNo() {
return System.currentTimeMillis() + (int) (Math.random() * 9000) + 1000;
}
}
order-management/src/main/java/cn/freemud/management/adapter/WaimaiSdkAdapter.java
package cn.freemud.management.adapter;
import cn.freemud.management.entities.dto.request.order.OrderManagerRequest;
import com.freemud.application.sdk.api.takeaway.request.order.BaseOrderRequest;
import com.freemud.application.sdk.api.takeaway.request.order.OrderSendOutRequest;
import com.freemud.application.sdk.api.takeaway.request.order.PlatformOrderRequest;
import com.freemud.application.sdk.api.takeaway.request.order.*;
import com.freemud.sdk.api.assortment.order.response.order.QueryOrdersResponse;
import org.apache.commons.lang.StringUtils;
import org.springframework.stereotype.Component;
......@@ -71,5 +69,46 @@ public class WaimaiSdkAdapter {
return arriveReq;
}
/**
* 拒单
* @param request
* @param orderBean
* @return
*/
public PartnerCancelRequest getPartnerCancelRequest(OrderManagerRequest request, QueryOrdersResponse.DataBean.OrderBean orderBean){
PartnerCancelRequest cancelRequest = new PartnerCancelRequest();
cancelRequest.setPlatformOrderId(orderBean.getCustomerOrder());
cancelRequest.setOperator(request.getOperator());
cancelRequest.setType(request.getReason_code() == null ? 11 : request.getReason_code());
cancelRequest.setReason(request.getReason());
cancelRequest.setShopId(request.getStoreId());
cancelRequest.setOrderId(request.getOrderId());
cancelRequest.setChannel(orderBean.getSource());
cancelRequest.setCompanyId(request.getPartnerId());
return cancelRequest;
}
/**
* 拒绝或同意退款
* @param request
* @param orderBean
* @param isAgree true:同意退款，false:拒绝退款
* @return
*/
public AgreeOrderRequest getAgreeOrderRequest(OrderManagerRequest request, QueryOrdersResponse.DataBean.OrderBean orderBean,boolean isAgree){
AgreeOrderRequest agreeOrderRequest = new AgreeOrderRequest();
agreeOrderRequest.setPlatformOrderId(orderBean.getCustomerOrder());
agreeOrderRequest.setChannel( orderBean.getSource() );
agreeOrderRequest.setCompanyId(request.getPartnerId());
agreeOrderRequest.setOrderId(orderBean.getOid());
agreeOrderRequest.setShopId(request.getStoreId());
agreeOrderRequest.setOperator(request.getOperator());
agreeOrderRequest.setReason(request.getReason());
agreeOrderRequest.setAfterSalesCode(orderBean.getRefundList().get(0).getRid());
agreeOrderRequest.setAgree(isAgree);
return agreeOrderRequest;
}
}
order-management/src/main/java/cn/freemud/management/controller/OrderManagerController.java
......@@ -55,6 +55,10 @@ public class OrderManagerController {
return orderManagerAdapter.orderAffirm(request,null);
case ORDER_REJECT:
return orderManagerAdapter.orderReject(request);
case ORDER_AGREE_REFUND:
return orderManagerAdapter.orderAgreeRefund(request);
case ORDER_REJECT_REFUND:
return orderManagerAdapter.orderRejectRefund(request);
default:
return ResponseUtil.error(ResponseResult.ORDER_OPERATE_TYPE_NOT_VALIDATE);
}
......
order-management/src/main/java/cn/freemud/management/entities/dto/request/order/OrderManagerRequest.java
......@@ -25,10 +25,19 @@ public class OrderManagerRequest {
@NotEmpty(message = "订单号不允许为nul")
private String orderId;
/**
* 退款原因
*/
@Size(max=50,message = "原因不能超过50个字符")
private String reason;
/**
* 退款原因code
* 用于平台外卖（美团、饿了么）
*/
private Integer reason_code;
/**
* 订单操作类型
* @see OperateType
*/
......
order-management/src/main/java/cn/freemud/management/entities/dto/response/pay/PayRefundResponse.java 0 → 100644
package cn.freemud.management.entities.dto.response.pay;
import com.freemud.sdk.api.assortment.order.enums.PayRefundStatus;
import lombok.Data;
/**
* All rights Reserved, Designed By www.freemud.cn
*
* @version V1.0
* @Title: PayRefundResponse
* @Package cn.freemud.management.entities.dto.response.pay
* @Description:
* @author: shuhu.hou
* @date: 2020/4/24 13:46
* @Copyright: 2020 www.freemud.cn Inc. All rights reserved.
* 注意：本内容仅限于上海非码科技内部传阅，禁止外泄以及用于其他的商业目
*/
@Data
public class PayRefundResponse {
/**
* 支付退款状态
*/
private PayRefundStatus payRefundStatus;
/**
* 退款序列号
*/
private String refundId;
}
order-management/src/main/java/cn/freemud/management/entities/dto/response/pay/RefundConfig.java 0 → 100644
package cn.freemud.management.entities.dto.response.pay;
import lombok.Data;
/**
* All rights Reserved, Designed By www.freemud.cn
*
* @version V1.0
* @Title: RefundConfig
* @Package cn.freemud.management.entities.dto.response.pay
* @Description:
* @author: shuhu.hou
* @date: 2020/5/7 17:18
* @Copyright: 2020 www.freemud.cn Inc. All rights reserved.
* 注意：本内容仅限于上海非码科技内部传阅，禁止外泄以及用于其他的商业目
*/
@Data
public class RefundConfig {
/**
* 是否退配送费
*/
private boolean isRefundDeliveryFee;
/**
* 订单是否支持退款
*/
private boolean isCanRefund;
public RefundConfig(){
}
public RefundConfig(boolean isCanRefund, boolean isRefundDeliveryFee){
this.isCanRefund = isCanRefund;
this.isRefundDeliveryFee=isRefundDeliveryFee;
}
}
order-management/src/main/java/cn/freemud/management/enums/DeliveryStatus.java
......@@ -3,6 +3,7 @@ package cn.freemud.management.enums;
import com.google.common.collect.Lists;
import java.util.List;
import java.util.Objects;
/**
* All rights Reserved, Designed By www.freemud.cn
......@@ -61,6 +62,15 @@ public enum DeliveryStatus {
}
return null;
}
public static String getDescByCode(int code) {
DeliveryStatus[] DeliveryStatues = values();
for (DeliveryStatus deliveryStatus : DeliveryStatues) {
if (Objects.equals(deliveryStatus.getCode(), code)) {
return deliveryStatus.getDesc();
}
}
return null;
}
public static boolean checkDeliveryStatueForPlatform(int status) {
DeliveryStatus deliveryStatus = DeliveryStatus.getDeliveryStatusByCode(status);
......
order-management/src/main/java/cn/freemud/management/enums/OrderRefundEnum.java 0 → 100644
package cn.freemud.management.enums;
/**
* All rights Reserved, Designed By www.freemud.cn
*
* @version V1.0
* @Title: OrderRefundEnum
* @Package cn.freemud.constant
* @Description:
* @author: bowen.hu
* @date: 2019-09-17 10:46
* @Copyright: 2019 www.freemud.cn Inc. All rights reserved.
* 注意：本内容仅限于上海非码科技内部传阅，禁止外泄以及用于其他的商业目的
*/
public enum OrderRefundEnum {
ORDER_REFUND("orderRefund", "已完成订单是否允许退款"),
REFUND_DATA_RANGE("refundDateRange", "退款允许日期"),
TAKEORDER_REFUND("takeOrderRefund", "未接单是否支持退款"),
RECEIPTORDER_REFUND("receiptOrderRefund", "已接单是否支持退款"),
COMPLETEMAKEORDER_REFUND("completeMakeOrderRefund", "制作完成是否支持退款"),
REFUND_DELIVERY_FEE_ENABLE("refundShippingFee","商家同意退款时是否退配送费");
private String keyValue;
private String message;
OrderRefundEnum(String keyValue, String message) {
this.keyValue = keyValue;
this.message = message;
}
public String getKeyValue() {
return keyValue;
}
public String getMessage() {
return message;
}
}
order-management/src/main/java/cn/freemud/management/enums/ResponseResult.java
......@@ -59,6 +59,7 @@ public enum ResponseResult {
STORE_NOT_TABLE_INFO("43012","查询桌号失败"),
STORE_DISCONTENT_DELIVERY_FEE("43013","不满足起送金额"),
STORE_BIND_MALL_NOT_FOUND("43014","商城门店存在"),
STORE_INFO_NOT_FOUND("43015","门店信息不存在"),
/**
* 购物车状态码
......@@ -152,10 +153,24 @@ public enum ResponseResult {
DONE_FAIL_NOT_ACCEPT("45069","订单不是接单状态，不能制作"),
DONE_FAIL_REPETITION("45070","重复操作，订单已送出"),
DONE_ORDER_FAIL("45071", "制作完成更改作态失败"),
REJECT_FAIL_REPETITION("45072", "重复操作，订单已拒单"),
REJECT_FAIL_ORDER_IS_DELIVERY("45072", "配送中，不能拒单"),
REJECT_FAIL_ORDER_IS_COMPLETE("45073", "订单已完成，不能拒单"),
REJECT_FAIL_ORDER_IS_NOT_NEW("45074", "不是新订单，不能拒单"),
REJECT_ORDER_FAIL("45075", "拒单失败"),
AGREE_REFUND_ORDER_FAIL("45076", "同意退款失败"),
ORDER_REFUND_NOT_APPLY("45077","用户未申请退款"),
ORDER_HAD_AFFIRM_CAN_NOT_REFUND("45078","当前订单不允许退款，请前往B端后台设置"),
ORDER_REJECT_REFUND_REPETITION("45079","重复操作，订单已拒绝退款"),
ORDER_REJECT_REFUND_STATUS_NOT("45080","订单不是申请退款中，不能操作"),
ORDER_REJECT_REFUND_STATUS_END("45081","订单未接单或者已取消，不能操作"),
REJECT_REFUND_ORDER_FAIL("45082", "拒绝退款失败"),
/**
* 支付
*/
PAY_BACKEND_CONFIG_ERROR("58003", "支付交易异常"),
REFUND_EXCEPTION("58004", "支付退款异常"),
REFUND_FAIL("58005", "支付退款失败"),
/**
* 优惠券活动
*/
......
order-management/src/main/java/cn/freemud/management/intercept/DeliveryServiceException.java 0 → 100644
package cn.freemud.management.intercept;
import cn.freemud.management.enums.ResponseResult;
import com.freemud.application.sdk.api.exception.IgnoreErrorAnnotation;
/**
* All rights Reserved, Designed By www.freemud.cn
*
* @version V1.0
* @Title: OrderServiceException
* @Package cn.freemud.management.intercept
* @Description:
* @author: shuhu.hou
* @date: 2020/4/23 11:37
* @Copyright: 2020 www.freemud.cn Inc. All rights reserved.
* 注意：本内容仅限于上海非码科技内部传阅，禁止外泄以及用于其他的商业目
*/
@IgnoreErrorAnnotation
public class DeliveryServiceException extends RuntimeException {
private ResponseResult result;
private String message;
public DeliveryServiceException(ResponseResult result) {
this.result = result;
this.message = result.getMessage();
}
public DeliveryServiceException(ResponseResult result, String message) {
this.result = result;
this.message = message;
}
public ResponseResult getResult() {
return result;
}
public void setResult(ResponseResult result) {
this.result = result;
}
@Override
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
}
\ No newline at end of file
order-management/src/main/java/cn/freemud/management/intercept/OrderExceptionHandler.java
......@@ -30,4 +30,16 @@ public class OrderExceptionHandler {
public BaseResponse bindException(OrderServiceException e) {
return ResponseUtil.error(e.getResult());
}
@ExceptionHandler(PaymentServiceException.class)
@ResponseStatus(HttpStatus.OK)
public BaseResponse bindException(PaymentServiceException e) {
return ResponseUtil.error(e.getResult().getCode(),e.getMessage());
}
@ExceptionHandler(DeliveryServiceException.class)
@ResponseStatus(HttpStatus.OK)
public BaseResponse bindException(DeliveryServiceException e) {
return ResponseUtil.error(e.getResult().getCode(),e.getMessage());
}
}
\ No newline at end of file
order-management/src/main/java/cn/freemud/management/intercept/PaymentServiceException.java 0 → 100644
package cn.freemud.management.intercept;
import cn.freemud.management.enums.ResponseResult;
import com.freemud.application.sdk.api.exception.IgnoreErrorAnnotation;
/**
* All rights Reserved, Designed By www.freemud.cn
*
* @version V1.0
* @Title: OrderServiceException
* @Package cn.freemud.management.intercept
* @Description:
* @author: shuhu.hou
* @date: 2020/4/23 11:37
* @Copyright: 2020 www.freemud.cn Inc. All rights reserved.
* 注意：本内容仅限于上海非码科技内部传阅，禁止外泄以及用于其他的商业目
*/
@IgnoreErrorAnnotation
public class PaymentServiceException extends RuntimeException {
private ResponseResult result;
private String message;
public PaymentServiceException(ResponseResult result) {
this.result = result;
this.message = result.getMessage();
}
public PaymentServiceException(ResponseResult result, String message) {
this.result = result;
this.message = message;
}
public ResponseResult getResult() {
return result;
}
public void setResult(ResponseResult result) {
this.result = result;
}
@Override
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
}
\ No newline at end of file
order-management/src/main/java/cn/freemud/management/service/OrderBaseService.java
......@@ -5,8 +5,10 @@ import cn.freemud.management.enums.DeliveryStatus;
import cn.freemud.management.enums.MessageCenterCmdType;
import cn.freemud.management.enums.OperateType;
import cn.freemud.management.enums.OrderSource;
import com.alibaba.fastjson.JSONObject;
import com.freemud.application.sdk.api.log.ErrorLog;
import com.freemud.application.sdk.api.log.LogThreadLocal;
import com.freemud.application.sdk.api.ordercenter.request.OrderExtInfoDto;
import com.freemud.application.sdk.api.structure.request.PushMessageNoticeDto;
import com.freemud.application.sdk.api.structure.service.MessageCenterClient;
import com.freemud.sdk.api.assortment.message.request.MessagePushOrderTemplateRequest;
......@@ -55,7 +57,7 @@ public class OrderBaseService {
//发送消息到pos消息中心
PushMessageNoticeDto pushMessageNoticeDto1 = null;
try {
pushMessageNoticeDto1 = messagePushAdapter.convent2PushMessageNoticeDto(2, orderBean.getCompanyId(), orderBean.getShopId(), null, orderBean.getOid(), null, MessageCenterCmdType.JIEDAN_DAYIN_TIXING.getCmd());
pushMessageNoticeDto1 = messagePushAdapter.convent2PushMessageNoticeDto1(orderBean);
messageCenterClient.createMessage(pushMessageNoticeDto1, LogThreadLocal.getTrackingNo());
} catch (Exception e) {
ErrorLog.printErrorLog("sendMessageCenterError", "", pushMessageNoticeDto1, e);
......
order-management/src/main/java/cn/freemud/management/service/OrderManagerService.java
......@@ -42,4 +42,29 @@ public interface OrderManagerService {
*/
BaseResponse<OrderManagerResponse> orderAffirm(OrderManagerRequest request, QueryOrdersResponse.DataBean.OrderBean orderBean);
/**
* 拒单
* @param request
* @param orderBean
* @return
*/
BaseResponse<OrderManagerResponse> orderReject(OrderManagerRequest request, QueryOrdersResponse.DataBean.OrderBean orderBean);
/**
* 同意退款
* @param request
* @param orderBean
* @return
*/
BaseResponse<OrderManagerResponse> orderAgreeRefund(OrderManagerRequest request, QueryOrdersResponse.DataBean.OrderBean orderBean);
/**
* 拒绝退款
* @param request
* @param orderBean
* @return
*/
BaseResponse<OrderManagerResponse> orderRejectRefund(OrderManagerRequest request, QueryOrdersResponse.DataBean.OrderBean orderBean);
}
order-management/src/main/java/cn/freemud/management/service/adapter/OrderManagerAdapter.java
......@@ -8,9 +8,8 @@ import cn.freemud.management.enums.OrderStatus;
import cn.freemud.management.enums.RefundStatus;
import cn.freemud.management.enums.ResponseResult;
import cn.freemud.management.service.OrderBaseService;
import cn.freemud.management.service.impl.OrderVerifyService;
import cn.freemud.management.service.handle.OrderVerifyHandle;
import cn.freemud.management.util.ResponseUtil;
import com.freemud.application.sdk.api.ordercenter.enums.OrderType;
import com.freemud.sdk.api.assortment.order.enums.OldOrderType;
import com.freemud.sdk.api.assortment.order.response.order.QueryOrdersResponse;
import org.apache.commons.collections4.CollectionUtils;
......@@ -23,7 +22,7 @@ import org.springframework.stereotype.Component;
public class OrderManagerAdapter {
@Autowired
private OrderVerifyService orderVerifyService;
private OrderVerifyHandle orderVerifyHandle;
@Autowired
private OrderBaseService orderBaseService;
@Autowired
......@@ -40,7 +39,7 @@ public class OrderManagerAdapter {
//查询订单
QueryOrdersResponse.DataBean.OrderBean orderBean = orderBaseService.getByOrderCode(request.getOrderId());
//订单接单参数校验
BaseResponse verifyResponse = orderVerifyService.orderConfirmTakeVerify(orderBean, request);
BaseResponse verifyResponse = orderVerifyHandle.orderConfirmTakeVerify(orderBean, request);
if (ObjectUtils.notEqual(verifyResponse.getCode(), ResponseResult.SUCCESS.getCode())) {
return verifyResponse;
}
......@@ -49,7 +48,6 @@ public class OrderManagerAdapter {
/**
* 制作完成
*
* @param request
* @return
*/
......@@ -57,17 +55,16 @@ public class OrderManagerAdapter {
//查询订单
QueryOrdersResponse.DataBean.OrderBean orderBean = orderBaseService.getByOrderCode(request.getOrderId());
//订单接单参数校验
BaseResponse verifyResponse = orderVerifyService.orderDoneVerify(orderBean, request);
BaseResponse verifyResponse = orderVerifyHandle.orderDoneVerify(orderBean, request);
if (ObjectUtils.notEqual(verifyResponse.getCode(), ResponseResult.SUCCESS.getCode())) {
return handleResponse(request, orderBean, verifyResponse);
return handleResponse(request,orderBean,verifyResponse);
}
BaseResponse<OrderManagerResponse> orderManagerResponse = orderBeanFactory.getOrderManagerService(orderBean).orderDone(request, orderBean);
return handleResponse(request, orderBean, orderManagerResponse);
return handleResponse(request,orderBean,orderManagerResponse);
}
/**
* 送出
*
* @param request
* @return
*/
......@@ -80,71 +77,123 @@ public class OrderManagerAdapter {
}
/*****容爱马哥，送出即完成end******/
//订单接单参数校验
BaseResponse verifyResponse = orderVerifyService.orderDeliveryVerify(orderBean, request);
BaseResponse verifyResponse = orderVerifyHandle.orderDeliveryVerify(orderBean, request);
if (ObjectUtils.notEqual(verifyResponse.getCode(), ResponseResult.SUCCESS.getCode())) {
return StringUtils.equals(verifyResponse.getCode(), ResponseResult.ORDER_IS_COMPLETE_CAN_NOT_DELIVERY.getCode()) ? handleResponse(request, orderBean, ResponseUtil.success()) : handleResponse(request, orderBean, verifyResponse);
return StringUtils.equals(verifyResponse.getCode(), ResponseResult.ORDER_IS_COMPLETE_CAN_NOT_DELIVERY.getCode()) ? handleResponse(request,orderBean,ResponseUtil.success()) : handleResponse(request,orderBean,verifyResponse);
}
BaseResponse<OrderManagerResponse> orderManagerResponse = orderBeanFactory.getOrderManagerService(orderBean).orderDelivery(request, orderBean);
return handleResponse(request, orderBean, orderManagerResponse);
return handleResponse(request,orderBean,orderManagerResponse);
}
/**
* 完成
*
* @param request
* @return
*/
public BaseResponse<OrderManagerResponse> orderAffirm(OrderManagerRequest request, QueryOrdersResponse.DataBean.OrderBean orderBean) {
if (orderBean == null) {
public BaseResponse<OrderManagerResponse> orderAffirm(OrderManagerRequest request,QueryOrdersResponse.DataBean.OrderBean orderBean) {
if (orderBean==null){
//查询订单
orderBean = orderBaseService.getByOrderCode(request.getOrderId());
}
//订单接单参数校验
BaseResponse verifyResponse = orderVerifyService.orderAffirmVerify(orderBean, request);
BaseResponse verifyResponse = orderVerifyHandle.orderAffirmVerify(orderBean, request);
if (ObjectUtils.notEqual(verifyResponse.getCode(), ResponseResult.SUCCESS.getCode())) {
return handleResponse(request, orderBean, verifyResponse);
return handleResponse(request,orderBean,verifyResponse);
}
BaseResponse<OrderManagerResponse> orderManagerResponse = orderBeanFactory.getOrderManagerService(orderBean).orderAffirm(request, orderBean);
return handleResponse(request, orderBean, orderManagerResponse);
return handleResponse(request,orderBean,orderManagerResponse);
}
/**
* 拒单
*
* @param request
* @return
*/
public BaseResponse orderReject(OrderManagerRequest request) {
//查询订单
QueryOrdersResponse.DataBean.OrderBean orderBean = orderBaseService.getByOrderCode(request.getOrderId());
//订单接单参数校验
BaseResponse verifyResponse = orderVerifyHandle.orderRejectVerify(orderBean, request);
if (ObjectUtils.notEqual(verifyResponse.getCode(), ResponseResult.SUCCESS.getCode())) {
return handleResponse(request,orderBean,verifyResponse);
}
BaseResponse<OrderManagerResponse> orderManagerResponse = orderBeanFactory.getOrderManagerService(orderBean).orderReject(request, orderBean);
return handleResponse(request,orderBean,orderManagerResponse);
}
private BaseResponse<OrderManagerResponse> handleResponse(OrderManagerRequest request, QueryOrdersResponse.DataBean.OrderBean orderBean, BaseResponse result) {
if (orderBean == null) {
/**
* 同意退款
* @param request
* @return
*/
public BaseResponse orderAgreeRefund(OrderManagerRequest request) {
//查询订单
QueryOrdersResponse.DataBean.OrderBean orderBean = orderBaseService.getByOrderCode(request.getOrderId());
//订单接单参数校验
BaseResponse verifyResponse = orderVerifyHandle.orderAgreeRefund(orderBean, request);
if (ObjectUtils.notEqual(verifyResponse.getCode(), ResponseResult.SUCCESS.getCode())) {
return handleResponse(request,orderBean,verifyResponse);
}
BaseResponse<OrderManagerResponse> orderManagerResponse = orderBeanFactory.getOrderManagerService(orderBean).orderAgreeRefund(request, orderBean);
return handleResponse(request,orderBean,orderManagerResponse);
}
/**
* 拒绝退款
* @param request
* @return
*/
public BaseResponse orderRejectRefund(OrderManagerRequest request) {
//查询订单
QueryOrdersResponse.DataBean.OrderBean orderBean = orderBaseService.getByOrderCode(request.getOrderId());
//订单接单参数校验
BaseResponse verifyResponse = orderVerifyHandle.orderRejectRefund(orderBean, request);
if (ObjectUtils.notEqual(verifyResponse.getCode(), ResponseResult.SUCCESS.getCode())) {
return handleResponse(request,orderBean,verifyResponse);
}
BaseResponse<OrderManagerResponse> orderManagerResponse = orderBeanFactory.getOrderManagerService(orderBean).orderRejectRefund(request, orderBean);
return handleResponse(request,orderBean,orderManagerResponse);
}
private BaseResponse<OrderManagerResponse> handleResponse(OrderManagerRequest request, QueryOrdersResponse.DataBean.OrderBean orderBean,BaseResponse result) {
if (orderBean==null){
return result;
}
RefundStatus refundStatus = CollectionUtils.isNotEmpty(orderBean.getRefundList()) ? RefundStatus.getByCode(orderBean.getRefundList().get(0).getStatus()) : null;
OrderStatus orderStatus = OrderStatus.getByCode(orderBean.getStatus());
if (ObjectUtils.equals(ResponseResult.SUCCESS.getCode(), result.getCode())) {
if (ObjectUtils.equals(ResponseResult.SUCCESS.getCode(),result.getCode())){
OperateType byOpType = OperateType.getByOpType(request.getOperateType());
switch (byOpType) {
case ORDER_CONFIRM:
orderStatus = OrderStatus.RECEIPT;
orderStatus=OrderStatus.RECEIPT;
break;
case ORDER_DONE:
orderStatus = OrderStatus.COMPLETE_MAKE;
orderStatus=OrderStatus.COMPLETE_MAKE;
break;
case ORDER_SEND:
orderStatus = OrderStatus.DISTRIBUTION;
orderStatus=OrderStatus.DISTRIBUTION;
break;
case ORDER_AFFIRM:
orderStatus = OrderStatus.COMPLETE;
orderStatus=OrderStatus.COMPLETE;
break;
case ORDER_REJECT:
case ORDER_AGREE_REFUND:
orderStatus=OrderStatus.CANCEL;
refundStatus=RefundStatus.COMPLETE_REFUND;
break;
case ORDER_REJECT_REFUND:
refundStatus=RefundStatus.REFUSE_REFUND;
break;
default:
}
return ResponseUtil.success(new OrderManagerResponse(orderStatus, refundStatus));
return ResponseUtil.success(new OrderManagerResponse(orderStatus,refundStatus));
}
result.setResult(new OrderManagerResponse(orderStatus, refundStatus));
result.setResult(new OrderManagerResponse(orderStatus,refundStatus));
return result;
}
/**
* 拒单
*
* @param request
* @return
*/
public BaseResponse orderReject(OrderManagerRequest request) {
return null;
}
}
order-management/src/main/java/cn/freemud/management/service/handle/DeliveryHandle.java 0 → 100644
package cn.freemud.management.service.handle;
import cn.freemud.base.entity.BaseResponse;
import cn.freemud.base.log.LogTreadLocal;
import cn.freemud.management.adapter.DeliverySdkAdapter;
import cn.freemud.management.entities.dto.request.order.OrderManagerRequest;
import cn.freemud.management.enums.DeliveryStatus;
import cn.freemud.management.enums.ResponseResult;
import cn.freemud.management.intercept.DeliveryServiceException;
import cn.freemud.management.intercept.OrderServiceException;
import cn.freemud.management.service.OrderBaseService;
import cn.freemud.management.util.ResponseUtil;
import com.freemud.application.sdk.api.deliverycenter.dto.CancelDeliveryOrderRequestDto;
import com.freemud.application.sdk.api.deliverycenter.dto.CreateDeliveryOrderRequestDto;
import com.freemud.application.sdk.api.deliverycenter.response.CreateDeliveryOrderResponseDto;
import com.freemud.application.sdk.api.deliverycenter.response.DeliveryResponseDto;
import com.freemud.application.sdk.api.deliverycenter.service.DeliveryService;
import com.freemud.application.sdk.api.log.LogThreadLocal;
import com.freemud.application.sdk.api.storecenter.request.StoreInfoRequest;
import com.freemud.application.sdk.api.storecenter.response.StoreResponse;
import com.freemud.sdk.api.assortment.order.enums.OrderSourceType;
import com.freemud.sdk.api.assortment.order.response.order.QueryOrdersResponse;
import javafx.util.Pair;
import org.apache.commons.lang.ObjectUtils;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
/**
* All rights Reserved, Designed By www.freemud.cn
*
* @version V1.0
* @Title: 配送服务处理类
* @Package cn.freemud.management.service.handle
* @Description:
* @author: shuhu.hou
* @date: 2020/4/26 15:44
* @Copyright: 2020 www.freemud.cn Inc. All rights reserved.
* 注意：本内容仅限于上海非码科技内部传阅，禁止外泄以及用于其他的商业目
*/
@Component
public class DeliveryHandle {
private static final String THIRD = "third";
private static final String delivery_type_self = "self";
private static final int SUCCESS = 100;
@Value("${saas.order.delivery.callBackUrl}")
private String deliveryCallBackUrl;
@Autowired
private DeliveryService deliveryService;
@Autowired
private DeliverySdkAdapter deliverySdkAdapter;
@Autowired
private OrderBaseService orderBaseService;
/**
* 创建配送单
*
* @param data
* @param request
* @return
*/
public BaseResponse createDelivery(QueryOrdersResponse.DataBean.OrderBean orderBean, OrderManagerRequest request, StoreResponse storeInfo) {
if (storeInfo == null || ObjectUtils.notEqual(ResponseResult.SUCCESS.getCode(), storeInfo.getStatusCode().toString()) || storeInfo.getBizVO() == null) {
throw new OrderServiceException(ResponseResult.STORE_INFO_NOT_FOUND);
}
if (!checkOrderOfDelivery(orderBean)) {
return ResponseUtil.success();
}
// 调用配送系统创建配送单
CreateDeliveryOrderRequestDto requestDto = deliverySdkAdapter.buildDeliveryOrderRequestDto(orderBean, storeInfo, deliveryCallBackUrl);
CreateDeliveryOrderResponseDto deliveryResponse = deliveryService.deliveryOrderAdd(requestDto, LogTreadLocal.getTrackingNo());
String operator = request == null || StringUtils.isBlank(request.getOperator()) ? "系统" : request.getOperator();
//创建配送单失败，更新订单为异常单
if (deliveryResponse == null || SUCCESS != deliveryResponse.getCode() || deliveryResponse.getData() == null) {
String deliveryId = deliveryResponse != null && deliveryResponse.getData() != null ? deliveryResponse.getData().getDeliveryId() : "";
orderBaseService.updateDeliveryAbnormal(orderBean.getCompanyId(), orderBean.getOid(), deliveryId, operator);
return ResponseUtil.success();
}
// 创建配送单成功
orderBaseService.updateDeliverySuccess(orderBean.getOid(), deliveryResponse.getData().getDeliveryId(), operator);
return ResponseUtil.success();
}
/**
* 取消配送
*
* @param orderBean
* @param request
* @return
*/
public BaseResponse cancelDelivery(QueryOrdersResponse.DataBean.OrderBean data, OrderManagerRequest request) {
if (data.getType() == 1 && data.getAddInfo() != null && ObjectUtils.equals(data.getAddInfo().getDeliveryType(), THIRD)) {
Integer deliverStatus = data.getAddInfo().getDeliverStatus();
//运单异常或取消时，无需作废三方配送运单
if (ObjectUtils.equals(DeliveryStatus.DELIVERYERROR.getCode(), deliverStatus)
|| ObjectUtils.equals(DeliveryStatus.DELIVERYCANCEL.getCode(), deliverStatus)
|| ObjectUtils.equals(DeliveryStatus.DELIVERYARRIVED.getCode(), deliverStatus)) {
return ResponseUtil.success();
}
//运单状态非待接单或系统接单时，不能取消运单
if (ObjectUtils.equals(DeliveryStatus.RIDERSTARTDELIVERY.getCode(), deliverStatus)) {
throw new DeliveryServiceException(ResponseResult.DELIVERY_CANCEL_ORDER_ERROR, String.format("订单已%s，不能取消", DeliveryStatus.getDescByCode(data.getAddInfo().getDeliverStatus())));
}
CancelDeliveryOrderRequestDto cancelDeliveryOrderRequestDto = new CancelDeliveryOrderRequestDto();
cancelDeliveryOrderRequestDto.setDeliveryId(data.getAddInfo().getDeliveryId());
cancelDeliveryOrderRequestDto.setOrderCancelCode(4);
//商家退款取消配送
cancelDeliveryOrderRequestDto.setOrderCancelDescription("顾客取消订单");
DeliveryResponseDto deliveryResponse = deliveryService.deliveryOrderCancel(cancelDeliveryOrderRequestDto, LogThreadLocal.getTrackingNo());
if (deliveryResponse == null || ObjectUtils.notEqual(Integer.getInteger(ResponseResult.SUCCESS.getCode()), deliveryResponse.getCode())) {
throw new DeliveryServiceException(ResponseResult.DELIVERY_CANCEL_ORDER_ERROR, deliveryResponse.getMsg());
}
}
return ResponseUtil.success();
}
/**
* 校验是否要创建配送单
*
* @param orderBean
* @return
*/
private boolean checkOrderOfDelivery(QueryOrdersResponse.DataBean.OrderBean orderBean) {
//判断外卖单
if (1 != orderBean.getType()) {
return false;
}
//订单来源异常
if (!orderBean.getSource().equalsIgnoreCase(OrderSourceType.SAAS.getCode())) {
return false;
}
//配送信息为空，则不创建配送单
if (orderBean.getAddInfo() == null || orderBean.getAddInfo().getDeliveryType() == null) {
return false;
}
//自配送不创建配送单
if (delivery_type_self.equalsIgnoreCase(orderBean.getAddInfo().getDeliveryType())) {
return false;
}
return true;
}
}
order-management/src/main/java/cn/freemud/management/service/handle/OrderVerifyHandle.java 0 → 100644
package cn.freemud.management.service.handle;
import cn.freemud.base.entity.BaseResponse;
import cn.freemud.management.entities.dto.request.order.OrderManagerRequest;
import cn.freemud.management.entities.dto.response.order.OrderManagerResponse;
import cn.freemud.management.entities.dto.response.pay.RefundConfig;
import cn.freemud.management.enums.OrderRefundEnum;
import cn.freemud.management.enums.OrderSource;
import cn.freemud.management.enums.OrderStatus;
import cn.freemud.management.enums.ResponseResult;
import cn.freemud.management.util.ResponseUtil;
import com.alibaba.fastjson.JSONObject;
import com.freemud.api.assortment.datamanager.entity.db.AssortmentOpenPlatformPartnerWxappConfig;
import com.freemud.api.assortment.datamanager.manager.cache.CacheOpenPlatformPartnerWxappConfigManager;
import com.freemud.application.sdk.api.ordercenter.enums.OperateClient;
import com.freemud.sdk.api.assortment.order.enums.OldOrderAccountType;
import com.freemud.sdk.api.assortment.order.response.order.QueryOrdersResponse;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang.ObjectUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.math.BigDecimal;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;
/**
* All rights Reserved, Designed By www.freemud.cn
*
* @version V1.0
* @Title: OrderVerifyService
* @Package cn.freemud.management.service.impl
* @Description:
* @author: shuhu.hou
* @date: 2020/3/26 16:04
* @Copyright: 2020 www.freemud.cn Inc. All rights reserved.
* 注意：本内容仅限于上海非码科技内部传阅，禁止外泄以及用于其他的商业目
*/
@Component
public class OrderVerifyHandle {
/**
* 允许退款
*/
private static final String ALLOW_REFUND = "1";
/**
* svc储值卡支付，可用于判断订单是否用储值卡支付
*/
private static final String PAY_CODE_10102 = "10102";
@Autowired
private CacheOpenPlatformPartnerWxappConfigManager cacheOpenPlatformPartnerWxappConfigManager;
/**
* 接单校验
*
* @param orderBean
* @param request
* @return
*/
public BaseResponse orderConfirmTakeVerify(QueryOrdersResponse.DataBean.OrderBean orderBean, OrderManagerRequest request) {
if (orderBean == null) {
return ResponseUtil.error(ResponseResult.ORDER_NOT_EXIST);
}
if (!OrderStatus.TAKE_ORDER.getCode().equals(orderBean.getStatus())) {
return ResponseUtil.error(ResponseResult.ORDER_CANNOT_CONFIRM, getOrderManagerResponse(orderBean));
}
return ResponseUtil.success();
}
/**
* 订单配送校验
*
* @param orderBean
* @param request
* @return
*/
public BaseResponse orderDeliveryVerify(QueryOrdersResponse.DataBean.OrderBean orderBean, OrderManagerRequest request) {
if (orderBean == null) {
return ResponseUtil.error(ResponseResult.ORDER_NOT_EXIST);
}
//已完成的订单不能配送
if (OrderStatus.COMPLETE.getCode().equals(orderBean.getStatus())) {
return ResponseUtil.error(ResponseResult.ORDER_IS_COMPLETE_CAN_NOT_DELIVERY, getOrderManagerResponse(orderBean));
}
//订单已经发送过配送
if (OrderStatus.DISTRIBUTION.getCode().equals(orderBean.getStatus())) {
return ResponseUtil.error(ResponseResult.DELIVERY_SEND_REPETITION, getOrderManagerResponse(orderBean));
}
//判断订单状态是否为已经申请退款订单
if (orderBean.getHasRefund() != null
&& orderBean.getHasRefund()
&& (orderBean.getRefundList().get(orderBean.getRefundList().size() - 1).getStatus() == 1
|| orderBean.getRefundList().get(orderBean.getRefundList().size() - 1).getStatus() == 4)) {
return ResponseUtil.error(ResponseResult.DELIVERY_SEND_APPLY_REFUND, getOrderManagerResponse(orderBean));
}
//外卖订单不是接单不能送出
if (!OrderStatus.RECEIPT.getCode().equals(orderBean.getStatus())) {
return ResponseUtil.error(ResponseResult.DELIVERY_SEND_STATUS_NOTAKE, getOrderManagerResponse(orderBean));
}
return ResponseUtil.success();
}
/**
* 订单制作完成校验
*
* @param orderBean
* @param request
* @return
*/
public BaseResponse orderDoneVerify(QueryOrdersResponse.DataBean.OrderBean orderBean, OrderManagerRequest request) {
if (orderBean == null) {
return ResponseUtil.error(ResponseResult.ORDER_NOT_EXIST);
}
//已制作完成的订单不能重复操作
if (OrderStatus.COMPLETE_MAKE.getCode().equals(orderBean.getStatus())) {
return ResponseUtil.error(ResponseResult.DONE_FAIL_REPETITION, getOrderManagerResponse(orderBean));
}
//订单非接单状态，不能制作完成
if (!OrderStatus.RECEIPT.getCode().equals(orderBean.getStatus())) {
return ResponseUtil.error(ResponseResult.DONE_FAIL_NOT_ACCEPT, getOrderManagerResponse(orderBean));
}
//判断订单状态是否为已经申请退款订单
if (orderBean.getHasRefund() != null
&& orderBean.getHasRefund()
&& (orderBean.getRefundList().get(orderBean.getRefundList().size() - 1).getStatus() == 1
|| orderBean.getRefundList().get(orderBean.getRefundList().size() - 1).getStatus() == 4)) {
return ResponseUtil.error(ResponseResult.DONE_FAIL_APPLY_REFUND, getOrderManagerResponse(orderBean));
}
return ResponseUtil.success();
}
/**
* 订单完成校验
*
* @param orderBean
* @param request
* @return
*/
public BaseResponse orderAffirmVerify(QueryOrdersResponse.DataBean.OrderBean orderBean, OrderManagerRequest request) {
if (orderBean == null) {
return ResponseUtil.error(ResponseResult.ORDER_NOT_EXIST);
}
//判断订单是否已送达
if (OrderStatus.COMPLETE.getCode().equals(orderBean.getStatus())) {
return ResponseUtil.error(ResponseResult.DELIVERY_SEND_REPETITION, getOrderManagerResponse(orderBean));
}
//已取消的订单不能操作
if (OrderStatus.CANCEL.getCode().equals(orderBean.getStatus())) {
return ResponseUtil.error(ResponseResult.ORDER_HAS_CANCELED, getOrderManagerResponse(orderBean));
}
//判断订单状态是否为已经申请退款订单
if (orderBean.getHasRefund() != null
&& orderBean.getHasRefund()
&& (orderBean.getRefundList().get(orderBean.getRefundList().size() - 1).getStatus() == 1
|| orderBean.getRefundList().get(orderBean.getRefundList().size() - 1).getStatus() == 4)) {
return ResponseUtil.error(ResponseResult.AFFIRM_FAIL_APPLY_REFUND, getOrderManagerResponse(orderBean));
}
//校验订单是否为配送状态
if (isWaimai(orderBean) && ObjectUtils.notEqual(OrderStatus.DISTRIBUTION.getCode(), orderBean.getStatus())) {
return ResponseUtil.error(ResponseResult.ORDER_DELIVERY_FAILED, getOrderManagerResponse(orderBean));
}
return ResponseUtil.success();
}
/**
* 拒单
*
* @param orderBean
* @param request
* @return
*/
public BaseResponse orderRejectVerify(QueryOrdersResponse.DataBean.OrderBean orderBean, OrderManagerRequest request) {
if (orderBean == null) {
return ResponseUtil.error(ResponseResult.ORDER_NOT_EXIST);
}
Integer status = orderBean.getStatus();
//判断订单是否已经被拒单
if (OrderStatus.REFUSE.getCode().equals(status)) {
return ResponseUtil.error(ResponseResult.REJECT_FAIL_REPETITION, getOrderManagerResponse(orderBean));
}
//判断订单是否已经取消
if (OrderStatus.CANCEL.getCode().equals(status)) {
return ResponseUtil.error(ResponseResult.ORDER_HAS_CANCELED, getOrderManagerResponse(orderBean));
}
//判断订单是否在配送中
if (OrderStatus.DISTRIBUTION.getCode().equals(status)) {
return ResponseUtil.error(ResponseResult.REJECT_FAIL_ORDER_IS_DELIVERY, getOrderManagerResponse(orderBean));
}
//判断订单是否已送达
if (OrderStatus.COMPLETE.getCode().equals(status)) {
return ResponseUtil.error(ResponseResult.REJECT_FAIL_ORDER_IS_COMPLETE, getOrderManagerResponse(orderBean));
}
if (!OrderStatus.TAKE_ORDER.getCode().equals(status)) {
return ResponseUtil.error(ResponseResult.REJECT_FAIL_ORDER_IS_NOT_NEW, getOrderManagerResponse(orderBean));
}
return ResponseUtil.success();
}
/**
* 同意退款
*
* @param orderBean
* @param request
* @return
*/
public BaseResponse orderAgreeRefund(QueryOrdersResponse.DataBean.OrderBean orderBean, OrderManagerRequest request) {
//已取消的订单不能操作
if (ObjectUtils.equals(OrderStatus.CANCEL.getCode(), orderBean.getStatus())) {
return ResponseUtil.error(ResponseResult.ORDER_HAS_CANCELED);
}
//判断订单是否有申请退款
if (orderBean.getHasRefund() == null
|| !orderBean.getHasRefund()
|| orderBean.getRefundList().get(orderBean.getRefundList().size() - 1).getStatus() != 1) {
return ResponseUtil.error(ResponseResult.ORDER_REFUND_NOT_APPLY);
}
//订单是否支持退款
boolean isCanRefund = false;
//订单
boolean isRefundDeliveryFee=false;
//saas渠道订单，已完成的订单不能操作, 商户配置已完成订单可退款可退款
if (ObjectUtils.equals(orderBean.getSource(), OrderSource.SAAS.getSource())) {
RefundConfig refundConfig = getRefundConfig(orderBean);
isCanRefund=refundConfig.isCanRefund();
isRefundDeliveryFee=refundConfig.isRefundDeliveryFee();
if (!isCanRefund) {
return ResponseUtil.error(ResponseResult.ORDER_HAD_AFFIRM_CAN_NOT_REFUND);
}
}
if (isCanRefund) {
orderBean.setAmount(getRefundAmount(orderBean,isRefundDeliveryFee).longValue());
}
return ResponseUtil.success();
}
/**
* 拒绝退款
* @param orderBean
* @param request
* @return
*/
public BaseResponse orderRejectRefund(QueryOrdersResponse.DataBean.OrderBean orderBean, OrderManagerRequest request) {
//判断当前订单是否发起退款
if (orderBean.getHasRefund() == null || !orderBean.getHasRefund()) {
return ResponseUtil.error(ResponseResult.ORDER_REFUND_NOT_APPLY);
}
//判断该当前订单是否已经退款
List<QueryOrdersResponse.DataBean.OrderBean.RefundBean> list = orderBean.getRefundList();
if (ObjectUtils.equals(list.get(list.size() - 1).getStatus(), 5)) {
return ResponseUtil.error(ResponseResult.ORDER_REJECT_REFUND_REPETITION);
}
//订单不是申请退款中，不能操作
if (ObjectUtils.notEqual(list.get(list.size() - 1).getStatus(), 1)) {
return ResponseUtil.error(ResponseResult.ORDER_REJECT_REFUND_STATUS_NOT);
}
//新订单，已完成，取消订单不能操作
if (OrderSource.SAAS.getSource().equals(orderBean.getSource())
&& (OrderStatus.TAKE_ORDER.getCode().equals(orderBean.getStatus())
|| OrderStatus.CANCEL.getCode().equals(orderBean.getStatus()))) {
return ResponseUtil.error(ResponseResult.ORDER_REJECT_REFUND_STATUS_END);
}
return ResponseUtil.success();
}
/**
* 通用校验
*
* @param orderBean
* @param request
* @return
*/
private BaseResponse commonVerify(QueryOrdersResponse.DataBean.OrderBean orderBean, OrderManagerRequest request) {
if (ObjectUtils.notEqual(orderBean.getCompanyId(), request.getPartnerId())) {
return ResponseUtil.error(ResponseResult.ORDER_PARTNER_ID_NOT_MATCTH, getOrderManagerResponse(orderBean));
}
//开放平台不传入门店
if (ObjectUtils.notEqual(request.getOperator(), OperateClient.OPEN_PLATFORM.getOpName()) && ObjectUtils.notEqual(orderBean.getShopId(), request.getStoreId())) {
return ResponseUtil.error(ResponseResult.ORDER_STORE_ID_NOT_MATCTH, getOrderManagerResponse(orderBean));
}
return ResponseUtil.success();
}
/**
* 是否是外卖
*
* @param orderBean
* @return
*/
private boolean isWaimai(QueryOrdersResponse.DataBean.OrderBean orderBean) {
String source = orderBean.getSource();
if (OrderSource.BDWM.getSource().equals(source) || OrderSource.JDWM.getSource().equals(source)
|| OrderSource.MTWM.getSource().equals(source) || OrderSource.ELEME.getSource().equals(source)) {
return true;
}
return false;
}
private OrderManagerResponse getOrderManagerResponse(QueryOrdersResponse.DataBean.OrderBean orderBean) {
Integer refundStatus = CollectionUtils.isEmpty(orderBean.getRefundList()) ? null : orderBean.getRefundList().get(0).getStatus();
return new OrderManagerResponse(orderBean.getGmtExpect(), orderBean.getStatus(), refundStatus);
}
/**
* 已完成订单退款配置查询
*
* @param data
* @return true=可同意退款
*/
private RefundConfig getRefundConfig(QueryOrdersResponse.DataBean.OrderBean data) {
boolean isFinishRefund = false;
com.freemud.application.sdk.api.ordercenter.request.OrderExtInfoDto extInfo = null;
JSONObject jsonObject1 = JSONObject.parseObject(data.getExtInfo());
extInfo = jsonObject1.toJavaObject(com.freemud.application.sdk.api.ordercenter.request.OrderExtInfoDto.class);
List<AssortmentOpenPlatformPartnerWxappConfig> partnerWxappConfigs = cacheOpenPlatformPartnerWxappConfigManager.cacheSelectDefaultPage(extInfo.getAppid(), "2");
Map<String, AssortmentOpenPlatformPartnerWxappConfig> configMap = partnerWxappConfigs.stream().collect(Collectors.toMap(AssortmentOpenPlatformPartnerWxappConfig::getAppKey, Function.identity()));
AssortmentOpenPlatformPartnerWxappConfig orderRefund;
//订单状态
switch (data.getStatus()) {
// 未接单
case 1:
orderRefund = configMap.get(OrderRefundEnum.TAKEORDER_REFUND.getKeyValue());
if (orderRefund == null || (orderRefund != null && ALLOW_REFUND.equals(orderRefund.getAppValue()))) {
isFinishRefund = true;
}
break;
//已接单
case 3:
orderRefund = configMap.get(OrderRefundEnum.RECEIPTORDER_REFUND.getKeyValue());
if (orderRefund == null || (orderRefund != null && ALLOW_REFUND.equals(orderRefund.getAppValue()))) {
isFinishRefund = true;
}
break;
//制作完成
case 31:
orderRefund = configMap.get(OrderRefundEnum.COMPLETEMAKEORDER_REFUND.getKeyValue());
if (orderRefund != null && ALLOW_REFUND.equals(orderRefund.getAppValue())) {
isFinishRefund = true;
}
break;
// 订单完成
case 5:
orderRefund = configMap.get(OrderRefundEnum.ORDER_REFUND.getKeyValue());
if (orderRefund != null && ALLOW_REFUND.equals(orderRefund.getAppValue())) {
isFinishRefund = true;
}
break;
default:
break;
}
boolean isRefundDeliveryFee = false;
AssortmentOpenPlatformPartnerWxappConfig refundDeliveryFeeConfig = configMap.get(OrderRefundEnum.REFUND_DELIVERY_FEE_ENABLE.getKeyValue());
// 0、null表示 关闭 ; 1 表示开启
if (null != refundDeliveryFeeConfig && ALLOW_REFUND.equals(refundDeliveryFeeConfig.getAppValue())) {
isRefundDeliveryFee = true;
}
return new RefundConfig(isFinishRefund,isRefundDeliveryFee);
}
/**
* 获取已完成订单退款金额
*/
private BigDecimal getRefundAmount(QueryOrdersResponse.DataBean.OrderBean data,boolean isRefundDeliveryFee) {
//是否配置已完成订单可退款
BigDecimal refundAmount = new BigDecimal(data.getAmount());
if (isRefundDeliveryFee || isPayBySVC(data)){
return refundAmount;
}
List<QueryOrdersResponse.DataBean.OrderBean.AccountBean> accountList = data.getAccountList();
if (CollectionUtils.isNotEmpty(accountList)) {
for (QueryOrdersResponse.DataBean.OrderBean.AccountBean orderCostResp : accountList) {
if (orderCostResp.getType() == OldOrderAccountType.DELIVERY_AMOUNT.getCode()) {
refundAmount = new BigDecimal(data.getAmount().intValue() - orderCostResp.getPrice());
}
}
}
return refundAmount;
}
/**
* 订单是否使用储值卡支付（储值卡支付的订单，不支持部分退款）
*
* @param order
* @return true-是，false-不是
*/
private boolean isPayBySVC(QueryOrdersResponse.DataBean.OrderBean order) {
return PAY_CODE_10102.equalsIgnoreCase(order.getPayChannel());
}
}
order-management/src/main/java/cn/freemud/management/service/handle/PaymentHandle.java 0 → 100644
package cn.freemud.management.service.handle;
import cn.freemud.management.adapter.PaymentSdkAdapter;
import cn.freemud.management.entities.dto.request.order.OrderManagerRequest;
import cn.freemud.management.entities.dto.response.pay.PayRefundResponse;
import cn.freemud.management.enums.ResponseResult;
import cn.freemud.management.intercept.OrderServiceException;
import com.freemud.application.sdk.api.base.BaseResponse;
import com.freemud.application.sdk.api.log.ErrorLog;
import com.freemud.sdk.api.assortment.order.enums.PayRefundStatus;
import com.freemud.sdk.api.assortment.order.response.order.QueryOrdersResponse;
import com.freemud.sdk.api.assortment.payment.request.OrderRefundRequest;
import com.freemud.sdk.api.assortment.payment.response.OrderRefundResponse;
import com.freemud.sdk.api.assortment.payment.service.StandardPaymentService;
import org.apache.commons.lang.ObjectUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
/**
* All rights Reserved, Designed By www.freemud.cn
*
* @version V1.0
* @Title: PaymentService
* @Package cn.freemud.management.service.impl
* @Description:
* @author: shuhu.hou
* @date: 2020/4/24 10:45
* @Copyright: 2020 www.freemud.cn Inc. All rights reserved.
* 注意：本内容仅限于上海非码科技内部传阅，禁止外泄以及用于其他的商业目
*/
@Component
public class PaymentHandle {
private static final String SUCCESS="100";
@Autowired
private StandardPaymentService standardPaymentService;
@Autowired
private PaymentSdkAdapter paymentSdkAdapter;
/**
* 退款
* @param request
* @param orderBean
* @return
*/
public PayRefundResponse refund(OrderManagerRequest request, QueryOrdersResponse.DataBean.OrderBean orderBean){
PayRefundStatus refundStatus=PayRefundStatus.SUCCESS;
OrderRefundRequest orderRefundRequest = paymentSdkAdapter.getOrderRefundRequest(orderBean);
if (ObjectUtils.equals(orderBean.getAmount(), 0)) {
return handlePayRefundResponse(refundStatus,orderRefundRequest.getRefundId());
}
BaseResponse<OrderRefundResponse> orderRefundResponse;
try {
orderRefundResponse = standardPaymentService.orderRefund(orderRefundRequest, "");
}catch (Exception ex){
ErrorLog.errorConvertJson(this.getClass(), "refundError", ex);
throw new OrderServiceException(ResponseResult.REFUND_EXCEPTION);
}
if (orderRefundResponse==null){
throw new OrderServiceException(ResponseResult.REFUND_EXCEPTION);
}
if (ObjectUtils.notEqual(orderRefundResponse.getCode(),SUCCESS)){
throw new OrderServiceException(ResponseResult.REFUND_FAIL,orderRefundResponse.getMessage());
}
refundStatus=ObjectUtils.equals( PayRefundStatus.SUCCESS.getCode(), orderRefundResponse.getData().getRefundStatus())?PayRefundStatus.SUCCESS:PayRefundStatus.RUNNING;
return handlePayRefundResponse(refundStatus,orderRefundRequest.getRefundId());
}
private PayRefundResponse handlePayRefundResponse(PayRefundStatus refundStatus, Long refundId){
PayRefundResponse payRefundResponse = new PayRefundResponse();
payRefundResponse.setPayRefundStatus(refundStatus);
payRefundResponse.setRefundId(refundId.toString());
return payRefundResponse;
}
}
order-management/src/main/java/cn/freemud/management/service/impl/SaasOrderService.java → order-management/src/main/java/cn/freemud/management/service/handle/SaasOrderHandle.java
package cn.freemud.management.service.impl;
package cn.freemud.management.service.handle;
import cn.freemud.base.entity.BaseResponse;
import cn.freemud.management.entities.dto.request.order.OrderManagerRequest;
import cn.freemud.management.entities.dto.response.order.OrderManagerResponse;
import cn.freemud.management.entities.dto.response.pay.PayRefundResponse;
import cn.freemud.management.enums.ResponseResult;
import cn.freemud.management.intercept.OrderServiceException;
import cn.freemud.management.util.ResponseUtil;
import com.freemud.sdk.api.assortment.order.adapter.OrderSdkAdapter;
import com.freemud.sdk.api.assortment.order.enums.PayRefundStatus;
import com.freemud.sdk.api.assortment.order.request.order.BaseQueryOrderRequest;
import com.freemud.sdk.api.assortment.order.request.order.CancelOrderRequest;
import com.freemud.sdk.api.assortment.order.response.order.BaseOrderResponse;
import com.freemud.sdk.api.assortment.order.response.order.QueryOrdersResponse;
import com.freemud.sdk.api.assortment.order.service.OrderCenterSdkService;
......@@ -28,7 +30,8 @@ import org.springframework.stereotype.Component;
* 注意：本内容仅限于上海非码科技内部传阅，禁止外泄以及用于其他的商业目
*/
@Component
public class SaasOrderService {
public class SaasOrderHandle {
@Autowired
private OrderSdkAdapter orderSdkAdapter;
@Autowired
......@@ -37,19 +40,20 @@ public class SaasOrderService {
/**
* 确认接单
*
* @param request
* @param orderBean
* @return
*/
public BaseResponse orderConfirm(OrderManagerRequest request, QueryOrdersResponse.DataBean.OrderBean orderBean){
public BaseResponse orderConfirm(OrderManagerRequest request, QueryOrdersResponse.DataBean.OrderBean orderBean) {
//订单接单
BaseQueryOrderRequest orderConfirmRequest = orderSdkAdapter.getOrderConfirmRequest(request.getOperator(), orderBean);
BaseOrderResponse confirmOrderResponse = orderCenterSdkService.orderConfirmTake(orderConfirmRequest);
//处理1秒重复接单问题 订单服务接单返回20067重复操作，20018状态机不支持认为接单成功
if ("20067".equals(confirmOrderResponse.getErrcode().toString()) || "20018".equals(confirmOrderResponse.getErrcode().toString()) || "50002".equals(confirmOrderResponse.getErrcode().toString()) ) {
if ("20067".equals(confirmOrderResponse.getErrcode().toString()) || "20018".equals(confirmOrderResponse.getErrcode().toString()) || "50002".equals(confirmOrderResponse.getErrcode().toString())) {
return ResponseUtil.success();
}
if( ObjectUtils.notEqual(ResponseResult.SUCCESS.getCode(),confirmOrderResponse.getErrcode().toString())){
if (ObjectUtils.notEqual(ResponseResult.SUCCESS.getCode(), confirmOrderResponse.getErrcode().toString())) {
throw new OrderServiceException(ResponseResult.ORDER_ACCEPT_FAILED);
}
return ResponseUtil.success();
......@@ -57,14 +61,15 @@ public class SaasOrderService {
/**
* 订单制作完成
*
* @param request
* @param orderBean
* @return
*/
public BaseResponse orderDone(OrderManagerRequest request, QueryOrdersResponse.DataBean.OrderBean orderBean){
public BaseResponse orderDone(OrderManagerRequest request, QueryOrdersResponse.DataBean.OrderBean orderBean) {
BaseQueryOrderRequest orderDoneRequest = orderSdkAdapter.getOrderConfirmRequest(request.getOperator(), orderBean);
BaseOrderResponse baseOrderResponse = orderCenterSdkService.orderDone(orderDoneRequest);
if (baseOrderResponse==null || ObjectUtils.notEqual(ResponseResult.SUCCESS.getCode(),baseOrderResponse.getErrcode().toString())){
if (baseOrderResponse == null || ObjectUtils.notEqual(ResponseResult.SUCCESS.getCode(), baseOrderResponse.getErrcode().toString())) {
throw new OrderServiceException(ResponseResult.DONE_ORDER_FAIL);
}
return ResponseUtil.success();
......@@ -72,14 +77,15 @@ public class SaasOrderService {
/**
* 订单配送
*
* @param request
* @param orderBean
* @return
*/
public BaseResponse orderDelivery(OrderManagerRequest request, QueryOrdersResponse.DataBean.OrderBean orderBean){
public BaseResponse orderDelivery(OrderManagerRequest request, QueryOrdersResponse.DataBean.OrderBean orderBean) {
BaseQueryOrderRequest orderDeliveryRequest = orderSdkAdapter.getOrderDeliveryRequest(request.getOperator(), orderBean);
BaseOrderResponse baseOrderResponse = orderCenterSdkService.orderSend(orderDeliveryRequest);
if (baseOrderResponse==null || ObjectUtils.notEqual(ResponseResult.SUCCESS.getCode(),baseOrderResponse.getErrcode().toString())){
if (baseOrderResponse == null || ObjectUtils.notEqual(ResponseResult.SUCCESS.getCode(), baseOrderResponse.getErrcode().toString())) {
throw new OrderServiceException(ResponseResult.DELIVERY_FAIL);
}
return ResponseUtil.success();
......@@ -87,16 +93,74 @@ public class SaasOrderService {
/**
* 订单完成
*
* @param request
* @param orderBean
* @return
*/
public BaseResponse orderAffirm(OrderManagerRequest request, QueryOrdersResponse.DataBean.OrderBean orderBean){
public BaseResponse orderAffirm(OrderManagerRequest request, QueryOrdersResponse.DataBean.OrderBean orderBean) {
BaseQueryOrderRequest orderAffirmRequest = orderSdkAdapter.getOrderDeliveryRequest(request.getOperator(), orderBean);
BaseOrderResponse baseOrderResponse = orderCenterSdkService.orderAffirm(orderAffirmRequest);
if (baseOrderResponse==null || ObjectUtils.notEqual(ResponseResult.SUCCESS.getCode(),baseOrderResponse.getErrcode().toString())){
if (baseOrderResponse == null || ObjectUtils.notEqual(ResponseResult.SUCCESS.getCode(), baseOrderResponse.getErrcode().toString())) {
throw new OrderServiceException(ResponseResult.AFFIRM_ORDER_FAIL);
}
return ResponseUtil.success();
}
/**
* 拒单
*
* @param request
* @param orderBean
* @return
*/
public BaseResponse orderReject(OrderManagerRequest request, PayRefundResponse refundResponse, QueryOrdersResponse.DataBean.OrderBean orderBean) {
//作废订单
CancelOrderRequest cancelOrderRequest = orderSdkAdapter.getCancelOrderRequest(request.getOperator(), request.getReason(), refundResponse.getPayRefundStatus(), refundResponse.getRefundId(), orderBean);
BaseOrderResponse baseOrderResponse = orderCenterSdkService.orderReject(cancelOrderRequest);
if (baseOrderResponse == null || ObjectUtils.notEqual(ResponseResult.SUCCESS.getCode(), baseOrderResponse.getErrcode().toString())) {
throw new OrderServiceException(ResponseResult.AFFIRM_ORDER_FAIL);
}
return ResponseUtil.success();
}
/**
* 同意退款
*
* @param request
* @param refundResponse
* @param orderBean
* @return
*/
public BaseResponse refundAgree(OrderManagerRequest request, PayRefundResponse refundResponse, QueryOrdersResponse.DataBean.OrderBean orderBean) {
BaseQueryOrderRequest refundAgreeRequest = orderSdkAdapter.getRefundAgreeRequest(refundResponse.getRefundId(), request.getReason(), request.getOperator(), orderBean);
BaseOrderResponse baseOrderResponse = null;
if (PayRefundStatus.SUCCESS.equals(refundResponse.getPayRefundStatus())) {
baseOrderResponse = orderCenterSdkService.refundComplete(refundAgreeRequest);
} else {
baseOrderResponse = orderCenterSdkService.refundReturn(refundAgreeRequest);
}
if (baseOrderResponse == null || ObjectUtils.notEqual(ResponseResult.SUCCESS.getCode(), baseOrderResponse.getErrcode().toString())) {
throw new OrderServiceException(ResponseResult.AGREE_REFUND_ORDER_FAIL);
}
return ResponseUtil.success();
}
/**
* 拒绝退款
* @param request
* @param orderBean
* @return
*/
public BaseResponse refundReject(OrderManagerRequest request, QueryOrdersResponse.DataBean.OrderBean orderBean) {
CancelOrderRequest rejectRefundRequest = orderSdkAdapter.getRejectRefundRequest(request.getOperator(), request.getReason(), orderBean);
BaseOrderResponse baseOrderResponse = orderCenterSdkService.orderRefundReject(rejectRefundRequest);
if (baseOrderResponse == null || ObjectUtils.notEqual(ResponseResult.SUCCESS.getCode(), baseOrderResponse.getErrcode().toString())) {
throw new OrderServiceException(ResponseResult.REJECT_REFUND_ORDER_FAIL);
}
return ResponseUtil.success();
}
}
order-management/src/main/java/cn/freemud/management/service/handle/StockHandle.java 0 → 100644
package cn.freemud.management.service.handle;
import cn.freemud.amqp.Header;
import cn.freemud.amqp.MQAction;
import cn.freemud.amqp.MQMessage;
import cn.freemud.amqp.MQService;
import cn.freemud.management.entities.dto.request.order.OrderManagerRequest;
import com.freemud.application.sdk.api.log.ApiLog;
import com.freemud.application.sdk.api.log.ErrorLog;
import com.freemud.sdk.api.assortment.order.request.order.OrderStatusChangeRequestDto;
import com.freemud.sdk.api.assortment.order.response.order.QueryOrdersResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
/**
* All rights Reserved, Designed By www.freemud.cn
*
* @version V1.0
* @Title: InventoryService
* @Package cn.freemud.management.service.impl
* @Description:
* @author: shuhu.hou
* @date: 2020/4/24 17:56
* @Copyright: 2020 www.freemud.cn Inc. All rights reserved.
* 注意：本内容仅限于上海非码科技内部传阅，禁止外泄以及用于其他的商业目
*/
@Component
public class StockHandle {
private static final String backOrdersChangeOrderStatusConsumerQueue="program.backorders_change_order_status_consumer_queue";
private static final String backOrdersNotifyActivityExchange="program.backorders_notify_activity_exchange";
@Autowired
private MQService mqService;
/**
* 冲正库存、券码等
* @param request
* @param orderBean
*/
public void revert(OrderManagerRequest request, QueryOrdersResponse.DataBean.OrderBean orderBean){
ApiLog.info("backOrdersStatusChange", orderBean.getOid(), String.valueOf(orderBean.getStatus()));
OrderStatusChangeRequestDto requestDto = new OrderStatusChangeRequestDto();
requestDto.setOid(orderBean.getOid());
requestDto.setOrderStatus(orderBean.getStatus());
try {
Header header = new Header(MQAction.INSERT.getAction(), "backOrdersStatusChange", orderBean.getOid(), backOrdersChangeOrderStatusConsumerQueue);
MQMessage<OrderStatusChangeRequestDto> message = new MQMessage<>(header, requestDto);
mqService.convertAndSend(backOrdersNotifyActivityExchange, backOrdersChangeOrderStatusConsumerQueue, message);
} catch (Exception e) {
ErrorLog.errorConvertJson(this.getClass(),"activityReverseError:"+orderBean.getOid(),e);
}
}
}
order-management/src/main/java/cn/freemud/management/service/impl/OrderDeliveryService.java
......@@ -4,9 +4,11 @@ import cn.freemud.base.entity.BaseResponse;
import cn.freemud.base.log.LogTreadLocal;
import cn.freemud.management.adapter.DeliverySdkAdapter;
import cn.freemud.management.entities.dto.request.delivery.DeliveryOrderRequest;
import cn.freemud.management.entities.dto.request.order.OrderManagerRequest;
import cn.freemud.management.enums.DeliveryStatus;
import cn.freemud.management.enums.ResponseResult;
import cn.freemud.management.service.OrderBaseService;
import cn.freemud.management.service.handle.DeliveryHandle;
import cn.freemud.management.util.CommonResp;
import cn.freemud.management.util.ResponseUtil;
import com.freemud.application.sdk.api.deliverycenter.dto.CancelDeliveryOrderRequestDto;
......@@ -35,17 +37,11 @@ public class OrderDeliveryService {
@Autowired
private StoreCenterService storeCenterService;
@Autowired
private DeliveryService deliveryService;
@Autowired
private OrderBaseService orderBaseService;
@Autowired
private DeliverySdkAdapter deliverySdkAdapter;
@Value("${saas.order.delivery.callBackUrl}")
private String deliveryCallBackUrl;
private DeliveryHandle deliveryHandle;
private int SUCCESS = 100;
private String delivery_type_self = "self";
private static final int SUCCESS = 100;
/**
* 外卖单创建配送信息
......@@ -56,114 +52,27 @@ public class OrderDeliveryService {
public BaseResponse createDelivery(String orderCode, String operator) {
QueryOrdersResponse.DataBean.OrderBean orderBean = orderBaseService.getByOrderCode(orderCode);
if (null == orderBean) {
return CommonResp.fail("订单不存在");
}
Pair<Boolean, String> delivery = this.createDelivery(orderBean, null, operator);
return delivery.getKey()? ResponseUtil.success():ResponseUtil.error(ResponseResult.DELIVERY_CREATE_ORDER_ERROR);
}
/**
* 创建配送信息
*
* @param orderBean
* @return
*/
public Pair<Boolean, String> createDelivery(QueryOrdersResponse.DataBean.OrderBean orderBean,StoreResponse storeInfo, String operator) {
Pair<Boolean, String> pair = checkOrderOfDelivery(orderBean);
if (!pair.getKey()) {
return new Pair<>(true, "该订单不是外卖类型订单,无需创建配送单");
return ResponseUtil.error(ResponseResult.ORDER_NOT_EXIST);
}
if (storeInfo==null){
storeInfo = storeCenterService.getStoreInfo(new StoreInfoRequest(orderBean.getCompanyId(), orderBean.getShopId()), LogTreadLocal.getTrackingNo());
StoreResponse storeInfo = storeCenterService.getStoreInfo(new StoreInfoRequest(orderBean.getCompanyId(), orderBean.getShopId()), LogTreadLocal.getTrackingNo());
if (SUCCESS != storeInfo.getStatusCode() || storeInfo.getBizVO() == null) {
return new Pair<>(false, "获取门店信息失败");
}
}
// 调用配送系统创建配送单
CreateDeliveryOrderRequestDto requestDto = deliverySdkAdapter.buildDeliveryOrderRequestDto(orderBean, storeInfo, deliveryCallBackUrl);
CreateDeliveryOrderResponseDto deliveryResponse = deliveryService.deliveryOrderAdd(requestDto, LogTreadLocal.getTrackingNo());
if (StringUtils.isBlank(operator)) {
operator = "系统";
}
//创建配送单失败，更新订单为异常单
if (deliveryResponse == null || SUCCESS != deliveryResponse.getCode() || deliveryResponse.getData() == null) {
String deliveryId = deliveryResponse != null && deliveryResponse.getData() != null ? deliveryResponse.getData().getDeliveryId() : "";
orderBaseService.updateDeliveryAbnormal(orderBean.getCompanyId(), orderBean.getOid(), deliveryId, operator);
return new Pair<>(true, "创建配送单信息失败，配送状态更新为配送异常");
}
// 创建配送单成功
orderBaseService.updateDeliverySuccess(orderBean.getOid(), deliveryResponse.getData().getDeliveryId(), operator);
return new Pair<>(true, "创建配送单成功");
return ResponseUtil.error(ResponseResult.STORE_INFO_NOT_FOUND);
}
/**
* 校验订单是否符合创建配送单要求
*
* @param orderBean
* @return
*/
public Pair<Boolean, String> checkOrderOfDelivery(QueryOrdersResponse.DataBean.OrderBean orderBean) {
//判断外卖单
if (1 != orderBean.getType()) {
return new Pair<>(false, "该订单不是外卖类型订单");
}
//非支付宝、微信渠道不创建配送单
if (!(orderBean.getSource().equalsIgnoreCase(OrderSourceType.SAAS.getCode()) || orderBean.getSource().equalsIgnoreCase(OrderSourceType.ALIPAY.getCode()))) {
return new Pair<>(false, "订单来源异常");
}
//配送信息为空，则不创建配送单
if (orderBean.getAddInfo() == null || orderBean.getAddInfo().getDeliveryType() == null) {
return new Pair<>(false, "未找到订单配送信息");
}
//自配送不创建配送单
if (delivery_type_self.equalsIgnoreCase(orderBean.getAddInfo().getDeliveryType())) {
return new Pair<>(false, "该订单为自配送");
}
return new Pair<>(true, "success");
return deliveryHandle.createDelivery(orderBean, null, storeInfo);
}
/**
* 取消外卖配送单
*
* @return
*/
public BaseResponse cancelDeliveryOrder(DeliveryOrderRequest request) {
BaseResponse baseResponse = new BaseResponse();
baseResponse.setCode(SUCCESS + "");
QueryOrdersResponse.DataBean.OrderBean data = orderBaseService.getByOrderCode(request.getOrderCode());
if (null == data) {
baseResponse.setCode("101");
baseResponse.setMessage("订单不存在");
return baseResponse;
}
if (data.getType() == 1 && data.getAddInfo() != null && ObjectUtils.equals(data.getAddInfo().getDeliveryType(), "third")) {
Integer deliverStatus = data.getAddInfo().getDeliverStatus();
//运单异常或取消时，无需作废三方配送运单
if (ObjectUtils.equals(DeliveryStatus.DELIVERYERROR.getCode(), deliverStatus)
|| ObjectUtils.equals(DeliveryStatus.DELIVERYCANCEL.getCode(), deliverStatus)
|| ObjectUtils.equals(DeliveryStatus.DELIVERYARRIVED.getCode(), deliverStatus)) {
return baseResponse;
}
//运单状态非待接单或系统接单时，不能取消运单
if (ObjectUtils.equals(DeliveryStatus.RIDERSTARTDELIVERY.getCode(), deliverStatus)) {
baseResponse.setCode("101");
baseResponse.setMessage("配送单不能取消");
return baseResponse;
}
CancelDeliveryOrderRequestDto cancelDeliveryOrderRequestDto = new CancelDeliveryOrderRequestDto();
cancelDeliveryOrderRequestDto.setDeliveryId(data.getAddInfo().getDeliveryId());
cancelDeliveryOrderRequestDto.setOrderCancelCode(4);
//商家退款取消配送
cancelDeliveryOrderRequestDto.setOrderCancelDescription("顾客取消订单");
DeliveryResponseDto deliveryResponse = deliveryService.deliveryOrderCancel(cancelDeliveryOrderRequestDto, LogThreadLocal.getTrackingNo());
if (deliveryResponse == null || SUCCESS != deliveryResponse.getCode()) {
baseResponse.setCode("101");
baseResponse.setMessage("取消配送单异常，不能操作");
return baseResponse;
}
return ResponseUtil.error(ResponseResult.ORDER_NOT_EXIST);
}
return baseResponse;
return deliveryHandle.cancelDelivery(data, null);
}
......
order-management/src/main/java/cn/freemud/management/service/impl/OrderVerifyService.java deleted 100644 → 0
package cn.freemud.management.service.impl;
import cn.freemud.base.entity.BaseResponse;
import cn.freemud.management.entities.dto.request.order.OrderManagerRequest;
import cn.freemud.management.entities.dto.response.order.OrderManagerResponse;
import cn.freemud.management.enums.OrderSource;
import cn.freemud.management.enums.OrderStatus;
import cn.freemud.management.enums.ResponseResult;
import cn.freemud.management.util.ResponseUtil;
import com.freemud.application.sdk.api.ordercenter.enums.OperateClient;
import com.freemud.sdk.api.assortment.order.response.order.QueryOrdersResponse;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang.ObjectUtils;
import org.springframework.stereotype.Service;
/**
* All rights Reserved, Designed By www.freemud.cn
*
* @version V1.0
* @Title: OrderVerifyService
* @Package cn.freemud.management.service.impl
* @Description:
* @author: shuhu.hou
* @date: 2020/3/26 16:04
* @Copyright: 2020 www.freemud.cn Inc. All rights reserved.
* 注意：本内容仅限于上海非码科技内部传阅，禁止外泄以及用于其他的商业目
*/
@Service
public class OrderVerifyService {
/**
* 接单校验
*
* @param orderBean
* @param request
* @return
*/
public BaseResponse orderConfirmTakeVerify(QueryOrdersResponse.DataBean.OrderBean orderBean, OrderManagerRequest request) {
if (orderBean == null) {
return ResponseUtil.error(ResponseResult.ORDER_NOT_EXIST);
}
if (!OrderStatus.TAKE_ORDER.getCode().equals(orderBean.getStatus())) {
return ResponseUtil.error(ResponseResult.ORDER_CANNOT_CONFIRM,getOrderManagerResponse(orderBean));
}
return commonVerify(orderBean, request);
}
/**
* 订单配送校验
* @param orderBean
* @param request
* @return
*/
public BaseResponse orderDeliveryVerify(QueryOrdersResponse.DataBean.OrderBean orderBean, OrderManagerRequest request) {
if (orderBean == null) {
return ResponseUtil.error(ResponseResult.ORDER_NOT_EXIST);
}
//已完成的订单不能配送
if(OrderStatus.COMPLETE.getCode().equals(orderBean.getStatus())){
return ResponseUtil.error(ResponseResult.ORDER_IS_COMPLETE_CAN_NOT_DELIVERY,getOrderManagerResponse(orderBean));
}
//订单已经发送过配送
if(OrderStatus.DISTRIBUTION.getCode().equals(orderBean.getStatus())){
return ResponseUtil.error(ResponseResult.DELIVERY_SEND_REPETITION,getOrderManagerResponse(orderBean));
}
//判断订单状态是否为已经申请退款订单
if (orderBean.getHasRefund() != null
&& orderBean.getHasRefund()
&& (orderBean.getRefundList().get(orderBean.getRefundList().size() - 1).getStatus() == 1
|| orderBean.getRefundList().get(orderBean.getRefundList().size() - 1).getStatus() == 4)) {
return ResponseUtil.error(ResponseResult.DELIVERY_SEND_APPLY_REFUND,getOrderManagerResponse(orderBean));
}
//外卖订单不是接单不能送出
if (!OrderStatus.RECEIPT.getCode().equals(orderBean.getStatus())) {
return ResponseUtil.error(ResponseResult.DELIVERY_SEND_STATUS_NOTAKE,getOrderManagerResponse(orderBean));
}
return commonVerify(orderBean, request);
}
/**
* 订单制作完成校验
* @param orderBean
* @param request
* @return
*/
public BaseResponse orderDoneVerify(QueryOrdersResponse.DataBean.OrderBean orderBean, OrderManagerRequest request) {
if (orderBean == null) {
return ResponseUtil.error(ResponseResult.ORDER_NOT_EXIST);
}
//已制作完成的订单不能重复操作
if (OrderStatus.COMPLETE_MAKE.getCode().equals(orderBean.getStatus())) {
return ResponseUtil.error(ResponseResult.DONE_FAIL_REPETITION,getOrderManagerResponse(orderBean));
}
//订单非接单状态，不能制作完成
if (!OrderStatus.RECEIPT.getCode().equals(orderBean.getStatus())) {
return ResponseUtil.error(ResponseResult.DONE_FAIL_NOT_ACCEPT,getOrderManagerResponse(orderBean));
}
//判断订单状态是否为已经申请退款订单
if (orderBean.getHasRefund() != null
&& orderBean.getHasRefund()
&& (orderBean.getRefundList().get(orderBean.getRefundList().size() - 1).getStatus() == 1
|| orderBean.getRefundList().get(orderBean.getRefundList().size() - 1).getStatus() == 4)) {
return ResponseUtil.error(ResponseResult.DONE_FAIL_APPLY_REFUND,getOrderManagerResponse(orderBean));
}
return ResponseUtil.success();
}
/**
* 订单完成校验
* @param orderBean
* @param request
* @return
*/
public BaseResponse orderAffirmVerify(QueryOrdersResponse.DataBean.OrderBean orderBean, OrderManagerRequest request) {
if (orderBean == null) {
return ResponseUtil.error(ResponseResult.ORDER_NOT_EXIST);
}
//判断订单是否已送达
if (OrderStatus.COMPLETE.getCode().equals(orderBean.getStatus())) {
return ResponseUtil.error(ResponseResult.DELIVERY_SEND_REPETITION,getOrderManagerResponse(orderBean));
}
//已取消的订单不能操作
if(OrderStatus.CANCEL.getCode().equals(orderBean.getStatus())){
return ResponseUtil.error(ResponseResult.ORDER_HAS_CANCELED,getOrderManagerResponse(orderBean));
}
//判断订单状态是否为已经申请退款订单
if (orderBean.getHasRefund() != null
&& orderBean.getHasRefund()
&& (orderBean.getRefundList().get(orderBean.getRefundList().size() - 1).getStatus() == 1
|| orderBean.getRefundList().get(orderBean.getRefundList().size() - 1).getStatus() == 4)) {
return ResponseUtil.error(ResponseResult.AFFIRM_FAIL_APPLY_REFUND,getOrderManagerResponse(orderBean));
}
//校验订单是否为配送状态
if(isWaimai(orderBean) && ObjectUtils.notEqual(OrderStatus.DISTRIBUTION.getCode(),orderBean.getStatus())){
return ResponseUtil.error(ResponseResult.ORDER_DELIVERY_FAILED,getOrderManagerResponse(orderBean));
}
return commonVerify(orderBean, request);
}
/**
* 通用校验
* @param orderBean
* @param request
* @return
*/
private BaseResponse commonVerify(QueryOrdersResponse.DataBean.OrderBean orderBean, OrderManagerRequest request) {
if (ObjectUtils.notEqual(orderBean.getCompanyId(), request.getPartnerId())) {
return ResponseUtil.error(ResponseResult.ORDER_PARTNER_ID_NOT_MATCTH,getOrderManagerResponse(orderBean));
}
//开放平台不传入门店
if (ObjectUtils.notEqual(request.getOperator(), OperateClient.OPEN_PLATFORM.getOpName()) && ObjectUtils.notEqual(orderBean.getShopId(), request.getStoreId())) {
return ResponseUtil.error(ResponseResult.ORDER_STORE_ID_NOT_MATCTH,getOrderManagerResponse(orderBean));
}
return ResponseUtil.success();
}
/**
* 是否是外卖
* @param orderBean
* @return
*/
private boolean isWaimai(QueryOrdersResponse.DataBean.OrderBean orderBean){
String source = orderBean.getSource();
if (OrderSource.BDWM.getSource().equals(source) || OrderSource.JDWM.getSource().equals(source)
|| OrderSource.MTWM.getSource().equals(source) || OrderSource.ELEME.getSource().equals(source)){
return true;
}
return false;
}
private OrderManagerResponse getOrderManagerResponse(QueryOrdersResponse.DataBean.OrderBean orderBean){
Integer refundStatus= CollectionUtils.isEmpty(orderBean.getRefundList())?null:orderBean.getRefundList().get(0).getStatus();
return new OrderManagerResponse(orderBean.getGmtExpect(),orderBean.getStatus(),refundStatus);
}
}
order-management/src/main/java/cn/freemud/management/service/impl/SaasOrderMangerServiceImpl.java
......@@ -3,22 +3,21 @@ package cn.freemud.management.service.impl;
import cn.freemud.base.entity.BaseResponse;
import cn.freemud.management.entities.dto.request.order.OrderManagerRequest;
import cn.freemud.management.entities.dto.response.order.OrderManagerResponse;
import cn.freemud.management.entities.dto.response.pay.PayRefundResponse;
import cn.freemud.management.enums.OperateType;
import cn.freemud.management.enums.OrderStatus;
import cn.freemud.management.enums.RefundStatus;
import cn.freemud.management.enums.ResponseResult;
import cn.freemud.management.service.OrderBaseService;
import cn.freemud.management.service.OrderManagerService;
import cn.freemud.management.service.handle.DeliveryHandle;
import cn.freemud.management.service.handle.PaymentHandle;
import cn.freemud.management.service.handle.SaasOrderHandle;
import cn.freemud.management.service.handle.StockHandle;
import cn.freemud.management.util.ResponseUtil;
import com.freemud.application.sdk.api.storecenter.request.StoreInfoRequest;
import com.freemud.application.sdk.api.storecenter.response.StoreResponse;
import com.freemud.application.sdk.api.storecenter.service.StoreCenterService;
import com.freemud.sdk.api.assortment.order.adapter.OrderSdkAdapter;
import com.freemud.sdk.api.assortment.order.request.order.BaseQueryOrderRequest;
import com.freemud.sdk.api.assortment.order.response.order.BaseOrderResponse;
import com.freemud.sdk.api.assortment.order.response.order.QueryOrdersResponse;
import com.freemud.sdk.api.assortment.order.service.OrderCenterSdkService;
import javafx.util.Pair;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang.ObjectUtils;
import org.springframework.beans.factory.annotation.Autowired;
......@@ -40,17 +39,17 @@ import org.springframework.stereotype.Service;
public class SaasOrderMangerServiceImpl implements OrderManagerService {
@Autowired
private OrderSdkAdapter orderSdkAdapter;
private SaasOrderHandle saasOrderHandle;
@Autowired
private OrderCenterSdkService orderCenterSdkService;
private OrderBaseService orderBaseService;
@Autowired
private SaasOrderService saasOrderService;
private StoreCenterService storeCenterService;
@Autowired
private OrderDeliveryService orderDeliveryService;
private PaymentHandle paymentHandle;
@Autowired
private OrderBaseService orderBaseService;
private StockHandle stockHandle;
@Autowired
private StoreCenterService storeCenterService;
private DeliveryHandle deliveryHandle;
/**
......@@ -63,15 +62,12 @@ public class SaasOrderMangerServiceImpl implements OrderManagerService {
@Override
public BaseResponse<OrderManagerResponse> orderConfirm(OrderManagerRequest request, QueryOrdersResponse.DataBean.OrderBean orderBean) {
// 订单接单
saasOrderService.orderConfirm(request, orderBean);
saasOrderHandle.orderConfirm(request, orderBean);
//获取门店信息
StoreResponse storeInfo = storeCenterService.getStoreInfo(new StoreInfoRequest(orderBean.getCompanyId(), orderBean.getShopId()), "");
if (ObjectUtils.notEqual(ResponseResult.SUCCESS.getCode(), storeInfo.getStatusCode().toString()) || storeInfo.getBizVO() == null) {
return ResponseUtil.error(ResponseResult.STORE_NOT_FOUND);
}
// 创建配送单
orderDeliveryService.createDelivery(orderBean, storeInfo, request.getOperator());
// 推送pos消息中心
deliveryHandle.createDelivery(orderBean, request, storeInfo);
// 推送pos、微信消息中心
orderBaseService.sendMessage(orderBean, OperateType.ORDER_CONFIRM, request.getReason());
return ResponseUtil.success(new OrderManagerResponse(storeInfo.getBizVO().getOrderPrintConfig(), orderBean.getGmtExpect(),
CollectionUtils.isEmpty(orderBean.getRefundList()) ? null : RefundStatus.getByCode(orderBean.getRefundList().get(0).getStatus())));
......@@ -87,8 +83,8 @@ public class SaasOrderMangerServiceImpl implements OrderManagerService {
@Override
public BaseResponse<OrderManagerResponse> orderDone(OrderManagerRequest request, QueryOrdersResponse.DataBean.OrderBean orderBean) {
// 订单制作完成
saasOrderService.orderDone(request, orderBean);
// 推送pos消息中心
saasOrderHandle.orderDone(request, orderBean);
// 推送pos、微信消息中心
orderBaseService.sendMessage(orderBean, OperateType.ORDER_DONE, request.getReason());
return ResponseUtil.success();
}
......@@ -103,8 +99,8 @@ public class SaasOrderMangerServiceImpl implements OrderManagerService {
@Override
public BaseResponse<OrderManagerResponse> orderDelivery(OrderManagerRequest request, QueryOrdersResponse.DataBean.OrderBean orderBean) {
// 订单配送
saasOrderService.orderDelivery(request, orderBean);
// 推送pos消息中心
saasOrderHandle.orderDelivery(request, orderBean);
// 推送pos、微信消息中心
orderBaseService.sendMessage(orderBean, OperateType.ORDER_SEND, request.getReason());
return ResponseUtil.success();
}
......@@ -119,10 +115,70 @@ public class SaasOrderMangerServiceImpl implements OrderManagerService {
@Override
public BaseResponse<OrderManagerResponse> orderAffirm(OrderManagerRequest request, QueryOrdersResponse.DataBean.OrderBean orderBean) {
// 订单完成
saasOrderService.orderAffirm(request, orderBean);
// 推送pos消息中心
saasOrderHandle.orderAffirm(request, orderBean);
// 推送pos、微信消息中心
orderBaseService.sendMessage(orderBean, OperateType.ORDER_AFFIRM, request.getReason());
return ResponseUtil.success();
}
/**
* 拒单
*
* @param request
* @param orderBean
* @return
*/
@Override
public BaseResponse<OrderManagerResponse> orderReject(OrderManagerRequest request, QueryOrdersResponse.DataBean.OrderBean orderBean) {
//支付退款
PayRefundResponse refundResponse = paymentHandle.refund(request, orderBean);
//订单拒单
saasOrderHandle.orderReject(request, refundResponse, orderBean);
// 推送pos、微信消息中心
orderBaseService.sendMessage(orderBean, OperateType.ORDER_REJECT, request.getReason());
//todo 可以考虑基于订单回调异步实现
//冲正库存
stockHandle.revert(request,orderBean);
return ResponseUtil.success();
}
/**
* 同意退款
*
* @param request
* @param orderBean
* @return
*/
@Override
public BaseResponse<OrderManagerResponse> orderAgreeRefund(OrderManagerRequest request, QueryOrdersResponse.DataBean.OrderBean orderBean) {
//取消配送单
deliveryHandle.cancelDelivery(orderBean,request);
//支付退款
PayRefundResponse refundResponse = paymentHandle.refund(request, orderBean);
//订单同意退款
saasOrderHandle.refundAgree(request, refundResponse, orderBean);
// 推送pos、微信消息中心
orderBaseService.sendMessage(orderBean, OperateType.ORDER_AGREE_REFUND, request.getReason());
//todo 可以考虑基于订单回调异步实现
//冲正库存
stockHandle.revert(request,orderBean);
return ResponseUtil.success();
}
/**
* 拒绝退款
*
* @param request
* @param orderBean
* @return
*/
@Override
public BaseResponse<OrderManagerResponse> orderRejectRefund(OrderManagerRequest request, QueryOrdersResponse.DataBean.OrderBean orderBean) {
//拒绝退款
saasOrderHandle.refundReject(request,orderBean);
// 推送pos、微信消息中心
orderBaseService.sendMessage(orderBean, OperateType.ORDER_REJECT_REFUND, request.getReason());
return ResponseUtil.success();
}
}
order-management/src/main/java/cn/freemud/management/service/impl/WaimaiOrderMangerServiceImpl.java
......@@ -8,7 +8,9 @@ import cn.freemud.management.entities.dto.response.order.OrderManagerResponse;
import cn.freemud.management.enums.ResponseResult;
import cn.freemud.management.service.OrderManagerService;
import cn.freemud.management.util.ResponseUtil;
import com.freemud.application.sdk.api.takeaway.request.order.AgreeOrderRequest;
import com.freemud.application.sdk.api.takeaway.request.order.OrderSendOutRequest;
import com.freemud.application.sdk.api.takeaway.request.order.PartnerCancelRequest;
import com.freemud.application.sdk.api.takeaway.request.order.PlatformOrderRequest;
import com.freemud.application.sdk.api.takeaway.service.WaimaiOrderService;
import com.freemud.sdk.api.assortment.order.response.order.QueryOrdersResponse;
......@@ -36,6 +38,12 @@ public class WaimaiOrderMangerServiceImpl implements OrderManagerService {
@Autowired
private WaimaiSdkAdapter waimaiSdkAdapter;
/**
* 接单
* @param request 请求参数
* @param orderBean 订单实体
* @return
*/
@Override
public BaseResponse<OrderManagerResponse> orderConfirm(OrderManagerRequest request, QueryOrdersResponse.DataBean.OrderBean orderBean) {
PlatformOrderRequest platformOrderRequest = waimaiSdkAdapter.getPlatformOrderRequest(request, orderBean);
......@@ -70,7 +78,7 @@ public class WaimaiOrderMangerServiceImpl implements OrderManagerService {
OrderSendOutRequest orderSendOutRequest = waimaiSdkAdapter.getOrderSendOutRequest(request, orderBean);
com.freemud.application.sdk.api.base.BaseResponse sendoutResponse = waimaiOrderService.sendout(orderSendOutRequest, LogTreadLocal.getTrackingNo());
if (ObjectUtils.notEqual(ResponseResult.SUCCESS.getCode(), sendoutResponse.getCode())) {
return ResponseUtil.error(ResponseResult.ORDER_ACCEPT_FAILED);
return ResponseUtil.error(ResponseResult.DELIVERY_FAIL);
}
return ResponseUtil.success();
}
......@@ -87,8 +95,60 @@ public class WaimaiOrderMangerServiceImpl implements OrderManagerService {
OrderSendOutRequest orderArriveRequest = waimaiSdkAdapter.getOrderArriveRequest(request, orderBean);
com.freemud.application.sdk.api.base.BaseResponse arriveResponse = waimaiOrderService.arrive(orderArriveRequest, LogTreadLocal.getTrackingNo());
if (ObjectUtils.notEqual(ResponseResult.SUCCESS.getCode(), arriveResponse.getCode())) {
return ResponseUtil.error(ResponseResult.ORDER_ACCEPT_FAILED);
return ResponseUtil.error(ResponseResult.AFFIRM_ORDER_FAIL);
}
return ResponseUtil.success();
}
/**
* 拒单
*
* @param request
* @param orderBean
* @return
*/
@Override
public BaseResponse<OrderManagerResponse> orderReject(OrderManagerRequest request, QueryOrdersResponse.DataBean.OrderBean orderBean) {
PartnerCancelRequest partnerCancelRequest = waimaiSdkAdapter.getPartnerCancelRequest(request, orderBean);
com.freemud.application.sdk.api.base.BaseResponse rejectResponse = waimaiOrderService.reject(partnerCancelRequest, "");
if (ObjectUtils.notEqual(ResponseResult.SUCCESS.getCode(), rejectResponse.getCode())) {
return ResponseUtil.error(ResponseResult.REJECT_ORDER_FAIL);
}
return ResponseUtil.success();
}
/**
* 同意退款
*
* @param request
* @param orderBean
* @return
*/
@Override
public BaseResponse<OrderManagerResponse> orderAgreeRefund(OrderManagerRequest request, QueryOrdersResponse.DataBean.OrderBean orderBean) {
AgreeOrderRequest agreeOrderRequest = waimaiSdkAdapter.getAgreeOrderRequest(request, orderBean,true);
com.freemud.application.sdk.api.base.BaseResponse agreeRefundResponse = waimaiOrderService.isAgreeRefund(agreeOrderRequest, "");
if (ObjectUtils.notEqual(ResponseResult.SUCCESS.getCode(), agreeRefundResponse.getCode())) {
return ResponseUtil.error(ResponseResult.AGREE_REFUND_ORDER_FAIL);
}
return ResponseUtil.success();
}
/**
* 拒绝退款
*
* @param request
* @param orderBean
* @return
*/
@Override
public BaseResponse<OrderManagerResponse> orderRejectRefund(OrderManagerRequest request, QueryOrdersResponse.DataBean.OrderBean orderBean) {
AgreeOrderRequest agreeOrderRequest = waimaiSdkAdapter.getAgreeOrderRequest(request, orderBean,false);
com.freemud.application.sdk.api.base.BaseResponse agreeRefundResponse = waimaiOrderService.isAgreeRefund(agreeOrderRequest, "");
if (ObjectUtils.notEqual(ResponseResult.SUCCESS.getCode(), agreeRefundResponse.getCode())) {
return ResponseUtil.error(ResponseResult.REJECT_REFUND_ORDER_FAIL);
}
return ResponseUtil.success();
}
}
ordercenter-sdk/src/main/java/com/freemud/application/sdk/api/ordercenter/request/OrderExtInfoDto.java
......@@ -65,5 +65,9 @@ public class OrderExtInfoDto {
* 版本号
*/
private String version;
/**
* 来源appId
*/
private String fromAppId;
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment