001    /**
002     * Copyright (c) 2000-2012 Liferay, Inc. All rights reserved.
003     *
004     * The contents of this file are subject to the terms of the Liferay Enterprise
005     * Subscription License ("License"). You may not use this file except in
006     * compliance with the License. You can obtain a copy of the License by
007     * contacting Liferay, Inc. See the License for the specific language governing
008     * permissions and limitations under the License, including but not limited to
009     * distribution rights of the Software.
010     *
011     *
012     *
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    
580                            if (status == WorkflowConstants.STATUS_ANY) {
581                                    sql = StringUtil.replace(sql, "(status = ?) AND", "");
582                            }
583    
584                            if (Validator.isNull(type)) {
585                                    sql = StringUtil.replace(sql, _TYPE_SQL, StringPool.BLANK);
586                            }
587    
588                            if (isNullArray(structureIds)) {
589                                    sql = StringUtil.replace(
590                                            sql, _STRUCTURE_ID_SQL, StringPool.BLANK);
591                            }
592                            else {
593                                    sql = CustomSQLUtil.replaceKeywords(
594                                            sql, "structureId", StringPool.LIKE, false, structureIds);
595                            }
596    
597                            if (isNullArray(templateIds)) {
598                                    sql = StringUtil.replace(
599                                            sql, _TEMPLATE_ID_SQL, StringPool.BLANK);
600                            }
601                            else {
602                                    sql = CustomSQLUtil.replaceKeywords(
603                                            sql, "templateId", StringPool.LIKE, false, templateIds);
604                            }
605    
606                            sql = CustomSQLUtil.replaceAndOperator(sql, andOperator);
607    
608                            if ((articleIds != null) &&
609                                    ((articleIds.length > 1) ||
610                                     ((articleIds.length == 1) && (articleIds[0] != null))) &&
611                                    (version == null)) {
612    
613                                    sql = StringUtil.replace(
614                                            sql, "MAX(version) AS tempVersion",
615                                            "version AS tempVersion");
616                                    sql = StringUtil.replace(sql, "[$GROUP_BY_CLAUSE$]", "");
617                            }
618                            else {
619                                    sql = StringUtil.replace(
620                                            sql, "[$GROUP_BY_CLAUSE$]", "GROUP BY groupId, articleId");
621                            }
622    
623                            if (inlineSQLHelper) {
624                                    sql = InlineSQLHelperUtil.replacePermissionCheck(
625                                            sql, JournalArticle.class.getName(),
626                                            "JournalArticle.resourcePrimKey", groupId);
627    
628                                    sql = StringUtil.replace(
629                                            sql, "(companyId", "(JournalArticle.companyId");
630                            }
631    
632                            SQLQuery q = session.createSQLQuery(sql);
633    
634                            q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
635    
636                            QueryPos qPos = QueryPos.getInstance(q);
637    
638                            qPos.add(companyId);
639    
640                            if (groupId > 0) {
641                                    qPos.add(groupId);
642                            }
643    
644                            qPos.add(classNameId);
645                            qPos.add(articleIds, 2);
646    
647                            if ((version != null) && (version > 0)) {
648                                    qPos.add(version);
649                            }
650    
651                            qPos.add(titles, 2);
652                            qPos.add(descriptions, 2);
653                            qPos.add(contents, 2);
654                            qPos.add(displayDateGT_TS);
655                            qPos.add(displayDateGT_TS);
656                            qPos.add(displayDateLT_TS);
657                            qPos.add(displayDateLT_TS);
658    
659                            if (status != WorkflowConstants.STATUS_ANY) {
660                                    qPos.add(status);
661                            }
662    
663                            qPos.add(reviewDate_TS);
664                            qPos.add(reviewDate_TS);
665    
666                            if (Validator.isNotNull(type)) {
667                                    qPos.add(type);
668                                    qPos.add(type);
669                            }
670    
671                            if (!isNullArray(structureIds)) {
672                                    qPos.add(structureIds, 2);
673                            }
674    
675                            if (!isNullArray(templateIds)) {
676                                    qPos.add(templateIds, 2);
677                            }
678    
679                            qPos.add(companyId);
680    
681                            Iterator<Long> itr = q.iterate();
682    
683                            if (itr.hasNext()) {
684                                    Long count = itr.next();
685    
686                                    if (count != null) {
687                                            return count.intValue();
688                                    }
689                            }
690    
691                            return 0;
692                    }
693                    catch (Exception e) {
694                            throw new SystemException(e);
695                    }
696                    finally {
697                            closeSession(session);
698                    }
699            }
700    
701            protected List<JournalArticle> doFindByC_G_C_A_V_T_D_C_T_S_T_D_S_R(
702                            long companyId, long groupId, long classNameId, String[] articleIds,
703                            Double version, String[] titles, String[] descriptions,
704                            String[] contents, String type, String[] structureIds,
705                            String[] templateIds, Date displayDateGT, Date displayDateLT,
706                            int status, Date reviewDate, boolean andOperator, int start,
707                            int end, OrderByComparator orderByComparator,
708                            boolean inlineSQLHelper)
709                    throws SystemException {
710    
711                    articleIds = CustomSQLUtil.keywords(articleIds, false);
712                    titles = CustomSQLUtil.keywords(titles);
713                    descriptions = CustomSQLUtil.keywords(descriptions, false);
714                    contents = CustomSQLUtil.keywords(contents, false);
715                    structureIds = CustomSQLUtil.keywords(structureIds, false);
716                    templateIds = CustomSQLUtil.keywords(templateIds, false);
717                    Timestamp displayDateGT_TS = CalendarUtil.getTimestamp(displayDateGT);
718                    Timestamp displayDateLT_TS = CalendarUtil.getTimestamp(displayDateLT);
719                    Timestamp reviewDate_TS = CalendarUtil.getTimestamp(reviewDate);
720    
721                    Session session = null;
722    
723                    try {
724                            session = openSession();
725    
726                            String sql = CustomSQLUtil.get(FIND_BY_C_G_C_A_V_T_D_C_T_S_T_D_S_R);
727    
728                            if (groupId <= 0) {
729                                    sql = StringUtil.replace(sql, "(groupId = ?) AND", "");
730                            }
731    
732                            sql = CustomSQLUtil.replaceKeywords(
733                                    sql, "articleId", StringPool.LIKE, false, articleIds);
734    
735                            if ((version == null) || (version <= 0)) {
736                                    sql = StringUtil.replace(
737                                            sql, "(version = ?) [$AND_OR_CONNECTOR$]", "");
738                            }
739    
740                            sql = CustomSQLUtil.replaceKeywords(
741                                    sql, "lower(title)", StringPool.LIKE, false, titles);
742                            sql = CustomSQLUtil.replaceKeywords(
743                                    sql, "description", StringPool.LIKE, false, descriptions);
744                            sql = CustomSQLUtil.replaceKeywords(
745                                    sql, "content", StringPool.LIKE, false, contents);
746    
747                            if (status == WorkflowConstants.STATUS_ANY) {
748                                    sql = StringUtil.replace(sql, "(status = ?) AND", "");
749                            }
750    
751                            if (Validator.isNull(type)) {
752                                    sql = StringUtil.replace(sql, _TYPE_SQL, StringPool.BLANK);
753                            }
754    
755                            if (isNullArray(structureIds)) {
756                                    sql = StringUtil.replace(
757                                            sql, _STRUCTURE_ID_SQL, StringPool.BLANK);
758                            }
759                            else {
760                                    sql = CustomSQLUtil.replaceKeywords(
761                                            sql, "structureId", StringPool.LIKE, false, structureIds);
762                            }
763    
764                            if (isNullArray(templateIds)) {
765                                    sql = StringUtil.replace(
766                                            sql, _TEMPLATE_ID_SQL, StringPool.BLANK);
767                            }
768                            else {
769                                    sql = CustomSQLUtil.replaceKeywords(
770                                            sql, "templateId", StringPool.LIKE, false, templateIds);
771                            }
772    
773                            sql = CustomSQLUtil.replaceAndOperator(sql, andOperator);
774    
775                            if ((articleIds != null) &&
776                                    ((articleIds.length > 1) ||
777                                     ((articleIds.length == 1) && (articleIds[0] != null))) &&
778                                    (version == null)) {
779    
780                                    sql = StringUtil.replace(
781                                            sql, "MAX(version) AS tempVersion",
782                                            "version AS tempVersion");
783                                    sql = StringUtil.replace(sql, "[$GROUP_BY_CLAUSE$]", "");
784                            }
785                            else {
786                                    sql = StringUtil.replace(
787                                            sql, "[$GROUP_BY_CLAUSE$]", "GROUP BY groupId, articleId");
788                            }
789    
790                            sql = CustomSQLUtil.replaceOrderBy(sql, orderByComparator);
791    
792                            if (inlineSQLHelper) {
793                                    sql = InlineSQLHelperUtil.replacePermissionCheck(
794                                            sql, JournalArticle.class.getName(),
795                                            "JournalArticle.resourcePrimKey", groupId);
796    
797                                    sql = StringUtil.replace(
798                                            sql, "(companyId", "(JournalArticle.companyId");
799                            }
800    
801                            SQLQuery q = session.createSQLQuery(sql);
802    
803                            q.addEntity("JournalArticle", JournalArticleImpl.class);
804    
805                            QueryPos qPos = QueryPos.getInstance(q);
806    
807                            qPos.add(companyId);
808    
809                            if (groupId > 0) {
810                                    qPos.add(groupId);
811                            }
812    
813                            qPos.add(classNameId);
814                            qPos.add(articleIds, 2);
815    
816                            if ((version != null) && (version > 0)) {
817                                    qPos.add(version);
818                            }
819    
820                            qPos.add(titles, 2);
821                            qPos.add(descriptions, 2);
822                            qPos.add(contents, 2);
823                            qPos.add(displayDateGT_TS);
824                            qPos.add(displayDateGT_TS);
825                            qPos.add(displayDateLT_TS);
826                            qPos.add(displayDateLT_TS);
827    
828                            if (status != WorkflowConstants.STATUS_ANY) {
829                                    qPos.add(status);
830                            }
831    
832                            qPos.add(reviewDate_TS);
833                            qPos.add(reviewDate_TS);
834    
835                            if (Validator.isNotNull(type)) {
836                                    qPos.add(type);
837                                    qPos.add(type);
838                            }
839    
840                            if (!isNullArray(structureIds)) {
841                                    qPos.add(structureIds, 2);
842                            }
843    
844                            if (!isNullArray(templateIds)) {
845                                    qPos.add(templateIds, 2);
846                            }
847    
848                            qPos.add(companyId);
849    
850                            return (List<JournalArticle>)QueryUtil.list(
851                                    q, getDialect(), start, end);
852                    }
853                    catch (Exception e) {
854                            throw new SystemException(e);
855                    }
856                    finally {
857                            closeSession(session);
858                    }
859            }
860    
861            protected JournalArticle getLatestArticle(
862                            long groupId, String articleId, int status)
863                    throws SystemException {
864    
865                    List<JournalArticle> articles = null;
866    
867                    if (status == WorkflowConstants.STATUS_ANY) {
868                            articles = JournalArticleUtil.findByG_A(groupId, articleId, 0, 1);
869                    }
870                    else {
871                            articles = JournalArticleUtil.findByG_A_ST(
872                                    groupId, articleId, status, 0, 1);
873                    }
874    
875                    if (articles.isEmpty()) {
876                            return null;
877                    }
878    
879                    return articles.get(0);
880            }
881    
882            protected boolean isNullArray(Object[] array) {
883                    if ((array == null) || (array.length == 0)) {
884                            return true;
885                    }
886    
887                    for (Object obj : array) {
888                            if (Validator.isNotNull(obj)) {
889                                    return false;
890                            }
891                    }
892    
893                    return true;
894            }
895    
896            private static final String _STRUCTURE_ID_SQL =
897                    "(structureId LIKE ? [$AND_OR_NULL_CHECK$]) [$AND_OR_CONNECTOR$]";
898    
899            private static final String _TEMPLATE_ID_SQL =
900                    "(templateId LIKE ? [$AND_OR_NULL_CHECK$]) [$AND_OR_CONNECTOR$]";
901    
902            private static final String _TYPE_SQL =
903                    "(type_ = ? [$AND_OR_NULL_CHECK$]) [$AND_OR_CONNECTOR$]";
904    
905    }