001    /**
002     * Copyright (c) 2000-2012 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.journal.service.persistence;
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.SystemException;
023    import com.liferay.portal.kernel.util.CalendarUtil;
024    import com.liferay.portal.kernel.util.OrderByComparator;
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.kernel.util.Validator;
029    import com.liferay.portal.kernel.workflow.WorkflowConstants;
030    import com.liferay.portal.security.permission.InlineSQLHelperUtil;
031    import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
032    import com.liferay.portlet.journal.NoSuchArticleException;
033    import com.liferay.portlet.journal.model.JournalArticle;
034    import com.liferay.portlet.journal.model.impl.JournalArticleImpl;
035    import com.liferay.util.dao.orm.CustomSQLUtil;
036    
037    import java.sql.Timestamp;
038    
039    import java.util.Date;
040    import java.util.Iterator;
041    import java.util.List;
042    
043    /**
044     * @author Brian Wing Shun Chan
045     * @author Raymond Augé
046     * @author Connor McKay
047     */
048    public class JournalArticleFinderImpl
049            extends BasePersistenceImpl<JournalArticle>
050            implements JournalArticleFinder {
051    
052            public static final String COUNT_BY_C_G_C_A_V_T_D_C_T_S_T_D_S_R =
053                    JournalArticleFinder.class.getName() +
054                            ".countByC_G_C_A_V_T_D_C_T_S_T_D_S_R";
055    
056            public static final String FIND_BY_EXPIRATION_DATE =
057                    JournalArticleFinder.class.getName() + ".findByExpirationDate";
058    
059            public static final String FIND_BY_REVIEW_DATE =
060                    JournalArticleFinder.class.getName() + ".findByReviewDate";
061    
062            public static final String FIND_BY_R_D =
063                    JournalArticleFinder.class.getName() + ".findByR_D";
064    
065            public static final String FIND_BY_C_G_C_A_V_T_D_C_T_S_T_D_S_R =
066                    JournalArticleFinder.class.getName() +
067                            ".findByC_G_C_A_V_T_D_C_T_S_T_D_S_R";
068    
069            public int countByKeywords(
070                            long companyId, long groupId, long classNameId, String keywords,
071                            Double version, String type, String structureId, String templateId,
072                            Date displayDateGT, Date displayDateLT, int status, Date reviewDate)
073                    throws SystemException {
074    
075                    String[] articleIds = null;
076                    String[] titles = null;
077                    String[] descriptions = null;
078                    String[] contents = null;
079                    String[] structureIds = CustomSQLUtil.keywords(structureId, false);
080                    String[] templateIds = CustomSQLUtil.keywords(templateId, false);
081                    boolean andOperator = false;
082    
083                    if (Validator.isNotNull(keywords)) {
084                            articleIds = CustomSQLUtil.keywords(keywords, false);
085                            titles = CustomSQLUtil.keywords(keywords);
086                            descriptions = CustomSQLUtil.keywords(keywords, false);
087                            contents = CustomSQLUtil.keywords(keywords, false);
088                    }
089                    else {
090                            andOperator = true;
091                    }
092    
093                    return doCountByC_G_C_A_V_T_D_C_T_S_T_D_S_R(
094                            companyId, groupId, classNameId, articleIds, version, titles,
095                            descriptions, contents, type, structureIds, templateIds,
096                            displayDateGT, displayDateLT, status, reviewDate, andOperator,
097                            false);
098            }
099    
100            public int countByC_G_C_A_V_T_D_C_T_S_T_D_S_R(
101                            long companyId, long groupId, long classNameId, String articleId,
102                            Double version, String title, String description, String content,
103                            String type, String structureId, String templateId,
104                            Date displayDateGT, Date displayDateLT, int status, Date reviewDate,
105                            boolean andOperator)
106                    throws SystemException {
107    
108                    String[] structureIds = CustomSQLUtil.keywords(structureId, false);
109                    String[] templateIds = CustomSQLUtil.keywords(templateId, false);
110    
111                    return countByC_G_C_A_V_T_D_C_T_S_T_D_S_R(
112                            companyId, groupId, classNameId, articleId, version, title,
113                            description, content, type, structureIds, templateIds,
114                            displayDateGT, displayDateLT, status, reviewDate, andOperator);
115            }
116    
117            public int countByC_G_C_A_V_T_D_C_T_S_T_D_S_R(
118                            long companyId, long groupId, long classNameId, String articleId,
119                            Double version, String title, String description, String content,
120                            String type, String[] structureIds, String[] templateIds,
121                            Date displayDateGT, Date displayDateLT, int status, Date reviewDate,
122                            boolean andOperator)
123                    throws SystemException {
124    
125                    String[] articleIds = CustomSQLUtil.keywords(articleId, false);
126                    String[] titles = CustomSQLUtil.keywords(title);
127                    String[] descriptions = CustomSQLUtil.keywords(description, false);
128                    String[] contents = CustomSQLUtil.keywords(content, false);
129    
130                    return countByC_G_C_A_V_T_D_C_T_S_T_D_S_R(
131                            companyId, groupId, classNameId, articleIds, version, titles,
132                            descriptions, contents, type, structureIds, templateIds,
133                            displayDateGT, displayDateLT, status, reviewDate, andOperator);
134            }
135    
136            public int countByC_G_C_A_V_T_D_C_T_S_T_D_S_R(
137                            long companyId, long groupId, long classNameId, String[] articleIds,
138                            Double version, String[] titles, String[] descriptions,
139                            String[] contents, String type, String[] structureIds,
140                            String[] templateIds, Date displayDateGT, Date displayDateLT,
141                            int status, Date reviewDate, boolean andOperator)
142                    throws SystemException {
143    
144                    return doCountByC_G_C_A_V_T_D_C_T_S_T_D_S_R(
145                            companyId, groupId, classNameId, articleIds, version, titles,
146                            descriptions, contents, type, structureIds, templateIds,
147                            displayDateGT, displayDateLT, status, reviewDate, andOperator,
148                            false);
149            }
150    
151            public int filterCountByKeywords(
152                            long companyId, long groupId, long classNameId, String keywords,
153                            Double version, String type, String structureId, String templateId,
154                            Date displayDateGT, Date displayDateLT, int status, Date reviewDate)
155                    throws SystemException {
156    
157                    String[] articleIds = null;
158                    String[] titles = null;
159                    String[] descriptions = null;
160                    String[] contents = null;
161                    String[] structureIds = CustomSQLUtil.keywords(structureId, false);
162                    String[] templateIds = CustomSQLUtil.keywords(templateId, false);
163                    boolean andOperator = false;
164    
165                    if (Validator.isNotNull(keywords)) {
166                            articleIds = CustomSQLUtil.keywords(keywords, false);
167                            titles = CustomSQLUtil.keywords(keywords);
168                            descriptions = CustomSQLUtil.keywords(keywords, false);
169                            contents = CustomSQLUtil.keywords(keywords, false);
170                    }
171                    else {
172                            andOperator = true;
173                    }
174    
175                    return doCountByC_G_C_A_V_T_D_C_T_S_T_D_S_R(
176                            companyId, groupId, classNameId, articleIds, version, titles,
177                            descriptions, contents, type, structureIds, templateIds,
178                            displayDateGT, displayDateLT, status, reviewDate, andOperator,
179                            true);
180            }
181    
182            public int filterCountByC_G_C_A_V_T_D_C_T_S_T_D_S_R(
183                            long companyId, long groupId, long classNameId, String articleId,
184                            Double version, String title, String description, String content,
185                            String type, String structureId, String templateId,
186                            Date displayDateGT, Date displayDateLT, int status, Date reviewDate,
187                            boolean andOperator)
188                    throws SystemException {
189    
190                    String[] structureIds = CustomSQLUtil.keywords(structureId, false);
191                    String[] templateIds = CustomSQLUtil.keywords(templateId, false);
192    
193                    return filterCountByC_G_C_A_V_T_D_C_T_S_T_D_S_R(
194                            companyId, groupId, classNameId, articleId, version, title,
195                            description, content, type, structureIds, templateIds,
196                            displayDateGT, displayDateLT, status, reviewDate, andOperator);
197            }
198    
199            public int filterCountByC_G_C_A_V_T_D_C_T_S_T_D_S_R(
200                            long companyId, long groupId, long classNameId, String articleId,
201                            Double version, String title, String description, String content,
202                            String type, String[] structureIds, String[] templateIds,
203                            Date displayDateGT, Date displayDateLT, int status, Date reviewDate,
204                            boolean andOperator)
205                    throws SystemException {
206    
207                    String[] articleIds = CustomSQLUtil.keywords(articleId, false);
208                    String[] titles = CustomSQLUtil.keywords(title);
209                    String[] descriptions = CustomSQLUtil.keywords(description, false);
210                    String[] contents = CustomSQLUtil.keywords(content, false);
211    
212                    return filterCountByC_G_C_A_V_T_D_C_T_S_T_D_S_R(
213                            companyId, groupId, classNameId, articleIds, version, titles,
214                            descriptions, contents, type, structureIds, templateIds,
215                            displayDateGT, displayDateLT, status, reviewDate, andOperator);
216            }
217    
218            public int filterCountByC_G_C_A_V_T_D_C_T_S_T_D_S_R(
219                            long companyId, long groupId, long classNameId, String[] articleIds,
220                            Double version, String[] titles, String[] descriptions,
221                            String[] contents, String type, String[] structureIds,
222                            String[] templateIds, Date displayDateGT, Date displayDateLT,
223                            int status, Date reviewDate, boolean andOperator)
224                    throws SystemException {
225    
226                    return doCountByC_G_C_A_V_T_D_C_T_S_T_D_S_R(
227                            companyId, groupId, classNameId, articleIds, version, titles,
228                            descriptions, contents, type, structureIds, templateIds,
229                            displayDateGT, displayDateLT, status, reviewDate, andOperator,
230                            true);
231            }
232    
233            public List<JournalArticle> filterFindByKeywords(
234                            long companyId, long groupId, long classNameId, String keywords,
235                            Double version, String type, String structureId, String templateId,
236                            Date displayDateGT, Date displayDateLT, int status, Date reviewDate,
237                            int start, int end, OrderByComparator orderByComparator)
238                    throws SystemException {
239    
240                    String[] articleIds = null;
241                    String[] titles = null;
242                    String[] descriptions = null;
243                    String[] contents = null;
244                    String[] structureIds = CustomSQLUtil.keywords(structureId, false);
245                    String[] templateIds = CustomSQLUtil.keywords(templateId, false);
246                    boolean andOperator = false;
247    
248                    if (Validator.isNotNull(keywords)) {
249                            articleIds = CustomSQLUtil.keywords(keywords, false);
250                            titles = CustomSQLUtil.keywords(keywords);
251                            descriptions = CustomSQLUtil.keywords(keywords, false);
252                            contents = CustomSQLUtil.keywords(keywords, false);
253                    }
254                    else {
255                            andOperator = true;
256                    }
257    
258                    return doFindByC_G_C_A_V_T_D_C_T_S_T_D_S_R(
259                            companyId, groupId, classNameId, articleIds, version, titles,
260                            descriptions, contents, type, structureIds, templateIds,
261                            displayDateGT, displayDateLT, status, reviewDate, andOperator,
262                            start, end, orderByComparator, true);
263            }
264    
265            public List<JournalArticle> filterFindByC_G_C_A_V_T_D_C_T_S_T_D_S_R(
266                            long companyId, long groupId, long classNameId, String articleId,
267                            Double version, String title, String description, String content,
268                            String type, String structureId, String templateId,
269                            Date displayDateGT, Date displayDateLT, int status, Date reviewDate,
270                            boolean andOperator, int start, int end,
271                            OrderByComparator orderByComparator)
272                    throws SystemException {
273    
274                    String[] structureIds = CustomSQLUtil.keywords(structureId, false);
275                    String[] templateIds = CustomSQLUtil.keywords(templateId, false);
276    
277                    return filterFindByC_G_C_A_V_T_D_C_T_S_T_D_S_R(
278                            companyId, groupId, classNameId, articleId, version, title,
279                            description, content, type, structureIds, templateIds,
280                            displayDateGT, displayDateLT, status, reviewDate, andOperator,
281                            start, end, orderByComparator);
282            }
283    
284            public List<JournalArticle> filterFindByC_G_C_A_V_T_D_C_T_S_T_D_S_R(
285                            long companyId, long groupId, long classNameId, String articleId,
286                            Double version, String title, String description, String content,
287                            String type, String[] structureIds, String[] templateIds,
288                            Date displayDateGT, Date displayDateLT, int status, Date reviewDate,
289                            boolean andOperator, int start, int end,
290                            OrderByComparator orderByComparator)
291                    throws SystemException {
292    
293                    String[] articleIds = CustomSQLUtil.keywords(articleId, false);
294                    String[] titles = CustomSQLUtil.keywords(title);
295                    String[] descriptions = CustomSQLUtil.keywords(description, false);
296                    String[] contents = CustomSQLUtil.keywords(content, false);
297    
298                    return filterFindByC_G_C_A_V_T_D_C_T_S_T_D_S_R(
299                            companyId, groupId, classNameId, articleIds, version, titles,
300                            descriptions, contents, type, structureIds, templateIds,
301                            displayDateGT, displayDateLT, status, reviewDate, andOperator,
302                            start, end, orderByComparator);
303            }
304    
305            public List<JournalArticle> filterFindByC_G_C_A_V_T_D_C_T_S_T_D_S_R(
306                            long companyId, long groupId, long classNameId, String[] articleIds,
307                            Double version, String[] titles, String[] descriptions,
308                            String[] contents, String type, String[] structureIds,
309                            String[] templateIds, Date displayDateGT, Date displayDateLT,
310                            int status, Date reviewDate, boolean andOperator, int start,
311                            int end, OrderByComparator orderByComparator)
312                    throws SystemException {
313    
314                    return doFindByC_G_C_A_V_T_D_C_T_S_T_D_S_R(
315                            companyId, groupId, classNameId, articleIds, version, titles,
316                            descriptions, contents, type, structureIds, templateIds,
317                            displayDateGT, displayDateLT, status, reviewDate, andOperator,
318                            start, end, orderByComparator, true);
319            }
320    
321            public List<JournalArticle> findByExpirationDate(
322                            long classNameId, int status, Date expirationDateLT)
323                    throws SystemException {
324    
325                    Timestamp expirationDateLT_TS = CalendarUtil.getTimestamp(
326                            expirationDateLT);
327    
328                    Session session = null;
329    
330                    try {
331                            session = openSession();
332    
333                            String sql = CustomSQLUtil.get(FIND_BY_EXPIRATION_DATE);
334    
335                            if (status == WorkflowConstants.STATUS_ANY) {
336                                    sql = StringUtil.replace(sql, "(status = ?) AND", "");
337                            }
338    
339                            SQLQuery q = session.createSQLQuery(sql);
340    
341                            q.addEntity("JournalArticle", JournalArticleImpl.class);
342    
343                            QueryPos qPos = QueryPos.getInstance(q);
344    
345                            qPos.add(classNameId);
346    
347                            if (status != WorkflowConstants.STATUS_ANY) {
348                                    qPos.add(status);
349                            }
350    
351                            qPos.add(expirationDateLT_TS);
352    
353                            return q.list(true);
354                    }
355                    catch (Exception e) {
356                            throw new SystemException(e);
357                    }
358                    finally {
359                            closeSession(session);
360                    }
361            }
362    
363            public List<JournalArticle> findByKeywords(
364                            long companyId, long groupId, long classNameId, String keywords,
365                            Double version, String type, String structureId, String templateId,
366                            Date displayDateGT, Date displayDateLT, int status, Date reviewDate,
367                            int start, int end, OrderByComparator orderByComparator)
368                    throws SystemException {
369    
370                    String[] articleIds = null;
371                    String[] titles = null;
372                    String[] descriptions = null;
373                    String[] contents = null;
374                    String[] structureIds = CustomSQLUtil.keywords(structureId, false);
375                    String[] templateIds = CustomSQLUtil.keywords(templateId, false);
376                    boolean andOperator = false;
377    
378                    if (Validator.isNotNull(keywords)) {
379                            articleIds = CustomSQLUtil.keywords(keywords, false);
380                            titles = CustomSQLUtil.keywords(keywords);
381                            descriptions = CustomSQLUtil.keywords(keywords, false);
382                            contents = CustomSQLUtil.keywords(keywords, false);
383                    }
384                    else {
385                            andOperator = true;
386                    }
387    
388                    return findByC_G_C_A_V_T_D_C_T_S_T_D_S_R(
389                            companyId, groupId, classNameId, articleIds, version, titles,
390                            descriptions, contents, type, structureIds, templateIds,
391                            displayDateGT, displayDateLT, status, reviewDate, andOperator,
392                            start, end, orderByComparator);
393            }
394    
395            public List<JournalArticle> findByReviewDate(
396                            long classNameId, Date reviewDateLT, Date reviewDateGT)
397                    throws SystemException {
398    
399                    Timestamp reviewDateLT_TS = CalendarUtil.getTimestamp(reviewDateLT);
400                    Timestamp reviewDateGT_TS = CalendarUtil.getTimestamp(reviewDateGT);
401    
402                    Session session = null;
403                    try {
404                            session = openSession();
405    
406                            String sql = CustomSQLUtil.get(FIND_BY_REVIEW_DATE);
407    
408                            SQLQuery q = session.createSQLQuery(sql);
409    
410                            q.addEntity("JournalArticle", JournalArticleImpl.class);
411    
412                            QueryPos qPos = QueryPos.getInstance(q);
413    
414                            qPos.add(classNameId);
415                            qPos.add(reviewDateGT_TS);
416                            qPos.add(reviewDateLT_TS);
417    
418                            return q.list(true);
419                    }
420                    catch (Exception e) {
421                            throw new SystemException(e);
422                    }
423                    finally {
424                            closeSession(session);
425                    }
426            }
427    
428            public JournalArticle findByR_D(long resourcePrimKey, Date displayDate)
429                    throws NoSuchArticleException, SystemException {
430    
431                    Timestamp displayDate_TS = CalendarUtil.getTimestamp(displayDate);
432    
433                    Session session = null;
434    
435                    try {
436                            session = openSession();
437    
438                            String sql = CustomSQLUtil.get(FIND_BY_R_D);
439    
440                            SQLQuery q = session.createSQLQuery(sql);
441    
442                            q.addEntity("JournalArticle", JournalArticleImpl.class);
443    
444                            QueryPos qPos = QueryPos.getInstance(q);
445    
446                            qPos.add(resourcePrimKey);
447                            qPos.add(displayDate_TS);
448    
449                            List<JournalArticle> articles = q.list();
450    
451                            if (!articles.isEmpty()) {
452                                    return articles.get(0);
453                            }
454                    }
455                    catch (Exception e) {
456                            throw new SystemException(e);
457                    }
458                    finally {
459                            closeSession(session);
460                    }
461    
462                    StringBundler sb = new StringBundler(6);
463    
464                    sb.append("No JournalArticle exists with the key ");
465                    sb.append("{resourcePrimKey=");
466                    sb.append(resourcePrimKey);
467                    sb.append(", displayDate=");
468                    sb.append(displayDate);
469                    sb.append("}");
470    
471                    throw new NoSuchArticleException(sb.toString());
472            }
473    
474            public List<JournalArticle> findByC_G_C_A_V_T_D_C_T_S_T_D_S_R(
475                            long companyId, long groupId, long classNameId, String articleId,
476                            Double version, String title, String description, String content,
477                            String type, String structureId, String templateId,
478                            Date displayDateGT, Date displayDateLT, int status, Date reviewDate,
479                            boolean andOperator, int start, int end,
480                            OrderByComparator orderByComparator)
481                    throws SystemException {
482    
483                    String[] articleIds = CustomSQLUtil.keywords(articleId, false);
484                    String[] titles = CustomSQLUtil.keywords(title);
485                    String[] descriptions = CustomSQLUtil.keywords(description, false);
486                    String[] contents = CustomSQLUtil.keywords(content, false);
487                    String[] structureIds = CustomSQLUtil.keywords(structureId, false);
488                    String[] templateIds = CustomSQLUtil.keywords(templateId, false);
489    
490                    return findByC_G_C_A_V_T_D_C_T_S_T_D_S_R(
491                            companyId, groupId, classNameId, articleIds, version, titles,
492                            descriptions, contents, type, structureIds, templateIds,
493                            displayDateGT, displayDateLT, status, reviewDate, andOperator,
494                            start, end, orderByComparator);
495            }
496    
497            public List<JournalArticle> findByC_G_C_A_V_T_D_C_T_S_T_D_S_R(
498                            long companyId, long groupId, long classNameId, String articleId,
499                            Double version, String title, String description, String content,
500                            String type, String[] structureIds, String[] templateIds,
501                            Date displayDateGT, Date displayDateLT, int status, Date reviewDate,
502                            boolean andOperator, int start, int end,
503                            OrderByComparator orderByComparator)
504                    throws SystemException {
505    
506                    String[] articleIds = CustomSQLUtil.keywords(articleId, false);
507                    String[] titles = CustomSQLUtil.keywords(title);
508                    String[] descriptions = CustomSQLUtil.keywords(description, false);
509                    String[] contents = CustomSQLUtil.keywords(content, false);
510    
511                    return findByC_G_C_A_V_T_D_C_T_S_T_D_S_R(
512                            companyId, groupId, classNameId, articleIds, version, titles,
513                            descriptions, contents, type, structureIds, templateIds,
514                            displayDateGT, displayDateLT, status, reviewDate, andOperator,
515                            start, end, orderByComparator);
516            }
517    
518            public List<JournalArticle> findByC_G_C_A_V_T_D_C_T_S_T_D_S_R(
519                            long companyId, long groupId, long classNameId, String[] articleIds,
520                            Double version, String[] titles, String[] descriptions,
521                            String[] contents, String type, String[] structureIds,
522                            String[] templateIds, Date displayDateGT, Date displayDateLT,
523                            int status, Date reviewDate, boolean andOperator, int start,
524                            int end, OrderByComparator orderByComparator)
525                    throws SystemException {
526    
527                    return doFindByC_G_C_A_V_T_D_C_T_S_T_D_S_R(
528                            companyId, groupId, classNameId, articleIds, version, titles,
529                            descriptions, contents, type, structureIds, templateIds,
530                            displayDateGT, displayDateLT, status, reviewDate, andOperator,
531                            start, end, orderByComparator, false);
532            }
533    
534            protected int doCountByC_G_C_A_V_T_D_C_T_S_T_D_S_R(
535                            long companyId, long groupId, long classNameId, String[] articleIds,
536                            Double version, String[] titles, String[] descriptions,
537                            String[] contents, String type, String[] structureIds,
538                            String[] templateIds, Date displayDateGT, Date displayDateLT,
539                            int status, Date reviewDate, boolean andOperator,
540                            boolean inlineSQLHelper)
541                    throws SystemException {
542    
543                    articleIds = CustomSQLUtil.keywords(articleIds, false);
544                    titles = CustomSQLUtil.keywords(titles);
545                    descriptions = CustomSQLUtil.keywords(descriptions, false);
546                    contents = CustomSQLUtil.keywords(contents, false);
547                    structureIds = CustomSQLUtil.keywords(structureIds, false);
548                    templateIds = CustomSQLUtil.keywords(templateIds, false);
549                    Timestamp displayDateGT_TS = CalendarUtil.getTimestamp(displayDateGT);
550                    Timestamp displayDateLT_TS = CalendarUtil.getTimestamp(displayDateLT);
551                    Timestamp reviewDate_TS = CalendarUtil.getTimestamp(reviewDate);
552    
553                    Session session = null;
554    
555                    try {
556                            session = openSession();
557    
558                            String sql = CustomSQLUtil.get(
559                                    COUNT_BY_C_G_C_A_V_T_D_C_T_S_T_D_S_R);
560    
561                            if (groupId <= 0) {
562                                    sql = StringUtil.replace(sql, "(groupId = ?) AND", "");
563                            }
564    
565                            sql = CustomSQLUtil.replaceKeywords(
566                                    sql, "articleId", StringPool.LIKE, false, articleIds);
567    
568                            if ((version == null) || (version <= 0)) {
569                                    sql = StringUtil.replace(
570                                            sql, "(version = ?) [$AND_OR_CONNECTOR$]", "");
571                            }
572    
573                            sql = CustomSQLUtil.replaceKeywords(
574                                    sql, "lower(title)", StringPool.LIKE, false, titles);
575                            sql = CustomSQLUtil.replaceKeywords(
576                                    sql, "description", StringPool.LIKE, false, descriptions);
577                            sql = CustomSQLUtil.replaceKeywords(
578                                    sql, "content", StringPool.LIKE, false, contents);
579                            sql = CustomSQLUtil.replaceKeywords(
580                                    sql, "structureId", StringPool.LIKE, false, structureIds);
581                            sql = CustomSQLUtil.replaceKeywords(
582                                    sql, "templateId", StringPool.LIKE, false, templateIds);
583    
584                            if (status == WorkflowConstants.STATUS_ANY) {
585                                    sql = StringUtil.replace(sql, "(status = ?) AND", "");
586                            }
587    
588                            sql = CustomSQLUtil.replaceAndOperator(sql, andOperator);
589    
590                            if ((articleIds != null) &&
591                                    ((articleIds.length > 1) ||
592                                     ((articleIds.length == 1) && (articleIds[0] != null))) &&
593                                    (version == null)) {
594    
595                                    sql = StringUtil.replace(
596                                            sql, "MAX(version) AS tempVersion",
597                                            "version AS tempVersion");
598                                    sql = StringUtil.replace(sql, "[$GROUP_BY_CLAUSE$]", "");
599                            }
600                            else {
601                                    sql = StringUtil.replace(
602                                            sql, "[$GROUP_BY_CLAUSE$]", "GROUP BY groupId, articleId");
603                            }
604    
605                            if (inlineSQLHelper) {
606                                    sql = InlineSQLHelperUtil.replacePermissionCheck(
607                                            sql, JournalArticle.class.getName(),
608                                            "JournalArticle.resourcePrimKey", groupId);
609    
610                                    sql = StringUtil.replace(
611                                            sql, "(companyId", "(JournalArticle.companyId");
612                            }
613    
614                            SQLQuery q = session.createSQLQuery(sql);
615    
616                            q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
617    
618                            QueryPos qPos = QueryPos.getInstance(q);
619    
620                            qPos.add(companyId);
621    
622                            if (groupId > 0) {
623                                    qPos.add(groupId);
624                            }
625    
626                            qPos.add(classNameId);
627                            qPos.add(articleIds, 2);
628    
629                            if ((version != null) && (version > 0)) {
630                                    qPos.add(version);
631                            }
632    
633                            qPos.add(titles, 2);
634                            qPos.add(descriptions, 2);
635                            qPos.add(contents, 2);
636                            qPos.add(type);
637                            qPos.add(type);
638                            qPos.add(structureIds, 2);
639                            qPos.add(templateIds, 2);
640                            qPos.add(displayDateGT_TS);
641                            qPos.add(displayDateGT_TS);
642                            qPos.add(displayDateLT_TS);
643                            qPos.add(displayDateLT_TS);
644    
645                            if (status != WorkflowConstants.STATUS_ANY) {
646                                    qPos.add(status);
647                            }
648    
649                            qPos.add(reviewDate_TS);
650                            qPos.add(reviewDate_TS);
651    
652                            Iterator<Long> itr = q.iterate();
653    
654                            if (itr.hasNext()) {
655                                    Long count = itr.next();
656    
657                                    if (count != null) {
658                                            return count.intValue();
659                                    }
660                            }
661    
662                            return 0;
663                    }
664                    catch (Exception e) {
665                            throw new SystemException(e);
666                    }
667                    finally {
668                            closeSession(session);
669                    }
670            }
671    
672            protected List<JournalArticle> doFindByC_G_C_A_V_T_D_C_T_S_T_D_S_R(
673                            long companyId, long groupId, long classNameId, String[] articleIds,
674                            Double version, String[] titles, String[] descriptions,
675                            String[] contents, String type, String[] structureIds,
676                            String[] templateIds, Date displayDateGT, Date displayDateLT,
677                            int status, Date reviewDate, boolean andOperator, int start,
678                            int end, OrderByComparator orderByComparator,
679                            boolean inlineSQLHelper)
680                    throws SystemException {
681    
682                    articleIds = CustomSQLUtil.keywords(articleIds, false);
683                    titles = CustomSQLUtil.keywords(titles);
684                    descriptions = CustomSQLUtil.keywords(descriptions, false);
685                    contents = CustomSQLUtil.keywords(contents, false);
686                    structureIds = CustomSQLUtil.keywords(structureIds, false);
687                    templateIds = CustomSQLUtil.keywords(templateIds, false);
688                    Timestamp displayDateGT_TS = CalendarUtil.getTimestamp(displayDateGT);
689                    Timestamp displayDateLT_TS = CalendarUtil.getTimestamp(displayDateLT);
690                    Timestamp reviewDate_TS = CalendarUtil.getTimestamp(reviewDate);
691    
692                    Session session = null;
693    
694                    try {
695                            session = openSession();
696    
697                            String sql = CustomSQLUtil.get(FIND_BY_C_G_C_A_V_T_D_C_T_S_T_D_S_R);
698    
699                            if (groupId <= 0) {
700                                    sql = StringUtil.replace(sql, "(groupId = ?) AND", "");
701                            }
702    
703                            sql = CustomSQLUtil.replaceKeywords(
704                                    sql, "articleId", StringPool.LIKE, false, articleIds);
705    
706                            if ((version == null) || (version <= 0)) {
707                                    sql = StringUtil.replace(
708                                            sql, "(version = ?) [$AND_OR_CONNECTOR$]", "");
709                            }
710    
711                            sql = CustomSQLUtil.replaceKeywords(
712                                    sql, "lower(title)", StringPool.LIKE, false, titles);
713                            sql = CustomSQLUtil.replaceKeywords(
714                                    sql, "description", StringPool.LIKE, false, descriptions);
715                            sql = CustomSQLUtil.replaceKeywords(
716                                    sql, "content", StringPool.LIKE, false, contents);
717                            sql = CustomSQLUtil.replaceKeywords(
718                                    sql, "structureId", StringPool.LIKE, false, structureIds);
719                            sql = CustomSQLUtil.replaceKeywords(
720                                    sql, "templateId", StringPool.LIKE, false, templateIds);
721    
722                            if (status == WorkflowConstants.STATUS_ANY) {
723                                    sql = StringUtil.replace(sql, "(status = ?) AND", "");
724                            }
725    
726                            sql = CustomSQLUtil.replaceAndOperator(sql, andOperator);
727    
728                            if ((articleIds != null) &&
729                                    ((articleIds.length > 1) ||
730                                     ((articleIds.length == 1) && (articleIds[0] != null))) &&
731                                    (version == null)) {
732    
733                                    sql = StringUtil.replace(
734                                            sql, "MAX(version) AS tempVersion",
735                                            "version AS tempVersion");
736                                    sql = StringUtil.replace(sql, "[$GROUP_BY_CLAUSE$]", "");
737                            }
738                            else {
739                                    sql = StringUtil.replace(
740                                            sql, "[$GROUP_BY_CLAUSE$]", "GROUP BY groupId, articleId");
741                            }
742    
743                            sql = CustomSQLUtil.replaceOrderBy(sql, orderByComparator);
744    
745                            if (inlineSQLHelper) {
746                                    sql = InlineSQLHelperUtil.replacePermissionCheck(
747                                            sql, JournalArticle.class.getName(),
748                                            "JournalArticle.resourcePrimKey", groupId);
749    
750                                    sql = StringUtil.replace(
751                                            sql, "(companyId", "(JournalArticle.companyId");
752                            }
753    
754                            SQLQuery q = session.createSQLQuery(sql);
755    
756                            q.addEntity("JournalArticle", JournalArticleImpl.class);
757    
758                            QueryPos qPos = QueryPos.getInstance(q);
759    
760                            qPos.add(companyId);
761    
762                            if (groupId > 0) {
763                                    qPos.add(groupId);
764                            }
765    
766                            qPos.add(classNameId);
767                            qPos.add(articleIds, 2);
768    
769                            if ((version != null) && (version > 0)) {
770                                    qPos.add(version);
771                            }
772    
773                            qPos.add(titles, 2);
774                            qPos.add(descriptions, 2);
775                            qPos.add(contents, 2);
776                            qPos.add(type);
777                            qPos.add(type);
778                            qPos.add(structureIds, 2);
779                            qPos.add(templateIds, 2);
780                            qPos.add(displayDateGT_TS);
781                            qPos.add(displayDateGT_TS);
782                            qPos.add(displayDateLT_TS);
783                            qPos.add(displayDateLT_TS);
784    
785                            if (status != WorkflowConstants.STATUS_ANY) {
786                                    qPos.add(status);
787                            }
788    
789                            qPos.add(reviewDate_TS);
790                            qPos.add(reviewDate_TS);
791    
792                            return (List<JournalArticle>)QueryUtil.list(
793                                    q, getDialect(), start, end);
794                    }
795                    catch (Exception e) {
796                            throw new SystemException(e);
797                    }
798                    finally {
799                            closeSession(session);
800                    }
801            }
802    
803            protected JournalArticle getLatestArticle(
804                            long groupId, String articleId, int status)
805                    throws SystemException {
806    
807                    List<JournalArticle> articles = null;
808    
809                    if (status == WorkflowConstants.STATUS_ANY) {
810                            articles = JournalArticleUtil.findByG_A(groupId, articleId, 0, 1);
811                    }
812                    else {
813                            articles = JournalArticleUtil.findByG_A_ST(
814                                    groupId, articleId, status, 0, 1);
815                    }
816    
817                    if (articles.isEmpty()) {
818                            return null;
819                    }
820    
821                    return articles.get(0);
822            }
823    
824    }