Java Code Examples for org.springframework.data.domain.Page#getSort()

@Override
protected void doProcess(ITemplateContext context, IProcessableElementTag tag, AttributeName attributeName,
        String attributeValue, IElementTagStructureHandler structureHandler) {

    String attrValue = String.valueOf(Expressions.evaluate(context, attributeValue)).trim();
    Page<?> page = PageUtils.findPage(context);
    String url = PageUtils.createSortUrl(context, attrValue, getForcedDirection());

    // Append class to the element if sorted by this field
    Sort sort = page.getSort();
    boolean isSorted = sort != null && sort.getOrderFor(attrValue) != null;
    String clas = isSorted
            ? SORTED_PREFIX.concat(sort.getOrderFor(attrValue).getDirection().toString().toLowerCase())
            : EMPTY;

    structureHandler.setAttribute(HREF, url);
    String currentClass = tag.getAttributeValue(CLASS);
    structureHandler.setAttribute(CLASS, Strings.concat(currentClass, BLANK, clas));
}
 

/**
 * Creates an url to sort data by fieldName
 * 
 * @param context execution context
 * @param fieldName field name to sort
 * @param forcedDir optional, if specified then only this sort direction will be allowed
 * @return sort URL
 */
public static String createSortUrl(final ITemplateContext context, final String fieldName, final Direction forcedDir) {
    // Params can be prefixed to manage multiple pagination on the same page
    final String prefix = getParamPrefix(context);
    final Collection<String> excludedParams = Arrays
            .asList(new String[] { prefix.concat(SORT), prefix.concat(PAGE) });
    final String baseUrl = buildBaseUrl(context, excludedParams);

    final StringBuilder sortParam = new StringBuilder();
    final Page<?> page = findPage(context);
    final Sort sort = page.getSort();
    final boolean hasPreviousOrder = sort != null && sort.getOrderFor(fieldName) != null;
    if (forcedDir != null) {
        sortParam.append(fieldName).append(COMMA).append(forcedDir.toString().toLowerCase());
    } else if (hasPreviousOrder) {
        // Sort parameters exists for this field, modify direction
        Order previousOrder = sort.getOrderFor(fieldName);
        Direction dir = previousOrder.isAscending() ? Direction.DESC : Direction.ASC;
        sortParam.append(fieldName).append(COMMA).append(dir.toString().toLowerCase());
    } else {
        sortParam.append(fieldName);
    }

    return buildUrl(baseUrl, context).append(SORT).append(EQ).append(sortParam).toString();
}
 

public void setStat(Page page, List<T> list) {
    this.number = page.getNumber();
    this.size = page.getSize();
    this.sort = page.getSort();
    this.totalPages = page.getTotalPages();
    this.totalElements = page.getTotalElements();
    this.content = list;
}
 

public final Page<Target> convertToPage(Page<Source> sourcePage, Map<String, Object> parameters) {
    final List<Target> targets = new ArrayList<>(sourcePage.getContent().size());
    for (Source source : sourcePage) {
        targets.add(convert(source, parameters));
    }

    final Pageable pageable = new PageRequest(sourcePage.getNumber(), sourcePage.getSize(), sourcePage.getSort());

    return new PageImpl<>(targets, pageable, sourcePage.getTotalElements());
}
 

public PlatformPageImpl(Page page) {
    super(page.getContent(),
            new PageRequest(page.getNumber(), page.getSize(), page.getSort()),
            page.getTotalElements());
    this.number = page.getNumber();
    this.size = page.getSize();
    this.totalPages = page.getTotalPages();
    this.numberOfElements = page.getNumberOfElements();
    this.totalElements = page.getTotalElements();
    this.first = page.isFirst();
    this.last = page.isLast();
    this.content = page.getContent();
    this.sort = page.getSort();
}
 

public static <S, T> Page<T> mapPage(Page<S> source, Class<T> targetClass) {
    List<S> sourceList = source.getContent();

    List<T> list = new ArrayList<>();
    for (int i = 0; i < sourceList.size(); i++) {
        T target = INSTANCE.map(sourceList.get(i), targetClass);
        list.add(target);
    }

    return new PageImpl<>(list, new PageRequest(source.getNumber(), source.getSize(), source.getSort()),
            source.getTotalElements());
}
 

private Page<LifecylceDTO> mapToDto(final Page<LifecycleEntity> lifecycleEntities) {
    final List<LifecylceDTO> lifecylceDTOList = newArrayList();

    for (final LifecycleEntity lifecycleEntity : lifecycleEntities) {
        final LifecylceDTO lifecylceDTO = new LifecylceDTO();

        lifecylceDTO.setApplication(lifecycleEntity.getApplicationEntity().getName());
        lifecylceDTO.setCreated(lifecycleEntity.getCreated());
        lifecylceDTO.setEventDate(lifecycleEntity.getEventDate());
        lifecylceDTO.setEventType(lifecycleEntity.getEventType());
        lifecylceDTO.setImageID(lifecycleEntity.getImageId());
        lifecylceDTO.setImageName(lifecycleEntity.getImageName());
        lifecylceDTO.setInstanceBootTime(lifecycleEntity.getInstanceBootTime());
        lifecylceDTO.setInstanceId(lifecycleEntity.getInstanceId());
        lifecylceDTO.setRegion(lifecycleEntity.getRegion());
        lifecylceDTO.setVersion(lifecycleEntity.getVersionEntity().getName());

        lifecylceDTOList.add(lifecylceDTO);
    }
    final PageRequest currentPageRequest = new PageRequest(
            lifecycleEntities.getNumber(),
            lifecycleEntities.getSize(),
            lifecycleEntities.getSort());


    return new PageImpl<>(lifecylceDTOList, currentPageRequest, lifecycleEntities.getTotalElements());
}
 

private Page<Violation> mapBackendToFrontendViolations(final Page<ViolationEntity> backendViolations) {
    final PageRequest currentPageRequest = new PageRequest(
            backendViolations.getNumber(),
            backendViolations.getSize(),
            backendViolations.getSort());
    return new PageImpl<>(
            backendViolations.getContent().stream().map(entityToDto::convert).collect(toList()),
            currentPageRequest,
            backendViolations.getTotalElements());
}