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

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

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

Introduction

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

Prototype

Sort getSort();

Source Link

Document

Returns the sorting parameters.

Usage

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();//from   w  w  w  .j  a  va  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[] { "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.dspace.app.rest.converter.DiscoverResultConverter.java

private void setRequestInformation(final Context context, final String query, final String dsoType,
        final String configurationName, final String scope, final List<SearchFilter> searchFilters,
        final Pageable page, final SearchResultsRest resultsRest) {
    resultsRest.setQuery(query);//from  www . j  av  a2 s.co  m
    resultsRest.setConfigurationName(configurationName);
    resultsRest.setDsoType(dsoType);

    resultsRest.setScope(scope);

    if (page != null && page.getSort() != null && page.getSort().iterator().hasNext()) {
        Sort.Order order = page.getSort().iterator().next();
        resultsRest.setSort(order.getProperty(), order.getDirection().name());
    }
    SearchQueryConverter searchQueryConverter = new SearchQueryConverter();
    List<SearchFilter> transformedFilters = searchQueryConverter.convert(searchFilters);

    SearchFilterToAppliedFilterConverter searchFilterToAppliedFilterConverter = new SearchFilterToAppliedFilterConverter();
    for (SearchFilter searchFilter : CollectionUtils.emptyIfNull(transformedFilters)) {

        resultsRest.addAppliedFilter(
                searchFilterToAppliedFilterConverter.convertSearchFilter(context, searchFilter));
    }
}

From source file:org.dspace.app.rest.repository.BrowseEntryLinkRepository.java

public Page<BrowseEntryRest> listBrowseEntries(HttpServletRequest request, String browseName, Pageable pageable,
        String projection) throws BrowseException, SQLException {
    // FIXME this should be bind automatically and available as method
    // argument//from   w ww .ja  v a 2 s .  co  m
    String scope = null;
    if (request != null) {
        scope = request.getParameter("scope");
    }

    Context context = obtainContext();
    BrowseEngine be = new BrowseEngine(context);
    BrowserScope bs = new BrowserScope(context);
    DSpaceObject scopeObj = null;
    if (scope != null) {
        UUID uuid = UUID.fromString(scope);
        scopeObj = communityService.find(context, uuid);
        if (scopeObj == null) {
            scopeObj = collectionService.find(context, uuid);
        }
    }

    // process the input, performing some inline validation
    final BrowseIndex bi;
    if (StringUtils.isNotEmpty(browseName)) {
        bi = BrowseIndex.getBrowseIndex(browseName);
    } else {
        bi = null;
    }
    if (bi == null) {
        throw new IllegalArgumentException("Unknown browse index");
    }
    if (!bi.isMetadataIndex()) {
        throw new IllegalStateException("The requested browse haven't metadata entries");
    }

    // set up a BrowseScope and start loading the values into it
    bs.setBrowseIndex(bi);
    Sort sort = null;
    if (pageable != null) {
        sort = pageable.getSort();
    }
    if (sort != null) {
        Iterator<Order> orders = sort.iterator();
        while (orders.hasNext()) {
            bs.setOrder(orders.next().getDirection().name());
        }
    }
    // bs.setFilterValue(value != null?value:authority);
    // bs.setFilterValueLang(valueLang);
    // bs.setJumpToItem(focus);
    // bs.setJumpToValue(valueFocus);
    // bs.setJumpToValueLang(valueFocusLang);
    // bs.setStartsWith(startsWith);
    if (pageable != null) {
        bs.setOffset(pageable.getOffset());
        bs.setResultsPerPage(pageable.getPageSize());
    }
    // bs.setEtAl(etAl);
    // bs.setAuthorityValue(authority);

    if (scopeObj != null) {
        bs.setBrowseContainer(scopeObj);
    }

    BrowseInfo binfo = be.browse(bs);
    Pageable pageResultInfo = new PageRequest((binfo.getStart() - 1) / binfo.getResultsPerPage(),
            binfo.getResultsPerPage());
    Page<BrowseEntryRest> page = new PageImpl<String[]>(Arrays.asList(binfo.getStringResults()), pageResultInfo,
            binfo.getTotal()).map(converter);
    page.forEach(new Consumer<BrowseEntryRest>() {
        @Override
        public void accept(BrowseEntryRest t) {
            t.setBrowseIndex(bixConverter.convert(bi));
        }
    });
    return page;
}

From source file:org.dspace.app.rest.repository.BrowseItemLinkRepository.java

public Page<ItemRest> listBrowseItems(HttpServletRequest request, String browseName, Pageable pageable,
        String projection) throws BrowseException, SQLException {
    //FIXME these should be bind automatically and available as method arguments
    String scope = null;/*from   w  w  w  .ja v  a  2s .co m*/
    String filterValue = null;
    String filterAuthority = null;

    if (request != null) {
        scope = request.getParameter("scope");
        filterValue = request.getParameter("filterValue");
        filterAuthority = request.getParameter("filterAuthority");
    }
    Context context = obtainContext();
    BrowseEngine be = new BrowseEngine(context);
    BrowserScope bs = new BrowserScope(context);
    DSpaceObject scopeObj = null;
    if (scope != null) {
        UUID uuid = UUID.fromString(scope);
        scopeObj = communityService.find(context, uuid);
        if (scopeObj == null) {
            scopeObj = collectionService.find(context, uuid);
        }
    }

    // process the input, performing some inline validation
    BrowseIndex bi = null;
    if (StringUtils.isNotEmpty(browseName)) {
        bi = BrowseIndex.getBrowseIndex(browseName);
    }
    if (bi == null) {
        throw new IllegalArgumentException("Unknown browse index");
    }
    if (!bi.isItemIndex() && (filterAuthority == null && filterValue == null)) {
        throw new IllegalStateException(
                "The requested browse doesn't provide direct access to items you must specify a filter");
    }

    if (!bi.isMetadataIndex() && (filterAuthority != null || filterValue != null)) {
        throw new IllegalStateException("The requested browse doesn't support filtering");
    }

    // set up a BrowseScope and start loading the values into it
    bs.setBrowseIndex(bi);
    Sort sort = null;
    if (pageable != null) {
        sort = pageable.getSort();
    }
    if (sort != null) {
        Iterator<Order> orders = sort.iterator();
        while (orders.hasNext()) {
            Order order = orders.next();
            bs.setOrder(order.getDirection().name());
            String sortBy;
            if (!StringUtils.equals("default", order.getProperty())) {
                sortBy = order.getProperty();
            } else {
                sortBy = bi.getDefaultOrder();
            }

            try {
                SortOption so = SortOption.getSortOption(sortBy);
                if (so != null) {
                    bs.setSortBy(so.getNumber());
                }
            } catch (SortException e) {
                throw new RuntimeException(e.getMessage(), e);
            }
        }
    }

    if (filterValue != null || filterAuthority != null) {
        bs.setFilterValue(filterValue);
        bs.setAuthorityValue(filterAuthority);
        bs.setBrowseLevel(1);
    }
    // bs.setFilterValueLang(valueLang);
    // bs.setJumpToItem(focus);
    // bs.setJumpToValue(valueFocus);
    // bs.setJumpToValueLang(valueFocusLang);
    // bs.setStartsWith(startsWith);
    if (pageable != null) {
        bs.setOffset(pageable.getOffset());
        bs.setResultsPerPage(pageable.getPageSize());
    }

    if (scopeObj != null) {
        bs.setBrowseContainer(scopeObj);
    }

    // For second level browses on metadata indexes, we need to adjust the default sorting
    if (bi != null && bi.isMetadataIndex() && bs.isSecondLevel() && bs.getSortBy() <= 0) {
        bs.setSortBy(1);
    }

    BrowseInfo binfo = be.browse(bs);

    Pageable pageResultInfo = new PageRequest((binfo.getStart() - 1) / binfo.getResultsPerPage(),
            binfo.getResultsPerPage());
    Page<ItemRest> page = new PageImpl<Item>(binfo.getBrowseItemResults(), pageResultInfo, binfo.getTotal())
            .map(converter);
    return page;
}

From source file:org.dspace.app.rest.utils.DiscoverQueryBuilder.java

private void configureSorting(Pageable page, DiscoverQuery queryArgs,
        DiscoverySortConfiguration searchSortConfiguration) throws InvalidSortingException {
    String sortBy = null;/*from  ww  w .ja  v  a2s.co  m*/
    String sortOrder = null;

    //Read the Pageable object if there is one
    if (page != null) {
        Sort sort = page.getSort();
        if (sort != null && sort.iterator().hasNext()) {
            Sort.Order order = sort.iterator().next();
            sortBy = order.getProperty();
            sortOrder = order.getDirection().name();
        }
    }

    //Load defaults if we did not receive values
    if (sortBy == null) {
        sortBy = getDefaultSortField(searchSortConfiguration);
    }
    if (sortOrder == null) {
        sortOrder = getDefaultSortDirection(searchSortConfiguration, sortOrder);
    }

    //Update Discovery query
    DiscoverySortFieldConfiguration sortFieldConfiguration = searchSortConfiguration
            .getSortFieldConfiguration(sortBy);

    if (sortFieldConfiguration != null) {
        String sortField = searchService.toSortFieldIndex(sortFieldConfiguration.getMetadataField(),
                sortFieldConfiguration.getType());

        if ("asc".equalsIgnoreCase(sortOrder)) {
            queryArgs.setSortField(sortField, DiscoverQuery.SORT_ORDER.asc);
        } else if ("desc".equalsIgnoreCase(sortOrder)) {
            queryArgs.setSortField(sortField, DiscoverQuery.SORT_ORDER.desc);
        } else {
            throw new InvalidSortingException(sortOrder + " is not a valid sort order");
        }

    } else {
        throw new InvalidSortingException(sortBy + " is not a valid sort field");
    }
}

From source file:org.dspace.app.rest.utils.RestRepositoryUtils.java

private Object[] prepareParameters(Method method, MultiValueMap<String, ? extends Object> rawParameters,
        Pageable pageable, Sort sort) {

    List<MethodParameter> parameters = new MethodParameters(method, PARAM_ANNOTATION).getParameters();

    if (parameters.isEmpty()) {
        return new Object[0];
    }//from  ww  w . j  a  v  a 2s  . c o  m

    Object[] result = new Object[parameters.size()];
    Sort sortToUse = pageable == null ? sort : pageable.getSort();

    for (int i = 0; i < result.length; i++) {

        MethodParameter param = parameters.get(i);
        Class<?> targetType = param.getParameterType();

        if (Pageable.class.isAssignableFrom(targetType)) {
            result[i] = pageable;
        } else if (Sort.class.isAssignableFrom(targetType)) {
            result[i] = sortToUse;
        } else {

            String parameterName = param.getParameterName();

            if (StringUtils.isBlank(parameterName)) {
                throw new IllegalArgumentException(
                        String.format(NAME_NOT_FOUND, ClassUtils.getQualifiedMethodName(method)));
            }

            Object value = unwrapSingleElement(rawParameters.get(parameterName));

            result[i] = targetType.isInstance(value) ? value : convert(value, param);
        }
    }

    return result;
}

From source file:org.ligoj.app.plugin.id.ldap.dao.AbstractContainerLdapRepository.java

@Override
public Page<T> findAll(final Set<T> groups, final String criteria, final Pageable pageable,
        final Map<String, Comparator<T>> customComparators) {
    // Create the set with the right comparator
    final List<Sort.Order> orders = IteratorUtils
            .toList(ObjectUtils.defaultIfNull(pageable.getSort(), new ArrayList<Sort.Order>()).iterator());
    orders.add(DEFAULT_ORDER);//from   w  ww .j  a  v  a  2  s.c o  m
    final Sort.Order order = orders.get(0);
    Comparator<T> comparator = customComparators.get(order.getProperty());
    if (order.getDirection() == Direction.DESC) {
        comparator = Collections.reverseOrder(comparator);
    }
    final Set<T> result = new TreeSet<>(comparator);

    // Filter the groups, filtering by the criteria
    addFilteredByPattern(groups, criteria, result);

    // Apply in-memory pagination
    return inMemoryPagination.newPage(result, pageable);
}

From source file:org.ligoj.app.plugin.id.ldap.dao.UserLdapRepository.java

@Override
public Page<UserOrg> findAll(final Collection<GroupOrg> requiredGroups, final Set<String> companies,
        final String criteria, final Pageable pageable) {
    // Create the set with the right comparator
    final List<Sort.Order> orders = IteratorUtils
            .toList(ObjectUtils.defaultIfNull(pageable.getSort(), new ArrayList<Sort.Order>()).iterator());
    orders.add(DEFAULT_ORDER);/*from   w  w w  .j  av  a2s .c o  m*/
    final Sort.Order order = orders.get(0);
    Comparator<UserOrg> comparator = ObjectUtils.defaultIfNull(COMPARATORS.get(order.getProperty()),
            DEFAULT_COMPARATOR);
    if (order.getDirection() == Direction.DESC) {
        comparator = Collections.reverseOrder(comparator);
    }
    final Set<UserOrg> result = new TreeSet<>(comparator);

    // Filter the users traversing firstly the required groups and their members,
    // the companies, then the criteria
    final Map<String, UserOrg> users = findAll();
    if (requiredGroups == null) {
        // No constraint on group
        addFilteredByCompaniesAndPattern(users.keySet(), companies, criteria, result, users);
    } else {
        // User must be within one the given groups
        for (final GroupOrg requiredGroup : requiredGroups) {
            addFilteredByCompaniesAndPattern(requiredGroup.getMembers(), companies, criteria, result, users);
        }
    }

    // Apply in-memory pagination
    return inMemoryPagination.newPage(result, pageable);
}

From source file:org.opentestsystem.shared.progman.client.ProgramManagementClient.java

private static Map<String, String> getPageableParams(final Pageable pageable) {
    Map<String, String> params = Maps.newHashMap();
    params.put("page.page", "");
    params.put("page.size", "");
    params.put("page.sort", "");
    params.put("page.sort.dir", "");

    if (pageable != null) {
        params.put("page.page", Integer.toString(pageable.getPageNumber()));
        params.put("page.size", Integer.toString(pageable.getPageSize()));
        if (pageable.getSort() != null && pageable.getSort().iterator().hasNext()) {
            Order firstOrder = pageable.getSort().iterator().next();
            params.put("page.sort", firstOrder.getProperty());
            params.put("page.sort.dir", firstOrder.getDirection().name());
        }//from w  ww.  j av a2  s .  co m
    }

    return params;
}

From source file:org.springframework.data.document.mongodb.repository.QueryDslMongoRepository.java

/**
 * Applies the given {@link Pageable} to the given {@link MongodbQuery}.
 * /*from w  w  w  .  j a  v  a  2  s  .  com*/
 * @param query
 * @param pageable
 * @return
 */
private MongodbQuery<T> applyPagination(MongodbQuery<T> query, Pageable pageable) {

    if (pageable == null) {
        return query;
    }

    query = query.offset(pageable.getOffset()).limit(pageable.getPageSize());
    return applySorting(query, pageable.getSort());
}