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

    //执行逻辑，为代码看清楚点，不要担心这里的代码重复，主要是把逻辑写清楚，免得后期维护麻烦，反正每次通知只有一种情况
    def invokeCallFunc = [
            "rider_status@10"   : { invokeOrder, InvokeCallParams source ->
                //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"],
                        itemContent: ""
                )
                OrderRiderItem.create(orderRiderItem, source.currentUser.id)

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

                //配送员接单/改派
                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))


                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

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

            "rider_status@12"   : { invokeOrder, InvokeCallParams source ->
                //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"],
                        itemContent: ""
                )
                OrderRiderItem.create(orderRiderItem, source.currentUser.id)

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

                //配送员到店
                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))

                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

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

            "rider_status@15"   : { invokeOrder, InvokeCallParams source ->
                //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"],
                        itemContent: ""
                )
                OrderRiderItem.create(orderRiderItem, source.currentUser.id)

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

                //配送员配送中
                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

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

            "order_complete@17" : { invokeOrder, InvokeCallParams source ->
                //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"],
                        itemContent: ""
                )
                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

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

            "rider_recall@22"   : { invokeOrder, InvokeCallParams source ->
                //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: "",
                        itemContent: invokeOrder["status_desc"]
                )
                OrderRiderItem.create(orderRiderItem, source.currentUser.id)

                businessOrder.orderStatus = BusinessOrderStatus.delivery.value
                orderRiderItem.riderStatus = OrderRiderStatus.riderReCall.value
                orderRiderItem.statusDesc = OrderRiderStatus.riderReCall.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

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

            "rider_exception@91": { invokeOrder, InvokeCallParams source ->
                //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: "",
                        riderLat: "",
                        itemContent: invokeOrder["ex_content"]
                )
                OrderRiderItem.create(orderRiderItem, source.currentUser.id)

                orderRiderItem.riderStatus = OrderRiderStatus.exception.value
                switch (invokeOrder["ex_id"] as int) {
                    case 4003:
                        orderRiderItem.statusDesc = "骑士上报异常:" + "托寄物丢失或损坏"
                        break
                    case 1001:
                        orderRiderItem.statusDesc = "骑士上报异常:" + "商家出货慢"
                        break
                    case 2010:
                        orderRiderItem.statusDesc = "骑士上报异常:" + "顾客拒绝实名认证"
                        break
                    case 3004:
                        orderRiderItem.statusDesc = "骑士上报异常:" + "实名认证校验失败"
                        break
                    case 1007:
                        orderRiderItem.statusDesc = "骑士上报异常:" + "更改取货地址"
                        break
                    case 2001:
                        orderRiderItem.statusDesc = "骑士上报异常:" + "顾客电话无法接通"
                        break
                    case 2004:
                        orderRiderItem.statusDesc = "骑士上报异常:" + "更改期望送达时间"
                        break
                    case 2005:
                        orderRiderItem.statusDesc = "骑士上报异常:" + "顾客拒收"
                        break
                    case 2008:
                        orderRiderItem.statusDesc = "骑士上报异常:" + "顾客不在家"
                        break
                    case 2009:
                        orderRiderItem.statusDesc = "骑士上报异常:" + "更改送货地址"
                        break
                    case 4001:
                        orderRiderItem.statusDesc = "骑士上报异常:" + "配送地址错误"
                        break
                    default:
                        orderRiderItem.statusDesc = "骑士上报异常:" + "其他"
                        break
                }

                stepList.add(orderStepService.parseOrderStep(businessOrder.id,
                        "配送异常",
                        "[" + businessOrder.outGoingPlatformName + "]" + orderRiderItem.operatorName + " " + orderRiderItem.statusDesc,
                        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 {
                        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

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

            "sf_cancel@2"       : { invokeOrder, InvokeCallParams source ->
                //region 顺丰原因订单取消回调

                //当订单在顺丰侧被取消时，会由顺丰同城回调对接方回调地址告知订单被取消。
                //一般情况下订单被顺丰侧取消原因为：用户拒收，订单超时严重未完成等等操作原因会在返回error_msg中返回。若仍有疑问，可与调度或骑士联系获取更多信息。

                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"],
                        itemContent: invokeOrder["cancel_reason"]
                )
                OrderRiderItem.create(orderRiderItem, source.currentUser.id)

                businessOrder.orderStatus = BusinessOrderStatus.accept.value
                orderRiderItem.riderStatus = OrderRiderStatus.cancel.value
                orderRiderItem.statusDesc = OrderRiderStatus.cancel.name

                stepList.add(orderStepService.parseOrderStep(businessOrder.id,
                        "配送取消",
                        "[" + businessOrder.outGoingPlatformName + "]" + "配送取消:" + invokeOrder["cancel_reason"],
                        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

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

            "bindnotify@0"      : { invokeOrder, InvokeCallParams source ->
                storeService.bindStorePlatform(source.params, "SFTC", source.dataSourceId, source.supplierCode, source.currentUser)
                return RetResult.<InvokeCallResult> successT().result(
                        InvokeCallResult.success()
                )
            }
    ]

    @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"]
        int orderStatus = 0
        if (!StringUtils.equalsIgnoreCase("bindnotify", urlIndex)) {
            orderStatus = invokeOrder["order_status"] as int
        }

        return invokeCallFunc.get(urlIndex + "@" + orderStatus).call(invokeOrder, source)

    }
}