dyDeliver/conf/script/1000/orderApi/BE_Order_ProcessRefund_DYLK.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.ESKeys
import com.dderp.common.datas.flycat.PlatformType
import com.dderp.common.datas.flycat.RefundRequestStatus
import com.dderp.common.entity.base.InvokeCallParams
import com.dderp.common.entity.base.InvokeCallResult
import com.dderp.common.entity.order.OrderAfterSaleBill
import com.dderp.common.entity.order.OrderRefundRequest
import com.dderp.common.entity.order.OrderStep
import com.dderp.common.entity.site.ERPTokenUser
import com.dderp.common.entity.store.StorePlatform
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.elasticsearch.action.bulk.BulkRequestBuilder
import org.elasticsearch.action.bulk.BulkResponse
import org.elasticsearch.action.index.IndexRequestBuilder
import org.elasticsearch.action.support.WriteRequest
import org.elasticsearch.action.update.UpdateRequestBuilder
import org.elasticsearch.common.xcontent.XContentType
import org.rex.RMap

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

import static org.elasticsearch.common.xcontent.XContentFactory.jsonBuilder

@SuppressWarnings("unused")
class BE_Order_ProcessRefund_DYLK 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> 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)
        String incomePlatformOrderCode = invokeOrder["order_id"] as String
        String platformStoreId = invokeOrder["poi_id"] as String
        String outAfterSaleId = invokeOrder["after_sale_id"] as String
        boolean pass = invokeOrder["pass"] as boolean

        StorePlatform storePlatform = storeService.getStorePlatformByInvokeInfo(platformStoreId, "DYLK", PlatformType.order.value, supplierCode)
        if (storePlatform == null) return RetResult.<InvokeCallResult> errorT().retinfo("订单来源平台未知!")
        if (storePlatform.enableStatue == 0) {
            logger.info("[" + storePlatform.platformName + "]门店[" + storePlatform.platformStoreId + "]已被禁用,消息已忽略")
            return RetResult.<InvokeCallResult> errorT().retinfo("[" + storePlatform.platformName + "]门店[" + storePlatform.platformStoreId + "]已被禁用")
        }
//
//        RMap searchParams = new RMap();
//        searchParams.set("incomePlatformId", platformStoreId)
//        searchParams.set("incomePlatformOrderCode", incomePlatformOrderCode)
//
//        RetResult<List<BusinessOrder>> orderResult = orderSearchService.searchBusinessOrderList(searchParams, currentUser, dataSourceId, supplierCode, null)
//        if (!orderResult.isSuccess()) return RetResult.<InvokeCallResult> errorT().retinfo(orderResult.retinfo)
//
//        BusinessOrder esOrder = orderResult.result.get(0) //这么查只可能有一个

        RMap searchParams = new RMap()
        searchParams.set("outAfterSaleId", outAfterSaleId)
        RetResult<List<OrderRefundRequest>> requestRetResult = orderSearchService.searchOrderRefundRequestList(searchParams,
                currentUser, dataSourceId, supplierCode, null)
        if (!requestRetResult.isSuccess()) return RetResult.<InvokeCallResult> errorT().retinfo(requestRetResult.retinfo)

        OrderRefundRequest refundRequest = requestRetResult.result.get(0) //这么查只可能有一个

        OrderAfterSaleBill afterSaleBill
        if (!pass) {
            //拒绝退款
            def codeList = (invokeOrder["refuse_audit_reasons"] as ArrayList).collect { it["code"] as int }
            def msgList = (invokeOrder["refuse_audit_reasons"] as ArrayList).collect { it["msg"] as String }

            refundRequest.setRequestStatus(RefundRequestStatus.refuse.value)
            refundRequest.setRefuseToRefundReasonCodes(jsonConvert.convertTo(codeList))
            refundRequest.setRefuseToRefundMemo(jsonConvert.convertTo(msgList))
            OrderRefundRequest.update(refundRequest, currentUser.id)
        } else {
            //同意退款
            refundRequest.setRequestStatus(RefundRequestStatus.agree.value)
            OrderRefundRequest.update(refundRequest, currentUser.id)

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

        OrderStep orderStep = orderStepService.parseOrderStep(refundRequest.idOrder, "[" + refundRequest.platformName + "]商家已" +
                pass ? "同意" : "拒绝" + "退款", pass ? "" : refundRequest.refuseToRefundMemo, currentUser)

        //持久化
        //订单退款申请
        BulkRequestBuilder bulkRequest = esClient.getClient().prepareBulk().setRefreshPolicy(WriteRequest.RefreshPolicy.IMMEDIATE)

        UpdateRequestBuilder refundQueryRequest = esClient.getClient().prepareUpdate(
                supplierInitService.getDateYearESIndex(supplierCode, ESKeys.ES_DELIVER_ORDER_REFUND_REQUEST_INDEX, 0),
                ESKeys.ES_DELIVER_ORDER_REFUND_REQUEST_TYPE,
                String.valueOf(refundRequest.getId()))
                .setDoc(jsonBuilder()
                        .startObject()
                        .field("requestStatus", refundRequest.requestStatus)
                        .field("updateBy", refundRequest.getUpdateBy())
                        .field("updateTimeLong", refundRequest.getUpdateTimeLong())
                        .endObject())
        bulkRequest.add(refundQueryRequest)

        //订单售后单,只有同意退款才写
        if (afterSaleBill) {
            IndexRequestBuilder afterSaleRequest = esClient.getClient()
                    .prepareIndex(supplierInitService.getDateYearESIndex(supplierCode, ESKeys.ES_DELIVER_BUSINESS_ORDER_INDEX, 0),
                            ESKeys.ES_DELIVER_ORDER_AFTER_SALE_BILL_TYPE)
                    .setId(String.valueOf(afterSaleBill.id))
                    .setParent(String.valueOf(afterSaleBill.idOrder))
                    .setSource(jsonConvert.convertTo(afterSaleBill), XContentType.JSON)
            bulkRequest.add(afterSaleRequest)
        }

        //订单脚印
        IndexRequestBuilder orderStepRequest = esClient.getClient()
                .prepareIndex(supplierInitService.getDateYearESIndex(supplierCode, ESKeys.ES_DELIVER_ORDER_STEP_INDEX, 0),
                        ESKeys.ES_DELIVER_ORDER_STEP_TYPE)
                .setId(String.valueOf(orderStep.id))
                .setSource(jsonConvert.convertTo(orderStep), XContentType.JSON)
        bulkRequest.add(orderStepRequest)


        BulkResponse bulkResponse = bulkRequest.get();
        orderDao = tunaService.generate(OrderDao.class)
        if (bulkResponse.hasFailures()) {
            logger.error("商户已同意/拒绝退款出错：" + bulkResponse.buildFailureMessage());
            return RetResult.<InvokeCallResult> errorT().retinfo("商户已同意/拒绝退款出错:" + refundRequest.orderName);
        } else {
            logger.info("商户已同意/拒绝退款成功");
            //写数据库
            List<OrderAfterSaleBill> afterSaleBillList = new ArrayList<>()
            if (afterSaleBill) afterSaleBillList.add(afterSaleBill)
            orderDao.processRefundOrder(refundRequest,
                    afterSaleBillList,
                    [orderStep],
                    dataSourceId,
                    String.valueOf(supplierCode))

            return RetResult.<InvokeCallResult> successT()
        }
    }
}