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.QueryDefinition;
018    import com.liferay.portal.kernel.dao.orm.QueryPos;
019    import com.liferay.portal.kernel.dao.orm.QueryUtil;
020    import com.liferay.portal.kernel.dao.orm.SQLQuery;
021    import com.liferay.portal.kernel.dao.orm.Session;
022    import com.liferay.portal.kernel.dao.orm.Type;
023    import com.liferay.portal.kernel.exception.SystemException;
024    import com.liferay.portal.kernel.util.CalendarUtil;
025    import com.liferay.portal.kernel.util.OrderByComparator;
026    import com.liferay.portal.kernel.util.StringBundler;
027    import com.liferay.portal.kernel.util.StringPool;
028    import com.liferay.portal.kernel.util.StringUtil;
029    import com.liferay.portal.kernel.util.Validator;
030    import com.liferay.portal.kernel.workflow.WorkflowConstants;
031    import com.liferay.portal.security.permission.InlineSQLHelperUtil;
032    import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
033    import com.liferay.portlet.journal.NoSuchArticleException;
034    import com.liferay.portlet.journal.model.JournalArticle;
035    import com.liferay.portlet.journal.model.JournalArticleConstants;
036    import com.liferay.portlet.journal.model.impl.JournalArticleImpl;
037    import com.liferay.util.dao.orm.CustomSQLUtil;
038    
039    import java.sql.Timestamp;
040    
041    import java.util.Date;
042    import java.util.Iterator;
043    import java.util.List;
044    
045    /**
046     * @author Brian Wing Shun Chan
047     * @author Raymond Augé
048     * @author Connor McKay
049     */
050    public class JournalArticleFinderImpl
051            extends BasePersistenceImpl<JournalArticle>
052            implements JournalArticleFinder {
053    
054            public static final String COUNT_BY_G_F =
055                    JournalArticleFinder.class.getName() + ".countByG_F";
056    
057            public static final String COUNT_BY_G_U_C =
058                    JournalArticleFinder.class.getName() + ".countByG_U_C";
059    
060            public static final String COUNT_BY_G_C_S =
061                    JournalArticleFinder.class.getName() + ".countByG_C_S";
062    
063            public static final String COUNT_BY_C_G_F_C_A_V_T_D_C_T_S_T_D_R =
064                    JournalArticleFinder.class.getName() +
065                            ".countByC_G_F_C_A_V_T_D_C_T_S_T_D_R";
066    
067            public static final String FIND_BY_EXPIRATION_DATE =
068                    JournalArticleFinder.class.getName() + ".findByExpirationDate";
069    
070            public static final String FIND_BY_REVIEW_DATE =
071                    JournalArticleFinder.class.getName() + ".findByReviewDate";
072    
073            public static final String FIND_BY_R_D =
074                    JournalArticleFinder.class.getName() + ".findByR_D";
075    
076            public static final String FIND_BY_G_U_C =
077                    JournalArticleFinder.class.getName() + ".findByG_U_C";
078    
079            public static final String FIND_BY_G_C_S =
080                    JournalArticleFinder.class.getName() + ".findByG_C_S";
081    
082            public static final String FIND_BY_C_G_F_C_A_V_T_D_C_T_S_T_D_R =
083                    JournalArticleFinder.class.getName() +
084                            ".findByC_G_F_C_A_V_T_D_C_T_S_T_D_R";
085    
086            public int countByKeywords(
087                            long companyId, long groupId, List<Long> folderIds,
088                            long classNameId, String keywords, Double version, String type,
089                            String structureId, String templateId, Date displayDateGT,
090                            Date displayDateLT, int status, Date reviewDate)
091                    throws SystemException {
092    
093                    String[] articleIds = null;
094                    String[] titles = null;
095                    String[] descriptions = null;
096                    String[] contents = null;
097                    String[] structureIds = CustomSQLUtil.keywords(structureId, false);
098                    String[] templateIds = CustomSQLUtil.keywords(templateId, false);
099                    boolean andOperator = false;
100    
101                    if (Validator.isNotNull(keywords)) {
102                            articleIds = CustomSQLUtil.keywords(keywords, false);
103                            titles = CustomSQLUtil.keywords(keywords);
104                            descriptions = CustomSQLUtil.keywords(keywords, false);
105                            contents = CustomSQLUtil.keywords(keywords, false);
106                    }
107                    else {
108                            andOperator = true;
109                    }
110    
111                    QueryDefinition queryDefinition = new QueryDefinition(status);
112    
113                    return doCountByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
114                            companyId, groupId, folderIds, classNameId, articleIds, version,
115                            titles, descriptions, contents, type, structureIds, templateIds,
116                            displayDateGT, displayDateLT, reviewDate, andOperator,
117                            queryDefinition, false);
118            }
119    
120            public int countByG_F(
121                            long groupId, List<Long> folderIds, QueryDefinition queryDefinition)
122                    throws SystemException {
123    
124                    return doCountByG_F(groupId, folderIds, queryDefinition, false);
125            }
126    
127            public int countByG_U_C(
128                            long groupId, long userId, long classNameId,
129                            QueryDefinition queryDefinition)
130                    throws SystemException {
131    
132                    return doCountByG_U_C(
133                            groupId, userId, classNameId, queryDefinition, false);
134            }
135    
136            public int countByG_C_S(
137                            long groupId, long classNameId, String structureId,
138                            QueryDefinition queryDefinition)
139                    throws SystemException {
140    
141                    return doCountByG_C_S(
142                            groupId, classNameId, structureId, queryDefinition, false);
143            }
144    
145            public int countByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
146                            long companyId, long groupId, List<Long> folderIds,
147                            long classNameId, String articleId, Double version, String title,
148                            String description, String content, String type, String structureId,
149                            String templateId, Date displayDateGT, Date displayDateLT,
150                            Date reviewDate, boolean andOperator,
151                            QueryDefinition queryDefinition)
152                    throws SystemException {
153    
154                    String[] structureIds = CustomSQLUtil.keywords(structureId, false);
155                    String[] templateIds = CustomSQLUtil.keywords(templateId, false);
156    
157                    return countByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
158                            companyId, groupId, folderIds, classNameId, articleId, version,
159                            title, description, content, type, structureIds, templateIds,
160                            displayDateGT, displayDateLT, reviewDate, andOperator,
161                            queryDefinition);
162            }
163    
164            public int countByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
165                            long companyId, long groupId, List<Long> folderIds,
166                            long classNameId, String articleId, Double version, String title,
167                            String description, String content, String type,
168                            String[] structureIds, String[] templateIds, Date displayDateGT,
169                            Date displayDateLT, Date reviewDate, boolean andOperator,
170                            QueryDefinition queryDefinition)
171                    throws SystemException {
172    
173                    String[] articleIds = CustomSQLUtil.keywords(articleId, false);
174                    String[] titles = CustomSQLUtil.keywords(title);
175                    String[] descriptions = CustomSQLUtil.keywords(description, false);
176                    String[] contents = CustomSQLUtil.keywords(content, false);
177    
178                    return countByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
179                            companyId, groupId, folderIds, classNameId, articleIds, version,
180                            titles, descriptions, contents, type, structureIds, templateIds,
181                            displayDateGT, displayDateLT, reviewDate, andOperator,
182                            queryDefinition);
183            }
184    
185            public int countByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
186                            long companyId, long groupId, List<Long> folderIds,
187                            long classNameId, String[] articleIds, Double version,
188                            String[] titles, String[] descriptions, String[] contents,
189                            String type, String[] structureIds, String[] templateIds,
190                            Date displayDateGT, Date displayDateLT, Date reviewDate,
191                            boolean andOperator, QueryDefinition queryDefinition)
192                    throws SystemException {
193    
194                    return doCountByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
195                            companyId, groupId, folderIds, classNameId, articleIds, version,
196                            titles, descriptions, contents, type, structureIds, templateIds,
197                            displayDateGT, displayDateLT, reviewDate, andOperator,
198                            queryDefinition, false);
199            }
200    
201            public int filterCountByKeywords(
202                            long companyId, long groupId, List<Long> folderIds,
203                            long classNameId, String keywords, Double version, String type,
204                            String structureId, String templateId, Date displayDateGT,
205                            Date displayDateLT, int status, Date reviewDate)
206                    throws SystemException {
207    
208                    String[] articleIds = null;
209                    String[] titles = null;
210                    String[] descriptions = null;
211                    String[] contents = null;
212                    String[] structureIds = CustomSQLUtil.keywords(structureId, false);
213                    String[] templateIds = CustomSQLUtil.keywords(templateId, false);
214                    boolean andOperator = false;
215    
216                    if (Validator.isNotNull(keywords)) {
217                            articleIds = CustomSQLUtil.keywords(keywords, false);
218                            titles = CustomSQLUtil.keywords(keywords);
219                            descriptions = CustomSQLUtil.keywords(keywords, false);
220                            contents = CustomSQLUtil.keywords(keywords, false);
221                    }
222                    else {
223                            andOperator = true;
224                    }
225    
226                    QueryDefinition queryDefinition = new QueryDefinition(status);
227    
228                    return doCountByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
229                            companyId, groupId, folderIds, classNameId, articleIds, version,
230                            titles, descriptions, contents, type, structureIds, templateIds,
231                            displayDateGT, displayDateLT, reviewDate, andOperator,
232                            queryDefinition, true);
233            }
234    
235            public int filterCountByG_F(
236                            long groupId, List<Long> folderIds, QueryDefinition queryDefinition)
237                    throws SystemException {
238    
239                    return doCountByG_F(groupId, folderIds, queryDefinition, true);
240            }
241    
242            public int filterCountByG_U_C(
243                            long groupId, long userId, long classNameId,
244                            QueryDefinition queryDefinition)
245                    throws SystemException {
246    
247                    return doCountByG_U_C(
248                            groupId, userId, classNameId, queryDefinition, true);
249            }
250    
251            public int filterCountByG_C_S(
252                            long groupId, long classNameId, String structureId,
253                            QueryDefinition queryDefinition)
254                    throws SystemException {
255    
256                    return doCountByG_C_S(
257                            groupId, classNameId, structureId, queryDefinition, true);
258            }
259    
260            public int filterCountByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
261                            long companyId, long groupId, List<Long> folderIds,
262                            long classNameId, String articleId, Double version, String title,
263                            String description, String content, String type, String structureId,
264                            String templateId, Date displayDateGT, Date displayDateLT,
265                            Date reviewDate, boolean andOperator,
266                            QueryDefinition queryDefinition)
267                    throws SystemException {
268    
269                    String[] structureIds = CustomSQLUtil.keywords(structureId, false);
270                    String[] templateIds = CustomSQLUtil.keywords(templateId, false);
271    
272                    return filterCountByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
273                            companyId, groupId, folderIds, classNameId, articleId, version,
274                            title, description, content, type, structureIds, templateIds,
275                            displayDateGT, displayDateLT, reviewDate, andOperator,
276                            queryDefinition);
277            }
278    
279            public int filterCountByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
280                            long companyId, long groupId, List<Long> folderIds,
281                            long classNameId, String articleId, Double version, String title,
282                            String description, String content, String type,
283                            String[] structureIds, String[] templateIds, Date displayDateGT,
284                            Date displayDateLT, Date reviewDate, boolean andOperator,
285                            QueryDefinition queryDefinition)
286                    throws SystemException {
287    
288                    String[] articleIds = CustomSQLUtil.keywords(articleId, false);
289                    String[] titles = CustomSQLUtil.keywords(title);
290                    String[] descriptions = CustomSQLUtil.keywords(description, false);
291                    String[] contents = CustomSQLUtil.keywords(content, false);
292    
293                    return filterCountByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
294                            companyId, groupId, folderIds, classNameId, articleIds, version,
295                            titles, descriptions, contents, type, structureIds, templateIds,
296                            displayDateGT, displayDateLT, reviewDate, andOperator,
297                            queryDefinition);
298            }
299    
300            public int filterCountByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
301                            long companyId, long groupId, List<Long> folderIds,
302                            long classNameId, String[] articleIds, Double version,
303                            String[] titles, String[] descriptions, String[] contents,
304                            String type, String[] structureIds, String[] templateIds,
305                            Date displayDateGT, Date displayDateLT, Date reviewDate,
306                            boolean andOperator, QueryDefinition queryDefinition)
307                    throws SystemException {
308    
309                    return doCountByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
310                            companyId, groupId, folderIds, classNameId, articleIds, version,
311                            titles, descriptions, contents, type, structureIds, templateIds,
312                            displayDateGT, displayDateLT, reviewDate, andOperator,
313                            queryDefinition, true);
314            }
315    
316            public List<JournalArticle> filterFindByKeywords(
317                            long companyId, long groupId, List<Long> folderIds,
318                            long classNameId, String keywords, Double version, String type,
319                            String structureId, String templateId, Date displayDateGT,
320                            Date displayDateLT, int status, Date reviewDate, int start, int end,
321                            OrderByComparator orderByComparator)
322                    throws SystemException {
323    
324                    String[] articleIds = null;
325                    String[] titles = null;
326                    String[] descriptions = null;
327                    String[] contents = null;
328                    String[] structureIds = CustomSQLUtil.keywords(structureId, false);
329                    String[] templateIds = CustomSQLUtil.keywords(templateId, false);
330                    boolean andOperator = false;
331    
332                    if (Validator.isNotNull(keywords)) {
333                            articleIds = CustomSQLUtil.keywords(keywords, false);
334                            titles = CustomSQLUtil.keywords(keywords);
335                            descriptions = CustomSQLUtil.keywords(keywords, false);
336                            contents = CustomSQLUtil.keywords(keywords, false);
337                    }
338                    else {
339                            andOperator = true;
340                    }
341    
342                    QueryDefinition queryDefinition = new QueryDefinition(
343                            status, start, end, orderByComparator);
344    
345                    return doFindByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
346                            companyId, groupId, folderIds, classNameId, articleIds, version,
347                            titles, descriptions, contents, type, structureIds, templateIds,
348                            displayDateGT, displayDateLT, reviewDate, andOperator,
349                            queryDefinition, true);
350            }
351    
352            public List<JournalArticle> filterFindByG_U_C(
353                            long groupId, long userId, long classNameId,
354                            QueryDefinition queryDefinition)
355                    throws SystemException {
356    
357                    return doFindByG_U_C(
358                            groupId, userId, classNameId, queryDefinition, true);
359            }
360    
361            public List<JournalArticle> filterFindByG_C_S(
362                            long groupId, long classNameId, String structureId,
363                            QueryDefinition queryDefinition)
364                    throws SystemException {
365    
366                    return doFindByG_C_S(
367                            groupId, classNameId, structureId, queryDefinition, true);
368            }
369    
370            public List<JournalArticle> filterFindByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
371                            long companyId, long groupId, List<Long> folderIds,
372                            long classNameId, String articleId, Double version, String title,
373                            String description, String content, String type, String structureId,
374                            String templateId, Date displayDateGT, Date displayDateLT,
375                            Date reviewDate, boolean andOperator,
376                            QueryDefinition queryDefinition)
377                    throws SystemException {
378    
379                    String[] structureIds = CustomSQLUtil.keywords(structureId, false);
380                    String[] templateIds = CustomSQLUtil.keywords(templateId, false);
381    
382                    return filterFindByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
383                            companyId, groupId, folderIds, classNameId, articleId, version,
384                            title, description, content, type, structureIds, templateIds,
385                            displayDateGT, displayDateLT, reviewDate, andOperator,
386                            queryDefinition);
387            }
388    
389            public List<JournalArticle> filterFindByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
390                            long companyId, long groupId, List<Long> folderIds,
391                            long classNameId, String articleId, Double version, String title,
392                            String description, String content, String type,
393                            String[] structureIds, String[] templateIds, Date displayDateGT,
394                            Date displayDateLT, Date reviewDate, boolean andOperator,
395                            QueryDefinition queryDefinition)
396                    throws SystemException {
397    
398                    String[] articleIds = CustomSQLUtil.keywords(articleId, false);
399                    String[] titles = CustomSQLUtil.keywords(title);
400                    String[] descriptions = CustomSQLUtil.keywords(description, false);
401                    String[] contents = CustomSQLUtil.keywords(content, false);
402    
403                    return filterFindByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
404                            companyId, groupId, folderIds, classNameId, articleIds, version,
405                            titles, descriptions, contents, type, structureIds, templateIds,
406                            displayDateGT, displayDateLT, reviewDate, andOperator,
407                            queryDefinition);
408            }
409    
410            public List<JournalArticle> filterFindByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
411                            long companyId, long groupId, List<Long> folderIds,
412                            long classNameId, String[] articleIds, Double version,
413                            String[] titles, String[] descriptions, String[] contents,
414                            String type, String[] structureIds, String[] templateIds,
415                            Date displayDateGT, Date displayDateLT, Date reviewDate,
416                            boolean andOperator, QueryDefinition queryDefinition)
417                    throws SystemException {
418    
419                    return doFindByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
420                            companyId, groupId, folderIds, classNameId, articleIds, version,
421                            titles, descriptions, contents, type, structureIds, templateIds,
422                            displayDateGT, displayDateLT, reviewDate, andOperator,
423                            queryDefinition, true);
424            }
425    
426            public List<JournalArticle> findByExpirationDate(
427                            long classNameId, int status, Date expirationDateLT)
428                    throws SystemException {
429    
430                    Timestamp expirationDateLT_TS = CalendarUtil.getTimestamp(
431                            expirationDateLT);
432    
433                    Session session = null;
434    
435                    try {
436                            session = openSession();
437    
438                            String sql = CustomSQLUtil.get(FIND_BY_EXPIRATION_DATE);
439    
440                            if (status == WorkflowConstants.STATUS_ANY) {
441                                    sql = StringUtil.replace(
442                                            sql, "(status = ?) AND", StringPool.BLANK);
443                            }
444    
445                            SQLQuery q = session.createSQLQuery(sql);
446    
447                            q.addEntity("JournalArticle", JournalArticleImpl.class);
448    
449                            QueryPos qPos = QueryPos.getInstance(q);
450    
451                            qPos.add(classNameId);
452    
453                            if (status != WorkflowConstants.STATUS_ANY) {
454                                    qPos.add(status);
455                            }
456    
457                            qPos.add(expirationDateLT_TS);
458    
459                            return q.list(true);
460                    }
461                    catch (Exception e) {
462                            throw new SystemException(e);
463                    }
464                    finally {
465                            closeSession(session);
466                    }
467            }
468    
469            public List<JournalArticle> findByKeywords(
470                            long companyId, long groupId, List<Long> folderIds,
471                            long classNameId, String keywords, Double version, String type,
472                            String structureId, String templateId, Date displayDateGT,
473                            Date displayDateLT, int status, Date reviewDate, int start, int end,
474                            OrderByComparator orderByComparator)
475                    throws SystemException {
476    
477                    String[] articleIds = null;
478                    String[] titles = null;
479                    String[] descriptions = null;
480                    String[] contents = null;
481                    String[] structureIds = CustomSQLUtil.keywords(structureId, false);
482                    String[] templateIds = CustomSQLUtil.keywords(templateId, false);
483                    boolean andOperator = false;
484    
485                    if (Validator.isNotNull(keywords)) {
486                            articleIds = CustomSQLUtil.keywords(keywords, false);
487                            titles = CustomSQLUtil.keywords(keywords);
488                            descriptions = CustomSQLUtil.keywords(keywords, false);
489                            contents = CustomSQLUtil.keywords(keywords, false);
490                    }
491                    else {
492                            andOperator = true;
493                    }
494    
495                    QueryDefinition queryDefinition = new QueryDefinition(
496                            status, start, end, orderByComparator);
497    
498                    return findByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
499                            companyId, groupId, folderIds, classNameId, articleIds, version,
500                            titles, descriptions, contents, type, structureIds, templateIds,
501                            displayDateGT, displayDateLT, reviewDate, andOperator,
502                            queryDefinition);
503            }
504    
505            public List<JournalArticle> findByReviewDate(
506                            long classNameId, Date reviewDateLT, Date reviewDateGT)
507                    throws SystemException {
508    
509                    Timestamp reviewDateLT_TS = CalendarUtil.getTimestamp(reviewDateLT);
510                    Timestamp reviewDateGT_TS = CalendarUtil.getTimestamp(reviewDateGT);
511    
512                    Session session = null;
513                    try {
514                            session = openSession();
515    
516                            String sql = CustomSQLUtil.get(FIND_BY_REVIEW_DATE);
517    
518                            SQLQuery q = session.createSQLQuery(sql);
519    
520                            q.addEntity("JournalArticle", JournalArticleImpl.class);
521    
522                            QueryPos qPos = QueryPos.getInstance(q);
523    
524                            qPos.add(classNameId);
525                            qPos.add(reviewDateGT_TS);
526                            qPos.add(reviewDateLT_TS);
527    
528                            return q.list(true);
529                    }
530                    catch (Exception e) {
531                            throw new SystemException(e);
532                    }
533                    finally {
534                            closeSession(session);
535                    }
536            }
537    
538            public JournalArticle findByR_D(long resourcePrimKey, Date displayDate)
539                    throws NoSuchArticleException, SystemException {
540    
541                    Timestamp displayDate_TS = CalendarUtil.getTimestamp(displayDate);
542    
543                    Session session = null;
544    
545                    try {
546                            session = openSession();
547    
548                            String sql = CustomSQLUtil.get(FIND_BY_R_D);
549    
550                            SQLQuery q = session.createSQLQuery(sql);
551    
552                            q.addEntity("JournalArticle", JournalArticleImpl.class);
553    
554                            QueryPos qPos = QueryPos.getInstance(q);
555    
556                            qPos.add(resourcePrimKey);
557                            qPos.add(displayDate_TS);
558    
559                            List<JournalArticle> articles = q.list();
560    
561                            if (!articles.isEmpty()) {
562                                    return articles.get(0);
563                            }
564                    }
565                    catch (Exception e) {
566                            throw new SystemException(e);
567                    }
568                    finally {
569                            closeSession(session);
570                    }
571    
572                    StringBundler sb = new StringBundler(6);
573    
574                    sb.append("No JournalArticle exists with the key ");
575                    sb.append("{resourcePrimKey=");
576                    sb.append(resourcePrimKey);
577                    sb.append(", displayDate=");
578                    sb.append(displayDate);
579                    sb.append("}");
580    
581                    throw new NoSuchArticleException(sb.toString());
582            }
583    
584            public List<JournalArticle> findByG_U_C(
585                            long groupId, long userId, long classNameId,
586                            QueryDefinition queryDefinition)
587                    throws SystemException {
588    
589                    return doFindByG_U_C(
590                            groupId, userId, classNameId, queryDefinition, false);
591            }
592    
593            public List<JournalArticle> findByG_C_S(
594                            long groupId, long classNameId, String structureId,
595                            QueryDefinition queryDefinition)
596                    throws SystemException {
597    
598                    return doFindByG_C_S(
599                            groupId, classNameId, structureId, queryDefinition, false);
600            }
601    
602            public List<JournalArticle> findByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
603                            long companyId, long groupId, List<Long> folderIds,
604                            long classNameId, String articleId, Double version, String title,
605                            String description, String content, String type, String structureId,
606                            String templateId, Date displayDateGT, Date displayDateLT,
607                            Date reviewDate, boolean andOperator,
608                            QueryDefinition queryDefinition)
609                    throws SystemException {
610    
611                    String[] articleIds = CustomSQLUtil.keywords(articleId, false);
612                    String[] titles = CustomSQLUtil.keywords(title);
613                    String[] descriptions = CustomSQLUtil.keywords(description, false);
614                    String[] contents = CustomSQLUtil.keywords(content, false);
615                    String[] structureIds = CustomSQLUtil.keywords(structureId, false);
616                    String[] templateIds = CustomSQLUtil.keywords(templateId, false);
617    
618                    return findByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
619                            companyId, groupId, folderIds, classNameId, articleIds, version,
620                            titles, descriptions, contents, type, structureIds, templateIds,
621                            displayDateGT, displayDateLT, reviewDate, andOperator,
622                            queryDefinition);
623            }
624    
625            public List<JournalArticle> findByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
626                            long companyId, long groupId, List<Long> folderIds,
627                            long classNameId, String articleId, Double version, String title,
628                            String description, String content, String type,
629                            String[] structureIds, String[] templateIds, Date displayDateGT,
630                            Date displayDateLT, Date reviewDate, boolean andOperator,
631                            QueryDefinition queryDefinition)
632                    throws SystemException {
633    
634                    String[] articleIds = CustomSQLUtil.keywords(articleId, false);
635                    String[] titles = CustomSQLUtil.keywords(title);
636                    String[] descriptions = CustomSQLUtil.keywords(description, false);
637                    String[] contents = CustomSQLUtil.keywords(content, false);
638    
639                    return findByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
640                            companyId, groupId, folderIds, classNameId, articleIds, version,
641                            titles, descriptions, contents, type, structureIds, templateIds,
642                            displayDateGT, displayDateLT, reviewDate, andOperator,
643                            queryDefinition);
644            }
645    
646            public List<JournalArticle> findByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
647                            long companyId, long groupId, List<Long> folderIds,
648                            long classNameId, String[] articleIds, Double version,
649                            String[] titles, String[] descriptions, String[] contents,
650                            String type, String[] structureIds, String[] templateIds,
651                            Date displayDateGT, Date displayDateLT, Date reviewDate,
652                            boolean andOperator, QueryDefinition queryDefinition)
653                    throws SystemException {
654    
655                    return doFindByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
656                            companyId, groupId, folderIds, classNameId, articleIds, version,
657                            titles, descriptions, contents, type, structureIds, templateIds,
658                            displayDateGT, displayDateLT, reviewDate, andOperator,
659                            queryDefinition, false);
660            }
661    
662            protected int doCountByG_F(
663                            long groupId, List<Long> folderIds, QueryDefinition queryDefinition,
664                            boolean inlineSQLHelper)
665                    throws SystemException {
666    
667                    Session session = null;
668    
669                    try {
670                            session = openSession();
671    
672                            String table = "JournalArticle";
673    
674                            String sql = CustomSQLUtil.get(COUNT_BY_G_F, queryDefinition);
675    
676                            if (inlineSQLHelper) {
677                                    sql = InlineSQLHelperUtil.replacePermissionCheck(
678                                            sql, JournalArticle.class.getName(),
679                                            "JournalArticle.resourcePrimKey", groupId);
680                            }
681    
682                            sql = StringUtil.replace(
683                                    sql, "[$FOLDER_ID$]", getFolderIds(folderIds, table));
684    
685                            SQLQuery q = session.createSQLQuery(sql);
686    
687                            q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
688    
689                            QueryPos qPos = QueryPos.getInstance(q);
690    
691                            qPos.add(groupId);
692                            qPos.add(queryDefinition.getStatus());
693    
694                            for (int i = 0; i < folderIds.size(); i++) {
695                                    Long folderId = folderIds.get(i);
696    
697                                    qPos.add(folderId);
698                            }
699    
700                            Iterator<Long> itr = q.iterate();
701    
702                            if (itr.hasNext()) {
703                                    Long count = itr.next();
704    
705                                    if (count != null) {
706                                            return count.intValue();
707                                    }
708                            }
709    
710                            return 0;
711                    }
712                    catch (Exception e) {
713                            throw new SystemException(e);
714                    }
715                    finally {
716                            closeSession(session);
717                    }
718            }
719    
720            protected int doCountByG_U_C(
721                            long groupId, long userId, long classNameId,
722                            QueryDefinition queryDefinition, boolean inlineSQLHelper)
723                    throws SystemException {
724    
725                    Session session = null;
726    
727                    try {
728                            session = openSession();
729    
730                            String sql = CustomSQLUtil.get(COUNT_BY_G_U_C, queryDefinition);
731    
732                            if (inlineSQLHelper) {
733                                    sql = InlineSQLHelperUtil.replacePermissionCheck(
734                                            sql, JournalArticle.class.getName(),
735                                            "JournalArticle.resourcePrimKey", groupId);
736                            }
737    
738                            SQLQuery q = session.createSQLQuery(sql);
739    
740                            q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
741    
742                            QueryPos qPos = QueryPos.getInstance(q);
743    
744                            qPos.add(groupId);
745                            qPos.add(classNameId);
746                            qPos.add(userId);
747                            qPos.add(queryDefinition.getStatus());
748    
749                            Iterator<Long> itr = q.iterate();
750    
751                            if (itr.hasNext()) {
752                                    Long count = itr.next();
753    
754                                    if (count != null) {
755                                            return count.intValue();
756                                    }
757                            }
758    
759                            return 0;
760                    }
761                    catch (Exception e) {
762                            throw new SystemException(e);
763                    }
764                    finally {
765                            closeSession(session);
766                    }
767            }
768    
769            protected int doCountByG_C_S(
770                            long groupId, long classNameId, String structureId,
771                            QueryDefinition queryDefinition, boolean inlineSQLHelper)
772                    throws SystemException {
773    
774                    Session session = null;
775    
776                    try {
777                            session = openSession();
778    
779                            String sql = CustomSQLUtil.get(COUNT_BY_G_C_S, queryDefinition);
780    
781                            if (structureId.equals(
782                                            String.valueOf(
783                                                    JournalArticleConstants.CLASSNAME_ID_DEFAULT))) {
784    
785                                    sql = StringUtil.replace(
786                                            sql, "(structureId = ?)",
787                                            "((structureId = ?) OR (structureId = '') OR" +
788                                                    "(structureId = null))");
789                            }
790    
791                            if (inlineSQLHelper) {
792                                    sql = InlineSQLHelperUtil.replacePermissionCheck(
793                                            sql, JournalArticle.class.getName(),
794                                            "JournalArticle.resourcePrimKey", groupId);
795                            }
796    
797                            SQLQuery q = session.createSQLQuery(sql);
798    
799                            q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
800    
801                            QueryPos qPos = QueryPos.getInstance(q);
802    
803                            qPos.add(groupId);
804                            qPos.add(classNameId);
805                            qPos.add(structureId);
806                            qPos.add(queryDefinition.getStatus());
807    
808                            Iterator<Long> itr = q.iterate();
809    
810                            if (itr.hasNext()) {
811                                    Long count = itr.next();
812    
813                                    if (count != null) {
814                                            return count.intValue();
815                                    }
816                            }
817    
818                            return 0;
819                    }
820                    catch (Exception e) {
821                            throw new SystemException(e);
822                    }
823                    finally {
824                            closeSession(session);
825                    }
826            }
827    
828            protected int doCountByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
829                            long companyId, long groupId, List<Long> folderIds,
830                            long classNameId, String[] articleIds, Double version,
831                            String[] titles, String[] descriptions, String[] contents,
832                            String type, String[] structureIds, String[] templateIds,
833                            Date displayDateGT, Date displayDateLT, Date reviewDate,
834                            boolean andOperator, QueryDefinition queryDefinition,
835                            boolean inlineSQLHelper)
836                    throws SystemException {
837    
838                    articleIds = CustomSQLUtil.keywords(articleIds, false);
839                    titles = CustomSQLUtil.keywords(titles);
840                    descriptions = CustomSQLUtil.keywords(descriptions, false);
841                    contents = CustomSQLUtil.keywords(contents, false);
842                    structureIds = CustomSQLUtil.keywords(structureIds, false);
843                    templateIds = CustomSQLUtil.keywords(templateIds, false);
844                    Timestamp displayDateGT_TS = CalendarUtil.getTimestamp(displayDateGT);
845                    Timestamp displayDateLT_TS = CalendarUtil.getTimestamp(displayDateLT);
846                    Timestamp reviewDate_TS = CalendarUtil.getTimestamp(reviewDate);
847    
848                    Session session = null;
849    
850                    try {
851                            session = openSession();
852    
853                            String sql = CustomSQLUtil.get(
854                                    COUNT_BY_C_G_F_C_A_V_T_D_C_T_S_T_D_R, queryDefinition);
855    
856                            if (groupId <= 0) {
857                                    sql = StringUtil.replace(
858                                            sql, "(groupId = ?) AND", StringPool.BLANK);
859                            }
860    
861                            if (folderIds.isEmpty()) {
862                                    sql = StringUtil.replace(
863                                            sql, "([$FOLDER_ID$]) AND", StringPool.BLANK);
864                            }
865                            else {
866                                    sql = StringUtil.replace(
867                                            sql, "[$FOLDER_ID$]",
868                                            getFolderIds(folderIds, "JournalArticle"));
869                            }
870    
871                            sql = CustomSQLUtil.replaceKeywords(
872                                    sql, "articleId", StringPool.LIKE, false, articleIds);
873    
874                            if ((version == null) || (version <= 0)) {
875                                    sql = StringUtil.replace(
876                                            sql, "(version = ?) [$AND_OR_CONNECTOR$]",
877                                            StringPool.BLANK);
878                            }
879    
880                            sql = CustomSQLUtil.replaceKeywords(
881                                    sql, "lower(title)", StringPool.LIKE, false, titles);
882                            sql = CustomSQLUtil.replaceKeywords(
883                                    sql, "description", StringPool.LIKE, false, descriptions);
884                            sql = CustomSQLUtil.replaceKeywords(
885                                    sql, "content", StringPool.LIKE, false, contents);
886    
887                            if (Validator.isNull(type)) {
888                                    sql = StringUtil.replace(sql, _TYPE_SQL, StringPool.BLANK);
889                            }
890    
891                            if (isNullArray(structureIds)) {
892                                    sql = StringUtil.replace(
893                                            sql, _STRUCTURE_ID_SQL, StringPool.BLANK);
894                            }
895                            else {
896                                    sql = CustomSQLUtil.replaceKeywords(
897                                            sql, "structureId", StringPool.LIKE, false, structureIds);
898                            }
899    
900                            if (isNullArray(templateIds)) {
901                                    sql = StringUtil.replace(
902                                            sql, _TEMPLATE_ID_SQL, StringPool.BLANK);
903                            }
904                            else {
905                                    sql = CustomSQLUtil.replaceKeywords(
906                                            sql, "templateId", StringPool.LIKE, false, templateIds);
907                            }
908    
909                            sql = CustomSQLUtil.replaceAndOperator(sql, andOperator);
910    
911                            if (inlineSQLHelper) {
912                                    sql = InlineSQLHelperUtil.replacePermissionCheck(
913                                            sql, JournalArticle.class.getName(),
914                                            "JournalArticle.resourcePrimKey", groupId);
915    
916                                    sql = StringUtil.replace(
917                                            sql, "(companyId", "(JournalArticle.companyId");
918                            }
919    
920                            SQLQuery q = session.createSQLQuery(sql);
921    
922                            q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
923    
924                            QueryPos qPos = QueryPos.getInstance(q);
925    
926                            qPos.add(companyId);
927    
928                            if (groupId > 0) {
929                                    qPos.add(groupId);
930                            }
931    
932                            for (long folderId : folderIds) {
933                                    qPos.add(folderId);
934                            }
935    
936                            qPos.add(classNameId);
937                            qPos.add(queryDefinition.getStatus());
938                            qPos.add(articleIds, 2);
939    
940                            if ((version != null) && (version > 0)) {
941                                    qPos.add(version);
942                            }
943    
944                            qPos.add(titles, 2);
945                            qPos.add(descriptions, 2);
946                            qPos.add(contents, 2);
947                            qPos.add(displayDateGT_TS);
948                            qPos.add(displayDateGT_TS);
949                            qPos.add(displayDateLT_TS);
950                            qPos.add(displayDateLT_TS);
951                            qPos.add(reviewDate_TS);
952                            qPos.add(reviewDate_TS);
953    
954                            if (Validator.isNotNull(type)) {
955                                    qPos.add(type);
956                                    qPos.add(type);
957                            }
958    
959                            if (!isNullArray(structureIds)) {
960                                    qPos.add(structureIds, 2);
961                            }
962    
963                            if (!isNullArray(templateIds)) {
964                                    qPos.add(templateIds, 2);
965                            }
966    
967                            qPos.add(companyId);
968    
969                            Iterator<Long> itr = q.iterate();
970    
971                            if (itr.hasNext()) {
972                                    Long count = itr.next();
973    
974                                    if (count != null) {
975                                            return count.intValue();
976                                    }
977                            }
978    
979                            return 0;
980                    }
981                    catch (Exception e) {
982                            throw new SystemException(e);
983                    }
984                    finally {
985                            closeSession(session);
986                    }
987            }
988    
989            protected List<JournalArticle> doFindByG_C_S(
990                            long groupId, long classNameId, String structureId,
991                            QueryDefinition queryDefinition, boolean inlineSQLHelper)
992                    throws SystemException {
993    
994                    Session session = null;
995    
996                    try {
997                            session = openSession();
998    
999                            String sql = CustomSQLUtil.get(FIND_BY_G_C_S, queryDefinition);
1000    
1001                            sql = CustomSQLUtil.replaceOrderBy(
1002                                    sql, queryDefinition.getOrderByComparator());
1003    
1004                            if (structureId.equals(
1005                                            String.valueOf(
1006                                                    JournalArticleConstants.CLASSNAME_ID_DEFAULT))) {
1007    
1008                                    sql = StringUtil.replace(
1009                                            sql, "(structureId = ?)",
1010                                            "((structureId = ?) OR (structureId = '') OR" +
1011                                                    "(structureId = null))");
1012                            }
1013    
1014                            if (inlineSQLHelper) {
1015                                    sql = InlineSQLHelperUtil.replacePermissionCheck(
1016                                            sql, JournalArticle.class.getName(),
1017                                            "JournalArticle.resourcePrimKey", groupId);
1018                            }
1019    
1020                            SQLQuery q = session.createSQLQuery(sql);
1021    
1022                            q.addEntity("JournalArticle", JournalArticleImpl.class);
1023    
1024                            QueryPos qPos = QueryPos.getInstance(q);
1025    
1026                            qPos.add(groupId);
1027                            qPos.add(classNameId);
1028                            qPos.add(structureId);
1029                            qPos.add(queryDefinition.getStatus());
1030    
1031                            return (List<JournalArticle>)QueryUtil.list(
1032                                    q, getDialect(), queryDefinition.getStart(),
1033                                    queryDefinition.getEnd());
1034                    }
1035                    catch (Exception e) {
1036                            throw new SystemException(e);
1037                    }
1038                    finally {
1039                            closeSession(session);
1040                    }
1041            }
1042    
1043            protected List<JournalArticle> doFindByG_U_C(
1044                            long groupId, long userId, long classNameId,
1045                            QueryDefinition queryDefinition, boolean inlineSQLHelper)
1046                    throws SystemException {
1047    
1048                    Session session = null;
1049    
1050                    try {
1051                            session = openSession();
1052    
1053                            String sql = CustomSQLUtil.get(FIND_BY_G_U_C, queryDefinition);
1054    
1055                            sql = CustomSQLUtil.replaceOrderBy(
1056                                    sql, queryDefinition.getOrderByComparator());
1057    
1058                            if (inlineSQLHelper) {
1059                                    sql = InlineSQLHelperUtil.replacePermissionCheck(
1060                                            sql, JournalArticle.class.getName(),
1061                                            "JournalArticle.resourcePrimKey", groupId);
1062                            }
1063    
1064                            SQLQuery q = session.createSQLQuery(sql);
1065    
1066                            q.addEntity("JournalArticle", JournalArticleImpl.class);
1067    
1068                            QueryPos qPos = QueryPos.getInstance(q);
1069    
1070                            qPos.add(groupId);
1071                            qPos.add(classNameId);
1072                            qPos.add(userId);
1073                            qPos.add(queryDefinition.getStatus());
1074    
1075                            return (List<JournalArticle>)QueryUtil.list(
1076                                    q, getDialect(), queryDefinition.getStart(),
1077                                    queryDefinition.getEnd());
1078                    }
1079                    catch (Exception e) {
1080                            throw new SystemException(e);
1081                    }
1082                    finally {
1083                            closeSession(session);
1084                    }
1085            }
1086    
1087            protected List<JournalArticle> doFindByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
1088                            long companyId, long groupId, List<Long> folderIds,
1089                            long classNameId, String[] articleIds, Double version,
1090                            String[] titles, String[] descriptions, String[] contents,
1091                            String type, String[] structureIds, String[] templateIds,
1092                            Date displayDateGT, Date displayDateLT, Date reviewDate,
1093                            boolean andOperator, QueryDefinition queryDefinition,
1094                            boolean inlineSQLHelper)
1095                    throws SystemException {
1096    
1097                    articleIds = CustomSQLUtil.keywords(articleIds, false);
1098                    titles = CustomSQLUtil.keywords(titles);
1099                    descriptions = CustomSQLUtil.keywords(descriptions, false);
1100                    contents = CustomSQLUtil.keywords(contents, false);
1101                    structureIds = CustomSQLUtil.keywords(structureIds, false);
1102                    templateIds = CustomSQLUtil.keywords(templateIds, false);
1103                    Timestamp displayDateGT_TS = CalendarUtil.getTimestamp(displayDateGT);
1104                    Timestamp displayDateLT_TS = CalendarUtil.getTimestamp(displayDateLT);
1105                    Timestamp reviewDate_TS = CalendarUtil.getTimestamp(reviewDate);
1106    
1107                    Session session = null;
1108    
1109                    try {
1110                            session = openSession();
1111    
1112                            String sql = CustomSQLUtil.get(
1113                                    FIND_BY_C_G_F_C_A_V_T_D_C_T_S_T_D_R, queryDefinition);
1114    
1115                            if (groupId <= 0) {
1116                                    sql = StringUtil.replace(
1117                                            sql, "(groupId = ?) AND", StringPool.BLANK);
1118                            }
1119    
1120                            if (folderIds.isEmpty()) {
1121                                    sql = StringUtil.replace(
1122                                            sql, "([$FOLDER_ID$]) AND", StringPool.BLANK);
1123                            }
1124                            else {
1125                                    sql = StringUtil.replace(
1126                                            sql, "[$FOLDER_ID$]",
1127                                            getFolderIds(folderIds, "JournalArticle"));
1128                            }
1129    
1130                            sql = CustomSQLUtil.replaceKeywords(
1131                                    sql, "articleId", StringPool.LIKE, false, articleIds);
1132    
1133                            if ((version == null) || (version <= 0)) {
1134                                    sql = StringUtil.replace(
1135                                            sql, "(version = ?) [$AND_OR_CONNECTOR$]",
1136                                            StringPool.BLANK);
1137                            }
1138    
1139                            sql = CustomSQLUtil.replaceKeywords(
1140                                    sql, "lower(title)", StringPool.LIKE, false, titles);
1141                            sql = CustomSQLUtil.replaceKeywords(
1142                                    sql, "description", StringPool.LIKE, false, descriptions);
1143                            sql = CustomSQLUtil.replaceKeywords(
1144                                    sql, "content", StringPool.LIKE, false, contents);
1145    
1146                            if (Validator.isNull(type)) {
1147                                    sql = StringUtil.replace(sql, _TYPE_SQL, StringPool.BLANK);
1148                            }
1149    
1150                            if (isNullArray(structureIds)) {
1151                                    sql = StringUtil.replace(
1152                                            sql, _STRUCTURE_ID_SQL, StringPool.BLANK);
1153                            }
1154                            else {
1155                                    sql = CustomSQLUtil.replaceKeywords(
1156                                            sql, "structureId", StringPool.LIKE, false, structureIds);
1157                            }
1158    
1159                            if (isNullArray(templateIds)) {
1160                                    sql = StringUtil.replace(
1161                                            sql, _TEMPLATE_ID_SQL, StringPool.BLANK);
1162                            }
1163                            else {
1164                                    sql = CustomSQLUtil.replaceKeywords(
1165                                            sql, "templateId", StringPool.LIKE, false, templateIds);
1166                            }
1167    
1168                            sql = CustomSQLUtil.replaceAndOperator(sql, andOperator);
1169                            sql = CustomSQLUtil.replaceOrderBy(
1170                                    sql, queryDefinition.getOrderByComparator());
1171    
1172                            if (inlineSQLHelper) {
1173                                    sql = InlineSQLHelperUtil.replacePermissionCheck(
1174                                            sql, JournalArticle.class.getName(),
1175                                            "JournalArticle.resourcePrimKey", groupId);
1176    
1177                                    sql = StringUtil.replace(
1178                                            sql, "(companyId", "(JournalArticle.companyId");
1179                            }
1180    
1181                            SQLQuery q = session.createSQLQuery(sql);
1182    
1183                            q.addEntity("JournalArticle", JournalArticleImpl.class);
1184    
1185                            QueryPos qPos = QueryPos.getInstance(q);
1186    
1187                            qPos.add(companyId);
1188    
1189                            if (groupId > 0) {
1190                                    qPos.add(groupId);
1191                            }
1192    
1193                            for (long folderId : folderIds) {
1194                                    qPos.add(folderId);
1195                            }
1196    
1197                            qPos.add(classNameId);
1198                            qPos.add(queryDefinition.getStatus());
1199                            qPos.add(articleIds, 2);
1200    
1201                            if ((version != null) && (version > 0)) {
1202                                    qPos.add(version);
1203                            }
1204    
1205                            qPos.add(titles, 2);
1206                            qPos.add(descriptions, 2);
1207                            qPos.add(contents, 2);
1208                            qPos.add(displayDateGT_TS);
1209                            qPos.add(displayDateGT_TS);
1210                            qPos.add(displayDateLT_TS);
1211                            qPos.add(displayDateLT_TS);
1212                            qPos.add(reviewDate_TS);
1213                            qPos.add(reviewDate_TS);
1214    
1215                            if (Validator.isNotNull(type)) {
1216                                    qPos.add(type);
1217                                    qPos.add(type);
1218                            }
1219    
1220                            if (!isNullArray(structureIds)) {
1221                                    qPos.add(structureIds, 2);
1222                            }
1223    
1224                            if (!isNullArray(templateIds)) {
1225                                    qPos.add(templateIds, 2);
1226                            }
1227    
1228                            qPos.add(companyId);
1229    
1230                            return (List<JournalArticle>)QueryUtil.list(
1231                                    q, getDialect(), queryDefinition.getStart(),
1232                                    queryDefinition.getEnd());
1233                    }
1234                    catch (Exception e) {
1235                            throw new SystemException(e);
1236                    }
1237                    finally {
1238                            closeSession(session);
1239                    }
1240            }
1241    
1242            protected String getFolderIds(List<Long> folderIds, String table) {
1243                    if (folderIds.isEmpty()) {
1244                            return StringPool.BLANK;
1245                    }
1246    
1247                    StringBundler sb = new StringBundler(folderIds.size() * 2 - 1);
1248    
1249                    for (int i = 0; i < folderIds.size(); i++) {
1250                            sb.append(table);
1251                            sb.append(".folderId = ? ");
1252    
1253                            if ((i + 1) != folderIds.size()) {
1254                                    sb.append(WHERE_OR);
1255                            }
1256                    }
1257    
1258                    return sb.toString();
1259            }
1260    
1261            protected JournalArticle getLatestArticle(
1262                            long groupId, String articleId, int status)
1263                    throws SystemException {
1264    
1265                    List<JournalArticle> articles = null;
1266    
1267                    if (status == WorkflowConstants.STATUS_ANY) {
1268                            articles = JournalArticleUtil.findByG_A(groupId, articleId, 0, 1);
1269                    }
1270                    else {
1271                            articles = JournalArticleUtil.findByG_A_ST(
1272                                    groupId, articleId, status, 0, 1);
1273                    }
1274    
1275                    if (articles.isEmpty()) {
1276                            return null;
1277                    }
1278    
1279                    return articles.get(0);
1280            }
1281    
1282            protected boolean isNullArray(Object[] array) {
1283                    if ((array == null) || (array.length == 0)) {
1284                            return true;
1285                    }
1286    
1287                    for (Object obj : array) {
1288                            if (Validator.isNotNull(obj)) {
1289                                    return false;
1290                            }
1291                    }
1292    
1293                    return true;
1294            }
1295    
1296            private static final String _STRUCTURE_ID_SQL =
1297                    "(structureId LIKE ? [$AND_OR_NULL_CHECK$]) [$AND_OR_CONNECTOR$]";
1298    
1299            private static final String _TEMPLATE_ID_SQL =
1300                    "(templateId LIKE ? [$AND_OR_NULL_CHECK$]) [$AND_OR_CONNECTOR$]";
1301    
1302            private static final String _TYPE_SQL =
1303                    "(type_ = ? [$AND_OR_NULL_CHECK$]) [$AND_OR_CONNECTOR$]";
1304    
1305    }