Examples with IllegalQueryParameterException com.b2international.commons.exceptions.IllegalQueryParameterException used on opensource projects

Example 1 with IllegalQueryParameterException

use of com.b2international.commons.exceptions.IllegalQueryParameterException in project snow-owl by b2ihealthcare.

the class RepositoryRequest method execute.

@Override
public B execute(final ServiceProvider context) {
    Repository repository = context.service(RepositoryManager.class).get(repositoryId);
    if (repository == null) {
        throw new IllegalArgumentException(String.format("Unknown repositoryId '%s'", repositoryId));
    }
    DefaultRepositoryContext repositoryContext = new DefaultRepositoryContext(context, repository.status());
    // by default add a NullProgressMonitor binding to the context
    // if the previous context is a delegate context, injecting all services can override this safely
    repositoryContext.bind(IProgressMonitor.class, new NullProgressMonitor());
    repositoryContext.bindAll(repository);
    // always "open" an index read context when executing requests inside a repository
    return repository.service(Index.class).read(index -> {
        try {
            repositoryContext.bind(Searcher.class, index);
            return next(repositoryContext);
        } catch (QueryParseException e) {
            throw new IllegalQueryParameterException(e.getMessage());
        }
    });
}

Example 2 with IllegalQueryParameterException

use of com.b2international.commons.exceptions.IllegalQueryParameterException in project snow-owl by b2ihealthcare.

the class RevisionIndexReadRequest method execute.

@Override
public B execute(final BranchContext context) {
    final String branchPath = context.path();
    RevisionIndex index = context.service(RevisionIndex.class);
    if (snapshot) {
        return index.read(branchPath, searcher -> {
            try {
                return next(context.inject().bind(RevisionSearcher.class, searcher).build());
            } catch (QueryParseException e) {
                throw new IllegalQueryParameterException(e.getMessage());
            }
        });
    } else {
        return next(context.inject().bind(RevisionSearcher.class, new RevisionSearcher() {

            @Override
            public <T> Aggregation<T> aggregate(AggregationBuilder<T> aggregation) throws IOException {
                return index.read(branchPath, searcher -> searcher.aggregate(aggregation));
            }

            @Override
            public Searcher searcher() {
                return index.read(branchPath, searcher -> searcher.searcher());
            }

            @Override
            public <T> Hits<T> search(Query<T> query) throws IOException {
                return index.read(branchPath, searcher -> searcher.search(query));
            }

            @Override
            public <T> Iterable<T> get(Class<T> type, Iterable<String> keys) throws IOException {
                return index.read(branchPath, searcher -> searcher.get(type, keys));
            }

            @Override
            public <T> T get(Class<T> type, String key) throws IOException {
                return index.read(branchPath, searcher -> searcher.get(type, key));
            }

            @Override
            public String branch() {
                return branchPath;
            }
        }).build());
    }
}

Example 3 with IllegalQueryParameterException

use of com.b2international.commons.exceptions.IllegalQueryParameterException in project snow-owl by b2ihealthcare.

the class SnomedRefSetMemberSearchRequest method prepareQuery.

@Override
protected Expression prepareQuery(BranchContext context) {
    final Collection<String> referencedComponentIds = getCollection(OptionKey.REFERENCED_COMPONENT, String.class);
    final Collection<SnomedRefSetType> refSetTypes = getCollection(OptionKey.REFSET_TYPE, SnomedRefSetType.class);
    final Options propsFilter = getOptions(OptionKey.PROPS);
    ExpressionBuilder queryBuilder = Expressions.builder();
    addActiveClause(queryBuilder);
    addReleasedClause(queryBuilder);
    addEclFilter(context, queryBuilder, SnomedSearchRequest.OptionKey.MODULE, SnomedDocument.Expressions::modules);
    addIdFilter(queryBuilder, RevisionDocument.Expressions::ids);
    addEffectiveTimeClause(queryBuilder);
    addEclFilter(context, queryBuilder, OptionKey.REFSET, SnomedRefSetMemberIndexEntry.Expressions::refsetIds);
    addComponentClause(queryBuilder);
    if (containsKey(OptionKey.REFERENCED_COMPONENT_TYPE)) {
        queryBuilder.filter(referencedComponentTypes(getCollection(OptionKey.REFERENCED_COMPONENT_TYPE, String.class)));
    }
    if (!referencedComponentIds.isEmpty()) {
        queryBuilder.filter(referencedComponentIds(referencedComponentIds));
    }
    if (!refSetTypes.isEmpty()) {
        queryBuilder.filter(refSetTypes(refSetTypes));
    }
    if (!propsFilter.isEmpty()) {
        final Set<String> propKeys = newHashSet(propsFilter.keySet());
        if (propKeys.remove(SnomedRf2Headers.FIELD_ACCEPTABILITY_ID)) {
            queryBuilder.filter(acceptabilityIds(propsFilter.getCollection(SnomedRf2Headers.FIELD_ACCEPTABILITY_ID, String.class)));
        }
        if (propKeys.remove(SnomedRf2Headers.FIELD_RELATIONSHIP_GROUP)) {
            final String operatorKey = SearchResourceRequest.operator(SnomedRf2Headers.FIELD_RELATIONSHIP_GROUP);
            SearchResourceRequest.Operator op;
            if (propKeys.remove(operatorKey)) {
                op = propsFilter.get(operatorKey, Operator.class);
            } else {
                op = SearchResourceRequest.Operator.EQUALS;
            }
            switch(op) {
                case EQUALS:
                    queryBuilder.filter(relationshipGroup(propsFilter.get(SnomedRf2Headers.FIELD_RELATIONSHIP_GROUP, Integer.class)));
                    break;
                case NOT_EQUALS:
                    queryBuilder.mustNot(relationshipGroup(propsFilter.get(SnomedRf2Headers.FIELD_RELATIONSHIP_GROUP, Integer.class)));
                    break;
                default:
                    throw new NotImplementedException("Unsupported relationship group operator %s", op);
            }
        }
        if (propKeys.remove(SnomedRf2Headers.FIELD_CHARACTERISTIC_TYPE_ID)) {
            addEclFilter(context, queryBuilder, propsFilter.getCollection(SnomedRf2Headers.FIELD_CHARACTERISTIC_TYPE_ID, String.class), SnomedRefSetMemberIndexEntry.Expressions::characteristicTypeIds);
        }
        if (propKeys.remove(SnomedRf2Headers.FIELD_CORRELATION_ID)) {
            addEclFilter(context, queryBuilder, propsFilter.getCollection(SnomedRf2Headers.FIELD_CORRELATION_ID, String.class), SnomedRefSetMemberIndexEntry.Expressions::correlationIds);
        }
        if (propKeys.remove(SnomedRf2Headers.FIELD_DESCRIPTION_FORMAT)) {
            addEclFilter(context, queryBuilder, propsFilter.getCollection(SnomedRf2Headers.FIELD_DESCRIPTION_FORMAT, String.class), SnomedRefSetMemberIndexEntry.Expressions::descriptionFormats);
        }
        if (propKeys.remove(SnomedRf2Headers.FIELD_MAP_CATEGORY_ID)) {
            addEclFilter(context, queryBuilder, propsFilter.getCollection(SnomedRf2Headers.FIELD_MAP_CATEGORY_ID, String.class), SnomedRefSetMemberIndexEntry.Expressions::mapCategoryIds);
        }
        if (propKeys.remove(SnomedRf2Headers.FIELD_TARGET_COMPONENT_ID)) {
            addEclFilter(context, queryBuilder, propsFilter.getCollection(SnomedRf2Headers.FIELD_TARGET_COMPONENT_ID, String.class), SnomedRefSetMemberIndexEntry.Expressions::targetComponentIds);
        }
        if (propKeys.remove(SnomedRf2Headers.FIELD_MAP_TARGET)) {
            queryBuilder.filter(mapTargets(propsFilter.getCollection(SnomedRf2Headers.FIELD_MAP_TARGET, String.class)));
        }
        if (propKeys.remove(SnomedRf2Headers.FIELD_MAP_TARGET_DESCRIPTION)) {
            queryBuilder.filter(mapTargetDescriptions(propsFilter.getCollection(SnomedRf2Headers.FIELD_MAP_TARGET_DESCRIPTION, String.class)));
        }
        if (propKeys.remove(SnomedRf2Headers.FIELD_MAP_GROUP)) {
            queryBuilder.filter(mapGroups(propsFilter.getCollection(SnomedRf2Headers.FIELD_MAP_GROUP, Integer.class)));
        }
        if (propKeys.remove(SnomedRf2Headers.FIELD_MAP_PRIORITY)) {
            queryBuilder.filter(mapPriority(propsFilter.getCollection(SnomedRf2Headers.FIELD_MAP_PRIORITY, Integer.class)));
        }
        if (propKeys.remove(SnomedRf2Headers.FIELD_MAP_BLOCK)) {
            queryBuilder.filter(mapBlock(propsFilter.getCollection(SnomedRf2Headers.FIELD_MAP_BLOCK, Integer.class)));
        }
        if (propKeys.remove(SnomedRf2Headers.FIELD_VALUE_ID)) {
            addEclFilter(context, queryBuilder, propsFilter.getCollection(SnomedRf2Headers.FIELD_VALUE_ID, String.class), SnomedRefSetMemberIndexEntry.Expressions::valueIds);
        }
        if (propKeys.remove(SnomedRf2Headers.FIELD_TYPE_ID)) {
            addEclFilter(context, queryBuilder, propsFilter.getCollection(SnomedRf2Headers.FIELD_TYPE_ID, String.class), SnomedRefSetMemberIndexEntry.Expressions::typeIds);
        }
        if (propKeys.remove(SnomedRf2Headers.FIELD_MRCM_DOMAIN_ID)) {
            addEclFilter(context, queryBuilder, propsFilter.getCollection(SnomedRf2Headers.FIELD_MRCM_DOMAIN_ID, String.class), SnomedRefSetMemberIndexEntry.Expressions::domainIds);
        }
        if (propKeys.remove(SnomedRf2Headers.FIELD_MRCM_CONTENT_TYPE_ID)) {
            addEclFilter(context, queryBuilder, propsFilter.getCollection(SnomedRf2Headers.FIELD_MRCM_CONTENT_TYPE_ID, String.class), SnomedRefSetMemberIndexEntry.Expressions::contentTypeIds);
        }
        if (propKeys.remove(SnomedRf2Headers.FIELD_MRCM_RULE_STRENGTH_ID)) {
            addEclFilter(context, queryBuilder, propsFilter.getCollection(SnomedRf2Headers.FIELD_MRCM_RULE_STRENGTH_ID, String.class), SnomedRefSetMemberIndexEntry.Expressions::ruleStrengthIds);
        }
        if (propKeys.remove(SnomedRf2Headers.FIELD_MRCM_RULE_REFSET_ID)) {
            addEclFilter(context, queryBuilder, propsFilter.getCollection(SnomedRf2Headers.FIELD_MRCM_RULE_REFSET_ID, String.class), SnomedRefSetMemberIndexEntry.Expressions::ruleRefSetIds);
        }
        if (propKeys.remove(SnomedRf2Headers.FIELD_MRCM_GROUPED)) {
            queryBuilder.filter(grouped(propsFilter.getBoolean(SnomedRf2Headers.FIELD_MRCM_GROUPED)));
        }
        if (propKeys.remove(SnomedRf2Headers.FIELD_MRCM_RANGE_CONSTRAINT)) {
            queryBuilder.filter(rangeConstraint(propsFilter.getString(SnomedRf2Headers.FIELD_MRCM_RANGE_CONSTRAINT)));
        }
        if (propKeys.remove(SnomedRf2Headers.FIELD_OWL_EXPRESSION)) {
            queryBuilder.filter(Expressions.exactMatch(SnomedRf2Headers.FIELD_OWL_EXPRESSION, propsFilter.getString(SnomedRf2Headers.FIELD_OWL_EXPRESSION)));
        }
        if (propKeys.remove(SnomedRefSetMemberSearchRequestBuilder.OWL_EXPRESSION_CONCEPTID)) {
            addEclFilter(context, queryBuilder, propsFilter.getCollection(SnomedRefSetMemberSearchRequestBuilder.OWL_EXPRESSION_CONCEPTID, String.class), SnomedRefSetMemberIndexEntry.Expressions::owlExpressionConcept);
        }
        if (propKeys.remove(SnomedRefSetMemberSearchRequestBuilder.OWL_EXPRESSION_DESTINATIONID)) {
            addEclFilter(context, queryBuilder, propsFilter.getCollection(SnomedRefSetMemberSearchRequestBuilder.OWL_EXPRESSION_DESTINATIONID, String.class), SnomedRefSetMemberIndexEntry.Expressions::owlExpressionDestination);
        }
        if (propKeys.remove(SnomedRefSetMemberSearchRequestBuilder.OWL_EXPRESSION_TYPEID)) {
            addEclFilter(context, queryBuilder, propsFilter.getCollection(SnomedRefSetMemberSearchRequestBuilder.OWL_EXPRESSION_TYPEID, String.class), SnomedRefSetMemberIndexEntry.Expressions::owlExpressionType);
        }
        if (propKeys.remove(SnomedRefSetMemberSearchRequestBuilder.OWL_EXPRESSION_GCI)) {
            queryBuilder.filter(gciAxiom(propsFilter.getBoolean(SnomedRefSetMemberSearchRequestBuilder.OWL_EXPRESSION_GCI)));
        }
        final Collection<DataType> dataTypes = propsFilter.getCollection(SnomedRefSetMemberIndexEntry.Fields.DATA_TYPE, DataType.class);
        if (propKeys.remove(SnomedRefSetMemberIndexEntry.Fields.DATA_TYPE)) {
            queryBuilder.filter(dataTypes(dataTypes));
        }
        if (propKeys.remove(SnomedRf2Headers.FIELD_VALUE)) {
            if (dataTypes.size() != 1) {
                throw new BadRequestException("DataType filter must be specified if filtering by value");
            }
            final DataType dataType = Iterables.getOnlyElement(dataTypes);
            final String operatorKey = SearchResourceRequest.operator(SnomedRf2Headers.FIELD_VALUE);
            SearchResourceRequest.Operator op;
            if (propKeys.remove(operatorKey)) {
                op = propsFilter.get(operatorKey, Operator.class);
            } else {
                op = SearchResourceRequest.Operator.EQUALS;
            }
            final Collection<Object> attributeValues = propsFilter.getCollection(SnomedRf2Headers.FIELD_VALUE, Object.class);
            switch(op) {
                case EQUALS:
                    queryBuilder.filter(values(dataType, attributeValues));
                    break;
                case NOT_EQUALS:
                    queryBuilder.mustNot(values(dataType, attributeValues));
                    break;
                case LESS_THAN:
                    checkRangeValue(attributeValues);
                    queryBuilder.filter(valueRange(dataType, null, Iterables.getOnlyElement(attributeValues), false, false));
                    break;
                case LESS_THAN_EQUALS:
                    checkRangeValue(attributeValues);
                    queryBuilder.filter(valueRange(dataType, null, Iterables.getOnlyElement(attributeValues), false, true));
                    break;
                case GREATER_THAN:
                    checkRangeValue(attributeValues);
                    queryBuilder.filter(valueRange(dataType, Iterables.getOnlyElement(attributeValues), null, false, false));
                    break;
                case GREATER_THAN_EQUALS:
                    checkRangeValue(attributeValues);
                    queryBuilder.filter(valueRange(dataType, Iterables.getOnlyElement(attributeValues), null, true, false));
                    break;
                default:
                    throw new NotImplementedException("Unsupported concrete domain value operator %s", op);
            }
        }
        if (!propKeys.isEmpty()) {
            throw new IllegalQueryParameterException("Unsupported property filter(s), %s", propKeys);
        }
    }
    return queryBuilder.build();
}