Add Source Code Linter Pipeline

screwdriver-3.5.6/box/snippets/java/jpa2/Filter.java

@@ -0,0 +1,14 @@
+package +zoccolo+.jpa;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import +zoccolo+.jpa.SearchParameter;
+
+public class Filter {
+	private List<SearchParameter<String>> params = new ArrayList<SearchParameter<String>>();
+
+	public List<SearchParameter<String>> getParams() {
+		return params;
+	}
+}

screwdriver-3.5.6/box/snippets/java/jpa2/GenericDao.java

@@ -0,0 +1,140 @@
+package +zoccolo+.jpa.dao;
+
+import java.util.Collection;
+import java.util.List;
+
+import +zoccolo+.jpa.Filter;
+import +zoccolo+.jpa.Order;
+import +zoccolo+.jpa.SearchParameter;
+
+/**
+ * Generic CRUD interface implemented by all DAOs.
+ *
+ * @param <T> entity to be managed.
+ */
+public interface GenericDao<T> {
+
+	/**
+	 * Persist the entity in DB (though a flush).
+	 * 
+	 * @param entity
+	 * @return
+	 */
+	T create(T entity);
+	
+	/**
+	 * Flush DB changes made in the entity, merging if the entity
+	 * is detached from the session.
+	 * 
+	 * @param entity
+	 * @return
+	 */
+	T update(T entity);
+	
+	/**
+	 * Effettua la rimozione dell'entity da db, effettuando il flush.
+	 * Esegue il merge se l'entity è detached dalla sessione.
+	 * 
+	 * @param entity
+	 */
+	void remove(T entity);
+	
+	/**
+	 * Ritrova l'entity con id associato.
+	 * 
+	 * @param entityClass
+	 * @param id
+	 * @return
+	 */
+	T findUniqueById(Class<T> entityClass, Integer id);
+	
+	/**
+	 * Ritrova l'entity con id associato.
+	 * 
+	 * @param entityClass
+	 * @param id
+	 * @return
+	 */
+	T findUniqueById(Class<T> entityClass, Long id);
+	
+	/**
+	 * Ritrova l'entity con id associato.
+	 * 
+	 * @param entityClass
+	 * @param id
+	 * @return
+	 */
+	T findUniqueById(Class<T> entityClass, String id);
+	
+	/**
+	 * Effettua una ricerca generica per il valore di un parametro.
+	 * 
+	 * @param entityClass Tipo di entity da ricercare.
+	 * @param fieldName Nome del campo di ricerca.
+	 * @param fieldClass Classe del campo di ricerca.
+	 * @param fieldValue Valore del campo di ricerca.
+	 * 
+	 * @return Elenco non ordinato dei valori trovati.
+	 */
+	Collection<T> findListBy(Class<T> entityClass, String fieldName, Class<?> fieldClass, Object fieldValue);
+	
+	/**
+	 * Effettua una ricerca full con ordinamento.
+	 * 
+	 * @param entityClass Tipo di entity da ricercare.
+	 * @param order Elenco di elementi di ordinamento
+	 * @return Elenco ordinato di tutti gli elementi della tabella indicata dall'entity.
+	 */
+	Collection<T> findAll(Class<T> entityClass, Order ... order);
+	
+	/**
+	 * Verifica se esiste un record dall'id specificato.
+	 * 
+	 * @param id
+	 * @param entityClass
+	 * @return
+	 */
+	Boolean exists(Class<T> entityClass, Integer id);
+	
+	/**
+	 * Verifica se esiste un record dall'id specificato.
+	 * 
+	 * @param id
+	 * @param entityClass
+	 * @return
+	 */
+	Boolean exists(Class<T> entityClass, Long id);
+	
+	/**
+	 * Verifica se esiste un record dall'id specificato.
+	 * 
+	 * @param id
+	 * @param entityClass
+	 * @return
+	 */
+	Boolean exists(Class<T> entityClass, String id);
+	
+	/**
+	 * Ottiene una lista di risultati con una like.
+	 * 
+	 * @param fieldValue
+	 * @param clazz
+	 * @return
+	 */
+	List<T> like(Class<T> fieldClazz, String fieldName, Class<String> class1, String fieldValue);
+
+	Long count(Class<T> entityClass);
+
+	Long count(Class<T> entityClass, Filter filter);
+
+	List<T> fetch(Class<T> entityClass, Filter filter, Order... order);
+
+	boolean existsByFilename(Class<T> entityClass, SearchParameter<String> fileName);
+
+	List<Object> oneColumnQuery(final String string);
+
+	List<Object[]> manyColumnQuery(final String string);
+
+	Object findByPrimary(Class<T> entityClass, Object chiave);
+
+}

screwdriver-3.5.6/box/snippets/java/jpa2/GenericDaoImpl.java

@@ -0,0 +1,341 @@
+package +zoccolo+.jpa.dao.impl;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+import javax.persistence.EntityManager;
+import javax.persistence.PersistenceContext;
+import javax.persistence.PersistenceException;
+import javax.persistence.Tuple;
+import javax.persistence.TypedQuery;
+import javax.persistence.criteria.CriteriaBuilder;
+import javax.persistence.criteria.CriteriaQuery;
+import javax.persistence.criteria.Expression;
+import javax.persistence.criteria.Predicate;
+import javax.persistence.criteria.Root;
+import javax.persistence.Query;
+
+import org.apache.log4j.LogManager;
+import org.apache.log4j.Logger;
+import org.springframework.transaction.annotation.Transactional;
+
+import +zoccolo+.jpa.Filter;
+import +zoccolo+.jpa.Order;
+import +zoccolo+.jpa.OrderBuilder.OrderType;
+import +zoccolo+.jpa.PaginatedFilter;
+import +zoccolo+.jpa.SearchParameter;
+import +zoccolo+.jpa.dao.GenericDao;
+
+/**
+ * Implementation of the interface for dao management.<br>
+  * <b>IMPORTANT</b> - Reference to the persistence context JPA is set in this implementation.
+ *
+ * @param <T>
+ */
+public abstract class GenericDaoImpl<T> implements GenericDao<T> {
+	
+	public static final Logger logger = LogManager.getLogger(GenericDaoImpl.class);
+	
+	@PersistenceContext(unitName="+rail+EntityManagerFactory")
+	protected EntityManager em;
+	
+	protected String generateDebugParameters(List<SearchParameter<String>> parameters) {
+		if (parameters == null || parameters.size() == 0) {
+			return "[]";
+		}
+		StringBuffer paramsDebug = new StringBuffer("[");
+		for (SearchParameter<String> parameter : parameters) {
+			paramsDebug.append(" ").append(parameter.getName()).append("=").append(parameter.getValue());
+		}
+		paramsDebug.append("]");
+		
+		return paramsDebug.toString(); 
+	}
+	
+	protected List<javax.persistence.criteria.Order> createOrderClauseList(CriteriaBuilder cb, Root<T> root, Order[] order) {
+		List<javax.persistence.criteria.Order> orderList = new ArrayList<>();
+		if (order == null) return orderList;
+		
+		for (Order ord : order) {
+			if (OrderType.ASC.toString().equals(ord.getAsc())) {
+				orderList.add(cb.asc(root.get(ord.getOrder())));
+			} else {
+				orderList.add(cb.desc(root.get(ord.getOrder())));
+			}
+		}
+		return orderList;
+	}
+
+	@Override
+	@Transactional(rollbackFor=PersistenceException.class)
+	public T create(T entity) {
+		if (logger.isDebugEnabled()) logger.debug("Create entity: " + entity);
+		em.persist(entity);
+		em.flush();
+		return entity;
+	}
+
+	@Override
+	@Transactional(rollbackFor=PersistenceException.class)
+	public T update(T entity) {
+		// Check if instance is detached
+		if (!em.contains(entity)) {
+			if (logger.isDebugEnabled()) logger.debug("Update entity: " + entity);
+			entity = em.merge(entity);
+		}
+		em.flush();
+		return entity;
+	}
+
+	@Override
+	@Transactional(rollbackFor=PersistenceException.class)
+	public void remove(T entity) {
+		if (logger.isDebugEnabled()) logger.debug("Remove entity: " + entity);
+		// check if instance is detached
+		if (!em.contains(entity)) {
+			entity = em.merge(entity);
+		}
+		em.remove(entity);
+		em.flush();
+	}
+
+	@Override
+	public T findUniqueById(Class<T> entityClass, Integer id) {
+		if (logger.isDebugEnabled()) logger.debug("findUniqueById(" + entityClass.getName() + ", " + id + ")");
+		T result = em.find(entityClass, id);
+		return result;
+	}
+
+	@Override
+	public T findUniqueById(Class<T> entityClass, Long id) {
+		if (logger.isDebugEnabled()) logger.debug("findUniqueById(" + entityClass.getName() + ", " + id + ")");
+		T result = em.find(entityClass, id);
+		return result;
+	}
+	
+	@Override
+	public T findUniqueById(Class<T> entityClass, String id) {
+		if (logger.isDebugEnabled()) logger.debug("findUniqueById(" + entityClass.getName() + ", '" + id + "')");
+		T result = em.find(entityClass, id);
+		return result;
+	}
+
+	@Override
+	public Collection<T> findListBy(Class<T> entityClass, String fieldName,
+			Class<?> fieldClass, Object fieldValue) {
+		
+		CriteriaBuilder cb = em.getCriteriaBuilder();
+		
+		CriteriaQuery<T> cq = cb.createQuery(entityClass);
+		Root<T> root = cq.from(entityClass);
+		
+		Predicate predicate = cb.equal(
+				root.get(fieldName).as(fieldClass), 
+				fieldValue);
+		
+		cq.where(predicate);
+		
+		TypedQuery<T> tq = em.createQuery(cq);
+		
+		if (logger.isDebugEnabled()) logger.debug("Start of findListBy(" + entityClass + ","
+					+ " '" + fieldName + "'" + " " + fieldClass + "" + " '" + fieldValue + "')");
+		Collection<T> results = tq.getResultList();
+		
+		return results;
+	}
+	
+	@Override
+	public List<T> like(Class<T> fieldClazz, String fieldName,
+			Class<String> valueClazz, String fieldValue) {
+
+		CriteriaBuilder cb = em.getCriteriaBuilder();
+
+		CriteriaQuery<T> cq = cb.createQuery(fieldClazz);
+		Root<T> root = cq.from(fieldClazz);
+
+		
+		Predicate predicate = cb.like(
+				(Expression<String>)cb.upper( root.get(fieldName).as(valueClazz)), "%"+
+						fieldValue.toUpperCase()+"%");
+		
+		cq.where(predicate);
+		
+		TypedQuery<T> tq = em.createQuery(cq);
+
+		List<T> results = tq.getResultList();
+		
+		return results;
+	}
+
+
+	@Override
+	public Collection<T> findAll(Class<T> entityClass, Order ... order) {
+		CriteriaBuilder cb = em.getCriteriaBuilder();
+		
+		CriteriaQuery<T> cq = cb.createQuery(entityClass);
+		Root<T> root = cq.from(entityClass);
+		
+		cq.orderBy(createOrderClauseList(cb, root, order));
+		
+		TypedQuery<T> tq = em.createQuery(cq);
+		
+		if (logger.isDebugEnabled()) logger.debug("Start of findAll(" + entityClass + ")");
+		Collection<T> result = tq.getResultList();
+		
+		return result;
+	}
+
+	@Override
+	public Boolean exists(Class<T> entityClass, Long id) {
+		if (logger.isDebugEnabled()) logger.debug("Start of exists(" + entityClass + ", " + id + ")");
+		T result = em.find(entityClass, id);
+		return result == null ? false : true;
+	}
+	
+	@Override
+	public Boolean exists(Class<T> entityClass, String id) {
+		if (logger.isDebugEnabled()) logger.debug("Start of exists(" + entityClass + ", " + id + ")");
+		T result = em.find(entityClass, id);
+		return result == null ? false : true;
+	}
+	
+	/**
+	 * Metodo da implementare per effettuare un'inizializzazione di una entity
+	 * con caricamenti di dati lazy. Per default restituisce la entity
+	 * inalterata.
+	 * 
+	 * la <code>HibernateUtils.initialize()</code>.
+	 * 
+	 * @param entity
+	 * @return
+	 */
+	protected T load(T entity) {
+		return entity;
+	}
+
+	protected void setPagination(TypedQuery<Tuple> tq, Filter filter) {
+		if (filter instanceof PaginatedFilter) {
+			PaginatedFilter pfilter = (PaginatedFilter) filter;
+
+			int firstResult = pfilter.getFirstResult();
+			int pageSize = pfilter.getPageSize();
+			
+			if (logger.isTraceEnabled()) logger.trace("Range (" + firstResult + ", " + pageSize + ")");
+			tq.setFirstResult(firstResult);
+			tq.setMaxResults(pageSize);
+		}
+	}
+
+	@Override
+	public Long count(Class<T> entityClass) {
+		CriteriaBuilder cb = em.getCriteriaBuilder();
+		CriteriaQuery<Long> cq = cb.createQuery(Long.class);
+		Root<T> root = cq.from(entityClass);
+		cq.select(cb.count(root));
+
+		TypedQuery<Long> tq = em.createQuery(cq);
+		Long result = tq.getSingleResult();
+		return result;
+	}
+
+	@Override
+	public Long count(Class<T> entityClass, Filter filter) {
+		CriteriaBuilder cb = em.getCriteriaBuilder();
+		CriteriaQuery<Long> cq = cb.createQuery(Long.class);
+		Root<T> root = cq.from(entityClass);
+
+		List<Predicate> predicates = new ArrayList<>();
+		if (!filter.getParams().isEmpty()) {
+			predicates.add(getLikePredicate(cb, root, filter.getParams()));
+		}
+		if (predicates.size() > 0) {
+			cq.where(cb.and(predicates.toArray(new Predicate[] {})));
+		}
+
+		cq.select(cb.count(root));
+
+		TypedQuery<Long> tq = em.createQuery(cq);
+		Long result = tq.getSingleResult();
+		return result;
+	}
+
+	@Override
+	@SuppressWarnings("unchecked")
+	public List<T> fetch(Class<T> entityClass, Filter filter, Order... order) {
+		CriteriaBuilder cb = em.getCriteriaBuilder();
+		CriteriaQuery<Tuple> cq = cb.createTupleQuery();
+		Root<T> root = cq.from(entityClass);
+
+		List<Predicate> predicates = new ArrayList<>();
+		if (!filter.getParams().isEmpty()) {
+			predicates.add(getLikePredicate(cb, root, filter.getParams()));
+		}
+		if (predicates.size() > 0) {
+			cq.where(cb.and(predicates.toArray(new Predicate[] {})));
+		}
+
+		cq.select(cb.tuple(root));
+
+		cq.distinct(true);
+
+		cq.orderBy(createOrderClauseList(cb, root, order));
+
+		TypedQuery<Tuple> tq = em.createQuery(cq);
+
+		setPagination(tq, filter);
+		List<Tuple> results = tq.getResultList();
+		List<T> loadedResults = new ArrayList<T>();
+		for (Tuple result : results) {
+			loadedResults.add(load((T) result.get(0)));
+		}
+		return loadedResults;
+	}
+
+	@Override
+	public boolean existsByFilename(Class<T> entityClass, SearchParameter<String> fileName) {
+		CriteriaBuilder cb = em.getCriteriaBuilder();
+		CriteriaQuery<Long> cq = cb.createQuery(Long.class);
+		Root<T> root = cq.from(entityClass);
+
+		Predicate p = cb.equal(root.get(fileName.getName()).as(String.class), fileName.getValue());
+		cq.where(p);
+
+		cq.select(cb.count(root));
+
+		TypedQuery<Long> tq = em.createQuery(cq);
+		Long result = tq.getSingleResult();
+		return result > 0;
+	}
+
+	private Predicate getLikePredicate(CriteriaBuilder cb, Root<T> root, List<SearchParameter<String>> parameters) {
+		List<Predicate> orPredicates = new ArrayList<Predicate>();
+
+		for (SearchParameter<String> parameter : parameters) {
+			orPredicates.add(cb.like(cb.upper(root.get(parameter.getName()).as(String.class)), "%" + parameter.getValue().toUpperCase() + "%"));
+		}
+
+		return cb.or(orPredicates.toArray(new Predicate[] {}));
+	}
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public List<Object> oneColumnQuery(final String string) {
+		Query qu = em.createQuery(string);
+		List<Object> sE = qu.getResultList();
+		return sE;
+	}
+
+	@Override
+	public List<Object[]> manyColumnQuery(final String string) {
+		Query qu = em.createQuery(string);
+		List<Object[]> sE = qu.getResultList();
+		return sE;
+	}
+
+	@Override
+	public Object findByPrimary(Class<T> entityClass, Object chiave) {
+		Object x = em.find(entityClass, chiave);
+		return x;
+	}
+}

screwdriver-3.5.6/box/snippets/java/jpa2/Order.java

@@ -0,0 +1,8 @@
+package +zoccolo+.jpa;
+
+public interface Order {
+	
+	public String getOrder();
+	public String getAsc();
+	
+}

screwdriver-3.5.6/box/snippets/java/jpa2/OrderBuilder.java

@@ -0,0 +1,63 @@
+package +zoccolo+.jpa;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class OrderBuilder {
+
+	public static enum OrderType {
+		ASC("asc"), DESC("desc");
+
+		private String value;
+
+		private OrderType(String value) {
+			this.value = value;
+		}
+
+		@Override
+		public String toString() {
+			return this.value.toString();
+		}
+	}
+
+	private List<Order> orders;
+
+	public OrderBuilder() {
+		orders = new ArrayList<Order>();
+	}
+
+	public OrderBuilder add(final String order) {
+		orders.add(new Order() {
+			public String getOrder() {
+				return order;
+			}
+
+			public String getAsc() {
+				return OrderType.ASC.toString();
+			}
+		});
+		return this;
+	}
+
+	public OrderBuilder add(final String order, final String asc) {
+		orders.add(new Order() {
+			public String getOrder() {
+				return order;
+			}
+
+			public String getAsc() {
+				return asc;
+			}
+		});
+		return this;
+	}
+
+	public List<Order> getOrders() {
+		return orders;
+	}
+
+	public Order[] toArray() {
+		return orders.toArray(new Order[] {});
+	}
+
+}

screwdriver-3.5.6/box/snippets/java/jpa2/PaginatedFilter.java

@@ -0,0 +1,30 @@
+package +zoccolo+.jpa;
+
+public class PaginatedFilter extends Filter {
+
+	private int firstResult = 1;
+
+	private int pageSize = 5;
+
+	public PaginatedFilter(int firstResult, int pageSize) {
+		this.firstResult = firstResult;
+		this.pageSize = pageSize;
+	}
+
+	public int getFirstResult() {
+		return firstResult;
+	}
+
+	public void setFirstResult(int firstResult) {
+		this.firstResult = firstResult;
+	}
+
+	public int getPageSize() {
+		return pageSize;
+	}
+
+	public void setPageSize(int pageSize) {
+		this.pageSize = pageSize;
+	}
+
+}

screwdriver-3.5.6/box/snippets/java/jpa2/SearchParameter.java

@@ -0,0 +1,7 @@
+package +zoccolo+.jpa;
+
+public interface SearchParameter<T> {
+	String getName();
+	T getValue();
+	Class<T> getType();
+}

screwdriver-3.5.6/box/snippets/java/jpa2/SearchParameterBuilder.java

@@ -0,0 +1,71 @@
+package +zoccolo+.jpa;
+
+import javax.persistence.metamodel.SingularAttribute;
+
+public class SearchParameterBuilder {
+
+	public static SearchParameter<String> getStringParam(String name, String value) {
+		return new StringParameter(name, value);
+	}
+
+	/**
+	 * Per parametri anonimi.
+	 */
+	public static SearchParameter<String> getStringParam(String value) {
+		return getStringParam("", value);
+	}
+
+	public static <D, T> SearchParameter<T> getParam(SingularAttribute<D, T> sa, final T value) {
+		return new SingularParameter<D, T>(sa, value);
+	}
+
+	/**
+	 * Il value non deve essere null.
+	 */
+	public static <T> SearchParameter<T> getParam(final String name, final T value) {
+		return new SearchParameter<T>() {
+			@Override
+			public String getName() {
+				return name;
+			}
+
+			@Override
+			public T getValue() {
+				return value;
+			}
+
+			@SuppressWarnings("unchecked")
+			@Override
+			public Class<T> getType() {
+				return (Class<T>) value.getClass();
+			}
+		};
+	}
+
+	/**
+	 * Per parametri anonimi.
+	 */
+	public static SearchParameter<String> getParam(String value) {
+		return getParam("", value);
+	}
+
+	public static <T> SearchParameter<T> getParam(final String name, final T value, final Class<T> clazz) {
+		return new SearchParameter<T>() {
+			@Override
+			public String getName() {
+				return name;
+			}
+
+			@Override
+			public T getValue() {
+				return value;
+			}
+
+			@Override
+			public Class<T> getType() {
+				return clazz;
+			}
+		};
+	}
+
+}

screwdriver-3.5.6/box/snippets/java/jpa2/SingularParameter.java

@@ -0,0 +1,31 @@
+package +zoccolo+.jpa;
+
+import javax.persistence.metamodel.SingularAttribute;
+
+public class SingularParameter<D, T> implements SearchParameter<T> {
+
+	private final String name;
+
+	private final T value;
+
+	private final Class<T> type;
+
+	public SingularParameter(SingularAttribute<D, T> sa, T value) {
+		this.name = sa.getName();
+		this.value = value;
+		this.type = sa.getJavaType();
+	}
+
+	public String getName() {
+		return name;
+	}
+
+	public T getValue() {
+		return value;
+	}
+
+	public Class<T> getType() {
+		return type;
+	}
+
+}

screwdriver-3.5.6/box/snippets/java/jpa2/StringParameter.java

@@ -0,0 +1,26 @@
+package +zoccolo+.jpa;
+
+public class StringParameter implements SearchParameter<String> {
+
+	private final String name;
+
+	private final String value;
+
+	public StringParameter(String name, String value) {
+		this.name = name;
+		this.value = value;
+	}
+
+	public String getName() {
+		return name;
+	}
+
+	public String getValue() {
+		return value;
+	}
+
+	public Class<String> getType() {
+		return String.class;
+	}
+
+}