Updated code

src/main/java/net/gepafin/tendermanagement/dao/ApplicationAmendmentRequestDao.java

@@ -2,8 +2,10 @@ package net.gepafin.tendermanagement.dao;
 
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import jakarta.persistence.criteria.CriteriaBuilder;
 import jakarta.persistence.criteria.Join;
 import jakarta.persistence.criteria.Predicate;
+import jakarta.persistence.criteria.Root;
 import jakarta.servlet.http.HttpServletRequest;
 import net.gepafin.tendermanagement.config.Translator;
 import net.gepafin.tendermanagement.constants.GepafinConstant;
@@ -12,6 +14,7 @@ import net.gepafin.tendermanagement.entities.SystemEmailTemplatesEntity.SystemEm
 import net.gepafin.tendermanagement.enums.*;
 import net.gepafin.tendermanagement.model.request.*;
 import net.gepafin.tendermanagement.model.response.*;
+import net.gepafin.tendermanagement.model.util.SortBy;
 import net.gepafin.tendermanagement.repositories.*;
 import net.gepafin.tendermanagement.service.*;
 import net.gepafin.tendermanagement.util.DateTimeUtil;
@@ -25,6 +28,8 @@ import net.gepafin.tendermanagement.web.rest.api.errors.Status;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
 import org.springframework.data.jpa.domain.Specification;
 import org.springframework.stereotype.Component;
 
@@ -37,6 +42,7 @@ import java.util.stream.Collectors;
 import static java.time.temporal.ChronoUnit.DAYS;
 import static net.gepafin.tendermanagement.util.Utils.log;
 import static net.gepafin.tendermanagement.util.Utils.setIfUpdated;
+import static org.apache.commons.lang3.StringUtils.isEmpty;
 
 @Component
 public class ApplicationAmendmentRequestDao {
@@ -1183,4 +1189,118 @@ public class ApplicationAmendmentRequestDao {
 		documentService.deleteFile(documentId);
 	}
 
+    public PageableResponseBean<List<ApplicationAmendmentRequestResponse>> getApplicationAmendmentByPaginnation(Long userId, ApplicationAmendmentPaginationRequestBean applicationAmendmentPaginationRequestBean) {
+        Integer pageNo = null;
+        Integer pageLimit = null;
+        if (applicationAmendmentPaginationRequestBean.getGlobalFilters() != null) {
+            pageNo = applicationAmendmentPaginationRequestBean.getGlobalFilters().getPage();
+            pageLimit = applicationAmendmentPaginationRequestBean.getGlobalFilters().getLimit();
+        }
+        if (pageLimit == null || pageLimit <= 0) {
+            pageLimit = GepafinConstant.DEFAULT_PAGE_LIMIT;
+        }
+        if (pageNo == null || pageNo <= 0) {
+            pageNo = GepafinConstant.DEFAULT_PAGE;
+        }
+        Specification<ApplicationAmendmentRequestEntity> spec = searchPagination(userId,applicationAmendmentPaginationRequestBean);
+        Page<ApplicationAmendmentRequestEntity> entityPage = applicationAmendmentRequestRepository.findAll(spec, PageRequest.of(pageNo - 1, pageLimit));
+
+
+        List<ApplicationAmendmentRequestResponse> applicationResponses = entityPage.getContent().stream()
+                .map(application -> {
+                    ApplicationAmendmentRequestResponse response = convertEntityToResponse(application,false);
+                    return response;
+                })
+                .collect(Collectors.toList());
+
+
+        PageableResponseBean<List<ApplicationAmendmentRequestResponse>> pageableResponseBean = new PageableResponseBean<>();
+        pageableResponseBean.setBody(applicationResponses);
+        pageableResponseBean.setCurrentPage(entityPage.getNumber() + 1); // Page numbers typically start from 0, so add 1 for user-friendly indexing
+        pageableResponseBean.setTotalPages(entityPage.getTotalPages());
+        pageableResponseBean.setTotalRecords(entityPage.getTotalElements());
+        pageableResponseBean.setPageSize(entityPage.getSize());
+
+        return pageableResponseBean;
+    }
+
+    public Specification<ApplicationAmendmentRequestEntity> searchPagination(Long userId,ApplicationAmendmentPaginationRequestBean applicationAmendmentPaginationRequestBean) {
+        return (root, query, criteriaBuilder) -> {
+
+            List<Predicate> predicates = getPredicates(applicationAmendmentPaginationRequestBean, criteriaBuilder, root,userId);
+            SortBy sortBy = new SortBy(GepafinConstant.CREATED_DATE, true);
+
+            if (applicationAmendmentPaginationRequestBean .getGlobalFilters() != null
+                    && applicationAmendmentPaginationRequestBean.getGlobalFilters().getSortBy() != null &&
+                    applicationAmendmentPaginationRequestBean.getGlobalFilters().getSortBy().getColumnName() != null && Boolean.FALSE.equals(
+                    isEmpty(applicationAmendmentPaginationRequestBean.getGlobalFilters().getSortBy().getColumnName()))) {
+                sortBy.setColumnName(applicationAmendmentPaginationRequestBean.getGlobalFilters().getSortBy().getColumnName());
+                sortBy.setSortDesc(true);
+                if (applicationAmendmentPaginationRequestBean.getGlobalFilters().getSortBy().getSortDesc() != null) {
+                    sortBy.setSortDesc(applicationAmendmentPaginationRequestBean.getGlobalFilters().getSortBy().getSortDesc());
+                }
+            }
+
+            query.orderBy(criteriaBuilder.desc(root.get(sortBy.getColumnName())));
+            if (Boolean.FALSE.equals(sortBy.getSortDesc())) {
+                query.orderBy(criteriaBuilder.asc(root.get(sortBy.getColumnName())));
+            }
+            return query.where(criteriaBuilder.and(predicates.toArray(new Predicate[0]))).getRestriction();
+        };
+    }
+
+
+    private List<Predicate> getPredicates(ApplicationAmendmentPaginationRequestBean amendmentPaginationRequestBean,
+                                          CriteriaBuilder criteriaBuilder, Root<ApplicationAmendmentRequestEntity> root,Long userId) {
+
+        Integer year = null;
+        String search = null;
+        if (amendmentPaginationRequestBean.getGlobalFilters() != null) {
+            year = amendmentPaginationRequestBean.getGlobalFilters().getYear();
+            search = amendmentPaginationRequestBean.getGlobalFilters().getSearch();
+        }
+        List<Predicate> predicates = new ArrayList<>();
+
+        if (year != null && year > 0) {
+            int filterYear = amendmentPaginationRequestBean.getGlobalFilters().getYear();
+
+// Create LocalDateTime boundaries for the start and end of the year
+            LocalDateTime startOfYear = LocalDateTime.of(filterYear, 1, 1, 0, 0);
+            LocalDateTime endOfYear = LocalDateTime.of(filterYear, 12, 31, 23, 59, 59);
+
+// Add the range comparison to filter records within the year
+            predicates.add(criteriaBuilder.between(root.get(GepafinConstant.CREATED_DATE), startOfYear, endOfYear));
+
+        }
+        // Search in `title` and `message` (if search term is provided)
+        if (search != null && !search.isEmpty()) {
+            Predicate notePredicate = criteriaBuilder.like(
+                    criteriaBuilder.upper(root.get(GepafinConstant.NOTE)),
+                    "%" + search.toUpperCase() + "%"
+            );
+            predicates.add(criteriaBuilder.or(notePredicate));
+            Predicate internalNotePredicate = criteriaBuilder.like(
+                    criteriaBuilder.upper(root.get(GepafinConstant.INTERNAL_NOTE)),
+                    "%" + search.toUpperCase() + "%"
+            );
+            predicates.add(criteriaBuilder.or(internalNotePredicate));
+        }
+
+        // Filter by `status` (if status list is provided)
+        if (amendmentPaginationRequestBean.getStatus() != null && !amendmentPaginationRequestBean.getStatus().isEmpty()) {
+            List<String> statusValues = amendmentPaginationRequestBean.getStatus().stream()
+                    .map(ApplicationAmendmentRequestEnum::name) // Convert enum to string
+                    .toList();
+            predicates.add(root.get(GepafinConstant.STATUS).in(statusValues));
+        }
+        if(Boolean.TRUE.equals(validator.checkIsBeneficiary())) {
+            predicates.add(root.get("applicationEvaluationEntity").get("assignedApplicationsEntity").get("application").get("userId").in(userId));
+        }
+        if (Boolean.FALSE.equals(validator.checkIsBeneficiary())) {
+            predicates.add(root.get("applicationEvaluationEntity").get("assignedApplicationsEntity").get("userId").in(userId));
+        }
+
+        return predicates;
+
+    }
 }

src/main/java/net/gepafin/tendermanagement/dao/UserActionDao.java

@@ -2,15 +2,18 @@ package net.gepafin.tendermanagement.dao;
 
 import jakarta.persistence.criteria.CriteriaBuilder;
 import jakarta.persistence.criteria.Predicate;
+import jakarta.persistence.criteria.Root;
 import jakarta.servlet.http.HttpServletRequest;
-import net.gepafin.tendermanagement.entities.RoleActionContextEntity;
-import net.gepafin.tendermanagement.entities.UserActionEntity;
-import net.gepafin.tendermanagement.entities.UserEntity;
+import net.gepafin.tendermanagement.constants.GepafinConstant;
+import net.gepafin.tendermanagement.entities.*;
+import net.gepafin.tendermanagement.enums.ApplicationStatusTypeEnum;
 import net.gepafin.tendermanagement.enums.TimePeriodEnum;
 import net.gepafin.tendermanagement.enums.UserActionContextEnum;
-import net.gepafin.tendermanagement.model.response.ActionContextLabelResponse;
-import net.gepafin.tendermanagement.model.response.SummaryPageResponseBean;
-import net.gepafin.tendermanagement.model.response.UserActionResponseBean;
+import net.gepafin.tendermanagement.enums.UserActionLogsEnum;
+import net.gepafin.tendermanagement.model.request.ApplicationPageableRequestBean;
+import net.gepafin.tendermanagement.model.request.UserActionPaginationRequest;
+import net.gepafin.tendermanagement.model.response.*;
+import net.gepafin.tendermanagement.model.util.SortBy;
 import net.gepafin.tendermanagement.repositories.AssignedApplicationsRepository;
 import net.gepafin.tendermanagement.repositories.RoleActionContextRepository;
 import net.gepafin.tendermanagement.repositories.UserActionsRepository;
@@ -23,9 +26,12 @@ import org.springframework.data.jpa.domain.Specification;
 import org.springframework.stereotype.Component;
 
 import java.time.LocalDateTime;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.stream.Collectors;
 
+import static org.apache.commons.lang3.StringUtils.isEmpty;
+
 @Component
 public class UserActionDao {
 
@@ -47,10 +53,11 @@ public class UserActionDao {
 
         List<UserActionEntity> userActions = getFilterUserActions(userEntity.getId(),timeFilter,actionContext);
 
-        return createSummaryPageResponse(userEntity,numberOfLoginAttempts,applicationsProcessed,userActions);
+        return null;
+//                createSummaryPageResponse(userEntity,numberOfLoginAttempts,applicationsProcessed,userActions);
     }
 
-    public SummaryPageResponseBean createSummaryPageResponse(UserEntity user, Long numberOfLoginAttempts, Long applicationsProcessed, List<UserActionEntity> userActions){
+    public SummaryPageResponseBean createSummaryPageResponse(UserEntity user, Long numberOfLoginAttempts, Long applicationsProcessed,PageableResponseBean<List<UserActionResponseBean>> userActions){
         SummaryPageResponseBean response = new SummaryPageResponseBean();
         response.setRole(user.getRoleEntity().getRoleName());
         response.setLastLogin(user.getLastLogin());
@@ -59,9 +66,7 @@ public class UserActionDao {
         response.setEmail(user.getEmail());
         response.setNumberOfLoginAttempts(numberOfLoginAttempts);
         response.setApplicationsProcessed(applicationsProcessed);
-
-        List<UserActionResponseBean> userAction = convertEntityToResponse(userActions);
-        response.setUserActions(userAction);
+        response.setUserActions(userActions);
         return response;
     }
 
@@ -157,4 +162,138 @@ public class UserActionDao {
             return responseBean;
         }).collect(Collectors.toList());
     }
+    public SummaryPageResponseBean getUserActionByPagination(UserEntity user, UserActionPaginationRequest userActionPaginationRequest) {
+        Integer pageNo = null;
+        Integer pageLimit = null;
+        if (userActionPaginationRequest.getGlobalFilters() != null) {
+            pageNo = userActionPaginationRequest.getGlobalFilters().getPage();
+            pageLimit = userActionPaginationRequest.getGlobalFilters().getLimit();
+        }
+        if (pageLimit == null || pageLimit <= 0) {
+            pageLimit = GepafinConstant.DEFAULT_PAGE_LIMIT;
+        }
+        if (pageNo == null || pageNo <= 0) {
+            pageNo = GepafinConstant.DEFAULT_PAGE;
+        }
+        Specification<UserActionEntity> spec = search(userActionPaginationRequest,user);
+        Page<UserActionEntity> entityPage = userActionsRepository.findAll(spec, PageRequest.of(pageNo - 1, pageLimit));
+        // Prepare the response
+        Long numberOfLoginAttempts = userActionsRepository.countUserLoginAttempts(user.getId());
+        Long applicationsProcessed = assignedApplicationsRepository.countAssignedApplicationsByUserId(user.getId());
+
+
+        List<UserActionResponseBean> userActionResponseBeans = convertEntityToResponse(entityPage.stream().toList());
+
+
+        PageableResponseBean<List<UserActionResponseBean>> pageableResponseBean = new PageableResponseBean<>();
+        pageableResponseBean.setBody(userActionResponseBeans);
+        pageableResponseBean.setCurrentPage(entityPage.getNumber() + 1); // Page numbers typically start from 0, so add 1 for user-friendly indexing
+        pageableResponseBean.setTotalPages(entityPage.getTotalPages());
+        pageableResponseBean.setTotalRecords(entityPage.getTotalElements());
+        pageableResponseBean.setPageSize(entityPage.getSize());
+
+      return createSummaryPageResponse(user,numberOfLoginAttempts,applicationsProcessed,pageableResponseBean);
+    }
+    public Specification<UserActionEntity> search(UserActionPaginationRequest userActionPaginationRequest,UserEntity userEntity) {
+        return (root, query, criteriaBuilder) -> {
+
+            List<Predicate> predicates = getPredicates(userActionPaginationRequest, criteriaBuilder, root,userEntity);
+            SortBy sortBy = new SortBy(GepafinConstant.CREATED_DATE, true);
+
+            if (userActionPaginationRequest .getGlobalFilters() != null
+                    && userActionPaginationRequest.getGlobalFilters().getSortBy() != null &&
+                    userActionPaginationRequest.getGlobalFilters().getSortBy().getColumnName() != null && Boolean.FALSE.equals(
+                    isEmpty(userActionPaginationRequest.getGlobalFilters().getSortBy().getColumnName()))) {
+                sortBy.setColumnName(userActionPaginationRequest.getGlobalFilters().getSortBy().getColumnName());
+                sortBy.setSortDesc(true);
+                if (userActionPaginationRequest.getGlobalFilters().getSortBy().getSortDesc() != null) {
+                    sortBy.setSortDesc(userActionPaginationRequest.getGlobalFilters().getSortBy().getSortDesc());
+                }
+            }
+
+            query.orderBy(criteriaBuilder.desc(root.get(sortBy.getColumnName())));
+            if (Boolean.FALSE.equals(sortBy.getSortDesc())) {
+                query.orderBy(criteriaBuilder.asc(root.get(sortBy.getColumnName())));
+            }
+            return query.where(criteriaBuilder.and(predicates.toArray(new Predicate[0]))).getRestriction();
+        };
+    }
+
+
+    private List<Predicate> getPredicates(UserActionPaginationRequest userActionPaginationRequest,
+                                          CriteriaBuilder criteriaBuilder, Root<UserActionEntity> root,UserEntity userEntity) {
+
+        Integer year = null;
+        String search = null;
+        if (userActionPaginationRequest.getGlobalFilters() != null) {
+            year = userActionPaginationRequest.getGlobalFilters().getYear();
+            search = userActionPaginationRequest.getGlobalFilters().getSearch();
+        }
+        List<Predicate> predicates = new ArrayList<>();
+
+        if (year != null && year > 0) {
+            int filterYear = userActionPaginationRequest.getGlobalFilters().getYear();
+
+// Create LocalDateTime boundaries for the start and end of the year
+            LocalDateTime startOfYear = LocalDateTime.of(filterYear, 1, 1, 0, 0);
+            LocalDateTime endOfYear = LocalDateTime.of(filterYear, 12, 31, 23, 59, 59);
+
+// Add the range comparison to filter records within the year
+            predicates.add(criteriaBuilder.between(root.get(GepafinConstant.CREATED_DATE), startOfYear, endOfYear));
+
+        }
+        // Search in `title` and `message` (if search term is provided)
+        if (search != null && !search.isEmpty()) {
+            Predicate actionType = criteriaBuilder.like(
+                    criteriaBuilder.upper(root.get(GepafinConstant.ACTION_TYPE)),
+                    "%" + search.toUpperCase() + "%"
+            );
+            predicates.add(criteriaBuilder.or(actionType));
+            Predicate actionContext = criteriaBuilder.like(
+                    criteriaBuilder.upper(root.get(GepafinConstant.ACTION_CONTEXT)),
+                    "%" + search.toUpperCase() + "%"
+            );
+            predicates.add(criteriaBuilder.or(actionContext));
+            Predicate methodType = criteriaBuilder.like(
+                    criteriaBuilder.upper(root.get(GepafinConstant.METHOD_TYPE)),
+                    "%" + search.toUpperCase() + "%"
+            );
+            predicates.add(criteriaBuilder.or(methodType));
+        }
+
+        // Filter by `status` (if status list is provided)
+        if (userActionPaginationRequest.getActionContext() != null && !userActionPaginationRequest.getActionContext().isEmpty()) {
+            List<String> statusValues = userActionPaginationRequest.getActionContext().stream()
+                    .map(UserActionContextEnum::name) // Convert enum to string
+                    .toList();
+            predicates.add(root.get("actionContext").in(statusValues));
+        }
+        if (userActionPaginationRequest.getActionType() != null && !userActionPaginationRequest.getActionType().isEmpty()) {
+            List<String> statusValues = userActionPaginationRequest.getActionType().stream()
+                    .map(UserActionLogsEnum::name) // Convert enum to string
+                    .toList();
+            predicates.add(root.get("actionType").in(statusValues));
+        }
+
+        TimePeriodEnum timeRange= userActionPaginationRequest.getTimeFilter();
+        if (timeRange != null) {
+            LocalDateTime startDate = null;
+            LocalDateTime endDate = LocalDateTime.now();
+
+            switch (timeRange) {
+                case LAST_WEEK -> startDate = endDate.minusWeeks(1);
+                case LAST_QUARTER -> startDate = endDate.minusMonths(3);
+                case LAST_SEMESTER -> startDate = endDate.minusMonths(6);
+                case LAST_YEAR -> startDate = endDate.minusYears(1);
+            }
+
+            if (startDate != null) {
+                predicates.add(criteriaBuilder.between(root.get(GepafinConstant.CREATED_DATE), startDate, endDate));
+            }
+        }
+        predicates.add(criteriaBuilder.equal(root.get(GepafinConstant.USER_ID), userEntity.getId()));
+
+        return predicates;
+
+    }
 }

src/main/java/net/gepafin/tendermanagement/dao/UserDao.java

@@ -1,5 +1,8 @@
 package net.gepafin.tendermanagement.dao;
 
+import jakarta.persistence.criteria.CriteriaBuilder;
+import jakarta.persistence.criteria.Predicate;
+import jakarta.persistence.criteria.Root;
 import jakarta.servlet.http.HttpServletRequest;
 import jakarta.servlet.http.HttpServletResponse;
 import net.gepafin.tendermanagement.config.SamlSuccessHandler;
@@ -10,6 +13,7 @@ import net.gepafin.tendermanagement.enums.*;
 import net.gepafin.tendermanagement.model.request.*;
 import net.gepafin.tendermanagement.model.response.*;
 import net.gepafin.tendermanagement.model.util.JWTToken;
+import net.gepafin.tendermanagement.model.util.SortBy;
 import net.gepafin.tendermanagement.repositories.BeneficiaryRepository;
 import net.gepafin.tendermanagement.repositories.UserRepository;
 import net.gepafin.tendermanagement.service.HubService;
@@ -28,8 +32,13 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.jpa.domain.Specification;
 import org.springframework.security.crypto.password.PasswordEncoder;
 import org.springframework.stereotype.Component;
+
+import java.time.LocalDateTime;
 import java.util.ArrayList;
 import java.util.List;
 
@@ -37,6 +46,7 @@ import java.util.Map;
 import java.util.stream.Collectors;
 
 import static net.gepafin.tendermanagement.util.Utils.setIfUpdated;
+import static org.apache.commons.lang3.StringUtils.isEmpty;
 
 @Component
 public class UserDao {
@@ -596,6 +606,151 @@ public class UserDao {
         log.info("Total users found with role ID {}: {}", roleIds, userResponseBeans.size());
         return userResponseBeans;
     }
+    public PageableResponseBean<List<UserResponseBean>> getUserByPagination(UserPaginationRequestBean userPaginationRequestBean,UserEntity userEntity) {
+            Integer pageNo = null;
+        Integer pageLimit = null;
+        if (userPaginationRequestBean.getGlobalFilters() != null) {
+            pageNo = userPaginationRequestBean.getGlobalFilters().getPage();
+            pageLimit = userPaginationRequestBean.getGlobalFilters().getLimit();
+        }
+        if (pageLimit == null || pageLimit <= 0) {
+            pageLimit = GepafinConstant.DEFAULT_PAGE_LIMIT;
+        }
+        if (pageNo == null || pageNo <= 0) {
+            pageNo = GepafinConstant.DEFAULT_PAGE;
+        }
+        Specification<UserEntity> spec = search(userPaginationRequestBean,userEntity);
+        Page<UserEntity> entityPage = userRepository.findAll(spec, PageRequest.of(pageNo - 1, pageLimit));
 
 
+        List<UserResponseBean> applicationResponses = entityPage.getContent().stream()
+                .map(user -> {
+                    UserResponseBean response = convertUserEntityToUserResponse(user);
+                    return response;
+                })
+                .collect(Collectors.toList());
+
+
+        PageableResponseBean<List<UserResponseBean>> pageableResponseBean = new PageableResponseBean<>();
+        pageableResponseBean.setBody(applicationResponses);
+        pageableResponseBean.setCurrentPage(entityPage.getNumber() + 1); // Page numbers typically start from 0, so add 1 for user-friendly indexing
+        pageableResponseBean.setTotalPages(entityPage.getTotalPages());
+        pageableResponseBean.setTotalRecords(entityPage.getTotalElements());
+        pageableResponseBean.setPageSize(entityPage.getSize());
+
+        return pageableResponseBean;
+    }
+
+    public Specification<UserEntity> search(UserPaginationRequestBean userPaginationRequestBean,UserEntity userEntity) {
+        return (root, query, criteriaBuilder) -> {
+
+            List<Predicate> predicates = getPredicates(userPaginationRequestBean, criteriaBuilder, root,userEntity);
+            SortBy sortBy = new SortBy(GepafinConstant.CREATED_DATE, true);
+
+            if (userPaginationRequestBean .getGlobalFilters() != null
+                    && userPaginationRequestBean.getGlobalFilters().getSortBy() != null &&
+                    userPaginationRequestBean.getGlobalFilters().getSortBy().getColumnName() != null && Boolean.FALSE.equals(
+                    isEmpty(userPaginationRequestBean.getGlobalFilters().getSortBy().getColumnName()))) {
+                sortBy.setColumnName(userPaginationRequestBean.getGlobalFilters().getSortBy().getColumnName());
+                sortBy.setSortDesc(true);
+                if (userPaginationRequestBean.getGlobalFilters().getSortBy().getSortDesc() != null) {
+                    sortBy.setSortDesc(userPaginationRequestBean.getGlobalFilters().getSortBy().getSortDesc());
+                }
+            }
+
+            query.orderBy(criteriaBuilder.desc(root.get(sortBy.getColumnName())));
+            if (Boolean.FALSE.equals(sortBy.getSortDesc())) {
+                query.orderBy(criteriaBuilder.asc(root.get(sortBy.getColumnName())));
+            }
+            return query.where(criteriaBuilder.and(predicates.toArray(new Predicate[0]))).getRestriction();
+        };
+    }
+
+
+    private List<Predicate> getPredicates(UserPaginationRequestBean userPaginationRequestBean,
+                                          CriteriaBuilder criteriaBuilder, Root<UserEntity> root,UserEntity user) {
+
+        Integer year = null;
+        String search = null;
+        if (userPaginationRequestBean.getGlobalFilters() != null) {
+            year = userPaginationRequestBean.getGlobalFilters().getYear();
+            search = userPaginationRequestBean.getGlobalFilters().getSearch();
+        }
+        List<Predicate> predicates = new ArrayList<>();
+
+        if (year != null && year > 0) {
+            int filterYear = userPaginationRequestBean.getGlobalFilters().getYear();
+
+// Create LocalDateTime boundaries for the start and end of the year
+            LocalDateTime startOfYear = LocalDateTime.of(filterYear, 1, 1, 0, 0);
+            LocalDateTime endOfYear = LocalDateTime.of(filterYear, 12, 31, 23, 59, 59);
+
+// Add the range comparison to filter records within the year
+            predicates.add(criteriaBuilder.between(root.get(GepafinConstant.CREATED_DATE), startOfYear, endOfYear));
+
+        }
+        // Search in `title` and `message` (if search term is provided)
+        if (search != null && !search.isEmpty()) {
+            Predicate predicate = criteriaBuilder.like(
+                    criteriaBuilder.upper(root.get("firstName")),
+                    "%" + search.toUpperCase() + "%"
+            );
+            predicates.add(criteriaBuilder.or(predicate));
+            Predicate predicate1 = criteriaBuilder.like(
+                    criteriaBuilder.upper(root.get("lastName")),
+                    "%" + search.toUpperCase() + "%"
+            );
+            predicates.add(criteriaBuilder.or(predicate1));
+
+            Predicate predicate2 = criteriaBuilder.like(
+                    criteriaBuilder.upper(root.get("phoneNumber")),
+                    "%" + search.toUpperCase() + "%"
+            );
+            predicates.add(criteriaBuilder.or(predicate2));
+
+            Predicate predicate3 = criteriaBuilder.like(
+                    criteriaBuilder.upper(root.get("organization")),
+                    "%" + search.toUpperCase() + "%"
+            );
+            predicates.add(criteriaBuilder.or(predicate3));
+
+            Predicate predicate4 = criteriaBuilder.like(
+                    criteriaBuilder.upper(root.get("address")),
+                    "%" + search.toUpperCase() + "%"
+            );
+            predicates.add(criteriaBuilder.or(predicate4));
+
+            Predicate predicate5 = criteriaBuilder.like(
+                    criteriaBuilder.upper(root.get("city")),
+                    "%" + search.toUpperCase() + "%"
+            );
+            predicates.add(criteriaBuilder.or(predicate5));
+
+            Predicate predicate6 = criteriaBuilder.like(
+                    criteriaBuilder.upper(root.get("country")),
+                    "%" + search.toUpperCase() + "%"
+            );
+            predicates.add(criteriaBuilder.or(predicate6));
+
+
+        }
+
+        // Filter by `status` (if status list is provided)
+        if (userPaginationRequestBean.getStatus() != null && !userPaginationRequestBean.getStatus().isEmpty()) {
+            List<String> statusValues = userPaginationRequestBean.getStatus().stream()
+                    .map(UserStatusEnum::name) // Convert enum to string
+                    .toList();
+            predicates.add(root.get(GepafinConstant.STATUS).in(statusValues));
+        }
+        if (userPaginationRequestBean.getRole() != null && !userPaginationRequestBean.getRole().isEmpty()) {
+            List<String> roleValues = userPaginationRequestBean.getRole().stream()
+                    .map(RoleStatusEnum::name) // Convert enum to string
+                    .toList();
+            predicates.add(root.get("roleEntity").get("roleType").in(roleValues));
+        }
+        predicates.add(root.get(GepafinConstant.HUB).get("id").in(user.getHub().getId()));
+
+        return predicates;
+
+    }
 }