001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.announcements.service.persistence.impl;
016    
017    import com.liferay.portal.kernel.dao.orm.QueryPos;
018    import com.liferay.portal.kernel.dao.orm.QueryUtil;
019    import com.liferay.portal.kernel.dao.orm.SQLQuery;
020    import com.liferay.portal.kernel.dao.orm.Session;
021    import com.liferay.portal.kernel.dao.orm.Type;
022    import com.liferay.portal.kernel.exception.PortalException;
023    import com.liferay.portal.kernel.exception.SystemException;
024    import com.liferay.portal.kernel.util.CalendarUtil;
025    import com.liferay.portal.kernel.util.StringBundler;
026    import com.liferay.portal.kernel.util.StringPool;
027    import com.liferay.portal.kernel.util.StringUtil;
028    import com.liferay.portal.util.PortalUtil;
029    import com.liferay.portlet.announcements.model.AnnouncementsEntry;
030    import com.liferay.portlet.announcements.model.AnnouncementsFlagConstants;
031    import com.liferay.portlet.announcements.model.impl.AnnouncementsEntryImpl;
032    import com.liferay.portlet.announcements.service.persistence.AnnouncementsEntryFinder;
033    import com.liferay.util.dao.orm.CustomSQLUtil;
034    
035    import java.sql.Timestamp;
036    
037    import java.util.Date;
038    import java.util.Iterator;
039    import java.util.LinkedHashMap;
040    import java.util.List;
041    import java.util.Map;
042    
043    /**
044     * @author Thiago Moreira
045     * @author Raymond Aug??
046     */
047    public class AnnouncementsEntryFinderImpl
048            extends AnnouncementsEntryFinderBaseImpl
049            implements AnnouncementsEntryFinder {
050    
051            public static final String COUNT_BY_HIDDEN =
052                    AnnouncementsEntryFinder.class.getName() + ".countByHidden";
053    
054            public static final String COUNT_BY_NOT_HIDDEN =
055                    AnnouncementsEntryFinder.class.getName() + ".countByNotHidden";
056    
057            public static final String FIND_BY_DISPLAY_DATE =
058                    AnnouncementsEntryFinder.class.getName() + ".findByDisplayDate";
059    
060            public static final String FIND_BY_HIDDEN =
061                    AnnouncementsEntryFinder.class.getName() + ".findByHidden";
062    
063            public static final String FIND_BY_NOT_HIDDEN =
064                    AnnouncementsEntryFinder.class.getName() + ".findByNotHidden";
065    
066            @Override
067            public int countByScope(
068                    long userId, long classNameId, long[] classPKs, int displayDateMonth,
069                    int displayDateDay, int displayDateYear, int displayDateHour,
070                    int displayDateMinute, int expirationDateMonth, int expirationDateDay,
071                    int expirationDateYear, int expirationDateHour,
072                    int expirationDateMinute, boolean alert, int flagValue) {
073    
074                    Session session = null;
075    
076                    try {
077                            session = openSession();
078    
079                            String sql = CustomSQLUtil.get(COUNT_BY_HIDDEN);
080    
081                            if (flagValue == AnnouncementsFlagConstants.NOT_HIDDEN) {
082                                    sql = CustomSQLUtil.get(COUNT_BY_NOT_HIDDEN);
083                            }
084    
085                            sql = StringUtil.replace(
086                                    sql, "[$CLASS_PKS$]", getClassPKs(classNameId, classPKs));
087                            sql = CustomSQLUtil.replaceAndOperator(sql, true);
088    
089                            SQLQuery q = session.createSynchronizedSQLQuery(sql);
090    
091                            q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
092    
093                            QueryPos qPos = QueryPos.getInstance(q);
094    
095                            setClassPKs(qPos, classNameId, classPKs);
096    
097                            setDates(
098                                    qPos, displayDateMonth, displayDateDay, displayDateYear,
099                                    displayDateHour, displayDateMinute, expirationDateMonth,
100                                    expirationDateDay, expirationDateYear, expirationDateHour,
101                                    expirationDateMinute);
102    
103                            qPos.add(alert);
104                            qPos.add(userId);
105                            qPos.add(AnnouncementsFlagConstants.HIDDEN);
106    
107                            Iterator<Long> itr = q.iterate();
108    
109                            if (itr.hasNext()) {
110                                    Long count = itr.next();
111    
112                                    if (count != null) {
113                                            return count.intValue();
114                                    }
115                            }
116    
117                            return 0;
118                    }
119                    catch (Exception e) {
120                            throw new SystemException(e);
121                    }
122                    finally {
123                            closeSession(session);
124                    }
125            }
126    
127            @Override
128            public int countByScopes(
129                    long userId, LinkedHashMap<Long, long[]> scopes, int displayDateMonth,
130                    int displayDateDay, int displayDateYear, int displayDateHour,
131                    int displayDateMinute, int expirationDateMonth, int expirationDateDay,
132                    int expirationDateYear, int expirationDateHour,
133                    int expirationDateMinute, boolean alert, int flagValue) {
134    
135                    Session session = null;
136    
137                    try {
138                            session = openSession();
139    
140                            String sql = CustomSQLUtil.get(COUNT_BY_HIDDEN);
141    
142                            if (flagValue == AnnouncementsFlagConstants.NOT_HIDDEN) {
143                                    sql = CustomSQLUtil.get(COUNT_BY_NOT_HIDDEN);
144                            }
145    
146                            sql = StringUtil.replace(sql, "[$CLASS_PKS$]", getClassPKs(scopes));
147                            sql = CustomSQLUtil.replaceAndOperator(sql, true);
148    
149                            SQLQuery q = session.createSynchronizedSQLQuery(sql);
150    
151                            q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
152    
153                            QueryPos qPos = QueryPos.getInstance(q);
154    
155                            setClassPKs(qPos, scopes);
156    
157                            setDates(
158                                    qPos, displayDateMonth, displayDateDay, displayDateYear,
159                                    displayDateHour, displayDateMinute, expirationDateMonth,
160                                    expirationDateDay, expirationDateYear, expirationDateHour,
161                                    expirationDateMinute);
162    
163                            qPos.add(alert);
164                            qPos.add(userId);
165                            qPos.add(AnnouncementsFlagConstants.HIDDEN);
166    
167                            Iterator<Long> itr = q.iterate();
168    
169                            if (itr.hasNext()) {
170                                    Long count = itr.next();
171    
172                                    if (count != null) {
173                                            return count.intValue();
174                                    }
175                            }
176    
177                            return 0;
178                    }
179                    catch (Exception e) {
180                            throw new SystemException(e);
181                    }
182                    finally {
183                            closeSession(session);
184                    }
185            }
186    
187            @Override
188            public List<AnnouncementsEntry> findByDisplayDate(
189                    Date displayDateLT, Date displayDateGT) {
190    
191                    Timestamp displayDateLT_TS = CalendarUtil.getTimestamp(displayDateLT);
192                    Timestamp displayDateGT_TS = CalendarUtil.getTimestamp(displayDateGT);
193    
194                    Session session = null;
195    
196                    try {
197                            session = openSession();
198    
199                            String sql = CustomSQLUtil.get(FIND_BY_DISPLAY_DATE);
200    
201                            SQLQuery q = session.createSynchronizedSQLQuery(sql);
202    
203                            q.addEntity("AnnouncementsEntry", AnnouncementsEntryImpl.class);
204    
205                            QueryPos qPos = QueryPos.getInstance(q);
206    
207                            qPos.add(displayDateGT_TS);
208                            qPos.add(displayDateLT_TS);
209    
210                            return q.list(true);
211                    }
212                    catch (Exception e) {
213                            throw new SystemException(e);
214                    }
215                    finally {
216                            closeSession(session);
217                    }
218            }
219    
220            @Override
221            public List<AnnouncementsEntry> findByScope(
222                    long userId, long classNameId, long[] classPKs, int displayDateMonth,
223                    int displayDateDay, int displayDateYear, int displayDateHour,
224                    int displayDateMinute, int expirationDateMonth, int expirationDateDay,
225                    int expirationDateYear, int expirationDateHour,
226                    int expirationDateMinute, boolean alert, int flagValue, int start,
227                    int end) {
228    
229                    Session session = null;
230    
231                    try {
232                            session = openSession();
233    
234                            String sql = CustomSQLUtil.get(FIND_BY_HIDDEN);
235    
236                            if (flagValue == AnnouncementsFlagConstants.NOT_HIDDEN) {
237                                    sql = CustomSQLUtil.get(FIND_BY_NOT_HIDDEN);
238                            }
239    
240                            sql = StringUtil.replace(
241                                    sql, "[$CLASS_PKS$]", getClassPKs(classNameId, classPKs));
242                            sql = CustomSQLUtil.replaceAndOperator(sql, true);
243    
244                            SQLQuery q = session.createSynchronizedSQLQuery(sql);
245    
246                            q.addEntity("AnnouncementsEntry", AnnouncementsEntryImpl.class);
247    
248                            QueryPos qPos = QueryPos.getInstance(q);
249    
250                            setClassPKs(qPos, classNameId, classPKs);
251    
252                            setDates(
253                                    qPos, displayDateMonth, displayDateDay, displayDateYear,
254                                    displayDateHour, displayDateMinute, expirationDateMonth,
255                                    expirationDateDay, expirationDateYear, expirationDateHour,
256                                    expirationDateMinute);
257    
258                            qPos.add(alert);
259                            qPos.add(userId);
260                            qPos.add(AnnouncementsFlagConstants.HIDDEN);
261    
262                            return (List<AnnouncementsEntry>)QueryUtil.list(
263                                    q, getDialect(), start, end);
264                    }
265                    catch (Exception e) {
266                            throw new SystemException(e);
267                    }
268                    finally {
269                            closeSession(session);
270                    }
271            }
272    
273            @Override
274            public List<AnnouncementsEntry> findByScopes(
275                    long userId, LinkedHashMap<Long, long[]> scopes, int displayDateMonth,
276                    int displayDateDay, int displayDateYear, int displayDateHour,
277                    int displayDateMinute, int expirationDateMonth, int expirationDateDay,
278                    int expirationDateYear, int expirationDateHour,
279                    int expirationDateMinute, boolean alert, int flagValue, int start,
280                    int end) {
281    
282                    Session session = null;
283    
284                    try {
285                            session = openSession();
286    
287                            String sql = CustomSQLUtil.get(FIND_BY_HIDDEN);
288    
289                            if (flagValue == AnnouncementsFlagConstants.NOT_HIDDEN) {
290                                    sql = CustomSQLUtil.get(FIND_BY_NOT_HIDDEN);
291                            }
292    
293                            sql = StringUtil.replace(sql, "[$CLASS_PKS$]", getClassPKs(scopes));
294                            sql = CustomSQLUtil.replaceAndOperator(sql, true);
295    
296                            SQLQuery q = session.createSynchronizedSQLQuery(sql);
297    
298                            q.addEntity("AnnouncementsEntry", AnnouncementsEntryImpl.class);
299    
300                            QueryPos qPos = QueryPos.getInstance(q);
301    
302                            setClassPKs(qPos, scopes);
303    
304                            setDates(
305                                    qPos, displayDateMonth, displayDateDay, displayDateYear,
306                                    displayDateHour, displayDateMinute, expirationDateMonth,
307                                    expirationDateDay, expirationDateYear, expirationDateHour,
308                                    expirationDateMinute);
309    
310                            qPos.add(alert);
311                            qPos.add(userId);
312                            qPos.add(AnnouncementsFlagConstants.HIDDEN);
313    
314                            return (List<AnnouncementsEntry>)QueryUtil.list(
315                                    q, getDialect(), start, end);
316                    }
317                    catch (Exception e) {
318                            throw new SystemException(e);
319                    }
320                    finally {
321                            closeSession(session);
322                    }
323            }
324    
325            protected String getClassPKs(LinkedHashMap<Long, long[]> scopes) {
326                    if ((scopes == null) || scopes.isEmpty()) {
327                            return StringPool.BLANK;
328                    }
329    
330                    StringBundler sb = new StringBundler(scopes.size() * 4);
331    
332                    for (Map.Entry<Long, long[]> entry : scopes.entrySet()) {
333                            Long classNameId = entry.getKey();
334                            long[] classPKs = entry.getValue();
335    
336                            sb.append(StringPool.OPEN_PARENTHESIS);
337                            sb.append(getClassPKs(classNameId.longValue(), classPKs));
338                            sb.append(StringPool.CLOSE_PARENTHESIS);
339                            sb.append(" OR ");
340                    }
341    
342                    sb.setIndex(sb.index() - 1);
343    
344                    return sb.toString();
345            }
346    
347            protected String getClassPKs(long classNameId, long[] classPKs) {
348                    if (classPKs.length == 0) {
349                            return "(AnnouncementsEntry.classNameId = ?) AND (";
350                    }
351    
352                    StringBundler sb = new StringBundler(classPKs.length * 2 + 1);
353    
354                    sb.append("(AnnouncementsEntry.classNameId = ?) AND (");
355    
356                    for (int i = 0; i < classPKs.length; i++) {
357                            sb.append("(AnnouncementsEntry.classPK = ?)");
358    
359                            if ((i + 1) < classPKs.length) {
360                                    sb.append(" OR ");
361                            }
362                            else {
363                                    sb.append(StringPool.CLOSE_PARENTHESIS);
364                            }
365                    }
366    
367                    return sb.toString();
368            }
369    
370            protected void setClassPKs(
371                    QueryPos qPos, LinkedHashMap<Long, long[]> scopes) {
372    
373                    if (scopes == null) {
374                            return;
375                    }
376    
377                    for (Map.Entry<Long, long[]> entry : scopes.entrySet()) {
378                            Long classNameId = entry.getKey();
379                            long[] classPKs = entry.getValue();
380    
381                            setClassPKs(qPos, classNameId.longValue(), classPKs);
382                    }
383            }
384    
385            protected void setClassPKs(
386                    QueryPos qPos, long classNameId, long[] classPKs) {
387    
388                    qPos.add(classNameId);
389    
390                    for (int i = 0; i < classPKs.length; i++) {
391                            qPos.add(classPKs[i]);
392                    }
393            }
394    
395            protected void setDates(
396                    QueryPos qPos, int displayDateMonth, int displayDateDay,
397                    int displayDateYear, int displayDateHour, int displayDateMinute,
398                    int expirationDateMonth, int expirationDateDay, int expirationDateYear,
399                    int expirationDateHour, int expirationDateMinute) {
400    
401                    Date displayDate = null;
402    
403                    try {
404                            displayDate = PortalUtil.getDate(
405                                    displayDateMonth, displayDateDay, displayDateYear,
406                                    displayDateHour, displayDateMinute, null);
407                    }
408                    catch (PortalException pe) {
409                    }
410    
411                    if (displayDate == null) {
412                            displayDate = new Date();
413                    }
414    
415                    Timestamp displayDateTS = CalendarUtil.getTimestamp(displayDate);
416    
417                    Date expirationDate = null;
418    
419                    try {
420                            expirationDate = PortalUtil.getDate(
421                                    expirationDateMonth, expirationDateDay, expirationDateYear,
422                                    expirationDateHour, expirationDateMinute, null);
423                    }
424                    catch (PortalException pe) {
425                    }
426    
427                    if (expirationDate == null) {
428                            expirationDate = new Date();
429                    }
430    
431                    Timestamp expirationDateTS = CalendarUtil.getTimestamp(expirationDate);
432    
433                    qPos.add(displayDateTS);
434                    qPos.add(displayDateTS);
435                    qPos.add(expirationDateTS);
436                    qPos.add(expirationDateTS);
437            }
438    
439    }