Untitled

// Custom Filter
public class CustomFilter {
    private Predicate<TransactionEntity> condition;

    public CustomFilter(Predicate<TransactionEntity> condition) {
        this.condition = condition;
    }

    public Predicate<TransactionEntity> getCondition(){
        return this.condition;
    }
}

// Transaction Manager

public class TransactionManager {
    TransactionRepository repository;
    PaginationStrategy strategy;

    public TransactionManager() {
        this.repository = new TransactionRepository();
        this.strategy = new CursorPagination();
    }

    public List<TransactionEntity> filterTxns(List<TransactionEntity> txns, List<CustomFilter> filters){
        Predicate<TransactionEntity> combinedPredicate = filters.stream().map(CustomFilter::getCondition).reduce(x -> true, Predicate::and);
        return txns.stream().filter(combinedPredicate).collect(Collectors.toList());
    }

    public void createTxns(int num){
        for(int i = 0;i<num;i++){
            int random = new Random().nextInt(0,10);
            int amount = new Random().nextInt(1, 100);
            LocalDateTime time = LocalDateTime.now().minusDays(random);
            repository.createTransaction(new TransactionEntity(i, time, random,  amount));
        }
    }

    public List<TransactionEntity> getAllTxns(){
        return repository.getAllTxns();
    }

    public List<PaginationResponse> getPaginatedResponse(List<TransactionEntity> txns){
        PaginationRequest request = new PaginationRequest(10, 0, null);
        List<PaginationResponse> responses = new ArrayList<>();
        PaginationResponse response = strategy.paginate(txns, request);
        responses.add(response);
        while (response.isHasNextPage()){
//            int newOffset = request.getOffset() + 10;
//            request.setOffset(newOffset);
            int newCursor = response.getNextCursor();
            request.setCursor(newCursor);

            response = strategy.paginate(txns, request);
            responses.add(response);
        }

        for(PaginationResponse res: responses){
            System.out.println(res.getData());
        }

        return responses;
    }
}


// Repository

public class TransactionRepository {
    private HashMap<Integer, TransactionEntity> transactionDataBase;

    public TransactionRepository(){
        this.transactionDataBase = new HashMap<>();
    }

    public void createTransaction(TransactionEntity entity){
        this.transactionDataBase.put(entity.getId(), entity);
    }

    public void deleteTransaction(int id){
        this.transactionDataBase.remove(id);
    }

    public TransactionEntity getTransaction(int id){
        return this.transactionDataBase.getOrDefault(id, null);
    }

    public List<TransactionEntity> getAllTxns(){
        return this.transactionDataBase.values().stream().toList();
    }
}

// Cursor Pagination

public class CursorPagination implements PaginationStrategy {
    @Override
    public PaginationResponse paginate(List<TransactionEntity> txns, PaginationRequest request) {
        int cursor = request.getCursor() == null ? 0 : request.getCursor();
        int limit = request.getLimit() == null ? txns.size(): request.getLimit();
        List<TransactionEntity> sortedTxn = txns.stream().sorted(Comparator.comparing(TransactionEntity::getAmount)).toList();
        List<TransactionEntity> data = sortedTxn.stream().filter( txn -> txn.getAmount() > cursor).limit(limit).toList();

        boolean hasNext = data.getLast().getId() != sortedTxn.getLast().getId();
        Integer nextCursor = null;
        if(hasNext){
            nextCursor = data.getLast().getAmount();
        }
        System.out.println("\nNext Cursor: " + nextCursor);
        return new PaginationResponse(hasNext, data, nextCursor);
    }



}


// Limit pagination

public class LimitPS implements PaginationStrategy {
    @Override
    public PaginationResponse paginate(List<TransactionEntity> txns, PaginationRequest request) {
        int limit = request.getLimit() == null ? txns.size() : request.getLimit();
        int offset = request.getOffset() == null ? 0 : request.getOffset();

        List<TransactionEntity> data = txns.stream().skip(offset).limit(limit).toList();
        boolean hasNextPage = data.size() == limit;
        return new PaginationResponse(hasNextPage, data, null);
    }
}


// Pagination Request

public class PaginationRequest {
    private Integer limit;
    private Integer offset;
    private Integer cursor;

    public PaginationRequest(Integer limit, Integer offset, Integer cursor) {
        this.limit = limit;
        this.offset = offset;
        this.cursor = cursor;
    }

    public Integer getLimit() {
        return limit;
    }

    public void setLimit(int limit) {
        this.limit = limit;
    }

    public Integer getOffset() {
        return offset;
    }

    public void setOffset(int offset) {
        this.offset = offset;
    }

    public Integer getCursor() {
        return cursor;
    }

    public void setCursor(int cursor) {
        this.cursor = cursor;
    }
}


// Paginatio Response

public class PaginationResponse {
    private boolean hasNextPage;
    private List<TransactionEntity> data;
    private Integer nextCursor;

    public Integer getNextCursor() {
        return nextCursor;
    }

    public List<TransactionEntity> getData() {
        return data;
    }

    public boolean isHasNextPage() {
        return hasNextPage;
    }

    public PaginationResponse(boolean hasNextPage, List<TransactionEntity> data, Integer nextCursor) {
        this.hasNextPage = hasNextPage;
        this.data = data;
        this.nextCursor = nextCursor;
    }
}