dyDeliver/conf/script/1000/orderSearch/BE_ERP_BusinessOrder_Search.groovy

import com.dderp.common.api.BusinessExecutor
import com.dderp.common.api.SupplierInitService
import com.dderp.common.datas.ERPModule
import com.dderp.common.datas.ESKeys
import com.dderp.common.datas.ReadOrderOption
import com.dderp.common.datas.TokenUserFrom
import com.dderp.common.entity.base.ProcessSearchOptionsItem
import com.dderp.common.entity.order.*
import com.dderp.common.entity.site.ERPTokenUser
import com.dderp.common.tool.ERPUtils
import com.dySweetFishPlugin.elasticsearch.ESClient
import com.dySweetFishPlugin.tool.lang.DateUtil
import com.sweetfish.convert.json.JsonConvert
import com.sweetfish.service.RetResult
import org.apache.commons.lang3.StringUtils
import org.apache.logging.log4j.LogManager
import org.apache.logging.log4j.Logger
import org.apache.lucene.search.join.ScoreMode
import org.elasticsearch.action.search.SearchResponse
import org.elasticsearch.index.query.BoolQueryBuilder
import org.elasticsearch.index.query.Operator
import org.elasticsearch.index.query.QueryBuilder
import org.elasticsearch.index.query.QueryBuilders
import org.elasticsearch.join.query.JoinQueryBuilders
import org.elasticsearch.search.aggregations.AggregationBuilders
import org.elasticsearch.search.aggregations.metrics.sum.InternalSum
import org.elasticsearch.search.aggregations.metrics.valuecount.ValueCount
import org.elasticsearch.search.sort.SortBuilders
import org.elasticsearch.search.sort.SortOrder
import org.rex.RMap

import javax.annotation.Resource
import java.math.RoundingMode
import java.util.function.ToLongFunction

@SuppressWarnings(["rawtypes", "unused"])
class BE_ERP_BusinessOrder_Search implements BusinessExecutor<ProcessSearchOptionsItem<ReadOrderOption>, BusinessOrder> {

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

    @Resource
    SupplierInitService supplierService

    @Resource
    ESClient esClient

    @Resource
    JsonConvert jsonConvert

    @Override
    String scriptName() {
        return "ERP-外卖订单-查询"
    }

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


    def <T> List<T> searchOrderChildInfoList(Class<T> clazz, String childESType, long[] idOrders, long supplierCode) {
        return ESList.<T> getESList()
                .esClient(esClient)
                .jsonConvert(jsonConvert)
                .clazz(clazz)
                .queryBuilder({
                    //获取完成的数据情况
                    return QueryBuilders.boolQuery()
                            .must(QueryBuilders.typeQuery(childESType))
                            .must(QueryBuilders.termsQuery("idOrder", ERPUtils.longArrayToStrArray(idOrders)))
                })
                .index(supplierService.getDateYearESIndex(supplierCode, ESKeys.ES_DELIVER_BUSINESS_ORDER_INDEX, 1))
                .executeNonePage()
    }

    def <T> Map<Long, List<T>> searchOrderChildInfoMap(Class<T> clazz, String childESType, long[] idOrders, long supplierCode, ToLongFunction<T> convertLong) {
        return ESMap.<T> getESMap()
                .srcIds(idOrders)
                .esClient(esClient)
                .jsonConvert(jsonConvert)
                .clazz(clazz)
                .queryBuilder({
                    //获取完成的数据情况
                    return QueryBuilders.boolQuery()
                            .must(QueryBuilders.typeQuery(childESType))
                            .must(QueryBuilders.termsQuery("idOrder", ERPUtils.longArrayToStrArray(idOrders)))
                })
                .convertLongExecutor(convertLong) //这里直接写{it.idOrder}，只要所有的子类有这个值，groovy应该是可以的，只是看着难受，让调用接口传入转换方法
                .index(supplierService.getDateYearESIndex(supplierCode, ESKeys.ES_DELIVER_BUSINESS_ORDER_INDEX, 1))
                .execute()
    }

    def <T> List<T> getOrderChildInfoList(Class<T> clazz, String childESType, long idOrder, long supplierCode) {
        return ESList.<T> getESList()
                .esClient(esClient)
                .jsonConvert(jsonConvert)
                .clazz(clazz)
                .queryBuilder({
                    //获取完成的数据情况
                    return QueryBuilders.boolQuery()
                            .must(QueryBuilders.typeQuery(childESType))
                            .must(QueryBuilders.termQuery("idOrder", idOrder))
                })
                .index(supplierService.getDateYearESIndex(supplierCode, ESKeys.ES_DELIVER_BUSINESS_ORDER_INDEX, 1))
                .executeNonePage()
    }

    def <T> T getOrderChildInfo(Class<T> clazz, String childESType, long idOrder, long supplierCode) {
        return ESOne.<T> getESOneInfo()
                .esClient(esClient)
                .jsonConvert(jsonConvert)
                .clazz(clazz)
                .queryBuilder({
                    //获取完成的数据情况
                    return QueryBuilders.boolQuery()
                            .must(QueryBuilders.typeQuery(childESType))
                            .must(QueryBuilders.termQuery("idOrder", idOrder))
                })
                .index(supplierService.getDateYearESIndex(supplierCode, ESKeys.ES_DELIVER_BUSINESS_ORDER_INDEX, 1))
                .execute()
    }

    def readOrderOptions(List<BusinessOrder> orderList, long supplierCode,
                         ReadOrderOption... options) {
        long[] idOrders = orderList*.id.toArray() as long[]

        if ((options != null) && (options.length > 0) && (idOrders.length > 0)) {
            //防止搞坏事，options传重复数据过来，先去重
            options.toUnique().each { opt ->
                switch (opt) {
                    case ReadOrderOption.ORDER_PRODUCT:
                        Map<Long, List<OrderDetailItem>> orderItemMap = searchOrderChildInfoMap(OrderDetailItem.class, ESKeys.ES_DELIVER_ORDER_DETAIL_ITEM_TYPE, idOrders, supplierCode, { it.idOrder })
                        orderList.each { order ->
                            order.detailItemList = orderItemMap.get(order.id)
                        }

                        break
                    case ReadOrderOption.ORDER_DELIVERY:
                        List<OrderDeliveryInfo> childInfoList = searchOrderChildInfoList(OrderDeliveryInfo.class, ESKeys.ES_DELIVER_ORDER_DELIVERY_INFO_TYPE, idOrders, supplierCode)
                        orderList.each { o ->
                            o.orderDeliveryInfo = childInfoList.find { c -> c.idOrder == o.id }
                        }
                        break
                    case ReadOrderOption.ORDER_FINANCES:
                        List<OrderFinances> childInfoList = searchOrderChildInfoList(OrderFinances.class, ESKeys.ES_DELIVER_ORDER_FINANCES_TYPE, idOrders, supplierCode)
                        orderList.each { o ->
                            o.orderFinances = childInfoList.find { c -> c.idOrder == o.id }
                        }
                        List<OrderDiscount> childInfoList1 = searchOrderChildInfoList(OrderDiscount.class, ESKeys.ES_DELIVER_ORDER_DISCOUNT_TYPE, idOrders, supplierCode)
                        orderList.each { o ->
                            o.orderDiscountList = childInfoList1.findAll { c -> c.idOrder == o.id }
                        }
                        break
                    case ReadOrderOption.ORDER_RIDER:
                        Map<Long, List<OrderRiderItem>> orderItemMap = searchOrderChildInfoMap(OrderRiderItem.class, ESKeys.ES_DELIVER_ORDER_RIDER_ITEM_TYPE, idOrders, supplierCode, { it.idOrder })
                        orderList.each { order ->
                            order.riderItemList = orderItemMap.get(order.id)
                        }

                        break
                }
            }
        }
    }

    def readOrderOptions(BusinessOrder businessOrder, long supplierCode,
                         ReadOrderOption... options) {
        if ((options != null) && (options.length > 0)) {
            //防止搞坏事，options传重复数据过来，先去重
            options.toUnique().each { opt ->
                switch (opt) {
                    case ReadOrderOption.ORDER_PRODUCT:
                        businessOrder.detailItemList = getOrderChildInfoList(OrderDetailItem.class, ESKeys.ES_DELIVER_ORDER_DETAIL_ITEM_TYPE, businessOrder.id, supplierCode)

                        break
                    case ReadOrderOption.ORDER_DELIVERY:
                        businessOrder.orderDeliveryInfo = getOrderChildInfo(OrderDeliveryInfo.class, ESKeys.ES_DELIVER_ORDER_DELIVERY_INFO_TYPE, businessOrder.id, supplierCode)

                        break
                    case ReadOrderOption.ORDER_FINANCES:
                        businessOrder.orderFinances = getOrderChildInfo(OrderFinances.class, ESKeys.ES_DELIVER_ORDER_FINANCES_TYPE, businessOrder.id, supplierCode)

                        break
                    case ReadOrderOption.ORDER_RIDER:
                        businessOrder.riderItemList = getOrderChildInfoList(OrderRiderItem.class, ESKeys.ES_DELIVER_ORDER_RIDER_ITEM_TYPE, businessOrder.id, supplierCode)

                        break
                }
            }
        }
    }

    def readOrderTotal(RMap searchData, ERPTokenUser currentUser, long supplierCode, ReadOrderOption... options) {

        if (!(ReadOrderOption.ORDER_TOTAL in options)) {
            return null
        }



        //这里的查询需要和主表一致
        BoolQueryBuilder bqb = searchByFinance(searchData)
                .byOrderParentQuery(
                        search(searchData)
                                .byOrderStates()
                                .byKeyWord()
                                .byOrderCode()
                                .byIdPlatformIn()
                                .byIdPlatformOut()
                                .byVoidFlagIn()
                                .byVoidFlagOut()
                                .byDeliverAddress_QuerySlave()
                                .byItemName_QuerySlave()
                                .byIdStore()
                                .byBeginTime_Create()
                                .byEndTime_Create()
                                .build()
                )

                .build()


        //合计金额，所以主表从orderMoney中开始

        SearchResponse searchResponse = esClient.getClient()
                .prepareSearch(supplierService.getDateYearESIndex(supplierCode, ESKeys.ES_DELIVER_BUSINESS_ORDER_INDEX, 1))
                .setQuery(bqb)
                .addAggregation(AggregationBuilders.count("sub_count").field("id"))
                .addAggregation(AggregationBuilders.sum("orderMoneySum").field("orderMoney"))
                .addAggregation(AggregationBuilders.sum("deliverFeeSum").field("deliverFee"))
                .addAggregation(AggregationBuilders.sum("orderPlatformSubsidySum").field("orderPlatformSubsidy"))
                .addAggregation(AggregationBuilders.sum("storeDiscountSum").field("storeDiscount"))
                .addAggregation(AggregationBuilders.sum("customerPaidSum").field("customerPaid"))
                .addAggregation(AggregationBuilders.sum("platformServiceFeeSum").field("platformServiceFee"))
                .addAggregation(AggregationBuilders.sum("storeRealCollectionSum").field("storeRealCollection"))
                .addAggregation(AggregationBuilders.sum("omeServiceFeeSum").field("omeServiceFee"))
                .execute().actionGet()

        ValueCount orderCountSum = searchResponse.getAggregations().get("sub_count")
        InternalSum orderMoneySum = searchResponse.getAggregations().get("orderMoneySum")
        InternalSum deliverFeeSum = searchResponse.getAggregations().get("deliverFeeSum")
        InternalSum orderPlatformSubsidySum = searchResponse.getAggregations().get("orderPlatformSubsidySum")
        InternalSum storeDiscountSum = searchResponse.getAggregations().get("storeDiscountSum")
        InternalSum customerPaidSum = searchResponse.getAggregations().get("customerPaidSum")
        InternalSum platformServiceFeeSum = searchResponse.getAggregations().get("platformServiceFeeSum")
        InternalSum storeRealCollectionSum = searchResponse.getAggregations().get("storeRealCollectionSum")
        InternalSum omeServiceFeeSum = searchResponse.getAggregations().get("omeServiceFeeSum")

        RMap<String, Number> collectionData = new RMap<>()
        collectionData.put("orderCountSum", orderCountSum.getValue())
        collectionData.put("orderMoneySum", BigDecimal.valueOf(orderMoneySum.getValue()).setScale(2, RoundingMode.HALF_UP))
        collectionData.put("deliverFeeSum", BigDecimal.valueOf(deliverFeeSum.getValue()).setScale(2, RoundingMode.HALF_UP))
        collectionData.put("orderPlatformSubsidySum", BigDecimal.valueOf(orderPlatformSubsidySum.getValue()).setScale(2, RoundingMode.HALF_UP))
        collectionData.put("storeDiscountSum", BigDecimal.valueOf(storeDiscountSum.getValue()).setScale(0, RoundingMode.HALF_UP))
        collectionData.put("customerPaidSum", BigDecimal.valueOf(customerPaidSum.getValue()).setScale(0, RoundingMode.HALF_UP))
        collectionData.put("platformServiceFeeSum", BigDecimal.valueOf(platformServiceFeeSum.getValue()).setScale(0, RoundingMode.HALF_UP))
        collectionData.put("storeRealCollectionSum", BigDecimal.valueOf(storeRealCollectionSum.getValue()).setScale(0, RoundingMode.HALF_UP))
        collectionData.put("omeServiceFeeSum", BigDecimal.valueOf(omeServiceFeeSum.getValue()).setScale(0, RoundingMode.HALF_UP))

        return collectionData

    }

    private RetResult<List<BusinessOrder>> queryByConditions(ProcessSearchOptionsItem<ReadOrderOption> source) {
        String orderByField = "createTimeLong"
        String orderBySort = "desc"

        if (StringUtils.isNotBlank(source.orderBy)) {
            orderByField = source.orderBy.split(",")[0].trim()
            orderBySort = source.orderBy.split(",")[1].trim().toLowerCase()
        }

        if ((source.currentUser.userFrom == TokenUserFrom.APP_STORE_ADMIN.value) || (source.currentUser.userFrom == TokenUserFrom.PC_STORE_ADMIN.value)) {
            if (source.searchData == null) {
                source.searchData = new RMap()
            }

            source.searchData.put("idStore", source.currentUser.idBindOrg)
        }

        List<BusinessOrder> orderList = ESList.<BusinessOrder> getESList()
                .esClient(esClient)
                .jsonConvert(jsonConvert)
                .clazz(BusinessOrder.class)
                .queryBuilder({
                    return search(source.searchData)
                            .byOrderStates()
                            .byKeyWord()
                            .byOrderCode()
                            .byIdPlatformIn()
                            .byIdPlatformOut()
                            .byVoidFlagIn()
                            .byVoidFlagOut()
                            .byDeliverAddress_QuerySlave()
                            .byItemName_QuerySlave()
                            .byIdStore()
                            .byBeginTime_Create()
                            .byEndTime_Create()
                            .build()
                })
                .index(supplierService.getDateYearESIndex(source.supplierCode, ESKeys.ES_DELIVER_BUSINESS_ORDER_INDEX, 1))
                .sortBuilder({
                    switch (orderBySort) {
                        case 'asc': return SortBuilders.fieldSort(orderByField).order(SortOrder.ASC)
                        case 'desc': return SortBuilders.fieldSort(orderByField).order(SortOrder.DESC)
                    }

                })
                .dataExecutor(null)
                .executePage(source.pageFlipper)

        readOrderOptions(orderList, source.supplierCode, source.options)

        RMap<String, Number> collectionData = readOrderTotal(source.searchData, source.currentUser, source.supplierCode, source.options)
        return RetResult.<List<BusinessOrder>> successT().result(orderList).page(source.pageFlipper).attachRMap(collectionData)


    }

    private RetResult<List<BusinessOrder>> queryByIds(ProcessSearchOptionsItem<ReadOrderOption> source) {
        if (!ERPUtils.mapContainKey(source.searchData, ERPUtils.PARAM_SEARCH_IDS)) {
            return RetResult.<List<BusinessOrder>> errorT().retinfo("无效的ids参数")
        }


        String[] idOrders = source.searchData.get(ERPUtils.PARAM_SEARCH_IDS)
        //ES规定，addIds或者terms中的数据长度好像是1024个限制，这里为了安全，把list拆分一下
        //待测试下，collate分隔之后的类型，不行的话还是得List<List<String>>
        //测试后，结果是List<List<>>，不明白数组为什么转成List
        List<List<String>> idOrderArrayList = idOrders.collate(500)
        List<BusinessOrder> orderList = new ArrayList<>()

        idOrderArrayList.each { l ->
            List<BusinessOrder> subOrderList = ESList.<BusinessOrder> getESList()
                    .esClient(esClient)
                    .jsonConvert(jsonConvert)
                    .clazz(BusinessOrder.class)
                    .queryBuilder({
                        return search(source.searchData)
                                .byIdOrders(l.toArray(String[]::new))
                                .build()
                    })
                    .index(supplierService.getDateYearESIndex(source.supplierCode, ESKeys.ES_DELIVER_BUSINESS_ORDER_INDEX, 1))
                    .executeNonePage()
            readOrderOptions(subOrderList, source.supplierCode, source.options)
            if (!subOrderList.isEmpty()) {
                orderList.addAll(subOrderList)
            }
        }
        return RetResult.<List<BusinessOrder>> successT().result(orderList)
    }

    private RetResult<BusinessOrder> queryById(ProcessSearchOptionsItem<ReadOrderOption> source) {
        if (!ERPUtils.mapContainKey(source.searchData, ERPUtils.PARAM_SEARCH_ID)) {
            return RetResult.<BusinessOrder> errorT().retinfo("无效的id参数")
        }

        long idOrder = source.searchData.getLong(ERPUtils.PARAM_SEARCH_ID)

        BusinessOrder businessOrder = ESOne.<BusinessOrder> getESOneInfo()
                .esClient(esClient)
                .jsonConvert(jsonConvert)
                .clazz(BusinessOrder.class)
                .queryBuilder({
                    //获取完成的数据情况
                    ESConditionBuilder qb = search(null).byIdOrder(idOrder)
                    //这里还需要判断数据权限
                    if ((source.currentUser.userFrom == TokenUserFrom.APP_STORE_ADMIN.value) || (source.currentUser.userFrom == TokenUserFrom.PC_STORE_ADMIN.value)) {
                        //如果是客户自行导入的
                        qb = qb.byIdStore(source.currentUser.idBindOrg)
                    }
                    return qb.build()
                })
                .index(supplierService.getDateYearESIndex(source.supplierCode, ESKeys.ES_DELIVER_BUSINESS_ORDER_INDEX, 1))
                .execute()

        if (businessOrder == null) {
            return RetResult.<BusinessOrder> errorT().retinfo("无效的订单")
        }

        readOrderOptions(businessOrder, source.supplierCode, source.options)

        return RetResult.<BusinessOrder> successT().result(businessOrder)
    }

    private RetResult<BusinessOrder> queryByCode(ProcessSearchOptionsItem<ReadOrderOption> source) {
        if (!ERPUtils.mapContainKey(source.searchData, ERPUtils.PARAM_SEARCH_CODE)) {
            return RetResult.<BusinessOrder> errorT().retinfo("无效的id参数")
        }

        String orderCode = source.searchData.getString(ERPUtils.PARAM_SEARCH_CODE)

        BusinessOrder businessOrder = ESOne.<BusinessOrder> getESOneInfo()
                .esClient(esClient)
                .jsonConvert(jsonConvert)
                .clazz(BusinessOrder.class)
                .queryBuilder({
                    //获取完成的数据情况
                    return search(null).byOrderCode(orderCode).build()
                })
                .index(supplierService.getDateYearESIndex(source.supplierCode, ESKeys.ES_DELIVER_BUSINESS_ORDER_INDEX, 1))
                .execute()

        if (businessOrder == null) {
            return RetResult.<BusinessOrder> errorT().retinfo("无效的订单")
        }

        readOrderOptions(businessOrder, source.supplierCode, source.options)

        return RetResult.<BusinessOrder> successT().result(businessOrder)
    }

    @Override
    RetResult<BusinessOrder> execute(ProcessSearchOptionsItem<ReadOrderOption> source) {
        //可以参考一些都能运的代码，但那个硬编码需要多一些，这里直接判断搜索条件里面都有没有对应的条件

        if (ERPUtils.mapContainKey(source.searchData, ERPUtils.PARAM_SEARCH_ID)) {
            return queryById(source)
        } else if (ERPUtils.mapContainKey(source.searchData, ERPUtils.PARAM_SEARCH_CODE)) {
            return queryByCode(source)
        }

        return RetResult.<BusinessOrder> errorT().retinfo("无效的查询方式execute，查多数据应该使用executeList")
    }

    @Override
    RetResult<List<BusinessOrder>> executeList(ProcessSearchOptionsItem<ReadOrderOption> source) {

        if (ERPUtils.mapContainKey(source.searchData, ERPUtils.PARAM_SEARCH_IDS)) {
            return queryByIds(source)
        } else {
            return queryByConditions(source)
        }
    }

    //region 条件构造

    //groovy没法用java中类似SendOrderESConditionBuilder的静态方法构造内部类，强制编译不报错，运行还是报错无适配的构造函数，但用常规的类好使，估计是内部类有什么说法

    ESConditionBuilder search(RMap searchData) {
        return new ESConditionBuilder(searchData, QueryBuilders.boolQuery().must(QueryBuilders.typeQuery(ESKeys.ES_DELIVER_BUSINESS_ORDER_TYPE)))
    }

    ESConditionBuilder searchByItem(RMap searchData) {
        return new ESConditionBuilder(searchData, QueryBuilders.boolQuery().must(QueryBuilders.typeQuery(ESKeys.ES_DELIVER_ORDER_DETAIL_ITEM_TYPE)))
    }

    ESConditionBuilder searchByFinance(RMap searchData) {
        return new ESConditionBuilder(searchData, QueryBuilders.boolQuery().must(QueryBuilders.typeQuery(ESKeys.ES_DELIVER_ORDER_FINANCES_TYPE)))
    }

    //这里是做一个示例，表示通过查部件子表查询订单
    ESConditionBuilder searchByOrderRider(RMap searchData) {
        return new ESConditionBuilder(searchData, QueryBuilders.boolQuery().must(QueryBuilders.typeQuery(ESKeys.ES_DELIVER_ORDER_RIDER_ITEM_TYPE)))
    }

    //endregion

    class ESConditionBuilder {

        RMap searchData

        BoolQueryBuilder qb

        ESConditionBuilder() {
        }

        ESConditionBuilder(RMap searchData) {
            this.searchData = searchData
        }

        ESConditionBuilder(RMap searchData, BoolQueryBuilder qb) {
            this.searchData = searchData
            this.qb = qb
        }

        //上面没法用java类似的静态方法返回条件，运行期还是报错没有适配的构造函数

        //注意这里如果定义成闭包，不能用this做流式写法，参考https://groovy-lang.org/closures.html#closure-owner
        //但是用了owner，返回的类型是Object，还得做转换，所以这里直接用java的写法

        ESConditionBuilder byIdOrders(String[] idOrders) {
            if (idOrders.length > 0) {
                qb = qb.must(QueryBuilders.idsQuery(ESKeys.ES_DELIVER_BUSINESS_ORDER_TYPE).addIds(idOrders))
            }
            return this
        }

        ESConditionBuilder byIdOrders(List<Long> idOrders) {
            if (!idOrders.isEmpty()) {
                qb = qb.must(QueryBuilders.idsQuery(ESKeys.ES_DELIVER_BUSINESS_ORDER_TYPE).addIds(ERPUtils.longArrayToStrArray(ERPUtils.longListToArray(idOrders))))
            }
            return this
        }

        //子表查订单ids
        ESConditionBuilder byChildIdOrders(long[] idOrders) {
            qb = qb.must(QueryBuilders.termsQuery("idOrder", idOrders))
            return this
        }

        ESConditionBuilder byIdOrder(long idOrder) {
            //这里不要判断idOrder是否大于0，防止条件漏了
            qb = qb.must(QueryBuilders.idsQuery(ESKeys.ES_DELIVER_BUSINESS_ORDER_TYPE).addIds(String.valueOf(idOrder)))
            return this
        }

        ESConditionBuilder byIdPlatformIn() {
            if (ERPUtils.mapContainKey(searchData, "incomePlatformId")) {
                long idPlatformIn = searchData.getLong("incomePlatformId")
                if (idPlatformIn > 0L) {
                    qb = qb.must(QueryBuilders.termQuery("incomePlatformId", idPlatformIn))
                }
            }
            return this
        }

        ESConditionBuilder byIdPlatformOut() {
            if (ERPUtils.mapContainKey(searchData, "outGoingPlatformId")) {
                long idPlatformOut = searchData.getLong("outGoingPlatformId")
                if (idPlatformOut > 0L) {
                    qb = qb.must(QueryBuilders.termQuery("outGoingPlatformId", idPlatformOut))
                }
            }
            return this
        }

        ESConditionBuilder byKeyWord() {
            if (ERPUtils.mapContainKey(searchData, "keyWord")) {
                String keyWord = searchData.getString("keyWord")

                //下面的关系不要弄错了，一定是must里面在should，如果一直should不用must包起来，则导致搜索条件是全部或者的关系，主表搜索只会搜索有子表的记录，结果就是全部数据都会命中
                QueryBuilder qbDeliveryInfoKeyWord = QueryBuilders.boolQuery()
                        .must(QueryBuilders.typeQuery(ESKeys.ES_DELIVER_ORDER_DELIVERY_INFO_TYPE))
                        .must(QueryBuilders.boolQuery()
                                .should(QueryBuilders.matchQuery("deliverAddress", keyWord).analyzer("query_ansj").operator(Operator.AND))
                                .should(QueryBuilders.termQuery("deliverAddress.number", keyWord.toLowerCase()))
                                .should(QueryBuilders.matchQuery("deliverAddress.letter", keyWord.toLowerCase()).operator(Operator.AND))
                        )

                QueryBuilder qbKeyWord = QueryBuilders.boolQuery()
                        .should(QueryBuilders.termQuery("orderCode", keyWord.toLowerCase()))
                        .should(QueryBuilders.termQuery("incomePlatformOrderCode", keyWord.toLowerCase()))
                        .should(QueryBuilders.termQuery("outGoingPlatformOrderCode", keyWord.toLowerCase()))
                        .should(QueryBuilders.matchQuery("orderName", keyWord).operator(Operator.AND))
                        .should(QueryBuilders.matchQuery("storeName", keyWord).operator(Operator.AND))
                        .should(JoinQueryBuilders.hasChildQuery(ESKeys.ES_DELIVER_ORDER_DELIVERY_INFO_TYPE, qbDeliveryInfoKeyWord, ScoreMode.None))

                qb = qb.must(qbKeyWord)
            }
            return this
        }

        ESConditionBuilder byOrderStates() {
            if (ERPUtils.mapContainKey(searchData, "orderStates")) {
                String orderStates = searchData.getString("orderStates")
                qb = qb.must(QueryBuilders.termsQuery("orderState", orderStates.split(",")))
            }
            return this
        }

        ESConditionBuilder byOrderStates(String orderStates) {
            qb = qb.must(QueryBuilders.termsQuery("orderState", orderStates.split(",")))
            return this
        }

        ESConditionBuilder byOrderState(int orderState) {
            qb = qb.must(QueryBuilders.termQuery("orderState", orderState))
            return this
        }

        ESConditionBuilder byVoidFlagIn() {
            if (ERPUtils.mapContainKey(searchData, "voidFlagIn")) {
                int voidFlag = searchData.getInt("voidFlagIn")
                if (voidFlag >= 0) {
                    qb = qb.must(QueryBuilders.termQuery("voidFlagIn", voidFlag))
                }
            }
            return this
        }

        ESConditionBuilder byVoidFlagOut() {
            if (ERPUtils.mapContainKey(searchData, "voidFlagOut")) {
                int voidFlag = searchData.getInt("voidFlagOut")
                if (voidFlag >= 0) {
                    qb = qb.must(QueryBuilders.termQuery("voidFlagOut", voidFlag))
                }
            }
            return this
        }

        ESConditionBuilder byOrderCode() {
            if (ERPUtils.mapContainKey(searchData, "orderCode")) {
                String orderCode = searchData.getString("orderCode")
                qb = qb.must(QueryBuilders.termQuery("orderCode", orderCode.toLowerCase()))
            }
            return this
        }

        ESConditionBuilder byOrderCode(String orderCode) {
            qb = qb.must(QueryBuilders.termQuery("orderCode", orderCode.toLowerCase()))
            return this
        }

        ESConditionBuilder byBeginTime_Create() {
            if (ERPUtils.mapContainKey(searchData, "beginTime")) {
                String beginTimeStr = searchData.getString("beginTime")
                long beginTime
                if (beginTimeStr.contains("-")) {
                    beginTime = DateUtil.getStartOfDay(DateUtil.asDate(beginTimeStr, "yyyy-MM-dd")).getTime()
                } else {
                    beginTime = DateUtil.getStartOfDay(new Date(searchData.getLong("beginTime"))).getTime()
                }
                qb = qb.must(QueryBuilders.rangeQuery("createTimeLong").gte(beginTime))
            }
            return this
        }

        ESConditionBuilder byEndTime_Create() {
            if (ERPUtils.mapContainKey(searchData, "endTime")) {
                String endTimeStr = searchData.getString("endTime")
                long endTime
                if (endTimeStr.contains("-")) {
                    endTime = DateUtil.getEndOfDay(DateUtil.asDate(endTimeStr, "yyyy-MM-dd")).getTime()
                } else {
                    endTime = DateUtil.getEndOfDay(new Date(searchData.getLong("endTime"))).getTime()
                }
                qb = qb.must(QueryBuilders.rangeQuery("createTimeLong").lte(endTime))
            }
            return this
        }

        /**
         * 主表为order，查子表的查DeliverAddress
         * @return 查询构造器
         */
        ESConditionBuilder byDeliverAddress_QuerySlave() {
            if (ERPUtils.mapContainKey(searchData, "deliverAddress")) {
                String deliverAddress = searchData.getString("deliverAddress")
                BoolQueryBuilder qbDeliverAddress = QueryBuilders.boolQuery()
                        .should(QueryBuilders.matchQuery("deliverAddress", deliverAddress).analyzer("query_ansj").operator(Operator.AND))
                        .should(QueryBuilders.termQuery("deliverAddress.number", deliverAddress.toLowerCase()))
                        .should(QueryBuilders.matchQuery("deliverAddress.letter", deliverAddress.toLowerCase()).operator(Operator.AND))
                qb = qb.must(JoinQueryBuilders.hasChildQuery(ESKeys.ES_DELIVER_ORDER_DELIVERY_INFO_TYPE, qbDeliverAddress, ScoreMode.None))
            }
            return this
        }

        /**
         * 主表为order，查子表的查itemName
         * @return 查询构造器
         */
        ESConditionBuilder byItemName_QuerySlave() {
            if (ERPUtils.mapContainKey(searchData, "itemName")) {
                String itemName = searchData.getString("itemName")
                BoolQueryBuilder qbItemName = QueryBuilders.boolQuery()
                        .should(QueryBuilders.matchQuery("itemName", itemName).analyzer("query_ansj").operator(Operator.AND))
                        .should(QueryBuilders.termQuery("itemName.number", itemName.toLowerCase()))
                        .should(QueryBuilders.matchQuery("itemName.letter", itemName.toLowerCase()).operator(Operator.AND))
                qb = qb.must(JoinQueryBuilders.hasChildQuery(ESKeys.ES_DELIVER_ORDER_DETAIL_ITEM_TYPE, qbItemName, ScoreMode.None))
            }
            return this
        }

        ESConditionBuilder byIdStore() {
            if (ERPUtils.mapContainKey(searchData, "idStore")) {
                long idStore = searchData.getLong("idStore")
                if (idStore > 0)
                    qb = qb.must(QueryBuilders.termQuery("idStore", idStore))
            }
            return this
        }

        ESConditionBuilder byIdStore(long idStore) {
            qb = qb.must(QueryBuilders.termQuery("idStore", idStore))
            return this
        }

        ESConditionBuilder byOrderParentQuery(QueryBuilder qbParent) {
            qb = qb.must(JoinQueryBuilders.hasParentQuery(ESKeys.ES_DELIVER_BUSINESS_ORDER_TYPE, qbParent, false))
            return this
        }

        BoolQueryBuilder build() {
            return qb
        }
    }

}