View difference between Paste ID: QJnkYRRh and cAt1zCrc

-package com.blog.repo;
+package com.project.repo;
 
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.Map;
 
 import javax.persistence.criteria.CriteriaBuilder;
 import javax.persistence.criteria.CriteriaQuery;
 import javax.persistence.criteria.Expression;
 import javax.persistence.criteria.Path;
 import javax.persistence.criteria.Predicate;
 import javax.persistence.criteria.Root;
 
 public abstract class RefineableDao {
 	private final Map<String,Refinement> allowedRefinements = new HashMap<String,Refinement>();
 
 	protected enum RefineType{
 		STRING,
 		LIST,
 		GREATER,
 		LESSER,
 	}
 
 	public class Refinement{
 		protected final String field;
 		protected final RefineType enumType;
 
 		public Refinement(final String field, final RefineType enumType){
 			this.field = field;
 			this.enumType = enumType;
 		}
 
 		public RefineType getEnum(){
 			return enumType;
 		}
 
 		public String getField(){
 			return field;
 		}
 	}
 
 	/**
 	 * Create refined query with unspecified root.
 	 * @param refine
 	 * @param cb
 	 * @param query
 	 * @param cls
 	 * @return
 	 */
 	@SuppressWarnings("unchecked")
 	protected <T> Predicate refineQuery(final Map<String,Object> refine, final CriteriaBuilder cb, final CriteriaQuery<T> query, final Class<T> cls){
 		Root<T> root = null;
 		for(Root<?> tempRoot : query.getRoots()){
 			//Check if a root already exists for incoming class. Assume we're intending to refine that one.
 			if(tempRoot.getJavaType().equals(cls)){
 				root = (Root<T>)tempRoot;
 				break;
 			}
 		}
 		if(root == null){
 			//Create new root.
 			root = query.from(cls);
 		}
 		return this.refineQuery(refine, cb, query, root);
 	}
 
 	/**
 	 * Create refined query with specified root.
 	 * @param refine
 	 * @param cb
 	 * @param query
 	 * @param root
 	 * @return
 	 */
 	@SuppressWarnings("unchecked")
 	protected <T> Predicate refineQuery(final Map<String,Object> refine, final CriteriaBuilder cb, final CriteriaQuery<T> query, final Root<?> root){
 		Predicate predicate = cb.conjunction();
 		for(String key : refine.keySet()){
 			Object refineObj = refine.get(key);
 			Object[] iterable;
 			//Convert to an array of objects. Make sure it's iterable.
 			if(allowedRefinements.get(key).getEnum() != RefineType.LIST && refineObj instanceof Collection){
 				iterable = ((Collection<Object>)refineObj).toArray();
 			}else if(refineObj instanceof Object[]){
 				iterable = (Object[])refineObj;
 			}else{
 				iterable = new Object[]{refineObj};
 			}
 			for(Object obj : iterable){
 				Refinement refinement = allowedRefinements.get(key);
 
 				switch(allowedRefinements.get(key).getEnum()){
 				case STRING:
 					Expression<String> path = root.get(refinement.getField());
 					//Lower case to make searching case insensitive.
 					path = cb.lower(path);
 					predicate = cb.and(predicate,cb.like(path, "%".concat(((String)obj).toLowerCase()).concat("%")));
 					break;
 				case LIST:
 					String[] fields = refinement.getField().split("\\.");
 					if(fields.length == 0){
 						fields = new String[]{refinement.getField()};
 					}
 					Path<?> pathList = null;
 					for(String field : fields){
 						pathList = pathList == null ? root.get(field) : pathList.get(field);
 					}
 					predicate = cb.and(predicate,pathList.in(obj));
 					break;
 				case GREATER:
 					Expression<Double> pathNum = root.get(refinement.getField());
 					predicate = cb.and(predicate,cb.greaterThanOrEqualTo(pathNum, Double.parseDouble(obj.toString())));
 					break;
 				case LESSER:
 					pathNum = root.get(refinement.getField());
 					predicate = cb.and(predicate,cb.lessThanOrEqualTo(pathNum, Double.parseDouble(obj.toString())));
 					break;
 				}
 			}
 		}
 		return predicate;
 	}
 
 	public Map<String, Refinement> getAllowedRefinements() {
 		return allowedRefinements;
 	}
 }