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

import com.dderp.business.dao.OrderDao
import com.dderp.common.api.*
import com.dderp.common.api.flycat.OrderSearchService
import com.dderp.common.api.flycat.OrderStepService
import com.dderp.common.datas.ERPModule
import com.dderp.common.datas.ESKeys
import com.dderp.common.datas.RedisKeys
import com.dderp.common.datas.flycat.BusinessOrderStatus
import com.dderp.common.datas.flycat.OrderRiderStatus
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.OrderRiderItem
import com.dderp.common.entity.order.OrderStep
import com.dySweetFishPlugin.elasticsearch.ESClient
import com.dySweetFishPlugin.sql.TableIdService
import com.dySweetFishPlugin.sql.dao.OperatorWait
import com.dySweetFishPlugin.sql.dao.TunaService
import com.sweetfish.convert.json.JsonConvert
import com.sweetfish.service.RetResult
import groovy.json.JsonSlurper
import org.apache.commons.lang3.StringUtils
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.UpdateRequest
import org.elasticsearch.common.xcontent.XContentType

import javax.annotation.Resource

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

class BE_Express_CallBack_Invoke_SFTC implements BusinessExecutor<InvokeCallParams, InvokeCallResult> {

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

    @Resource
    JsonConvert jsonConvert

    @Resource
    ERPLockDataService lockDataService

    @Resource
    NoSqlKeysService keysService

    @Resource
    StoreService storeService

    @Resource
    OrderSearchService orderSearchService

    @Resource
    OrderStepService orderStepService

    @Resource
    TableIdService tableIdService

    @Resource
    TunaService tunaService

    @Resource
    ESClient esClient

    @Resource
    SupplierInitService supplierService

    private OrderDao orderDao

    @Override
    String scriptName() {
        return "顺丰同城数据回调"
    }

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

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

    @Override
    void start(long supplierCode) {
        orderDao = tunaService.generate(OrderDao.class)
    }

    @Override
    RetResult<InvokeCallParams> beforeExecute(InvokeCallParams source) {
        //此回调post的数据看着没有子表，直接用groovy自带的json即可，如果有子表，还是应该建立一个类进行转换

        //锁定下数据，防止重复提交
        def jsonSlurper = new JsonSlurper()
        def invokeOrder = jsonSlurper.parseText(source.params)

        String urlIndex = invokeOrder["url_index"] as String

        //这里除了店铺授权和店铺取消授权，其它都是订单，if-else先写着
        if (StringUtils.equalsIgnoreCase("bindnotify", urlIndex)) {
            //店铺授权回调
            String shopId = invokeOrder["shop_id"] as String
            if (lockDataService.hLockAdd(shopId, RedisKeys.KEY_ERP_WORKING_SF_STORE, source.supplierCode) > 1) {
                return RetResult.<InvokeCallParams> errorT().retinfo(shopId + "提交工作中，请稍后刷新即可，无需重复操作")
            }
        } else if (StringUtils.equalsIgnoreCase("cancelbindnotify", urlIndex)) {
            //店铺取消授权回调
            String shopId = invokeOrder["shop_id"] as String
            if (lockDataService.hLockAdd(shopId, RedisKeys.KEY_ERP_WORKING_SF_STORE, source.supplierCode) > 1) {
                return RetResult.<InvokeCallParams> errorT().retinfo(shopId + "提交工作中，请稍后刷新即可，无需重复操作")
            }
        } else {
            String invokeOrderId = invokeOrder["shop_order_id"] as String
            if (lockDataService.hLockAdd(invokeOrderId, RedisKeys.KEY_ERP_WORKING_ORDER, source.supplierCode) > 1) {
                return RetResult.<InvokeCallParams> errorT().retinfo(invokeOrderId + "提交工作中，请稍后刷新即可，无需重复操作")
            }
        }

        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 urlIndex = invokeOrder["url_index"] as String
        if (StringUtils.equalsIgnoreCase("bindnotify", urlIndex)) {
            //店铺授权回调
            String shopId = invokeOrder["shop_id"] as String
            lockDataService.hLockDel(shopId, RedisKeys.KEY_ERP_WORKING_SF_STORE, source.supplierCode)
        } else if (StringUtils.equalsIgnoreCase("cancelbindnotify", urlIndex)) {
            //店铺取消授权回调
            String shopId = invokeOrder["shop_id"] as String
            lockDataService.hLockDel(shopId, RedisKeys.KEY_ERP_WORKING_SF_STORE, source.supplierCode)
        } else {
            String invokeOrderId = invokeOrder["shop_order_id"] as String
            lockDataService.hLockDel(invokeOrderId, RedisKeys.KEY_ERP_WORKING_ORDER, source.supplierCode)
        }
    }

    RetResult<InvokeCallResult> execute(InvokeCallParams source) {
        def jsonSlurper = new JsonSlurper()
        def invokeOrder = jsonSlurper.parseText(source.params)

        logger.info(source.params)

        //https://openic.sf-express.com/open/api/docs/index#/apidoc
        //顺丰订单的逻辑，只有取消和完成才是订单终态
        String urlIndex = invokeOrder["url_index"]
        if (StringUtils.equalsIgnoreCase("rider_status", urlIndex)) {
            //region 配送状态更改回调

            long orderId = invokeOrder["shop_order_id"] as long
            RetResult<BusinessOrder> orderResult = orderSearchService.getBusinessOrder(orderId,
                    source.currentUser, source.dataSourceId, source.supplierCode)

            if (!orderResult.isSuccess()) {
                return RetResult.<InvokeCallResult> errorT().retinfo("无效的订单信息")
            }

            BusinessOrder businessOrder = orderResult.result

            OrderRiderItem orderRiderItem = new OrderRiderItem(
                    id: tableIdService.getTableIdMulti("deOrderRiderItems.id", 1, source.dataSourceId, String.valueOf(source.supplierCode)),
                    idOrder: businessOrder.id,
                    idPlatform: businessOrder.outGoingPlatformId,
                    platformCode: 'SFTC',
                    platformName: businessOrder.outGoingPlatformName,
                    platformOrderId: invokeOrder["sf_order_id"],
                    operatorName: invokeOrder["operator_name"],
                    operatorPhone: invokeOrder["operator_phone"],
                    riderLng: invokeOrder["rider_lng"],
                    riderLat: invokeOrder["rider_lat"]
            )
            OrderRiderItem.create(orderRiderItem, source.currentUser.id)

            List<OrderStep> stepList = new ArrayList<>()

            int sfOrderStatus = invokeOrder["order_status"] as int
            if (sfOrderStatus == 10) {
                //配送员接单/改派
                businessOrder.orderStatus = BusinessOrderStatus.riderReceiving.value
                orderRiderItem.riderStatus = OrderRiderStatus.accept.value
                orderRiderItem.statusDesc = OrderRiderStatus.accept.name

                stepList.add(orderStepService.parseOrderStep(businessOrder.id,
                        "配送接单",
                        "[" + businessOrder.outGoingPlatformName + "]" + orderRiderItem.operatorName + "(" + orderRiderItem.operatorPhone + ")接单",
                        source.currentUser))
            } else if (sfOrderStatus == 12) {
                //配送员到店
                businessOrder.orderStatus = BusinessOrderStatus.riderComing.value
                orderRiderItem.riderStatus = OrderRiderStatus.store.value
                orderRiderItem.statusDesc = OrderRiderStatus.store.name

                stepList.add(orderStepService.parseOrderStep(businessOrder.id,
                        "配送到店",
                        "[" + businessOrder.outGoingPlatformName + "]" + orderRiderItem.operatorName + "(" + orderRiderItem.operatorPhone + ")到店",
                        source.currentUser))
            } else if (sfOrderStatus == 15) {
                //配送员配送中
                businessOrder.orderStatus = BusinessOrderStatus.riderTaking.value
                orderRiderItem.riderStatus = OrderRiderStatus.working.value
                orderRiderItem.statusDesc = OrderRiderStatus.working.name

                stepList.add(orderStepService.parseOrderStep(businessOrder.id,
                        "开始配送",
                        "[" + businessOrder.outGoingPlatformName + "]" + orderRiderItem.operatorName + "(" + orderRiderItem.operatorPhone + ")配送",
                        source.currentUser))
            }

            int iData = orderDao.expressRiderOrder(businessOrder, orderRiderItem, stepList, source.dataSourceId, source.supplierCode + "_1")

            if (iData >= 0) {
                BulkRequestBuilder bulkRequest = esClient.getClient().prepareBulk().setRefreshPolicy(WriteRequest.RefreshPolicy.IMMEDIATE)
                try {
                    UpdateRequest orderRequest = new UpdateRequest(
                            supplierService.getDateYearESIndex(source.supplierCode, ESKeys.ES_DELIVER_BUSINESS_ORDER_INDEX, 1),
                            ESKeys.ES_DELIVER_BUSINESS_ORDER_TYPE, String.valueOf(businessOrder.id))
                            .doc(jsonBuilder()
                                    .startObject()
                                    .field("orderStatus", businessOrder.orderStatus)
                                    .endObject())
                    bulkRequest.add(orderRequest)

                    IndexRequestBuilder itemRequest = esClient.getClient()
                            .prepareIndex(supplierService.getDateYearESIndex(source.supplierCode, ESKeys.ES_DELIVER_BUSINESS_ORDER_INDEX, 1),
                                    ESKeys.ES_DELIVER_ORDER_RIDER_ITEM_TYPE)
                            .setId(String.valueOf(orderRiderItem.id))
                            .setParent(String.valueOf(orderRiderItem.idOrder))
                            .setSource(jsonConvert.convertTo(orderRiderItem), XContentType.JSON)
                    bulkRequest.add(itemRequest)

                    stepList.each { orderStep ->
                        IndexRequestBuilder orderStepRequest = esClient.getClient()
                                .prepareIndex(supplierService.getDateYearESIndex(source.supplierCode, ESKeys.ES_DELIVER_ORDER_STEP_INDEX, 1),
                                        ESKeys.ES_DELIVER_ORDER_STEP_TYPE)
                                .setSource(jsonConvert.convertTo(orderStep), XContentType.JSON)
                        bulkRequest.add(orderStepRequest)
                    }

                    //写入到es索引中
                    BulkResponse bulkResponse = bulkRequest.execute().actionGet()
                    if (bulkResponse.hasFailures()) {
                        logger.error("订单配送发单错误：" + bulkResponse.buildFailureMessage())
                    }
                } catch (Exception e) {
                    logger.error("订单配送发单错误：" + e.getMessage(), e)
                }
            }

            //endregion
        } else if (StringUtils.equalsIgnoreCase("order_complete", urlIndex)) {
            //region 订单完成
            long orderId = invokeOrder["shop_order_id"] as long
            RetResult<BusinessOrder> orderResult = orderSearchService.getBusinessOrder(orderId,
                    source.currentUser, source.dataSourceId, source.supplierCode)

            if (!orderResult.isSuccess()) {
                return RetResult.<InvokeCallResult> errorT().retinfo("无效的订单信息")
            }

            BusinessOrder businessOrder = orderResult.result

            List<OrderStep> stepList = new ArrayList<>()

            OrderRiderItem orderRiderItem = new OrderRiderItem(
                    id: tableIdService.getTableIdMulti("deOrderRiderItems.id", 1, source.dataSourceId, String.valueOf(source.supplierCode)),
                    idOrder: businessOrder.id,
                    idPlatform: businessOrder.outGoingPlatformId,
                    platformCode: 'SFTC',
                    platformName: businessOrder.outGoingPlatformName,
                    platformOrderId: invokeOrder["sf_order_id"],
                    operatorName: invokeOrder["operator_name"],
                    operatorPhone: invokeOrder["operator_phone"],
                    riderLng: invokeOrder["rider_lng"],
                    riderLat: invokeOrder["rider_lat"]
            )
            OrderRiderItem.create(orderRiderItem, source.currentUser.id)
            businessOrder.orderStatus = BusinessOrderStatus.riderComplete.value
            orderRiderItem.riderStatus = OrderRiderStatus.complete.value
            orderRiderItem.statusDesc = OrderRiderStatus.complete.name

            stepList.add(orderStepService.parseOrderStep(businessOrder.id,
                    "配送完成",
                    "[" + businessOrder.outGoingPlatformName + "]" + orderRiderItem.operatorName + "(" + orderRiderItem.operatorPhone + ")配送完成",
                    source.currentUser))

            int iData = orderDao.expressRiderOrder(businessOrder, orderRiderItem, stepList, source.dataSourceId, source.supplierCode + "_1")

            if (iData >= 0) {
                BulkRequestBuilder bulkRequest = esClient.getClient().prepareBulk().setRefreshPolicy(WriteRequest.RefreshPolicy.IMMEDIATE)
                try {
                    UpdateRequest orderRequest = new UpdateRequest(
                            supplierService.getDateYearESIndex(source.supplierCode, ESKeys.ES_DELIVER_BUSINESS_ORDER_INDEX, 1),
                            ESKeys.ES_DELIVER_BUSINESS_ORDER_TYPE, String.valueOf(businessOrder.id))
                            .doc(jsonBuilder()
                                    .startObject()
                                    .field("orderStatus", businessOrder.orderStatus)
                                    .endObject())
                    bulkRequest.add(orderRequest)

                    IndexRequestBuilder itemRequest = esClient.getClient()
                            .prepareIndex(supplierService.getDateYearESIndex(source.supplierCode, ESKeys.ES_DELIVER_BUSINESS_ORDER_INDEX, 1),
                                    ESKeys.ES_DELIVER_ORDER_RIDER_ITEM_TYPE)
                            .setId(String.valueOf(orderRiderItem.id))
                            .setParent(String.valueOf(orderRiderItem.idOrder))
                            .setSource(jsonConvert.convertTo(orderRiderItem), XContentType.JSON)
                    bulkRequest.add(itemRequest)

                    stepList.each { orderStep ->
                        IndexRequestBuilder orderStepRequest = esClient.getClient()
                                .prepareIndex(supplierService.getDateYearESIndex(source.supplierCode, ESKeys.ES_DELIVER_ORDER_STEP_INDEX, 1),
                                        ESKeys.ES_DELIVER_ORDER_STEP_TYPE)
                                .setSource(jsonConvert.convertTo(orderStep), XContentType.JSON)
                        bulkRequest.add(orderStepRequest)
                    }

                    //写入到es索引中
                    BulkResponse bulkResponse = bulkRequest.execute().actionGet()
                    if (bulkResponse.hasFailures()) {
                        logger.error("订单配送发单错误：" + bulkResponse.buildFailureMessage())
                    }
                } catch (Exception e) {
                    logger.error("订单配送发单错误：" + e.getMessage(), e)
                }
            }

            //endregion
        } else if (StringUtils.equalsIgnoreCase("rider_recall", urlIndex)) {
            //region 配送员撤单

            //当订单被骑士撤单的时候，顺丰同城会将订单撤撤单状态进行回调通知。
            //注：顺丰同城撤单是指订单由A骑士接单后，因A骑士自身原因无法继续配送，故会将订单撤回抢单池，允许其他骑士继续抢单直至订单完结

            //此消息并不会完全配送撤单，需要修正一下订单状态、轨迹和脚印
            long orderId = invokeOrder["shop_order_id"] as long
            RetResult<BusinessOrder> orderResult = orderSearchService.getBusinessOrder(orderId,
                    source.currentUser, source.dataSourceId, source.supplierCode)

            if (!orderResult.isSuccess()) {
                return RetResult.<InvokeCallResult> errorT().retinfo("无效的订单信息")
            }

            BusinessOrder businessOrder = orderResult.result

            List<OrderStep> stepList = new ArrayList<>()

            OrderRiderItem orderRiderItem = new OrderRiderItem(
                    id: tableIdService.getTableIdMulti("deOrderRiderItems.id", 1, source.dataSourceId, String.valueOf(source.supplierCode)),
                    idOrder: businessOrder.id,
                    idPlatform: businessOrder.outGoingPlatformId,
                    platformCode: 'SFTC',
                    platformName: businessOrder.outGoingPlatformName,
                    platformOrderId: invokeOrder["sf_order_id"],
                    operatorName: "",
                    operatorPhone: "",
                    riderLng: "",
                    riderLat: ""
            )
            OrderRiderItem.create(orderRiderItem, source.currentUser.id)
            businessOrder.orderStatus = BusinessOrderStatus.riderComplete.value
            orderRiderItem.riderStatus = OrderRiderStatus.complete.value
            orderRiderItem.statusDesc = OrderRiderStatus.complete.name

            stepList.add(orderStepService.parseOrderStep(businessOrder.id,
                    "配送撤单",
                    "[" + businessOrder.outGoingPlatformName + "]" + "配送员撤单",
                    source.currentUser))

            int iData = orderDao.expressRiderOrder(businessOrder, orderRiderItem, stepList, source.dataSourceId, source.supplierCode + "_1")

            if (iData >= 0) {
                BulkRequestBuilder bulkRequest = esClient.getClient().prepareBulk().setRefreshPolicy(WriteRequest.RefreshPolicy.IMMEDIATE)
                try {
                    UpdateRequest orderRequest = new UpdateRequest(
                            supplierService.getDateYearESIndex(source.supplierCode, ESKeys.ES_DELIVER_BUSINESS_ORDER_INDEX, 1),
                            ESKeys.ES_DELIVER_BUSINESS_ORDER_TYPE, String.valueOf(businessOrder.id))
                            .doc(jsonBuilder()
                                    .startObject()
                                    .field("orderStatus", businessOrder.orderStatus)
                                    .endObject())
                    bulkRequest.add(orderRequest)

                    IndexRequestBuilder itemRequest = esClient.getClient()
                            .prepareIndex(supplierService.getDateYearESIndex(source.supplierCode, ESKeys.ES_DELIVER_BUSINESS_ORDER_INDEX, 1),
                                    ESKeys.ES_DELIVER_ORDER_RIDER_ITEM_TYPE)
                            .setId(String.valueOf(orderRiderItem.id))
                            .setParent(String.valueOf(orderRiderItem.idOrder))
                            .setSource(jsonConvert.convertTo(orderRiderItem), XContentType.JSON)
                    bulkRequest.add(itemRequest)

                    stepList.each { orderStep ->
                        IndexRequestBuilder orderStepRequest = esClient.getClient()
                                .prepareIndex(supplierService.getDateYearESIndex(source.supplierCode, ESKeys.ES_DELIVER_ORDER_STEP_INDEX, 1),
                                        ESKeys.ES_DELIVER_ORDER_STEP_TYPE)
                                .setSource(jsonConvert.convertTo(orderStep), XContentType.JSON)
                        bulkRequest.add(orderStepRequest)
                    }

                    //写入到es索引中
                    BulkResponse bulkResponse = bulkRequest.execute().actionGet()
                    if (bulkResponse.hasFailures()) {
                        logger.error("订单配送发单错误：" + bulkResponse.buildFailureMessage())
                    }
                } catch (Exception e) {
                    logger.error("订单配送发单错误：" + e.getMessage(), e)
                }
            }

            //endregion
        } else if (StringUtils.equalsIgnoreCase("bindnotify", urlIndex)) {
            storeService.bindStorePlatform(source.params, "SFTC", source.dataSourceId, source.supplierCode, source.currentUser)
        }

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