Merge branch 'feature/20201015_麦咖啡允许重复申请退款_xukang' into 2020/10/29-fabu-huiyang

# Conflicts:
#	assortment-ordercenter-sdk/pom.xml
#	order-application-service/pom.xml
#	order-management/pom.xml
#	ordercenter-sdk/pom.xml

assortment-ordercenter-sdk/src/main/java/com/freemud/sdk/api/assortment/order/enums/RefundStatus.java

+/**
+ * All rights Reserved, Designed By www.freemud.cn
+ *
+ * @Title: OrderType
+ * @Package cn.freemud.enums
+ * @Description: 订单状态
+ * @author: liming.guo
+ * @date: 2018/5/21 14:43
+ * @version V1.0
+ * @Copyright: 2018 www.freemud.cn Inc. All rights reserved.
+ * 注意：本内容仅限于上海非码科技内部传阅，禁止外泄以及用于其他的商业目
+ */
+package com.freemud.sdk.api.assortment.order.enums;
+
+public enum RefundStatus {
+
+    APPLY_REFUND(1, "申请退款"),
+    AGREE_REFUND(2, "同意退款"),
+    ALREADY_REFUND(3, "已退货"),
+    COMPLETE_REFUND(4, "退款完成"),
+    REFUSE_REFUND(5, "拒绝退款");
+
+
+    private Integer code;
+    private String desc;
+
+    RefundStatus(Integer code, String desc) {
+        this.code = code;
+        this.desc = desc;
+    }
+
+    public static RefundStatus getByCode(Integer code) {
+        for (RefundStatus status : values()) {
+            if (status.getCode().equals(code)) {
+                return status;
+            }
+        }
+        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;
+    }
+}

assortment-ordercenter-sdk/src/main/java/com/freemud/sdk/api/assortment/order/request/order/OrderRefundRequest.java

 package com.freemud.sdk.api.assortment.order.request.order;
 
+import com.freemud.application.sdk.api.ordercenter.enums.AfterSalesType;
 import com.freemud.sdk.api.assortment.order.config.BaseConfig;
 import lombok.Data;
 
@@ -24,6 +25,12 @@ public class OrderRefundRequest extends BaseConfig {
      */
     private Integer orderStatus;
 
+    //    申请金额，单位分，如果是全部退款，并且传递null,则自动填入 订单用户需支付金额"
+    private Long reqAmount = null;
+
+    //    实际金额，单位分，如果是全部退款，并且传递null,则自动填入 订单用户需支付金额"
+    private Long actualAmount = null;
+
     /**
      * 退款备注
      */
@@ -33,4 +40,16 @@ public class OrderRefundRequest extends BaseConfig {
 
     //操作人
     private String operator;
+    /**
+     *  若为null，默认只做【创建】，售后单状态为【待处理】
+     若为2，默认做【创建】+【审核通过】，售后单状态为【退货中】
+     若为5，默认做【创建】+【同意并退货完成】，售后单状态【已退货】
+     若为4，默认做【创建】+【同意并退款完成】，售后单状态为【完成】
+     *
+     */
+    private Integer createEvent;
+
+    private AfterSalesType afterSalesType;
+
+    private Integer orderClient;
 }

assortment-ordercenter-sdk/src/main/java/com/freemud/sdk/api/assortment/order/service/OrderCenterSdkService.java

@@ -108,6 +108,11 @@ public interface OrderCenterSdkService {
     BaseOrderResponse orderReject(CancelOrderRequest cancelOrderRequest);
 
     /**
+     * 订单POS拒单 POS
+     */
+    BaseOrderResponse mcCafeOrderReject(CancelOrderRequest cancelOrderRequest, QueryOrdersResponse.DataBean.OrderBean orderBean);
+
+    /**
      * 订单配送中 POS
      */
     BaseOrderResponse orderSend(BaseQueryOrderRequest baseQueryOrderRequest);

assortment-ordercenter-sdk/src/main/java/com/freemud/sdk/api/assortment/order/service/order/OrderCenterSdkServiceImpl.java

@@ -501,22 +501,32 @@ public class OrderCenterSdkServiceImpl implements OrderCenterSdkService {
     public BaseOrderResponse orderRefund(OrderRefundRequest orderRefundRequest) {
         CreateAfterSalesOrder request = new CreateAfterSalesOrder();
         request.setPartnerId(orderRefundRequest.getPartnerId());
+        if(null != orderRefundRequest.getOrderClient()) {
+            request.setOrderClient(orderRefundRequest.getOrderClient());
+        } else {
             request.setOrderClient(OrderClientType.SAAS.getIndex());
-        //实际金额，单位分，如果是全部退款，并且传递null,则自动填入 订单用户需支付金额
-        request.setActualAmount(null);
+        }
+        if(orderRefundRequest.getActualAmount() != null)
+        request.setActualAmount(orderRefundRequest.getActualAmount());
         //申请金额，单位分，如果是全部退款，并且传递null,则自动填入 订单用户需支付金额
-        request.setReqAmount(null);
+        request.setReqAmount(orderRefundRequest.getReqAmount());
         //是否有退货货物
         request.setHasCargo(false);
         //传入的售后单类型为：2：售中用户取消 8：售后申请
-        request.setAfterSalesType(AfterSalesType.USER_CANCEL.getIndex());
-        if (OldOrderStatus.COMPLETE.getCode().equals(orderRefundRequest.getOrderStatus())) {
+        if(null != orderRefundRequest.getAfterSalesType()) {
+            request.setAfterSalesType(orderRefundRequest.getAfterSalesType().getIndex());
+        } else if (OldOrderStatus.COMPLETE.getCode().equals(orderRefundRequest.getOrderStatus())) {
             request.setAfterSalesType(AfterSalesType.USER_SALE_RETURN.getIndex());
+        } else {
+            request.setAfterSalesType(AfterSalesType.USER_CANCEL.getIndex());
         }
         request.setOrderCode(orderRefundRequest.getOrderId());
         request.setReqRemark(orderRefundRequest.getRemark());
         request.setAfterSalesReason(orderRefundRequest.getReason());
         request.setOperator(orderRefundRequest.getOperator());
+        if(null != orderRefundRequest.getCreateEvent()) {
+            request.setCreateEvent(orderRefundRequest.getCreateEvent());
+        }
         // 查询门店服务配置，退单模式为2为自动退款，判断自动退款时间,设置为0则不传入timeout,
         StoreResponse.Configuration configuration = getStoreAutoConfiguration(orderRefundRequest.getPartnerId(), orderRefundRequest.getStoreId(), orderRefundRequest.getTrackingNo());
         if (configuration != null && ObjectUtils.equals("2", configuration.getAutoChargebackOrderType())
@@ -749,6 +759,64 @@ public class OrderCenterSdkServiceImpl implements OrderCenterSdkService {
     }
 
     @Override
+    public BaseOrderResponse mcCafeOrderReject(CancelOrderRequest cancelOrderRequest, QueryOrdersResponse.DataBean.OrderBean orderBean) {
+        if(CollectionUtils.isEmpty(orderBean.getRefundList())) {
+            OrderCancelReq request = new OrderCancelReq();
+            //商户号必传
+            request.setPartnerId(cancelOrderRequest.getPartnerId());
+            request.setOrderCode(cancelOrderRequest.getOrderId());
+            //售后单类型 1:其他取消 2:用户取消 3:商户取消 4:未支付超时关单 5:商户接单超时取消 6:商家拒单
+            // 7:配送用户拒收 8:用户售后退货/售后退款 9:系统取消 10:客服取消 11:用户统一取消，
+            request.setAfterSalesType(cancelOrderRequest.getAfterSalesType().getIndex() == null ? 1 : cancelOrderRequest.getAfterSalesType().getIndex());
+            request.setOrderClient(OrderClientType.SAAS.getIndex());
+            request.setCancelReason(cancelOrderRequest.getReason());
+            //若为4，默认做【创建】+【同意并退款完成】，售后单状态为【完成】
+            request.setCreateEvent(4);
+            request.setOperator(cancelOrderRequest.getOperator());
+            request.setAfterSerialNo(cancelOrderRequest.getRefundSerialNo());
+            com.freemud.application.sdk.api.ordercenter.response.BaseResponse response = orderSdkService.cancelOrder(request, cancelOrderRequest.getTrackingNo());
+            return orderSdkAdapter.convent2BaseOrderResponse(response);
+        } else {
+            for(int i=0;i<orderBean.getRefundList().size();i++) {
+                if (RefundStatus.APPLY_REFUND.getCode().equals(orderBean.getRefundList().get(i).getStatus())) {
+                    AfterSalesOperateReq request = new AfterSalesOperateReq();
+                    request.setOrderCode(cancelOrderRequest.getOrderId());
+                    request.setPartnerId(cancelOrderRequest.getPartnerId());
+                    request.setOrderClient(OrderClientType.SAAS.getIndex());
+                    request.setAfterSalesCode(orderBean.getRefundList().get(i).getRid());
+                    request.setAfterSerialNo(cancelOrderRequest.getRefundSerialNo());
+                    request.setAdultRemark(cancelOrderRequest.getReason());
+                    request.setOperator(cancelOrderRequest.getOperator());
+                    com.freemud.application.sdk.api.ordercenter.response.BaseResponse response = orderSdkService.adultApproveWithRefundComplete(request, cancelOrderRequest.getTrackingNo());
+                    return orderSdkAdapter.convent2BaseOrderResponse(response);
+                }
+                if (RefundStatus.COMPLETE_REFUND.getCode().equals(orderBean.getRefundList().get(i).getStatus())) {
+                    BaseOrderResponse response = new BaseOrderResponse();
+                    response.setErrcode(100);
+                    response.setErrmsg("success");
+                    return response;
+                }
+            }
+            OrderRefundRequest orderRefundRequest = new OrderRefundRequest();
+            orderRefundRequest.setPartnerId(cancelOrderRequest.getPartnerId());
+            orderRefundRequest.setStoreId(cancelOrderRequest.getStoreId());
+            orderRefundRequest.setOrderId(cancelOrderRequest.getOrderId());
+            orderRefundRequest.setOrderClient(OrderClientType.SAAS.getIndex());
+
+            orderRefundRequest.setAfterSalesType(cancelOrderRequest.getAfterSalesType().getIndex() == null ? AfterSalesType.PARTNER_REJECT
+                    : cancelOrderRequest.getAfterSalesType());
+            orderRefundRequest.setReason(cancelOrderRequest.getReason());
+            orderRefundRequest.setRemark(cancelOrderRequest.getReqRemark());
+            orderRefundRequest.setOperator(cancelOrderRequest.getOperator());
+            orderRefundRequest.setOrderStatus(orderBean.getStatus());
+            orderRefundRequest.setCreateEvent(4);
+
+            BaseOrderResponse baseOrderResponse = orderRefund(orderRefundRequest);
+            return baseOrderResponse;
+        }
+    }
+
+    @Override
     public BaseOrderResponse orderSend(BaseQueryOrderRequest baseQueryOrderRequest) {
         POSOrderOperationBaseReq request = new POSOrderOperationBaseReq();
         request.setOrderCode(baseQueryOrderRequest.getOrderId());

order-application-service/src/main/java/cn/freemud/adapter/OrderAdapter.java

@@ -34,6 +34,7 @@ import cn.freemud.enums.OrderSourceType;
 import cn.freemud.enums.OrderType;
 import cn.freemud.enums.PayStatus;
 import cn.freemud.enums.QueryOrderStatus;
+import cn.freemud.enums.RefundStatus;
 import cn.freemud.enums.ResponseResult;
 import cn.freemud.interceptor.ServiceException;
 import cn.freemud.redis.RedisCache;
@@ -104,6 +105,8 @@ public class OrderAdapter {
 
     @Value("${mccafe.partner.id}")
     private String mcCafePartnerId;
+    @Value("${mcCafe.refund.interval}")
+    private String mccafeRefundInterval;
 
     @Value("${saas.reverseNotifyiDcUrl}")
     private String reverseNotifyiDcUrl;
@@ -1191,7 +1194,36 @@ public class OrderAdapter {
                 responseVo.setModifiedTime(DateUtil.convert2String(new Date(ordersBean.getGmtModified()), "yyyy-MM-dd HH:mm:ss"));
             }
             if (ordersBean.getHasRefund() != null && ordersBean.getHasRefund() && CollectionUtils.isNotEmpty(ordersBean.getRefundList())) {
-                if (CollectionUtils.isNotEmpty(ordersBean.getRefundList())) {
+                if(mcCafePartnerId.equals(ordersBean.getCompanyId())) {
+
+                    QueryOrdersResponse.DataBean.OrderBean.RefundBean latestRefundBean = ordersBean.getRefundList().get(0);
+                    for(int i=0;i<ordersBean.getRefundList().size();i++) {
+                        QueryOrdersResponse.DataBean.OrderBean.RefundBean refundBean = ordersBean.getRefundList().get(i);
+                        if (RefundStatus.COMPLETE_REFUND.getCode().equals(refundBean.getStatus())
+                                || RefundStatus.APPLY_REFUND.getCode().equals(refundBean.getStatus())) {
+                            responseVo.setRid(refundBean.getRid());
+                            responseVo.setRefundStatus(refundBean.getStatus());
+                            responseVo.setRefundStatusDesc(Optional.ofNullable(RefundStatus.getByCode(refundBean.getStatus()))
+                                    .map(RefundStatus::getDesc).orElse(""));
+                            responseVo.setRefundReason(refundBean.getReason());
+                            String refundCreateTime = DateUtil.convert2String(new Date(Long.parseLong(refundBean.getCreateTime())),DateUtil.FORMAT_YYYY_MM_DD_HHMMSS);
+                            responseVo.setRefundCreateTime(refundCreateTime);
+                            break;
+                        } else {
+                            if(new Date(Long.valueOf(refundBean.getCreateTime())).after(new Date(Long.valueOf(latestRefundBean.getCreateTime())))) {
+                                latestRefundBean = refundBean;
+                            }
+                        }
+                    }
+
+                    if(StringUtils.isBlank(responseVo.getRid())) {
+                        if(new Date().getTime() - Long.parseLong(latestRefundBean.getCreateTime()) > Long.valueOf(mccafeRefundInterval)) {
+                            responseVo.setAfterRefundInterval(true);
+                        }
+                        responseVo.setRefundIntervalTime(Long.valueOf(latestRefundBean.getCreateTime()) + Long.valueOf(mccafeRefundInterval));
+                    }
+
+                } else {
                     QueryOrdersResponse.DataBean.OrderBean.RefundBean refundBean = ordersBean.getRefundList().get(0);
                     responseVo.setRid(refundBean.getRid());
                     responseVo.setRefundStatus(refundBean.getStatus());
@@ -1201,6 +1233,14 @@ public class OrderAdapter {
                     String refundCreateTime = DateUtil.convert2String(new Date(Long.parseLong(refundBean.getCreateTime())),DateUtil.FORMAT_YYYY_MM_DD_HHMMSS);
                     responseVo.setRefundCreateTime(refundCreateTime);
                 }
+            } else {
+                responseVo.setAfterRefundInterval(true);
+            }
+            //如果是已取消、拒单、已完成的订单，则设置不能申请取消订单
+            if(OrderStatus.REFUSE.getCode().equals(ordersBean.getStatus())
+                    || OrderStatus.CALCEL.getCode().equals(ordersBean.getStatus())
+                    || OrderStatus.COMPLETE.getCode().equals(ordersBean.getStatus())) {
+                responseVo.setAfterRefundInterval(false);
             }
             //商品信息转换
             convent2ProductVos(ordersBean.getProductList(), responseVo);

order-application-service/src/main/java/cn/freemud/entities/dto/QueryOrdersResponseDto.java

@@ -449,6 +449,13 @@ public class QueryOrdersResponseDto {
                  */
                 private Integer status;
 
+                private String remark;
+                //商家退单审核 备注
+                private String decisionReason;
+
+                //创建时间
+                private String createTime;
+
             }
 
             @NoArgsConstructor

order-application-service/src/main/java/cn/freemud/entities/vo/QueryOrderResponseVo.java

@@ -268,6 +268,14 @@ public class QueryOrderResponseVo {
      * 订单是否可申请退款  可申请退款条件 ：1 .支付未接单 2. 已接单，制作完成，配送中 ，用户可申请退款
      */
     private Boolean enableRefund;
+    /**
+     * 订单是否可再次申请退款  必须经过规定的间隔时间才可以再次申请
+     */
+    private Boolean afterRefundInterval = false;
+    /**
+     * 订单是否可再次申请退款  必须经过规定的间隔时间才可以再次申请
+     */
+    private Long refundIntervalTime = 0l;
 
 
     private List<ProductVo> products;

order-application-service/src/main/java/cn/freemud/service/impl/MCCafeOrderServiceImpl.java

@@ -131,6 +131,8 @@ public class MCCafeOrderServiceImpl implements MCCafeOrderService {
 
     @Value("${mcCafe.reverseNotifyiDcUrl}")
     private String reverseNotifyiDcUrl;
+    @Value("${mcCafe.refund.interval}")
+    private String mccafeRefundInterval;
     @Value("${program.backorders_change_order_status_consumer_queue}")
     private String backOrdersChangeOrderStatusConsumerQueue;
     @Value("${program.backorders_notify_activity_exchange}")
@@ -1069,13 +1071,22 @@ public class MCCafeOrderServiceImpl implements MCCafeOrderService {
 
         if (enableRefundCodes.contains(orderBean.getStatus()) && PayStatus.HAVE_PAID.getCode().equals(orderBean.getPayStatus())) {
             if (CollectionUtils.isNotEmpty(orderBean.getRefundList())) {
-                OrderBean.RefundBean refundBean = orderBean.getRefundList().get(0);
+
+                for(int i=0;i<orderBean.getRefundList().size();i++) {
+                    OrderBean.RefundBean refundBean = orderBean.getRefundList().get(i);
+                    if (RefundStatus.COMPLETE_REFUND.getCode().equals(refundBean.getStatus())) {
+                        return ResponseUtil.error(ResponseResult.ORDER__ERRORREFUND.getCode(), "订单已退款完成，无法再次退款");
+                    }
                     if (RefundStatus.APPLY_REFUND.getCode().equals(refundBean.getStatus())) {
                         return ResponseUtil.error(ResponseResult.ORDER__ERRORREFUND.getCode(), "商家正在处理中，请稍后……");
                     }
-                if (RefundStatus.REFUSE_REFUND.getCode().equals(refundBean.getStatus())) {
-                    return ResponseUtil.error(ResponseResult.ORDER__ERRORREFUND.getCode(), "您的申请已被商家拒绝，请联系门店沟通。");
+                    if(new Date().getTime() - Long.valueOf(refundBean.getCreateTime()) < Long.valueOf(mccafeRefundInterval)) {
+                        return ResponseUtil.error(ResponseResult.ORDER__ERRORREFUND.getCode(), "退款请求太频繁，请稍后再试");
+                    }
                 }
+//                if (RefundStatus.REFUSE_REFUND.getCode().equals(refundBean.getStatus())) {
+//                    return ResponseUtil.error(ResponseResult.ORDER__ERRORREFUND.getCode(), "您的申请已被商家拒绝，请联系门店沟通。");
+//                }
             }
 //            List<AssortmentOpenPlatformPartnerWxappConfig> partnerWxappConfigs = cacheOpenPlatformPartnerWxappConfigManager.cacheSelectDefaultPage(userInfo.getWxAppId(), "2");
 
@@ -1114,23 +1125,23 @@ public class MCCafeOrderServiceImpl implements MCCafeOrderService {
                 backOrdersStatusChange(orderBean.getOid(), orderBean.getStatus());
             } else if(OldOrderType.TAKE_OUT.getCode().equals(orderBean.getOrderType()) && CancelDeliveryResponseDto.hasCollectMsg.equals(deliveryBaseResponse.getErrmsg())) {
 
-                CancelOrderRequest cancelOrderRequest = new CancelOrderRequest();
-                cancelOrderRequest.setPartnerId(orderBean.getCompanyId());
-                cancelOrderRequest.setStoreId(orderBean.getShopId());
-                cancelOrderRequest.setOrderId(orderBean.getOid());
-                cancelOrderRequest.setOrderClient(orderAdapter.getNewOrderClient(orderBean.getSource()));
-
-                //传入的售后单类型为：2：售中用户取消 8：售后申请
-                cancelOrderRequest.setAfterSalesType(AfterSalesType.USER_CANCEL);
-                cancelOrderRequest.setReason(orderRefundVo.getReason());
-                cancelOrderRequest.setReqRemark(orderRefundVo.getRemarks());
-                cancelOrderRequest.setOperator(orderBean.getUserName());
-                cancelOrderRequest.setTrackingNo(LogTreadLocal.getTrackingNo());
-                cancelOrderRequest.setRefundDeliveryAmount(isRefundDeliveryFee);
-                BaseOrderResponse baseResponseDto = orderCenterSdkService.orderCancel(cancelOrderRequest);
-
-                if (!RESPONSE_SUCCESS_CODE.equals(baseResponseDto.getErrcode())) {
-                    return ResponseUtil.error(ResponseResult.ORDER__ERRORREFUND.getCode(), baseResponseDto.getErrmsg());
+                OrderRefundRequest orderRefundRequest = new OrderRefundRequest();
+                orderRefundRequest.setPartnerId(orderBean.getCompanyId());
+                orderRefundRequest.setStoreId(orderBean.getShopId());
+                orderRefundRequest.setOrderId(orderBean.getOid());
+                orderRefundRequest.setOrderClient(OrderClientType.SAAS.getIndex());
+
+                orderRefundRequest.setAfterSalesType(AfterSalesType.USER_CANCEL);
+                orderRefundRequest.setReason(orderRefundVo.getReason());
+                orderRefundRequest.setRemark(orderRefundVo.getRemarks());
+                orderRefundRequest.setOperator(orderBean.getUserName());
+                orderRefundRequest.setOrderStatus(orderBean.getStatus());
+                orderRefundRequest.setActualAmount(orderBean.getAmount());
+                orderRefundRequest.setReqAmount(orderBean.getAmount());
+
+                BaseOrderResponse baseOrderResponse = orderCenterSdkService.orderRefund(orderRefundRequest);
+                if (baseOrderResponse == null || baseOrderResponse.getData() == null || !ObjectUtils.equals(ResponseConstant.SUCCESS_RESPONSE_CODE, baseOrderResponse.getErrcode())) {
+                    return ResponseUtil.error(ResponseResult.ORDER__ERRORREFUND.getCode(), "创建售后单失败");
                 }
 //                if (orderBean.getAmount() > 0) {
 //                    sendPosMessage(partnerId, orderBean.getShopId());

order-application-service/src/main/java/cn/freemud/service/mccafe/CouponClientService.java

@@ -15,34 +15,13 @@ import java.util.List;
 
 public interface CouponClientService {
 
-    CouponRedeemResponse redeem(QueryOrdersResponse.DataBean.OrderBean orderBean, List<CreateOrderAccountRequest> accounts);
-
     CouponRedeemResponse redeem(MCCafeCouponRequest mcCafeCouponRequest);
 
-    CouponRedeemResponse redeemBatch(QueryOrdersResponse.DataBean.OrderBean orderBean, List<CreateOrderAccountRequest> accounts);
-
     List<CouponRedeemResponse> redeemBatch(QueryOrdersResponseDto.DataBean.OrderBean orderBean);
 
-    CouponRedeemResponse cancelRedeem(QueryOrdersResponse.DataBean.OrderBean orderBean, List<CreateOrderAccountRequest> accounts);
-
-    CouponQueryResponse query(MCCafeCouponRequest mcCafeCouponRequest);
-
     McdNetBatchQueryResponse batchQuery(MCCafeCouponRequest mcCafeCouponRequest);
 
-    CouponBaseResponse lock(QueryOrdersResponse.DataBean.OrderBean orderBean, List<CreateOrderAccountRequest> accounts);
-
     CouponBaseResponse lock(MCCafeCouponLockRequest mcCafeCouponLockRequest);
 
-    CouponBaseResponse lockBatch(QueryOrdersResponse.DataBean.OrderBean orderBean, List<CreateOrderAccountRequest> accounts);
-
     List<CouponBaseResponse> lockBatch(QueryOrdersResponseDto.DataBean.OrderBean orderBean);
-
-    CouponBaseResponse unlock(MCCafeCouponLockRequest mcCafeCouponLockRequest);
-
-    /**
-     * 移除卡包
-     * @param orderBean
-     * @return
-     */
-    BaseResponse callbackNotify(QueryOrdersResponseDto.DataBean.OrderBean orderBean) ;
 }

order-management/src/main/java/cn/freemud/management/service/handle/OrderVerifyHandle.java

@@ -19,6 +19,7 @@ import com.freemud.sdk.api.assortment.order.adapter.OrderSdkAdapter;
 import com.freemud.sdk.api.assortment.order.domain.ResponseCodeConstant;
 import com.freemud.sdk.api.assortment.message.enums.OrderType;
 import com.freemud.sdk.api.assortment.order.enums.OldOrderAccountType;
+import com.freemud.sdk.api.assortment.order.enums.RefundStatus;
 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;
@@ -260,9 +261,13 @@ public class OrderVerifyHandle {
         if (ObjectUtils.equals(OrderStatus.CANCEL.getCode(), orderBean.getStatus())) {
             return ResponseUtil.error(ResponseResult.ORDER_HAS_CANCELED);
         }
-        if(CollectionUtils.isNotEmpty(orderBean.getRefundList())
-                && orderBean.getRefundList().get(orderBean.getRefundList().size() - 1).getStatus() != 1) {
-            return ResponseUtil.error(ResponseResult.ORDER_REFUND_NOT_APPLY);
+        for (QueryOrdersResponse.DataBean.OrderBean.RefundBean refundBean : orderBean.getRefundList()) {
+            if(RefundStatus.APPLY_REFUND.getCode().equals(refundBean.getStatus())) {
+                return ResponseUtil.success();
+            }
+            if(RefundStatus.COMPLETE_REFUND.getCode().equals(refundBean.getStatus())) {
+                return ResponseUtil.error(ResponseResult.AGREE_REFUND_ORDER_FAIL.getCode(), "订单已经退款完成，不能重复申请");
+            }
         }
         return ResponseUtil.success();
     }

order-management/src/main/java/cn/freemud/management/service/handle/PaymentHandle.java

@@ -75,6 +75,34 @@ public class PaymentHandle {
         refundStatus=ObjectUtils.equals( PayRefundStatus.SUCCESS.getCode(), orderRefundResponse.getData().getRefundStatus())?PayRefundStatus.SUCCESS:PayRefundStatus.RUNNING;
         return handlePayRefundResponse(refundStatus,orderRefundRequest.getRefundId());
     }
+    /**
+     * 麦咖啡退款
+     * @param request
+     * @param orderBean
+     * @return
+     */
+    public PayRefundResponse mcCafeRefund(OrderManagerRequest request, QueryOrdersResponse.DataBean.OrderBean orderBean){
+        PayRefundStatus refundStatus=PayRefundStatus.SUCCESS;
+        OrderRefundRequest orderRefundRequest = paymentSdkAdapter.getOrderRefundRequest(orderBean, new BigDecimal(orderBean.getAmount()));
+        if (ObjectUtils.equals(orderBean.getAmount(), 0L)) {
+            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());
+    }
 
     /**
      * 获取退款金额

order-management/src/main/java/cn/freemud/management/service/handle/SaasOrderHandle.java

@@ -7,11 +7,17 @@ import cn.freemud.management.enums.ResponseResult;
 import cn.freemud.management.intercept.OrderServiceException;
 import cn.freemud.management.util.ResponseUtil;
 import com.freemud.application.sdk.api.log.LogThreadLocal;
+import com.freemud.application.sdk.api.ordercenter.enums.AfterSalesCreateEvent;
+import com.freemud.application.sdk.api.ordercenter.enums.AfterSalesType;
+import com.freemud.application.sdk.api.ordercenter.enums.OrderClientType;
+import com.freemud.application.sdk.api.ordercenter.request.AfterSalesOperateReq;
 import com.freemud.application.sdk.api.ordercenter.request.OrderModifyRelatingCodeReq;
 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.enums.RefundStatus;
 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.request.order.OrderRefundRequest;
 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;
@@ -147,6 +153,23 @@ public class SaasOrderHandle {
     }
 
     /**
+     * 麦咖啡拒单
+     *
+     * @param request
+     * @param orderBean
+     * @return
+     */
+    public BaseResponse mcCafeOrderReject(OrderManagerRequest request, PayRefundResponse refundResponse, QueryOrdersResponse.DataBean.OrderBean orderBean) {
+        //作废订单
+        CancelOrderRequest cancelOrderRequest = orderSdkAdapter.getCancelOrderRequest(request.getOperator(), request.getReason(), refundResponse.getPayRefundStatus(), refundResponse.getRefundId(), orderBean);
+        BaseOrderResponse baseOrderResponse = orderCenterSdkService.mcCafeOrderReject(cancelOrderRequest, orderBean);
+        if (baseOrderResponse == null || ObjectUtils.notEqual(ResponseResult.SUCCESS.getCode(), baseOrderResponse.getErrcode().toString())) {
+            return ResponseUtil.error(ResponseResult.AFFIRM_ORDER_FAIL);
+        }
+        return ResponseUtil.success();
+    }
+
+    /**
      * 同意退款
      *
      * @param request
@@ -169,6 +192,58 @@ public class SaasOrderHandle {
     }
 
     /**
+     * 麦咖啡同意退款
+     *
+     * @param request
+     * @param refundResponse
+     * @param orderBean
+     * @return
+     */
+    public BaseResponse mcCafeRefundAgree(OrderManagerRequest request, PayRefundResponse refundResponse, QueryOrdersResponse.DataBean.OrderBean orderBean) {
+        BaseQueryOrderRequest refundAgreeRequest = orderSdkAdapter.getRefundAgreeRequest(refundResponse.getRefundId(), request.getReason(), request.getOperator(), orderBean);
+        BaseOrderResponse baseOrderResponse = null;
+        for(int i=0;i<orderBean.getRefundList().size();i++) {
+
+            if (RefundStatus.APPLY_REFUND.getCode().equals(orderBean.getRefundList().get(i).getStatus())) {
+                refundAgreeRequest.setAfterSalesCode(orderBean.getRefundList().get(i).getRid());
+                if (PayRefundStatus.SUCCESS.equals(refundResponse.getPayRefundStatus())) {
+                    baseOrderResponse = orderCenterSdkService.refundComplete(refundAgreeRequest);
+                } else {
+                    baseOrderResponse = orderCenterSdkService.refundReturn(refundAgreeRequest);
+                }
+                break;
+            } else if (RefundStatus.COMPLETE_REFUND.getCode().equals(orderBean.getRefundList().get(i).getStatus())) {
+                baseOrderResponse = new BaseOrderResponse();
+                baseOrderResponse.setErrcode(Integer.valueOf(ResponseResult.AGREE_REFUND_ORDER_FAIL.getCode()));
+                baseOrderResponse.setErrmsg("订单已经退款完成，不能重复申请");
+                break;
+            }
+        }
+        if(null == baseOrderResponse) {
+            OrderRefundRequest orderRefundRequest = new OrderRefundRequest();
+            orderRefundRequest.setPartnerId(refundAgreeRequest.getPartnerId());
+            orderRefundRequest.setStoreId(refundAgreeRequest.getShopId());
+            orderRefundRequest.setOrderId(refundAgreeRequest.getOrderId());
+            orderRefundRequest.setOrderClient(OrderClientType.SAAS.getIndex());
+
+            orderRefundRequest.setAfterSalesType(AfterSalesType.PARTNER_CANCEL);
+            orderRefundRequest.setReason(refundAgreeRequest.getReason());
+            orderRefundRequest.setOperator(refundAgreeRequest.getOperator());
+            orderRefundRequest.setOrderStatus(orderBean.getStatus());
+            if (PayRefundStatus.SUCCESS.equals(refundResponse.getPayRefundStatus())) {
+                orderRefundRequest.setCreateEvent(4);
+            } else {
+                orderRefundRequest.setCreateEvent(5);
+            }
+            baseOrderResponse = orderCenterSdkService.orderRefund(orderRefundRequest);
+        }
+        if (baseOrderResponse == null || ObjectUtils.notEqual(ResponseResult.SUCCESS.getCode(), baseOrderResponse.getErrcode().toString())) {
+            return ResponseUtil.error(ResponseResult.AGREE_REFUND_ORDER_FAIL);
+        }
+        return ResponseUtil.success();
+    }
+
+    /**
      * 拒绝退款
      * @param request
      * @param orderBean
@@ -184,6 +259,33 @@ public class SaasOrderHandle {
     }
 
     /**
+     * 麦咖啡拒绝退款
+     * @param request
+     * @param orderBean
+     * @return
+     */
+    public BaseResponse mcCafeRefundReject(OrderManagerRequest request, QueryOrdersResponse.DataBean.OrderBean orderBean) {
+        CancelOrderRequest rejectRefundRequest = orderSdkAdapter.getRejectRefundRequest(request.getOperator(), request.getReason(), orderBean);
+        BaseOrderResponse baseOrderResponse = null;
+        for(int i=0;i<orderBean.getRefundList().size();i++) {
+
+            if (RefundStatus.APPLY_REFUND.getCode().equals(orderBean.getRefundList().get(i).getStatus())) {
+                rejectRefundRequest.setAfterSalesCode(orderBean.getRefundList().get(i).getRid());
+                baseOrderResponse = orderCenterSdkService.orderRefundReject(rejectRefundRequest);
+            }
+            if (RefundStatus.COMPLETE_REFUND.getCode().equals(orderBean.getRefundList().get(i).getStatus())) {
+                baseOrderResponse = new BaseOrderResponse();
+                baseOrderResponse.setErrcode(100);
+                baseOrderResponse.setErrmsg("success");
+            }
+        }
+        if (baseOrderResponse == null || ObjectUtils.notEqual(ResponseResult.SUCCESS.getCode(), baseOrderResponse.getErrcode().toString())) {
+            return ResponseUtil.error(ResponseResult.REJECT_REFUND_ORDER_FAIL);
+        }
+        return ResponseUtil.success();
+    }
+
+    /**
      * 取消订单
      */
     public BaseResponse orderCancel(OrderManagerRequest request, PayRefundResponse refundResponse,QueryOrdersResponse.DataBean.OrderBean orderBean) {

order-management/src/main/java/cn/freemud/management/service/impl/McCafeMangerServiceImpl.java

@@ -123,9 +123,9 @@ public class McCafeMangerServiceImpl implements OrderManagerService {
 
         }else {
             //支付退款
-            PayRefundResponse refundResponse = paymentHandle.refund(orderManagerRequest, orderBean);
+            PayRefundResponse refundResponse = paymentHandle.mcCafeRefund(orderManagerRequest, orderBean);
             //订单拒单
-            saasOrderHandle.orderReject(orderManagerRequest, refundResponse, orderBean);
+            saasOrderHandle.mcCafeOrderReject(orderManagerRequest, refundResponse, orderBean);
             //冲正库存
             stockHandle.revert(orderManagerRequest, orderBean);
         }
@@ -186,9 +186,9 @@ public class McCafeMangerServiceImpl implements OrderManagerService {
     @Override
     public BaseResponse<OrderManagerResponse> orderAgreeRefund(OrderManagerRequest request, QueryOrdersResponse.DataBean.OrderBean orderBean) {
         //支付退款
-        PayRefundResponse refund = paymentHandle.refund(request, orderBean);
+        PayRefundResponse refund = paymentHandle.mcCafeRefund(request, orderBean);
         //订单拒单
-        saasOrderHandle.refundAgree(request,refund, orderBean);
+        saasOrderHandle.mcCafeRefundAgree(request,refund, orderBean);
         //冲正库存
         stockHandle.revert(request, orderBean);
         return ResponseUtil.success();
@@ -204,7 +204,7 @@ public class McCafeMangerServiceImpl implements OrderManagerService {
     @Override
     public BaseResponse<OrderManagerResponse> orderRejectRefund(OrderManagerRequest request, QueryOrdersResponse.DataBean.OrderBean orderBean) {
         //拒绝退款
-        saasOrderHandle.refundReject(request,orderBean);
+        saasOrderHandle.mcCafeRefundReject(request,orderBean);
         return ResponseUtil.success();
     }
 
@@ -215,7 +215,7 @@ public class McCafeMangerServiceImpl implements OrderManagerService {
     @Override
     public BaseResponse<OrderManagerResponse> orderCancel(OrderManagerRequest request, QueryOrdersResponse.DataBean.OrderBean orderBean) {
         //支付退款
-        PayRefundResponse refund = paymentHandle.refund(request, orderBean);
+        PayRefundResponse refund = paymentHandle.mcCafeRefund(request, orderBean);
         //订单拒单
         saasOrderHandle.orderCancel(request,refund, orderBean);
         //冲正库存