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.api.StoreService
import com.dderp.common.api.flycat.OrderSearchService
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.order.BusinessOrder
import com.dderp.common.entity.store.StoreInfo
import com.dderp.common.entity.store.StorePlatformRequire
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

    @Resource
    OrderSearchService orderSearchService

    @Resource
    StoreService storeService

    @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 获取订单信息

        RetResult<BusinessOrder> orderResult = orderSearchService.getBusinessOrder(Long.parseLong(orderId), source.currentUser, source.dataSourceId, source.supplierCode)
        if (!orderResult.isSuccess()) {
            return RetResult.<InvokeCallParams> errorT().retinfo("无效的订单信息")
        }

        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

        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) {
        //检查订单信息
        def jsonSlurper = new JsonSlurper()
        def invokeOrder = jsonSlurper.parseText(source.params)

        String orderId = invokeOrder["orderId"] as String

        RetResult<BusinessOrder> orderResult = orderSearchService.getBusinessOrder(Long.parseLong(orderId), source.currentUser, source.dataSourceId, source.supplierCode)
        if (!orderResult.isSuccess()) {
            return RetResult.<InvokeCallResult> errorT().retinfo("无效的订单信息")
        }

        BusinessOrder businessOrder = orderResult.result

        StoreInfo storeInfo = storeService.getStoreInfo(businessOrder.idStore, source.supplierCode, false, false, true)
        if (storeInfo == null) {
            return RetResult.<InvokeCallResult> errorT().retinfo("无效的门店信息")
        }
        StorePlatformRequire storePlatformRequire = storeInfo.requireItem("SFTC", "shopId")
        if (storePlatformRequire == null) {
            return RetResult.<InvokeCallResult> errorT().retinfo("门店未设置顺丰店铺id")
        }

        //秒级时间戳，groovy里面不让用system
        long currentTime = LocalDateTime.now().toEpochSecond(ZoneOffset.ofHours(8))
        long testTime = LocalDateTime.now().toInstant(ZoneOffset.ofHours(8)).toEpochMilli()

        def sfOrder = [
                dev_id        : sfAppId,
                shop_id       : storePlatformRequire.itemValue,
                shop_type     : 1,
                shop_order_id : businessOrder.orderCode,
                order_source  : businessOrder.incomePlatformName,
                order_sequence: String.valueOf(businessOrder.orderSequence),
                order_time    : currentTime,
                push_time     : currentTime,
                version       : 19,

                order_detail  : [
                        total_price     : 30100L,
                        product_type    : 1,
                        weight_gram     : 3000L,
                        product_num     : 15,
                        product_type_num: 5,
                        product_detail  : businessOrder.detailItemList.collect { detailItem ->
                            def productDetail = [
                                    product_name: detailItem.itemName,
                                    product_num : detailItem.itemCount
                            ]
                            return productDetail
                        }
                ],
                receive       : [
                        user_name   : businessOrder.orderDeliveryInfo.receiveMan,
                        user_phone  : businessOrder.orderDeliveryInfo.contractPhone,
                        user_lng    : String.valueOf(businessOrder.orderDeliveryInfo.geoPoiLocation.longitude),
                        user_lat    : String.valueOf(businessOrder.orderDeliveryInfo.geoPoiLocation.latitude),
                        user_address: businessOrder.orderDeliveryInfo.deliverAddress
                ]
        ]

        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 sfCreateOrderJson = apiResult.get(6000, TimeUnit.SECONDS)

            def sfOrderData = jsonSlurper.parseText(sfCreateOrderJson)

            logger.info(sfOrderData)

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

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