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