private Collection<ClauseHandler> getHandlersForClauseName(final QueryCreationContext queryCreationContext, final String primaryClauseName) { if (queryCreationContext.isSecurityOverriden()) { return searchHandlerManager.getClauseHandler(primaryClauseName); } else { return searchHandlerManager.getClauseHandler(queryCreationContext.getApplicationUser(), primaryClauseName); } } }
public boolean isAliasForField(final ApplicationUser user, final String jqlName) { final SearchHandlerManager searchHandlerManager = ComponentAccessor.getComponentOfType(SearchHandlerManager.class); final Collection<String> fieldIds = searchHandlerManager.getFieldIds(user, jqlName); return fieldIds.contains(navigableField.getId()); }
@Override public IssueSearcher<?> getSearcher(final String id) { return manager.getSearcher(id); }
final Collection<ClauseNames> matchingClauseNames = searchHandlerManager.getJqlClauseNames(field);
final List<String> fieldIds = new ArrayList<String>(searchHandlerManager.getFieldIds(searcher, searchSort.getField())); Collection<ClauseHandler> clauseHandler = searchHandlerManager.getClauseHandler(searchSort.getField()); clauseHandler.stream() .filter((handler) -> handler.getInformation() instanceof AliasClauseInformation)
@Override public Collection<IssueSearcher<?>> getAllSearchers() { return manager.getAllSearchers(); }
@Override public Collection<SearcherGroup> getSearcherGroups() { return manager.getSearcherGroups(); }
@Override public Collection<IssueSearcher<?>> getSearchers(final ApplicationUser searcher, final SearchContext context) { return manager.getSearchers(searcher, context); }
final Collection<ClauseNames> clauseNames = searchHandlerManager.getJqlClauseNames(fieldName); String sortName = fieldName; if (!clauseNames.isEmpty())
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; } }
bean.searchable = field instanceof SearchableField; final Collection<ClauseNames> jqlClauseNames = searchHandlerManager.getJqlClauseNames(field.getId()); bean.clauseNames = new LinkedHashSet<String>(); for (ClauseNames names : jqlClauseNames)
/** * @param overrideSecurity false if only fields which the user can see should be resolved * @param searcher the user performing the search * @param clauseName the clause name used * @return the set of {@link com.atlassian.jira.issue.fields.CustomField}s which map to the clause name and are also * of the type {@link com.atlassian.jira.issue.customfields.impl.CascadingSelectCFType}; never null. */ private Set<CustomField> resolveField(final boolean overrideSecurity, final ApplicationUser searcher, final String clauseName) { final Set<CustomField> fields = new HashSet<CustomField>(); final Collection<String> fieldIds = overrideSecurity ? searchHandlerManager.getFieldIds(clauseName) : searchHandlerManager.getFieldIds(searcher, clauseName); for (String fieldId : fieldIds) { final CustomField field = customFieldManager.getCustomFieldObject(fieldId); if (field != null && field.getCustomFieldType() instanceof CascadingSelectCFType) { fields.add(field); } else { log.info(String.format("jql clause name %s does not resolve to a cascading select field", clauseName)); } } return fields; }
final IssueSearcher projectSearcher = searchHandlerManager.getSearcher(IssueFieldConstants.PROJECT); final ProjectSearchInputTransformer searchInputTransformer = (ProjectSearchInputTransformer) projectSearcher.getSearchInputTransformer(); final Set<String> projectIds = searchInputTransformer.getIdValuesAsStrings(user, query);
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; }
bean.searchable = field instanceof SearchableField; final Collection<ClauseNames> jqlClauseNames = searchHandlerManager.getJqlClauseNames(field.getId()); bean.clauseNames = new LinkedHashSet<String>(); for (ClauseNames names : jqlClauseNames)
final Collection<String> fieldIds = searchHandlerManager.getFieldIds(searcher, jqlClauseName); if (!fieldIds.isEmpty())
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(); }
public Results getPossibleValues(final ApplicationUser user, final String jqlClauseName, final String valuePrefix, final int maxNumResults) { final ApplicationUser searcher = user; final Set<String> suggestions = new TreeSet<String>(); final Collection<String> fieldIds = getSearchHandlerManager().getFieldIds(searcher, jqlClauseName); for (String fieldId : fieldIds) { if(fieldId.equals(SystemSearchConstants.forLabels().getFieldId())) { suggestions.addAll(labelManager.getSuggestedLabels(searcher, null, valuePrefix)); } else { suggestions.addAll(labelManager.getSuggestedLabels(searcher, null, CustomFieldUtils.getCustomFieldId(fieldId), valuePrefix)); } } final List<Result> results = Lists.newArrayListWithCapacity(suggestions.size()); for (String suggestion : suggestions) { if(results.size() == maxNumResults) { break; } results.add(new Result(suggestion)); } return new Results(results); }
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; } }
final List<String> fieldIds = new ArrayList<String>(searchHandlerManager.getFieldIds(searcher, sortClauseName));