src/main/java/ru/indvdum/jpa/dao/JPADataAccessObject.groovy
changeset 16 409046072775
parent 13 bfcb605c25ef
child 19 39381427da3f
equal deleted inserted replaced
15:7d8a7e7635d2 16:409046072775
    57 	void rollback() {
    57 	void rollback() {
    58 		if(tx != null && tx.isActive()) {
    58 		if(tx != null && tx.isActive()) {
    59 			tx.rollback()
    59 			tx.rollback()
    60 		}
    60 		}
    61 	}
    61 	}
    62 	
    62 
    63 	void detach(Object entity) {
    63 	void detach(Object entity) {
    64 		em.detach(entity);
    64 		em.detach(entity);
    65 	}
    65 	}
    66 
    66 
    67 	protected static String getPersistenceUnitName() {
    67 	protected static String getPersistenceUnitName() {
   152 		}
   152 		}
   153 
   153 
   154 		return true
   154 		return true
   155 	}
   155 	}
   156 
   156 
   157 	public <T> T find(Class<T> entityClass, Object primaryKey) {
   157 	public <T> List<T> list(Class<T> entityClass) {
   158 		return em.find(entityClass, primaryKey);
   158 		CriteriaQuery<T> query = em.getCriteriaBuilder().createQuery(entityClass);
       
   159 		query.from(entityClass);
       
   160 		return new ArrayList(em.createQuery(query).getResultList());
   159 	}
   161 	}
   160 
   162 
   161 	public <T> List<T> list(Class<T> entityClass, Map<String, Object> equalProperties, Map<String, Object> notEqualProperties) {
   163 	public <T> List<T> list(Class<T> entityClass, Map<String, Object> equalProperties, Map<String, Object> notEqualProperties) {
   162 		CriteriaBuilder cb = em.getCriteriaBuilder();
   164 		CriteriaBuilder cb = em.getCriteriaBuilder();
   163 		CriteriaQuery<T> query = cb.createQuery(entityClass);
   165 		CriteriaQuery<T> query = cb.createQuery(entityClass);
   179 		}
   181 		}
   180 		query.where(cb.and(predicates.toArray(new Predicate[predicates.size()])));
   182 		query.where(cb.and(predicates.toArray(new Predicate[predicates.size()])));
   181 		return em.createQuery(query).getResultList();
   183 		return em.createQuery(query).getResultList();
   182 	}
   184 	}
   183 
   185 
       
   186 	public <T> List<T> list(Class<T> entityClass, Object ... equalFieldNamesAndValues) {
       
   187 		if (equalFieldNamesAndValues.length % 2 != 0)
       
   188 			throw new RuntimeException("Illegal arguments count: ${equalFieldNamesAndValues.length}");
       
   189 		Map fieldValues = [:];
       
   190 		for (int i = 0; i < equalFieldNamesAndValues.length;) {
       
   191 			String field = (String) equalFieldNamesAndValues[i++];
       
   192 			Object value = equalFieldNamesAndValues[i++];
       
   193 			fieldValues["${field}"] = value;
       
   194 		}
       
   195 		return list(entityClass, fieldValues, null);
       
   196 	}
       
   197 
       
   198 	public List list(String jpql, Object ... paramValues) {
       
   199 		Query query = em.createQuery(jpql);
       
   200 		for (int i = 0; i < paramValues.length; i++)
       
   201 			query.setParameter(i + 1, paramValues[i]);
       
   202 		return query.getResultList();
       
   203 	}
       
   204 
       
   205 	public <T> T find(Class<T> entityClass, Object primaryKey) {
       
   206 		return em.find(entityClass, primaryKey);
       
   207 	}
       
   208 
   184 	public <T> T find(Class<T> entityClass, Map<String, Object> equalProperties, Map<String, Object> notEqualProperties) {
   209 	public <T> T find(Class<T> entityClass, Map<String, Object> equalProperties, Map<String, Object> notEqualProperties) {
   185 		CriteriaBuilder cb = em.getCriteriaBuilder();
   210 		CriteriaBuilder cb = em.getCriteriaBuilder();
   186 		CriteriaQuery<T> query = cb.createQuery(entityClass);
   211 		CriteriaQuery<T> query = cb.createQuery(entityClass);
   187 		Root<T> root = query.from(entityClass);
   212 		Root<T> root = query.from(entityClass);
   188 		Collection<Predicate> predicates = new HashSet<Predicate>();
   213 		Collection<Predicate> predicates = new HashSet<Predicate>();
   208 			log.info("Object not found in Database: " + e.getMessage());
   233 			log.info("Object not found in Database: " + e.getMessage());
   209 		}
   234 		}
   210 		return result;
   235 		return result;
   211 	}
   236 	}
   212 
   237 
   213 	public <T> T find(Class<T> entityClass, String field, Object value) {
   238 	public <T> T find(Class<T> entityClass, Object ... equalFieldNamesAndValues) {
   214 		return find(entityClass, ["${field}": value], null);
   239 		if (equalFieldNamesAndValues.length % 2 != 0)
   215 	}
   240 			throw new RuntimeException("Illegal arguments count: ${equalFieldNamesAndValues.length}");
   216 
   241 		Map fieldValues = [:];
   217 	public <T> List<T> list(Class<T> entityClass) {
   242 		for (int i = 0; i < equalFieldNamesAndValues.length;) {
   218 		CriteriaQuery<T> query = em.getCriteriaBuilder().createQuery(entityClass);
   243 			String field = (String) equalFieldNamesAndValues[i++];
   219 		query.from(entityClass);
   244 			Object value = equalFieldNamesAndValues[i++];
   220 		return new ArrayList(em.createQuery(query).getResultList());
   245 			fieldValues["${field}"] = value;
       
   246 		}
       
   247 		return find(entityClass, fieldValues, null);
       
   248 	}
       
   249 	
       
   250 	
       
   251 	public Object find(String jpql, Object ... paramValues) {
       
   252 		Query query = em.createQuery(jpql);
       
   253 		for (int i = 0; i < paramValues.length; i++)
       
   254 			query.setParameter(i + 1, paramValues[i]);
       
   255 		return query.getSingleResult();
   221 	}
   256 	}
   222 
   257 
   223 	public boolean contains(Collection entities) {
   258 	public boolean contains(Collection entities) {
   224 		boolean res = true;
   259 		boolean res = true;
   225 		entities.each {res &= contains(it)}
   260 		entities.each {res &= contains(it)}