pagination - spring -web -flux

package com.synerise.manager.definitions;

import lombok.extern.slf4j.Slf4j;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.util.StringUtils;
import org.springframework.web.reactive.function.server.ServerRequest;
import reactor.core.publisher.Mono;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.function.Function;
import java.util.stream.Collectors;

import static org.springframework.data.domain.Sort.*;

@Slf4j
public class PaginationHandler {

    private static final String SORT_DELIMITER = ",";
    private static final String PAGE_QUERY_PARAM_KEY = "page";
    private static final String SIZE_QUERY_PARAM_KEY = "size";
    private static final String SORT_QUERY_PARAM_KEY = "sort";

    public static Mono<Pageable> handle(ServerRequest serverRequest) {
        return handle().apply(serverRequest);
    }

    public static Function<ServerRequest, Mono<Pageable>> handle() {
        return serverRequest -> {
            Mono<Integer> page = getQueryParamByGivenKey(serverRequest, PAGE_QUERY_PARAM_KEY);
            Mono<Integer> size = getQueryParamByGivenKey(serverRequest, SIZE_QUERY_PARAM_KEY);
            Mono<List<String>> sort = Mono.defer(() -> Mono.just(serverRequest.queryParams().get(SORT_QUERY_PARAM_KEY)));
            return Mono.zip(page, size, sort)
                    .map(pagination -> {
                        Integer pageNumber = pagination.getT1();
                        Integer sizeNumber = pagination.getT2();
                        List<Order> orders = getOrders(pagination.getT3());
                        return (Pageable) PageRequest.of(pageNumber, sizeNumber, orders.isEmpty() ? unsorted()
                                : by(orders));
                    })
                    .doOnSuccess(pageable -> log.info("Applying pagination {}", pageable))
                    .doOnError(throwable -> log.error("Could not apply pagination falling back to unpaged", throwable))
                    .onErrorReturn(Pageable.unpaged());
        };
    }

    private static Mono<Integer> getQueryParamByGivenKey(ServerRequest serverRequest, String queryParamKey) {
        return Mono.defer(() -> Mono.justOrEmpty(serverRequest.queryParam(queryParamKey)
                .map(Integer::valueOf)));
    }

    private static List<Order> getOrders(List<String> sort) {
        return sort.stream().flatMap(value -> {
            final List<Order> allOrders = new ArrayList<>();
            final String[] elements = value.split(SORT_DELIMITER);
            final Optional<Sort.Direction> direction = elements.length == 0 ? Optional.empty()
                    : Direction.fromOptionalString(elements[elements.length - 1]);

            int lastIndex = direction.map(it -> elements.length - 1).orElseGet(() -> elements.length);

            for (int i = 0; i < lastIndex; i++) {
                toOrder(elements[i], direction).ifPresent(allOrders::add);
            }
            return allOrders.stream();
        }).collect(Collectors.toList());
    }

    private static Optional<Order> toOrder(String property, Optional<Direction> direction) {

        if (!StringUtils.hasText(property)) {
            return Optional.empty();
        }

        return Optional.of(direction.map(it -> new Order(it, property)).orElseGet(() -> Order.by(property)));
    }
}