Example usage for org.springframework.data.domain Pageable getPageSize

List of usage examples for org.springframework.data.domain Pageable getPageSize

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.data.domain.*
  5. Pageable
  6. getPageSize

Introduction

In this page you can find the example usage for org.springframework.data.domain Pageable getPageSize.

Prototype

int getPageSize();

Source Link

Document

Returns the number of items to be returned.

Usage

From source file:org.wallride.repository.CategoryRepositoryImpl.java

@Override
public Page<Category> search(CategorySearchRequest request, Pageable pageable) {
    FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager);
    QueryBuilder qb = fullTextEntityManager.getSearchFactory().buildQueryBuilder().forEntity(Category.class)
            .get();/*from  w ww .j  av a 2 s. c o m*/

    @SuppressWarnings("rawtypes")
    BooleanJunction<BooleanJunction> junction = qb.bool();
    junction.must(qb.all().createQuery());

    if (StringUtils.hasText(request.getKeyword())) {
        Analyzer analyzer = fullTextEntityManager.getSearchFactory().getAnalyzer("synonyms");
        String[] fields = new String[] { "name" };
        MultiFieldQueryParser parser = new MultiFieldQueryParser(fields, analyzer);
        parser.setDefaultOperator(QueryParser.Operator.AND);
        Query query = null;
        try {
            query = parser.parse(request.getKeyword());
        } catch (ParseException e1) {
            try {
                query = parser.parse(QueryParser.escape(request.getKeyword()));
            } catch (ParseException e2) {
                throw new RuntimeException(e2);
            }
        }
        junction.must(query);
    }

    if (StringUtils.hasText(request.getLanguage())) {
        junction.must(qb.keyword().onField("language").matching(request.getLanguage()).createQuery());
    }

    Query searchQuery = junction.createQuery();

    Session session = (Session) entityManager.getDelegate();
    Criteria criteria = session.createCriteria(Category.class);

    Sort sort = new Sort(new SortField("sortName", SortField.Type.STRING));

    FullTextQuery persistenceQuery = fullTextEntityManager.createFullTextQuery(searchQuery, Category.class)
            .setCriteriaQuery(criteria).setSort(sort);
    if (pageable != null) {
        persistenceQuery.setFirstResult(pageable.getOffset());
        persistenceQuery.setMaxResults(pageable.getPageSize());
    }

    int resultSize = persistenceQuery.getResultSize();

    @SuppressWarnings("unchecked")
    List<Category> results = persistenceQuery.getResultList();
    return new PageImpl<>(results, pageable, resultSize);
}

From source file:org.wallride.repository.UserRepositoryImpl.java

private FullTextQuery buildFullTextQuery(UserSearchRequest request, Pageable pageable, Criteria criteria) {
    FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager);
    QueryBuilder qb = fullTextEntityManager.getSearchFactory().buildQueryBuilder().forEntity(User.class).get();

    @SuppressWarnings("rawtypes")
    BooleanJunction<BooleanJunction> junction = qb.bool();
    junction.must(qb.all().createQuery());

    if (StringUtils.hasText(request.getKeyword())) {
        Analyzer analyzer = fullTextEntityManager.getSearchFactory().getAnalyzer("synonyms");
        String[] fields = new String[] { "loginId", "name.firstName", "name.lastName", };
        MultiFieldQueryParser parser = new MultiFieldQueryParser(fields, analyzer);
        parser.setDefaultOperator(QueryParser.Operator.AND);
        Query query = null;//from  w w  w. j a  va  2s  .  c  om
        try {
            query = parser.parse(request.getKeyword());
        } catch (ParseException e1) {
            try {
                query = parser.parse(QueryParser.escape(request.getKeyword()));
            } catch (ParseException e2) {
                throw new RuntimeException(e2);
            }
        }
        junction.must(query);
    }

    if (!CollectionUtils.isEmpty(request.getRoles())) {
        for (User.Role role : request.getRoles()) {
            junction.must(qb.keyword().onField("roles").matching(role).createQuery());
        }
    }

    Query searchQuery = junction.createQuery();

    Sort sort = new Sort(new SortField("sortId", SortField.Type.LONG, false));

    FullTextQuery persistenceQuery = fullTextEntityManager.createFullTextQuery(searchQuery, User.class)
            .setCriteriaQuery(criteria)
            //            .setProjection("id")
            .setSort(sort);
    if (pageable != null) {
        persistenceQuery.setFirstResult(pageable.getOffset());
        persistenceQuery.setMaxResults(pageable.getPageSize());
    }
    return persistenceQuery;
}

From source file:com.netflix.genie.core.jpa.services.JpaJobSearchServiceImpl.java

/**
 * {@inheritDoc}//from  w  w w  .j  a v  a2s  .  c  o  m
 */
@Override
public Page<JobSearchResult> findJobs(final String id, final String jobName, final String user,
        final Set<JobStatus> statuses, final Set<String> tags, final String clusterName, final String clusterId,
        final String commandName, final String commandId, final Date minStarted, final Date maxStarted,
        final Date minFinished, final Date maxFinished, @NotNull final Pageable page) {
    log.debug("called");

    final CriteriaBuilder cb = this.entityManager.getCriteriaBuilder();
    final CriteriaQuery<Long> countQuery = cb.createQuery(Long.class);
    final Root<JobEntity> root = countQuery.from(JobEntity.class);

    final Predicate whereClause = JpaJobSpecs.getFindPredicate(root, cb, id, jobName, user, statuses, tags,
            clusterName, clusterId == null ? null : this.clusterRepository.findOne(clusterId), commandName,
            commandId == null ? null : this.commandRepository.findOne(commandId), minStarted, maxStarted,
            minFinished, maxFinished);

    countQuery.select(cb.count(root)).where(whereClause);

    final Long count = this.entityManager.createQuery(countQuery).getSingleResult();

    // Use the count to make sure we even need to make this query
    if (count > 0) {
        final CriteriaQuery<JobSearchResult> contentQuery = cb.createQuery(JobSearchResult.class);
        contentQuery.from(JobEntity.class);

        contentQuery.multiselect(root.get(JobEntity_.id), root.get(JobEntity_.name), root.get(JobEntity_.user),
                root.get(JobEntity_.status), root.get(JobEntity_.started), root.get(JobEntity_.finished),
                root.get(JobEntity_.clusterName), root.get(JobEntity_.commandName));

        contentQuery.where(whereClause);

        final Sort sort = page.getSort();
        final List<Order> orders = new ArrayList<>();
        sort.iterator().forEachRemaining(order -> {
            if (order.isAscending()) {
                orders.add(cb.asc(root.get(order.getProperty())));
            } else {
                orders.add(cb.desc(root.get(order.getProperty())));
            }
        });

        contentQuery.orderBy(orders);

        final List<JobSearchResult> results = this.entityManager.createQuery(contentQuery)
                .setFirstResult(page.getOffset()).setMaxResults(page.getPageSize()).getResultList();

        return new PageImpl<>(results, page, count);
    } else {
        return new PageImpl<>(Lists.newArrayList(), page, count);
    }
}

From source file:com.ethlo.geodata.GeodataServiceImpl.java

@Override
public Page<GeoLocation> filter(LocationFilter filter, Pageable pageable) {
    final Collection<Query<GeoLocation>> queries = new LinkedList<>();

    if (filter.getName() != null) {
        if (filter.getName().endsWith("*")) {
            queries.add(QueryFactory.startsWith(CqGeonamesRepository.ATTRIBUTE_LC_NAME,
                    StringUtils.strip(filter.getName(), "*")));
        } else {/*from   w  w  w.j  av  a2 s.c  om*/
            queries.add(QueryFactory.equal(CqGeonamesRepository.ATTRIBUTE_LC_NAME, filter.getName()));
        }
    }

    if (!filter.getFeatureClasses().isEmpty()) {
        queries.add(QueryFactory.in(CqGeonamesRepository.ATTRIBUTE_FEATURE_CLASS, filter.getFeatureClasses()));
    }

    if (!filter.getFeatureCodes().isEmpty()) {
        queries.add(QueryFactory.in(CqGeonamesRepository.ATTRIBUTE_FEATURE_CODE, filter.getFeatureCodes()));
    }

    if (!filter.getCountryCodes().isEmpty()) {
        queries.add(QueryFactory.in(CqGeonamesRepository.ATTRIBUTE_COUNTRY_CODE, filter.getCountryCodes()));
    }

    Query<GeoLocation> query;

    if (queries.isEmpty()) {
        query = QueryFactory.none(GeoLocation.class);
    } else if (queries.size() == 1) {
        query = queries.iterator().next();
    } else {
        query = new And<>(queries);
    }

    final ResultSet<GeoLocation> result = geoNamesRepository.retrieve(query,
            QueryFactory.queryOptions(QueryFactory.orderBy(QueryFactory
                    .descending(QueryFactory.missingLast(CqGeonamesRepository.ATTRIBUTE_POPULATION)))));
    int index = 0;
    final List<GeoLocation> content = new LinkedList<>();
    for (GeoLocation l : result) {
        if (index >= pageable.getOffset() && content.size() < pageable.getPageSize()) {
            content.add(l);
        }
        index++;
    }

    return new PageImpl<>(content, pageable, index);
}

From source file:com.epam.ta.reportportal.database.dao.ReportPortalRepositoryImpl.java

@Override
public long getPageNumber(String entityId, Filter filterable, Pageable pageable) {
    Class<T> javaType = this.getEntityInformation().getJavaType();
    ImmutableList.Builder<AggregationOperation> pipelineBuilder = ImmutableList.<AggregationOperation>builder()
            .add(new MatchOperation(
                    new Criteria().andOperator(toArray(toCriteriaList(filterable), Criteria.class))) {
                @Override/*  www.ja  v a 2s  .  c o  m*/
                public DBObject toDBObject(AggregationOperationContext context) {
                    return super.toDBObject(new TypeBasedAggregationOperationContext(javaType,
                            mongoOperations.getConverter().getMappingContext(), queryMapper));
                }
            });

    if (null != pageable.getSort()) {
        pipelineBuilder.add(
                /* sort results as requested */
                sort(pageable.getSort()));
    }

    pipelineBuilder.add(
            /* group items into one field pushing all results into one array */
            group("result").push("$_id").as("array"),
            /* unwind array adding index to each result */
            unwind("array", "ind", false),
            /* find needed item. How we know its index in query result */
            match(where("array").is(ObjectId.isValid(entityId) ? new ObjectId(entityId) : entityId)),
            /* grab index only */
            project("ind"));

    /* find items matching an provided filter */
    Aggregation a = Aggregation.newAggregation(toArray(pipelineBuilder.build(), AggregationOperation.class));

    final AggregationResults<Map> aggregate = mongoOperations.aggregate(a,
            getEntityInformation().getCollectionName(), Map.class);

    if (!aggregate.getUniqueMappedResult().containsKey("ind")) {
        throw new ReportPortalException(ErrorType.INCORRECT_FILTER_PARAMETERS,
                "Unable to calculate page number. Check your input parameters");
    }

    /* result returned as long. Calculate page number */
    return (long) Math.ceil((((Long) aggregate.getUniqueMappedResult().get("ind")).doubleValue() + 1d)
            / (double) pageable.getPageSize());
}

From source file:org.wallride.repository.CommentRepositoryImpl.java

@Override
public Page<Comment> search(CommentSearchRequest request, Pageable pageable) {
    FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager);
    QueryBuilder qb = fullTextEntityManager.getSearchFactory().buildQueryBuilder().forEntity(Comment.class)
            .get();/* w w  w.  ja v  a  2  s . com*/

    @SuppressWarnings("rawtypes")
    BooleanJunction<BooleanJunction> junction = qb.bool();
    junction.must(qb.all().createQuery());

    if (StringUtils.hasText(request.getKeyword())) {
        Analyzer analyzer = fullTextEntityManager.getSearchFactory().getAnalyzer("synonyms");
        String[] fields = new String[] { "authorName", "content" };
        MultiFieldQueryParser parser = new MultiFieldQueryParser(fields, analyzer);
        parser.setDefaultOperator(QueryParser.Operator.AND);
        Query query = null;
        try {
            query = parser.parse(request.getKeyword());
        } catch (ParseException e1) {
            try {
                query = parser.parse(QueryParser.escape(request.getKeyword()));
            } catch (ParseException e2) {
                throw new RuntimeException(e2);
            }
        }
        junction.must(query);
    }

    if (StringUtils.hasText(request.getLanguage())) {
        junction.must(qb.keyword().onField("post.language").matching(request.getLanguage()).createQuery());
    }

    if (request.getPostId() != null) {
        junction.must(qb.keyword().onField("post.id").matching(request.getPostId()).createQuery());
    }

    if (request.getApproved() != null) {
        junction.must(qb.keyword().onField("approved").matching(request.getApproved()).createQuery());
    }

    Query searchQuery = junction.createQuery();

    Session session = (Session) entityManager.getDelegate();
    Criteria criteria = session.createCriteria(Comment.class).setFetchMode("post", FetchMode.JOIN)
            .setFetchMode("author", FetchMode.JOIN);

    Sort sort = null;
    if (pageable.getSort() != null) {
        if (pageable.getSort().getOrderFor("date") != null) {
            Order order = pageable.getSort().getOrderFor("date");
            sort = new Sort(
                    new SortField("sortDate", SortField.Type.STRING,
                            order.getDirection().equals(Direction.DESC)),
                    new SortField("sortId", SortField.Type.LONG, order.getDirection().equals(Direction.DESC)));
        }
    }

    if (sort == null) {
        sort = new Sort(new SortField("sortDate", SortField.Type.STRING),
                new SortField("sortId", SortField.Type.LONG));
    }

    FullTextQuery persistenceQuery = fullTextEntityManager.createFullTextQuery(searchQuery, Comment.class)
            .setCriteriaQuery(criteria).setSort(sort);
    persistenceQuery.setFirstResult(pageable.getOffset());
    persistenceQuery.setMaxResults(pageable.getPageSize());

    int resultSize = persistenceQuery.getResultSize();

    @SuppressWarnings("unchecked")
    List<Comment> results = persistenceQuery.getResultList();
    return new PageImpl<>(results, pageable, resultSize);
}

From source file:org.wallride.repository.PostRepositoryImpl.java

@Override
public Page<Post> search(PostSearchRequest request, Pageable pageable) {
    FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager);
    QueryBuilder qb = fullTextEntityManager.getSearchFactory().buildQueryBuilder().forEntity(Post.class).get();

    @SuppressWarnings("rawtypes")
    BooleanJunction<BooleanJunction> junction = qb.bool();
    junction.must(qb.all().createQuery());

    junction.must(qb.keyword().onField("drafted").ignoreAnalyzer().matching("_null_").createQuery());

    if (StringUtils.hasText(request.getKeyword())) {
        Analyzer analyzer = fullTextEntityManager.getSearchFactory().getAnalyzer("synonyms");
        String[] fields = new String[] { "title", "body", "tags.name", };
        MultiFieldQueryParser parser = new MultiFieldQueryParser(fields, analyzer);
        parser.setDefaultOperator(QueryParser.Operator.AND);
        Query query = null;/*  w  w  w .j  a  v a2 s.  c  o  m*/
        try {
            query = parser.parse(request.getKeyword());
        } catch (ParseException e1) {
            try {
                query = parser.parse(QueryParser.escape(request.getKeyword()));
            } catch (ParseException e2) {
                throw new RuntimeException(e2);
            }
        }
        junction.must(query);
    }
    if (request.getStatus() != null) {
        junction.must(qb.keyword().onField("status").matching(request.getStatus()).createQuery());
    }
    if (StringUtils.hasText(request.getLanguage())) {
        junction.must(qb.keyword().onField("language").matching(request.getLanguage()).createQuery());
    }

    if (request.getDateFrom() != null) {
        junction.must(qb.range().onField("date").above(request.getDateFrom()).createQuery());
    }
    if (request.getDateTo() != null) {
        junction.must(qb.range().onField("date").below(request.getDateTo()).createQuery());
    }

    if (!CollectionUtils.isEmpty(request.getTagNames())) {
        BooleanJunction<BooleanJunction> subJunction = qb.bool();
        for (String tagName : request.getTagNames()) {
            subJunction.should(qb.phrase().onField("tags.name").sentence(tagName).createQuery());
        }
        junction.must(subJunction.createQuery());
    }

    if (!CollectionUtils.isEmpty(request.getPostIds())) {
        BooleanJunction<BooleanJunction> bool = qb.bool();
        for (long postId : request.getPostIds()) {
            bool.should(qb.keyword().onField("id").matching(postId).createQuery());
        }
        junction.must(bool.createQuery());
    }

    Query searchQuery = junction.createQuery();

    Session session = (Session) entityManager.getDelegate();
    Criteria criteria = session.createCriteria(Post.class).setFetchMode("cover", FetchMode.JOIN)
            .setFetchMode("tags", FetchMode.JOIN).setFetchMode("categories", FetchMode.JOIN)
            .setFetchMode("customFieldValues", FetchMode.JOIN)
            .setFetchMode("customFieldValues.customField", FetchMode.JOIN)
            .setFetchMode("author", FetchMode.JOIN);

    Sort sort = new Sort(new SortField("sortDate", SortField.Type.STRING, true),
            new SortField("sortId", SortField.Type.LONG, true));

    FullTextQuery persistenceQuery = fullTextEntityManager.createFullTextQuery(searchQuery, Post.class)
            .setCriteriaQuery(criteria).setSort(sort);
    persistenceQuery.setFirstResult(pageable.getOffset());
    persistenceQuery.setMaxResults(pageable.getPageSize());

    int resultSize = persistenceQuery.getResultSize();

    @SuppressWarnings("unchecked")
    List<Post> results = persistenceQuery.getResultList();
    return new PageImpl<>(results, pageable, resultSize);
}

From source file:org.wallride.repository.PageRepositoryImpl.java

private FullTextQuery buildFullTextQuery(PageSearchRequest request, Pageable pageable, Criteria criteria) {
    FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager);
    QueryBuilder qb = fullTextEntityManager.getSearchFactory().buildQueryBuilder().forEntity(Page.class).get();

    @SuppressWarnings("rawtypes")
    BooleanJunction<BooleanJunction> junction = qb.bool();
    junction.must(qb.all().createQuery());

    junction.must(qb.keyword().onField("drafted").ignoreAnalyzer().matching("_null_").createQuery());

    if (StringUtils.hasText(request.getKeyword())) {
        Analyzer analyzer = fullTextEntityManager.getSearchFactory().getAnalyzer("synonyms");
        String[] fields = new String[] { "title", "body", "tags.name", };
        MultiFieldQueryParser parser = new MultiFieldQueryParser(fields, analyzer);
        parser.setDefaultOperator(QueryParser.Operator.AND);
        Query query = null;//from   w  w  w  .  ja v a 2 s  .  co  m
        try {
            query = parser.parse(request.getKeyword());
        } catch (ParseException e1) {
            try {
                query = parser.parse(QueryParser.escape(request.getKeyword()));
            } catch (ParseException e2) {
                throw new RuntimeException(e2);
            }
        }
        junction.must(query);
    }
    if (StringUtils.hasText(request.getLanguage())) {
        junction.must(qb.keyword().onField("language").matching(request.getLanguage()).createQuery());
    }

    if (request.getStatus() != null) {
        junction.must(qb.keyword().onField("status").matching(request.getStatus()).createQuery());
    }

    if (!CollectionUtils.isEmpty(request.getCategoryIds())) {
        BooleanJunction<BooleanJunction> subJunction = qb.bool();
        for (long categoryId : request.getCategoryIds()) {
            subJunction.should(qb.keyword().onField("categories.id").matching(categoryId).createQuery());
        }
        junction.must(subJunction.createQuery());
    }
    if (!CollectionUtils.isEmpty(request.getCategoryCodes())) {
        BooleanJunction<BooleanJunction> subJunction = qb.bool();
        for (String categoryCode : request.getCategoryCodes()) {
            subJunction.should(qb.keyword().onField("categories.code").matching(categoryCode).createQuery());
        }
        junction.must(subJunction.createQuery());
    }

    if (!CollectionUtils.isEmpty(request.getTagIds())) {
        BooleanJunction<BooleanJunction> subJunction = qb.bool();
        for (long tagId : request.getTagIds()) {
            subJunction.should(qb.keyword().onField("tags.id").matching(tagId).createQuery());
        }
        junction.must(subJunction.createQuery());
    }
    if (!CollectionUtils.isEmpty(request.getTagNames())) {
        BooleanJunction<BooleanJunction> subJunction = qb.bool();
        for (String tagName : request.getTagNames()) {
            subJunction.should(qb.phrase().onField("tags.name").sentence(tagName).createQuery());
        }
        junction.must(subJunction.createQuery());
    }

    if (!CollectionUtils.isEmpty(request.getCustomFields())) {
        javax.persistence.Query query = entityManager.createQuery(
                "from CustomField where language = :language and code in (:codes)", CustomField.class);
        query.setParameter("language", request.getLanguage()).setParameter("codes",
                request.getCustomFields().keySet());
        List<CustomField> customFields = query.getResultList();

        if (!CollectionUtils.isEmpty(customFields)) {
            Map<String, CustomField> customFieldMap = customFields.stream()
                    .collect(Collectors.toMap(CustomField::getCode, Function.identity()));

            BooleanJunction<BooleanJunction> subJunction = qb.bool();
            for (String key : request.getCustomFields().keySet()) {
                List<Object> values = (List<Object>) request.getCustomFields().get(key);
                CustomField target = customFieldMap.get(key);
                BooleanJunction<BooleanJunction> customFieldJunction = qb.bool();
                switch (target.getFieldType()) {
                case TEXT:
                case TEXTAREA:
                case HTML:
                    for (Object value : values) {
                        customFieldJunction.must(qb.keyword().onField("customFieldValues." + key)
                                .ignoreFieldBridge().matching(value.toString()).createQuery());
                    }
                    break;
                default:
                    for (Object value : values) {
                        customFieldJunction.must(qb.phrase().onField("customFieldValues." + key)
                                .ignoreFieldBridge().sentence(value.toString()).createQuery());
                    }
                }
                subJunction.must(customFieldJunction.createQuery());
            }
            junction.must(subJunction.createQuery());
        }
    }

    if (request.getAuthorId() != null) {
        junction.must(qb.keyword().onField("author.id").matching(request.getAuthorId()).createQuery());
    }

    Query searchQuery = junction.createQuery();

    Sort sort = new Sort(new SortField("sortLft", SortField.Type.INT));

    FullTextQuery persistenceQuery = fullTextEntityManager.createFullTextQuery(searchQuery, Page.class)
            .setCriteriaQuery(criteria).setSort(sort);
    if (pageable != null) {
        persistenceQuery.setFirstResult(pageable.getOffset());
        persistenceQuery.setMaxResults(pageable.getPageSize());
    }
    return persistenceQuery;
}

From source file:org.wallride.repository.ArticleRepositoryImpl.java

private FullTextQuery buildFullTextQuery(ArticleSearchRequest request, Pageable pageable, Criteria criteria) {
    FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager);
    QueryBuilder qb = fullTextEntityManager.getSearchFactory().buildQueryBuilder().forEntity(Article.class)
            .get();/* ww  w .ja  va  2s . c  o  m*/

    @SuppressWarnings("rawtypes")
    BooleanJunction<BooleanJunction> junction = qb.bool();
    junction.must(qb.all().createQuery());

    junction.must(qb.keyword().onField("drafted").ignoreAnalyzer().matching("_null_").createQuery());

    if (StringUtils.hasText(request.getKeyword())) {
        Analyzer analyzer = fullTextEntityManager.getSearchFactory().getAnalyzer("synonyms");
        String[] fields = new String[] { "title", "body", "categories.name", "tags.name",
                "customFieldValues.value" };
        MultiFieldQueryParser parser = new MultiFieldQueryParser(fields, analyzer);
        parser.setDefaultOperator(QueryParser.Operator.AND);
        Query query = null;
        try {
            query = parser.parse(request.getKeyword());
        } catch (ParseException e1) {
            try {
                query = parser.parse(QueryParser.escape(request.getKeyword()));
            } catch (ParseException e2) {
                throw new RuntimeException(e2);
            }
        }
        junction.must(query);
    }
    if (request.getStatus() != null) {
        junction.must(qb.keyword().onField("status").matching(request.getStatus()).createQuery());
    }
    if (StringUtils.hasText(request.getLanguage())) {
        junction.must(qb.keyword().onField("language").matching(request.getLanguage()).createQuery());
    }

    if (request.getDateFrom() != null) {
        junction.must(qb.range().onField("date").above(request.getDateFrom()).createQuery());
    }
    if (request.getDateTo() != null) {
        junction.must(qb.range().onField("date").below(request.getDateTo()).createQuery());
    }

    if (!CollectionUtils.isEmpty(request.getCategoryIds())) {
        BooleanJunction<BooleanJunction> subJunction = qb.bool();
        for (long categoryId : request.getCategoryIds()) {
            subJunction.should(qb.keyword().onField("categories.id").matching(categoryId).createQuery());
        }
        junction.must(subJunction.createQuery());
    }
    if (!CollectionUtils.isEmpty(request.getCategoryCodes())) {
        BooleanJunction<BooleanJunction> subJunction = qb.bool();
        for (String categoryCode : request.getCategoryCodes()) {
            subJunction.should(qb.keyword().onField("categories.code").matching(categoryCode).createQuery());
        }
        junction.must(subJunction.createQuery());
    }

    if (!CollectionUtils.isEmpty(request.getTagIds())) {
        BooleanJunction<BooleanJunction> subJunction = qb.bool();
        for (long tagId : request.getTagIds()) {
            subJunction.should(qb.keyword().onField("tags.id").matching(tagId).createQuery());
        }
        junction.must(subJunction.createQuery());
    }
    if (!CollectionUtils.isEmpty(request.getTagNames())) {
        BooleanJunction<BooleanJunction> subJunction = qb.bool();
        for (String tagName : request.getTagNames()) {
            subJunction.should(qb.phrase().onField("tags.name").sentence(tagName).createQuery());
        }
        junction.must(subJunction.createQuery());
    }

    if (!CollectionUtils.isEmpty(request.getCustomFields())) {
        javax.persistence.Query query = entityManager.createQuery(
                "from CustomField where language = :language and code in (:codes)", CustomField.class);
        query.setParameter("language", request.getLanguage()).setParameter("codes",
                request.getCustomFields().keySet());
        List<CustomField> customFields = query.getResultList();

        if (!CollectionUtils.isEmpty(customFields)) {
            Map<String, CustomField> customFieldMap = customFields.stream()
                    .collect(Collectors.toMap(CustomField::getCode, Function.identity()));

            BooleanJunction<BooleanJunction> subJunction = qb.bool();
            for (String key : request.getCustomFields().keySet()) {
                List<Object> values = (List<Object>) request.getCustomFields().get(key);
                CustomField target = customFieldMap.get(key);
                BooleanJunction<BooleanJunction> customFieldJunction = qb.bool();
                switch (target.getFieldType()) {
                case TEXT:
                case TEXTAREA:
                case HTML:
                    for (Object value : values) {
                        customFieldJunction.must(qb.keyword().onField("customFieldValues." + key)
                                .ignoreFieldBridge().matching(value.toString()).createQuery());
                    }
                    break;
                default:
                    for (Object value : values) {
                        customFieldJunction.must(qb.phrase().onField("customFieldValues." + key)
                                .ignoreFieldBridge().sentence(value.toString()).createQuery());
                    }
                }
                subJunction.must(customFieldJunction.createQuery());
            }
            junction.must(subJunction.createQuery());
        }
    }

    if (request.getAuthorId() != null) {
        junction.must(qb.keyword().onField("author.id").matching(request.getAuthorId()).createQuery());
    }

    Query searchQuery = junction.createQuery();

    Sort sort = new Sort(new SortField("sortDate", SortField.Type.STRING, true),
            new SortField("sortId", SortField.Type.LONG, true));

    FullTextQuery persistenceQuery = fullTextEntityManager.createFullTextQuery(searchQuery, Article.class)
            .setCriteriaQuery(criteria).setSort(sort);
    if (pageable != null) {
        persistenceQuery.setFirstResult(pageable.getOffset());
        persistenceQuery.setMaxResults(pageable.getPageSize());
    }
    return persistenceQuery;
}

From source file:org.dspace.app.rest.converter.DiscoverFacetResultsConverter.java

private void addToFacetResultList(String facetName, DiscoverResult searchResult,
        FacetResultsRest facetResultsRest, DiscoveryConfiguration configuration, Pageable page) {

    DiscoverySearchFilterFacet field = configuration.getSidebarFacet(facetName);
    List<DiscoverResult.FacetResult> facetValues = searchResult.getFacetResult(field);
    int valueCount = 0;

    for (DiscoverResult.FacetResult value : CollectionUtils.emptyIfNull(facetValues)) {
        if (valueCount >= page.getPageSize()) {
            //We requested one facet value more as the page size. We must make sure to not return the extra value.
            break;
        }/*from  w  w  w . java2s  .  c o m*/
        SearchFacetValueRest searchFacetValueRest = buildSearchFacetValueRestFromFacetResult(value);
        facetResultsRest.addToFacetResultList(searchFacetValueRest);
        valueCount++;
    }
}