1   /**
2    * Copyright (c) 2000-2009 Liferay, Inc. All rights reserved.
3    *
4    * The contents of this file are subject to the terms of the Liferay Enterprise
5    * Subscription License ("License"). You may not use this file except in
6    * compliance with the License. You can obtain a copy of the License by
7    * contacting Liferay, Inc. See the License for the specific language governing
8    * permissions and limitations under the License, including but not limited to
9    * distribution rights of the Software.
10   *
11   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
12   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
13   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
14   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
15   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
16   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
17   * SOFTWARE.
18   */
19  
20  package com.liferay.portlet.announcements.service.persistence;
21  
22  import com.liferay.portal.PortalException;
23  import com.liferay.portal.SystemException;
24  import com.liferay.portal.kernel.dao.orm.QueryPos;
25  import com.liferay.portal.kernel.dao.orm.QueryUtil;
26  import com.liferay.portal.kernel.dao.orm.SQLQuery;
27  import com.liferay.portal.kernel.dao.orm.Session;
28  import com.liferay.portal.kernel.dao.orm.Type;
29  import com.liferay.portal.kernel.util.CalendarUtil;
30  import com.liferay.portal.kernel.util.StringPool;
31  import com.liferay.portal.kernel.util.StringUtil;
32  import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
33  import com.liferay.portal.util.PortalUtil;
34  import com.liferay.portlet.announcements.model.AnnouncementsEntry;
35  import com.liferay.portlet.announcements.model.impl.AnnouncementsEntryImpl;
36  import com.liferay.portlet.announcements.model.impl.AnnouncementsFlagImpl;
37  import com.liferay.util.dao.orm.CustomSQLUtil;
38  
39  import java.sql.Timestamp;
40  
41  import java.util.Date;
42  import java.util.Iterator;
43  import java.util.LinkedHashMap;
44  import java.util.List;
45  import java.util.Map;
46  
47  /**
48   * <a href="AnnouncementsEntryFinderImpl.java.html"><b><i>View Source</i></b>
49   * </a>
50   *
51   * @author Thiago Moreira
52   * @author Raymond Augé
53   *
54   */
55  public class AnnouncementsEntryFinderImpl
56      extends BasePersistenceImpl implements AnnouncementsEntryFinder {
57  
58      public static String COUNT_BY_HIDDEN =
59          AnnouncementsEntryFinder.class.getName() + ".countByHidden";
60  
61      public static String COUNT_BY_NOT_HIDDEN =
62          AnnouncementsEntryFinder.class.getName() + ".countByNotHidden";
63  
64      public static String FIND_BY_DISPLAY_DATE =
65          AnnouncementsEntryFinder.class.getName() + ".findByDisplayDate";
66  
67      public static String FIND_BY_HIDDEN =
68          AnnouncementsEntryFinder.class.getName() + ".findByHidden";
69  
70      public static String FIND_BY_NOT_HIDDEN =
71          AnnouncementsEntryFinder.class.getName() + ".findByNotHidden";
72  
73      public int countByScope(
74              long userId, long classNameId, long[] classPKs,
75              int displayDateMonth, int displayDateDay, int displayDateYear,
76              int displayDateHour, int displayDateMinute, int expirationDateMonth,
77              int expirationDateDay, int expirationDateYear,
78              int expirationDateHour, int expirationDateMinute, boolean alert,
79              int flagValue)
80          throws SystemException {
81  
82          Session session = null;
83  
84          try {
85              session = openSession();
86  
87              String sql = CustomSQLUtil.get(COUNT_BY_HIDDEN);
88  
89              if (flagValue == AnnouncementsFlagImpl.NOT_HIDDEN) {
90                  sql = CustomSQLUtil.get(COUNT_BY_NOT_HIDDEN);
91              }
92  
93              sql = StringUtil.replace(
94                  sql, "[$CLASS_PKS$]", getClassPKs(classNameId, classPKs));
95              sql = CustomSQLUtil.replaceAndOperator(sql, true);
96  
97              SQLQuery q = session.createSQLQuery(sql);
98  
99              q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
100 
101             QueryPos qPos = QueryPos.getInstance(q);
102 
103             setClassPKs(qPos, classNameId, classPKs);
104 
105             setDates(
106                 qPos, displayDateMonth, displayDateDay, displayDateYear,
107                 displayDateHour, displayDateMinute, expirationDateMonth,
108                 expirationDateDay, expirationDateYear, expirationDateHour,
109                 expirationDateMinute);
110 
111             qPos.add(alert);
112             qPos.add(userId);
113             qPos.add(AnnouncementsFlagImpl.HIDDEN);
114 
115             Iterator<Long> itr = q.list().iterator();
116 
117             if (itr.hasNext()) {
118                 Long count = itr.next();
119 
120                 if (count != null) {
121                     return count.intValue();
122                 }
123             }
124 
125             return 0;
126         }
127         catch (Exception e) {
128             throw new SystemException(e);
129         }
130         finally {
131             closeSession(session);
132         }
133     }
134 
135     public int countByScopes(
136             long userId, LinkedHashMap<Long, long[]> scopes,
137             int displayDateMonth, int displayDateDay, int displayDateYear,
138             int displayDateHour, int displayDateMinute, int expirationDateMonth,
139             int expirationDateDay, int expirationDateYear,
140             int expirationDateHour, int expirationDateMinute, boolean alert,
141             int flagValue)
142         throws SystemException {
143 
144         Session session = null;
145 
146         try {
147             session = openSession();
148 
149             String sql = CustomSQLUtil.get(COUNT_BY_HIDDEN);
150 
151             if (flagValue == AnnouncementsFlagImpl.NOT_HIDDEN) {
152                 sql = CustomSQLUtil.get(COUNT_BY_NOT_HIDDEN);
153             }
154 
155             sql = StringUtil.replace(sql, "[$CLASS_PKS$]", getClassPKs(scopes));
156             sql = CustomSQLUtil.replaceAndOperator(sql, true);
157 
158             SQLQuery q = session.createSQLQuery(sql);
159 
160             q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
161 
162             QueryPos qPos = QueryPos.getInstance(q);
163 
164             setClassPKs(qPos, scopes);
165 
166             setDates(
167                 qPos, displayDateMonth, displayDateDay, displayDateYear,
168                 displayDateHour, displayDateMinute, expirationDateMonth,
169                 expirationDateDay, expirationDateYear, expirationDateHour,
170                 expirationDateMinute);
171 
172             qPos.add(alert);
173             qPos.add(userId);
174             qPos.add(AnnouncementsFlagImpl.HIDDEN);
175 
176             Iterator<Long> itr = q.list().iterator();
177 
178             if (itr.hasNext()) {
179                 Long count = itr.next();
180 
181                 if (count != null) {
182                     return count.intValue();
183                 }
184             }
185 
186             return 0;
187         }
188         catch (Exception e) {
189             throw new SystemException(e);
190         }
191         finally {
192             closeSession(session);
193         }
194     }
195 
196     public List<AnnouncementsEntry> findByDisplayDate(
197             Date displayDateLT, Date displayDateGT)
198         throws SystemException {
199 
200         Timestamp displayDateLT_TS = CalendarUtil.getTimestamp(displayDateLT);
201         Timestamp displayDateGT_TS = CalendarUtil.getTimestamp(displayDateGT);
202 
203         Session session = null;
204 
205         try {
206             session = openSession();
207 
208             String sql = CustomSQLUtil.get(FIND_BY_DISPLAY_DATE);
209 
210             SQLQuery q = session.createSQLQuery(sql);
211 
212             q.addEntity("AnnouncementsEntry", AnnouncementsEntryImpl.class);
213 
214             QueryPos qPos = QueryPos.getInstance(q);
215 
216             qPos.add(displayDateGT_TS);
217             qPos.add(displayDateLT_TS);
218 
219             return q.list();
220         }
221         catch (Exception e) {
222             throw new SystemException(e);
223         }
224         finally {
225             closeSession(session);
226         }
227     }
228 
229     public List<AnnouncementsEntry> findByScope(
230             long userId, long classNameId, long[] classPKs,
231             int displayDateMonth, int displayDateDay, int displayDateYear,
232             int displayDateHour, int displayDateMinute, int expirationDateMonth,
233             int expirationDateDay, int expirationDateYear,
234             int expirationDateHour, int expirationDateMinute, boolean alert,
235             int flagValue, int start, int end)
236         throws SystemException {
237 
238         Session session = null;
239 
240         try {
241             session = openSession();
242 
243             String sql = CustomSQLUtil.get(FIND_BY_HIDDEN);
244 
245             if (flagValue == AnnouncementsFlagImpl.NOT_HIDDEN) {
246                 sql = CustomSQLUtil.get(FIND_BY_NOT_HIDDEN);
247             }
248 
249             sql = StringUtil.replace(
250                 sql, "[$CLASS_PKS$]", getClassPKs(classNameId, classPKs));
251             sql = CustomSQLUtil.replaceAndOperator(sql, true);
252 
253             SQLQuery q = session.createSQLQuery(sql);
254 
255             q.addEntity("AnnouncementsEntry", AnnouncementsEntryImpl.class);
256 
257             QueryPos qPos = QueryPos.getInstance(q);
258 
259             setClassPKs(qPos, classNameId, classPKs);
260 
261             setDates(
262                 qPos, displayDateMonth, displayDateDay, displayDateYear,
263                 displayDateHour, displayDateMinute, expirationDateMonth,
264                 expirationDateDay, expirationDateYear, expirationDateHour,
265                 expirationDateMinute);
266 
267             qPos.add(alert);
268             qPos.add(userId);
269             qPos.add(AnnouncementsFlagImpl.HIDDEN);
270 
271             return (List<AnnouncementsEntry>)QueryUtil.list(
272                 q, getDialect(), start, end);
273         }
274         catch (Exception e) {
275             throw new SystemException(e);
276         }
277         finally {
278             closeSession(session);
279         }
280     }
281 
282     public List<AnnouncementsEntry> findByScopes(
283             long userId, LinkedHashMap<Long, long[]> scopes,
284             int displayDateMonth, int displayDateDay, int displayDateYear,
285             int displayDateHour, int displayDateMinute, int expirationDateMonth,
286             int expirationDateDay, int expirationDateYear,
287             int expirationDateHour, int expirationDateMinute, boolean alert,
288             int flagValue, int start, int end)
289         throws SystemException {
290 
291         Session session = null;
292 
293         try {
294             session = openSession();
295 
296             String sql = CustomSQLUtil.get(FIND_BY_HIDDEN);
297 
298             if (flagValue == AnnouncementsFlagImpl.NOT_HIDDEN) {
299                 sql = CustomSQLUtil.get(FIND_BY_NOT_HIDDEN);
300             }
301 
302             sql = StringUtil.replace(sql, "[$CLASS_PKS$]", getClassPKs(scopes));
303             sql = CustomSQLUtil.replaceAndOperator(sql, true);
304 
305             SQLQuery q = session.createSQLQuery(sql);
306 
307             q.addEntity("AnnouncementsEntry", AnnouncementsEntryImpl.class);
308 
309             QueryPos qPos = QueryPos.getInstance(q);
310 
311             setClassPKs(qPos, scopes);
312 
313             setDates(
314                 qPos, displayDateMonth, displayDateDay, displayDateYear,
315                 displayDateHour, displayDateMinute, expirationDateMonth,
316                 expirationDateDay, expirationDateYear, expirationDateHour,
317                 expirationDateMinute);
318 
319             qPos.add(alert);
320             qPos.add(userId);
321             qPos.add(AnnouncementsFlagImpl.HIDDEN);
322 
323             return (List<AnnouncementsEntry>)QueryUtil.list(
324                 q, getDialect(), start, end);
325         }
326         catch (Exception e) {
327             throw new SystemException(e);
328         }
329         finally {
330             closeSession(session);
331         }
332     }
333 
334     protected String getClassPKs(long classNameId, long[] classPKs) {
335         StringBuilder sb = new StringBuilder();
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) {
355             return StringPool.BLANK;
356         }
357 
358         StringBuilder sb = new StringBuilder();
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 }