BFLOWS/bflows-bandi-be
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #235 from Kitzanos/feature/GEPAFINBE-181

Browse Source 
GEPAFINBE-181 (Apply search filter for call pagination endpoint )
This commit is contained in:
Rinaldo
2025-03-05 10:43:57 +01:00
committed by GitHub
parent d1ee521e18 63a60b2522
commit 6bdf208741
3 changed files with 141 additions and 4 deletions
Download Patch File Download Diff File Expand all files Collapse all files

137
src/main/java/net/gepafin/tendermanagement/dao/CallDao.java
View File

@@ -4,17 +4,18 @@ import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.math.BigDecimal;
import java.sql.Timestamp;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.OffsetDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.stream.Collectors;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;
import jakarta.persistence.criteria.CriteriaBuilder;
import jakarta.persistence.criteria.Predicate;
import jakarta.persistence.criteria.Root;
import jakarta.persistence.criteria.*;
import jakarta.servlet.http.HttpServletRequest;
import net.gepafin.tendermanagement.entities.*;
import net.gepafin.tendermanagement.enums.*;
@@ -1058,10 +1059,14 @@ public class CallDao {
Integer year = null;
String search = null;
Map<String, FilterCriteria> filters = new HashMap<>();
if (callPageableRequestBean.getGlobalFilters() != null) {
year = callPageableRequestBean.getGlobalFilters().getYear();
search = callPageableRequestBean.getGlobalFilters().getSearch();
}
if (callPageableRequestBean.getFilters() != null) {
filters = callPageableRequestBean.getFilters();
}
List<Predicate> predicates = new ArrayList<>();
if (year != null && year > 0) {
int filterYear = callPageableRequestBean.getGlobalFilters().getYear();
@@ -1104,7 +1109,7 @@ public class CallDao {
.toList();
predicates.add(root.get(GepafinConstant.STATUS).in(statusValues));
}
applyFilters(root, criteriaBuilder, predicates, filters);
predicates.add(criteriaBuilder.equal(root.get(GepafinConstant.HUB).get(GepafinConstant.ID), userEntity.getHub().getId()));
@@ -1112,6 +1117,130 @@ public class CallDao {
}
private void applyFilters(Root<?> root, CriteriaBuilder criteriaBuilder, List<Predicate> predicates, Map<String, FilterCriteria> filters) {
if (Boolean.FALSE.equals(filters.isEmpty())) {
for (Map.Entry<String, FilterCriteria> entry : filters.entrySet()) {
String fieldName = entry.getKey();
FilterCriteria filterCriteria = entry.getValue();
Object value = filterCriteria.getValue();
MatchModeEnum matchMode = filterCriteria.getMatchMode();
if (value != null && matchMode != null) {
Path<?> fieldPath = getFieldPath(root, fieldName);
if (fieldPath != null) {
applyStringFilter(fieldPath, criteriaBuilder, predicates, value, matchMode);
applyNumberFilter(fieldPath, criteriaBuilder, predicates, value, matchMode);
applyDateFilter(fieldPath, criteriaBuilder, predicates, value, matchMode,root);
}
}
}
}
}
private void applyStringFilter(Path<?> fieldPath, CriteriaBuilder criteriaBuilder, List<Predicate> predicates, Object value, MatchModeEnum matchMode) {
if (value instanceof String) {
String valueStr = (String) value;
if (fieldPath.getJavaType().equals(String.class)) {
MatchModeEnum mode = MatchModeEnum.fromObject(matchMode.getValue());
switch (mode) {
case CONTAINS ->
predicates.add(criteriaBuilder.like(criteriaBuilder.lower(fieldPath.as(String.class)), "%" + valueStr.toLowerCase() + "%"));
case EQUALS -> predicates.add(criteriaBuilder.equal(fieldPath, valueStr));
case STARTSWITH ->
predicates.add(criteriaBuilder.like(criteriaBuilder.lower(fieldPath.as(String.class)), valueStr.toLowerCase() + "%"));
case ENDSWITH ->
predicates.add(criteriaBuilder.like(criteriaBuilder.lower(fieldPath.as(String.class)), "%" + valueStr.toLowerCase()));
}
}
}
}
private void applyNumberFilter(Path<?> fieldPath, CriteriaBuilder criteriaBuilder, List<Predicate> predicates, Object value, MatchModeEnum matchMode) {
if (Number.class.isAssignableFrom(fieldPath.getJavaType())) {
Number numberValue = null;
if (value instanceof Number) {
numberValue = (Number) value;
}
MatchModeEnum mode = MatchModeEnum.fromObject(matchMode.getValue());
switch (mode) {
case EQUALS -> predicates.add(criteriaBuilder.equal(fieldPath, numberValue));
}
}
}
private void applyDateFilter(Path<?> fieldPath, CriteriaBuilder criteriaBuilder, List<Predicate> predicates, Object value, MatchModeEnum matchMode, Root<?> root) {
if (fieldPath.getJavaType().equals(LocalDateTime.class)) {
// Convert input string: Replace 'T' with space
String formattedValue = value.toString().replace("T", " ");
// Handle timezones and UTC (`Z` or `+HH:mm`)
if (formattedValue.contains("Z") || formattedValue.matches(".*[+-]\\d{2}:\\d{2}$")) {
OffsetDateTime offsetDateTime = OffsetDateTime.parse(value.toString(), DateTimeFormatter.ISO_OFFSET_DATE_TIME);
formattedValue = offsetDateTime.toLocalDateTime().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS"));
}
// Check if more than 3 decimal places exist
if (formattedValue.contains(".")) {
int dotIndex = formattedValue.indexOf(".");
if (formattedValue.length() > dotIndex + 4) {
formattedValue = formattedValue.substring(0, dotIndex + 4); // Keep only 3 decimals
}
} else {
formattedValue += ".000"; // Ensure 3 decimals
}
// Define correct date-time format
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS");
// Parse the formatted value into LocalDateTime
LocalDateTime dateTimeValue = LocalDateTime.parse(formattedValue, formatter);
// Extract only the date portion
LocalDate dateValue = dateTimeValue.toLocalDate();
// Convert database field to LocalDate for date-only comparison
Expression<LocalDate> dateField = criteriaBuilder.function("DATE", LocalDate.class, fieldPath);
MatchModeEnum mode = MatchModeEnum.fromObject(matchMode.getValue());
switch (mode) {
case DATEIS -> predicates.add(criteriaBuilder.equal(dateField, dateValue));
case DATEISNOT -> predicates.add(criteriaBuilder.notEqual(dateField, dateValue));
case BEFORE -> predicates.add(criteriaBuilder.lessThan(fieldPath.as(Timestamp.class), Timestamp.valueOf(dateTimeValue)));
case AFTER -> predicates.add(criteriaBuilder.greaterThan(fieldPath.as(Timestamp.class), Timestamp.valueOf(dateTimeValue)));
}
}
}
private Path<?> getFieldPath(Root<?> root, String fieldName) {
try {
return switch (fieldName) {
case GepafinConstant.REGION_ID -> {
// Ensure join is only created if not already present
Join<?, RegionEntity> regionJoin = root.getJoins().stream()
.filter(j -> j.getAttribute().getName().equals("region"))
.findFirst()
.map(j -> (Join<?, RegionEntity>) j)
.orElseGet(() -> root.join("region", JoinType.LEFT));
yield regionJoin.get("id");
}
default -> root.get(fieldName);
};
} catch (IllegalArgumentException e) {
return null;
}
}
public CallResponse createCallStep2EvaluationV2(CallEntity callEntity, CreateCallRequestStep2EvaluationV2 createCallRequest, UserEntity user) {
convertToDocumentEntities(createCallRequest.getDocs(), callEntity.getId(), DocumentTypeEnum.DOCUMENT);