Archives/Athou_commafeed
1
0
Fork 1
mirror of https://github.com/Athou/commafeed.git synced 2026-03-21 21:37:29 +00:00
Code Issues Packages Projects Releases Wiki Activity

removed wicket and tomee, use dropwizard instead. remove wro4j, use gulp instead

Browse Source
This commit is contained in:
Athou
2014-08-08 16:49:02 +02:00
parent bbcd79e49f
commit 986fd25942
357 changed files with 2178 additions and 19556 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
src/main/java/com/commafeed/backend/dao/ApplicationSettingsDAO.java
View File

@@ -1,10 +0,0 @@
package com.commafeed.backend.dao;
import javax.ejb.Stateless;
import com.commafeed.backend.model.ApplicationSettings;
@Stateless
public class ApplicationSettingsDAO extends GenericDAO<ApplicationSettings> {
}

81
src/main/java/com/commafeed/backend/dao/FeedCategoryDAO.java
View File

@@ -2,91 +2,50 @@ package com.commafeed.backend.dao;
import java.util.List;
import javax.ejb.Stateless;
import javax.persistence.NoResultException;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Join;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import org.apache.commons.lang.ObjectUtils;
import org.hibernate.SessionFactory;
import com.commafeed.backend.model.FeedCategory;
import com.commafeed.backend.model.FeedCategory_;
import com.commafeed.backend.model.QFeedCategory;
import com.commafeed.backend.model.QUser;
import com.commafeed.backend.model.User;
import com.commafeed.backend.model.User_;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import com.mysema.query.types.Predicate;
@Stateless
public class FeedCategoryDAO extends GenericDAO<FeedCategory> {
@SuppressWarnings("unchecked")
private QFeedCategory category = QFeedCategory.feedCategory;
public FeedCategoryDAO(SessionFactory sessionFactory) {
super(sessionFactory);
}
public List<FeedCategory> findAll(User user) {
CriteriaQuery<FeedCategory> query = builder.createQuery(getType());
Root<FeedCategory> root = query.from(getType());
Join<FeedCategory, User> userJoin = (Join<FeedCategory, User>) root.fetch(FeedCategory_.user);
query.where(builder.equal(userJoin.get(User_.id), user.getId()));
return cache(em.createQuery(query)).getResultList();
return newQuery().from(category).where(category.user.eq(user)).join(category.user, QUser.user).fetch().list(category);
}
public FeedCategory findById(User user, Long id) {
CriteriaQuery<FeedCategory> query = builder.createQuery(getType());
Root<FeedCategory> root = query.from(getType());
Predicate p1 = builder.equal(root.get(FeedCategory_.user).get(User_.id), user.getId());
Predicate p2 = builder.equal(root.get(FeedCategory_.id), id);
query.where(p1, p2);
return Iterables.getFirst(cache(em.createQuery(query)).getResultList(), null);
return newQuery().from(category).where(category.user.eq(user), category.id.eq(id)).uniqueResult(category);
}
public FeedCategory findByName(User user, String name, FeedCategory parent) {
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));
Predicate parentPredicate = null;
if (parent == null) {
predicates.add(builder.isNull(root.get(FeedCategory_.parent)));
parentPredicate = category.parent.isNull();
} else {
predicates.add(builder.equal(root.get(FeedCategory_.parent), parent));
parentPredicate = category.parent.eq(parent);
}
query.where(predicates.toArray(new Predicate[0]));
FeedCategory category = null;
try {
category = em.createQuery(query).getSingleResult();
} catch (NoResultException e) {
category = null;
}
return category;
return newQuery().from(category).where(category.user.eq(user), category.name.eq(name), parentPredicate).uniqueResult(category);
}
public List<FeedCategory> findByParent(User user, FeedCategory parent) {
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));
Predicate parentPredicate = null;
if (parent == null) {
predicates.add(builder.isNull(root.get(FeedCategory_.parent)));
parentPredicate = category.parent.isNull();
} else {
predicates.add(builder.equal(root.get(FeedCategory_.parent), parent));
parentPredicate = category.parent.eq(parent);
}
query.where(predicates.toArray(new Predicate[0]));
return em.createQuery(query).getResultList();
return newQuery().from(category).where(category.user.eq(user), parentPredicate).list(category);
}
public List<FeedCategory> findAllChildrenCategories(User user, FeedCategory parent) {

119
src/main/java/com/commafeed/backend/dao/FeedDAO.java
View File

@@ -3,104 +3,75 @@ package com.commafeed.backend.dao;
import java.util.Date;
import java.util.List;
import javax.ejb.Stateless;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Join;
import javax.persistence.criteria.JoinType;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import javax.persistence.criteria.SetJoin;
import javax.persistence.criteria.Subquery;
import org.apache.commons.codec.digest.DigestUtils;
import org.apache.commons.lang.StringUtils;
import org.hibernate.SessionFactory;
import com.commafeed.backend.feeds.FeedUtils;
import com.commafeed.backend.model.Feed;
import com.commafeed.backend.model.FeedSubscription;
import com.commafeed.backend.model.FeedSubscription_;
import com.commafeed.backend.model.Feed_;
import com.commafeed.backend.model.User;
import com.commafeed.backend.model.User_;
import com.commafeed.backend.model.QFeed;
import com.commafeed.backend.model.QFeedSubscription;
import com.commafeed.backend.model.QUser;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import com.mysema.query.BooleanBuilder;
import com.mysema.query.jpa.hibernate.HibernateQuery;
import com.mysema.query.jpa.hibernate.HibernateSubQuery;
@Stateless
public class FeedDAO extends GenericDAO<Feed> {
private List<Predicate> getUpdatablePredicates(CriteriaQuery<?> query, Root<Feed> root, Date lastLoginThreshold) {
private QFeed feed = QFeed.feed;
List<Predicate> preds = Lists.newArrayList();
Predicate isNull = builder.isNull(root.get(Feed_.disabledUntil));
Predicate lessThan = builder.lessThan(root.get(Feed_.disabledUntil), new Date());
preds.add(builder.or(isNull, lessThan));
if (lastLoginThreshold != null) {
Subquery<Long> subquery = query.subquery(Long.class);
Root<FeedSubscription> subroot = subquery.from(FeedSubscription.class);
subquery.select(builder.count(subroot.get(FeedSubscription_.id)));
Join<FeedSubscription, User> userJoin = subroot.join(FeedSubscription_.user);
Predicate p1 = builder.equal(subroot.get(FeedSubscription_.feed), root);
Predicate p2 = builder.greaterThanOrEqualTo(userJoin.get(User_.lastLogin), lastLoginThreshold);
subquery.where(p1, p2);
preds.add(builder.exists(subquery));
}
return preds;
public FeedDAO(SessionFactory sessionFactory) {
super(sessionFactory);
}
public Long getUpdatableCount(Date lastLoginThreshold) {
CriteriaQuery<Long> query = builder.createQuery(Long.class);
Root<Feed> root = query.from(getType());
BooleanBuilder disabledDatePredicate = new BooleanBuilder();
disabledDatePredicate.or(feed.disabledUntil.isNull());
disabledDatePredicate.or(feed.disabledUntil.lt(new Date()));
query.select(builder.count(root));
query.where(getUpdatablePredicates(query, root, lastLoginThreshold).toArray(new Predicate[0]));
TypedQuery<Long> q = em.createQuery(query);
return q.getSingleResult();
HibernateQuery query = newQuery().from(feed).where(disabledDatePredicate);
if (lastLoginThreshold != null) {
QFeedSubscription sub = QFeedSubscription.feedSubscription;
QUser user = QUser.user;
HibernateSubQuery subquery = new HibernateSubQuery();
subquery.from(sub).join(sub.user, user).where(sub.feed.eq(feed), user.lastLogin.gt(lastLoginThreshold));
query.where(subquery.exists());
}
return query.orderBy(feed.disabledUntil.asc()).count();
}
public List<Feed> findNextUpdatable(int count, Date lastLoginThreshold) {
CriteriaQuery<Feed> query = builder.createQuery(getType());
Root<Feed> root = query.from(getType());
BooleanBuilder disabledDatePredicate = new BooleanBuilder();
disabledDatePredicate.or(feed.disabledUntil.isNull());
disabledDatePredicate.or(feed.disabledUntil.lt(new Date()));
query.where(getUpdatablePredicates(query, root, lastLoginThreshold).toArray(new Predicate[0]));
query.orderBy(builder.asc(root.get(Feed_.disabledUntil)));
TypedQuery<Feed> q = em.createQuery(query);
q.setMaxResults(count);
return q.getResultList();
}
public Feed findByUrl(String url) {
String normalized = FeedUtils.normalizeURL(url);
List<Feed> feeds = findByField(Feed_.normalizedUrlHash, DigestUtils.sha1Hex(normalized));
Feed feed = Iterables.getFirst(feeds, null);
if (feed != null && StringUtils.equals(normalized, feed.getNormalizedUrl())) {
return feed;
HibernateQuery query = newQuery().from(feed).where(disabledDatePredicate);
if (lastLoginThreshold != null) {
QFeedSubscription sub = QFeedSubscription.feedSubscription;
QUser user = QUser.user;
HibernateSubQuery subquery = new HibernateSubQuery();
subquery.from(sub).join(sub.user, user).where(sub.feed.eq(feed), user.lastLogin.gt(lastLoginThreshold));
query.where(subquery.exists());
}
return query.orderBy(feed.disabledUntil.asc()).limit(count).list(feed);
}
public Feed findByUrl(String normalizedUrl) {
List<Feed> feeds = newQuery().from(feed).where(feed.normalizedUrlHash.eq(DigestUtils.sha1Hex(normalizedUrl))).list(feed);
Feed feed = Iterables.getFirst(feeds, null);
if (feed != null && StringUtils.equals(normalizedUrl, feed.getNormalizedUrl())) {
return feed;
}
return null;
}
public List<Feed> findByTopic(String topic) {
return findByField(Feed_.pushTopicHash, DigestUtils.sha1Hex(topic));
return newQuery().from(feed).where(feed.pushTopicHash.eq(DigestUtils.sha1Hex(topic))).list(feed);
}
public List<Feed> findWithoutSubscriptions(int max) {
CriteriaQuery<Feed> query = builder.createQuery(getType());
Root<Feed> root = query.from(getType());
SetJoin<Feed, FeedSubscription> join = root.join(Feed_.subscriptions, JoinType.LEFT);
query.where(builder.isNull(join.get(FeedSubscription_.id)));
TypedQuery<Feed> q = em.createQuery(query);
q.setMaxResults(max);
return q.getResultList();
QFeedSubscription sub = QFeedSubscription.feedSubscription;
return newQuery().from(feed).leftJoin(feed.subscriptions, sub).where(sub.id.isNull()).limit(max).list(feed);
}
}

50
src/main/java/com/commafeed/backend/dao/FeedEntryContentDAO.java
View File

@@ -2,52 +2,34 @@ package com.commafeed.backend.dao;
import java.util.List;
import javax.ejb.Stateless;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Join;
import javax.persistence.criteria.JoinType;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import org.hibernate.SessionFactory;
import com.commafeed.backend.model.FeedEntry;
import com.commafeed.backend.model.FeedEntryContent;
import com.commafeed.backend.model.FeedEntryContent_;
import com.commafeed.backend.model.FeedEntry_;
import com.commafeed.backend.model.QFeedEntry;
import com.commafeed.backend.model.QFeedEntryContent;
import com.google.common.collect.Iterables;
import com.mysema.query.types.ConstructorExpression;
@Stateless
public class FeedEntryContentDAO extends GenericDAO<FeedEntryContent> {
private QFeedEntryContent content = QFeedEntryContent.feedEntryContent;
public FeedEntryContentDAO(SessionFactory sessionFactory) {
super(sessionFactory);
}
public Long findExisting(String contentHash, String titleHash) {
CriteriaQuery<Long> query = builder.createQuery(Long.class);
Root<FeedEntryContent> root = query.from(getType());
query.select(root.get(FeedEntryContent_.id));
Predicate p1 = builder.equal(root.get(FeedEntryContent_.contentHash), contentHash);
Predicate p2 = builder.equal(root.get(FeedEntryContent_.titleHash), titleHash);
query.where(p1, p2);
TypedQuery<Long> q = em.createQuery(query);
limit(q, 0, 1);
return Iterables.getFirst(q.getResultList(), null);
List<Long> list = newQuery().from(content).where(content.contentHash.eq(contentHash), content.titleHash.eq(titleHash)).limit(1)
.list(ConstructorExpression.create(Long.class, content.id));
return Iterables.getFirst(list, null);
}
public int deleteWithoutEntries(int max) {
CriteriaQuery<FeedEntryContent> query = builder.createQuery(getType());
Root<FeedEntryContent> root = query.from(getType());
Join<FeedEntryContent, FeedEntry> join = root.join(FeedEntryContent_.entries, JoinType.LEFT);
query.where(builder.isNull(join.get(FeedEntry_.id)));
TypedQuery<FeedEntryContent> q = em.createQuery(query);
q.setMaxResults(max);
List<FeedEntryContent> list = q.getResultList();
QFeedEntry entry = QFeedEntry.feedEntry;
List<FeedEntryContent> list = newQuery().from(content).leftJoin(content.entries, entry).where(entry.id.isNull()).limit(max)
.list(content);
int deleted = list.size();
delete(list);
return deleted;
}
}

71
src/main/java/com/commafeed/backend/dao/FeedEntryDAO.java
View File

@@ -3,82 +3,47 @@ package com.commafeed.backend.dao;
import java.util.Date;
import java.util.List;
import javax.ejb.Stateless;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Join;
import javax.persistence.criteria.JoinType;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import javax.persistence.criteria.SetJoin;
import org.apache.commons.codec.digest.DigestUtils;
import org.hibernate.SessionFactory;
import com.commafeed.backend.model.Feed;
import com.commafeed.backend.model.FeedEntry;
import com.commafeed.backend.model.FeedEntry_;
import com.commafeed.backend.model.FeedSubscription;
import com.commafeed.backend.model.FeedSubscription_;
import com.commafeed.backend.model.Feed_;
import com.commafeed.backend.model.QFeed;
import com.commafeed.backend.model.QFeedEntry;
import com.commafeed.backend.model.QFeedSubscription;
import com.google.common.collect.Iterables;
import com.mysema.query.types.ConstructorExpression;
@Stateless
public class FeedEntryDAO extends GenericDAO<FeedEntry> {
public Long findExisting(String guid, Long feedId) {
private QFeedEntry entry = QFeedEntry.feedEntry;
CriteriaQuery<Long> query = builder.createQuery(Long.class);
Root<FeedEntry> root = query.from(getType());
query.select(root.get(FeedEntry_.id));
public FeedEntryDAO(SessionFactory sessionFactory) {
super(sessionFactory);
}
Predicate p1 = builder.equal(root.get(FeedEntry_.guidHash), DigestUtils.sha1Hex(guid));
Predicate p2 = builder.equal(root.get(FeedEntry_.feed).get(Feed_.id), feedId);
query.where(p1, p2);
TypedQuery<Long> q = em.createQuery(query);
limit(q, 0, 1);
List<Long> list = q.getResultList();
public Long findExisting(String guid, Feed feed) {
List<Long> list = newQuery().from(entry).where(entry.guidHash.eq(DigestUtils.sha1Hex(guid)), entry.feed.eq(feed)).limit(1)
.list(ConstructorExpression.create(Long.class, entry.id));
return Iterables.getFirst(list, null);
}
public List<FeedEntry> findWithoutSubscriptions(int max) {
CriteriaQuery<FeedEntry> query = builder.createQuery(getType());
Root<FeedEntry> root = query.from(getType());
Join<FeedEntry, Feed> feedJoin = root.join(FeedEntry_.feed);
SetJoin<Feed, FeedSubscription> subJoin = feedJoin.join(Feed_.subscriptions, JoinType.LEFT);
query.where(builder.isNull(subJoin.get(FeedSubscription_.id)));
TypedQuery<FeedEntry> q = em.createQuery(query);
q.setMaxResults(max);
return q.getResultList();
QFeed feed = QFeed.feed;
QFeedSubscription sub = QFeedSubscription.feedSubscription;
return newQuery().from(entry).join(entry.feed, feed).leftJoin(feed.subscriptions, sub).where(sub.id.isNull()).limit(max)
.list(entry);
}
public int delete(Feed feed, int max) {
CriteriaQuery<FeedEntry> query = builder.createQuery(getType());
Root<FeedEntry> root = query.from(getType());
query.where(builder.equal(root.get(FeedEntry_.feed), feed));
TypedQuery<FeedEntry> q = em.createQuery(query);
q.setMaxResults(max);
List<FeedEntry> list = q.getResultList();
List<FeedEntry> list = newQuery().from(entry).where(entry.feed.eq(feed)).limit(max).list(entry);
int deleted = list.size();
delete(list);
return deleted;
}
public int delete(Date olderThan, int max) {
CriteriaQuery<FeedEntry> query = builder.createQuery(getType());
Root<FeedEntry> root = query.from(getType());
query.where(builder.lessThan(root.get(FeedEntry_.inserted), olderThan));
TypedQuery<FeedEntry> q = em.createQuery(query);
q.setMaxResults(max);
List<FeedEntry> list = q.getResultList();
List<FeedEntry> list = newQuery().from(entry).where(entry.inserted.lt(olderThan)).limit(max).list(entry);
int deleted = list.size();
delete(list);
return deleted;

166
src/main/java/com/commafeed/backend/dao/FeedEntryStatusDAO.java
View File

@@ -5,18 +5,10 @@ import java.util.Date;
import java.util.List;
import java.util.Map;
import javax.ejb.Stateless;
import javax.inject.Inject;
import javax.persistence.Query;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Path;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang3.builder.CompareToBuilder;
import org.apache.commons.lang.builder.CompareToBuilder;
import org.hibernate.Criteria;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.Conjunction;
import org.hibernate.criterion.Disjunction;
import org.hibernate.criterion.MatchMode;
@@ -27,33 +19,44 @@ import org.hibernate.criterion.Restrictions;
import org.hibernate.sql.JoinType;
import org.hibernate.transform.Transformers;
import com.commafeed.CommaFeedConfiguration;
import com.commafeed.backend.FixedSizeSortedSet;
import com.commafeed.backend.model.FeedEntry;
import com.commafeed.backend.model.FeedEntryContent_;
import com.commafeed.backend.model.FeedEntryStatus;
import com.commafeed.backend.model.FeedEntryStatus_;
import com.commafeed.backend.model.FeedEntryTag;
import com.commafeed.backend.model.FeedEntryTag_;
import com.commafeed.backend.model.FeedEntry_;
import com.commafeed.backend.model.FeedSubscription;
import com.commafeed.backend.model.Models;
import com.commafeed.backend.model.QFeedEntry;
import com.commafeed.backend.model.QFeedEntryContent;
import com.commafeed.backend.model.QFeedEntryStatus;
import com.commafeed.backend.model.QFeedEntryTag;
import com.commafeed.backend.model.User;
import com.commafeed.backend.model.UserSettings.ReadingOrder;
import com.commafeed.backend.services.ApplicationSettingsService;
import com.commafeed.frontend.model.UnreadCount;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import com.google.common.collect.Ordering;
import com.mysema.query.jpa.hibernate.HibernateQuery;
@Stateless
public class FeedEntryStatusDAO extends GenericDAO<FeedEntryStatus> {
private static final String ALIAS_STATUS = "status";
private static final String ALIAS_ENTRY = "entry";
private static final String ALIAS_TAG = "tag";
@Inject
FeedEntryTagDAO feedEntryTagDAO;
private FeedEntryDAO feedEntryDAO;
private FeedEntryTagDAO feedEntryTagDAO;
private CommaFeedConfiguration config;
private QFeedEntryStatus status = QFeedEntryStatus.feedEntryStatus;
public FeedEntryStatusDAO(SessionFactory sessionFactory, FeedEntryDAO feedEntryDAO, FeedEntryTagDAO feedEntryTagDAO,
CommaFeedConfiguration config) {
super(sessionFactory);
this.feedEntryDAO = feedEntryDAO;
this.feedEntryTagDAO = feedEntryTagDAO;
this.config = config;
}
private static final Comparator<FeedEntryStatus> STATUS_COMPARATOR_DESC = new Comparator<FeedEntryStatus>() {
@Override
@@ -61,34 +64,21 @@ public class FeedEntryStatusDAO extends GenericDAO<FeedEntryStatus> {
CompareToBuilder builder = new CompareToBuilder();
builder.append(o2.getEntryUpdated(), o1.getEntryUpdated());
builder.append(o2.getId(), o1.getId());
return builder.build();
return builder.toComparison();
};
};
private static final Comparator<FeedEntryStatus> STATUS_COMPARATOR_ASC = Ordering.from(STATUS_COMPARATOR_DESC).reverse();
@Inject
ApplicationSettingsService applicationSettingsService;
public FeedEntryStatus getStatus(User user, FeedSubscription sub, FeedEntry entry) {
CriteriaQuery<FeedEntryStatus> query = builder.createQuery(getType());
Root<FeedEntryStatus> root = query.from(getType());
Predicate p1 = builder.equal(root.get(FeedEntryStatus_.entry), entry);
Predicate p2 = builder.equal(root.get(FeedEntryStatus_.subscription), sub);
query.where(p1, p2);
List<FeedEntryStatus> statuses = em.createQuery(query).getResultList();
List<FeedEntryStatus> statuses = newQuery().from(status).where(status.entry.eq(entry), status.subscription.eq(sub)).list(status);
FeedEntryStatus status = Iterables.getFirst(statuses, null);
return handleStatus(user, status, sub, entry);
}
private FeedEntryStatus handleStatus(User user, FeedEntryStatus status, FeedSubscription sub, FeedEntry entry) {
if (status == null) {
Date unreadThreshold = applicationSettingsService.getUnreadThreshold();
Date unreadThreshold = config.getApplicationSettings().getUnreadThreshold();
boolean read = unreadThreshold == null ? false : entry.getUpdated().before(unreadThreshold);
status = new FeedEntryStatus(user, sub, entry);
status.setRead(read);
@@ -106,27 +96,20 @@ public class FeedEntryStatusDAO extends GenericDAO<FeedEntryStatus> {
}
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());
List<Predicate> predicates = Lists.newArrayList();
predicates.add(builder.equal(root.get(FeedEntryStatus_.user), user));
predicates.add(builder.equal(root.get(FeedEntryStatus_.starred), true));
HibernateQuery query = newQuery().from(status).where(status.user.eq(user), status.starred.isTrue());
if (newerThan != null) {
predicates.add(builder.greaterThanOrEqualTo(root.get(FeedEntryStatus_.entryInserted), newerThan));
query.where(status.entryInserted.gt(newerThan));
}
query.where(predicates.toArray(new Predicate[0]));
orderStatusesBy(query, root, order);
if (order == ReadingOrder.asc) {
query.orderBy(status.entryUpdated.asc(), status.id.asc());
} else {
query.orderBy(status.entryUpdated.desc(), status.id.desc());
}
TypedQuery<FeedEntryStatus> q = em.createQuery(query);
limit(q, offset, limit);
setTimeout(q);
List<FeedEntryStatus> statuses = q.getResultList();
query.offset(offset).limit(limit).setTimeout(config.getApplicationSettings().getQueryTimeout());
List<FeedEntryStatus> statuses = query.list(status);
for (FeedEntryStatus status : statuses) {
status = handleStatus(user, status, status.getSubscription(), status.getEntry());
status = fetchTags(user, status);
@@ -134,62 +117,66 @@ public class FeedEntryStatusDAO extends GenericDAO<FeedEntryStatus> {
return lazyLoadContent(includeContent, statuses);
}
private Criteria buildSearchCriteria(User user, FeedSubscription sub, boolean unreadOnly, String keywords, Date newerThan, int offset, int limit,
ReadingOrder order, Date last, String tag) {
Criteria criteria = getSession().createCriteria(FeedEntry.class, ALIAS_ENTRY);
private Criteria buildSearchCriteria(User user, FeedSubscription sub, boolean unreadOnly, String keywords, Date newerThan, int offset,
int limit, ReadingOrder order, Date last, String tag) {
QFeedEntry entry = QFeedEntry.feedEntry;
QFeedEntryContent content = QFeedEntryContent.feedEntryContent;
QFeedEntryStatus status = QFeedEntryStatus.feedEntryStatus;
QFeedEntryTag entryTag = QFeedEntryTag.feedEntryTag;
criteria.add(Restrictions.eq(FeedEntry_.feed.getName(), sub.getFeed()));
Criteria criteria = currentSession().createCriteria(FeedEntry.class, ALIAS_ENTRY);
criteria.add(Restrictions.eq(entry.feed.getMetadata().getName(), sub.getFeed()));
if (keywords != null) {
Criteria contentJoin = criteria.createCriteria(FeedEntry_.content.getName(), "content", JoinType.INNER_JOIN);
Criteria contentJoin = criteria.createCriteria(entry.content.getMetadata().getName(), "content", JoinType.INNER_JOIN);
for (String keyword : StringUtils.split(keywords)) {
Disjunction or = Restrictions.disjunction();
or.add(Restrictions.ilike(FeedEntryContent_.content.getName(), keyword, MatchMode.ANYWHERE));
or.add(Restrictions.ilike(FeedEntryContent_.title.getName(), keyword, MatchMode.ANYWHERE));
or.add(Restrictions.ilike(content.content.getMetadata().getName(), keyword, MatchMode.ANYWHERE));
or.add(Restrictions.ilike(content.title.getMetadata().getName(), keyword, MatchMode.ANYWHERE));
contentJoin.add(or);
}
}
Criteria statusJoin = criteria.createCriteria(FeedEntry_.statuses.getName(), ALIAS_STATUS, JoinType.LEFT_OUTER_JOIN,
Restrictions.eq(FeedEntryStatus_.subscription.getName(), sub));
Criteria statusJoin = criteria.createCriteria(entry.statuses.getMetadata().getName(), ALIAS_STATUS, JoinType.LEFT_OUTER_JOIN,
Restrictions.eq(status.subscription.getMetadata().getName(), sub));
if (unreadOnly && tag == null) {
Disjunction or = Restrictions.disjunction();
or.add(Restrictions.isNull(FeedEntryStatus_.read.getName()));
or.add(Restrictions.eq(FeedEntryStatus_.read.getName(), false));
or.add(Restrictions.isNull(status.read.getMetadata().getName()));
or.add(Restrictions.eq(status.read.getMetadata().getName(), false));
statusJoin.add(or);
Date unreadThreshold = applicationSettingsService.getUnreadThreshold();
Date unreadThreshold = config.getApplicationSettings().getUnreadThreshold();
if (unreadThreshold != null) {
criteria.add(Restrictions.ge(FeedEntry_.updated.getName(), unreadThreshold));
criteria.add(Restrictions.ge(entry.updated.getMetadata().getName(), unreadThreshold));
}
}
if (tag != null) {
Conjunction and = Restrictions.conjunction();
and.add(Restrictions.eq(FeedEntryTag_.user.getName(), user));
and.add(Restrictions.eq(FeedEntryTag_.name.getName(), tag));
criteria.createCriteria(FeedEntry_.tags.getName(), ALIAS_TAG, JoinType.INNER_JOIN, and);
and.add(Restrictions.eq(entryTag.user.getMetadata().getName(), user));
and.add(Restrictions.eq(entryTag.name.getMetadata().getName(), tag));
criteria.createCriteria(entry.tags.getMetadata().getName(), ALIAS_TAG, JoinType.INNER_JOIN, and);
}
if (newerThan != null) {
criteria.add(Restrictions.ge(FeedEntry_.inserted.getName(), newerThan));
criteria.add(Restrictions.ge(entry.inserted.getMetadata().getName(), newerThan));
}
if (last != null) {
if (order == ReadingOrder.desc) {
criteria.add(Restrictions.gt(FeedEntry_.updated.getName(), last));
criteria.add(Restrictions.gt(entry.updated.getMetadata().getName(), last));
} else {
criteria.add(Restrictions.lt(FeedEntry_.updated.getName(), last));
criteria.add(Restrictions.lt(entry.updated.getMetadata().getName(), last));
}
}
if (order != null) {
if (order == ReadingOrder.asc) {
criteria.addOrder(Order.asc(FeedEntry_.updated.getName())).addOrder(Order.asc(FeedEntry_.id.getName()));
criteria.addOrder(Order.asc(entry.updated.getMetadata().getName())).addOrder(Order.asc(entry.id.getMetadata().getName()));
} else {
criteria.addOrder(Order.desc(FeedEntry_.updated.getName())).addOrder(Order.desc(FeedEntry_.id.getName()));
criteria.addOrder(Order.desc(entry.updated.getMetadata().getName())).addOrder(Order.desc(entry.id.getMetadata().getName()));
}
}
if (offset > -1) {
@@ -198,7 +185,7 @@ public class FeedEntryStatusDAO extends GenericDAO<FeedEntryStatus> {
if (limit > -1) {
criteria.setMaxResults(limit);
}
int timeout = applicationSettingsService.get().getQueryTimeout();
int timeout = config.getApplicationSettings().getQueryTimeout();
if (timeout > 0) {
// hibernate timeout is in seconds, jpa timeout is in millis
criteria.setTimeout(timeout / 1000);
@@ -255,7 +242,7 @@ public class FeedEntryStatusDAO extends GenericDAO<FeedEntryStatus> {
statuses = Lists.newArrayList();
for (FeedEntryStatus placeholder : placeholders) {
Long statusId = placeholder.getId();
FeedEntry entry = em.find(FeedEntry.class, placeholder.getEntry().getId());
FeedEntry entry = feedEntryDAO.findById(placeholder.getEntry().getId());
FeedEntryStatus status = handleStatus(user, statusId == null ? null : findById(statusId), placeholder.getSubscription(),
entry);
status = fetchTags(user, status);
@@ -272,7 +259,7 @@ public class FeedEntryStatusDAO extends GenericDAO<FeedEntryStatus> {
Criteria criteria = buildSearchCriteria(user, subscription, true, null, null, -1, -1, null, null, null);
ProjectionList projection = Projections.projectionList();
projection.add(Projections.rowCount(), "count");
projection.add(Projections.max(FeedEntry_.updated.getName()), "updated");
projection.add(Projections.max(QFeedEntry.feedEntry.updated.getMetadata().getName()), "updated");
criteria.setProjection(projection);
criteria.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
List<Map<String, Object>> list = criteria.list();
@@ -294,35 +281,8 @@ public class FeedEntryStatusDAO extends GenericDAO<FeedEntryStatus> {
return results;
}
private void orderStatusesBy(CriteriaQuery<?> query, Path<FeedEntryStatus> statusJoin, ReadingOrder order) {
orderBy(query, statusJoin.get(FeedEntryStatus_.entryUpdated), statusJoin.get(FeedEntryStatus_.id), order);
}
private void orderBy(CriteriaQuery<?> query, Path<Date> date, Path<Long> id, ReadingOrder order) {
if (order != null) {
if (order == ReadingOrder.asc) {
query.orderBy(builder.asc(date), builder.asc(id));
} else {
query.orderBy(builder.desc(date), builder.desc(id));
}
}
}
protected void setTimeout(Query query) {
setTimeout(query, applicationSettingsService.get().getQueryTimeout());
}
public List<FeedEntryStatus> getOldStatuses(Date olderThan, int limit) {
CriteriaQuery<FeedEntryStatus> query = builder.createQuery(getType());
Root<FeedEntryStatus> root = query.from(getType());
Predicate p1 = builder.lessThan(root.get(FeedEntryStatus_.entryInserted), olderThan);
Predicate p2 = builder.isFalse(root.get(FeedEntryStatus_.starred));
query.where(p1, p2);
TypedQuery<FeedEntryStatus> q = em.createQuery(query);
q.setMaxResults(limit);
return q.getResultList();
return newQuery().from(status).where(status.entryInserted.lt(olderThan), status.starred.isFalse()).limit(limit).list(status);
}
}

37
src/main/java/com/commafeed/backend/dao/FeedEntryTagDAO.java
View File

@@ -2,42 +2,27 @@ package com.commafeed.backend.dao;
import java.util.List;
import javax.ejb.Stateless;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import org.hibernate.SessionFactory;
import com.commafeed.backend.model.FeedEntry;
import com.commafeed.backend.model.FeedEntryTag;
import com.commafeed.backend.model.FeedEntryTag_;
import com.commafeed.backend.model.FeedEntry_;
import com.commafeed.backend.model.QFeedEntryTag;
import com.commafeed.backend.model.User;
import com.commafeed.backend.model.User_;
import com.mysema.query.types.ConstructorExpression;
@Stateless
public class FeedEntryTagDAO extends GenericDAO<FeedEntryTag> {
private QFeedEntryTag tag = QFeedEntryTag.feedEntryTag;
public FeedEntryTagDAO(SessionFactory sessionFactory) {
super(sessionFactory);
}
public List<String> findByUser(User user) {
CriteriaQuery<String> query = builder.createQuery(String.class);
Root<FeedEntryTag> root = query.from(getType());
query.select(root.get(FeedEntryTag_.name));
query.distinct(true);
Predicate p1 = builder.equal(root.get(FeedEntryTag_.user).get(User_.id), user.getId());
query.where(p1);
return cache(em.createQuery(query)).getResultList();
return newQuery().from(tag).where(tag.user.eq(user)).distinct().list(ConstructorExpression.create(String.class, tag.name));
}
public List<FeedEntryTag> findByEntry(User user, FeedEntry entry) {
CriteriaQuery<FeedEntryTag> query = builder.createQuery(getType());
Root<FeedEntryTag> root = query.from(getType());
Predicate p1 = builder.equal(root.get(FeedEntryTag_.user).get(User_.id), user.getId());
Predicate p2 = builder.equal(root.get(FeedEntryTag_.entry).get(FeedEntry_.id), entry.getId());
query.where(p1, p2);
return cache(em.createQuery(query)).getResultList();
return newQuery().from(tag).where(tag.user.eq(user), tag.entry.eq(entry)).list(tag);
}
}

101
src/main/java/com/commafeed/backend/dao/FeedSubscriptionDAO.java
View File

@@ -2,110 +2,59 @@ 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 org.hibernate.SessionFactory;
import com.commafeed.backend.model.Feed;
import com.commafeed.backend.model.FeedCategory;
import com.commafeed.backend.model.FeedCategory_;
import com.commafeed.backend.model.FeedSubscription;
import com.commafeed.backend.model.FeedSubscription_;
import com.commafeed.backend.model.Feed_;
import com.commafeed.backend.model.Models;
import com.commafeed.backend.model.QFeedSubscription;
import com.commafeed.backend.model.User;
import com.commafeed.backend.model.User_;
import com.google.common.base.Function;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import com.mysema.query.jpa.hibernate.HibernateQuery;
@Stateless
public class FeedSubscriptionDAO extends GenericDAO<FeedSubscription> {
private QFeedSubscription sub = QFeedSubscription.feedSubscription;
public FeedSubscriptionDAO(SessionFactory sessionFactory) {
super(sessionFactory);
}
public FeedSubscription findById(User user, Long id) {
CriteriaQuery<FeedSubscription> query = builder.createQuery(getType());
Root<FeedSubscription> root = query.from(getType());
Predicate p1 = builder.equal(root.get(FeedSubscription_.user).get(User_.id), user.getId());
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);
FeedSubscription sub = Iterables.getFirst(cache(em.createQuery(query)).getResultList(), null);
initRelations(sub);
return sub;
List<FeedSubscription> subs = newQuery().from(sub).where(sub.user.eq(user), sub.id.eq(id)).leftJoin(sub.feed).fetch()
.leftJoin(sub.category).fetch().list(sub);
return initRelations(Iterables.getFirst(subs, null));
}
public List<FeedSubscription> findByFeed(Feed feed) {
CriteriaQuery<FeedSubscription> query = builder.createQuery(getType());
Root<FeedSubscription> root = query.from(getType());
query.where(builder.equal(root.get(FeedSubscription_.feed), feed));
List<FeedSubscription> list = cache(em.createQuery(query)).getResultList();
return list;
return newQuery().from(sub).where(sub.feed.eq(feed)).list(sub);
}
public FeedSubscription findByFeed(User user, Feed feed) {
CriteriaQuery<FeedSubscription> query = builder.createQuery(getType());
Root<FeedSubscription> root = query.from(getType());
Predicate p1 = builder.equal(root.get(FeedSubscription_.user).get(User_.id), user.getId());
Predicate p2 = builder.equal(root.get(FeedSubscription_.feed).get(Feed_.id), feed.getId());
root.fetch(FeedSubscription_.feed, JoinType.LEFT);
root.fetch(FeedSubscription_.category, JoinType.LEFT);
query.where(p1, p2);
FeedSubscription sub = Iterables.getFirst(cache(em.createQuery(query)).getResultList(), null);
initRelations(sub);
return sub;
List<FeedSubscription> subs = newQuery().from(sub).where(sub.user.eq(user), sub.feed.eq(feed)).list(sub);
return initRelations(Iterables.getFirst(subs, null));
}
public List<FeedSubscription> findAll(User user) {
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).get(User_.id), user.getId()));
List<FeedSubscription> list = cache(em.createQuery(query)).getResultList();
initRelations(list);
return list;
List<FeedSubscription> subs = newQuery().from(sub).where(sub.user.eq(user)).leftJoin(sub.feed).fetch().leftJoin(sub.category)
.fetch().list(sub);
return initRelations(subs);
}
public List<FeedSubscription> findByCategory(User user, FeedCategory category) {
CriteriaQuery<FeedSubscription> query = builder.createQuery(getType());
Root<FeedSubscription> root = query.from(getType());
Predicate p1 = builder.equal(root.get(FeedSubscription_.user).get(User_.id), user.getId());
Predicate p2 = null;
HibernateQuery query = newQuery().from(sub).where(sub.user.eq(user));
if (category == null) {
p2 = builder.isNull(root.get(FeedSubscription_.category));
query.where(sub.category.isNull());
} else {
p2 = builder.equal(root.get(FeedSubscription_.category).get(FeedCategory_.id), category.getId());
query.where(sub.category.eq(category));
}
query.where(p1, p2);
List<FeedSubscription> list = cache(em.createQuery(query)).getResultList();
initRelations(list);
return list;
return initRelations(query.list(sub));
}
public List<FeedSubscription> findByCategories(User user, List<FeedCategory> categories) {
List<Long> categoryIds = Lists.transform(categories, new Function<FeedCategory, Long>() {
@Override
public Long apply(FeedCategory input) {
@@ -122,16 +71,18 @@ public class FeedSubscriptionDAO extends GenericDAO<FeedSubscription> {
return subscriptions;
}
private void initRelations(List<FeedSubscription> list) {
private List<FeedSubscription> initRelations(List<FeedSubscription> list) {
for (FeedSubscription sub : list) {
initRelations(sub);
}
return list;
}
private void initRelations(FeedSubscription sub) {
private FeedSubscription initRelations(FeedSubscription sub) {
if (sub != null) {
Models.initialize(sub.getFeed());
Models.initialize(sub.getCategory());
}
return sub;
}
}

166
src/main/java/com/commafeed/backend/dao/GenericDAO.java
View File

@@ -1,160 +1,59 @@
package com.commafeed.backend.dao;
import java.util.Arrays;
import io.dropwizard.hibernate.AbstractDAO;
import java.util.Collection;
import java.util.List;
import javax.annotation.PostConstruct;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import javax.persistence.metamodel.Attribute;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import com.commafeed.backend.model.AbstractModel;
import com.google.common.reflect.TypeToken;
import com.mysema.query.jpa.hibernate.HibernateQuery;
@SuppressWarnings("serial")
public abstract class GenericDAO<T extends AbstractModel> {
public abstract class GenericDAO<T extends AbstractModel> extends AbstractDAO<T> {
private TypeToken<T> type = new TypeToken<T>(getClass()) {
};
@PersistenceContext
protected EntityManager em;
protected CriteriaBuilder builder;
@PostConstruct
public void init() {
builder = em.getCriteriaBuilder();
public GenericDAO(SessionFactory sessionFactory) {
super(sessionFactory);
}
public Session getSession() {
Session session = em.unwrap(Session.class);
return session;
protected HibernateQuery newQuery() {
return new HibernateQuery(currentSession());
}
public void saveOrUpdate(Collection<? extends AbstractModel> models) {
Session session = getSession();
int i = 1;
for (AbstractModel model : models) {
session.saveOrUpdate(model);
if (i % 50 == 0) {
session.flush();
session.clear();
}
public void saveOrUpdate(T model) {
persist(model);
}
public void saveOrUpdate(Collection<T> models) {
for (T model : models) {
persist(model);
}
}
public void saveOrUpdate(AbstractModel... models) {
saveOrUpdate(Arrays.asList(models));
public void merge(T model) {
currentSession().merge(model);
}
public void delete(AbstractModel object) {
if (object != null) {
object = em.merge(object);
em.remove(object);
}
}
public int delete(Collection<? extends AbstractModel> objects) {
for (AbstractModel object : objects) {
delete(object);
}
return objects.size();
}
public void deleteById(Long id) {
Object ref = em.getReference(getType(), id);
if (ref != null) {
em.remove(ref);
public void merge(Collection<T> models) {
for (T model : models) {
merge(model);
}
}
public T findById(Long id) {
T t = em.find(getType(), id);
return t;
return get(id);
}
public List<T> findAll() {
CriteriaQuery<T> query = builder.createQuery(getType());
query.from(getType());
return em.createQuery(query).getResultList();
}
public List<T> findAll(int startIndex, int count) {
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) {
CriteriaQuery<T> query = builder.createQuery(getType());
Root<T> root = query.from(getType());
if (asc) {
query.orderBy(builder.asc(root.get(orderBy)));
} else {
query.orderBy(builder.desc(root.get(orderBy)));
}
TypedQuery<T> q = em.createQuery(query);
q.setMaxResults(count);
q.setFirstResult(startIndex);
return q.getResultList();
}
public long getCount() {
CriteriaBuilder builder = em.getCriteriaBuilder();
CriteriaQuery<Long> query = builder.createQuery(Long.class);
Root<T> root = query.from(getType());
query.select(builder.count(root));
return em.createQuery(query).getSingleResult();
}
protected <V> List<T> findByField(Attribute<T, V> field, V value) {
return findByField(field, value, false);
}
protected <V> List<T> findByField(Attribute<T, V> field, V value, boolean cache) {
CriteriaQuery<T> query = builder.createQuery(getType());
Root<T> root = query.from(getType());
query.where(builder.equal(root.get(field.getName()), value));
TypedQuery<T> q = em.createQuery(query);
if (cache) {
cache(q);
}
return em.createQuery(query).getResultList();
}
protected <Q> void limit(TypedQuery<Q> query, int offset, int limit) {
if (offset > -1) {
query.setFirstResult(offset);
}
if (limit > -1) {
query.setMaxResults(limit);
public void delete(T object) {
if (object != null) {
currentSession().delete(object);
}
}
protected <Q> TypedQuery<Q> readOnly(TypedQuery<Q> query) {
query.unwrap(Query.class).setReadOnly(true);
return query;
}
protected <Q> TypedQuery<Q> cache(TypedQuery<Q> query) {
query.unwrap(Query.class).setCacheable(true);
return query;
public int delete(Collection<T> objects) {
for (T object : objects) {
delete(object);
}
return objects.size();
}
protected void setTimeout(javax.persistence.Query query, int queryTimeout) {
@@ -162,9 +61,4 @@ public abstract class GenericDAO<T extends AbstractModel> {
query.setHint("javax.persistence.query.timeout", queryTimeout);
}
}
@SuppressWarnings("unchecked")
protected Class<T> getType() {
return (Class<T>) type.getRawType();
}
}

60
src/main/java/com/commafeed/backend/dao/UnitOfWork.java Normal file
View File

@@ -0,0 +1,60 @@
package com.commafeed.backend.dao;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.context.internal.ManagedSessionContext;
public abstract class UnitOfWork<T> {
private SessionFactory sessionFactory;
public UnitOfWork(SessionFactory sessionFactory) {
this.sessionFactory = sessionFactory;
}
protected abstract T runInSession() throws Exception;
public T run() {
final Session session = sessionFactory.openSession();
if (ManagedSessionContext.hasBind(sessionFactory)) {
throw new IllegalStateException("Already in a unit of work!");
}
T t = null;
try {
ManagedSessionContext.bind(session);
session.beginTransaction();
try {
t = runInSession();
commitTransaction(session);
} catch (Exception e) {
rollbackTransaction(session);
this.<RuntimeException> rethrow(e);
}
} finally {
session.close();
ManagedSessionContext.unbind(sessionFactory);
}
return t;
}
private void rollbackTransaction(Session session) {
final Transaction txn = session.getTransaction();
if (txn != null && txn.isActive()) {
txn.rollback();
}
}
private void commitTransaction(Session session) {
final Transaction txn = session.getTransaction();
if (txn != null && txn.isActive()) {
txn.commit();
}
}
@SuppressWarnings("unchecked")
private <E extends Exception> void rethrow(Exception e) throws E {
throw (E) e;
}
}

63
src/main/java/com/commafeed/backend/dao/UserDAO.java
View File

@@ -1,68 +1,27 @@
package com.commafeed.backend.dao;
import javax.ejb.Stateless;
import javax.persistence.NoResultException;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import org.apache.commons.lang3.StringUtils;
import org.hibernate.SessionFactory;
import com.commafeed.backend.model.QUser;
import com.commafeed.backend.model.User;
import com.commafeed.backend.model.User_;
@Stateless
public class UserDAO extends GenericDAO<User> {
private QUser user = QUser.user;
public UserDAO(SessionFactory sessionFactory) {
super(sessionFactory);
}
public User findByName(String name) {
CriteriaQuery<User> query = builder.createQuery(getType());
Root<User> root = query.from(getType());
query.where(builder.equal(builder.lower(root.get(User_.name)), name.toLowerCase()));
TypedQuery<User> q = em.createQuery(query);
cache(q);
User user = null;
try {
user = q.getSingleResult();
} catch (NoResultException e) {
user = null;
}
return user;
return newQuery().from(user).where(user.name.equalsIgnoreCase(name)).uniqueResult(user);
}
public User findByApiKey(String key) {
CriteriaQuery<User> query = builder.createQuery(getType());
Root<User> root = query.from(getType());
query.where(builder.equal(root.get(User_.apiKey), key));
TypedQuery<User> q = em.createQuery(query);
cache(q);
User user = null;
try {
user = q.getSingleResult();
} catch (NoResultException e) {
user = null;
}
return user;
return newQuery().from(user).where(user.apiKey.equalsIgnoreCase(key)).uniqueResult(user);
}
public User findByEmail(String email) {
if (StringUtils.isBlank(email)) {
return null;
}
CriteriaQuery<User> query = builder.createQuery(getType());
Root<User> root = query.from(getType());
query.where(builder.equal(root.get(User_.email), email));
TypedQuery<User> q = em.createQuery(query);
User user = null;
try {
user = q.getSingleResult();
} catch (NoResultException e) {
user = null;
}
return user;
return newQuery().from(user).where(user.email.equalsIgnoreCase(email)).uniqueResult(user);
}
}

30
src/main/java/com/commafeed/backend/dao/UserRoleDAO.java
View File

@@ -3,38 +3,28 @@ package com.commafeed.backend.dao;
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 org.hibernate.SessionFactory;
import com.commafeed.backend.model.QUserRole;
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.commafeed.backend.model.User_;
import com.google.common.collect.Sets;
@Stateless
public class UserRoleDAO extends GenericDAO<UserRole> {
@Override
private QUserRole role = QUserRole.userRole;
public UserRoleDAO(SessionFactory sessionFactory) {
super(sessionFactory);
}
public List<UserRole> findAll() {
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();
return newQuery().from(role).leftJoin(role.user).fetch().distinct().list(role);
}
public List<UserRole> findAll(User user) {
CriteriaQuery<UserRole> query = builder.createQuery(getType());
Root<UserRole> root = query.from(getType());
query.where(builder.equal(root.get(UserRole_.user).get(User_.id), user.getId()));
return cache(em.createQuery(query)).getResultList();
return newQuery().from(role).where(role.user.eq(user)).distinct().list(role);
}
public Set<Role> findRoles(User user) {

27
src/main/java/com/commafeed/backend/dao/UserSettingsDAO.java
View File

@@ -1,31 +1,18 @@
package com.commafeed.backend.dao;
import javax.ejb.Stateless;
import javax.persistence.NoResultException;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.Restrictions;
import com.commafeed.backend.model.User;
import com.commafeed.backend.model.UserSettings;
import com.commafeed.backend.model.UserSettings_;
import com.commafeed.backend.model.User_;
@Stateless
public class UserSettingsDAO extends GenericDAO<UserSettings> {
public UserSettingsDAO(SessionFactory sessionFactory) {
super(sessionFactory);
}
public UserSettings findByUser(User user) {
CriteriaQuery<UserSettings> query = builder.createQuery(getType());
Root<UserSettings> root = query.from(getType());
query.where(builder.equal(root.get(UserSettings_.user).get(User_.id), user.getId()));
UserSettings settings = null;
try {
settings = cache(em.createQuery(query)).getSingleResult();
} catch (NoResultException e) {
settings = null;
}
return settings;
return uniqueResult(criteria().add(Restrictions.eq("user", user)));
}
}