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