Merge branch 'master' into tg

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/FeedEntryDAO.java

@@ -10,6 +10,7 @@ import javax.persistence.criteria.Root;
 import javax.persistence.criteria.SetJoin;
 
 import org.apache.commons.codec.digest.DigestUtils;
+import org.hibernate.Hibernate;
 
 import com.commafeed.backend.model.Feed;
 import com.commafeed.backend.model.FeedEntry;
@@ -25,12 +26,16 @@ public class FeedEntryDAO extends GenericDAO<FeedEntry> {
 
 		CriteriaQuery<FeedEntry> query = builder.createQuery(getType());
 		Root<FeedEntry> root = query.from(getType());
-		
+
 		query.distinct(true);
 		query.where(builder.equal(root.get(FeedEntry_.guidHash), hash));
-		root.fetch(FeedEntry_.feeds, JoinType.LEFT);
+
 		TypedQuery<FeedEntry> q = em.createQuery(query);
-		return q.getResultList();
+		List<FeedEntry> list = q.getResultList();
+		for (FeedEntry entry : list) {
+			Hibernate.initialize(entry.getFeeds());
+		}
+		return list;
 	}
 
 	public List<FeedEntry> findByGuids(List<String> guids) {
@@ -41,19 +46,24 @@ public class FeedEntryDAO extends GenericDAO<FeedEntry> {
 
 		CriteriaQuery<FeedEntry> query = builder.createQuery(getType());
 		Root<FeedEntry> root = query.from(getType());
-		
+
 		query.distinct(true);
 		query.where(root.get(FeedEntry_.guidHash).in(hashes));
 		root.fetch(FeedEntry_.feeds, JoinType.LEFT);
+
 		TypedQuery<FeedEntry> q = em.createQuery(query);
-		return q.getResultList();
+		List<FeedEntry> list = q.getResultList();
+		for (FeedEntry entry : list) {
+			Hibernate.initialize(entry.getFeeds());
+		}
+		return list;
 	}
 
 	public List<FeedEntry> findByFeed(Feed feed, int offset, int limit) {
 		CriteriaQuery<FeedEntry> query = builder.createQuery(getType());
 		Root<FeedEntry> root = query.from(getType());
 		SetJoin<FeedEntry, Feed> feedsJoin = root.join(FeedEntry_.feeds);
-		
+
 		query.distinct(true);
 		query.where(builder.equal(feedsJoin.get(Feed_.id), feed.getId()));
 		query.orderBy(builder.desc(root.get(FeedEntry_.updated)));

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;
 		}
@@ -96,11 +100,11 @@ public class FeedEntryStatusDAO extends GenericDAO<FeedEntryStatus> {
 
 	public List<FeedEntryStatus> findStarred(User user, ReadingOrder order,
 			boolean includeContent) {
-		return findStarred(user, -1, -1, order, includeContent);
+		return findStarred(user, null, -1, -1, order, includeContent);
 	}
 
-	public List<FeedEntryStatus> findStarred(User user, int offset, int limit,
-			ReadingOrder order, boolean includeContent) {
+	public List<FeedEntryStatus> findStarred(User user, Date newerThan,
+			int offset, int limit, ReadingOrder order, boolean includeContent) {
 
 		CriteriaQuery<FeedEntryStatus> query = builder.createQuery(getType());
 		Root<FeedEntryStatus> root = query.from(getType());
@@ -118,6 +122,11 @@ public class FeedEntryStatusDAO extends GenericDAO<FeedEntryStatus> {
 		predicates.add(builder.equal(root.get(FeedEntryStatus_.starred), true));
 		query.where(predicates.toArray(new Predicate[0]));
 
+		if (newerThan != null) {
+			predicates.add(builder.greaterThanOrEqualTo(
+					entryJoin.get(FeedEntry_.inserted), newerThan));
+		}
+
 		orderBy(query, entryJoin, order);
 
 		TypedQuery<FeedEntryStatus> q = em.createQuery(query);
@@ -127,11 +136,12 @@ public class FeedEntryStatusDAO extends GenericDAO<FeedEntryStatus> {
 
 	public List<FeedEntryStatus> findAll(User user, boolean unreadOnly,
 			ReadingOrder order, boolean includeContent) {
-		return findAll(user, unreadOnly, -1, -1, order, includeContent);
+		return findAll(user, unreadOnly, null, -1, -1, order, includeContent);
 	}
 
 	public List<FeedEntryStatus> findAll(User user, boolean unreadOnly,
-			int offset, int limit, ReadingOrder order, boolean includeContent) {
+			Date newerThan, int offset, int limit, ReadingOrder order,
+			boolean includeContent) {
 		CriteriaQuery<FeedEntryStatus> query = builder.createQuery(getType());
 		Root<FeedEntryStatus> root = query.from(getType());
 
@@ -148,6 +158,11 @@ public class FeedEntryStatusDAO extends GenericDAO<FeedEntryStatus> {
 			predicates.add(builder.isFalse(root.get(FeedEntryStatus_.read)));
 		}
 
+		if (newerThan != null) {
+			predicates.add(builder.greaterThanOrEqualTo(
+					entryJoin.get(FeedEntry_.inserted), newerThan));
+		}
+
 		query.where(predicates.toArray(new Predicate[0]));
 		orderBy(query, entryJoin, order);
 
@@ -158,12 +173,13 @@ public class FeedEntryStatusDAO extends GenericDAO<FeedEntryStatus> {
 
 	public List<FeedEntryStatus> findByFeed(Feed feed, User user,
 			boolean unreadOnly, ReadingOrder order, boolean includeContent) {
-		return findByFeed(feed, user, unreadOnly, -1, -1, order, includeContent);
+		return findByFeed(feed, user, unreadOnly, null, -1, -1, order,
+				includeContent);
 	}
 
 	public List<FeedEntryStatus> findByFeed(Feed feed, User user,
-			boolean unreadOnly, int offset, int limit, ReadingOrder order,
-			boolean includeContent) {
+			boolean unreadOnly, Date newerThan, int offset, int limit,
+			ReadingOrder order, boolean includeContent) {
 
 		CriteriaQuery<FeedEntryStatus> query = builder.createQuery(getType());
 		Root<FeedEntryStatus> root = query.from(getType());
@@ -183,6 +199,11 @@ public class FeedEntryStatusDAO extends GenericDAO<FeedEntryStatus> {
 			predicates.add(builder.isFalse(root.get(FeedEntryStatus_.read)));
 		}
 
+		if (newerThan != null) {
+			predicates.add(builder.greaterThanOrEqualTo(
+					entryJoin.get(FeedEntry_.inserted), newerThan));
+		}
+
 		query.where(predicates.toArray(new Predicate[0]));
 
 		orderBy(query, entryJoin, order);
@@ -195,13 +216,14 @@ public class FeedEntryStatusDAO extends GenericDAO<FeedEntryStatus> {
 	public List<FeedEntryStatus> findByCategories(
 			List<FeedCategory> categories, User user, boolean unreadOnly,
 			ReadingOrder order, boolean includeContent) {
-		return findByCategories(categories, user, unreadOnly, -1, -1, order,
-				includeContent);
+		return findByCategories(categories, user, unreadOnly, null, -1, -1,
+				order, includeContent);
 	}
 
 	public List<FeedEntryStatus> findByCategories(
 			List<FeedCategory> categories, User user, boolean unreadOnly,
-			int offset, int limit, ReadingOrder order, boolean includeContent) {
+			Date newerThan, int offset, int limit, ReadingOrder order,
+			boolean includeContent) {
 
 		CriteriaQuery<FeedEntryStatus> query = builder.createQuery(getType());
 		Root<FeedEntryStatus> root = query.from(getType());
@@ -220,6 +242,11 @@ public class FeedEntryStatusDAO extends GenericDAO<FeedEntryStatus> {
 			predicates.add(builder.isFalse(root.get(FeedEntryStatus_.read)));
 		}
 
+		if (newerThan != null) {
+			predicates.add(builder.greaterThanOrEqualTo(
+					entryJoin.get(FeedEntry_.inserted), newerThan));
+		}
+
 		query.where(predicates.toArray(new Predicate[0]));
 
 		orderBy(query, entryJoin, order);

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;
 		}

src/main/java/com/commafeed/backend/pubsubhubbub/SubscriptionHandler.java

@@ -18,7 +18,6 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import com.commafeed.backend.HttpGetter;
-import com.commafeed.backend.dao.FeedDAO;
 import com.commafeed.backend.feeds.FeedRefreshTaskGiver;
 import com.commafeed.backend.feeds.FeedUtils;
 import com.commafeed.backend.model.Feed;
@@ -39,7 +38,8 @@ public class SubscriptionHandler {
 	public void subscribe(Feed feed) {
 
 		try {
-			// make sure the feed has been updated for the callback to work
+			// make sure the feed has been updated in the database so that the
+			// callback works
 			Thread.sleep(30000);
 		} catch (InterruptedException e1) {
 			// do nothing