From 5b5ad242e0e183689711bc77bf89abdfdc9e5c53 Mon Sep 17 00:00:00 2001 From: Athou Date: Thu, 11 Apr 2013 20:49:08 +0200 Subject: [PATCH] major classes refactoring --- .../com/commafeed/backend/StartupBean.java | 46 ++++++------ ...rvice.java => ApplicationSettingsDAO.java} | 2 +- ...egoryService.java => FeedCategoryDAO.java} | 2 +- .../dao/{FeedService.java => FeedDAO.java} | 4 +- .../commafeed/backend/dao/FeedEntryDAO.java | 38 ++++++++++ ...usService.java => FeedEntryStatusDAO.java} | 41 ++++------ ...nService.java => FeedSubscriptionDAO.java} | 53 +------------ .../com/commafeed/backend/dao/GenericDAO.java | 12 +++ .../com/commafeed/backend/dao/UserDAO.java | 31 ++++++++ ...{UserRoleService.java => UserRoleDAO.java} | 4 +- ...tingsService.java => UserSettingsDAO.java} | 2 +- .../backend/feeds/FeedRefreshWorker.java | 20 +++-- .../commafeed/backend/feeds/OPMLImporter.java | 14 ++-- .../services/FeedSubscriptionService.java | 75 +++++++++++++++++++ .../FeedUpdateService.java} | 54 +++++-------- .../PasswordEncryptionService.java | 6 +- .../{dao => services}/UserService.java | 31 +++----- .../commafeed/frontend/CommaFeedSession.java | 8 +- .../commafeed/frontend/pages/BasePage.java | 32 ++++---- .../pages/GoogleImportCallbackPage.java | 12 +-- .../pages/GoogleImportRedirectPage.java | 6 +- .../commafeed/frontend/pages/HomePage.java | 6 +- .../commafeed/frontend/pages/WelcomePage.java | 6 +- .../pages/components/RegisterPanel.java | 14 ++-- .../frontend/rest/resources/AbstractREST.java | 38 ++++++---- .../rest/resources/AdminSettingsREST.java | 8 +- .../rest/resources/AdminUsersREST.java | 32 ++++---- .../frontend/rest/resources/EntriesREST.java | 38 +++++----- .../frontend/rest/resources/SessionREST.java | 2 +- .../frontend/rest/resources/SettingsREST.java | 6 +- .../rest/resources/SubscriptionsREST.java | 34 ++++----- 31 files changed, 380 insertions(+), 297 deletions(-) rename src/main/java/com/commafeed/backend/dao/{ApplicationSettingsService.java => ApplicationSettingsDAO.java} (91%) rename src/main/java/com/commafeed/backend/dao/{FeedCategoryService.java => FeedCategoryDAO.java} (93%) rename src/main/java/com/commafeed/backend/dao/{FeedService.java => FeedDAO.java} (91%) create mode 100644 src/main/java/com/commafeed/backend/dao/FeedEntryDAO.java rename src/main/java/com/commafeed/backend/dao/{FeedEntryStatusService.java => FeedEntryStatusDAO.java} (83%) rename src/main/java/com/commafeed/backend/dao/{FeedSubscriptionService.java => FeedSubscriptionDAO.java} (61%) create mode 100644 src/main/java/com/commafeed/backend/dao/UserDAO.java rename src/main/java/com/commafeed/backend/dao/{UserRoleService.java => UserRoleDAO.java} (83%) rename src/main/java/com/commafeed/backend/dao/{UserSettingsService.java => UserSettingsDAO.java} (88%) create mode 100644 src/main/java/com/commafeed/backend/services/FeedSubscriptionService.java rename src/main/java/com/commafeed/backend/{dao/FeedEntryService.java => services/FeedUpdateService.java} (53%) rename src/main/java/com/commafeed/backend/{security => services}/PasswordEncryptionService.java (92%) rename src/main/java/com/commafeed/backend/{dao => services}/UserService.java (63%) diff --git a/src/main/java/com/commafeed/backend/StartupBean.java b/src/main/java/com/commafeed/backend/StartupBean.java index d56cfbf2..eb38212e 100644 --- a/src/main/java/com/commafeed/backend/StartupBean.java +++ b/src/main/java/com/commafeed/backend/StartupBean.java @@ -11,11 +11,11 @@ import javax.inject.Inject; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import com.commafeed.backend.dao.ApplicationSettingsService; -import com.commafeed.backend.dao.FeedCategoryService; -import com.commafeed.backend.dao.FeedService; -import com.commafeed.backend.dao.FeedSubscriptionService; -import com.commafeed.backend.dao.UserService; +import com.commafeed.backend.dao.ApplicationSettingsDAO; +import com.commafeed.backend.dao.FeedCategoryDAO; +import com.commafeed.backend.dao.FeedDAO; +import com.commafeed.backend.dao.FeedSubscriptionDAO; +import com.commafeed.backend.dao.UserDAO; import com.commafeed.backend.feeds.FeedRefreshWorker; import com.commafeed.backend.model.ApplicationSettings; import com.commafeed.backend.model.Feed; @@ -23,7 +23,8 @@ import com.commafeed.backend.model.FeedCategory; import com.commafeed.backend.model.FeedSubscription; import com.commafeed.backend.model.User; import com.commafeed.backend.model.UserRole.Role; -import com.commafeed.backend.security.PasswordEncryptionService; +import com.commafeed.backend.services.PasswordEncryptionService; +import com.commafeed.backend.services.UserService; @Startup @Singleton @@ -33,13 +34,16 @@ public class StartupBean { public static final String ADMIN_NAME = "admin"; @Inject - FeedService feedService; + FeedDAO feedDAO; @Inject - FeedCategoryService feedCategoryService; + FeedCategoryDAO feedCategoryDAO; @Inject - FeedSubscriptionService feedSubscriptionService; + FeedSubscriptionDAO feedSubscriptionDAO; + + @Inject + UserDAO userDAO; @Inject UserService userService; @@ -48,7 +52,7 @@ public class StartupBean { PasswordEncryptionService encryptionService; @Inject - ApplicationSettingsService applicationSettingsService; + ApplicationSettingsDAO applicationSettingsDAO; @Inject FeedRefreshWorker worker; @@ -58,7 +62,7 @@ public class StartupBean { @PostConstruct private void init() { startupTime = Calendar.getInstance().getTimeInMillis(); - if (userService.getCount() == 0) { + if (userDAO.getCount() == 0) { initialData(); } @@ -72,57 +76,57 @@ public class StartupBean { private void initialData() { log.info("Populating database with default values"); - applicationSettingsService.save(new ApplicationSettings()); + applicationSettingsDAO.save(new ApplicationSettings()); User user = userService.register(ADMIN_NAME, "admin", Arrays.asList(Role.ADMIN, Role.USER)); userService.register("test", "test", Arrays.asList(Role.USER)); Feed dilbert = new Feed("http://feed.dilbert.com/dilbert/daily_strip"); - feedService.save(dilbert); + feedDAO.save(dilbert); Feed engadget = new Feed("http://www.engadget.com/rss.xml"); - feedService.save(engadget); + feedDAO.save(engadget); Feed frandroid = new Feed("http://feeds.feedburner.com/frandroid"); - feedService.save(frandroid); + feedDAO.save(frandroid); FeedCategory newsCategory = new FeedCategory(); newsCategory.setName("News"); newsCategory.setUser(user); - feedCategoryService.save(newsCategory); + feedCategoryDAO.save(newsCategory); FeedCategory comicsCategory = new FeedCategory(); comicsCategory.setName("Comics"); comicsCategory.setUser(user); comicsCategory.setParent(newsCategory); - feedCategoryService.save(comicsCategory); + feedCategoryDAO.save(comicsCategory); FeedCategory techCategory = new FeedCategory(); techCategory.setName("Tech"); techCategory.setUser(user); techCategory.setParent(newsCategory); - feedCategoryService.save(techCategory); + feedCategoryDAO.save(techCategory); FeedSubscription sub = new FeedSubscription(); sub.setCategory(comicsCategory); sub.setFeed(dilbert); sub.setTitle("Dilbert - Strips"); sub.setUser(user); - feedSubscriptionService.save(sub); + feedSubscriptionDAO.save(sub); FeedSubscription sub2 = new FeedSubscription(); sub2.setCategory(techCategory); sub2.setFeed(engadget); sub2.setTitle("Engadget"); sub2.setUser(user); - feedSubscriptionService.save(sub2); + feedSubscriptionDAO.save(sub2); FeedSubscription sub3 = new FeedSubscription(); sub3.setFeed(frandroid); sub3.setTitle("Frandroid"); sub3.setUser(user); - feedSubscriptionService.save(sub3); + feedSubscriptionDAO.save(sub3); } public long getStartupTime() { diff --git a/src/main/java/com/commafeed/backend/dao/ApplicationSettingsService.java b/src/main/java/com/commafeed/backend/dao/ApplicationSettingsDAO.java similarity index 91% rename from src/main/java/com/commafeed/backend/dao/ApplicationSettingsService.java rename to src/main/java/com/commafeed/backend/dao/ApplicationSettingsDAO.java index 2b03b660..5fa5a967 100644 --- a/src/main/java/com/commafeed/backend/dao/ApplicationSettingsService.java +++ b/src/main/java/com/commafeed/backend/dao/ApplicationSettingsDAO.java @@ -12,7 +12,7 @@ import com.uaihebert.factory.EasyCriteriaFactory; import com.uaihebert.model.EasyCriteria; @Stateless -public class ApplicationSettingsService { +public class ApplicationSettingsDAO { @PersistenceContext protected EntityManager em; diff --git a/src/main/java/com/commafeed/backend/dao/FeedCategoryService.java b/src/main/java/com/commafeed/backend/dao/FeedCategoryDAO.java similarity index 93% rename from src/main/java/com/commafeed/backend/dao/FeedCategoryService.java rename to src/main/java/com/commafeed/backend/dao/FeedCategoryDAO.java index c2f7df73..64333b25 100644 --- a/src/main/java/com/commafeed/backend/dao/FeedCategoryService.java +++ b/src/main/java/com/commafeed/backend/dao/FeedCategoryDAO.java @@ -16,7 +16,7 @@ import com.uaihebert.model.EasyCriteria; @Stateless @SuppressWarnings("serial") -public class FeedCategoryService extends GenericDAO { +public class FeedCategoryDAO extends GenericDAO { public List findAll(User user) { EasyCriteria criteria = createCriteria(); diff --git a/src/main/java/com/commafeed/backend/dao/FeedService.java b/src/main/java/com/commafeed/backend/dao/FeedDAO.java similarity index 91% rename from src/main/java/com/commafeed/backend/dao/FeedService.java rename to src/main/java/com/commafeed/backend/dao/FeedDAO.java index 77b949b2..72e51b80 100644 --- a/src/main/java/com/commafeed/backend/dao/FeedService.java +++ b/src/main/java/com/commafeed/backend/dao/FeedDAO.java @@ -20,7 +20,7 @@ import com.uaihebert.model.EasyCriteria; @Stateless @SuppressWarnings("serial") -public class FeedService extends GenericDAO { +public class FeedDAO extends GenericDAO { public List findNextUpdatable(int count) { CriteriaQuery query = builder.createQuery(getType()); @@ -56,7 +56,7 @@ public class FeedService extends GenericDAO { return Iterables.getFirst(feeds, null); } - public Feed getByIdWithEntries(Long feedId, int offset, int limit) { + public Feed findByIdWithEntries(Long feedId, int offset, int limit) { EasyCriteria criteria = createCriteria(); criteria.andEquals(MF.i(proxy().getId()), feedId); criteria.leftJoinFetch(MF.i(proxy().getEntries())); diff --git a/src/main/java/com/commafeed/backend/dao/FeedEntryDAO.java b/src/main/java/com/commafeed/backend/dao/FeedEntryDAO.java new file mode 100644 index 00000000..9ea33928 --- /dev/null +++ b/src/main/java/com/commafeed/backend/dao/FeedEntryDAO.java @@ -0,0 +1,38 @@ +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.Root; + +import com.commafeed.backend.model.Feed; +import com.commafeed.backend.model.FeedEntry; +import com.commafeed.backend.model.FeedEntry_; +import com.commafeed.frontend.utils.ModelFactory.MF; +import com.uaihebert.model.EasyCriteria; + +@Stateless +@SuppressWarnings("serial") +public class FeedEntryDAO extends GenericDAO { + + public List findByGuids(List guids) { + EasyCriteria criteria = createCriteria(); + criteria.setDistinctTrue(); + criteria.andStringIn(MF.i(proxy().getGuid()), guids); + criteria.leftJoinFetch(MF.i(proxy().getFeeds())); + return criteria.getResultList(); + } + + public List findByFeed(Feed feed, int offset, int limit) { + CriteriaQuery query = builder.createQuery(getType()); + Root root = query.from(getType()); + query.where(builder.isMember(feed, root.get(FeedEntry_.feeds))); + query.orderBy(builder.desc(root.get(FeedEntry_.updated))); + TypedQuery q = em.createQuery(query); + q.setFirstResult(offset); + q.setMaxResults(limit); + return q.getResultList(); + } +} diff --git a/src/main/java/com/commafeed/backend/dao/FeedEntryStatusService.java b/src/main/java/com/commafeed/backend/dao/FeedEntryStatusDAO.java similarity index 83% rename from src/main/java/com/commafeed/backend/dao/FeedEntryStatusService.java rename to src/main/java/com/commafeed/backend/dao/FeedEntryStatusDAO.java index 4eb762cc..aa61e365 100644 --- a/src/main/java/com/commafeed/backend/dao/FeedEntryStatusService.java +++ b/src/main/java/com/commafeed/backend/dao/FeedEntryStatusDAO.java @@ -5,7 +5,6 @@ import java.util.List; import java.util.Map; import javax.ejb.Stateless; -import javax.inject.Inject; import javax.persistence.NoResultException; import javax.persistence.Query; import javax.persistence.TypedQuery; @@ -33,10 +32,7 @@ import com.uaihebert.model.EasyCriteria; @Stateless @SuppressWarnings("serial") -public class FeedEntryStatusService extends GenericDAO { - - @Inject - FeedCategoryService feedCategoryService; +public class FeedEntryStatusDAO extends GenericDAO { public FeedEntryStatus findById(User user, Long id) { @@ -58,7 +54,7 @@ public class FeedEntryStatusService extends GenericDAO { return status; } - public List getStatusesByKeywords(User user, + public List findByKeywords(User user, String keywords, int offset, int limit, boolean includeContent) { String joinedKeywords = StringUtils.join( @@ -93,12 +89,12 @@ public class FeedEntryStatusService extends GenericDAO { return q.getResultList(); } - public List getStatuses(User user, boolean unreadOnly, + public List findAll(User user, boolean unreadOnly, ReadingOrder order, boolean includeContent) { - return getStatuses(user, unreadOnly, -1, -1, order, includeContent); + return findAll(user, unreadOnly, -1, -1, order, includeContent); } - public List getStatuses(User user, boolean unreadOnly, + public List findAll(User user, boolean unreadOnly, int offset, int limit, ReadingOrder order, boolean includeContent) { CriteriaQuery query = builder.createQuery(getType()); Root root = query.from(getType()); @@ -138,13 +134,13 @@ public class FeedEntryStatusService extends GenericDAO { return map; } - public List getStatuses(Feed feed, User user, + public List findByFeed(Feed feed, User user, boolean unreadOnly, ReadingOrder order, boolean includeContent) { - return getStatuses(feed, user, unreadOnly, -1, -1, order, + return findByFeed(feed, user, unreadOnly, -1, -1, order, includeContent); } - public List getStatuses(Feed feed, User user, + public List findByFeed(Feed feed, User user, boolean unreadOnly, int offset, int limit, ReadingOrder order, boolean includeContent) { @@ -173,14 +169,14 @@ public class FeedEntryStatusService extends GenericDAO { return q.getResultList(); } - public List getStatuses(List categories, + public List findByCategories(List categories, User user, boolean unreadOnly, ReadingOrder order, boolean includeContent) { - return getStatuses(categories, user, unreadOnly, -1, -1, order, + return findByCategories(categories, user, unreadOnly, -1, -1, order, includeContent); } - public List getStatuses(List categories, + public List findByCategories(List categories, User user, boolean unreadOnly, int offset, int limit, ReadingOrder order, boolean includeContent) { @@ -209,15 +205,6 @@ public class FeedEntryStatusService extends GenericDAO { return q.getResultList(); } - private void limit(TypedQuery query, int offset, int limit) { - if (offset > -1) { - query.setFirstResult(offset); - } - if (limit > -1) { - query.setMaxResults(limit); - } - } - private void orderBy(CriteriaQuery query, Root root, ReadingOrder order) { Path orderPath = root.get(FeedEntryStatus_.entry).get( @@ -231,20 +218,20 @@ public class FeedEntryStatusService extends GenericDAO { } public void markFeedEntries(User user, Feed feed, Date olderThan) { - List statuses = getStatuses(feed, user, true, + List statuses = findByFeed(feed, user, true, ReadingOrder.desc, false); update(markList(statuses, olderThan)); } public void markCategoryEntries(User user, List categories, Date olderThan) { - List statuses = getStatuses(categories, user, true, + List statuses = findByCategories(categories, user, true, ReadingOrder.desc, false); update(markList(statuses, olderThan)); } public void markAllEntries(User user, Date olderThan) { - List statuses = getStatuses(user, true, + List statuses = findAll(user, true, ReadingOrder.desc, false); update(markList(statuses, olderThan)); } diff --git a/src/main/java/com/commafeed/backend/dao/FeedSubscriptionService.java b/src/main/java/com/commafeed/backend/dao/FeedSubscriptionDAO.java similarity index 61% rename from src/main/java/com/commafeed/backend/dao/FeedSubscriptionService.java rename to src/main/java/com/commafeed/backend/dao/FeedSubscriptionDAO.java index 4b5fd432..1b10324e 100644 --- a/src/main/java/com/commafeed/backend/dao/FeedSubscriptionService.java +++ b/src/main/java/com/commafeed/backend/dao/FeedSubscriptionDAO.java @@ -3,72 +3,21 @@ package com.commafeed.backend.dao; import java.util.List; import javax.ejb.Stateless; -import javax.inject.Inject; import com.commafeed.backend.model.Feed; import com.commafeed.backend.model.FeedCategory; -import com.commafeed.backend.model.FeedEntry; -import com.commafeed.backend.model.FeedEntryStatus; import com.commafeed.backend.model.FeedSubscription; import com.commafeed.backend.model.User; import com.commafeed.frontend.utils.ModelFactory.MF; -import com.google.api.client.util.Lists; import com.google.common.collect.Iterables; import com.uaihebert.factory.EasyCriteriaFactory; import com.uaihebert.model.EasyCriteria; @Stateless @SuppressWarnings("serial") -public class FeedSubscriptionService extends GenericDAO { +public class FeedSubscriptionDAO extends GenericDAO { - @Inject - FeedCategoryService feedCategoryService; - @Inject - FeedService feedService; - - @Inject - FeedEntryService feedEntryService; - - @Inject - FeedEntryStatusService feedEntryStatusService; - - public void subscribe(User user, String url, String title, - FeedCategory category) { - - Feed feed = feedService.findByUrl(url); - if (feed == null) { - feed = new Feed(); - feed.setUrl(url); - feedService.save(feed); - } - - FeedSubscription sub = findByFeed(user, feed); - boolean newSubscription = false; - if (sub == null) { - sub = new FeedSubscription(); - sub.setFeed(feed); - sub.setUser(user); - newSubscription = true; - } - sub.setCategory(category); - sub.setTitle(title); - saveOrUpdate(sub); - - if (newSubscription) { - List statuses = Lists.newArrayList(); - List allEntries = feedEntryService.findByFeed(feed, 0, - 10); - for (FeedEntry entry : allEntries) { - FeedEntryStatus status = new FeedEntryStatus(); - status.setEntry(entry); - status.setRead(true); - status.setSubscription(sub); - statuses.add(status); - } - feedEntryStatusService.save(statuses); - } - } public FeedSubscription findById(User user, Long id) { EasyCriteria criteria = createCriteria(); diff --git a/src/main/java/com/commafeed/backend/dao/GenericDAO.java b/src/main/java/com/commafeed/backend/dao/GenericDAO.java index 18eb7599..6a59ed37 100644 --- a/src/main/java/com/commafeed/backend/dao/GenericDAO.java +++ b/src/main/java/com/commafeed/backend/dao/GenericDAO.java @@ -7,11 +7,13 @@ 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 com.commafeed.backend.model.AbstractModel; +import com.commafeed.backend.model.FeedEntryStatus; import com.commafeed.frontend.utils.ModelFactory.MF; import com.google.common.reflect.TypeToken; import com.uaihebert.factory.EasyCriteriaFactory; @@ -128,6 +130,16 @@ public abstract class GenericDAO implements return criteria.getResultList(); } + protected void limit(TypedQuery query, int offset, + int limit) { + if (offset > -1) { + query.setFirstResult(offset); + } + if (limit > -1) { + query.setMaxResults(limit); + } + } + @SuppressWarnings("unchecked") protected Class getType() { return (Class) type.getRawType(); diff --git a/src/main/java/com/commafeed/backend/dao/UserDAO.java b/src/main/java/com/commafeed/backend/dao/UserDAO.java new file mode 100644 index 00000000..8a765734 --- /dev/null +++ b/src/main/java/com/commafeed/backend/dao/UserDAO.java @@ -0,0 +1,31 @@ +package com.commafeed.backend.dao; + +import javax.ejb.Stateless; +import javax.inject.Inject; +import javax.persistence.NoResultException; +import javax.persistence.TypedQuery; + +import com.commafeed.backend.model.User; +import com.commafeed.backend.services.PasswordEncryptionService; + +@Stateless +@SuppressWarnings("serial") +public class UserDAO extends GenericDAO { + + @Inject + PasswordEncryptionService encryptionService; + + public User findByName(String name) { + TypedQuery query = em.createNamedQuery("User.byName", User.class); + query.setParameter("name", name.toLowerCase()); + + User user = null; + try { + user = query.getSingleResult(); + } catch (NoResultException e) { + user = null; + } + return user; + } + +} diff --git a/src/main/java/com/commafeed/backend/dao/UserRoleService.java b/src/main/java/com/commafeed/backend/dao/UserRoleDAO.java similarity index 83% rename from src/main/java/com/commafeed/backend/dao/UserRoleService.java rename to src/main/java/com/commafeed/backend/dao/UserRoleDAO.java index a2d0c896..55ff9b1a 100644 --- a/src/main/java/com/commafeed/backend/dao/UserRoleService.java +++ b/src/main/java/com/commafeed/backend/dao/UserRoleDAO.java @@ -13,13 +13,13 @@ import com.google.common.collect.Sets; @SuppressWarnings("serial") @Stateless -public class UserRoleService extends GenericDAO { +public class UserRoleDAO extends GenericDAO { public List findAll(User user) { return findByField(MF.i(MF.p(UserRole.class).getUser()), user); } - public Set getRoles(User user) { + public Set findRoles(User user) { Set list = Sets.newHashSet(); for (UserRole role : findByField(MF.i(proxy().getUser()), user)) { list.add(role.getRole()); diff --git a/src/main/java/com/commafeed/backend/dao/UserSettingsService.java b/src/main/java/com/commafeed/backend/dao/UserSettingsDAO.java similarity index 88% rename from src/main/java/com/commafeed/backend/dao/UserSettingsService.java rename to src/main/java/com/commafeed/backend/dao/UserSettingsDAO.java index 0de5a32a..5610e3ab 100644 --- a/src/main/java/com/commafeed/backend/dao/UserSettingsService.java +++ b/src/main/java/com/commafeed/backend/dao/UserSettingsDAO.java @@ -11,7 +11,7 @@ import com.uaihebert.model.EasyCriteria; @Stateless @SuppressWarnings("serial") -public class UserSettingsService extends GenericDAO { +public class UserSettingsDAO extends GenericDAO { public UserSettings findByUser(User user) { diff --git a/src/main/java/com/commafeed/backend/feeds/FeedRefreshWorker.java b/src/main/java/com/commafeed/backend/feeds/FeedRefreshWorker.java index 223cea7c..19d1a762 100644 --- a/src/main/java/com/commafeed/backend/feeds/FeedRefreshWorker.java +++ b/src/main/java/com/commafeed/backend/feeds/FeedRefreshWorker.java @@ -22,9 +22,10 @@ import org.apache.commons.lang.time.DateUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import com.commafeed.backend.dao.FeedEntryService; -import com.commafeed.backend.dao.FeedService; +import com.commafeed.backend.dao.FeedDAO; +import com.commafeed.backend.dao.FeedEntryDAO; import com.commafeed.backend.model.Feed; +import com.commafeed.backend.services.FeedUpdateService; import com.google.common.collect.Iterables; @Stateless @@ -40,10 +41,13 @@ public class FeedRefreshWorker { FeedFetcher fetcher; @Inject - FeedService feedService; + FeedDAO feedDAO; @Inject - FeedEntryService feedEntryService; + FeedEntryDAO feedEntryDAO; + + @Inject + FeedUpdateService feedUpdateService; @Resource private UserTransaction transaction; @@ -102,13 +106,13 @@ public class FeedRefreshWorker { transaction.begin(); if (fetchedFeed != null) { - feedEntryService.updateEntries(feed.getUrl(), + feedUpdateService.updateEntries(feed.getUrl(), fetchedFeed.getEntries()); if (feed.getLink() == null) { feed.setLink(fetchedFeed.getLink()); } } - feedService.update(feed); + feedDAO.update(feed); transaction.commit(); @@ -121,10 +125,10 @@ public class FeedRefreshWorker { Feed feed = null; lock.lock(); try { - feed = Iterables.getFirst(feedService.findNextUpdatable(1), null); + feed = Iterables.getFirst(feedDAO.findNextUpdatable(1), null); if (feed != null) { feed.setLastUpdated(Calendar.getInstance().getTime()); - feedService.update(feed); + feedDAO.update(feed); } } finally { lock.unlock(); diff --git a/src/main/java/com/commafeed/backend/feeds/OPMLImporter.java b/src/main/java/com/commafeed/backend/feeds/OPMLImporter.java index e9fd6904..ec2345b2 100644 --- a/src/main/java/com/commafeed/backend/feeds/OPMLImporter.java +++ b/src/main/java/com/commafeed/backend/feeds/OPMLImporter.java @@ -7,11 +7,11 @@ import javax.inject.Inject; import org.apache.commons.lang.StringUtils; -import com.commafeed.backend.dao.FeedCategoryService; -import com.commafeed.backend.dao.FeedService; -import com.commafeed.backend.dao.FeedSubscriptionService; +import com.commafeed.backend.dao.FeedCategoryDAO; +import com.commafeed.backend.dao.FeedDAO; import com.commafeed.backend.model.FeedCategory; import com.commafeed.backend.model.User; +import com.commafeed.backend.services.FeedSubscriptionService; import com.sun.syndication.feed.opml.Opml; import com.sun.syndication.feed.opml.Outline; import com.sun.syndication.io.FeedException; @@ -20,13 +20,13 @@ import com.sun.syndication.io.WireFeedInput; public class OPMLImporter { @Inject - FeedService feedService; + FeedDAO feedDAO; @Inject FeedSubscriptionService feedSubscriptionService; @Inject - FeedCategoryService feedCategoryService; + FeedCategoryDAO feedCategoryDAO; @SuppressWarnings("unchecked") public void importOpml(User user, String xml) throws FeedException { @@ -43,14 +43,14 @@ public class OPMLImporter { private void handleOutline(User user, Outline outline, FeedCategory parent) { if (StringUtils.isEmpty(outline.getType())) { - FeedCategory category = feedCategoryService.findByName(user, + FeedCategory category = feedCategoryDAO.findByName(user, outline.getText(), parent); if (category == null) { category = new FeedCategory(); category.setName(outline.getText()); category.setParent(parent); category.setUser(user); - feedCategoryService.save(category); + feedCategoryDAO.save(category); } List children = outline.getChildren(); diff --git a/src/main/java/com/commafeed/backend/services/FeedSubscriptionService.java b/src/main/java/com/commafeed/backend/services/FeedSubscriptionService.java new file mode 100644 index 00000000..7d292336 --- /dev/null +++ b/src/main/java/com/commafeed/backend/services/FeedSubscriptionService.java @@ -0,0 +1,75 @@ +package com.commafeed.backend.services; + +import java.util.List; + +import javax.ejb.Stateless; +import javax.inject.Inject; + +import com.commafeed.backend.dao.FeedCategoryDAO; +import com.commafeed.backend.dao.FeedDAO; +import com.commafeed.backend.dao.FeedEntryDAO; +import com.commafeed.backend.dao.FeedEntryStatusDAO; +import com.commafeed.backend.dao.FeedSubscriptionDAO; +import com.commafeed.backend.model.Feed; +import com.commafeed.backend.model.FeedCategory; +import com.commafeed.backend.model.FeedEntry; +import com.commafeed.backend.model.FeedEntryStatus; +import com.commafeed.backend.model.FeedSubscription; +import com.commafeed.backend.model.User; +import com.google.api.client.util.Lists; + +@Stateless +public class FeedSubscriptionService { + + @Inject + FeedCategoryDAO feedCategoryDAO; + + @Inject + FeedDAO feedDAO; + + @Inject + FeedEntryDAO feedEntryDAO; + + @Inject + FeedEntryStatusDAO feedEntryStatusDAO; + + @Inject + FeedSubscriptionDAO feedSubscriptionDAO; + + public void subscribe(User user, String url, String title, + FeedCategory category) { + + Feed feed = feedDAO.findByUrl(url); + if (feed == null) { + feed = new Feed(); + feed.setUrl(url); + feedDAO.save(feed); + } + + FeedSubscription sub = feedSubscriptionDAO.findByFeed(user, feed); + boolean newSubscription = false; + if (sub == null) { + sub = new FeedSubscription(); + sub.setFeed(feed); + sub.setUser(user); + newSubscription = true; + } + sub.setCategory(category); + sub.setTitle(title); + feedSubscriptionDAO.saveOrUpdate(sub); + + if (newSubscription) { + List statuses = Lists.newArrayList(); + List allEntries = feedEntryDAO.findByFeed(feed, 0, + 10); + for (FeedEntry entry : allEntries) { + FeedEntryStatus status = new FeedEntryStatus(); + status.setEntry(entry); + status.setRead(true); + status.setSubscription(sub); + statuses.add(status); + } + feedEntryStatusDAO.save(statuses); + } + } +} diff --git a/src/main/java/com/commafeed/backend/dao/FeedEntryService.java b/src/main/java/com/commafeed/backend/services/FeedUpdateService.java similarity index 53% rename from src/main/java/com/commafeed/backend/dao/FeedEntryService.java rename to src/main/java/com/commafeed/backend/services/FeedUpdateService.java index cff37503..5a24f983 100644 --- a/src/main/java/com/commafeed/backend/dao/FeedEntryService.java +++ b/src/main/java/com/commafeed/backend/services/FeedUpdateService.java @@ -1,4 +1,4 @@ -package com.commafeed.backend.dao; +package com.commafeed.backend.services; import java.util.ArrayList; import java.util.Calendar; @@ -7,41 +7,44 @@ import java.util.List; import javax.ejb.Stateless; import javax.inject.Inject; -import javax.persistence.TypedQuery; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; import org.apache.commons.lang.ObjectUtils; import org.apache.commons.lang.StringUtils; +import com.commafeed.backend.dao.FeedDAO; +import com.commafeed.backend.dao.FeedEntryDAO; +import com.commafeed.backend.dao.FeedEntryStatusDAO; +import com.commafeed.backend.dao.FeedSubscriptionDAO; import com.commafeed.backend.model.Feed; import com.commafeed.backend.model.FeedEntry; import com.commafeed.backend.model.FeedEntryStatus; -import com.commafeed.backend.model.FeedEntry_; import com.commafeed.backend.model.FeedSubscription; -import com.commafeed.frontend.utils.ModelFactory.MF; import com.google.common.collect.Lists; -import com.uaihebert.model.EasyCriteria; @Stateless -@SuppressWarnings("serial") -public class FeedEntryService extends GenericDAO { +public class FeedUpdateService { @Inject - FeedService feedService; + FeedDAO feedDAO; @Inject - FeedSubscriptionService feedSubscriptionService; + FeedSubscriptionDAO feedSubscriptionDAO; + + @Inject + FeedEntryDAO feedEntryDAO; + + @Inject + FeedEntryStatusDAO feedEntryStatusDAO; public void updateEntries(String url, Collection entries) { - Feed feed = feedService.findByUrl(url); + Feed feed = feedDAO.findByUrl(url); List guids = Lists.newArrayList(); for (FeedEntry entry : entries) { guids.add(entry.getGuid()); } List existingEntries = guids.isEmpty() ? new ArrayList() - : findByGuids(guids); + : feedEntryDAO.findByGuids(guids); for (FeedEntry entry : entries) { FeedEntry foundEntry = null; for (FeedEntry existingEntry : existingEntries) { @@ -72,34 +75,15 @@ public class FeedEntryService extends GenericDAO { private void addFeedToEntry(FeedEntry entry, Feed feed) { entry.getFeeds().add(feed); - saveOrUpdate(entry); - List subscriptions = feedSubscriptionService + feedEntryDAO.saveOrUpdate(entry); + List subscriptions = feedSubscriptionDAO .findByFeed(feed); for (FeedSubscription sub : subscriptions) { FeedEntryStatus status = new FeedEntryStatus(); status.setEntry(entry); status.setSubscription(sub); - em.persist(status); + feedEntryStatusDAO.save(status); } } - - public List findByGuids(List guids) { - EasyCriteria criteria = createCriteria(); - criteria.setDistinctTrue(); - criteria.andStringIn(MF.i(proxy().getGuid()), guids); - criteria.leftJoinFetch(MF.i(proxy().getFeeds())); - return criteria.getResultList(); - } - - public List findByFeed(Feed feed, int offset, int limit) { - CriteriaQuery query = builder.createQuery(getType()); - Root root = query.from(getType()); - query.where(builder.isMember(feed, root.get(FeedEntry_.feeds))); - query.orderBy(builder.desc(root.get(FeedEntry_.updated))); - TypedQuery q = em.createQuery(query); - q.setFirstResult(offset); - q.setMaxResults(limit); - return q.getResultList(); - } } diff --git a/src/main/java/com/commafeed/backend/security/PasswordEncryptionService.java b/src/main/java/com/commafeed/backend/services/PasswordEncryptionService.java similarity index 92% rename from src/main/java/com/commafeed/backend/security/PasswordEncryptionService.java rename to src/main/java/com/commafeed/backend/services/PasswordEncryptionService.java index 2a438618..cbceb2f3 100644 --- a/src/main/java/com/commafeed/backend/security/PasswordEncryptionService.java +++ b/src/main/java/com/commafeed/backend/services/PasswordEncryptionService.java @@ -1,4 +1,4 @@ -package com.commafeed.backend.security; +package com.commafeed.backend.services; import java.security.NoSuchAlgorithmException; import java.security.SecureRandom; @@ -13,14 +13,14 @@ import javax.ejb.Singleton; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import com.commafeed.backend.dao.UserService; +import com.commafeed.backend.dao.UserDAO; // http://www.javacodegeeks.com/2012/05/secure-password-storage-donts-dos-and.html @Singleton public class PasswordEncryptionService { private static final Logger log = LoggerFactory - .getLogger(UserService.class); + .getLogger(UserDAO.class); public boolean authenticate(String attemptedPassword, byte[] encryptedPassword, byte[] salt) { diff --git a/src/main/java/com/commafeed/backend/dao/UserService.java b/src/main/java/com/commafeed/backend/services/UserService.java similarity index 63% rename from src/main/java/com/commafeed/backend/dao/UserService.java rename to src/main/java/com/commafeed/backend/services/UserService.java index be74fbc4..21947f96 100644 --- a/src/main/java/com/commafeed/backend/dao/UserService.java +++ b/src/main/java/com/commafeed/backend/services/UserService.java @@ -1,39 +1,26 @@ -package com.commafeed.backend.dao; +package com.commafeed.backend.services; import java.util.Collection; import javax.ejb.Stateless; import javax.inject.Inject; -import javax.persistence.NoResultException; -import javax.persistence.TypedQuery; +import com.commafeed.backend.dao.UserDAO; import com.commafeed.backend.model.User; import com.commafeed.backend.model.UserRole; import com.commafeed.backend.model.UserRole.Role; -import com.commafeed.backend.security.PasswordEncryptionService; @Stateless -@SuppressWarnings("serial") -public class UserService extends GenericDAO { +public class UserService { + + @Inject + UserDAO userDAO; @Inject PasswordEncryptionService encryptionService; - public User findByName(String name) { - TypedQuery query = em.createNamedQuery("User.byName", User.class); - query.setParameter("name", name.toLowerCase()); - - User user = null; - try { - user = query.getSingleResult(); - } catch (NoResultException e) { - user = null; - } - return user; - } - public User login(String name, String password) { - User user = findByName(name); + User user = userDAO.findByName(name); if (user != null && !user.isDisabled()) { boolean authenticated = encryptionService.authenticate(password, user.getPassword(), user.getSalt()); @@ -51,7 +38,7 @@ public class UserService extends GenericDAO { public User register(String name, String password, String email, Collection roles) { - if (findByName(name) != null) { + if (userDAO.findByName(name) != null) { return null; } User user = new User(); @@ -65,7 +52,7 @@ public class UserService extends GenericDAO { user.getRoles().add(new UserRole(user, role)); user.getRoles().add(new UserRole(user, role)); } - save(user); + userDAO.save(user); return user; } } diff --git a/src/main/java/com/commafeed/frontend/CommaFeedSession.java b/src/main/java/com/commafeed/frontend/CommaFeedSession.java index c4edc548..80c264e0 100644 --- a/src/main/java/com/commafeed/frontend/CommaFeedSession.java +++ b/src/main/java/com/commafeed/frontend/CommaFeedSession.java @@ -9,10 +9,10 @@ import org.apache.wicket.authroles.authentication.AuthenticatedWebSession; import org.apache.wicket.authroles.authorization.strategies.role.Roles; import org.apache.wicket.request.Request; -import com.commafeed.backend.dao.UserRoleService; -import com.commafeed.backend.dao.UserService; +import com.commafeed.backend.dao.UserRoleDAO; import com.commafeed.backend.model.User; import com.commafeed.backend.model.UserRole.Role; +import com.commafeed.backend.services.UserService; import com.google.common.collect.Sets; @SuppressWarnings("serial") @@ -22,7 +22,7 @@ public class CommaFeedSession extends AuthenticatedWebSession { UserService userService; @Inject - UserRoleService userRoleService; + UserRoleDAO userRoleDAO; private User user; private Roles roles = new Roles(); @@ -57,7 +57,7 @@ public class CommaFeedSession extends AuthenticatedWebSession { } else { Set roleSet = Sets.newHashSet(); - for (Role role : userRoleService.getRoles(user)) { + for (Role role : userRoleDAO.findRoles(user)) { roleSet.add(role.name()); } this.user = user; diff --git a/src/main/java/com/commafeed/frontend/pages/BasePage.java b/src/main/java/com/commafeed/frontend/pages/BasePage.java index 1331e8d9..46d7c267 100644 --- a/src/main/java/com/commafeed/frontend/pages/BasePage.java +++ b/src/main/java/com/commafeed/frontend/pages/BasePage.java @@ -5,14 +5,14 @@ import javax.inject.Inject; import org.apache.wicket.markup.head.IHeaderResponse; import org.apache.wicket.markup.html.WebPage; -import com.commafeed.backend.dao.FeedCategoryService; -import com.commafeed.backend.dao.FeedEntryService; -import com.commafeed.backend.dao.FeedEntryStatusService; -import com.commafeed.backend.dao.FeedService; -import com.commafeed.backend.dao.FeedSubscriptionService; -import com.commafeed.backend.dao.UserRoleService; -import com.commafeed.backend.dao.UserService; -import com.commafeed.backend.dao.UserSettingsService; +import com.commafeed.backend.dao.FeedCategoryDAO; +import com.commafeed.backend.dao.FeedDAO; +import com.commafeed.backend.dao.FeedEntryDAO; +import com.commafeed.backend.dao.FeedEntryStatusDAO; +import com.commafeed.backend.dao.FeedSubscriptionDAO; +import com.commafeed.backend.dao.UserDAO; +import com.commafeed.backend.dao.UserRoleDAO; +import com.commafeed.backend.dao.UserSettingsDAO; import de.agilecoders.wicket.Bootstrap; @@ -20,28 +20,28 @@ import de.agilecoders.wicket.Bootstrap; public class BasePage extends WebPage { @Inject - protected FeedService feedService; + protected FeedDAO feedDAO; @Inject - protected FeedSubscriptionService feedSubscriptionService; + protected FeedSubscriptionDAO feedSubscriptionDAO; @Inject - protected FeedCategoryService feedCategoryService; + protected FeedCategoryDAO feedCategoryDAO; @Inject - protected FeedEntryService feedEntryService; + protected FeedEntryDAO feedEntryDAO; @Inject - protected FeedEntryStatusService feedEntryStatusService; + protected FeedEntryStatusDAO feedEntryStatusDAO; @Inject - protected UserService userService; + protected UserDAO userDAO; @Inject - protected UserSettingsService userSettingsService; + protected UserSettingsDAO userSettingsDAO; @Inject - protected UserRoleService userRoleService; + protected UserRoleDAO userRoleDAO; @Override public void renderHead(IHeaderResponse response) { diff --git a/src/main/java/com/commafeed/frontend/pages/GoogleImportCallbackPage.java b/src/main/java/com/commafeed/frontend/pages/GoogleImportCallbackPage.java index 72e1959d..d37cc9ce 100644 --- a/src/main/java/com/commafeed/frontend/pages/GoogleImportCallbackPage.java +++ b/src/main/java/com/commafeed/frontend/pages/GoogleImportCallbackPage.java @@ -10,8 +10,8 @@ import org.apache.wicket.request.UrlRenderer; import org.apache.wicket.request.cycle.RequestCycle; import org.apache.wicket.request.mapper.parameter.PageParameters; -import com.commafeed.backend.dao.ApplicationSettingsService; -import com.commafeed.backend.dao.UserService; +import com.commafeed.backend.dao.ApplicationSettingsDAO; +import com.commafeed.backend.dao.UserDAO; import com.commafeed.backend.feeds.OPMLImporter; import com.commafeed.backend.model.ApplicationSettings; import com.commafeed.frontend.utils.WicketUtils; @@ -33,13 +33,13 @@ public class GoogleImportCallbackPage extends WebPage { private static final String EXPORT_URL = "https://www.google.com/reader/subscriptions/export"; @Inject - ApplicationSettingsService applicationSettingsService; + ApplicationSettingsDAO applicationSettingsDAO; @Inject OPMLImporter importer; @Inject - UserService userService; + UserDAO userDAO; public static String getCallbackUrl() { RequestCycle cycle = RequestCycle.get(); @@ -65,7 +65,7 @@ public class GoogleImportCallbackPage extends WebPage { } else if (code == null) { throw new DisplayException("Missing authorization code"); } else { - ApplicationSettings settings = applicationSettingsService.get(); + ApplicationSettings settings = applicationSettingsDAO.get(); String redirectUri = getCallbackUrl(); String clientId = settings.getGoogleClientId(); String clientSecret = settings.getGoogleClientSecret(); @@ -90,7 +90,7 @@ public class GoogleImportCallbackPage extends WebPage { httpRequest, accessToken); String opml = httpRequest.execute().parseAsString(); String state = responseUrl.getState(); - importer.importOpml(userService.findById(Long.valueOf(state)), + importer.importOpml(userDAO.findById(Long.valueOf(state)), opml); } catch (Exception e) { throw new DisplayException(e); diff --git a/src/main/java/com/commafeed/frontend/pages/GoogleImportRedirectPage.java b/src/main/java/com/commafeed/frontend/pages/GoogleImportRedirectPage.java index 4e0f8a53..74ec8c7c 100644 --- a/src/main/java/com/commafeed/frontend/pages/GoogleImportRedirectPage.java +++ b/src/main/java/com/commafeed/frontend/pages/GoogleImportRedirectPage.java @@ -9,7 +9,7 @@ import org.apache.wicket.markup.html.WebPage; import org.apache.wicket.request.flow.RedirectToUrlException; import org.jboss.logging.Logger; -import com.commafeed.backend.dao.ApplicationSettingsService; +import com.commafeed.backend.dao.ApplicationSettingsDAO; import com.commafeed.backend.model.ApplicationSettings; import com.commafeed.frontend.CommaFeedSession; @@ -23,11 +23,11 @@ public class GoogleImportRedirectPage extends WebPage { private static final String AUTH_URL = "https://accounts.google.com/o/oauth2/auth"; @Inject - ApplicationSettingsService applicationSettingsService; + ApplicationSettingsDAO applicationSettingsDAO; public GoogleImportRedirectPage() { - ApplicationSettings settings = applicationSettingsService.get(); + ApplicationSettings settings = applicationSettingsDAO.get(); String clientId = settings.getGoogleClientId(); diff --git a/src/main/java/com/commafeed/frontend/pages/HomePage.java b/src/main/java/com/commafeed/frontend/pages/HomePage.java index e1e81ea8..debbe764 100644 --- a/src/main/java/com/commafeed/frontend/pages/HomePage.java +++ b/src/main/java/com/commafeed/frontend/pages/HomePage.java @@ -7,7 +7,7 @@ import org.apache.wicket.markup.head.IHeaderResponse; import org.apache.wicket.markup.head.JavaScriptHeaderItem; import org.apache.wicket.request.mapper.parameter.PageParameters; -import com.commafeed.backend.dao.UserSettingsService; +import com.commafeed.backend.dao.UserSettingsDAO; import com.commafeed.backend.model.UserRole.Role; import com.commafeed.backend.model.UserSettings; import com.commafeed.frontend.CommaFeedSession; @@ -34,7 +34,7 @@ import de.agilecoders.wicket.markup.html.bootstrap.extensions.icon.OpenWebIconsC public class HomePage extends BasePage { @Inject - UserSettingsService settingsService; + UserSettingsDAO userSettingsDAO; @Override public void renderHead(IHeaderResponse response) { @@ -67,7 +67,7 @@ public class HomePage extends BasePage { new UserCustomCssReference() { @Override protected String getCss() { - UserSettings settings = settingsService + UserSettings settings = userSettingsDAO .findByUser(CommaFeedSession.get().getUser()); return settings == null ? null : settings .getCustomCss(); diff --git a/src/main/java/com/commafeed/frontend/pages/WelcomePage.java b/src/main/java/com/commafeed/frontend/pages/WelcomePage.java index 7258db7b..910d9079 100644 --- a/src/main/java/com/commafeed/frontend/pages/WelcomePage.java +++ b/src/main/java/com/commafeed/frontend/pages/WelcomePage.java @@ -4,7 +4,7 @@ import javax.inject.Inject; import org.apache.wicket.markup.head.IHeaderResponse; -import com.commafeed.backend.dao.ApplicationSettingsService; +import com.commafeed.backend.dao.ApplicationSettingsDAO; import com.commafeed.frontend.pages.components.LoginPanel; import com.commafeed.frontend.pages.components.RegisterPanel; import com.commafeed.frontend.utils.WicketUtils; @@ -13,7 +13,7 @@ import com.commafeed.frontend.utils.WicketUtils; public class WelcomePage extends BasePage { @Inject - ApplicationSettingsService applicationSettingsService; + ApplicationSettingsDAO applicationSettingsDAO; public WelcomePage() { add(new LoginPanel("login")); @@ -21,7 +21,7 @@ public class WelcomePage extends BasePage { @Override protected void onConfigure() { super.onConfigure(); - setVisibilityAllowed(applicationSettingsService.get() + setVisibilityAllowed(applicationSettingsDAO.get() .isAllowRegistrations()); } }); diff --git a/src/main/java/com/commafeed/frontend/pages/components/RegisterPanel.java b/src/main/java/com/commafeed/frontend/pages/components/RegisterPanel.java index 158b1d5e..17a3fc67 100644 --- a/src/main/java/com/commafeed/frontend/pages/components/RegisterPanel.java +++ b/src/main/java/com/commafeed/frontend/pages/components/RegisterPanel.java @@ -20,10 +20,11 @@ import org.apache.wicket.validation.IValidator; import org.apache.wicket.validation.ValidationError; import org.apache.wicket.validation.validator.StringValidator; -import com.commafeed.backend.dao.ApplicationSettingsService; -import com.commafeed.backend.dao.UserService; +import com.commafeed.backend.dao.ApplicationSettingsDAO; +import com.commafeed.backend.dao.UserDAO; import com.commafeed.backend.model.User; import com.commafeed.backend.model.UserRole.Role; +import com.commafeed.backend.services.UserService; import com.commafeed.frontend.CommaFeedSession; import com.commafeed.frontend.model.RegistrationRequest; import com.commafeed.frontend.pages.GoogleImportRedirectPage; @@ -32,11 +33,14 @@ import com.commafeed.frontend.utils.ModelFactory.MF; @SuppressWarnings("serial") public class RegisterPanel extends Panel { + @Inject + UserDAO userDAO; + @Inject UserService userService; @Inject - ApplicationSettingsService applicationSettingsService; + ApplicationSettingsDAO applicationSettingsDAO; public RegisterPanel(String markupId) { super(markupId); @@ -47,7 +51,7 @@ public class RegisterPanel extends Panel { "form", model) { @Override protected void onSubmit() { - if (applicationSettingsService.get().isAllowRegistrations()) { + if (applicationSettingsDAO.get().isAllowRegistrations()) { RegistrationRequest req = getModelObject(); userService.register(req.getName(), req.getPassword(), Arrays.asList(Role.USER)); @@ -79,7 +83,7 @@ public class RegisterPanel extends Panel { public void validate( IValidatable validatable) { String name = validatable.getValue(); - User user = userService.findByName(name); + User user = userDAO.findByName(name); if (user != null) { validatable.error(new ValidationError( "Name is already taken.")); diff --git a/src/main/java/com/commafeed/frontend/rest/resources/AbstractREST.java b/src/main/java/com/commafeed/frontend/rest/resources/AbstractREST.java index 58b7b3c2..2ba774ce 100644 --- a/src/main/java/com/commafeed/frontend/rest/resources/AbstractREST.java +++ b/src/main/java/com/commafeed/frontend/rest/resources/AbstractREST.java @@ -23,19 +23,21 @@ import org.apache.wicket.protocol.http.servlet.ServletWebRequest; import org.apache.wicket.protocol.http.servlet.ServletWebResponse; import org.apache.wicket.request.cycle.RequestCycle; -import com.commafeed.backend.dao.FeedCategoryService; -import com.commafeed.backend.dao.FeedEntryService; -import com.commafeed.backend.dao.FeedEntryStatusService; -import com.commafeed.backend.dao.FeedService; -import com.commafeed.backend.dao.FeedSubscriptionService; -import com.commafeed.backend.dao.UserRoleService; -import com.commafeed.backend.dao.UserService; -import com.commafeed.backend.dao.UserSettingsService; +import com.commafeed.backend.dao.FeedCategoryDAO; +import com.commafeed.backend.dao.FeedDAO; +import com.commafeed.backend.dao.FeedEntryDAO; +import com.commafeed.backend.dao.FeedEntryStatusDAO; +import com.commafeed.backend.dao.FeedSubscriptionDAO; +import com.commafeed.backend.dao.UserDAO; +import com.commafeed.backend.dao.UserRoleDAO; +import com.commafeed.backend.dao.UserSettingsDAO; import com.commafeed.backend.feeds.FeedFetcher; import com.commafeed.backend.feeds.OPMLImporter; import com.commafeed.backend.model.User; import com.commafeed.backend.model.UserRole.Role; -import com.commafeed.backend.security.PasswordEncryptionService; +import com.commafeed.backend.services.FeedSubscriptionService; +import com.commafeed.backend.services.PasswordEncryptionService; +import com.commafeed.backend.services.UserService; import com.commafeed.frontend.CommaFeedApplication; import com.commafeed.frontend.CommaFeedSession; import com.commafeed.frontend.SecurityCheck; @@ -52,28 +54,34 @@ public abstract class AbstractREST { HttpServletResponse response; @Inject - FeedService feedService; + FeedDAO feedDAO; + + @Inject + FeedSubscriptionDAO feedSubscriptionDAO; @Inject FeedSubscriptionService feedSubscriptionService; @Inject - FeedCategoryService feedCategoryService; + FeedCategoryDAO feedCategoryDAO; @Inject - FeedEntryService feedEntryService; + FeedEntryDAO feedEntryDAO; @Inject - FeedEntryStatusService feedEntryStatusService; + FeedEntryStatusDAO feedEntryStatusDAO; + + @Inject + UserDAO userDAO; @Inject UserService userService; @Inject - UserSettingsService userSettingsService; + UserSettingsDAO userSettingsDAO; @Inject - UserRoleService userRoleService; + UserRoleDAO userRoleDAO; @Inject OPMLImporter opmlImporter; diff --git a/src/main/java/com/commafeed/frontend/rest/resources/AdminSettingsREST.java b/src/main/java/com/commafeed/frontend/rest/resources/AdminSettingsREST.java index 0c8c90ec..e90e8513 100644 --- a/src/main/java/com/commafeed/frontend/rest/resources/AdminSettingsREST.java +++ b/src/main/java/com/commafeed/frontend/rest/resources/AdminSettingsREST.java @@ -6,7 +6,7 @@ import javax.ws.rs.POST; import javax.ws.rs.Path; import javax.ws.rs.core.Response; -import com.commafeed.backend.dao.ApplicationSettingsService; +import com.commafeed.backend.dao.ApplicationSettingsDAO; import com.commafeed.backend.model.ApplicationSettings; import com.commafeed.backend.model.UserRole.Role; import com.commafeed.frontend.SecurityCheck; @@ -16,18 +16,18 @@ import com.commafeed.frontend.SecurityCheck; public class AdminSettingsREST { @Inject - ApplicationSettingsService applicationSettingsService; + ApplicationSettingsDAO applicationSettingsDAO; @Path("get") @GET public ApplicationSettings get() { - return applicationSettingsService.get(); + return applicationSettingsDAO.get(); } @Path("save") @POST public Response save(ApplicationSettings settings) { - applicationSettingsService.save(settings); + applicationSettingsDAO.save(settings); return Response.ok().build(); } } diff --git a/src/main/java/com/commafeed/frontend/rest/resources/AdminUsersREST.java b/src/main/java/com/commafeed/frontend/rest/resources/AdminUsersREST.java index b1bc8ef4..f8dcf685 100644 --- a/src/main/java/com/commafeed/frontend/rest/resources/AdminUsersREST.java +++ b/src/main/java/com/commafeed/frontend/rest/resources/AdminUsersREST.java @@ -50,7 +50,7 @@ public class AdminUsersREST extends AbstractREST { .entity("User already exists.").build(); } } else { - User user = userService.findById(id); + User user = userDAO.findById(id); if (StartupBean.ADMIN_NAME.equals(user.getName()) && !userModel.isEnabled()) { return Response.status(Status.FORBIDDEN) @@ -62,11 +62,11 @@ public class AdminUsersREST extends AbstractREST { userModel.getPassword(), user.getSalt())); } user.setDisabled(!userModel.isEnabled()); - userService.update(user); + userDAO.update(user); - Set roles = userRoleService.getRoles(user); + Set roles = userRoleDAO.findRoles(user); if (userModel.isAdmin() && !roles.contains(Role.ADMIN)) { - userRoleService.save(new UserRole(user, Role.ADMIN)); + userRoleDAO.save(new UserRole(user, Role.ADMIN)); } else if (!userModel.isAdmin() && roles.contains(Role.ADMIN)) { if (StartupBean.ADMIN_NAME.equals(user.getName())) { return Response @@ -74,9 +74,9 @@ public class AdminUsersREST extends AbstractREST { .entity("You cannot remove the admin role from the admin user.") .build(); } - for (UserRole userRole : userRoleService.findAll(user)) { + for (UserRole userRole : userRoleDAO.findAll(user)) { if (userRole.getRole() == Role.ADMIN) { - userRoleService.delete(userRole); + userRoleDAO.delete(userRole); } } } @@ -89,12 +89,12 @@ public class AdminUsersREST extends AbstractREST { @Path("get") @GET public UserModel getUser(@QueryParam("id") Long id) { - User user = userService.findById(id); + User user = userDAO.findById(id); UserModel userModel = new UserModel(); userModel.setId(user.getId()); userModel.setName(user.getName()); userModel.setEnabled(!user.isDisabled()); - for (UserRole role : userRoleService.findAll(user)) { + for (UserRole role : userRoleDAO.findAll(user)) { if (role.getRole() == Role.ADMIN) { userModel.setAdmin(true); } @@ -106,7 +106,7 @@ public class AdminUsersREST extends AbstractREST { @GET public Collection getUsers() { Map users = Maps.newHashMap(); - for (UserRole role : userRoleService.findAll()) { + for (UserRole role : userRoleDAO.findAll()) { User user = role.getUser(); Long key = user.getId(); UserModel userModel = users.get(key); @@ -127,7 +127,7 @@ public class AdminUsersREST extends AbstractREST { @Path("delete") @GET public Response delete(@QueryParam("id") Long id) { - User user = userService.findById(id); + User user = userDAO.findById(id); if (user == null) { return Response.status(Status.NOT_FOUND).build(); } @@ -135,13 +135,13 @@ public class AdminUsersREST extends AbstractREST { return Response.status(Status.FORBIDDEN) .entity("You cannot delete the admin user.").build(); } - feedEntryStatusService.delete(feedEntryStatusService.getStatuses(user, + feedEntryStatusDAO.delete(feedEntryStatusDAO.findAll(user, false, ReadingOrder.desc, false)); - feedSubscriptionService.delete(feedSubscriptionService.findAll(user)); - feedCategoryService.delete(feedCategoryService.findAll(user)); - userSettingsService.delete(userSettingsService.findByUser(user)); - userRoleService.delete(userRoleService.findAll(user)); - userService.delete(user); + feedSubscriptionDAO.delete(feedSubscriptionDAO.findAll(user)); + feedCategoryDAO.delete(feedCategoryDAO.findAll(user)); + userSettingsDAO.delete(userSettingsDAO.findByUser(user)); + userRoleDAO.delete(userRoleDAO.findAll(user)); + userDAO.delete(user); return Response.ok().build(); } diff --git a/src/main/java/com/commafeed/frontend/rest/resources/EntriesREST.java b/src/main/java/com/commafeed/frontend/rest/resources/EntriesREST.java index 8f3bd7e0..e30b927b 100644 --- a/src/main/java/com/commafeed/frontend/rest/resources/EntriesREST.java +++ b/src/main/java/com/commafeed/frontend/rest/resources/EntriesREST.java @@ -54,15 +54,15 @@ public class EntriesREST extends AbstractREST { boolean unreadOnly = readType == ReadType.unread; if (type == Type.feed) { - FeedSubscription subscription = feedSubscriptionService.findById( + FeedSubscription subscription = feedSubscriptionDAO.findById( getUser(), Long.valueOf(id)); if (subscription != null) { entries.setName(subscription.getTitle()); entries.setMessage(subscription.getFeed().getMessage()); entries.setErrorCount(subscription.getFeed().getErrorCount()); - List unreadEntries = feedEntryStatusService - .getStatuses(subscription.getFeed(), getUser(), + List unreadEntries = feedEntryStatusDAO + .findByFeed(subscription.getFeed(), getUser(), unreadOnly, offset, limit, order, true); for (FeedEntryStatus status : unreadEntries) { entries.getEntries().add(buildEntry(status)); @@ -73,21 +73,21 @@ public class EntriesREST extends AbstractREST { if (ALL.equals(id)) { entries.setName("All"); - List unreadEntries = feedEntryStatusService - .getStatuses(getUser(), unreadOnly, offset, limit, + List unreadEntries = feedEntryStatusDAO + .findAll(getUser(), unreadOnly, offset, limit, order, true); for (FeedEntryStatus status : unreadEntries) { entries.getEntries().add(buildEntry(status)); } } else { - FeedCategory feedCategory = feedCategoryService.findById( + FeedCategory feedCategory = feedCategoryDAO.findById( getUser(), Long.valueOf(id)); if (feedCategory != null) { - List childrenCategories = feedCategoryService + List childrenCategories = feedCategoryDAO .findAllChildrenCategories(getUser(), feedCategory); - List unreadEntries = feedEntryStatusService - .getStatuses(childrenCategories, getUser(), + List unreadEntries = feedEntryStatusDAO + .findByCategories(childrenCategories, getUser(), unreadOnly, offset, limit, order, true); for (FeedEntryStatus status : unreadEntries) { entries.getEntries().add(buildEntry(status)); @@ -136,15 +136,15 @@ public class EntriesREST extends AbstractREST { olderThanTimestamp); if (type == Type.entry) { - FeedEntryStatus status = feedEntryStatusService.findById(getUser(), + FeedEntryStatus status = feedEntryStatusDAO.findById(getUser(), Long.valueOf(id)); status.setRead(read); - feedEntryStatusService.update(status); + feedEntryStatusDAO.update(status); } else if (type == Type.feed) { if (read) { - FeedSubscription subscription = feedSubscriptionService + FeedSubscription subscription = feedSubscriptionDAO .findById(getUser(), Long.valueOf(id)); - feedEntryStatusService.markFeedEntries(getUser(), + feedEntryStatusDAO.markFeedEntries(getUser(), subscription.getFeed(), olderThan); } else { throw new WebApplicationException(Response.status( @@ -153,13 +153,13 @@ public class EntriesREST extends AbstractREST { } else if (type == Type.category) { if (read) { if (ALL.equals(id)) { - feedEntryStatusService.markAllEntries(getUser(), olderThan); + feedEntryStatusDAO.markAllEntries(getUser(), olderThan); } else { - List categories = feedCategoryService + List categories = feedCategoryDAO .findAllChildrenCategories(getUser(), - feedCategoryService.findById(getUser(), + feedCategoryDAO.findById(getUser(), Long.valueOf(id))); - feedEntryStatusService.markCategoryEntries(getUser(), + feedEntryStatusDAO.markCategoryEntries(getUser(), categories, olderThan); } } else { @@ -180,8 +180,8 @@ public class EntriesREST extends AbstractREST { Entries entries = new Entries(); List list = Lists.newArrayList(); - List entriesStatus = feedEntryStatusService - .getStatusesByKeywords(getUser(), keywords, offset, limit, true); + List entriesStatus = feedEntryStatusDAO + .findByKeywords(getUser(), keywords, offset, limit, true); for (FeedEntryStatus status : entriesStatus) { list.add(buildEntry(status)); } diff --git a/src/main/java/com/commafeed/frontend/rest/resources/SessionREST.java b/src/main/java/com/commafeed/frontend/rest/resources/SessionREST.java index a61ac923..3bd2e7d4 100644 --- a/src/main/java/com/commafeed/frontend/rest/resources/SessionREST.java +++ b/src/main/java/com/commafeed/frontend/rest/resources/SessionREST.java @@ -19,7 +19,7 @@ public class SessionREST extends AbstractREST { userModel.setId(user.getId()); userModel.setName(user.getName()); userModel.setEnabled(!user.isDisabled()); - for (UserRole role : userRoleService.findAll(user)) { + for (UserRole role : userRoleDAO.findAll(user)) { if (role.getRole() == Role.ADMIN) { userModel.setAdmin(true); } diff --git a/src/main/java/com/commafeed/frontend/rest/resources/SettingsREST.java b/src/main/java/com/commafeed/frontend/rest/resources/SettingsREST.java index 4000a53b..6ddaaa6a 100644 --- a/src/main/java/com/commafeed/frontend/rest/resources/SettingsREST.java +++ b/src/main/java/com/commafeed/frontend/rest/resources/SettingsREST.java @@ -19,7 +19,7 @@ public class SettingsREST extends AbstractREST { @GET public Settings get() { Settings s = new Settings(); - UserSettings settings = userSettingsService.findByUser(getUser()); + UserSettings settings = userSettingsDAO.findByUser(getUser()); if (settings != null) { s.setReadingMode(settings.getReadingMode().name()); s.setReadingOrder(settings.getReadingOrder().name()); @@ -36,7 +36,7 @@ public class SettingsREST extends AbstractREST { public Response save(Settings settings) { Preconditions.checkNotNull(settings); - UserSettings s = userSettingsService.findByUser(getUser()); + UserSettings s = userSettingsDAO.findByUser(getUser()); if (s == null) { s = new UserSettings(); s.setUser(getUser()); @@ -44,7 +44,7 @@ public class SettingsREST extends AbstractREST { s.setReadingMode(ReadingMode.valueOf(settings.getReadingMode())); s.setReadingOrder(ReadingOrder.valueOf(settings.getReadingOrder())); s.setCustomCss(settings.getCustomCss()); - userSettingsService.saveOrUpdate(s); + userSettingsDAO.saveOrUpdate(s); return Response.ok(Status.OK).build(); } diff --git a/src/main/java/com/commafeed/frontend/rest/resources/SubscriptionsREST.java b/src/main/java/com/commafeed/frontend/rest/resources/SubscriptionsREST.java index 43f7ea55..46b81259 100644 --- a/src/main/java/com/commafeed/frontend/rest/resources/SubscriptionsREST.java +++ b/src/main/java/com/commafeed/frontend/rest/resources/SubscriptionsREST.java @@ -61,7 +61,7 @@ public class SubscriptionsREST extends AbstractREST { String url = prependHttp(req.getUrl()); FeedCategory category = EntriesREST.ALL.equals(req.getCategoryId()) ? null - : feedCategoryService + : feedCategoryDAO .findById(Long.valueOf(req.getCategoryId())); Feed fetchedFeed = fetchFeed(url); feedSubscriptionService.subscribe(getUser(), fetchedFeed.getUrl(), @@ -80,10 +80,10 @@ public class SubscriptionsREST extends AbstractREST { @GET @Path("unsubscribe") public Response unsubscribe(@QueryParam("id") Long subscriptionId) { - FeedSubscription sub = feedSubscriptionService.findById(getUser(), + FeedSubscription sub = feedSubscriptionDAO.findById(getUser(), subscriptionId); if (sub != null) { - feedSubscriptionService.delete(sub); + feedSubscriptionDAO.delete(sub); return Response.ok(Status.OK).build(); } else { return Response.status(Status.NOT_FOUND).build(); @@ -95,14 +95,14 @@ public class SubscriptionsREST extends AbstractREST { public Response rename(@QueryParam("type") Type type, @QueryParam("id") Long id, @QueryParam("name") String name) { if (type == Type.feed) { - FeedSubscription subscription = feedSubscriptionService.findById( + FeedSubscription subscription = feedSubscriptionDAO.findById( getUser(), id); subscription.setTitle(name); - feedSubscriptionService.update(subscription); + feedSubscriptionDAO.update(subscription); } else if (type == Type.category) { - FeedCategory category = feedCategoryService.findById(getUser(), id); + FeedCategory category = feedCategoryDAO.findById(getUser(), id); category.setName(name); - feedCategoryService.update(category); + feedCategoryDAO.update(category); } return Response.ok(Status.OK).build(); } @@ -113,10 +113,10 @@ public class SubscriptionsREST extends AbstractREST { @QueryParam("collapse") boolean collapse) { Preconditions.checkNotNull(id); if (!EntriesREST.ALL.equals(id)) { - FeedCategory category = feedCategoryService.findById(getUser(), + FeedCategory category = feedCategoryDAO.findById(getUser(), Long.valueOf(id)); category.setCollapsed(collapse); - feedCategoryService.update(category); + feedCategoryDAO.update(category); } return Response.ok(Status.OK).build(); } @@ -135,22 +135,22 @@ public class SubscriptionsREST extends AbstractREST { parent.setId(Long.valueOf(parentId)); cat.setParent(parent); } - feedCategoryService.save(cat); + feedCategoryDAO.save(cat); return Response.ok().build(); } @GET @Path("deleteCategory") public Response deleteCategory(@QueryParam("id") Long id) { - FeedCategory cat = feedCategoryService.findById(getUser(), id); + FeedCategory cat = feedCategoryDAO.findById(getUser(), id); if (cat != null) { - List subs = feedSubscriptionService + List subs = feedSubscriptionDAO .findByCategory(getUser(), cat); for (FeedSubscription sub : subs) { sub.setCategory(null); } - feedSubscriptionService.update(subs); - feedCategoryService.delete(cat); + feedSubscriptionDAO.update(subs); + feedCategoryDAO.delete(cat); return Response.ok().build(); } else { return Response.status(Status.NOT_FOUND).build(); @@ -182,10 +182,10 @@ public class SubscriptionsREST extends AbstractREST { @GET public Category getSubscriptions() { - List categories = feedCategoryService.findAll(getUser()); - List subscriptions = feedSubscriptionService + List categories = feedCategoryDAO.findAll(getUser()); + List subscriptions = feedSubscriptionDAO .findAll(getUser()); - Map unreadCount = feedEntryStatusService + Map unreadCount = feedEntryStatusDAO .getUnreadCount(getUser()); Category root = buildCategory(null, categories, subscriptions,