How to use org.elasticsearch.index.query

public static ToXContent fullParamer(MatchPhraseQueryBuilder query, Paramer paramer) {
  if (paramer.analysis != null) {
    query.analyzer(paramer.analysis);
  }
  if (paramer.boost != null) {
    query.boost(paramer.boost);
  }
  if (paramer.slop != null) {
    query.slop(paramer.slop);
  }
  return query;
}

  public static ToXContent fullParamer(SpanNearQueryBuilder query, Paramer paramer) {
    if (paramer.boost != null) {
      query.boost(paramer.boost);
    }

    if (paramer.inOrder != null) {
      query.inOrder(paramer.inOrder);
    }

    return query;
  }
}

public static ToXContent fullParamer(WildcardQueryBuilder query, Paramer paramer) {
  if (paramer.boost != null) {
    query.boost(paramer.boost);
  }
  return query;
}

private static void addCreatedAfterByProjectsFilter(Map<String, QueryBuilder> filters, IssueQuery query) {
 Map<String, PeriodStart> createdAfterByProjectUuids = query.createdAfterByProjectUuids();
 BoolQueryBuilder boolQueryBuilder = boolQuery();
 createdAfterByProjectUuids.forEach((projectUuid, createdAfterDate) -> boolQueryBuilder.should(boolQuery()
  .filter(termQuery(FIELD_ISSUE_PROJECT_UUID, projectUuid))
  .filter(rangeQuery(FIELD_ISSUE_FUNC_CREATED_AT).from(BaseDoc.dateToEpochSeconds(createdAfterDate.date()), createdAfterDate.inclusive()))));
 filters.put("createdAfterByProjectUuids", boolQueryBuilder);
}

private static BoolQueryBuilder addTermFilter(BoolQueryBuilder filter, String field, @Nullable Collection<String> values) {
 if (isNotEmpty(values)) {
  BoolQueryBuilder valuesFilter = boolQuery();
  for (String value : values) {
   QueryBuilder valueFilter = QueryBuilders.termQuery(field, value);
   valuesFilter.should(valueFilter);
  }
  filter.must(valuesFilter);
 }
 return filter;
}

/**
 * Generate the field name term for the field name  for queries
 */
private NestedQueryBuilder fieldNameTerm( final String fieldName, final QueryBuilder fieldValueQuery ) {
  final BoolQueryBuilder booleanQuery = QueryBuilders.boolQuery();
  booleanQuery.must( QueryBuilders.termQuery(IndexingUtils.FIELD_NAME_NESTED, fieldName) );
  booleanQuery.must( fieldValueQuery );
  return QueryBuilders.nestedQuery(IndexingUtils.ENTITY_FIELDS, booleanQuery);
}

private static AbstractAggregationBuilder createNoDataFacet(String metricKey) {
 return AggregationBuilders.filter(
  "no_data_" + metricKey,
  boolQuery().mustNot(nestedQuery(FIELD_MEASURES, termQuery(FIELD_MEASURES_KEY, metricKey), ScoreMode.Avg)));
}

private static BoolQueryBuilder addTermFilter(BoolQueryBuilder filter, String field, @Nullable String value) {
 if (StringUtils.isNotEmpty(value)) {
  filter.must(QueryBuilders.termQuery(field, value));
 }
 return filter;
}

private BoolQueryBuilder createBoolFilter(IssueQuery query) {
 BoolQueryBuilder boolQuery = boolQuery();
 for (QueryBuilder filter : createFilters(query).values()) {
  if (filter != null) {
   boolQuery.must(filter);
  }
 }
 return boolQuery;
}

private ToXContent fixNot(Condition cond, ToXContent bqb) {
  if (NOT_OPEAR_SET.contains(cond.getOpear())) {
      bqb = QueryBuilders.boolQuery().mustNot((QueryBuilder) bqb);
  }
  return bqb;
}

@Nullable
public static QueryBuilder getTimestampRangeFilter(TimeRange range) {
  if (range == null) {
    return null;
  }
  return QueryBuilders.rangeQuery(Message.FIELD_TIMESTAMP)
      .gte(Tools.buildElasticSearchTimeFormat(range.getFrom()))
      .lte(Tools.buildElasticSearchTimeFormat(range.getTo()));
}

 @Override
 QueryBuilder getQuery(String queryText) {
  return matchQuery(SORTABLE_ANALYZER.subField(FIELD_KEY), queryText)
   .boost(50f);
 }
};

 @Override
 QueryBuilder getQuery(String queryText) {
  BoolQueryBuilder queryBuilder = boolQuery();
  split(queryText)
   .map(text -> partialTermQuery(text, FIELD_NAME))
   .forEach(queryBuilder::must);
  return queryBuilder
   .boost(0.5f);
 }
},

public static ToXContent fullParamer(MatchQueryBuilder query, Paramer paramer) {
  if (paramer.analysis != null) {
    query.analyzer(paramer.analysis);
  }
  if (paramer.boost != null) {
    query.boost(paramer.boost);
  }
  if (paramer.operator != null) {
    query.operator(paramer.operator);
  }
  if (paramer.minimumShouldMatch != null) {
    query.minimumShouldMatch(paramer.minimumShouldMatch);
  }
  return query;
}

/**
 * Generate the field name term for the field name for filters
 */
private NestedFilterBuilder fieldNameTerm( final String fieldName, final FilterBuilder fieldValueBuilder ) {
  final BoolFilterBuilder booleanQuery = FilterBuilders.boolFilter();
  booleanQuery.must( FilterBuilders.termFilter( IndexingUtils.FIELD_NAME_NESTED, fieldName ) );
  booleanQuery.must( fieldValueBuilder );
  return FilterBuilders.nestedFilter( IndexingUtils.ENTITY_FIELDS, booleanQuery );
}

private static QueryBuilder termQuery(String field, String query, float boost) {
 return QueryBuilders.multiMatchQuery(query,
  field, SEARCH_WORDS_ANALYZER.subField(field))
  .operator(Operator.AND)
  .boost(boost);
}

/**
 * Create a term filter for our sorts
 */
public static TermFilterBuilder sortPropertyTermFilter( final String propertyName ) {
  return FilterBuilders.termFilter( IndexingUtils.FIELD_NAME, propertyName );
}

 @Override
 QueryBuilder getQuery(String queryText) {
  return matchQuery(SORTABLE_ANALYZER.subField(FIELD_NAME), queryText)
   .boost(2.5f);
 }
},

 @Override
 public QueryBuilder getQuery(ComponentTextSearchQuery query) {
  return matchQuery(SORTABLE_ANALYZER.subField(query.getFieldName()), query.getQueryText())
   .boost(2.5f);
 }
},

 @Override
 public QueryBuilder getQuery(ComponentTextSearchQuery query) {
  return matchQuery(SORTABLE_ANALYZER.subField(query.getFieldKey()), query.getQueryText())
   .boost(50f);
 }
},