How to use

DefaultSearchHandlerManager

in

com.atlassian.jira.issue.search.managers

@Override
public Collection<SearcherGroup> getSearcherGroups()
{
  return returnNullAsEmpty(getHelper().getSearcherGroups());
}

@Override
public Collection<SearcherGroup> getSearcherGroups(final SearchContext searchContext)
{
  return getSearcherGroups();
}

@Override
@Nonnull
public Collection<IssueSearcher<?>> getSearchersByClauseName(final ApplicationUser user, final String jqlClauseName, final SearchContext searchContext)
{
  return getSearchersByClauseName(user, jqlClauseName);
}

@Override
@Nonnull
public Collection<ClauseHandler> getClauseHandler(final String jqlClauseName)
{
  notBlank("jqlClauseName", jqlClauseName);
  return unmodifiableCollection(getHelper().getSearchHandler(jqlClauseName));
}

private void refreshWhenModuleChanged(ModuleDescriptor<?> module)
{
  // we listen to the EntityPropertyIndexDocumentModuleDescriptor to listen for plugins that
  // might be defining JQL aliases but have no custom field searchers
  if (module instanceof CustomFieldSearcherModuleDescriptor
      || module instanceof EntityPropertyIndexDocumentModuleDescriptor)
  {
    refresh();
  }
}

@SuppressWarnings ({ "UnusedDeclaration" })
@EventListener
public void onPluginModuleEnabled(final PluginModuleEnabledEvent event)
{
  // when a CustomFieldSearcher is enabled we need to flush the cache (i.e. the {@link Helper) ,
  // otherwise we will use the old delegate with stale {@link IssueSearcher}s. I guess we could
  // just flush the CustomFieldSearchers, but we'd need another delegate.
  final ModuleDescriptor<?> module = event.getModule();
  refreshWhenModuleChanged(module);
}

@Override
@Nonnull
public Collection<ClauseHandler> getClauseHandler(final ApplicationUser user, final String jqlClauseName)
{
  Collection<ClauseHandler> clauseHandler = queryCache.getClauseHandlers(user, jqlClauseName);
  if (clauseHandler == null)
  {
    List<ClauseHandler> filteredHandlers = new ArrayList<ClauseHandler>();
    Collection<ClauseHandler> unfilteredHandlers = getClauseHandler(jqlClauseName);
    for (ClauseHandler handler : unfilteredHandlers)
    {
      if (handler.getPermissionHandler().hasPermissionToUseClause(user))
      {
        filteredHandlers.add(handler);
      }
    }
    clauseHandler = unmodifiableCollection(filteredHandlers);
    queryCache.setClauseHandlers(user, jqlClauseName, clauseHandler);
  }
  return clauseHandler;
}

@Override
public Collection<IssueSearcher<?>> getSearchers(final ApplicationUser searcher, final SearchContext context)
{
  notNull("context", context);
  context.verify();
  return toList(filter(getAllSearchers(), new IsShown(searcher, context)));
}

@Override
@Nonnull
public Collection<String> getFieldIds(final String jqlClauseName)
{
  return transform(filter(getHelper().getSearchHandler(jqlClauseName), hasFieldId), getFieldId);
}

@SuppressWarnings ({ "UnusedDeclaration" })
@EventListener
public void onClearCache(final ClearCacheEvent event)
{
  refresh();
}

@SuppressWarnings ({ "UnusedDeclaration" })
@EventListener
public void onPluginModuleDisabled(final PluginModuleDisabledEvent event)
{
  // See {#onPluginModuleEnabled}
  final ModuleDescriptor<?> module = event.getModule();
  refreshWhenModuleChanged(module);
}

@Override
public Collection<IssueSearcher<?>> getAllSearchers()
{
  return returnNullAsEmpty(getHelper().getAllIssueSearchers());
}

@Override
@Nonnull
public Collection<String> getFieldIds(final ApplicationUser searcher, final String jqlClauseName)
{
  return transform(filter(getHelper().getSearchHandler(jqlClauseName), and(hasFieldId, new PermissionToUse(searcher))), getFieldId);
}

@Override
@Nonnull
public Collection<ClauseNames> getJqlClauseNames(final String fieldId)
{
  notBlank("fieldId", fieldId);
  return returnNullAsEmpty(getHelper().getJqlClauseNames(fieldId));
}

@Override
public IssueSearcher<?> getSearcher(final String id)
{
  notBlank("id", id);
  return getHelper().getIssueSearcher(id);
}

@Override
@Nonnull
public Collection<ClauseNames> getVisibleJqlClauseNames(final ApplicationUser searcher)
{
  return transformSet(filter(getHelper().getSearchHandlers(), new PermissionToUse(searcher)), getClauseNames);
}

@Override
@Nonnull
public Collection<IssueSearcher<?>> getSearchersByClauseName(final ApplicationUser user, final String jqlClauseName)
{
  notBlank("jqlClauseName", jqlClauseName);
  return toList(filter(transform(getHelper().getIssueSearcherRegistrationsByClauseName(jqlClauseName),
      new Function<SearcherRegistration, IssueSearcher<?>>()
      {
        @Override
        public IssueSearcher<?> get(final SearcherRegistration searcherRegistration)
        {
          return searcherRegistration.getIssueSearcher();
        }
      }), Predicates.<IssueSearcher<?>>notNull()));
}

@Override
@Nonnull
public Collection<ClauseHandler> getVisibleClauseHandlers(final ApplicationUser searcher)
{
  Set<ClauseHandler> visibleClauseHandlers = new HashSet<ClauseHandler>();
  final Collection<ClauseHandler> clauseHandlers = getHelper().getSearchHandlers();
  Set<FieldLayout> fieldLayouts = fieldManager.getVisibleFieldLayouts(searcher);
  for (ClauseHandler clauseHandler : clauseHandlers)
  {
    if (clauseHandler.getPermissionHandler().hasPermissionToUseClause(searcher, fieldLayouts))
    {
      visibleClauseHandlers.add(clauseHandler);
    }
  }
  return visibleClauseHandlers;
}