How to use

getClauseHandler

method

in

com.atlassian.jira.issue.search.managers.SearchHandlerManager

  private Collection<ClauseHandler> getHandlersForClauseName(final QueryCreationContext queryCreationContext, final String primaryClauseName)
  {
    if (queryCreationContext.isSecurityOverriden())
    {
      return searchHandlerManager.getClauseHandler(primaryClauseName);
    }
    else
    {
      return searchHandlerManager.getClauseHandler(queryCreationContext.getApplicationUser(), primaryClauseName);
    }
  }
}

  private ClauseValuesGenerator getClauseValuesGeneratorForField(final String fieldName)
  {
    final ApplicationUser searcher = authenticationContext.getUser();
    final Collection<ClauseHandler> clauseHandlers = searchHandlerManager.getClauseHandler(searcher, fieldName);
    if (clauseHandlers != null && clauseHandlers.size() == 1)
    {
      ClauseHandler clauseHandler = clauseHandlers.iterator().next();

      if (clauseHandler instanceof ValueGeneratingClauseHandler)
      {
        return ((ValueGeneratingClauseHandler) clauseHandler).getClauseValuesGenerator();
      }
    }
    return null;
  }
}

  public String getUniqueClauseName(final ApplicationUser user, final String primaryName, final String fieldName)
  {
    // we must check that the name of the field is not something that would cause it to not be registered in the
    // SearchHandlerManager, for this would mean that the name is potentially not unique
    if (!SystemSearchConstants.isSystemName(fieldName))
    {
      if (!JqlCustomFieldId.isJqlCustomFieldId(fieldName))
      {
        if (searchHandlerManager.getClauseHandler(user, fieldName).size() == 1)
        {
          return fieldName;
        }
      }
    }
    return primaryName;
  }
}

public Collection<ClauseValidator> getClauseValidator(final ApplicationUser searcher, final TerminalClause clause)
{
  notNull("clause", clause);
  Collection<ClauseHandler> clauseHandlers = manager.getClauseHandler(searcher, clause.getName());
  // Collect the factories.
  // JRA-23141 : We avoid using a lazy transformed collection here because it gets accessed multiple times
  // and size() in particular is slow.
  List<ClauseValidator> clauseValidators = new ArrayList<ClauseValidator>(clauseHandlers.size());
  for (ClauseHandler clauseHandler : clauseHandlers)
  {
    clauseValidators.add(clauseHandler.getValidator());
  }
  return clauseValidators;
}

public Iterable<Result> getAutoCompleteResultsForField(final String fieldName, final String fieldValue)
{
  checkNotNull(fieldName);
  checkNotNull(fieldValue);
  final ApplicationUser searcher = getSearcher();
  final Collection<ClauseHandler> clauseHandlers = searchHandlerManager.getClauseHandler(searcher, fieldName);
  if (clauseHandlers.size() == 1)
  {
    ClauseHandler clauseHandler = clauseHandlers.iterator().next();
    if (clauseHandler instanceof ValueGeneratingClauseHandler)
    {
      final ClauseValuesGenerator clauseValuesGenerator =  ((ValueGeneratingClauseHandler) (clauseHandler))
          .getClauseValuesGenerator();
      return generateResults(clauseValuesGenerator, searcher, fieldName, fieldValue);
    }
  }
  return ImmutableList.of();
}

private boolean stringValueExists(PossibleValuesHolder possibleValuesHolder, ApplicationUser searcher, String fieldName, String rawValue)
  final Collection<ClauseHandler> clauseHandlers = searchHandlerManager.getClauseHandler(searcher, fieldName);
  if (clauseHandlers != null && clauseHandlers.size() == 1)

public Clause visit(TerminalClause clause)
{
  // if we don't get any handlers back, this means the user does not have permission to use the clause, so just
  // return the input
  final Collection<ClauseHandler> handlers = searchHandlerManager.getClauseHandler(user, clause.getName());
  if (handlers.isEmpty())
  {
    return clause;
  }
  // first, we want to sanitise all operands with the DefaultOperandSanitisingVisitor, as it uses a strategy that
  // should be applied across all fields
  clause = sanitiseOperands(clause);
  // we only care about unique sanitised clauses, so use a set
  final Set<Clause> newClauses = new LinkedHashSet<Clause>();
  for (ClauseHandler clauseHandler : handlers)
  {
    newClauses.add(clauseHandler.getPermissionHandler().sanitise(user, clause));
  }
  return newClauses.size() == 1 ? newClauses.iterator().next() : new OrClause(newClauses);
}

  public Collection<ClauseQueryFactory> getClauseQueryFactory(final QueryCreationContext queryCreationContext, final TerminalClause clause)
  {
    notNull("clause", clause);
    final Collection<ClauseHandler> handlers;
    if (!queryCreationContext.isSecurityOverriden())
    {
      handlers = manager.getClauseHandler(queryCreationContext.getApplicationUser(), clause.getName());
    }
    else
    {
      handlers = manager.getClauseHandler(clause.getName());
    }
    // Collect the factories.
    // JRA-23141 : We avoid using a lazy transformed collection here because it gets accessed multiple times
    // and size() in particular is slow.
    final List<ClauseQueryFactory> clauseQueryFactories = new ArrayList<ClauseQueryFactory>(handlers.size());
    for (ClauseHandler clauseHandler : handlers)
    {
      clauseQueryFactories.add(clauseHandler.getFactory());
    }
    return clauseQueryFactories;
  }
}

final Collection<ClauseHandler> handlers = searchHandlerManager.getClauseHandler(user, sort.getField());

final Collection<ClauseHandler> handlers = searchHandlerManager.getClauseHandler(user, customField.getClauseNames().getPrimaryName());
for (ClauseHandler handler : handlers)

for (SearchSort newSort : newSorts)
  final Collection<ClauseHandler> newHandlers = searchHandlerManager.getClauseHandler(user, newSort.getField());
  if (newHandlers.size() != 1)
  for (SearchSort oldSort : oldSorts)
    final Collection<ClauseHandler> oldHandlers = searchHandlerManager.getClauseHandler(user, oldSort.getField());
    if (oldHandlers.size() == 1)

final Collection<ClauseHandler> handlers = searchHandlerManager.getClauseHandler(searcher, clauseName);
final Set<ClauseContext> fullClauseContexts = new HashSet<ClauseContext>();
final Set<ClauseContext> simpleClauseContexts = new HashSet<ClauseContext>();

List<ClauseContextFactory> getAllSystemFieldFactories(final ApplicationUser searcher)
{
  final List<String> systemFieldClauseNames = CollectionBuilder.newBuilder(
      SystemSearchConstants.forComments().getJqlClauseNames().getPrimaryName(),
      SystemSearchConstants.forDescription().getJqlClauseNames().getPrimaryName(),
      SystemSearchConstants.forEnvironment().getJqlClauseNames().getPrimaryName(),
      SystemSearchConstants.forSummary().getJqlClauseNames().getPrimaryName()
  ).asList();
  final List<ClauseContextFactory> factories = Lists.newArrayListWithCapacity(systemFieldClauseNames.size());
  for (String clauseName : systemFieldClauseNames)
  {
    final Collection<ClauseHandler> handlers = searchHandlerManager.getClauseHandler(searcher, clauseName);
    for (ClauseHandler handler : handlers)
    {
      factories.add(handler.getClauseContextFactory());
    }
  }
  return factories;
}

Collection<ClauseHandler> clauseHandler = searchHandlerManager.getClauseHandler(searchSort.getField());
clauseHandler.stream()
    .filter((handler) -> handler.getInformation() instanceof AliasClauseInformation)