removed easycriteria

src/main/java/com/commafeed/backend/dao/FeedCategoryDAO.java

@@ -4,6 +4,9 @@ import java.util.List;
 
 import javax.ejb.Stateless;
 import javax.persistence.NoResultException;
+import javax.persistence.criteria.CriteriaQuery;
+import javax.persistence.criteria.Predicate;
+import javax.persistence.criteria.Root;
 
 import org.apache.commons.lang.ObjectUtils;
 
@@ -12,39 +15,54 @@ import com.commafeed.backend.model.FeedCategory_;
 import com.commafeed.backend.model.User;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
-import com.uaihebert.model.EasyCriteria;
 
 @Stateless
 public class FeedCategoryDAO extends GenericDAO<FeedCategory> {
 
 	public List<FeedCategory> findAll(User user) {
-		EasyCriteria<FeedCategory> criteria = createCriteria();
-		criteria.andEquals(FeedCategory_.user.getName(), user);
 
-		criteria.innerJoinFetch(FeedCategory_.user.getName());
-		return criteria.getResultList();
+		CriteriaQuery<FeedCategory> query = builder.createQuery(getType());
+		Root<FeedCategory> root = query.from(getType());
+
+		query.where(builder.equal(root.get(FeedCategory_.user), user));
+		root.fetch(FeedCategory_.user.getName());
+
+		return em.createQuery(query).getResultList();
 	}
 
 	public FeedCategory findById(User user, Long id) {
-		EasyCriteria<FeedCategory> criteria = createCriteria();
-		criteria.andEquals(FeedCategory_.user.getName(), user);
-		criteria.andEquals(FeedCategory_.id.getName(), id);
-		return Iterables.getFirst(criteria.getResultList(), null);
+		CriteriaQuery<FeedCategory> query = builder.createQuery(getType());
+		Root<FeedCategory> root = query.from(getType());
+
+		Predicate p1 = builder.equal(root.get(FeedCategory_.user), user);
+		Predicate p2 = builder.equal(root.get(FeedCategory_.id), id);
+
+		query.where(p1, p2);
+
+		return Iterables.getFirst(em.createQuery(query).getResultList(), null);
 	}
 
 	public FeedCategory findByName(User user, String name, FeedCategory parent) {
-		EasyCriteria<FeedCategory> criteria = createCriteria();
-		criteria.andEquals(FeedCategory_.user.getName(), user);
-		criteria.andEquals(FeedCategory_.name.getName(), name);
+		CriteriaQuery<FeedCategory> query = builder.createQuery(getType());
+		Root<FeedCategory> root = query.from(getType());
+
+		List<Predicate> predicates = Lists.newArrayList();
+
+		predicates.add(builder.equal(root.get(FeedCategory_.user), user));
+		predicates.add(builder.equal(root.get(FeedCategory_.name), name));
+
 		if (parent == null) {
-			criteria.andIsNull(FeedCategory_.parent.getName());
+			predicates.add(builder.isNull(root.get(FeedCategory_.parent)));
 		} else {
-			criteria.andEquals(FeedCategory_.parent.getName(), parent);
+			predicates
+					.add(builder.equal(root.get(FeedCategory_.parent), parent));
 		}
 
+		query.where(predicates.toArray(new Predicate[0]));
+
 		FeedCategory category = null;
 		try {
-			category = criteria.getSingleResult();
+			category = em.createQuery(query).getSingleResult();
 		} catch (NoResultException e) {
 			category = null;
 		}
@@ -52,15 +70,22 @@ public class FeedCategoryDAO extends GenericDAO<FeedCategory> {
 	}
 
 	public List<FeedCategory> findByParent(User user, FeedCategory parent) {
-		EasyCriteria<FeedCategory> criteria = createCriteria();
-		criteria.andEquals(FeedCategory_.user.getName(), user);
+		CriteriaQuery<FeedCategory> query = builder.createQuery(getType());
+		Root<FeedCategory> root = query.from(getType());
+
+		List<Predicate> predicates = Lists.newArrayList();
+
+		predicates.add(builder.equal(root.get(FeedCategory_.user), user));
 		if (parent == null) {
-			criteria.andIsNull(FeedCategory_.parent.getName());
+			predicates.add(builder.isNull(root.get(FeedCategory_.parent)));
 		} else {
-			criteria.andEquals(FeedCategory_.parent.getName(), parent);
+			predicates
+					.add(builder.equal(root.get(FeedCategory_.parent), parent));
 		}
 
-		return criteria.getResultList();
+		query.where(predicates.toArray(new Predicate[0]));
+
+		return em.createQuery(query).getResultList();
 	}
 
 	public List<FeedCategory> findAllChildrenCategories(User user,

src/main/java/com/commafeed/backend/dao/FeedDAO.java

@@ -7,6 +7,7 @@ import java.util.List;
 import javax.ejb.Stateless;
 import javax.persistence.TypedQuery;
 import javax.persistence.criteria.CriteriaQuery;
+import javax.persistence.criteria.JoinType;
 import javax.persistence.criteria.Predicate;
 import javax.persistence.criteria.Root;
 
@@ -18,7 +19,6 @@ import com.commafeed.backend.model.Feed;
 import com.commafeed.backend.model.Feed_;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
-import com.uaihebert.model.EasyCriteria;
 
 @Stateless
 public class FeedDAO extends GenericDAO<Feed> {
@@ -78,13 +78,15 @@ public class FeedDAO extends GenericDAO<Feed> {
 	}
 
 	public Feed findByIdWithEntries(Long feedId, int offset, int limit) {
-		EasyCriteria<Feed> criteria = createCriteria();
-		criteria.andEquals(Feed_.id.getName(), feedId);
-		criteria.leftJoinFetch(Feed_.entries.getName());
+		CriteriaQuery<Feed> query = builder.createQuery(getType());
+		Root<Feed> root = query.from(getType());
 
-		criteria.setFirstResult(offset);
-		criteria.setMaxResults(limit);
-		return criteria.getSingleResult();
+		query.where(builder.equal(root.get(Feed_.id), feedId));
+		root.fetch(Feed_.entries, JoinType.LEFT);
+
+		TypedQuery<Feed> q = em.createQuery(query);
+		limit(q, offset, limit);
+		return q.getSingleResult();
 	}
 
 	public List<Feed> findByTopic(String topic) {

src/main/java/com/commafeed/backend/dao/FeedEntryStatusDAO.java

@@ -31,23 +31,27 @@ import com.commafeed.backend.model.User;
 import com.commafeed.backend.model.UserSettings.ReadingOrder;
 import com.google.api.client.util.Lists;
 import com.google.api.client.util.Maps;
-import com.uaihebert.model.EasyCriteria;
 
 @Stateless
 public class FeedEntryStatusDAO extends GenericDAO<FeedEntryStatus> {
 
+	@SuppressWarnings("unchecked")
 	public FeedEntryStatus findById(User user, Long id) {
 
-		EasyCriteria<FeedEntryStatus> criteria = createCriteria();
-		criteria.andEquals(FeedEntryStatus_.id.getName(), id);
+		CriteriaQuery<FeedEntryStatus> query = builder.createQuery(getType());
+		Root<FeedEntryStatus> root = query.from(getType());
 
-		criteria.innerJoinFetch(FeedEntryStatus_.subscription.getName());
-		criteria.andJoinEquals(FeedEntryStatus_.subscription.getName(),
-				FeedSubscription_.user.getName(), user);
+		Join<FeedEntryStatus, FeedSubscription> join = (Join<FeedEntryStatus, FeedSubscription>) root
+				.fetch(FeedEntryStatus_.subscription);
+
+		Predicate p1 = builder.equal(root.get(FeedEntryStatus_.id), id);
+		Predicate p2 = builder.equal(join.get(FeedSubscription_.user), user);
+
+		query.where(p1, p2);
 
 		FeedEntryStatus status = null;
 		try {
-			status = criteria.getSingleResult();
+			status = em.createQuery(query).getSingleResult();
 		} catch (NoResultException e) {
 			status = null;
 		}

src/main/java/com/commafeed/backend/dao/FeedSubscriptionDAO.java

@@ -3,6 +3,10 @@ package com.commafeed.backend.dao;
 import java.util.List;
 
 import javax.ejb.Stateless;
+import javax.persistence.criteria.CriteriaQuery;
+import javax.persistence.criteria.JoinType;
+import javax.persistence.criteria.Predicate;
+import javax.persistence.criteria.Root;
 
 import com.commafeed.backend.model.Feed;
 import com.commafeed.backend.model.FeedCategory;
@@ -10,59 +14,83 @@ import com.commafeed.backend.model.FeedSubscription;
 import com.commafeed.backend.model.FeedSubscription_;
 import com.commafeed.backend.model.User;
 import com.google.common.collect.Iterables;
-import com.uaihebert.factory.EasyCriteriaFactory;
-import com.uaihebert.model.EasyCriteria;
 
 @Stateless
 public class FeedSubscriptionDAO extends GenericDAO<FeedSubscription> {
 
 	public FeedSubscription findById(User user, Long id) {
-		EasyCriteria<FeedSubscription> criteria = createCriteria();
-		criteria.andEquals(FeedSubscription_.user.getName(), user);
-		criteria.andEquals(FeedSubscription_.id.getName(), id);
-		criteria.leftJoinFetch(FeedSubscription_.feed.getName());
-		criteria.leftJoinFetch(FeedSubscription_.category.getName());
-		return Iterables.getFirst(criteria.getResultList(), null);
+		CriteriaQuery<FeedSubscription> query = builder.createQuery(getType());
+		Root<FeedSubscription> root = query.from(getType());
+
+		Predicate p1 = builder.equal(root.get(FeedSubscription_.user), user);
+		Predicate p2 = builder.equal(root.get(FeedSubscription_.id), id);
+
+		root.fetch(FeedSubscription_.feed, JoinType.LEFT);
+		root.fetch(FeedSubscription_.category, JoinType.LEFT);
+
+		query.where(p1, p2);
+
+		return Iterables.getFirst(em.createQuery(query).getResultList(), null);
 	}
 
 	public List<FeedSubscription> findByFeed(Feed feed) {
-		EasyCriteria<FeedSubscription> criteria = createCriteria();
-		criteria.andEquals(FeedSubscription_.feed.getName(), feed);
-		return criteria.getResultList();
+		return findByField(FeedSubscription_.feed, feed);
 	}
 
 	public FeedSubscription findByFeed(User user, Feed feed) {
-		EasyCriteria<FeedSubscription> criteria = createCriteria();
-		criteria.andEquals(FeedSubscription_.user.getName(), user);
-		criteria.andEquals(FeedSubscription_.feed.getName(), feed);
-		return Iterables.getFirst(criteria.getResultList(), null);
+
+		CriteriaQuery<FeedSubscription> query = builder.createQuery(getType());
+		Root<FeedSubscription> root = query.from(getType());
+
+		Predicate p1 = builder.equal(root.get(FeedSubscription_.user), user);
+		Predicate p2 = builder.equal(root.get(FeedSubscription_.feed), feed);
+
+		root.fetch(FeedSubscription_.feed, JoinType.LEFT);
+		root.fetch(FeedSubscription_.category, JoinType.LEFT);
+
+		query.where(p1, p2);
+
+		return Iterables.getFirst(em.createQuery(query).getResultList(), null);
 	}
 
 	public List<FeedSubscription> findAll(User user) {
-		EasyCriteria<FeedSubscription> criteria = createCriteria();
-		criteria.andEquals(FeedSubscription_.user.getName(), user);
 
-		criteria.innerJoinFetch(FeedSubscription_.feed.getName());
-		criteria.leftJoinFetch(FeedSubscription_.category.getName());
-		return criteria.getResultList();
+		CriteriaQuery<FeedSubscription> query = builder.createQuery(getType());
+		Root<FeedSubscription> root = query.from(getType());
+
+		root.fetch(FeedSubscription_.feed, JoinType.LEFT);
+		root.fetch(FeedSubscription_.category, JoinType.LEFT);
+
+		query.where(builder.equal(root.get(FeedSubscription_.user), user));
+
+		return em.createQuery(query).getResultList();
 	}
 
 	public List<FeedSubscription> findByCategory(User user,
 			FeedCategory category) {
-		EasyCriteria<FeedSubscription> criteria = EasyCriteriaFactory
-				.createQueryCriteria(em, getType());
-		criteria.andEquals(FeedSubscription_.user.getName(), user);
-		criteria.andEquals(FeedSubscription_.category.getName(), category);
-		return criteria.getResultList();
 
+		CriteriaQuery<FeedSubscription> query = builder.createQuery(getType());
+		Root<FeedSubscription> root = query.from(getType());
+
+		Predicate p1 = builder.equal(root.get(FeedSubscription_.user), user);
+		Predicate p2 = builder.equal(root.get(FeedSubscription_.category),
+				category);
+
+		query.where(p1, p2);
+
+		return em.createQuery(query).getResultList();
 	}
 
 	public List<FeedSubscription> findWithoutCategories(User user) {
-		EasyCriteria<FeedSubscription> criteria = EasyCriteriaFactory
-				.createQueryCriteria(em, getType());
-		criteria.andEquals(FeedSubscription_.user.getName(), user);
-		criteria.andIsNull(FeedSubscription_.category.getName());
-		return criteria.getResultList();
 
+		CriteriaQuery<FeedSubscription> query = builder.createQuery(getType());
+		Root<FeedSubscription> root = query.from(getType());
+
+		Predicate p1 = builder.equal(root.get(FeedSubscription_.user), user);
+		Predicate p2 = builder.isNull(root.get(FeedSubscription_.category));
+
+		query.where(p1, p2);
+
+		return em.createQuery(query).getResultList();
 	}
 }

src/main/java/com/commafeed/backend/dao/GenericDAO.java

@@ -17,8 +17,6 @@ import org.hibernate.Session;
 
 import com.commafeed.backend.model.AbstractModel;
 import com.google.common.reflect.TypeToken;
-import com.uaihebert.factory.EasyCriteriaFactory;
-import com.uaihebert.model.EasyCriteria;
 
 @SuppressWarnings("serial")
 public abstract class GenericDAO<T extends AbstractModel> {
@@ -73,30 +71,36 @@ public abstract class GenericDAO<T extends AbstractModel> {
 	}
 
 	public List<T> findAll() {
-		return EasyCriteriaFactory.createQueryCriteria(em, getType())
-				.getResultList();
+		CriteriaQuery<T> query = builder.createQuery(getType());
+		query.from(getType());
+		return em.createQuery(query).getResultList();
 	}
 
 	public List<T> findAll(int startIndex, int count) {
-		EasyCriteria<T> criteria = EasyCriteriaFactory.createQueryCriteria(em,
-				getType());
-		criteria.setMaxResults(count);
-		criteria.setFirstResult(startIndex);
-		return criteria.getResultList();
+		CriteriaQuery<T> query = builder.createQuery(getType());
+		query.from(getType());
+		TypedQuery<T> q = em.createQuery(query);
+		q.setMaxResults(count);
+		q.setFirstResult(startIndex);
+		return q.getResultList();
 	}
 
 	public List<T> findAll(int startIndex, int count, String orderBy,
 			boolean asc) {
-		EasyCriteria<T> criteria = EasyCriteriaFactory.createQueryCriteria(em,
-				getType());
-		criteria.setMaxResults(count);
-		criteria.setFirstResult(startIndex);
+
+		CriteriaQuery<T> query = builder.createQuery(getType());
+		Root<T> root = query.from(getType());
+
 		if (asc) {
-			criteria.orderByAsc(orderBy);
+			query.orderBy(builder.asc(root.get(orderBy)));
 		} else {
-			criteria.orderByDesc(orderBy);
+			query.orderBy(builder.desc(root.get(orderBy)));
 		}
-		return criteria.getResultList();
+
+		TypedQuery<T> q = em.createQuery(query);
+		q.setMaxResults(count);
+		q.setFirstResult(startIndex);
+		return q.getResultList();
 	}
 
 	public long getCount() {
@@ -107,10 +111,12 @@ public abstract class GenericDAO<T extends AbstractModel> {
 		return em.createQuery(query).getSingleResult();
 	}
 
-	public <V> List<T> findByField(Attribute<T, V> field, V value) {
-		EasyCriteria<T> criteria = createCriteria();
-		criteria.andEquals(field.getName(), value);
-		return criteria.getResultList();
+	protected <V> List<T> findByField(Attribute<T, V> field, V value) {
+		CriteriaQuery<T> query = builder.createQuery(getType());
+		Root<T> root = query.from(getType());
+
+		query.where(builder.equal(root.get(field.getName()), value));
+		return em.createQuery(query).getResultList();
 	}
 
 	protected void limit(TypedQuery<?> query, int offset, int limit) {
@@ -126,8 +132,4 @@ public abstract class GenericDAO<T extends AbstractModel> {
 	protected Class<T> getType() {
 		return (Class<T>) type.getRawType();
 	}
-
-	public EasyCriteria<T> createCriteria() {
-		return EasyCriteriaFactory.createQueryCriteria(em, getType());
-	}
 }

src/main/java/com/commafeed/backend/dao/UserRoleDAO.java

@@ -4,25 +4,28 @@ import java.util.List;
 import java.util.Set;
 
 import javax.ejb.Stateless;
+import javax.persistence.criteria.CriteriaQuery;
+import javax.persistence.criteria.JoinType;
+import javax.persistence.criteria.Root;
 
 import com.commafeed.backend.model.User;
 import com.commafeed.backend.model.UserRole;
 import com.commafeed.backend.model.UserRole.Role;
 import com.commafeed.backend.model.UserRole_;
 import com.google.common.collect.Sets;
-import com.uaihebert.factory.EasyCriteriaFactory;
-import com.uaihebert.model.EasyCriteria;
 
 @Stateless
 public class UserRoleDAO extends GenericDAO<UserRole> {
 
 	@Override
 	public List<UserRole> findAll() {
-		EasyCriteria<UserRole> criteria = EasyCriteriaFactory
-				.createQueryCriteria(em, getType());
-		criteria.setDistinctTrue();
-		criteria.leftJoinFetch(UserRole_.user.getName());
-		return criteria.getResultList();
+		CriteriaQuery<UserRole> query = builder.createQuery(getType());
+		Root<UserRole> root = query.from(getType());
+		query.distinct(true);
+
+		root.fetch(UserRole_.user, JoinType.LEFT);
+
+		return em.createQuery(query).getResultList();
 	}
 
 	public List<UserRole> findAll(User user) {

src/main/java/com/commafeed/backend/dao/UserSettingsDAO.java

@@ -2,25 +2,26 @@ package com.commafeed.backend.dao;
 
 import javax.ejb.Stateless;
 import javax.persistence.NoResultException;
+import javax.persistence.criteria.CriteriaQuery;
+import javax.persistence.criteria.Root;
 
 import com.commafeed.backend.model.User;
 import com.commafeed.backend.model.UserSettings;
 import com.commafeed.backend.model.UserSettings_;
-import com.uaihebert.factory.EasyCriteriaFactory;
-import com.uaihebert.model.EasyCriteria;
 
 @Stateless
 public class UserSettingsDAO extends GenericDAO<UserSettings> {
 
 	public UserSettings findByUser(User user) {
 
-		EasyCriteria<UserSettings> criteria = EasyCriteriaFactory
-				.createQueryCriteria(em, getType());
-		criteria.andEquals(UserSettings_.user.getName(), user);
+		CriteriaQuery<UserSettings> query = builder.createQuery(getType());
+		Root<UserSettings> root = query.from(getType());
+
+		query.where(builder.equal(root.get(UserSettings_.user), user));
 
 		UserSettings settings = null;
 		try {
-			settings = criteria.getSingleResult();
+			settings = em.createQuery(query).getSingleResult();
 		} catch (NoResultException e) {
 			settings = null;
 		}