From b3d0580439b9a00c7eb918085de1694151066004 Mon Sep 17 00:00:00 2001
From: Kenmegne <stephanie.kenmegne@gmail.com>
Date: Thu, 18 Jun 2026 16:02:49 +0000
Subject: [PATCH] rename packages
---
fdx_convert/src/main/java/com/megatim/fdxconvert/dao/AbstractDAO.java | 295 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 295 insertions(+), 0 deletions(-)
diff --git a/fdx_convert/src/main/java/com/megatim/fdxconvert/dao/AbstractDAO.java b/fdx_convert/src/main/java/com/megatim/fdxconvert/dao/AbstractDAO.java
new file mode 100644
index 0000000..041943b
--- /dev/null
+++ b/fdx_convert/src/main/java/com/megatim/fdxconvert/dao/AbstractDAO.java
@@ -0,0 +1,295 @@
+/*
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template
+ */
+package com.megatim.fdxconvert.dao;
+
+import com.megatimfx.common.pojo.SearchCriteria;
+import com.megatim.fdxconvert.service.pojo.PaginationElts;
+import java.lang.reflect.Field;
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import javax.persistence.TypedQuery;
+import javax.persistence.criteria.CriteriaBuilder;
+import javax.persistence.criteria.CriteriaQuery;
+import javax.persistence.criteria.Predicate;
+import javax.persistence.criteria.Root;
+import lombok.Getter;
+import lombok.Setter;
+import org.hibernate.Session;
+
+/**
+ *
+ * @author mela
+ */
+@Getter
+@Setter
+public class AbstractDAO<T> {
+
+ private Class<T> clazz;
+ private PaginationElts pagination;
+
+ public AbstractDAO(Class<T> clas) {
+ clazz = clas;
+ pagination = new PaginationElts();
+ }
+
+ public <T> T add(T element) {
+ try ( Session session = HibernateUtil.getSessionFactory().openSession()) {
+ session.beginTransaction();
+ session.persist(element);
+ session.getTransaction().commit();
+ session.refresh(element);
+
+ return element;
+ }
+ }
+
+ public <T> T edit(T element) {
+ try ( Session session = HibernateUtil.getSessionFactory().openSession()) {
+ session.beginTransaction();
+ session.update(element);
+ session.getTransaction().commit();
+ session.refresh(element);
+
+ return element;
+ }
+ }
+
+ public void delete(T element) {
+ try ( Session session = HibernateUtil.getSessionFactory().openSession()) {
+ session.beginTransaction();
+ session.delete(element);
+ session.getTransaction().commit();
+ }
+ }
+
+ public void deleteAll(String tableName) {
+ List<T> liste = getAll(tableName);
+ try ( Session session = HibernateUtil.getSessionFactory().openSession()) {
+ session.beginTransaction();
+ liste.forEach(t -> session.delete(t));
+ session.getTransaction().commit();
+ }
+ }
+
+ public <Optional> T find(Object element) {
+ try ( Session session = HibernateUtil.getSessionFactory().openSession()) {
+ return session.find(clazz, element);
+ }
+ }
+
+ public List<T> getAll(String tableName) {
+
+ try ( Session session = HibernateUtil.getSessionFactory().openSession()) {
+
+ List<T> liste = session.createQuery("from " + tableName).getResultList();
+
+ return liste;
+
+ }
+
+ }
+
+ public List<T> getAllByPage(int indexDebut, int numberOfElt, List<SearchCriteria> searchCriterias) {
+ try ( Session session = HibernateUtil.getSessionFactory().openSession()) {
+ CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
+ CriteriaQuery<T> criteriaQuery = criteriaBuilder.createQuery(clazz);
+ Root<T> root = criteriaQuery.from(clazz);
+ List<Predicate> predicates = createPedicates(searchCriterias, criteriaBuilder, root);
+
+ CriteriaQuery<T> cq = criteriaQuery.select(root);
+
+ cq = cq.select(root).where(predicates.toArray(new Predicate[predicates.size()]));
+
+ TypedQuery<T> typedQuery = session.createQuery(cq);
+
+ typedQuery.setFirstResult(indexDebut);
+ typedQuery.setMaxResults(numberOfElt);
+ List<T> liste = typedQuery.getResultList();
+
+ return liste;
+ }
+ }
+
+ private long count(List<SearchCriteria> searchCriterias) {
+ try ( Session session = HibernateUtil.getSessionFactory().openSession()) {
+ CriteriaBuilder qb = session.getCriteriaBuilder();
+ CriteriaQuery<Long> cq = qb.createQuery(Long.class);
+ Root<T> root = cq.from(clazz);
+ List<Predicate> predicates = createPedicates(searchCriterias, qb, root);
+
+ cq.select(qb.count(root));
+ cq.where(predicates.toArray(new Predicate[predicates.size()]));
+
+ return (long) session.createQuery(cq).getSingleResult();
+ }
+ }
+
+ public PaginationElts initPaginationElts(int pageNumber, List<SearchCriteria> searchCriterias) {
+ int indexDebut = pageNumber * pagination.getNbEltsPerPage();
+ pagination.setListe(getAllByPage(indexDebut, pagination.getNbEltsPerPage(), searchCriterias));
+ pagination.setTotalElts(count(searchCriterias));
+ pagination.setPage(pageNumber);
+
+ if (pageNumber == 0) {
+ pagination.setNumberOfElts(pagination.getListe().size());
+ } else {
+ pagination.setNumberOfElts(pageNumber * pagination.getNbEltsPerPage() + pagination.getListe().size());
+ }
+
+ pagination.setNumberOfPage((pagination.getTotalElts() % pagination.getNbEltsPerPage() == 0) ? (pagination.getTotalElts() / pagination.getNbEltsPerPage())
+ : (pagination.getTotalElts() / pagination.getNbEltsPerPage()) + 1);
+
+ return pagination;
+ }
+
+ /**
+ * Méthode qui retounre la liste des champs de la classe clazz
+ *
+ * @return
+ */
+ private Map<String, Field> getClassFields() {
+ Field[] fields = clazz.getDeclaredFields();
+ Map<String, Field> mapOfFields = new HashMap<>();
+ for (Field field : fields) {
+ mapOfFields.put(field.getName(), field);
+ }
+
+ return mapOfFields;
+ }
+
+ /**
+ * Méthode qui vérifie que le champ "fieldValue" de l'objet searchCriteria
+ * est du même type que le champ "fieldName" dans la classe clazz
+ *
+ * @param field : contient les informations sur le champ correspondant
+ * @param value : valeur dont on veut vérifier le type
+ * @return : retourne vrai sivalue est du même type que celui renseigné dans
+ * field
+ */
+ private boolean isFieldAndValueOfSameType(Field field, Object value) {
+ boolean result = true;
+ try {
+ field.getType().cast(value);
+ } catch (ClassCastException ex) {
+ result = false;
+ }
+ return result;
+ //String className = field.getType().getName();
+ }
+
+ /**
+ * Méthode qui filtre la liste des critères afin de ne garder que ceux qui
+ * respectent le type du champ correspondant dans la classe et ceux dont le
+ * fieldName correspond à un champ de la classe clazz
+ *
+ * @param searchCriterias
+ * @return
+ */
+ private List<SearchCriteria> verifySearchCriteria(List<SearchCriteria> searchCriterias) {
+ Map<String, Field> mapOfFields = getClassFields();
+
+ //Retire les critères dont le fieldName ne correspond à aucun champ de la classe clazz
+ for (SearchCriteria criteria : searchCriterias) {
+ if (!mapOfFields.containsKey(criteria.getFieldName())) {
+ searchCriterias.remove(criteria);
+// continue;
+ }
+
+// Retire les critères dont le type de fieldValue ne correspond pas au type du champ dans la classe clazz
+// if(!isFieldAndValueOfSameType(mapOfFields.get(criteria.getFieldName()),criteria.getFieldValue())){
+// searchCriterias.remove(criteria);
+// }
+ }
+ return searchCriterias;
+ }
+
+ /**
+ * Méthode qui les prédicats à partir des critères de recherche
+ *
+ * @param searchCriterias
+ * @param cb
+ * @return
+ */
+ private List<Predicate> createPedicates(List<SearchCriteria> searchCriterias, CriteriaBuilder cb, Root<T> root) {
+ List<Predicate> predicates = new ArrayList<>();
+
+ searchCriterias = verifySearchCriteria(searchCriterias);
+ searchCriterias.parallelStream().forEach(s -> {
+ Predicate predicate = null;
+ switch (s.getOperateur()) {
+ case EQUALS:
+ predicate = cb.equal(root.get(s.getFieldName()), s.getFieldValue());
+ predicates.add(predicate);
+ break;
+
+ case NOT_EQUALS:
+ predicate = cb.notEqual(root.get(s.getFieldName()), s.getFieldValue());
+ predicates.add(predicate);
+ break;
+
+ case LIKE:
+ if (s.getFieldValue() instanceof String) {
+ predicate = cb.like(root.get(s.getFieldName()), "%" + s.getFieldValue().toString() + "%");
+ predicates.add(predicate);
+ }
+ break;
+
+ case GREATER_THAN:
+ if (s.getFieldValue() instanceof Number) {
+ predicate = cb.gt(root.get(s.getFieldName()), (Number) s.getFieldValue());
+ predicates.add(predicate);
+
+ } else if (s.getFieldValue() instanceof LocalDate) {
+ predicate = cb.greaterThan(root.get(s.getFieldName()), (LocalDate) s.getFieldValue());
+ predicates.add(predicate);
+ }
+ break;
+
+ case GREATER_OR_EQUALS_THAN:
+ if (s.getFieldValue() instanceof Number) {
+ predicate = cb.ge(root.get(s.getFieldName()), (Number) s.getFieldValue());
+ predicates.add(predicate);
+ } else if (s.getFieldValue() instanceof LocalDate) {
+ predicate = cb.greaterThanOrEqualTo(root.get(s.getFieldName()), (LocalDate) s.getFieldValue());
+ predicates.add(predicate);
+ }
+ break;
+
+ case LESS_THAN:
+ if (s.getFieldValue() instanceof Number) {
+ predicate = cb.lt(root.get(s.getFieldName()), (Number) s.getFieldValue());
+ predicates.add(predicate);
+ } else if (s.getFieldValue() instanceof LocalDate) {
+ predicate = cb.lessThan(root.get(s.getFieldName()), (LocalDate)s.getFieldValue());
+ predicates.add(predicate);
+ }
+ break;
+
+ case _LESS_OR_EQUALS_THAN:
+ if (s.getFieldValue() instanceof Number) {
+ predicate = cb.le(root.get(s.getFieldName()), (Number) s.getFieldValue());
+ predicates.add(predicate);
+ } else if (s.getFieldValue() instanceof LocalDate) {
+ predicate = cb.lessThanOrEqualTo(root.get(s.getFieldName()), (LocalDate)s.getFieldValue());
+ predicates.add(predicate);
+ }
+ break;
+ case IN:
+ if (s.getFieldValue() instanceof java.util.Collection) {
+ predicate = root.get(s.getFieldName()).in(s.getFieldValue());
+ predicates.add(predicate);
+ }
+ break;
+ default:
+
+ }
+ });
+
+ return predicates;
+ }
+}
--
Gitblit v1.10.0