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.persistence.impl;
016    
017    import com.liferay.portal.kernel.dao.orm.QueryPos;
018    import com.liferay.portal.kernel.dao.orm.QueryUtil;
019    import com.liferay.portal.kernel.dao.orm.SQLQuery;
020    import com.liferay.portal.kernel.dao.orm.Session;
021    import com.liferay.portal.kernel.dao.orm.Type;
022    import com.liferay.portal.kernel.exception.SystemException;
023    import com.liferay.portal.kernel.util.OrderByComparator;
024    import com.liferay.portal.kernel.util.StringBundler;
025    import com.liferay.portal.kernel.util.StringPool;
026    import com.liferay.portal.kernel.util.StringUtil;
027    import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
028    import com.liferay.portlet.blogs.model.BlogsStatsUser;
029    import com.liferay.portlet.blogs.model.impl.BlogsStatsUserImpl;
030    import com.liferay.portlet.blogs.service.persistence.BlogsStatsUserFinder;
031    import com.liferay.portlet.blogs.service.persistence.BlogsStatsUserUtil;
032    import com.liferay.util.dao.orm.CustomSQLUtil;
033    
034    import java.util.ArrayList;
035    import java.util.Date;
036    import java.util.Iterator;
037    import java.util.List;
038    
039    /**
040     * @author Brian Wing Shun Chan
041     */
042    public class BlogsStatsUserFinderImpl
043            extends BasePersistenceImpl<BlogsStatsUser>
044            implements BlogsStatsUserFinder {
045    
046            public static final String COUNT_BY_ORGANIZATION_IDS =
047                    BlogsStatsUserFinder.class.getName() + ".countByOrganizationIds";
048    
049            public static final String FIND_BY_GROUP_IDS =
050                    BlogsStatsUserFinder.class.getName() + ".findByGroupIds";
051    
052            public static final String FIND_BY_ORGANIZATION_IDS =
053                    BlogsStatsUserFinder.class.getName() + ".findByOrganizationIds";
054    
055            @Override
056            public int countByOrganizationId(long organizationId) {
057                    List<Long> organizationIds = new ArrayList<Long>();
058    
059                    organizationIds.add(organizationId);
060    
061                    return countByOrganizationIds(organizationIds);
062            }
063    
064            @Override
065            public int countByOrganizationIds(List<Long> organizationIds) {
066                    Session session = null;
067    
068                    try {
069                            session = openSession();
070    
071                            String sql = CustomSQLUtil.get(COUNT_BY_ORGANIZATION_IDS);
072    
073                            sql = StringUtil.replace(
074                                    sql, "[$ORGANIZATION_ID$]",
075                                    getOrganizationIds(organizationIds));
076    
077                            SQLQuery q = session.createSynchronizedSQLQuery(sql);
078    
079                            q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
080    
081                            QueryPos qPos = QueryPos.getInstance(q);
082    
083                            for (int i = 0; i < organizationIds.size(); i++) {
084                                    Long organizationId = organizationIds.get(i);
085    
086                                    qPos.add(organizationId);
087                            }
088    
089                            Iterator<Long> itr = q.iterate();
090    
091                            if (itr.hasNext()) {
092                                    Long count = itr.next();
093    
094                                    if (count != null) {
095                                            return count.intValue();
096                                    }
097                            }
098    
099                            return 0;
100                    }
101                    catch (Exception e) {
102                            throw new SystemException(e);
103                    }
104                    finally {
105                            closeSession(session);
106                    }
107            }
108    
109            @Override
110            public List<BlogsStatsUser> findByGroupIds(
111                    long companyId, long groupId, int start, int end) {
112    
113                    Session session = null;
114    
115                    try {
116                            session = openSession();
117    
118                            String sql = CustomSQLUtil.get(FIND_BY_GROUP_IDS);
119    
120                            SQLQuery q = session.createSynchronizedSQLQuery(sql);
121    
122                            q.addScalar("userId", Type.LONG);
123                            q.addScalar("lastPostDate", Type.TIMESTAMP);
124    
125                            QueryPos qPos = QueryPos.getInstance(q);
126    
127                            qPos.add(companyId);
128                            qPos.add(groupId);
129                            qPos.add(groupId);
130                            qPos.add(groupId);
131    
132                            List<BlogsStatsUser> statsUsers = new ArrayList<BlogsStatsUser>();
133    
134                            Iterator<Object[]> itr = (Iterator<Object[]>)QueryUtil.iterate(
135                                    q, getDialect(), start, end);
136    
137                            while (itr.hasNext()) {
138                                    Object[] array = itr.next();
139    
140                                    long userId = (Long)array[0];
141                                    Date lastPostDate = (Date)array[1];
142    
143                                    List<BlogsStatsUser> curStatsUsers =
144                                            BlogsStatsUserUtil.findByU_L(userId, lastPostDate);
145    
146                                    if (!curStatsUsers.isEmpty()) {
147                                            BlogsStatsUser statsUser = curStatsUsers.get(0);
148    
149                                            statsUsers.add(statsUser);
150                                    }
151                            }
152    
153                            return statsUsers;
154                    }
155                    catch (Exception e) {
156                            throw new SystemException(e);
157                    }
158                    finally {
159                            closeSession(session);
160                    }
161            }
162    
163            @Override
164            public List<BlogsStatsUser> findByOrganizationId(
165                    long organizationId, int start, int end,
166                    OrderByComparator<BlogsStatsUser> obc) {
167    
168                    List<Long> organizationIds = new ArrayList<Long>();
169    
170                    organizationIds.add(organizationId);
171    
172                    return findByOrganizationIds(organizationIds, start, end, obc);
173            }
174    
175            @Override
176            public List<BlogsStatsUser> findByOrganizationIds(
177                    List<Long> organizationIds, int start, int end,
178                    OrderByComparator<BlogsStatsUser> obc) {
179    
180                    Session session = null;
181    
182                    try {
183                            session = openSession();
184    
185                            String sql = CustomSQLUtil.get(FIND_BY_ORGANIZATION_IDS);
186    
187                            sql = StringUtil.replace(
188                                    sql, "[$ORGANIZATION_ID$]",
189                                    getOrganizationIds(organizationIds));
190                            sql = CustomSQLUtil.replaceOrderBy(sql, obc);
191    
192                            SQLQuery q = session.createSynchronizedSQLQuery(sql);
193    
194                            q.addEntity("BlogsStatsUser", BlogsStatsUserImpl.class);
195    
196                            QueryPos qPos = QueryPos.getInstance(q);
197    
198                            for (int i = 0; i < organizationIds.size(); i++) {
199                                    Long organizationId = organizationIds.get(i);
200    
201                                    qPos.add(organizationId);
202                            }
203    
204                            return (List<BlogsStatsUser>)QueryUtil.list(
205                                    q, getDialect(), start, end);
206                    }
207                    catch (Exception e) {
208                            throw new SystemException(e);
209                    }
210                    finally {
211                            closeSession(session);
212                    }
213            }
214    
215            protected String getOrganizationIds(List<Long> organizationIds) {
216                    if (organizationIds.isEmpty()) {
217                            return StringPool.BLANK;
218                    }
219    
220                    StringBundler sb = new StringBundler(organizationIds.size() * 2 - 1);
221    
222                    for (int i = 0; i < organizationIds.size(); i++) {
223                            sb.append("Users_Orgs.organizationId = ? ");
224    
225                            if ((i + 1) != organizationIds.size()) {
226                                    sb.append("OR ");
227                            }
228                    }
229    
230                    return sb.toString();
231            }
232    
233    }