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)