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

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

+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

+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

+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

+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

+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

+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

+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

+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

+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

+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

+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

+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, "该订单不是外卖类型订单,无需创建配送单");
-        }
-        if (storeInfo==null){
-            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 = "系统";
+            return ResponseUtil.error(ResponseResult.ORDER_NOT_EXIST);
         }
-        //创建配送单失败，更新订单为异常单
-        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, "创建配送单信息失败，配送状态更新为配送异常");
+        StoreResponse storeInfo = storeCenterService.getStoreInfo(new StoreInfoRequest(orderBean.getCompanyId(), orderBean.getShopId()), LogTreadLocal.getTrackingNo());
+        if (SUCCESS != storeInfo.getStatusCode() || storeInfo.getBizVO() == null) {
+            return ResponseUtil.error(ResponseResult.STORE_INFO_NOT_FOUND);
         }
-        // 创建配送单成功
-        orderBaseService.updateDeliverySuccess(orderBean.getOid(), deliveryResponse.getData().getDeliveryId(), operator);
-        return new Pair<>(true, "创建配送单成功");
-    }
-
-    /**
-     * 校验订单是否符合创建配送单要求
-     *
-     * @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

-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;
 
 }