#155 | The infrastructure for Pagination, Order, and Filter has been created.

src/main/java/org/gelecekbilimde/scienceplatform/common/model/BaseFilter.java

@@ -0,0 +1,10 @@
+package org.gelecekbilimde.scienceplatform.common.model;
+
+import org.springframework.data.jpa.domain.Specification;
+
+public interface BaseFilter {
+
+	@SuppressWarnings({"java:S3740", "rawtypes"})
+	Specification toSpecification();
+
+}

src/main/java/org/gelecekbilimde/scienceplatform/common/model/BasePage.java

@@ -0,0 +1,65 @@
+package org.gelecekbilimde.scienceplatform.common.model;
+
+import lombok.Builder;
+import lombok.Getter;
+import lombok.Setter;
+import org.springframework.data.domain.Page;
+
+import java.util.List;
+
+@Getter
+@Setter
+@Builder
+public class BasePage<R> {
+
+	private List<R> content;
+
+	private Integer pageNumber;
+
+	private Integer pageSize;
+
+	private Integer totalPageCount;
+
+	private Long totalElementCount;
+
+	private List<BaseSort.BaseOrder> orderedBy;
+
+	private BaseFilter filteredBy;
+
+
+	public static <E, C> BasePage<C> of(final Page<E> pageableEntities,
+										final List<C> content) {
+
+		final var responseBuilder = BasePage.<C>builder()
+			.content(content)
+			.pageNumber(pageableEntities.getNumber() + 1)
+			.pageSize(content.size())
+			.totalPageCount(pageableEntities.getTotalPages())
+			.totalElementCount(pageableEntities.getTotalElements());
+
+		if (pageableEntities.getSort().isSorted()) {
+			responseBuilder.orderedBy(BaseSort.of(pageableEntities.getSort()).getOrders());
+		}
+
+		return responseBuilder.build();
+	}
+
+	public static <E, C> BasePage<C> of(final BaseFilter filter,
+										final Page<E> pageableEntities,
+										final List<C> content) {
+
+		final var responseBuilder = BasePage.<C>builder()
+			.content(content)
+			.pageNumber(pageableEntities.getNumber() + 1)
+			.pageSize(content.size())
+			.totalPageCount(pageableEntities.getTotalPages())
+			.totalElementCount(pageableEntities.getTotalElements())
+			.filteredBy(filter);
+
+		if (pageableEntities.getSort().isSorted()) {
+			responseBuilder.orderedBy(BaseSort.of(pageableEntities.getSort()).getOrders());
+		}
+
+		return responseBuilder.build();
+	}
+}

src/main/java/org/gelecekbilimde/scienceplatform/common/model/BasePageable.java

@@ -0,0 +1,45 @@
+package org.gelecekbilimde.scienceplatform.common.model;
+
+
+import com.nimbusds.oauth2.sdk.util.CollectionUtils;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import lombok.experimental.SuperBuilder;
+import org.hibernate.validator.constraints.Range;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+
+@Getter
+@Setter
+@SuperBuilder
+@AllArgsConstructor
+@NoArgsConstructor
+public class BasePageable extends BaseSort {
+
+
+	@Range(min = 1, max = 99999999)
+	private int page;
+
+
+	@Range(min = 10, max = 10)
+	private int pageSize;
+
+
+	public Pageable toPageable() {
+
+		if (CollectionUtils.isNotEmpty(this.getOrders())) {
+			return PageRequest.of(
+				this.page - 1,
+				this.pageSize,
+				this.toSort()
+			);
+		}
+
+		return PageRequest.of(
+			this.page - 1,
+			this.pageSize
+		);
+	}
+}

src/main/java/org/gelecekbilimde/scienceplatform/common/model/BaseSort.java

@@ -0,0 +1,68 @@
+package org.gelecekbilimde.scienceplatform.common.model;
+
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import lombok.*;
+import lombok.experimental.SuperBuilder;
+import org.springframework.data.domain.Sort;
+
+import java.util.List;
+
+
+@Getter
+@Setter
+@SuperBuilder
+@NoArgsConstructor
+@AllArgsConstructor
+public class BaseSort {
+
+	@Valid
+	protected List<BaseOrder> orders;
+
+	@Getter
+	@Setter
+	@Builder
+	@AllArgsConstructor
+	@NoArgsConstructor
+	public static class BaseOrder {
+
+		@NotBlank
+		private String property;
+
+		@NotNull
+		private Direction direction;
+	}
+
+	public enum Direction {
+
+		ASC,
+		DESC;
+
+		public Sort.Direction toDirection() {
+			return Sort.Direction.valueOf(this.name());
+		}
+	}
+
+	protected org.springframework.data.domain.Sort toSort() {
+		return org.springframework.data.domain.Sort.by(
+			this.orders.stream()
+				.map(order -> Sort.Order.by(order.getProperty()).with(order.getDirection().toDirection()))
+				.toList()
+		);
+	}
+
+	public static BaseSort of(final org.springframework.data.domain.Sort sorts) {
+
+		List<BaseOrder> orders = sorts.stream()
+			.map(order -> BaseOrder.builder()
+				.property(order.getProperty())
+				.direction(Direction.valueOf(order.getDirection().toString()))
+				.build())
+			.toList();
+
+		return BaseSort.builder()
+			.orders(orders)
+			.build();
+	}
+}

src/main/java/org/gelecekbilimde/scienceplatform/common/model/request/PagingRequest.java

@@ -1,32 +1,56 @@
 package org.gelecekbilimde.scienceplatform.common.model.request;
 
+import jakarta.validation.Valid;
 import jakarta.validation.constraints.NotNull;
-import lombok.Data;
-import org.hibernate.validator.constraints.Range;
-import org.springframework.data.domain.PageRequest;
-import org.springframework.data.domain.Pageable;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import org.apache.commons.lang3.StringUtils;
+import org.gelecekbilimde.scienceplatform.common.model.BasePageable;
+import org.gelecekbilimde.scienceplatform.common.model.BaseSort;
+import org.springframework.util.CollectionUtils;
 
+import java.util.List;
+import java.util.Set;
 
-@Data
-public class PagingRequest {
 
-	@NotNull
-	@Range(min = 1)
-	public Integer page = 1;
+@Getter
+@Setter
+@NoArgsConstructor
+public abstract class PagingRequest {
 
+	@Valid
 	@NotNull
-	@Range(min = 2, max = 100)
-	public Integer pageSize = 20;
+	protected BasePageable pageable;
 
+	public abstract boolean isOrderPropertyAccepted();
 
-	public Pageable toPageable() {
-		return PageRequest.of(
-			this.getPage(),
-			this.getPageSize()
-		);
-	}
+	@SuppressWarnings("all")
+	public boolean isPropertyAccepted(final Set<String> acceptedProperties) {
+
+		if (this.pageable == null || CollectionUtils.isEmpty(this.pageable.getOrders())) {
+			return true;
+		}
+
+		for (BaseSort.BaseOrder order : this.pageable.getOrders()) {
+			if (StringUtils.isBlank(order.getProperty()) || order.getDirection() == null) {
+				return true;
+			}
+		}
+
+		final List<BaseSort.BaseOrder> orders = this.pageable.getOrders();
+		if (CollectionUtils.isEmpty(orders)) {
+			return true;
+		}
+
+		final boolean isAnyDirectionEmpty = orders.stream().anyMatch(order -> order.getDirection() == null);
+		final boolean isAnyPropertyEmpty = orders.stream().anyMatch(order -> order.getProperty() == null);
+		if (isAnyDirectionEmpty || isAnyPropertyEmpty) {
+			return true;
+		}
 
-	public Integer getPage() {
-		return this.page - 1;
+		return orders.stream()
+			.map(BaseSort.BaseOrder::getProperty)
+			.allMatch(acceptedProperties::contains);
 	}
 }

src/main/java/org/gelecekbilimde/scienceplatform/common/model/response/PagingResponse.java

@@ -2,7 +2,9 @@
 
 import lombok.Builder;
 import lombok.Getter;
-import org.gelecekbilimde.scienceplatform.common.model.Paging;
+import org.gelecekbilimde.scienceplatform.common.model.BaseFilter;
+import org.gelecekbilimde.scienceplatform.common.model.BasePage;
+import org.gelecekbilimde.scienceplatform.common.model.BaseSort;
 
 import java.util.List;
 
@@ -11,20 +13,31 @@
 public class PagingResponse<R> {
 
 	private List<R> content;
+
 	private Integer pageNumber;
+
 	private Integer pageSize;
+
 	private Integer totalPageCount;
+
 	private Long totalElementCount;
 
+	private List<BaseSort.BaseOrder> orderedBy;
 
-	@SuppressWarnings("unused")
+	private BaseFilter filteredBy;
+
+
+	@SuppressWarnings("This method is unused by the application directly but Spring is using it in the background.")
 	public static class PagingResponseBuilder<R> {
-		public <M> PagingResponse.PagingResponseBuilder<R> of(final Paging<M> page) {
+
+		public <M> PagingResponse.PagingResponseBuilder<R> of(final BasePage<M> page) {
 			return PagingResponse.<R>builder()
 				.pageNumber(page.getPageNumber())
 				.pageSize(page.getPageSize())
 				.totalPageCount(page.getTotalPageCount())
-				.totalElementCount(page.getTotalElementCount());
+				.totalElementCount(page.getTotalElementCount())
+				.orderedBy(page.getOrderedBy())
+				.filteredBy(page.getFilteredBy());
 		}
 	}
 }

src/main/java/org/gelecekbilimde/scienceplatform/post/controller/AdminController.java

@@ -2,7 +2,7 @@
 
 import jakarta.validation.Valid;
 import lombok.RequiredArgsConstructor;
-import org.gelecekbilimde.scienceplatform.common.model.Paging;
+import org.gelecekbilimde.scienceplatform.common.model.BasePage;
 import org.gelecekbilimde.scienceplatform.common.model.response.PagingResponse;
 import org.gelecekbilimde.scienceplatform.common.model.response.SuccessResponse;
 import org.gelecekbilimde.scienceplatform.post.model.Post;
@@ -34,7 +34,7 @@ class AdminController {
 	@GetMapping
 	SuccessResponse<PagingResponse<AdminPostResponse>> getPostList(@Valid AdminPostListRequest request) {
 
-		final Paging<Post> postList = postService.getPostListAdmin(request);
+		final BasePage<Post> postList = postService.getPostListAdmin(request);
 
 		final PagingResponse<AdminPostResponse> pageOfAdminUsersResponse = PagingResponse.<AdminPostResponse>builder()
 			.of(postList)

src/main/java/org/gelecekbilimde/scienceplatform/post/model/AdminPostFilter.java

@@ -0,0 +1,27 @@
+package org.gelecekbilimde.scienceplatform.post.model;
+
+import lombok.Getter;
+import lombok.Setter;
+import org.gelecekbilimde.scienceplatform.common.model.BaseFilter;
+import org.gelecekbilimde.scienceplatform.post.model.entity.PostEntity;
+import org.springframework.data.jpa.domain.Specification;
+
+
+@Getter
+@Setter
+public class AdminPostFilter implements BaseFilter {
+
+	private Boolean isActive;
+
+	@Override
+	public Specification<PostEntity> toSpecification() {
+		Specification<PostEntity> specification = Specification.where(null);
+
+		if (isActive != null) {
+			specification = specification.and((root, query, criteriaBuilder) ->
+				criteriaBuilder.equal(root.get("isActive"), isActive)
+			);
+		}
+		return specification;
+	}
+}