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:io.getlime.push.controller.rest.PushCampaignController.java

/**
 * Method for getting users from specific campaign in paged format
 *
 * @param id Campaign id/*from  w  w  w .j a  v a 2s  .c  om*/
 * @param pageable Format for pagination (?page=x&size=y), where "x" is chosen page and "y" is size is number of elements per page, beginning from zero
 * @return Campaign id, list of users
 */
@RequestMapping(value = "{id}/user/list", method = RequestMethod.GET)
@ResponseBody
public PagedResponse<ListOfUsersFromCampaignResponse> getListOfUsersFromCampaign(
        @PathVariable(value = "id") Long id, Pageable pageable) {
    ListOfUsersFromCampaignResponse listOfUsersFromCampaignResponse = new ListOfUsersFromCampaignResponse();
    List<PushCampaignUserEntity> users = pushCampaignUserRepository.findAllByCampaignId(id, pageable);
    ListOfUsers listOfUsers = new ListOfUsers();
    for (PushCampaignUserEntity user : users) {
        listOfUsers.add(user.getUserId());
    }
    listOfUsersFromCampaignResponse.setCampaingId(id);
    listOfUsersFromCampaignResponse.setUsers(listOfUsers);
    PagedResponse<ListOfUsersFromCampaignResponse> pagedResponse = new PagedResponse<>(
            listOfUsersFromCampaignResponse);
    pagedResponse.setPage(pageable.getPageNumber());
    pagedResponse.setSize(pageable.getPageSize());
    return pagedResponse;
}

From source file:com.ethercamp.harmony.service.ContractsService.java

/**
 * Get contract storage entries.//from ww w . j  a v  a2  s.  co m
 *
 * @param hexAddress - address of contract
 * @param path - nested level of fields
 * @param pageable - for paging
 */
public Page<StorageEntry> getContractStorage(String hexAddress, String path, Pageable pageable) {
    final byte[] address = Hex.decode(hexAddress);
    final ContractEntity contract = Optional.ofNullable(contractsStorage.get(address))
            .map(bytes -> contractFormat.decode(bytes))
            .orElseThrow(() -> new RuntimeException("Contract sources not found"));

    final StoragePage storagePage = getContractData(hexAddress, contract.getDataMembers(), Path.parse(path),
            pageable.getPageNumber(), pageable.getPageSize());

    final PageImpl<StorageEntry> storage = new PageImpl<>(storagePage.getEntries(), pageable,
            storagePage.getTotal());

    return storage;
}

From source file:ei.ne.ke.cassandra.cql3.AstyanaxCql3Repository.java

protected Page<T> doFindAll(Predicate predicate, Pageable pageable) {
    try {/*from  w  ww .  j  a v  a 2s.  c  o m*/
        int pageNumber = pageable.getPageNumber();
        int pageSize = pageable.getPageSize();
        int offset = pageable.getOffset();
        int firstRow = pageNumber * pageSize + offset;
        int lastRow = (pageNumber + 1) * pageSize + offset;
        Map<String, ByteBuffer> serializedValues = Maps.newLinkedHashMap();
        predicate.accept(new PredicateSerializerVisitor(), serializedValues);
        String cql = cqlGen.buildFindAllStatement(Lists.newArrayList(serializedValues.keySet()));
        PreparedCqlQuery<String, String> preparedStatement = doPreparedCqlRead(cql);
        for (Map.Entry<String, ByteBuffer> entry : serializedValues.entrySet()) {
            preparedStatement = preparedStatement.withValue(entry.getValue());
        }
        OperationResult<CqlResult<String, String>> opResult = preparedStatement.execute();
        LOGGER.debug("attempts: {}, latency: {}ms", opResult.getAttemptsCount(),
                opResult.getLatency(TimeUnit.MILLISECONDS));
        CqlResult<String, String> cqlResult = opResult.getResult();
        List<T> elements = Lists.newArrayList(spec.map(cqlResult.getRows()));
        List<T> result = Lists.newArrayListWithExpectedSize(lastRow - firstRow + 1);
        for (int i = firstRow; i < elements.size() && i < lastRow; i++) {
            result.add(elements.get(i));
        }
        return new PageImpl<T>(result, pageable, doCount(predicate));
    } catch (ConnectionException e) {
        throw new DataRetrievalFailureException("Error while executing CQL3 query", e);
    }
}

From source file:cn.guoyukun.spring.jpa.web.bind.method.annotation.PageableMethodArgumentResolver.java

@Override
public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
        NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {

    PageableDefaults pageableDefaults = getPageableDefaults(parameter);
    //page request
    Pageable defaultPageRequest = getDefaultFromAnnotationOrFallback(pageableDefaults);

    String pageableNamePrefix = getPagePrefix(parameter);
    String sortNamePrefix = getSortPrefix(parameter);
    Map<String, String[]> pageableMap = getPrefixParameterMap(pageableNamePrefix, webRequest, true);
    Map<String, String[]> sortMap = getPrefixParameterMap(sortNamePrefix, webRequest, false);

    Sort sort = getSort(sortNamePrefix, sortMap, defaultPageRequest, webRequest);
    if (pageableMap.size() == 0) {
        return new PageRequest(defaultPageRequest.getPageNumber(), defaultPageRequest.getPageSize(),
                sort == null ? defaultPageRequest.getSort() : sort);
    }//  ww w.ja v a  2s.co  m

    int pn = getPn(pageableMap, defaultPageRequest);
    int pageSize = getPageSize(pageableMap, defaultPageRequest);

    return new PageRequest(pn - 1, pageSize, sort);

}

From source file:cn.edu.zjnu.acm.judge.mapper.BestSubmissionsBuilder.java

public static String bestSubmissions(@Param("problemId") long problemId, @Param("pageable") Pageable pageable) {
    Set<String> dejaVu = new TreeSet<>(String.CASE_INSENSITIVE_ORDER);
    Sort sort = Optional.ofNullable(pageable.getSort()).map(s -> s.and(DEFAULT_SORT)).orElse(DEFAULT_SORT);
    Sort.Order[] orders = StreamSupport.stream(sort.spliterator(), false)
            .filter(order -> ALLOW_COLUMNS.contains(order.getProperty()) && dejaVu.add(order.getProperty()))
            .toArray(Sort.Order[]::new);
    final int length = orders.length;
    log.debug("{}", Arrays.asList(orders));

    StringBuilder sb = new StringBuilder(
            "select " + SubmissionMapper.LIST_COLUMNS + " from solution s where problem_id=").append(problemId)
                    .append(" and score=100 ");
    for (int i = length - 1; i >= 0; --i) {
        sb.append("and(user_id");
        for (int j = 0; j <= i; ++j) {
            sb.append(',').append(orders[j].getProperty());
        }// w w w  .j a v  a 2s . c o m
        sb.append(")in(select user_id");
        for (int j = 0; j < i; ++j) {
            sb.append(',').append(orders[j].getProperty());
        }
        sb.append(',').append(orders[i].isAscending() ? "min" : "max").append("(")
                .append(orders[i].getProperty()).append(")").append(orders[i].getProperty())
                .append(" from solution where problem_id=").append(problemId).append(" and score=100 ");
    }
    for (int i = 0; i < length; ++i) {
        sb.append("group by user_id)");
    }
    if (length > 0) {
        sb.append(" order by ");
        for (int i = 0; i < length; ++i) {
            if (i > 0) {
                sb.append(",");
            }
            sb.append(orders[i].getProperty());
            if (!orders[i].isAscending()) {
                sb.append(" desc");
            }
        }
    }
    return sb.append(" limit ").append(pageable.getOffset()).append(",").append(pageable.getPageSize())
            .toString();
}

From source file:org.ngrinder.perftest.controller.PerfTestController.java

/**
 * Get the perf test lists.// w  ww .j  a  v a 2 s  .  co m
 *
 * @param user        user
 * @param query       query string to search the perf test
 * @param tag         tag
 * @param queryFilter "F" means get only finished, "S" means get only scheduled tests.
 * @param pageable    page
 * @param model       modelMap
 * @return perftest/list
 */
@RequestMapping({ "/list", "/", "" })
public String getAll(User user, @RequestParam(required = false) String query,
        @RequestParam(required = false) String tag, @RequestParam(required = false) String queryFilter,
        @PageableDefaults Pageable pageable, ModelMap model) {
    pageable = new PageRequest(pageable.getPageNumber(), pageable.getPageSize(),
            defaultIfNull(pageable.getSort(), new Sort(Direction.DESC, "lastModifiedDate")));
    Page<PerfTest> tests = perfTestService.getPagedAll(user, query, tag, queryFilter, pageable);
    annotateDateMarker(tests);
    model.addAttribute("tag", tag);
    model.addAttribute("availTags", tagService.getAllTagStrings(user, StringUtils.EMPTY));
    model.addAttribute("testListPage", tests);
    model.addAttribute("queryFilter", queryFilter);
    model.addAttribute("query", query);
    putPageIntoModelMap(model, pageable);
    return "perftest/list";
}

From source file:am.ik.categolj2.domain.repository.entry.EntryRepositoryImpl.java

Page<Entry> searchTemplate(Pageable pageable,
        Function<QueryBuilder, org.apache.lucene.search.Query> queryCreator) {
    try {//from ww  w.ja  v  a  2 s. com
        creatingIndex.get();
    } catch (InterruptedException e) {
        logger.warn("Interrupted!", e);
        Thread.currentThread().interrupt();
    } catch (ExecutionException e) {
        logger.error("Index creation failed!!", e);
    }
    FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager);
    QueryBuilder queryBuilder = fullTextEntityManager.getSearchFactory().buildQueryBuilder()
            .forEntity(Entry.class).get();

    org.apache.lucene.search.Query query = queryCreator.apply(queryBuilder);
    org.apache.lucene.search.Sort sort = new Sort(
            new SortField("lastModifiedDate", SortField.Type.STRING_VAL, true));
    Query jpaQuery = fullTextEntityManager.createFullTextQuery(query, Entry.class).setSort(sort)
            .setFirstResult(pageable.getOffset()).setMaxResults(pageable.getPageSize());
    int count = fullTextEntityManager.createFullTextQuery(query, Entry.class).getResultSize();
    @SuppressWarnings("unchecked")
    List<Entry> content = jpaQuery.getResultList();
    return new PageImpl<>(content, pageable, count);
}

From source file:de.hska.ld.content.persistence.repository.custom.impl.DocumentRepositoryImpl.java

@Override
@Transactional/*w ww . j  a  v a2s .  co  m*/
@SuppressWarnings("unchecked")
public Page<Document> searchDocumentByTitleOrDescription(String searchTerm, Pageable pageable) {

    FullTextEntityManager fullTextEntityManager = org.hibernate.search.jpa.Search.getFullTextEntityManager(em);

    // create native Lucene query unsing the query DSL
    // alternatively you can write the Lucene query using the Lucene query parser
    // or the Lucene programmatic API. The Hibernate Search DSL is recommended though
    QueryBuilder searchQb = fullTextEntityManager.getSearchFactory().buildQueryBuilder()
            .forEntity(Document.class).get();
    org.apache.lucene.search.Query luceneQuery = searchQb.phrase().onField("title").andField("description")
            //.onFields("title", "description")
            .sentence(searchTerm)
            //.matching(searchTerm)
            .createQuery();

    // wrap Lucene query in a javax.persistence.Query
    javax.persistence.Query jpaQuery = fullTextEntityManager.createFullTextQuery(luceneQuery, Document.class);

    long total = jpaQuery.getResultList().size();

    jpaQuery.setMaxResults(pageable.getPageSize());
    jpaQuery.setFirstResult(pageable.getOffset());

    // execute search
    List result = jpaQuery.getResultList();

    return new PageImpl<Document>(result, pageable, total);
}

From source file:com.mobileman.kuravis.core.services.entity.impl.AbstractEntityServiceImpl.java

@Override
public List<DBObject> findAllByQuery(String entityName, DBObject query, Pageable page) {

    if (query.containsField(EntityUtils.NAME)) {
        String name = (String) query.get(EntityUtils.NAME);
        query.put(EntityUtils.NAME,//from ww  w .  ja  v  a2  s  . co  m
                new BasicDBObject("$regex", "^" + name.toLowerCase() + "$").append("$options", "i"));
    }

    DBCursor cursor = null;
    if (page.getSort() != null) {
        cursor = getCollection(entityName).find(query).sort(createSort(page)).skip(page.getOffset())
                .limit(page.getPageSize());
    } else {
        cursor = getCollection(entityName).find(query).skip(page.getOffset()).limit(page.getPageSize());
    }

    List<DBObject> result = cursor.toArray();
    return result;
}