Merge branch 'KA-接口调用订单退款' into 'master'

Ka 接口调用订单退款

See merge request !136

order-application-service/src/main/java/cn/freemud/controller/OrderDeveloperController.java

+package cn.freemud.controller;
+
+import cn.freemud.base.entity.BaseResponse;
+import cn.freemud.entities.vo.OrderDevelopRefundVo;
+import cn.freemud.entities.vo.OrderRefundVo;
+import cn.freemud.service.Orderservice;
+import com.freemud.application.sdk.api.log.ApiAnnotation;
+import com.freemud.application.sdk.api.log.LogParams;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * @author : xh.Z
+ * @email : fisherman0510@163.com
+ * @Date : 2022/4/30 14:55
+ * @description : 针对开发人员开放的接口操作, 不暴露给外部人员
+ */
+@RequestMapping("/order/develop")
+@RestController
+public class OrderDeveloperController {
+
+    @Autowired
+    private Orderservice orderservice;
+
+    /**
+     * 订单内部人员操作 给订单退款, 使用该接口需要报备
+     * 1.生成售后单
+     * 2.直接调用oms进行退款处理
+     */
+    @ApiAnnotation(logMessage = "/order/develop/refund")
+    @PostMapping("/refund")
+    public BaseResponse developRefund(@Validated @LogParams @RequestBody OrderDevelopRefundVo orderRefundVo) {
+        return orderservice.developRefund(orderRefundVo);
+    }
+
+}

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

+package cn.freemud.entities.vo;
+
+import com.freemud.application.sdk.api.ordercenter.enums.RefundModeEnum;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import javax.validation.constraints.NotBlank;
+import java.util.List;
+
+/**
+ * @author : xh.Z
+ * @email : fisherman0510@163.com
+ * @Date : 2022/4/30 15:03
+ * @description :
+ */
+@Data
+public class OrderDevelopRefundVo {
+    /**
+     * 订单号
+     */
+    private List<String> orderCodes;
+
+    private String partnerId;
+
+    /**
+     * 退款理由
+     */
+    private String reason;
+
+    /**
+     * 操作人,需要记录操作人
+     */
+    @NotBlank(message = "请真实填写调动该接口的操作人")
+    private String operator;
+
+    /**
+     * 微商城退款方式
+     *
+     * @see RefundModeEnum#getIndex()
+     */
+    @ApiModelProperty(value = "微商城退款方式", notes = RefundModeEnum.API_DOC)
+    private Byte refundMode;
+}

order-application-service/src/main/java/cn/freemud/service/Orderservice.java

@@ -219,4 +219,11 @@ public interface Orderservice extends OrderFactoryService{
      * @return
      */
     BaseResponse couponOrderRefundRetry(OrderRefundRetryVo orderRefundRetryVo);
+
+    /**
+     * 开发人员 操作退款订单 该接口 生产使用请通知SE
+     * @param orderRefundVo
+     * @return
+     */
+    BaseResponse developRefund(OrderDevelopRefundVo orderRefundVo);
 }

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

@@ -52,6 +52,7 @@ import cn.freemud.enums.*;
 import cn.freemud.handler.WeChatLiveMsgHandle;
 import cn.freemud.interceptor.ServiceException;
 import cn.freemud.management.entities.dto.request.BatchOrderRefundV2Request;
+import cn.freemud.management.entities.dto.request.order.OrderManagerRequest;
 import cn.freemud.management.entities.dto.request.pay.PayRefundRequestDto;
 import cn.freemud.management.entities.dto.response.activity.GroupWorkRefundResponse;
 import cn.freemud.management.entities.dto.response.pay.OrderRefundResponse;
@@ -59,6 +60,7 @@ import cn.freemud.management.entities.dto.response.pay.PayBatchRefundResponse;
 import cn.freemud.management.entities.dto.response.pay.PayRefundResponse;
 import cn.freemud.management.enums.SettlementTypeEnum;
 import cn.freemud.management.intercept.OrderServiceException;
+import cn.freemud.management.service.adapter.OrderManagerAdapter;
 import cn.freemud.management.service.handle.ActivityHandle;
 import cn.freemud.management.service.handle.OrderVerifyHandle;
 import cn.freemud.management.service.handle.PaymentHandle;
@@ -155,7 +157,6 @@ import java.util.stream.Collectors;
 import static cn.freemud.constant.OrderRefundConstant.ALLOW_REFUND;
 
 
-
 @Service
 public class OrderServiceImpl implements Orderservice {
 
@@ -294,6 +295,9 @@ public class OrderServiceImpl implements Orderservice {
     @Autowired
     private StockHandle stockHandle;
 
+    @Autowired
+    private OrderManagerAdapter orderManagerAdapter;
+
     @Value("${sellcoupon.test.order.refund.fail:}")
     private Integer testOrderRefundFail;
 //    @Override
@@ -670,7 +674,7 @@ public class OrderServiceImpl implements Orderservice {
             return newSendPaySuccessNoticeMessage();
         }
         //无售后单，退款回掉取消订单，冲正库存等
-        if(CollectionUtils.isEmpty(orderBean.getRefundList())){
+        if (CollectionUtils.isEmpty(orderBean.getRefundList())) {
             return cancelOrder(orderBean);
         }
         //订单状态
@@ -975,7 +979,7 @@ public class OrderServiceImpl implements Orderservice {
                     // 所以在这个地方排除掉coco，在下边单独实现
                     //参与支付有礼活动
 //                    if (!cocoPartnerId.contains(queryOrderVo.getPartnerId())) {
-                        joinPayGift(queryOrderVo.getSessionId(), queryOrderResponseVo, partnerId, queryOrderVo.getPayGiftVer());
+                    joinPayGift(queryOrderVo.getSessionId(), queryOrderResponseVo, partnerId, queryOrderVo.getPayGiftVer());
 //                    }
 
                 } catch (Exception e) {
@@ -1251,7 +1255,7 @@ public class OrderServiceImpl implements Orderservice {
                     // 所以在这个地方排除掉coco，在下边单独实现
                     //参与支付有礼活动
 //                    if (!cocoPartnerId.contains(queryOrderVo.getPartnerId())) {
-                        joinPayGift(queryOrderVo.getSessionId(), queryOrderResponseVo, partnerId, queryOrderVo.getPayGiftVer());
+                    joinPayGift(queryOrderVo.getSessionId(), queryOrderResponseVo, partnerId, queryOrderVo.getPayGiftVer());
 //                    }
                 } catch (Exception e) {
                     AppLogUtil.errorLog("queryOrders_activity_error", gson.toJson(queryOrdersRequest), gson.toJson(queryOrderResponseVo), e);
@@ -1892,7 +1896,7 @@ public class OrderServiceImpl implements Orderservice {
             // 这里如果发现会员id不一致，就去查询会员合并数据，重新匹配一下
             // 不要在外面查， 大部分情况不会进这个if， 不影响通常逻辑下的tps
             List<String> memberIds = memberInfoManager.getMemberAllIds(partnerId, memberId);
-            if (! memberIds.contains(orderByIdResponseDto.getData().getUserId()))
+            if (!memberIds.contains(orderByIdResponseDto.getData().getUserId()))
                 return ResponseUtil.error(ResponseResult.ORDER_QUERYORDER_ERROR.getCode(), "不能操作非本人的订单");
         }
         OrderBeanV1 orderBean = orderByIdResponseDto.getData();
@@ -1906,7 +1910,7 @@ public class OrderServiceImpl implements Orderservice {
         }
 
         // 微商城订单
-        if (Objects.equals(BizTypeEnum.MALL.getBizType() ,orderBean.getBizType()) || Objects.equals("23",orderBean.getOrderClient())) {
+        if (Objects.equals(BizTypeEnum.MALL.getBizType(), orderBean.getBizType()) || Objects.equals("23", orderBean.getOrderClient())) {
             // 微商城因为没有退款原因选项 所以将用户退款说明用户作为退款原因
             orderRefundVo.setReason(orderRefundVo.getRemarks());
             // 必须选择退款方式
@@ -1924,8 +1928,7 @@ public class OrderServiceImpl implements Orderservice {
                     && (StringUtils.isBlank(orderBean.getSpellGroupCode()) || StringUtils.isBlank(orderBean.getSpellGroupActivityCode()))) {
                 return ResponseUtil.error(ResponseResult.SPELL_GROUP_QUERY_GROUP_WORK_ERROR);
             }
-        }
-        else if (NewOrderStatus.DELIVERING.getIndex().equals(orderBean.getStatusV2())) {
+        } else if (NewOrderStatus.DELIVERING.getIndex().equals(orderBean.getStatusV2())) {
             return ResponseUtil.error(ResponseResult.ORDER__ERRORREFUND.getCode(), "订单配送中，退款请联系售后！");
         }
 
@@ -1953,7 +1956,7 @@ public class OrderServiceImpl implements Orderservice {
                     return ResponseUtil.error(ResponseResult.ORDER__ERRORREFUND.getCode(), "商家正在处理中，请稍后……");
                 }
                 //商城订单可二次发起退款
-                if (!Objects.equals(BizTypeEnum.MALL.getBizType(),orderBean.getBizType()) && RefundStatus.REFUSE_REFUND.getCode().equals(refundBean.getStatus())) {
+                if (!Objects.equals(BizTypeEnum.MALL.getBizType(), orderBean.getBizType()) && RefundStatus.REFUSE_REFUND.getCode().equals(refundBean.getStatus())) {
                     return ResponseUtil.error(ResponseResult.ORDER__ERRORREFUND.getCode(), "您的申请已被商家拒绝，请联系门店沟通。");
                 }
             }
@@ -1965,7 +1968,7 @@ public class OrderServiceImpl implements Orderservice {
 
             boolean isRefundDeliveryFee = true;
             //商城查询配送费
-            if (Objects.equals(BizTypeEnum.MALL.getBizType(),orderBean.getBizType())
+            if (Objects.equals(BizTypeEnum.MALL.getBizType(), orderBean.getBizType())
                     && StringUtils.isNotEmpty(orderBean.getExtInfo())) {
                 JSONObject extInfoJsonObject = JSONObject.parseObject(orderBean.getExtInfo());
                 OrderExtInfoDto orderExtInfoDto = extInfoJsonObject.toJavaObject(OrderExtInfoDto.class);
@@ -2344,7 +2347,7 @@ public class OrderServiceImpl implements Orderservice {
             spuIds.add(productDto.getProductId());
         }
         Map<String, GetProductsVo> products = itemService.getSpuProducts(spuIds, createOrderDto.getCompanyId(), createOrderDto.getShopId(), createOrderDto.getMenuType());
-        if (products==null) {
+        if (products == null) {
             return createOrderDto;
         }
         if (products.isEmpty()) {
@@ -3306,6 +3309,7 @@ public class OrderServiceImpl implements Orderservice {
 
     /**
      * 支付退款成功，订单未创建售后单
+     *
      * @return
      */
     private String cancelOrder(OrderBeanV1 orderBean) {
@@ -3341,7 +3345,7 @@ public class OrderServiceImpl implements Orderservice {
             userLoginInfoDto = new AssortmentCustomerInfoVo();
             userLoginInfoDto.setMemberId(orderBean.getUserId());
             userLoginInfoDto.setWxAppId(orderBean.getAppId());
-        }else {
+        } else {
             // 校验用户是否登录
             BaseResponse<AssortmentCustomerInfoVo> baseResponse = this.checkUserLoginInfoDto(orderRefundVo.getSessionId());
             if (!Objects.equals(baseResponse.getCode(), ResponseResult.SUCCESS.getCode())) {
@@ -3370,7 +3374,7 @@ public class OrderServiceImpl implements Orderservice {
         // 走正常退款订单逻辑 这里是否可以丢MQ 异步操作
         try {
             this.doCouponOrderRefund(orderBean, orderRefundVo);
-        }catch (Exception e){
+        } catch (Exception e) {
             RefundFailureRequestDTO requestDTO = RefundFailureRequestDTO.builder().orderCode(orderBean.getOid())
                     .failureType(RefundFailureRequestDTO.FAILURETYPE_SYSTEM_ERROR)
                     .reason(JSON.toJSONString(e.getMessage()))
@@ -3383,7 +3387,6 @@ public class OrderServiceImpl implements Orderservice {
     }
 
     /**
-     *
      * @param orderBean
      * @return
      */
@@ -3411,7 +3414,8 @@ public class OrderServiceImpl implements Orderservice {
     }
 
     /**
-     *  调用券码作废操作
+     * 调用券码作废操作
+     *
      * @param orderBean
      * @return
      */
@@ -3433,7 +3437,7 @@ public class OrderServiceImpl implements Orderservice {
 
         CouponResponseDTO<CheckAndCancelResponseDTO> responseDTO = couponOnlineClient.checkandcancel(request);
         if (responseDTO == null
-                || !Objects.equals(responseDTO.getStatusCode(),100)) {
+                || !Objects.equals(responseDTO.getStatusCode(), 100)) {
             // 直接接口调用失败,
             return ResponseUtil.error(ResponseResult.COUPON_CANCEL_FAIL.getCode(), "操作失败,请稍后重试");
         }
@@ -3471,7 +3475,7 @@ public class OrderServiceImpl implements Orderservice {
         QueryRefundFailuresListReq queryRefundFailuresListReq = new QueryRefundFailuresListReq();
         queryRefundFailuresListReq.setId(orderRefundRetryVo.getId());
         BaseResponse<List<QueryRefundFailuresListDto>> queryRefundFailuresListDtoBaseResponse = orderServiceClient.refundFailuresList(queryRefundFailuresListReq);
-        if(!ResponseConstant.SUCCESS_RESPONSE_CODE_STR.equals(queryRefundFailuresListDtoBaseResponse.getCode())
+        if (!ResponseConstant.SUCCESS_RESPONSE_CODE_STR.equals(queryRefundFailuresListDtoBaseResponse.getCode())
                 || CollectionUtils.isEmpty(queryRefundFailuresListDtoBaseResponse.getResult())
                 || queryRefundFailuresListDtoBaseResponse.getResult().size() != 1) {
             return ResponseUtil.error(ResponseResult.ORDER__ERRORREFUND.getCode(), "该记录不存在或查询异常");
@@ -3481,11 +3485,11 @@ public class OrderServiceImpl implements Orderservice {
         // 查询订单
         BaseResponse<OrderBeanV1> orderResponse = this.checkOrderAndGetOrderBean(queryRefundFailuresListDto.getOrderCode());
         if (!Objects.equals(orderResponse.getCode(), ResponseResult.SUCCESS.getCode())) {
-            return ResponseUtil.error(ResponseResult.ORDER__ERRORREFUND.getCode(), "订单数据查询失败："+orderResponse.getMessage());
+            return ResponseUtil.error(ResponseResult.ORDER__ERRORREFUND.getCode(), "订单数据查询失败：" + orderResponse.getMessage());
         }
         OrderBeanV1 orderBean = orderResponse.getResult();
         AfterSalesOrderResp afterSalesOrderResp = orderBean.getAfterSalesOrderResp();
-        if(afterSalesOrderResp == null) {
+        if (afterSalesOrderResp == null) {
             return ResponseUtil.error(ResponseResult.ORDER__ERRORREFUND.getCode(), "不存在售后单信息");
         }
 
@@ -3496,7 +3500,7 @@ public class OrderServiceImpl implements Orderservice {
                 return ResponseUtil.error(ResponseResult.ORDER__ERRORREFUND.getCode(), "处理中，请稍等。");
             }
 
-            if(Integer.valueOf(1).equals(queryRefundFailuresListDto.getLastFailureType()) || Integer.valueOf(2).equals(queryRefundFailuresListDto.getLastFailureType())) {
+            if (Integer.valueOf(1).equals(queryRefundFailuresListDto.getLastFailureType()) || Integer.valueOf(2).equals(queryRefundFailuresListDto.getLastFailureType())) {
                 Long refundId = System.currentTimeMillis();
 
                 if (orderBean.getAmount() != 0) {
@@ -3505,7 +3509,7 @@ public class OrderServiceImpl implements Orderservice {
                         MultiOrderRefundRequest multiOrderRefundRequest = orderAdapter.getMultiOrderPayRefundRequest(orderBean, refundId);
                         MultiOrderRefundResponse multiOrderRefundResponse = payServiceImpl.paymentApplicationRefund(multiOrderRefundRequest, orderBean.getCompanyId());
                         if (multiOrderRefundResponse == null || multiOrderRefundResponse.getData() == null || !ResponseCodeConstant.RESPONSE_SUCCESS_200.equals(multiOrderRefundResponse.getCode())) {
-                            return ResponseUtil.error(ResponseResult.ORDER__ERRORREFUND.getCode(), "调用支付退款接口失败："+JSON.toJSONString(multiOrderRefundResponse));
+                            return ResponseUtil.error(ResponseResult.ORDER__ERRORREFUND.getCode(), "调用支付退款接口失败：" + JSON.toJSONString(multiOrderRefundResponse));
                         }
                         List<MultiOrderRefundResponse.RefundPlatformResponse> refundPlatformResponseList = multiOrderRefundResponse.getData().refundPlatformResponseList;
                         if (null != refundPlatformResponseList && refundPlatformResponseList.size() > 0) {
@@ -3518,10 +3522,10 @@ public class OrderServiceImpl implements Orderservice {
                         orderPayRefundRequest.setRefundDesc("退款失败人工重试");
                         com.freemud.application.sdk.api.base.BaseResponse<OrderRefundResponse> response = payServiceImpl.orderRefund(orderPayRefundRequest);
                         if (response == null || response.getData() == null || !ResponseCodeConstant.RESPONSE_SUCCESS_STR.equals(response.getCode())) {
-                            return ResponseUtil.error(ResponseResult.ORDER__ERRORREFUND.getCode(), "调用支付退款接口失败："+JSON.toJSONString(response));
+                            return ResponseUtil.error(ResponseResult.ORDER__ERRORREFUND.getCode(), "调用支付退款接口失败：" + JSON.toJSONString(response));
                         }
-                        if(!ResponseConstant.SUCCESS_RESPONSE_CODE.equals(response.getData().getStatusCode())) {
-                            return ResponseUtil.error(ResponseResult.ORDER__ERRORREFUND.getCode(), "支付退款失败："+JSON.toJSONString(response));
+                        if (!ResponseConstant.SUCCESS_RESPONSE_CODE.equals(response.getData().getStatusCode())) {
+                            return ResponseUtil.error(ResponseResult.ORDER__ERRORREFUND.getCode(), "支付退款失败：" + JSON.toJSONString(response));
                         }
                     }
                 }
@@ -3531,7 +3535,7 @@ public class OrderServiceImpl implements Orderservice {
                 refundFailuresSuccessfulReq.setOrderCode(orderBean.getOid());
                 refundFailuresSuccessfulReq.setPartnerId(orderBean.getCompanyId());
                 BaseResponse baseResponse = orderServiceClient.refundFailuresSuccessful(refundFailuresSuccessfulReq);
-                if(!ResponseConstant.SUCCESS_RESPONSE_CODE_STR.equals(baseResponse.getCode())) {
+                if (!ResponseConstant.SUCCESS_RESPONSE_CODE_STR.equals(baseResponse.getCode())) {
                     return ResponseUtil.error(ResponseResult.ORDER__ERRORREFUND.getCode(), "处理完成但更新记录失败");
                 }
 
@@ -3549,7 +3553,7 @@ public class OrderServiceImpl implements Orderservice {
                     return ResponseUtil.error(ResponseResult.ORDER__ERRORREFUND.getCode(), "基础服务订单退款完成失败");
                 }
 
-                stockHandle.revert(null,orderBean);
+                stockHandle.revert(null, orderBean);
 
             } else {
                 return ResponseUtil.error(ResponseResult.ORDER__ERRORREFUND.getCode(), "暂不支持该操作");
@@ -3558,12 +3562,160 @@ public class OrderServiceImpl implements Orderservice {
         } catch (Exception e) {
             throw e;
         } finally {
-            LockUtils.unlock(redisCache.getRedisTemplate(),lockKey);
+            LockUtils.unlock(redisCache.getRedisTemplate(), lockKey);
         }
 
         return ResponseUtil.success();
     }
 
+    @Override
+    public BaseResponse developRefund(OrderDevelopRefundVo orderRefundVo) {
+
+        if (CollectionUtils.isEmpty(orderRefundVo.getOrderCodes())) {
+            return ResponseUtil.error(ResponseResult.ORDER_QUERYORDER_ERROR.getCode(), "未传递订单号");
+        }
+        Map<String, String> resultMap = new HashMap<>();
+        orderRefundVo.getOrderCodes().forEach(orderCode -> {
+            try {
+                BaseResponse resp = this.batchDevelopRefund(orderRefundVo, orderCode);
+                if (Objects.equals(resp.getCode(), ResponseResult.SUCCESS.getCode())) {
+                    resultMap.put(orderCode, "成功");
+                } else {
+                    resultMap.put(orderCode, resp.getMessage());
+                }
+            }catch (Exception e){
+                resultMap.put(orderCode, e.getMessage());
+            }
+        });
+        return ResponseUtil.success(resultMap);
+    }
+
+    private BaseResponse batchDevelopRefund(OrderDevelopRefundVo orderRefundVo, String orderCode) {
+        if (StringUtils.isEmpty(orderRefundVo.getReason())) {
+            orderRefundVo.setReason("内部操作退款,操作人:" + orderRefundVo.getOperator());
+        }
+        // 查询订单
+        BaseQueryOrderRequest baseQueryOrderRequest = new BaseQueryOrderRequest();
+        baseQueryOrderRequest.setOrderId(orderCode);
+        baseQueryOrderRequest.setTrackingNo(LogThreadLocal.getTrackingNo());
+        QueryOrderByIdResponse queryOrderByIdResponse = orderCenterSdkService.queryOrderById(baseQueryOrderRequest);
+        String string = JSONObject.toJSONString(queryOrderByIdResponse);
+        JSONObject jsonObject = JSONObject.parseObject(string);
+        QueryOrderByIdResponseDto orderByIdResponseDto = jsonObject.toJavaObject(QueryOrderByIdResponseDto.class);
+        if (!RESPONSE_SUCCESS_CODE.equals(orderByIdResponseDto.getErrcode()) || orderByIdResponseDto.getData() == null) {
+            return ResponseUtil.error(ResponseResult.ORDER_QUERYORDER_ERROR.getCode(), "订单信息不存在");
+        }
+        OrderBeanV1 orderBean = orderByIdResponseDto.getData();
+        if (PayStatus.NOT_PAY.getCode().equals(orderByIdResponseDto.getData().getPayStatus())
+                || NewOrderStatus.PENDING_PAYMENT.getIndex().equals(orderBean.getStatusV2())) {
+            return ResponseUtil.error(ResponseResult.ORDER__ERRORREFUND.getCode(), "订单未支付，无法退款");
+        }
+        if (NewOrderStatus.CLOSED.getIndex().equals(orderBean.getStatusV2())) {
+            return ResponseUtil.error(ResponseResult.ORDER__ERRORREFUND.getCode(), "订单已取消，无法退款");
+        }
+        // fisherman 仅仅支持 餐饮类订单进行操作
+        if (BizTypeEnum.ORDINARY.getBizType().compareTo(orderBean.getBizType()) !=0) {
+            return ResponseUtil.error(ResponseResult.ORDER__ERRORREFUND.getCode(), "仅支持餐饮订单操作");
+        }
+
+        // fisherman 该接口的调用 肯定是因已经商户确认要退款的操作, 所以不走正常的 是否可退款判断
+        if (PayStatus.HAVE_PAID.getCode().equals(orderBean.getPayStatus())) {
+            boolean isRefundDeliveryFee = true;
+            //商城查询配送费
+            if (Objects.equals(BizTypeEnum.MALL.getBizType(), orderBean.getBizType())
+                    && StringUtils.isNotEmpty(orderBean.getExtInfo())) {
+                JSONObject extInfoJsonObject = JSONObject.parseObject(orderBean.getExtInfo());
+                OrderExtInfoDto orderExtInfoDto = extInfoJsonObject.toJavaObject(OrderExtInfoDto.class);
+                if (null != orderExtInfoDto && null != orderExtInfoDto.getProvince()) {
+                    String province = orderExtInfoDto.getProvince();
+                    QueryFreightRefundSupportedVo queryFreightRefundSupportedVo = new QueryFreightRefundSupportedVo();
+                    queryFreightRefundSupportedVo.setPartnerId(orderBean.getCompanyId());
+                    queryFreightRefundSupportedVo.setProvince(province);
+                    //整合商城订单状态，订单状态 1 2 3不需校验直接退运费 20210513
+                    List<Integer> isRefundDeliveryFeeCodes = Arrays.asList(
+                            NewOrderStatus.PENDING_PAYMENT.getIndex(), NewOrderStatus.PLACE_AN_ORDER.getIndex(), NewOrderStatus.ACCEPTED.getIndex());
+                    if (isRefundDeliveryFeeCodes.contains(orderBean.getStatusV2())) {
+                        isRefundDeliveryFee = true;
+                    } else {
+                        QueryFreightRefundSupportedResponse queryFreightRefundSupportedResponse = deliveryFeiginClient.isFreightRefundSupported(queryFreightRefundSupportedVo);
+                        if (null != queryFreightRefundSupportedResponse && RESPONSE_SUCCESS_CODE == queryFreightRefundSupportedResponse.getCode()) {
+                            Boolean freightRefundSupported = queryFreightRefundSupportedResponse.getData();
+                            isRefundDeliveryFee = freightRefundSupported;
+                        }
+                    }
+                }
+            } else {
+                // 查询小程序是否配置了退运费
+                String configStr = redisCache.hashGet(MessageFormat.format(OrderRedisKeyConstant.ORDER_REFUND_CONFIG, orderBean.getCompanyId(), orderBean.getAppId()), OrderRedisKeyConstant.HashKeyForOrderRefundConfig.TAKE_OUT);
+                if (StringUtils.isNotEmpty(configStr)) {
+                    OrderRefundConfigEntity config = JSON.parseObject(configStr, OrderRefundConfigEntity.class);
+                    String refundDeliveryFeeConfig = config.getRefundShippingFee();
+                    // 0、null表示 关闭 ; 1 表示开启
+                    if (null != refundDeliveryFeeConfig
+                            && Arrays.asList(NewOrderStatus.DELIVERING.getIndex(), NewOrderStatus.COMPLETE.getIndex()).contains(orderBean.getStatusV2())
+                            && !ALLOW_REFUND.equals(refundDeliveryFeeConfig)) {
+                        isRefundDeliveryFee = false;
+                    }
+                }
+            }
+
+            // 未接单
+            if (NewOrderStatus.PLACE_AN_ORDER.getIndex().equals(orderBean.getStatusV2())) {
+                // 未接单的 请用户直接操作C端小程序处理
+                return ResponseUtil.error(ResponseResult.ORDER__ERRORREFUND.getCode(), "订单未接单,请指引用户C端操作退款！");
+            } else {
+                CancelOrderRequest cancelOrderRequest = new CancelOrderRequest();
+                cancelOrderRequest.setPartnerId(orderBean.getCompanyId());
+                cancelOrderRequest.setStoreId(orderBean.getShopId());
+                cancelOrderRequest.setOrderId(orderBean.getOid());
+                cancelOrderRequest.setOrderClient(Integer.parseInt(orderBean.getOrderClient()));
+
+                //传入的售后单类型为：2：售中用户取消 8：售后申请
+                cancelOrderRequest.setAfterSalesType(AfterSalesType.USER_CANCEL);
+                if (NewOrderStatus.COMPLETE.getIndex().equals(orderBean.getStatusV2())) {
+                    cancelOrderRequest.setAfterSalesType(AfterSalesType.USER_SALE_RETURN);
+                }
+                cancelOrderRequest.setReason(orderRefundVo.getReason());
+                cancelOrderRequest.setReqRemark(orderRefundVo.getReason());
+                // 商城订单 增加拓展信息
+                CancelOrderRequest.AfterSalesOrderExtInfoReq salesOrderExtInfoReq = new CancelOrderRequest.AfterSalesOrderExtInfoReq();
+                salesOrderExtInfoReq.setRefundMode(orderRefundVo.getRefundMode());
+                cancelOrderRequest.setExtInfoReq(salesOrderExtInfoReq);
+
+                cancelOrderRequest.setOperator(orderBean.getUserName());
+                cancelOrderRequest.setTrackingNo(LogThreadLocal.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());
+                }
+                if (orderBean.getAmount() > 0) {
+                    sendPosMessage(orderBean.getCompanyId(), orderBean.getShopId());
+                }
+                // 兼容下面的方法
+                OrderRefundVo refundVo = new OrderRefundVo();
+                refundVo.setReason(orderRefundVo.getReason());
+                refundVo.setRemarks(orderRefundVo.getReason());
+                //通知小助手发送申请退款公众号订阅消息
+                sendApplyRefundSubscriptionNotice(orderBean, refundVo);
+                //已接单可发起退款申请，查询门店有无云打印机，有则打印退款申请小票
+                printApplyRefundSmallTicket(orderBean, refundVo);
+            }
+            // 调用oms的 同意退款操作
+            OrderManagerRequest request = new OrderManagerRequest();
+            request.setPartnerId(orderBean.getCompanyId());
+            request.setStoreId(orderBean.getShopId());
+            request.setOrderId(orderBean.getOid());
+            request.setReason(orderRefundVo.getReason());
+            request.setOperateType(cn.freemud.management.enums.OperateType.ORDER_DEVELOPER_AGREE_REFUND.getOpType());
+            request.setOperator(orderRefundVo.getOperator());
+            BaseResponse baseResponse = orderManagerAdapter.developRefund(request);
+            return baseResponse;
+        }
+        return ResponseUtil.error(ResponseResult.ORDER__ERRORREFUND.getCode(), "订单未支付！");
+    }
+
     /**
      * 订单退款操作
      * 1.调用支付 进行退款
@@ -3587,9 +3739,9 @@ public class OrderServiceImpl implements Orderservice {
         //支付退款
         PayRefundResponse refundResponse;
         try {
-            if(null != orderBean.getOrderPayItem() && orderBean.getOrderPayItem().size()>0){
+            if (null != orderBean.getOrderPayItem() && orderBean.getOrderPayItem().size() > 0) {
                 refundResponse = paymentHandle.multiRefund(orderBean);
-            }else{
+            } else {
                 refundResponse = paymentHandle.refund("用户买券订单-申请退款", orderBean);
             }
             if (refundResponse.getPayRefundStatus().getCode().compareTo(PayRefundStatus.SUCCESS.getCode()) != 0) {
@@ -3606,7 +3758,7 @@ public class OrderServiceImpl implements Orderservice {
                 orderServiceClient.refundFailures(requestDTO);
             }
             state = refundResponse.getPayRefundStatus().getCode();
-        } catch (OrderServiceException orderEx){
+        } catch (OrderServiceException orderEx) {
             // 系统异常
             RefundFailureRequestDTO requestDTO = RefundFailureRequestDTO.builder().orderCode(orderBean.getOid())
                     .failureType(RefundFailureRequestDTO.FAILURETYPE_SYSTEM_ERROR)
@@ -3630,7 +3782,7 @@ public class OrderServiceImpl implements Orderservice {
         } else if (Objects.equals(PayRefundStatus.SUCCESS.getCode(), state)) {
             //退款成功
             cancelOrderRequest.setCreateEvent(AfterSalesOrderCreateEventEnum.REFUND_COMPLETE.getCreateEvent());
-        }else {
+        } else {
             // 退款失败,直接给基础服务null 用于后续补偿操作
             cancelOrderRequest.setCreateEvent(null);
         }
@@ -3646,7 +3798,7 @@ public class OrderServiceImpl implements Orderservice {
         }
         if (Objects.nonNull(state)) {
             //冲正库存
-            stockHandle.revert(null,orderBean);
+            stockHandle.revert(null, orderBean);
         }
         // 删除订单 通知活动添加商品库存  status 需要老订单的 ordercode
 //        orderQueueService.backOrdersStatusChange(orderBean.getOrderCode(), orderBean.getOrderState(), orderBean.getPayState());
@@ -3678,11 +3830,11 @@ public class OrderServiceImpl implements Orderservice {
         }
         // fisherman 查询配置是否能退款 未完成
         boolean isTrue = orderAdapter.checkRefundButtionBizTypeIs6(orderBean.getCompanyId(), orderBean.getBizType(),
-                orderBean.getStatus(),userLoginInfoDto.getWxAppId(), new Date(orderBean.getGmtCreate()), orderBean.getOrderType());
+                orderBean.getStatus(), userLoginInfoDto.getWxAppId(), new Date(orderBean.getGmtCreate()), orderBean.getOrderType());
         if (isTrue) {
             return ResponseUtil.success();
         }
-        return ResponseUtil.error(ResponseResult.COUPON_ORDER_COMMON_VERIFY_FAIL.getCode(),"虚拟券退款配置未启用,请联系客服");
+        return ResponseUtil.error(ResponseResult.COUPON_ORDER_COMMON_VERIFY_FAIL.getCode(), "虚拟券退款配置未启用,请联系客服");
     }
 
 
@@ -3725,7 +3877,6 @@ public class OrderServiceImpl implements Orderservice {
 
     /**
      * 发送支付成功模板消息
-     *
      */
     public void sendMessageByNewApp(SendPaySuccessMessageVo sendPaySuccessMessageVo) {
         OrderBeanV1 orderBean = new OrderBeanV1();

order-management/src/main/java/cn/freemud/management/enums/OperateType.java

@@ -13,7 +13,12 @@ public enum OperateType {
     ORDER_REJECT_REFUND("orderRejectRefund","拒绝退款"),
     ORDER_CANCEL("orderCancel","订单取消"),
     ORDER_CREATE_DELIVERY("orderCreateDelivery","创建配送"),
-    ORDER_CANCEL_DELIVERY("orderCancelDelivery","取消配送");
+    ORDER_CANCEL_DELIVERY("orderCancelDelivery","取消配送"),
+    /**
+     * 该操作无校验, 直接退款, 如果使用 请联系SE 进行报备,
+     * 该类型不给外部人员使用, 不对外部暴露接口
+     */
+    ORDER_DEVELOPER_AGREE_REFUND("orderDeveloperAgreeRefund","售后人员同意退款");
 
     /**
      * 操作类型

order-management/src/main/java/cn/freemud/management/service/adapter/OrderManagerAdapter.java

@@ -353,4 +353,22 @@ public class OrderManagerAdapter {
         BaseResponse<OrderManagerResponse> orderManagerResponse = orderBeanFactory.getOrderManagerService(orderBean).orderCancelDelivery(request, orderBean);
         return handleResponse(request,orderBean,orderManagerResponse);
     }
+
+    /**
+     * @see OrderManagerAdapter#orderAgreeRefund(cn.freemud.management.entities.dto.request.order.OrderManagerRequest)
+     * @param request
+     * @return 改操作 无需校验订单参数 直接退款
+     * 使用该方法 请先进行报备, 因为不暴露给外部使用, 不属于业务代码
+     */
+    public BaseResponse developRefund(OrderManagerRequest request) {
+        //查询订单
+        OrderBeanV1 orderBean = orderBaseService.getByOrderCode(request.getOrderId());
+        if (null == orderBean) {
+            return ResponseUtil.error(ResponseResult.ORDER_NOT_EXIST);
+        }
+        // 设置退款金额
+        orderBean.setAmount(orderVerifyHandle.getRefundAmount(orderBean,false).longValue());
+        BaseResponse<OrderManagerResponse> orderManagerResponse = orderBeanFactory.getOrderManagerService(orderBean).orderAgreeRefund(request, orderBean);
+        return handleResponse(request,orderBean,orderManagerResponse);
+    }
 }