dyDeliver/conf/script/1000/orderApi/BE_Order_ProcessRefund_Request.groovy

import com.dderp.business.dao.OrderDao
import com.dderp.common.api.BusinessExecutor
import com.dderp.common.api.StoreService
import com.dderp.common.api.SupplierInitService
import com.dderp.common.api.flycat.IncomePlatformService
import com.dderp.common.api.flycat.OrderSearchService
import com.dderp.common.api.flycat.OrderService
import com.dderp.common.api.flycat.OrderStepService
import com.dderp.common.datas.ERPModule
import com.dderp.common.datas.TokenUserFrom
import com.dderp.common.entity.base.InvokeCallParams
import com.dderp.common.entity.base.InvokeCallResult
import com.dderp.common.entity.order.BusinessOrder
import com.dderp.common.entity.order.OrderRefundRequest
import com.dderp.common.entity.site.ERPTokenUser
import com.dderp.common.tool.ERPUtils
import com.dySweetFishPlugin.elasticsearch.ESClient
import com.dySweetFishPlugin.sql.TableIdService
import com.dySweetFishPlugin.sql.dao.TunaService
import com.sweetfish.convert.json.JsonConvert
import com.sweetfish.service.RetResult
import groovy.json.JsonSlurper
import org.apache.logging.log4j.LogManager
import org.apache.logging.log4j.Logger
import org.rex.RMap

import javax.annotation.Resource
import java.time.LocalDateTime
import java.time.ZoneOffset

@SuppressWarnings("unused")
class BE_Order_ProcessRefund_Request implements BusinessExecutor<InvokeCallParams, InvokeCallResult> {

    private final Logger logger = LogManager.getLogger(this.getClass().getSimpleName())

    @Resource
    private JsonConvert jsonConvert

    @Resource
    private TableIdService tableIdService

    @Resource
    private StoreService storeService

    @Resource
    private ESClient esClient

    @Resource
    private SupplierInitService supplierInitService

    @Resource
    private OrderStepService orderStepService

    @Resource
    private OrderService orderService

    @Resource
    private OrderSearchService orderSearchService

    @Resource
    private IncomePlatformService douyinService

    @Resource
    private TunaService tunaService

    private OrderDao orderDao

    @Override
    String scriptName() {
        return "商户同意/拒绝退款请求"
    }

    @Override
    ERPModule module() {
        return ERPModule.ORDER_API
    }

    @Override
    RetResult<InvokeCallParams> checkExecute(InvokeCallParams source) {
        String dataSourceId = source.dataSourceId
        long supplierCode = source.supplierCode
        ERPTokenUser currentUser = source.currentUser

        def jsonSlurper = new JsonSlurper()
        def invokeOrder = jsonSlurper.parseText(source.params)
        long idRefundRequest = invokeOrder["idRefundRequest"] as Long
        int approve = invokeOrder["approve"] as int
        String rejectReasonCode = invokeOrder["rejectReasonCode"] as String
        String rejectMemo = invokeOrder["rejectMemo"] as String

        //groovy 不能直接使用ERPUtils.PARAM_SEARCH_ID，要么直接用字符串，不知道下面的用法是否可以，需要测试一下
        RetResult<OrderRefundRequest> requestRetResult = orderSearchService.searchOrderRefundRequest(new RMap<>("${ERPUtils.PARAM_SEARCH_ID}": idRefundRequest),
                currentUser, dataSourceId, supplierCode, null)
        if (!requestRetResult.isSuccess()) return RetResult.<InvokeCallParams> errorT().retinfo(requestRetResult.retinfo)

        if (!(approve in [0, 1])) return RetResult.<InvokeCallParams> errorT().retinfo("传入状态非法")

        OrderRefundRequest refundRequest = requestRetResult.result

        if ((source.currentUser.userFrom == TokenUserFrom.APP_STORE_ADMIN.value) || (source.currentUser.userFrom == TokenUserFrom.PC_STORE_ADMIN.value)) {
            if (refundRequest.idStore != source.currentUser.idBindOrg) {
                return RetResult.<InvokeCallParams> errorT().retinfo("无效的订单信息")
            }
        }

        return super.checkExecute(source)
    }

    @Override
    RetResult<InvokeCallParams> beforeExecute(InvokeCallParams source) {
        return super.beforeExecute(source)
    }

    /*
    params : {
        "idRefundRequest" : 2 ,                         客户退款申请id
        "approve" : 0 ,                                 拒绝0同意1
        "rejectReasonCode" : "[101,102,103]" ,          拒绝原因代码,注意这个括号不能少必须是数组形式
        "rejectMemo" : "拒绝原因备注"                     拒绝原因备注
    }
    */

    RetResult<InvokeCallResult> execute(InvokeCallParams source) {
        //秒级时间戳，groovy里面不让用system
        long currentTime = LocalDateTime.now().toEpochSecond(ZoneOffset.ofHours(8))
        String dataSourceId = source.dataSourceId
        long supplierCode = source.supplierCode
        ERPTokenUser currentUser = source.currentUser

        def jsonSlurper = new JsonSlurper()
        def invokeOrder = jsonSlurper.parseText(source.params)
        long idRefundRequest = invokeOrder["idRefundRequest"] as Long
        int approve = invokeOrder["approve"] as int
        String rejectReasonCode = invokeOrder["rejectReasonCode"] as String
        String rejectMemo = invokeOrder["rejectMemo"] as String

        //groovy 不能直接使用ERPUtils.PARAM_SEARCH_ID，要么直接用字符串，不知道下面的用法是否可以，需要测试一下
        RetResult<OrderRefundRequest> requestRetResult = orderSearchService.searchOrderRefundRequest(new RMap<>("${ERPUtils.PARAM_SEARCH_ID}": idRefundRequest),
                currentUser, dataSourceId, supplierCode, null)
        if (!requestRetResult.isSuccess()) return RetResult.<InvokeCallResult> errorT().retinfo(requestRetResult.retinfo)

        if (!(approve in [0, 1])) return RetResult.<InvokeCallResult> errorT().retinfo("传入状态非法")

        OrderRefundRequest refundRequest = requestRetResult.result

        /* 这部分还是在推送中完成
        OrderAfterSaleBill afterSaleBill
        def postBody
        if (approve == 0) {
            //拒绝退款
            refundRequest.setRequestStatus(RefundRequestStatus.refuse.value)
            refundRequest.setRefuseToRefundReasonCodes(rejectReasonCode)
            refundRequest.setRefuseToRefundMemo(rejectMemo)
            OrderRefundRequest.update(refundRequest, currentUser.id)

            postBody = [
                    after_sale_id: refundRequest.outAfterSaleId,
                    is_approved  : false,
                    reject_reason: [
                            reason_code: rejectReasonCode,
                            desc       : rejectMemo
                    ]
            ]
        } else if (approve == 1) {
            //同意退款
            afterSaleBill = OrderAfterSaleBill.buildFromRefundRequest(refundRequest)
            afterSaleBill.setId(tableIdService.getTableIdMulti("deOrderAfterSaleBill.id", 1, dataSourceId, String.valueOf(supplierCode)))
            afterSaleBill.setBillCode(tableIdService.getTableCodeMulti("deOrderAfterSaleBill.code", dataSourceId, String.valueOf(supplierCode)))
            OrderAfterSaleBill.create(afterSaleBill, currentUser.id)
        }

         */

        //根据订单来源平台,回调平台的接单接口
        switch (refundRequest.platformCode) {
            case "DYLK": {
                //抖音来客
                def postBody = [
                        after_sale_id: refundRequest.outAfterSaleId,
                        is_approved  : approve == 1,
                        reject_reason: {
                            if (approve == 0) {
                                [
                                        reason_code: rejectReasonCode,
                                        desc       : rejectMemo
                                ]
                            }
                        }
                ]

                String responseStr = douyinService.dyPostInvoker("/goodlife/v1/after_sale/audit/notify/", jsonConvert.convertTo(postBody))
                def response = jsonSlurper.parseText(responseStr)
                if (response["extra"]["error_code"] as Integer == 0) {
                    return RetResult.<InvokeCallResult> successT()
                } else {
                    //todo 抖音侧调用失败,怎么处理?
                    logger.error("[抖音来客]商户接单平台接口调用失败:" + response["extra"]["description"] as String)
                    return RetResult.<InvokeCallResult> errorT().retinfo("[抖音来客]商户接单平台接口调用失败:" + response["extra"]["description"] as String)
                }
            }
        }

        return RetResult.<InvokeCallResult> errorT().retinfo("订单来源平台未知!")
    }
}