1
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
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 }