001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.blogs.service.impl;
016    
017    import com.liferay.portal.kernel.exception.PortalException;
018    import com.liferay.portal.kernel.util.OrderByComparator;
019    import com.liferay.portal.kernel.workflow.WorkflowConstants;
020    import com.liferay.portal.model.Group;
021    import com.liferay.portlet.blogs.NoSuchStatsUserException;
022    import com.liferay.portlet.blogs.model.BlogsEntry;
023    import com.liferay.portlet.blogs.model.BlogsStatsUser;
024    import com.liferay.portlet.blogs.service.base.BlogsStatsUserLocalServiceBaseImpl;
025    import com.liferay.portlet.blogs.util.comparator.EntryDisplayDateComparator;
026    import com.liferay.portlet.blogs.util.comparator.StatsUserLastPostDateComparator;
027    
028    import java.util.Date;
029    import java.util.List;
030    
031    /**
032     * @author Brian Wing Shun Chan
033     * @author Mate Thurzo
034     */
035    public class BlogsStatsUserLocalServiceImpl
036            extends BlogsStatsUserLocalServiceBaseImpl {
037    
038            @Override
039            public void deleteStatsUser(BlogsStatsUser statsUsers) {
040                    blogsStatsUserPersistence.remove(statsUsers);
041            }
042    
043            @Override
044            public void deleteStatsUser(long statsUserId) throws PortalException {
045                    BlogsStatsUser statsUsers = blogsStatsUserPersistence.findByPrimaryKey(
046                            statsUserId);
047    
048                    deleteStatsUser(statsUsers);
049            }
050    
051            @Override
052            public void deleteStatsUserByGroupId(long groupId) {
053                    List<BlogsStatsUser> statsUsers =
054                            blogsStatsUserPersistence.findByGroupId(groupId);
055    
056                    for (BlogsStatsUser statsUser : statsUsers) {
057                            deleteStatsUser(statsUser);
058                    }
059            }
060    
061            @Override
062            public void deleteStatsUserByUserId(long userId) {
063                    List<BlogsStatsUser> statsUsers =
064                            blogsStatsUserPersistence.findByUserId(userId);
065    
066                    for (BlogsStatsUser statsUser : statsUsers) {
067                            deleteStatsUser(statsUser);
068                    }
069            }
070    
071            @Override
072            public List<BlogsStatsUser> getCompanyStatsUsers(
073                    long companyId, int start, int end) {
074    
075                    return blogsStatsUserPersistence.findByC_NotE(
076                            companyId, 0, start, end, new StatsUserLastPostDateComparator());
077            }
078    
079            @Override
080            public List<BlogsStatsUser> getCompanyStatsUsers(
081                    long companyId, int start, int end,
082                    OrderByComparator<BlogsStatsUser> obc) {
083    
084                    return blogsStatsUserPersistence.findByC_NotE(
085                            companyId, 0, start, end, obc);
086            }
087    
088            @Override
089            public int getCompanyStatsUsersCount(long companyId) {
090                    return blogsStatsUserPersistence.countByC_NotE(companyId, 0);
091            }
092    
093            @Override
094            public List<BlogsStatsUser> getGroupsStatsUsers(
095                    long companyId, long groupId, int start, int end) {
096    
097                    return blogsStatsUserFinder.findByGroupIds(
098                            companyId, groupId, start, end);
099            }
100    
101            @Override
102            public List<BlogsStatsUser> getGroupStatsUsers(
103                    long groupId, int start, int end) {
104    
105                    return blogsStatsUserPersistence.findByG_NotE(
106                            groupId, 0, start, end, new StatsUserLastPostDateComparator());
107            }
108    
109            @Override
110            public List<BlogsStatsUser> getGroupStatsUsers(
111                    long groupId, int start, int end,
112                    OrderByComparator<BlogsStatsUser> obc) {
113    
114                    return blogsStatsUserPersistence.findByG_NotE(
115                            groupId, 0, start, end, obc);
116            }
117    
118            @Override
119            public int getGroupStatsUsersCount(long groupId) {
120                    return blogsStatsUserPersistence.countByG_NotE(groupId, 0);
121            }
122    
123            @Override
124            public List<BlogsStatsUser> getOrganizationStatsUsers(
125                    long organizationId, int start, int end) {
126    
127                    return blogsStatsUserFinder.findByOrganizationId(
128                            organizationId, start, end, new StatsUserLastPostDateComparator());
129            }
130    
131            @Override
132            public List<BlogsStatsUser> getOrganizationStatsUsers(
133                    long organizationId, int start, int end,
134                    OrderByComparator<BlogsStatsUser> obc) {
135    
136                    return blogsStatsUserFinder.findByOrganizationId(
137                            organizationId, start, end, obc);
138            }
139    
140            @Override
141            public int getOrganizationStatsUsersCount(long organizationId) {
142                    return blogsStatsUserFinder.countByOrganizationId(organizationId);
143            }
144    
145            @Override
146            public BlogsStatsUser getStatsUser(long groupId, long userId)
147                    throws PortalException {
148    
149                    BlogsStatsUser statsUser = blogsStatsUserPersistence.fetchByG_U(
150                            groupId, userId);
151    
152                    if (statsUser == null) {
153                            Group group = groupPersistence.findByPrimaryKey(groupId);
154    
155                            long statsUserId = counterLocalService.increment();
156    
157                            statsUser = blogsStatsUserPersistence.create(statsUserId);
158    
159                            statsUser.setCompanyId(group.getCompanyId());
160                            statsUser.setGroupId(groupId);
161                            statsUser.setUserId(userId);
162    
163                            blogsStatsUserPersistence.update(statsUser);
164                    }
165    
166                    return statsUser;
167            }
168    
169            @Override
170            public void updateStatsUser(long groupId, long userId)
171                    throws PortalException {
172    
173                    updateStatsUser(groupId, userId, null);
174            }
175    
176            @Override
177            public void updateStatsUser(long groupId, long userId, Date displayDate)
178                    throws PortalException {
179    
180                    Date now = new Date();
181    
182                    int entryCount = blogsEntryPersistence.countByG_U_LtD_S(
183                            groupId, userId, now, WorkflowConstants.STATUS_APPROVED);
184    
185                    if (entryCount == 0) {
186                            try {
187                                    blogsStatsUserPersistence.removeByG_U(groupId, userId);
188                            }
189                            catch (NoSuchStatsUserException nssue) {
190                            }
191    
192                            return;
193                    }
194    
195                    BlogsStatsUser statsUser = getStatsUser(groupId, userId);
196    
197                    statsUser.setEntryCount(entryCount);
198    
199                    BlogsEntry blogsEntry = blogsEntryPersistence.findByG_U_LtD_S_First(
200                            groupId, userId, now, WorkflowConstants.STATUS_APPROVED,
201                            new EntryDisplayDateComparator());
202    
203                    Date lastDisplayDate = blogsEntry.getDisplayDate();
204    
205                    Date lastPostDate = statsUser.getLastPostDate();
206    
207                    if ((displayDate != null) && displayDate.before(now)) {
208                            if (lastPostDate == null) {
209                                    statsUser.setLastPostDate(displayDate);
210                            }
211                            else if (displayDate.after(lastPostDate)) {
212                                    statsUser.setLastPostDate(displayDate);
213                            }
214                            else if (lastDisplayDate.before(lastPostDate)) {
215                                    statsUser.setLastPostDate(lastDisplayDate);
216                            }
217                    }
218                    else if ((lastPostDate == null) ||
219                                     lastPostDate.before(lastDisplayDate)) {
220    
221                            statsUser.setLastPostDate(lastDisplayDate);
222                    }
223    
224                    blogsStatsUserPersistence.update(statsUser);
225            }
226    
227    }