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