1   /**
2    * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
3    *
4    * This library is free software; you can redistribute it and/or modify it under
5    * the terms of the GNU Lesser General Public License as published by the Free
6    * Software Foundation; either version 2.1 of the License, or (at your option)
7    * any later version.
8    *
9    * This library is distributed in the hope that it will be useful, but WITHOUT
10   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11   * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
12   * details.
13   */
14  
15  package com.liferay.portlet.announcements.service.persistence;
16  
17  import com.liferay.portal.kernel.dao.orm.QueryPos;
18  import com.liferay.portal.kernel.dao.orm.QueryUtil;
19  import com.liferay.portal.kernel.dao.orm.SQLQuery;
20  import com.liferay.portal.kernel.dao.orm.Session;
21  import com.liferay.portal.kernel.dao.orm.Type;
22  import com.liferay.portal.kernel.exception.PortalException;
23  import com.liferay.portal.kernel.exception.SystemException;
24  import com.liferay.portal.kernel.util.CalendarUtil;
25  import com.liferay.portal.kernel.util.StringBundler;
26  import com.liferay.portal.kernel.util.StringPool;
27  import com.liferay.portal.kernel.util.StringUtil;
28  import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
29  import com.liferay.portal.util.PortalUtil;
30  import com.liferay.portlet.announcements.model.AnnouncementsEntry;
31  import com.liferay.portlet.announcements.model.AnnouncementsFlagConstants;
32  import com.liferay.portlet.announcements.model.impl.AnnouncementsEntryImpl;
33  import com.liferay.util.dao.orm.CustomSQLUtil;
34  
35  import java.sql.Timestamp;
36  
37  import java.util.Date;
38  import java.util.Iterator;
39  import java.util.LinkedHashMap;
40  import java.util.List;
41  import java.util.Map;
42  
43  /**
44   * <a href="AnnouncementsEntryFinderImpl.java.html"><b><i>View Source</i></b>
45   * </a>
46   *
47   * @author Thiago Moreira
48   * @author Raymond Augé
49   */
50  public class AnnouncementsEntryFinderImpl
51      extends BasePersistenceImpl<AnnouncementsEntry>
52      implements AnnouncementsEntryFinder {
53  
54      public static String COUNT_BY_HIDDEN =
55          AnnouncementsEntryFinder.class.getName() + ".countByHidden";
56  
57      public static String COUNT_BY_NOT_HIDDEN =
58          AnnouncementsEntryFinder.class.getName() + ".countByNotHidden";
59  
60      public static String FIND_BY_DISPLAY_DATE =
61          AnnouncementsEntryFinder.class.getName() + ".findByDisplayDate";
62  
63      public static String FIND_BY_HIDDEN =
64          AnnouncementsEntryFinder.class.getName() + ".findByHidden";
65  
66      public static String FIND_BY_NOT_HIDDEN =
67          AnnouncementsEntryFinder.class.getName() + ".findByNotHidden";
68  
69      public int countByScope(
70              long userId, long classNameId, long[] classPKs,
71              int displayDateMonth, int displayDateDay, int displayDateYear,
72              int displayDateHour, int displayDateMinute, int expirationDateMonth,
73              int expirationDateDay, int expirationDateYear,
74              int expirationDateHour, int expirationDateMinute, boolean alert,
75              int flagValue)
76          throws SystemException {
77  
78          Session session = null;
79  
80          try {
81              session = openSession();
82  
83              String sql = CustomSQLUtil.get(COUNT_BY_HIDDEN);
84  
85              if (flagValue == AnnouncementsFlagConstants.NOT_HIDDEN) {
86                  sql = CustomSQLUtil.get(COUNT_BY_NOT_HIDDEN);
87              }
88  
89              sql = StringUtil.replace(
90                  sql, "[$CLASS_PKS$]", getClassPKs(classNameId, classPKs));
91              sql = CustomSQLUtil.replaceAndOperator(sql, true);
92  
93              SQLQuery q = session.createSQLQuery(sql);
94  
95              q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
96  
97              QueryPos qPos = QueryPos.getInstance(q);
98  
99              setClassPKs(qPos, classNameId, classPKs);
100 
101             setDates(
102                 qPos, displayDateMonth, displayDateDay, displayDateYear,
103                 displayDateHour, displayDateMinute, expirationDateMonth,
104                 expirationDateDay, expirationDateYear, expirationDateHour,
105                 expirationDateMinute);
106 
107             qPos.add(alert);
108             qPos.add(userId);
109             qPos.add(AnnouncementsFlagConstants.HIDDEN);
110 
111             Iterator<Long> itr = q.list().iterator();
112 
113             if (itr.hasNext()) {
114                 Long count = itr.next();
115 
116                 if (count != null) {
117                     return count.intValue();
118                 }
119             }
120 
121             return 0;
122         }
123         catch (Exception e) {
124             throw new SystemException(e);
125         }
126         finally {
127             closeSession(session);
128         }
129     }
130 
131     public int countByScopes(
132             long userId, LinkedHashMap<Long, long[]> scopes,
133             int displayDateMonth, int displayDateDay, int displayDateYear,
134             int displayDateHour, int displayDateMinute, int expirationDateMonth,
135             int expirationDateDay, int expirationDateYear,
136             int expirationDateHour, int expirationDateMinute, boolean alert,
137             int flagValue)
138         throws SystemException {
139 
140         Session session = null;
141 
142         try {
143             session = openSession();
144 
145             String sql = CustomSQLUtil.get(COUNT_BY_HIDDEN);
146 
147             if (flagValue == AnnouncementsFlagConstants.NOT_HIDDEN) {
148                 sql = CustomSQLUtil.get(COUNT_BY_NOT_HIDDEN);
149             }
150 
151             sql = StringUtil.replace(sql, "[$CLASS_PKS$]", getClassPKs(scopes));
152             sql = CustomSQLUtil.replaceAndOperator(sql, true);
153 
154             SQLQuery q = session.createSQLQuery(sql);
155 
156             q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
157 
158             QueryPos qPos = QueryPos.getInstance(q);
159 
160             setClassPKs(qPos, scopes);
161 
162             setDates(
163                 qPos, displayDateMonth, displayDateDay, displayDateYear,
164                 displayDateHour, displayDateMinute, expirationDateMonth,
165                 expirationDateDay, expirationDateYear, expirationDateHour,
166                 expirationDateMinute);
167 
168             qPos.add(alert);
169             qPos.add(userId);
170             qPos.add(AnnouncementsFlagConstants.HIDDEN);
171 
172             Iterator<Long> itr = q.list().iterator();
173 
174             if (itr.hasNext()) {
175                 Long count = itr.next();
176 
177                 if (count != null) {
178                     return count.intValue();
179                 }
180             }
181 
182             return 0;
183         }
184         catch (Exception e) {
185             throw new SystemException(e);
186         }
187         finally {
188             closeSession(session);
189         }
190     }
191 
192     public List<AnnouncementsEntry> findByDisplayDate(
193             Date displayDateLT, Date displayDateGT)
194         throws SystemException {
195 
196         Timestamp displayDateLT_TS = CalendarUtil.getTimestamp(displayDateLT);
197         Timestamp displayDateGT_TS = CalendarUtil.getTimestamp(displayDateGT);
198 
199         Session session = null;
200 
201         try {
202             session = openSession();
203 
204             String sql = CustomSQLUtil.get(FIND_BY_DISPLAY_DATE);
205 
206             SQLQuery q = session.createSQLQuery(sql);
207 
208             q.addEntity("AnnouncementsEntry", AnnouncementsEntryImpl.class);
209 
210             QueryPos qPos = QueryPos.getInstance(q);
211 
212             qPos.add(displayDateGT_TS);
213             qPos.add(displayDateLT_TS);
214 
215             return q.list();
216         }
217         catch (Exception e) {
218             throw new SystemException(e);
219         }
220         finally {
221             closeSession(session);
222         }
223     }
224 
225     public List<AnnouncementsEntry> findByScope(
226             long userId, long classNameId, long[] classPKs,
227             int displayDateMonth, int displayDateDay, int displayDateYear,
228             int displayDateHour, int displayDateMinute, int expirationDateMonth,
229             int expirationDateDay, int expirationDateYear,
230             int expirationDateHour, int expirationDateMinute, boolean alert,
231             int flagValue, int start, int end)
232         throws SystemException {
233 
234         Session session = null;
235 
236         try {
237             session = openSession();
238 
239             String sql = CustomSQLUtil.get(FIND_BY_HIDDEN);
240 
241             if (flagValue == AnnouncementsFlagConstants.NOT_HIDDEN) {
242                 sql = CustomSQLUtil.get(FIND_BY_NOT_HIDDEN);
243             }
244 
245             sql = StringUtil.replace(
246                 sql, "[$CLASS_PKS$]", getClassPKs(classNameId, classPKs));
247             sql = CustomSQLUtil.replaceAndOperator(sql, true);
248 
249             SQLQuery q = session.createSQLQuery(sql);
250 
251             q.addEntity("AnnouncementsEntry", AnnouncementsEntryImpl.class);
252 
253             QueryPos qPos = QueryPos.getInstance(q);
254 
255             setClassPKs(qPos, classNameId, classPKs);
256 
257             setDates(
258                 qPos, displayDateMonth, displayDateDay, displayDateYear,
259                 displayDateHour, displayDateMinute, expirationDateMonth,
260                 expirationDateDay, expirationDateYear, expirationDateHour,
261                 expirationDateMinute);
262 
263             qPos.add(alert);
264             qPos.add(userId);
265             qPos.add(AnnouncementsFlagConstants.HIDDEN);
266 
267             return (List<AnnouncementsEntry>)QueryUtil.list(
268                 q, getDialect(), start, end);
269         }
270         catch (Exception e) {
271             throw new SystemException(e);
272         }
273         finally {
274             closeSession(session);
275         }
276     }
277 
278     public List<AnnouncementsEntry> findByScopes(
279             long userId, LinkedHashMap<Long, long[]> scopes,
280             int displayDateMonth, int displayDateDay, int displayDateYear,
281             int displayDateHour, int displayDateMinute, int expirationDateMonth,
282             int expirationDateDay, int expirationDateYear,
283             int expirationDateHour, int expirationDateMinute, boolean alert,
284             int flagValue, int start, int end)
285         throws SystemException {
286 
287         Session session = null;
288 
289         try {
290             session = openSession();
291 
292             String sql = CustomSQLUtil.get(FIND_BY_HIDDEN);
293 
294             if (flagValue == AnnouncementsFlagConstants.NOT_HIDDEN) {
295                 sql = CustomSQLUtil.get(FIND_BY_NOT_HIDDEN);
296             }
297 
298             sql = StringUtil.replace(sql, "[$CLASS_PKS$]", getClassPKs(scopes));
299             sql = CustomSQLUtil.replaceAndOperator(sql, true);
300 
301             SQLQuery q = session.createSQLQuery(sql);
302 
303             q.addEntity("AnnouncementsEntry", AnnouncementsEntryImpl.class);
304 
305             QueryPos qPos = QueryPos.getInstance(q);
306 
307             setClassPKs(qPos, scopes);
308 
309             setDates(
310                 qPos, displayDateMonth, displayDateDay, displayDateYear,
311                 displayDateHour, displayDateMinute, expirationDateMonth,
312                 expirationDateDay, expirationDateYear, expirationDateHour,
313                 expirationDateMinute);
314 
315             qPos.add(alert);
316             qPos.add(userId);
317             qPos.add(AnnouncementsFlagConstants.HIDDEN);
318 
319             return (List<AnnouncementsEntry>)QueryUtil.list(
320                 q, getDialect(), start, end);
321         }
322         catch (Exception e) {
323             throw new SystemException(e);
324         }
325         finally {
326             closeSession(session);
327         }
328     }
329 
330     protected String getClassPKs(long classNameId, long[] classPKs) {
331         if (classPKs.length == 0) {
332             return "(AnnouncementsEntry.classNameId = ?) AND (";
333         }
334 
335         StringBundler sb = new StringBundler(classPKs.length * 2 + 1);
336 
337         sb.append("(AnnouncementsEntry.classNameId = ?) AND (");
338 
339         for (int i = 0; i < classPKs.length; i++) {
340             sb.append("(AnnouncementsEntry.classPK = ?)");
341 
342             if ((i + 1) < classPKs.length) {
343                 sb.append(" OR ");
344             }
345             else {
346                 sb.append(")");
347             }
348         }
349 
350         return sb.toString();
351     }
352 
353     protected String getClassPKs(LinkedHashMap<Long, long[]> scopes) {
354         if ((scopes == null) || scopes.isEmpty()) {
355             return StringPool.BLANK;
356         }
357 
358         StringBundler sb = new StringBundler(scopes.size() * 4 - 1);
359 
360         Iterator<Map.Entry<Long, long[]>> itr = scopes.entrySet().iterator();
361 
362         while (itr.hasNext()) {
363             Map.Entry<Long, long[]> entry = itr.next();
364 
365             Long classNameId = entry.getKey();
366             long[] classPKs = entry.getValue();
367 
368             sb.append("(");
369             sb.append(getClassPKs(classNameId.longValue(), classPKs));
370             sb.append(")");
371 
372             if (itr.hasNext()) {
373                 sb.append(" OR ");
374             }
375         }
376 
377         return sb.toString();
378     }
379 
380     protected void setClassPKs(
381         QueryPos qPos, long classNameId, long[] classPKs) {
382 
383         qPos.add(classNameId);
384 
385         for (int i = 0; i < classPKs.length; i++) {
386             qPos.add(classPKs[i]);
387         }
388     }
389 
390     protected void setClassPKs(
391         QueryPos qPos, LinkedHashMap<Long, long[]> scopes) {
392 
393         if (scopes == null) {
394             return;
395         }
396 
397         Iterator<Map.Entry<Long, long[]>> itr = scopes.entrySet().iterator();
398 
399         while (itr.hasNext()) {
400             Map.Entry<Long, long[]> entry = itr.next();
401 
402             Long classNameId = entry.getKey();
403             long[] classPKs = entry.getValue();
404 
405             setClassPKs(qPos, classNameId.longValue(), classPKs);
406         }
407     }
408 
409     protected void setDates(
410         QueryPos qPos, int displayDateMonth, int displayDateDay,
411         int displayDateYear, int displayDateHour, int displayDateMinute,
412         int expirationDateMonth, int expirationDateDay, int expirationDateYear,
413         int expirationDateHour, int expirationDateMinute) {
414 
415         Date displayDate = null;
416 
417         try {
418             displayDate = PortalUtil.getDate(
419                 displayDateMonth, displayDateDay, displayDateYear,
420                 displayDateHour, displayDateMinute, new PortalException());
421         }
422         catch (PortalException pe) {
423             displayDate = new Date();
424         }
425 
426         Timestamp displayDateTS = CalendarUtil.getTimestamp(displayDate);
427 
428         Date expirationDate = null;
429 
430         try {
431             expirationDate = PortalUtil.getDate(
432                 expirationDateMonth, expirationDateDay, expirationDateYear,
433                 expirationDateHour, expirationDateMinute,
434                 new PortalException());
435         }
436         catch (PortalException pe) {
437             expirationDate = new Date();
438         }
439 
440         Timestamp expirationDateTS = CalendarUtil.getTimestamp(expirationDate);
441 
442         qPos.add(displayDateTS);
443         qPos.add(displayDateTS);
444         qPos.add(expirationDateTS);
445         qPos.add(expirationDateTS);
446     }
447 
448 }