dyDeliver/conf/script/1000/expressApi/BE_Express_CreateOrder_SFTC.groovy

import com.alibaba.fastjson2.JSON
import com.dderp.common.api.BusinessExecutor
import com.dderp.common.api.ERPLockDataService
import com.dderp.common.datas.ERPModule
import com.dderp.common.datas.RedisKeys
import com.dderp.common.entity.base.InvokeCallParams
import com.dderp.common.entity.base.InvokeCallResult
import com.dderp.common.entity.express.*
import com.dderp.common.http.HttpTools
import com.dySweetFishPlugin.sql.dao.OperatorWait
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 javax.annotation.Resource
import java.nio.charset.StandardCharsets
import java.time.LocalDateTime
import java.time.ZoneOffset
import java.util.concurrent.CompletableFuture
import java.util.concurrent.ExecutionException
import java.util.concurrent.TimeUnit
import java.util.concurrent.TimeoutException

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

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

    @Resource(name = "property.sftc.appId")
    long sfAppId

    @Resource(name = "property.sftc.appKey")
    String sfAppKey

    @Resource(name = "property.sftc.apiUrl")
    String sfApiUrl

    @Resource
    JsonConvert jsonConvert

    @Resource
    ERPLockDataService lockDataService

    @Override
    String scriptName() {
        return "顺丰同城创建订单"
    }

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

    @Override
    OperatorWait getAWait(InvokeCallParams source) {
        return OperatorWait.ASNYC
    }

    @Override
    RetResult<InvokeCallParams> checkExecute(InvokeCallParams source) {
        //检查订单信息
        def jsonSlurper = new JsonSlurper()
        def invokeOrder = jsonSlurper.parseText(source.params)

        String orderId = invokeOrder["orderId"] as String
        //todo 获取订单信息

        return RetResult.<InvokeCallParams> successT().result(source)
    }

    @Override
    RetResult<InvokeCallParams> beforeExecute(InvokeCallParams source) {
        //锁定下订单数据
        def jsonSlurper = new JsonSlurper()
        def invokeOrder = jsonSlurper.parseText(source.params)

        String orderId = invokeOrder["orderId"] as String

        //todo 获取订单信息
        if (lockDataService.hLockAdd(orderId, RedisKeys.KEY_ERP_WORKING_ORDER, source.supplierCode) > 1) {
            return RetResult.<InvokeCallParams> errorT().retinfo(orderId + "提交工作中，请稍后刷新即可，无需重复操作")
        }
        return RetResult.<InvokeCallParams> successT().result(source)
    }

    @Override
    void afterExecute(boolean executeError, InvokeCallParams source, InvokeCallResult dest) {
        //锁定下订单数据
        def jsonSlurper = new JsonSlurper()
        def invokeOrder = jsonSlurper.parseText(source.params)

        String orderId = invokeOrder["orderId"] as String

        lockDataService.hLockDel(orderId, RedisKeys.KEY_ERP_WORKING_ORDER, source.supplierCode)
    }

    RetResult<InvokeCallResult> execute(InvokeCallParams source) {
        //秒级时间戳，groovy里面不让用system
        long currentTime = LocalDateTime.now().toEpochSecond(ZoneOffset.ofHours(8))
        long testTime = LocalDateTime.now().toInstant(ZoneOffset.ofHours(8)).toEpochMilli()
        SFOrder sfOrder = new SFOrder(
                dev_id: sfAppId,
                shop_id: "3243279847393",
                shop_type: 1,
                shop_order_id: "JY" + testTime + "L",
                order_sequence: "测试",
                lbs_type: 2,
                order_time: currentTime,
                push_time: currentTime,
                vehicle: 0,
                four_wheeler_type: 10,
                rider_pick_method: 1,
                version: 19,

                order_detail: new SFOrderDetail(
                        total_price: 30100L,
                        product_type: 6,
                        weight_gram: 3000L,
                        product_num: 15,
                        product_type_num: 5,
                        product_detail: [
                                new SFOrderProductDetail(
                                        product_name: "测试商品1",
                                        product_num: 1
                                ),
                                new SFOrderProductDetail(
                                        product_name: "测试商品2",
                                        product_num: 3
                                ),
                        ]

                ),

                receive: new SFOrderReceive(
                        user_name: "顺丰同城",
                        user_phone: "18237171439",
                        user_lng: "116.339392",
                        user_lat: "40.002349",
                        user_address: "北京市海淀区学清嘉创大厦A座15层"
                )
        )


        String postData = JSON.toJSONString(sfOrder)
        logger.info("请求数据: " + postData)
        String sign = ExpressApiSign.sfGenerateOpenSign(postData, sfAppId, sfAppKey)

        String url = sfApiUrl + "createorder?sign=" + sign

        CompletableFuture<String> apiResult = HttpTools.postHttpContentAsync(url,
                5000,
                StandardCharsets.UTF_8,
                postData,
                ["Content-Type": "application/json;charset=utf-8"])
        try {
            String orderResult = apiResult.get(6000, TimeUnit.SECONDS)

            def jsonSlurper = new JsonSlurper()
            def sfOrderJson = jsonSlurper.parseText(orderResult)

            logger.info(sfOrderJson)

            SFCreateOrderResult createOrderResult = jsonConvert.convertFromO(SFCreateOrderResult.class, orderResult)
            logger.info(orderResult)
            logger.info(jsonConvert.convertTo(createOrderResult))

            return RetResult.<InvokeCallResult> successT()
        } catch (InterruptedException | ExecutionException | TimeoutException e) {
            logger.error(e.getMessage(), e)

            return RetResult.<InvokeCallResult> errorT().retinfo(e.getMessage())
        }
    }
}