Clover icon

together Platform [Module:core] - Coverage Report

  1. Project Clover database Mon Dec 22 2025 14:59:38 CST
  2. Package org.europa.together.application

File GenericHbmDAO.java

 

Coverage histogram

../../../../img/srcFileCovDistChart10.png
0% of files have more coverage

Code metrics

34
81
13
1
259
218
32
0.4
6.23
13
2.46

Classes

Class Line # Actions
GenericHbmDAO 36 81 0% 32 2
0.98437598.4%
 

Contributing tests

This file is covered by 69 tests. .

Source view

1    package org.europa.together.application;
2   
3    import java.io.Serializable;
4    import java.lang.reflect.ParameterizedType;
5    import java.util.ArrayList;
6    import java.util.List;
7    import java.util.Map;
8    import jakarta.persistence.EntityManager;
9    import jakarta.persistence.PersistenceContext;
10    import jakarta.persistence.criteria.CriteriaBuilder;
11    import jakarta.persistence.criteria.CriteriaQuery;
12    import jakarta.persistence.criteria.Predicate;
13    import jakarta.persistence.criteria.Root;
14    import java.util.Date;
15    import org.europa.together.business.GenericDAO;
16    import org.europa.together.business.JsonTools;
17    import org.europa.together.business.Logger;
18    import org.europa.together.domain.LogLevel;
19    import org.europa.together.domain.JpaPagination;
20    import org.europa.together.exceptions.DAOException;
21    import org.europa.together.exceptions.JsonProcessingException;
22    import org.europa.together.utils.StringUtils;
23    import org.springframework.beans.factory.annotation.Autowired;
24    import org.springframework.stereotype.Repository;
25    import org.springframework.transaction.annotation.Transactional;
26   
27    /**
28    * Abstract implementation of Domain Access Object (DAO) Pattern.
29    *
30    * @param <T> as template.
31    * @param <PK> as PrimaryKey
32    */
33    @SuppressWarnings("unchecked")
34    @Repository
35    @Transactional
 
36    public abstract class GenericHbmDAO<T, PK extends Serializable>
37    implements GenericDAO<T, PK> {
38   
39    private static final long serialVersionUID = 2L;
40    private static final Logger LOGGER = new LogbackLogger(GenericHbmDAO.class);
41   
42    /**
43    * JPA Entity Manager for Transactions.
44    */
45    @PersistenceContext
46    @SuppressWarnings("checkstyle:visibilitymodifier")
47    public transient EntityManager mainEntityManagerFactory;
48   
49    @Autowired
50    private transient JsonTools<T> jsonTools;
51   
52    private final Class<T> genericType;
53   
54    /**
55    * Constructor.
56    */
 
57  2 toggle public GenericHbmDAO() {
58  2 ParameterizedType clazz = (ParameterizedType) getClass().getGenericSuperclass();
59  2 genericType = (Class<T>) clazz.getActualTypeArguments()[0];
60  2 LOGGER.log("instance class <" + genericType.getSimpleName() + ">", LogLevel.INFO);
61    }
62   
 
63  4 toggle @Override
64    public boolean create(final T object) {
65  4 boolean success = false;
66  4 if (object != null) {
67  3 mainEntityManagerFactory.persist(object);
68  3 success = true;
69    }
70  4 return success;
71    }
72   
 
73  3 toggle @Override
74    public void delete(final PK id)
75    throws DAOException {
76  3 T foundObject = find(id);
77  2 if (foundObject != null) {
78  1 mainEntityManagerFactory.remove(foundObject);
79    } else {
80  1 throw new DAOException("delete:" + id.toString());
81    }
82    }
83   
 
84  21 toggle @Override
85    public void update(final PK id, final T object)
86    throws DAOException {
87  20 if (object != null && this.find(id) != null) {
88  16 mainEntityManagerFactory.merge(object);
89  16 LOGGER.log("DAO (" + object.getClass().getSimpleName() + ") update",
90    LogLevel.TRACE);
91    } else {
92  4 String message = "update faild. -> ";
93  4 if (id != null) {
94  3 message += id.toString();
95    }
96  4 if (object != null) {
97  2 message += " : " + object.toString();
98    }
99  4 throw new DAOException(message);
100    }
101    }
102   
 
103  1 toggle @Override
104    @Transactional(readOnly = true)
105    public long countAllElements() {
106  1 CriteriaBuilder builder = mainEntityManagerFactory.getCriteriaBuilder();
107  1 CriteriaQuery<T> query = builder.createQuery(genericType);
108    // create Criteria
109  1 query.from(genericType);
110  1 return mainEntityManagerFactory.createQuery(query).getResultList().size();
111    }
112   
 
113  54 toggle @Override
114    @Transactional(readOnly = true)
115    public List<T> listAllElements(final JpaPagination pivotElement) {
116  54 LOGGER.log("GenericDAO: " + pivotElement.toString(), LogLevel.DEBUG);
117  54 CriteriaBuilder builder = mainEntityManagerFactory.getCriteriaBuilder();
118  54 CriteriaQuery<T> query = builder.createQuery(genericType);
119  54 Root<T> root = query.from(genericType);
120  54 int limit = pivotElement.getPageSize();
121   
122    // skip pagination
123  54 int countedResults = mainEntityManagerFactory.createQuery(query).getResultList().size();
124  54 if (limit == 0 || limit >= countedResults) {
125  43 limit = countedResults;
126    }
127   
128    // order the result set
129  54 if (pivotElement.getSorting().equals(JpaPagination.ORDER_ASC)) {
130  51 query.select(root).orderBy(builder.asc(root.get(pivotElement.getPrimaryKey())));
131    } else {
132  3 query.select(root).orderBy(builder.desc(root.get(pivotElement.getPrimaryKey())));
133    }
134  54 if (!StringUtils.isEmpty(pivotElement.getAdditionalOrdering())) {
135  5 query.select(root).orderBy(builder.asc(root.get(pivotElement.getAdditionalOrdering())));
136    }
137   
138    // put everything together
139  54 List<Predicate> filters = calculatePredicates(builder, root, pivotElement);
140  54 if (!filters.isEmpty()) {
141  47 query.where(filters.toArray(new Predicate[filters.size()]));
142    }
143  54 List<T> results = mainEntityManagerFactory.createQuery(query)
144    .setMaxResults(limit).getResultList();
145  54 return results;
146    }
147   
 
148  2 toggle @Override
149    @Transactional(readOnly = true)
150    public PK getPrimaryKeyOfObject(final T object) {
151  2 PK returnVal = null;
152  2 if (object != null) {
153  1 returnVal = (PK) mainEntityManagerFactory.getEntityManagerFactory()
154    .getPersistenceUnitUtil().getIdentifier(object);
155  1 LOGGER.log("DAO (" + object.getClass().getSimpleName() + ") IDX="
156    + returnVal, LogLevel.TRACE);
157    } else {
158  1 LOGGER.log("getPrimaryKeyOfObject() : Object is null.", LogLevel.WARN);
159    }
160  2 return returnVal;
161    }
162   
 
163  1 toggle @Override
164    public String serializeAsJson(final T object)
165    throws JsonProcessingException {
166  1 return jsonTools.serializeAsJsonObject(object);
167    }
168   
 
169  0 toggle @Override
170    //TOTO: Remove in Release TP-CORE 4.0.0 (API Change)
171    public T deserializeJsonAsObject(final String json, final Class<T> object)
172    throws JsonProcessingException, ClassNotFoundException {
173  0 return jsonTools.deserializeJsonAsObject(json, genericType);
174    }
175   
 
176  1 toggle @Override
177    public T deserializeJsonAsObject(final String json)
178    throws JsonProcessingException, ClassNotFoundException {
179  1 return jsonTools.deserializeJsonAsObject(json, genericType);
180    }
181   
 
182  1 toggle @Override
183    public List<T> deserializeJsonAsList(final String json)
184    throws JsonProcessingException, ClassNotFoundException {
185  1 return jsonTools.deserializeJsonAsList(json);
186    }
187   
 
188  44 toggle @Override
189    @Transactional(readOnly = true)
190    public T find(final PK id) {
191  44 T retVal = mainEntityManagerFactory.find(genericType, id);
192  41 return retVal;
193    }
194   
195    //### ######################################################################
 
196  54 toggle private List<Predicate> calculatePredicates(final CriteriaBuilder builder, final Root<T> root,
197    final JpaPagination pivotElement) {
198  54 List<Predicate> filters = new ArrayList<>();
199    // get the break element
200  54 if (!StringUtils.isEmpty(pivotElement.getPageBreak())) {
201  8 if (pivotElement.getPaging().equals(JpaPagination.PAGING_FOREWARD)) {
202  7 filters.add(builder.greaterThanOrEqualTo(root.get(pivotElement.getPrimaryKey()),
203    pivotElement.getPageBreak()
204    ));
205    } else {
206  1 filters.add(builder.lessThanOrEqualTo(root.get(pivotElement.getPrimaryKey()),
207    pivotElement.getPageBreak()
208    ));
209    }
210    }
211  54 if (!pivotElement.getFilterStringCriteria().isEmpty()) {
212  39 for (Map.Entry<String, String> entry
213    : pivotElement.getFilterStringCriteria().entrySet()) {
214  105 filters.add(
215    builder.equal(root.<String>get(entry.getKey()), entry.getValue()));
216    }
217    } else {
218  15 LOGGER.log("No String based filters are set.", LogLevel.DEBUG);
219    }
220  54 if (!pivotElement.getFilterBooleanCriteria().isEmpty()) {
221  3 for (Map.Entry<String, Boolean> entry
222    : pivotElement.getFilterBooleanCriteria().entrySet()) {
223  3 filters.add(
224    builder.equal(root.<Boolean>get(entry.getKey()), entry.getValue()));
225    }
226    } else {
227  51 LOGGER.log("No Boolean based filters are set.", LogLevel.DEBUG);
228    }
229  54 if (!pivotElement.getFilterIntegerCriteria().isEmpty()) {
230  2 for (Map.Entry<String, Integer> entry
231    : pivotElement.getFilterIntegerCriteria().entrySet()) {
232  2 filters.add(
233    builder.equal(root.<Integer>get(entry.getKey()), entry.getValue()));
234    }
235    } else {
236  52 LOGGER.log("No Integer based filters are set.", LogLevel.DEBUG);
237    }
238  54 if (!pivotElement.getFilterFloatCriteria().isEmpty()) {
239  2 for (Map.Entry<String, Float> entry
240    : pivotElement.getFilterFloatCriteria().entrySet()) {
241  2 filters.add(
242    builder.equal(root.<Float>get(entry.getKey()), entry.getValue()));
243    }
244    } else {
245  52 LOGGER.log("No Float based filters are set.", LogLevel.DEBUG);
246    }
247  54 if (!pivotElement.getFilterDateCriteria().isEmpty()) {
248  2 for (Map.Entry<String, Date> entry
249    : pivotElement.getFilterDateCriteria().entrySet()) {
250  2 filters.add(
251    builder.lessThanOrEqualTo(
252    root.<Date>get(entry.getKey()), entry.getValue()));
253    }
254    } else {
255  52 LOGGER.log("No Date based filters are set.", LogLevel.DEBUG);
256    }
257  54 return filters;
258    }
259    }
  • Report generated by OpenClover v 4.5.2 on Mon Dec 22 2025 15:00:28 CST using coverage data from Mon Dec 22 2025 15:00:14 CST.
  • OpenClover is free and open-source software.