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