001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.journal.service.persistence.impl;
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.ArrayUtil;
025    import com.liferay.portal.kernel.util.CalendarUtil;
026    import com.liferay.portal.kernel.util.OrderByComparator;
027    import com.liferay.portal.kernel.util.StringBundler;
028    import com.liferay.portal.kernel.util.StringPool;
029    import com.liferay.portal.kernel.util.StringUtil;
030    import com.liferay.portal.kernel.util.Validator;
031    import com.liferay.portal.kernel.workflow.WorkflowConstants;
032    import com.liferay.portal.security.permission.InlineSQLHelperUtil;
033    import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
034    import com.liferay.portlet.journal.NoSuchArticleException;
035    import com.liferay.portlet.journal.model.JournalArticle;
036    import com.liferay.portlet.journal.model.JournalArticleConstants;
037    import com.liferay.portlet.journal.model.impl.JournalArticleImpl;
038    import com.liferay.portlet.journal.service.persistence.JournalArticleFinder;
039    import com.liferay.portlet.journal.service.persistence.JournalArticleUtil;
040    import com.liferay.util.dao.orm.CustomSQLUtil;
041    
042    import java.sql.Timestamp;
043    
044    import java.util.Date;
045    import java.util.Iterator;
046    import java.util.List;
047    
048    /**
049     * @author Brian Wing Shun Chan
050     * @author Raymond Aug??
051     * @author Connor McKay
052     */
053    public class JournalArticleFinderImpl
054            extends BasePersistenceImpl<JournalArticle>
055            implements JournalArticleFinder {
056    
057            public static final String COUNT_BY_G_F =
058                    JournalArticleFinder.class.getName() + ".countByG_F";
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_G_U_F_C =
064                    JournalArticleFinder.class.getName() + ".countByG_U_F_C";
065    
066            public static final String COUNT_BY_C_G_F_C_A_V_T_D_C_T_S_T_D_R =
067                    JournalArticleFinder.class.getName() +
068                            ".countByC_G_F_C_A_V_T_D_C_T_S_T_D_R";
069    
070            public static final String FIND_BY_EXPIRATION_DATE =
071                    JournalArticleFinder.class.getName() + ".findByExpirationDate";
072    
073            public static final String FIND_BY_REVIEW_DATE =
074                    JournalArticleFinder.class.getName() + ".findByReviewDate";
075    
076            public static final String FIND_BY_R_D =
077                    JournalArticleFinder.class.getName() + ".findByR_D";
078    
079            public static final String FIND_BY_G_F =
080                    JournalArticleFinder.class.getName() + ".findByG_F";
081    
082            public static final String FIND_BY_G_C_S =
083                    JournalArticleFinder.class.getName() + ".findByG_C_S";
084    
085            public static final String FIND_BY_G_U_F_C =
086                    JournalArticleFinder.class.getName() + ".findByG_U_F_C";
087    
088            public static final String FIND_BY_C_G_F_C_A_V_T_D_C_T_S_T_D_R =
089                    JournalArticleFinder.class.getName() +
090                            ".findByC_G_F_C_A_V_T_D_C_T_S_T_D_R";
091    
092            @Override
093            public int countByKeywords(
094                    long companyId, long groupId, List<Long> folderIds, long classNameId,
095                    String keywords, Double version, String type, String ddmStructureKey,
096                    String ddmTemplateKey, Date displayDateGT, Date displayDateLT,
097                    int status, Date reviewDate) {
098    
099                    String[] articleIds = null;
100                    String[] titles = null;
101                    String[] descriptions = null;
102                    String[] contents = null;
103                    String[] ddmStructureKeys = CustomSQLUtil.keywords(
104                            ddmStructureKey, false);
105                    String[] ddmTemplateKeys = CustomSQLUtil.keywords(
106                            ddmTemplateKey, false);
107                    boolean andOperator = false;
108    
109                    if (Validator.isNotNull(keywords)) {
110                            articleIds = CustomSQLUtil.keywords(keywords, false);
111                            titles = CustomSQLUtil.keywords(keywords);
112                            descriptions = CustomSQLUtil.keywords(keywords, false);
113                            contents = CustomSQLUtil.keywords(keywords, false);
114                    }
115                    else {
116                            andOperator = true;
117                    }
118    
119                    QueryDefinition<JournalArticle> queryDefinition =
120                            new QueryDefinition<JournalArticle>(status);
121    
122                    return doCountByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
123                            companyId, groupId, folderIds, classNameId, articleIds, version,
124                            titles, descriptions, contents, type, ddmStructureKeys,
125                            ddmTemplateKeys, displayDateGT, displayDateLT, reviewDate,
126                            andOperator, queryDefinition, false);
127            }
128    
129            @Override
130            public int countByG_F(
131                    long groupId, List<Long> folderIds,
132                    QueryDefinition<JournalArticle> queryDefinition) {
133    
134                    return doCountByG_F(groupId, folderIds, queryDefinition, false);
135            }
136    
137            @Override
138            public int countByG_C_S(
139                    long groupId, long classNameId, String ddmStructureKey,
140                    QueryDefinition<JournalArticle> queryDefinition) {
141    
142                    return doCountByG_C_S(
143                            groupId, classNameId, ddmStructureKey, queryDefinition, false);
144            }
145    
146            @Override
147            public int countByG_U_F_C(
148                    long groupId, long userId, List<Long> folderIds, long classNameId,
149                    QueryDefinition<JournalArticle> queryDefinition) {
150    
151                    return doCountByG_U_F_C(
152                            groupId, userId, folderIds, classNameId, queryDefinition, false);
153            }
154    
155            @Override
156            public int countByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
157                    long companyId, long groupId, List<Long> folderIds, long classNameId,
158                    String articleId, Double version, String title, String description,
159                    String content, String type, String ddmStructureKey,
160                    String ddmTemplateKey, Date displayDateGT, Date displayDateLT,
161                    Date reviewDate, boolean andOperator,
162                    QueryDefinition<JournalArticle> queryDefinition) {
163    
164                    String[] ddmStructureKeys = CustomSQLUtil.keywords(
165                            ddmStructureKey, false);
166                    String[] ddmTemplateKeys = CustomSQLUtil.keywords(
167                            ddmTemplateKey, false);
168    
169                    return countByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
170                            companyId, groupId, folderIds, classNameId, articleId, version,
171                            title, description, content, type, ddmStructureKeys,
172                            ddmTemplateKeys, displayDateGT, displayDateLT, reviewDate,
173                            andOperator, queryDefinition);
174            }
175    
176            @Override
177            public int countByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
178                    long companyId, long groupId, List<Long> folderIds, long classNameId,
179                    String articleId, Double version, String title, String description,
180                    String content, String type, String[] ddmStructureKeys,
181                    String[] ddmTemplateKeys, Date displayDateGT, Date displayDateLT,
182                    Date reviewDate, boolean andOperator,
183                    QueryDefinition<JournalArticle> queryDefinition) {
184    
185                    String[] articleIds = CustomSQLUtil.keywords(articleId, false);
186                    String[] titles = CustomSQLUtil.keywords(title);
187                    String[] descriptions = CustomSQLUtil.keywords(description, false);
188                    String[] contents = CustomSQLUtil.keywords(content, false);
189    
190                    return countByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
191                            companyId, groupId, folderIds, classNameId, articleIds, version,
192                            titles, descriptions, contents, type, ddmStructureKeys,
193                            ddmTemplateKeys, displayDateGT, displayDateLT, reviewDate,
194                            andOperator, queryDefinition);
195            }
196    
197            @Override
198            public int countByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
199                    long companyId, long groupId, List<Long> folderIds, long classNameId,
200                    String[] articleIds, Double version, String[] titles,
201                    String[] descriptions, String[] contents, String type,
202                    String[] ddmStructureKeys, String[] ddmTemplateKeys, Date displayDateGT,
203                    Date displayDateLT, Date reviewDate, boolean andOperator,
204                    QueryDefinition<JournalArticle> queryDefinition) {
205    
206                    return doCountByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
207                            companyId, groupId, folderIds, classNameId, articleIds, version,
208                            titles, descriptions, contents, type, ddmStructureKeys,
209                            ddmTemplateKeys, displayDateGT, displayDateLT, reviewDate,
210                            andOperator, queryDefinition, false);
211            }
212    
213            @Override
214            public int filterCountByKeywords(
215                    long companyId, long groupId, List<Long> folderIds, long classNameId,
216                    String keywords, Double version, String type, String ddmStructureKey,
217                    String ddmTemplateKey, Date displayDateGT, Date displayDateLT,
218                    int status, Date reviewDate) {
219    
220                    String[] articleIds = null;
221                    String[] titles = null;
222                    String[] descriptions = null;
223                    String[] contents = null;
224                    String[] ddmStructureKeys = CustomSQLUtil.keywords(
225                            ddmStructureKey, false);
226                    String[] ddmTemplateKeys = CustomSQLUtil.keywords(
227                            ddmTemplateKey, false);
228                    boolean andOperator = false;
229    
230                    if (Validator.isNotNull(keywords)) {
231                            articleIds = CustomSQLUtil.keywords(keywords, false);
232                            titles = CustomSQLUtil.keywords(keywords);
233                            descriptions = CustomSQLUtil.keywords(keywords, false);
234                            contents = CustomSQLUtil.keywords(keywords, false);
235                    }
236                    else {
237                            andOperator = true;
238                    }
239    
240                    QueryDefinition<JournalArticle> queryDefinition =
241                            new QueryDefinition<JournalArticle>(status);
242    
243                    return doCountByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
244                            companyId, groupId, folderIds, classNameId, articleIds, version,
245                            titles, descriptions, contents, type, ddmStructureKeys,
246                            ddmTemplateKeys, displayDateGT, displayDateLT, reviewDate,
247                            andOperator, queryDefinition, true);
248            }
249    
250            @Override
251            public int filterCountByG_F(
252                    long groupId, List<Long> folderIds,
253                    QueryDefinition<JournalArticle> queryDefinition) {
254    
255                    return doCountByG_F(groupId, folderIds, queryDefinition, true);
256            }
257    
258            @Override
259            public int filterCountByG_C_S(
260                    long groupId, long classNameId, String ddmStructureKey,
261                    QueryDefinition<JournalArticle> queryDefinition) {
262    
263                    return doCountByG_C_S(
264                            groupId, classNameId, ddmStructureKey, queryDefinition, true);
265            }
266    
267            @Override
268            public int filterCountByG_U_F_C(
269                    long groupId, long userId, List<Long> folderIds, long classNameId,
270                    QueryDefinition<JournalArticle> queryDefinition) {
271    
272                    return doCountByG_U_F_C(
273                            groupId, userId, folderIds, classNameId, queryDefinition, true);
274            }
275    
276            @Override
277            public int filterCountByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
278                    long companyId, long groupId, List<Long> folderIds, long classNameId,
279                    String articleId, Double version, String title, String description,
280                    String content, String type, String ddmStructureKey,
281                    String ddmTemplateKey, Date displayDateGT, Date displayDateLT,
282                    Date reviewDate, boolean andOperator,
283                    QueryDefinition<JournalArticle> queryDefinition) {
284    
285                    String[] ddmStructureKeys = CustomSQLUtil.keywords(
286                            ddmStructureKey, false);
287                    String[] ddmTemplateKeys = CustomSQLUtil.keywords(
288                            ddmTemplateKey, false);
289    
290                    return filterCountByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
291                            companyId, groupId, folderIds, classNameId, articleId, version,
292                            title, description, content, type, ddmStructureKeys,
293                            ddmTemplateKeys, displayDateGT, displayDateLT, reviewDate,
294                            andOperator, queryDefinition);
295            }
296    
297            @Override
298            public int filterCountByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
299                    long companyId, long groupId, List<Long> folderIds, long classNameId,
300                    String articleId, Double version, String title, String description,
301                    String content, String type, String[] ddmStructureKeys,
302                    String[] ddmTemplateKeys, Date displayDateGT, Date displayDateLT,
303                    Date reviewDate, boolean andOperator,
304                    QueryDefinition<JournalArticle> queryDefinition) {
305    
306                    String[] articleIds = CustomSQLUtil.keywords(articleId, false);
307                    String[] titles = CustomSQLUtil.keywords(title);
308                    String[] descriptions = CustomSQLUtil.keywords(description, false);
309                    String[] contents = CustomSQLUtil.keywords(content, false);
310    
311                    return filterCountByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
312                            companyId, groupId, folderIds, classNameId, articleIds, version,
313                            titles, descriptions, contents, type, ddmStructureKeys,
314                            ddmTemplateKeys, displayDateGT, displayDateLT, reviewDate,
315                            andOperator, queryDefinition);
316            }
317    
318            @Override
319            public int filterCountByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
320                    long companyId, long groupId, List<Long> folderIds, long classNameId,
321                    String[] articleIds, Double version, String[] titles,
322                    String[] descriptions, String[] contents, String type,
323                    String[] ddmStructureKeys, String[] ddmTemplateKeys, Date displayDateGT,
324                    Date displayDateLT, Date reviewDate, boolean andOperator,
325                    QueryDefinition<JournalArticle> queryDefinition) {
326    
327                    return doCountByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
328                            companyId, groupId, folderIds, classNameId, articleIds, version,
329                            titles, descriptions, contents, type, ddmStructureKeys,
330                            ddmTemplateKeys, displayDateGT, displayDateLT, reviewDate,
331                            andOperator, queryDefinition, true);
332            }
333    
334            @Override
335            public List<JournalArticle> filterFindByKeywords(
336                    long companyId, long groupId, List<Long> folderIds, long classNameId,
337                    String keywords, Double version, String type, String ddmStructureKey,
338                    String ddmTemplateKey, Date displayDateGT, Date displayDateLT,
339                    int status, Date reviewDate, int start, int end,
340                    OrderByComparator<JournalArticle> orderByComparator) {
341    
342                    String[] articleIds = null;
343                    String[] titles = null;
344                    String[] descriptions = null;
345                    String[] contents = null;
346                    String[] ddmStructureKeys = CustomSQLUtil.keywords(
347                            ddmStructureKey, false);
348                    String[] ddmTemplateKeys = CustomSQLUtil.keywords(
349                            ddmTemplateKey, false);
350                    boolean andOperator = false;
351    
352                    if (Validator.isNotNull(keywords)) {
353                            articleIds = CustomSQLUtil.keywords(keywords, false);
354                            titles = CustomSQLUtil.keywords(keywords);
355                            descriptions = CustomSQLUtil.keywords(keywords, false);
356                            contents = CustomSQLUtil.keywords(keywords, false);
357                    }
358                    else {
359                            andOperator = true;
360                    }
361    
362                    QueryDefinition<JournalArticle> queryDefinition =
363                            new QueryDefinition<JournalArticle>(
364                                    status, start, end, orderByComparator);
365    
366                    return doFindByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
367                            companyId, groupId, folderIds, classNameId, articleIds, version,
368                            titles, descriptions, contents, type, ddmStructureKeys,
369                            ddmTemplateKeys, displayDateGT, displayDateLT, reviewDate,
370                            andOperator, queryDefinition, true);
371            }
372    
373            @Override
374            public List<JournalArticle> filterFindByG_F(
375                    long groupId, List<Long> folderIds,
376                    QueryDefinition<JournalArticle> queryDefinition) {
377    
378                    return doFindByG_F(groupId, folderIds, queryDefinition, true);
379            }
380    
381            @Override
382            public List<JournalArticle> filterFindByG_C_S(
383                    long groupId, long classNameId, String ddmStructureKey,
384                    QueryDefinition<JournalArticle> queryDefinition) {
385    
386                    return doFindByG_C_S(
387                            groupId, classNameId, ddmStructureKey, queryDefinition, true);
388            }
389    
390            @Override
391            public List<JournalArticle> filterFindByG_U_F_C(
392                    long groupId, long userId, List<Long> folderIds, long classNameId,
393                    QueryDefinition<JournalArticle> queryDefinition) {
394    
395                    return doFindByG_U_F_C(
396                            groupId, userId, folderIds, classNameId, queryDefinition, true);
397            }
398    
399            @Override
400            public List<JournalArticle> filterFindByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
401                    long companyId, long groupId, List<Long> folderIds, long classNameId,
402                    String articleId, Double version, String title, String description,
403                    String content, String type, String ddmStructureKey,
404                    String ddmTemplateKey, Date displayDateGT, Date displayDateLT,
405                    Date reviewDate, boolean andOperator,
406                    QueryDefinition<JournalArticle> queryDefinition) {
407    
408                    String[] ddmStructureKeys = CustomSQLUtil.keywords(
409                            ddmStructureKey, false);
410                    String[] ddmTemplateKeys = CustomSQLUtil.keywords(
411                            ddmTemplateKey, false);
412    
413                    return filterFindByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
414                            companyId, groupId, folderIds, classNameId, articleId, version,
415                            title, description, content, type, ddmStructureKeys,
416                            ddmTemplateKeys, displayDateGT, displayDateLT, reviewDate,
417                            andOperator, queryDefinition);
418            }
419    
420            @Override
421            public List<JournalArticle> filterFindByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
422                    long companyId, long groupId, List<Long> folderIds, long classNameId,
423                    String articleId, Double version, String title, String description,
424                    String content, String type, String[] ddmStructureKeys,
425                    String[] ddmTemplateKeys, Date displayDateGT, Date displayDateLT,
426                    Date reviewDate, boolean andOperator,
427                    QueryDefinition<JournalArticle> queryDefinition) {
428    
429                    String[] articleIds = CustomSQLUtil.keywords(articleId, false);
430                    String[] titles = CustomSQLUtil.keywords(title);
431                    String[] descriptions = CustomSQLUtil.keywords(description, false);
432                    String[] contents = CustomSQLUtil.keywords(content, false);
433    
434                    return filterFindByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
435                            companyId, groupId, folderIds, classNameId, articleIds, version,
436                            titles, descriptions, contents, type, ddmStructureKeys,
437                            ddmTemplateKeys, displayDateGT, displayDateLT, reviewDate,
438                            andOperator, queryDefinition);
439            }
440    
441            @Override
442            public List<JournalArticle> filterFindByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
443                    long companyId, long groupId, List<Long> folderIds, long classNameId,
444                    String[] articleIds, Double version, String[] titles,
445                    String[] descriptions, String[] contents, String type,
446                    String[] ddmStructureKeys, String[] ddmTemplateKeys, Date displayDateGT,
447                    Date displayDateLT, Date reviewDate, boolean andOperator,
448                    QueryDefinition<JournalArticle> queryDefinition) {
449    
450                    return doFindByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
451                            companyId, groupId, folderIds, classNameId, articleIds, version,
452                            titles, descriptions, contents, type, ddmStructureKeys,
453                            ddmTemplateKeys, displayDateGT, displayDateLT, reviewDate,
454                            andOperator, queryDefinition, true);
455            }
456    
457            @Override
458            public List<JournalArticle> findByExpirationDate(
459                    long classNameId, Date expirationDateLT,
460                    QueryDefinition<JournalArticle> queryDefinition) {
461    
462                    Timestamp expirationDateLT_TS = CalendarUtil.getTimestamp(
463                            expirationDateLT);
464    
465                    Session session = null;
466    
467                    try {
468                            session = openSession();
469    
470                            String sql = CustomSQLUtil.get(
471                                    FIND_BY_EXPIRATION_DATE, queryDefinition);
472    
473                            SQLQuery q = session.createSynchronizedSQLQuery(sql);
474    
475                            q.addEntity(
476                                    JournalArticleImpl.TABLE_NAME, JournalArticleImpl.class);
477    
478                            QueryPos qPos = QueryPos.getInstance(q);
479    
480                            qPos.add(classNameId);
481                            qPos.add(queryDefinition.getStatus());
482                            qPos.add(expirationDateLT_TS);
483    
484                            return q.list(true);
485                    }
486                    catch (Exception e) {
487                            throw new SystemException(e);
488                    }
489                    finally {
490                            closeSession(session);
491                    }
492            }
493    
494            @Override
495            public List<JournalArticle> findByKeywords(
496                    long companyId, long groupId, List<Long> folderIds, long classNameId,
497                    String keywords, Double version, String type, String ddmStructureKey,
498                    String ddmTemplateKey, Date displayDateGT, Date displayDateLT,
499                    int status, Date reviewDate, int start, int end,
500                    OrderByComparator<JournalArticle> orderByComparator) {
501    
502                    String[] articleIds = null;
503                    String[] titles = null;
504                    String[] descriptions = null;
505                    String[] contents = null;
506                    String[] ddmStructureKeys = CustomSQLUtil.keywords(
507                            ddmStructureKey, false);
508                    String[] ddmTemplateKeys = CustomSQLUtil.keywords(
509                            ddmTemplateKey, false);
510                    boolean andOperator = false;
511    
512                    if (Validator.isNotNull(keywords)) {
513                            articleIds = CustomSQLUtil.keywords(keywords, false);
514                            titles = CustomSQLUtil.keywords(keywords);
515                            descriptions = CustomSQLUtil.keywords(keywords, false);
516                            contents = CustomSQLUtil.keywords(keywords, false);
517                    }
518                    else {
519                            andOperator = true;
520                    }
521    
522                    QueryDefinition<JournalArticle> queryDefinition =
523                            new QueryDefinition<JournalArticle>(
524                                    status, start, end, orderByComparator);
525    
526                    return findByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
527                            companyId, groupId, folderIds, classNameId, articleIds, version,
528                            titles, descriptions, contents, type, ddmStructureKeys,
529                            ddmTemplateKeys, displayDateGT, displayDateLT, reviewDate,
530                            andOperator, queryDefinition);
531            }
532    
533            @Override
534            public List<JournalArticle> findByReviewDate(
535                    long classNameId, Date reviewDateLT, Date reviewDateGT) {
536    
537                    Timestamp reviewDateLT_TS = CalendarUtil.getTimestamp(reviewDateLT);
538                    Timestamp reviewDateGT_TS = CalendarUtil.getTimestamp(reviewDateGT);
539    
540                    Session session = null;
541                    try {
542                            session = openSession();
543    
544                            String sql = CustomSQLUtil.get(FIND_BY_REVIEW_DATE);
545    
546                            SQLQuery q = session.createSynchronizedSQLQuery(sql);
547    
548                            q.addEntity(
549                                    JournalArticleImpl.TABLE_NAME, JournalArticleImpl.class);
550    
551                            QueryPos qPos = QueryPos.getInstance(q);
552    
553                            qPos.add(classNameId);
554                            qPos.add(reviewDateGT_TS);
555                            qPos.add(reviewDateLT_TS);
556    
557                            return q.list(true);
558                    }
559                    catch (Exception e) {
560                            throw new SystemException(e);
561                    }
562                    finally {
563                            closeSession(session);
564                    }
565            }
566    
567            @Override
568            public JournalArticle findByR_D(long resourcePrimKey, Date displayDate)
569                    throws NoSuchArticleException {
570    
571                    Timestamp displayDate_TS = CalendarUtil.getTimestamp(displayDate);
572    
573                    Session session = null;
574    
575                    try {
576                            session = openSession();
577    
578                            String sql = CustomSQLUtil.get(FIND_BY_R_D);
579    
580                            SQLQuery q = session.createSynchronizedSQLQuery(sql);
581    
582                            q.addEntity(
583                                    JournalArticleImpl.TABLE_NAME, JournalArticleImpl.class);
584    
585                            QueryPos qPos = QueryPos.getInstance(q);
586    
587                            qPos.add(resourcePrimKey);
588                            qPos.add(displayDate_TS);
589    
590                            List<JournalArticle> articles = q.list();
591    
592                            if (!articles.isEmpty()) {
593                                    return articles.get(0);
594                            }
595                    }
596                    catch (Exception e) {
597                            throw new SystemException(e);
598                    }
599                    finally {
600                            closeSession(session);
601                    }
602    
603                    StringBundler sb = new StringBundler(6);
604    
605                    sb.append("No JournalArticle exists with the key ");
606                    sb.append("{resourcePrimKey=");
607                    sb.append(resourcePrimKey);
608                    sb.append(", displayDate=");
609                    sb.append(displayDate);
610                    sb.append("}");
611    
612                    throw new NoSuchArticleException(sb.toString());
613            }
614    
615            @Override
616            public List<JournalArticle> findByG_F(
617                    long groupId, List<Long> folderIds,
618                    QueryDefinition<JournalArticle> queryDefinition) {
619    
620                    return doFindByG_F(groupId, folderIds, queryDefinition, false);
621            }
622    
623            @Override
624            public List<JournalArticle> findByG_C_S(
625                    long groupId, long classNameId, String ddmStructureKey,
626                    QueryDefinition<JournalArticle> queryDefinition) {
627    
628                    return doFindByG_C_S(
629                            groupId, classNameId, ddmStructureKey, queryDefinition, false);
630            }
631    
632            @Override
633            public List<JournalArticle> findByG_U_F_C(
634                    long groupId, long userId, List<Long> folderIds, long classNameId,
635                    QueryDefinition<JournalArticle> queryDefinition) {
636    
637                    return doFindByG_U_F_C(
638                            groupId, userId, folderIds, classNameId, queryDefinition, false);
639            }
640    
641            @Override
642            public List<JournalArticle> findByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
643                    long companyId, long groupId, List<Long> folderIds, long classNameId,
644                    String articleId, Double version, String title, String description,
645                    String content, String type, String ddmStructureKey,
646                    String ddmTemplateKey, Date displayDateGT, Date displayDateLT,
647                    Date reviewDate, boolean andOperator,
648                    QueryDefinition<JournalArticle> queryDefinition) {
649    
650                    String[] articleIds = CustomSQLUtil.keywords(articleId, false);
651                    String[] titles = CustomSQLUtil.keywords(title);
652                    String[] descriptions = CustomSQLUtil.keywords(description, false);
653                    String[] contents = CustomSQLUtil.keywords(content, false);
654                    String[] ddmStructureKeys = CustomSQLUtil.keywords(
655                            ddmStructureKey, false);
656                    String[] ddmTemplateKeys = CustomSQLUtil.keywords(
657                            ddmTemplateKey, false);
658    
659                    return findByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
660                            companyId, groupId, folderIds, classNameId, articleIds, version,
661                            titles, descriptions, contents, type, ddmStructureKeys,
662                            ddmTemplateKeys, displayDateGT, displayDateLT, reviewDate,
663                            andOperator, queryDefinition);
664            }
665    
666            @Override
667            public List<JournalArticle> findByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
668                    long companyId, long groupId, List<Long> folderIds, long classNameId,
669                    String articleId, Double version, String title, String description,
670                    String content, String type, String[] ddmStructureKeys,
671                    String[] ddmTemplateKeys, Date displayDateGT, Date displayDateLT,
672                    Date reviewDate, boolean andOperator,
673                    QueryDefinition<JournalArticle> queryDefinition) {
674    
675                    String[] articleIds = CustomSQLUtil.keywords(articleId, false);
676                    String[] titles = CustomSQLUtil.keywords(title);
677                    String[] descriptions = CustomSQLUtil.keywords(description, false);
678                    String[] contents = CustomSQLUtil.keywords(content, false);
679    
680                    return findByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
681                            companyId, groupId, folderIds, classNameId, articleIds, version,
682                            titles, descriptions, contents, type, ddmStructureKeys,
683                            ddmTemplateKeys, displayDateGT, displayDateLT, reviewDate,
684                            andOperator, queryDefinition);
685            }
686    
687            @Override
688            public List<JournalArticle> findByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
689                    long companyId, long groupId, List<Long> folderIds, long classNameId,
690                    String[] articleIds, Double version, String[] titles,
691                    String[] descriptions, String[] contents, String type,
692                    String[] ddmStructureKeys, String[] ddmTemplateKeys, Date displayDateGT,
693                    Date displayDateLT, Date reviewDate, boolean andOperator,
694                    QueryDefinition<JournalArticle> queryDefinition) {
695    
696                    return doFindByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
697                            companyId, groupId, folderIds, classNameId, articleIds, version,
698                            titles, descriptions, contents, type, ddmStructureKeys,
699                            ddmTemplateKeys, displayDateGT, displayDateLT, reviewDate,
700                            andOperator, queryDefinition, false);
701            }
702    
703            protected int doCountByG_F(
704                    long groupId, List<Long> folderIds,
705                    QueryDefinition<JournalArticle> queryDefinition,
706                    boolean inlineSQLHelper) {
707    
708                    Session session = null;
709    
710                    try {
711                            session = openSession();
712    
713                            String sql = CustomSQLUtil.get(
714                                    COUNT_BY_G_F, queryDefinition, "JournalArticle");
715    
716                            sql = replaceStatusJoin(sql, queryDefinition);
717    
718                            if (inlineSQLHelper) {
719                                    sql = InlineSQLHelperUtil.replacePermissionCheck(
720                                            sql, JournalArticle.class.getName(),
721                                            "JournalArticle.resourcePrimKey", groupId);
722                            }
723    
724                            sql = StringUtil.replace(
725                                    sql, "[$FOLDER_ID$]",
726                                    getFolderIds(folderIds, JournalArticleImpl.TABLE_NAME));
727    
728                            SQLQuery q = session.createSynchronizedSQLQuery(sql);
729    
730                            q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
731    
732                            QueryPos qPos = QueryPos.getInstance(q);
733    
734                            qPos.add(groupId);
735                            qPos.add(queryDefinition.getStatus());
736    
737                            for (int i = 0; i < folderIds.size(); i++) {
738                                    Long folderId = folderIds.get(i);
739    
740                                    qPos.add(folderId);
741                            }
742    
743                            Iterator<Long> itr = q.iterate();
744    
745                            if (itr.hasNext()) {
746                                    Long count = itr.next();
747    
748                                    if (count != null) {
749                                            return count.intValue();
750                                    }
751                            }
752    
753                            return 0;
754                    }
755                    catch (Exception e) {
756                            throw new SystemException(e);
757                    }
758                    finally {
759                            closeSession(session);
760                    }
761            }
762    
763            protected int doCountByG_C_S(
764                    long groupId, long classNameId, String ddmStructureKey,
765                    QueryDefinition<JournalArticle> queryDefinition,
766                    boolean inlineSQLHelper) {
767    
768                    Session session = null;
769    
770                    try {
771                            session = openSession();
772    
773                            String sql = CustomSQLUtil.get(
774                                    COUNT_BY_G_C_S, queryDefinition, "JournalArticle");
775    
776                            if (groupId <= 0) {
777                                    sql = StringUtil.replace(
778                                            sql, "(groupId = ?) AND", StringPool.BLANK);
779                            }
780    
781                            if (ddmStructureKey.equals(
782                                            String.valueOf(
783                                                    JournalArticleConstants.CLASSNAME_ID_DEFAULT))) {
784    
785                                    sql = StringUtil.replace(
786                                            sql, "(structureId = ?)",
787                                            "((structureId = ?) OR (structureId = '') OR " +
788                                                    "(structureId IS 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.createSynchronizedSQLQuery(sql);
798    
799                            q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
800    
801                            QueryPos qPos = QueryPos.getInstance(q);
802    
803                            if (groupId > 0) {
804                                    qPos.add(groupId);
805                            }
806    
807                            qPos.add(classNameId);
808                            qPos.add(ddmStructureKey);
809                            qPos.add(queryDefinition.getStatus());
810    
811                            Iterator<Long> itr = q.iterate();
812    
813                            if (itr.hasNext()) {
814                                    Long count = itr.next();
815    
816                                    if (count != null) {
817                                            return count.intValue();
818                                    }
819                            }
820    
821                            return 0;
822                    }
823                    catch (Exception e) {
824                            throw new SystemException(e);
825                    }
826                    finally {
827                            closeSession(session);
828                    }
829            }
830    
831            protected int doCountByG_U_F_C(
832                    long groupId, long userId, List<Long> folderIds, long classNameId,
833                    QueryDefinition<JournalArticle> queryDefinition,
834                    boolean inlineSQLHelper) {
835    
836                    Session session = null;
837    
838                    try {
839                            session = openSession();
840    
841                            String sql = CustomSQLUtil.get(
842                                    COUNT_BY_G_U_F_C, queryDefinition, "JournalArticle");
843    
844                            sql = replaceStatusJoin(sql, queryDefinition);
845    
846                            if (folderIds.isEmpty()) {
847                                    sql = StringUtil.replace(
848                                            sql, "([$FOLDER_ID$]) AND", StringPool.BLANK);
849                            }
850                            else {
851                                    sql = StringUtil.replace(
852                                            sql, "[$FOLDER_ID$]",
853                                            getFolderIds(folderIds, JournalArticleImpl.TABLE_NAME));
854                            }
855    
856                            if (userId <= 0) {
857                                    sql = StringUtil.replace(
858                                            sql, "(JournalArticle.userId = ?) AND", StringPool.BLANK);
859                            }
860    
861                            if (inlineSQLHelper) {
862                                    sql = InlineSQLHelperUtil.replacePermissionCheck(
863                                            sql, JournalArticle.class.getName(),
864                                            "JournalArticle.resourcePrimKey", groupId);
865                            }
866    
867                            SQLQuery q = session.createSynchronizedSQLQuery(sql);
868    
869                            q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
870    
871                            QueryPos qPos = QueryPos.getInstance(q);
872    
873                            qPos.add(groupId);
874                            qPos.add(classNameId);
875    
876                            if (userId > 0) {
877                                    qPos.add(userId);
878                            }
879    
880                            for (long folderId : folderIds) {
881                                    qPos.add(folderId);
882                            }
883    
884                            qPos.add(queryDefinition.getStatus());
885    
886                            Iterator<Long> itr = q.iterate();
887    
888                            if (itr.hasNext()) {
889                                    Long count = itr.next();
890    
891                                    if (count != null) {
892                                            return count.intValue();
893                                    }
894                            }
895    
896                            return 0;
897                    }
898                    catch (Exception e) {
899                            throw new SystemException(e);
900                    }
901                    finally {
902                            closeSession(session);
903                    }
904            }
905    
906            protected int doCountByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
907                    long companyId, long groupId, List<Long> folderIds, long classNameId,
908                    String[] articleIds, Double version, String[] titles,
909                    String[] descriptions, String[] contents, String type,
910                    String[] ddmStructureKeys, String[] ddmTemplateKeys, Date displayDateGT,
911                    Date displayDateLT, Date reviewDate, boolean andOperator,
912                    QueryDefinition<JournalArticle> queryDefinition,
913                    boolean inlineSQLHelper) {
914    
915                    articleIds = CustomSQLUtil.keywords(articleIds, false);
916                    titles = CustomSQLUtil.keywords(titles);
917                    descriptions = CustomSQLUtil.keywords(descriptions, false);
918                    contents = CustomSQLUtil.keywords(contents, false);
919                    ddmStructureKeys = CustomSQLUtil.keywords(ddmStructureKeys, false);
920                    ddmTemplateKeys = CustomSQLUtil.keywords(ddmTemplateKeys, false);
921                    Timestamp displayDateGT_TS = CalendarUtil.getTimestamp(displayDateGT);
922                    Timestamp displayDateLT_TS = CalendarUtil.getTimestamp(displayDateLT);
923                    Timestamp reviewDate_TS = CalendarUtil.getTimestamp(reviewDate);
924    
925                    Session session = null;
926    
927                    try {
928                            session = openSession();
929    
930                            String sql = CustomSQLUtil.get(
931                                    COUNT_BY_C_G_F_C_A_V_T_D_C_T_S_T_D_R, queryDefinition,
932                                    "JournalArticle");
933    
934                            sql = replaceStatusJoin(sql, queryDefinition);
935    
936                            if (groupId <= 0) {
937                                    sql = StringUtil.replace(
938                                            sql, "(JournalArticle.groupId = ?) AND", StringPool.BLANK);
939                            }
940    
941                            if (folderIds.isEmpty()) {
942                                    sql = StringUtil.replace(
943                                            sql, "([$FOLDER_ID$]) AND", StringPool.BLANK);
944                            }
945                            else {
946                                    sql = StringUtil.replace(
947                                            sql, "[$FOLDER_ID$]",
948                                            getFolderIds(folderIds, JournalArticleImpl.TABLE_NAME));
949                            }
950    
951                            sql = CustomSQLUtil.replaceKeywords(
952                                    sql, "JournalArticle.articleId", StringPool.LIKE, false,
953                                    articleIds);
954    
955                            if ((version == null) || (version <= 0)) {
956                                    sql = StringUtil.replace(
957                                            sql, "(JournalArticle.version = ?) [$AND_OR_CONNECTOR$]",
958                                            StringPool.BLANK);
959                            }
960    
961                            sql = CustomSQLUtil.replaceKeywords(
962                                    sql, "lower(JournalArticle.title)", StringPool.LIKE, false,
963                                    titles);
964                            sql = CustomSQLUtil.replaceKeywords(
965                                    sql, "JournalArticle.description", StringPool.LIKE, false,
966                                    descriptions);
967                            sql = CustomSQLUtil.replaceKeywords(
968                                    sql, "JournalArticle.content", StringPool.LIKE, false,
969                                    contents);
970    
971                            sql = replaceTypeStructureTemplate(
972                                    sql, type, ddmStructureKeys, ddmTemplateKeys);
973    
974                            if (!isNullArray(ddmStructureKeys)) {
975                                    sql = CustomSQLUtil.replaceKeywords(
976                                            sql, "JournalArticle.structureId", StringPool.LIKE, false,
977                                            ddmStructureKeys);
978                            }
979    
980                            if (!isNullArray(ddmTemplateKeys)) {
981                                    sql = CustomSQLUtil.replaceKeywords(
982                                            sql, "JournalArticle.templateId", StringPool.LIKE, false,
983                                            ddmTemplateKeys);
984                            }
985    
986                            sql = CustomSQLUtil.replaceAndOperator(sql, andOperator);
987    
988                            if (inlineSQLHelper) {
989                                    sql = InlineSQLHelperUtil.replacePermissionCheck(
990                                            sql, JournalArticle.class.getName(),
991                                            "JournalArticle.resourcePrimKey", groupId);
992    
993                                    sql = StringUtil.replace(
994                                            sql, "(companyId", "(JournalArticle.companyId");
995                            }
996    
997                            SQLQuery q = session.createSynchronizedSQLQuery(sql);
998    
999                            q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
1000    
1001                            QueryPos qPos = QueryPos.getInstance(q);
1002    
1003                            qPos.add(companyId);
1004    
1005                            if (groupId > 0) {
1006                                    qPos.add(groupId);
1007                            }
1008    
1009                            for (long folderId : folderIds) {
1010                                    qPos.add(folderId);
1011                            }
1012    
1013                            qPos.add(classNameId);
1014                            qPos.add(queryDefinition.getStatus());
1015    
1016                            if (Validator.isNotNull(type)) {
1017                                    qPos.add(type);
1018                                    qPos.add(type);
1019                            }
1020    
1021                            if (!isNullArray(ddmStructureKeys)) {
1022                                    qPos.add(ddmStructureKeys, 2);
1023                            }
1024    
1025                            if (!isNullArray(ddmTemplateKeys)) {
1026                                    qPos.add(ddmTemplateKeys, 2);
1027                            }
1028    
1029                            qPos.add(articleIds, 2);
1030    
1031                            if ((version != null) && (version > 0)) {
1032                                    qPos.add(version);
1033                            }
1034    
1035                            qPos.add(titles, 2);
1036                            qPos.add(descriptions, 2);
1037                            qPos.add(contents, 2);
1038                            qPos.add(displayDateGT_TS);
1039                            qPos.add(displayDateGT_TS);
1040                            qPos.add(displayDateLT_TS);
1041                            qPos.add(displayDateLT_TS);
1042                            qPos.add(reviewDate_TS);
1043                            qPos.add(reviewDate_TS);
1044    
1045                            Iterator<Long> itr = q.iterate();
1046    
1047                            if (itr.hasNext()) {
1048                                    Long count = itr.next();
1049    
1050                                    if (count != null) {
1051                                            return count.intValue();
1052                                    }
1053                            }
1054    
1055                            return 0;
1056                    }
1057                    catch (Exception e) {
1058                            throw new SystemException(e);
1059                    }
1060                    finally {
1061                            closeSession(session);
1062                    }
1063            }
1064    
1065            protected List<JournalArticle> doFindByG_F(
1066                    long groupId, List<Long> folderIds,
1067                    QueryDefinition<JournalArticle> queryDefinition,
1068                    boolean inlineSQLHelper) {
1069    
1070                    Session session = null;
1071    
1072                    try {
1073                            session = openSession();
1074    
1075                            String sql = CustomSQLUtil.get(
1076                                    FIND_BY_G_F, queryDefinition, "JournalArticle");
1077    
1078                            sql = replaceStatusJoin(sql, queryDefinition);
1079    
1080                            sql = CustomSQLUtil.replaceOrderBy(
1081                                    sql, queryDefinition.getOrderByComparator("JournalArticle"));
1082    
1083                            if (inlineSQLHelper) {
1084                                    sql = InlineSQLHelperUtil.replacePermissionCheck(
1085                                            sql, JournalArticle.class.getName(),
1086                                            "JournalArticle.resourcePrimKey", groupId);
1087                            }
1088    
1089                            sql = StringUtil.replace(
1090                                    sql, "[$FOLDER_ID$]",
1091                                    getFolderIds(folderIds, JournalArticleImpl.TABLE_NAME));
1092    
1093                            SQLQuery q = session.createSynchronizedSQLQuery(sql);
1094    
1095                            q.addEntity(
1096                                    JournalArticleImpl.TABLE_NAME, JournalArticleImpl.class);
1097    
1098                            QueryPos qPos = QueryPos.getInstance(q);
1099    
1100                            qPos.add(groupId);
1101                            qPos.add(queryDefinition.getStatus());
1102    
1103                            for (int i = 0; i < folderIds.size(); i++) {
1104                                    Long folderId = folderIds.get(i);
1105    
1106                                    qPos.add(folderId);
1107                            }
1108    
1109                            return (List<JournalArticle>)QueryUtil.list(
1110                                    q, getDialect(), queryDefinition.getStart(),
1111                                    queryDefinition.getEnd());
1112                    }
1113                    catch (Exception e) {
1114                            throw new SystemException(e);
1115                    }
1116                    finally {
1117                            closeSession(session);
1118                    }
1119            }
1120    
1121            protected List<JournalArticle> doFindByG_C_S(
1122                    long groupId, long classNameId, String ddmStructureKey,
1123                    QueryDefinition<JournalArticle> queryDefinition,
1124                    boolean inlineSQLHelper) {
1125    
1126                    Session session = null;
1127    
1128                    try {
1129                            session = openSession();
1130    
1131                            String sql = CustomSQLUtil.get(
1132                                    FIND_BY_G_C_S, queryDefinition, "JournalArticle");
1133    
1134                            sql = replaceStatusJoin(sql, queryDefinition);
1135    
1136                            sql = CustomSQLUtil.replaceOrderBy(
1137                                    sql, queryDefinition.getOrderByComparator("JournalArticle"));
1138    
1139                            if (groupId <= 0) {
1140                                    sql = StringUtil.replace(
1141                                            sql, "(JournalArticle.groupId = ?) AND", StringPool.BLANK);
1142                            }
1143    
1144                            if (ddmStructureKey.equals(
1145                                            String.valueOf(
1146                                                    JournalArticleConstants.CLASSNAME_ID_DEFAULT))) {
1147    
1148                                    sql = StringUtil.replace(
1149                                            sql, "(JournalArticle.structureId = ?)",
1150                                            "((JournalArticle.structureId = ?) OR " +
1151                                                    "(JournalArticle.structureId = '') OR" +
1152                                                            "(JournalArticle.structureId IS NULL))");
1153                            }
1154    
1155                            if (inlineSQLHelper) {
1156                                    sql = InlineSQLHelperUtil.replacePermissionCheck(
1157                                            sql, JournalArticle.class.getName(),
1158                                            "JournalArticle.resourcePrimKey", groupId);
1159                            }
1160    
1161                            SQLQuery q = session.createSynchronizedSQLQuery(sql);
1162    
1163                            q.addEntity(
1164                                    JournalArticleImpl.TABLE_NAME, JournalArticleImpl.class);
1165    
1166                            QueryPos qPos = QueryPos.getInstance(q);
1167    
1168                            if (groupId > 0) {
1169                                    qPos.add(groupId);
1170                            }
1171    
1172                            qPos.add(classNameId);
1173                            qPos.add(ddmStructureKey);
1174                            qPos.add(queryDefinition.getStatus());
1175    
1176                            return (List<JournalArticle>)QueryUtil.list(
1177                                    q, getDialect(), queryDefinition.getStart(),
1178                                    queryDefinition.getEnd());
1179                    }
1180                    catch (Exception e) {
1181                            throw new SystemException(e);
1182                    }
1183                    finally {
1184                            closeSession(session);
1185                    }
1186            }
1187    
1188            protected List<JournalArticle> doFindByG_U_F_C(
1189                    long groupId, long userId, List<Long> folderIds, long classNameId,
1190                    QueryDefinition<JournalArticle> queryDefinition,
1191                    boolean inlineSQLHelper) {
1192    
1193                    Session session = null;
1194    
1195                    try {
1196                            session = openSession();
1197    
1198                            String sql = CustomSQLUtil.get(
1199                                    FIND_BY_G_U_F_C, queryDefinition, "JournalArticle");
1200    
1201                            sql = replaceStatusJoin(sql, queryDefinition);
1202    
1203                            sql = CustomSQLUtil.replaceOrderBy(
1204                                    sql, queryDefinition.getOrderByComparator("JournalArticle"));
1205    
1206                            if (folderIds.isEmpty()) {
1207                                    sql = StringUtil.replace(
1208                                            sql, "([$FOLDER_ID$]) AND", StringPool.BLANK);
1209                            }
1210                            else {
1211                                    sql = StringUtil.replace(
1212                                            sql, "[$FOLDER_ID$]",
1213                                            getFolderIds(folderIds, JournalArticleImpl.TABLE_NAME));
1214                            }
1215    
1216                            if (userId <= 0) {
1217                                    sql = StringUtil.replace(
1218                                            sql, "(JournalArticle.userId = ?) AND", StringPool.BLANK);
1219                            }
1220    
1221                            if (inlineSQLHelper) {
1222                                    sql = InlineSQLHelperUtil.replacePermissionCheck(
1223                                            sql, JournalArticle.class.getName(),
1224                                            "JournalArticle.resourcePrimKey", groupId);
1225                            }
1226    
1227                            SQLQuery q = session.createSynchronizedSQLQuery(sql);
1228    
1229                            q.addEntity(
1230                                    JournalArticleImpl.TABLE_NAME, JournalArticleImpl.class);
1231    
1232                            QueryPos qPos = QueryPos.getInstance(q);
1233    
1234                            qPos.add(groupId);
1235                            qPos.add(classNameId);
1236    
1237                            if (userId > 0) {
1238                                    qPos.add(userId);
1239                            }
1240    
1241                            for (long folderId : folderIds) {
1242                                    qPos.add(folderId);
1243                            }
1244    
1245                            qPos.add(queryDefinition.getStatus());
1246    
1247                            return (List<JournalArticle>)QueryUtil.list(
1248                                    q, getDialect(), queryDefinition.getStart(),
1249                                    queryDefinition.getEnd());
1250                    }
1251                    catch (Exception e) {
1252                            throw new SystemException(e);
1253                    }
1254                    finally {
1255                            closeSession(session);
1256                    }
1257            }
1258    
1259            protected List<JournalArticle> doFindByC_G_F_C_A_V_T_D_C_T_S_T_D_R(
1260                    long companyId, long groupId, List<Long> folderIds, long classNameId,
1261                    String[] articleIds, Double version, String[] titles,
1262                    String[] descriptions, String[] contents, String type,
1263                    String[] ddmStructureKeys, String[] ddmTemplateKeys, Date displayDateGT,
1264                    Date displayDateLT, Date reviewDate, boolean andOperator,
1265                    QueryDefinition<JournalArticle> queryDefinition,
1266                    boolean inlineSQLHelper) {
1267    
1268                    articleIds = CustomSQLUtil.keywords(articleIds, false);
1269                    titles = CustomSQLUtil.keywords(titles);
1270                    descriptions = CustomSQLUtil.keywords(descriptions, false);
1271                    contents = CustomSQLUtil.keywords(contents, false);
1272                    ddmStructureKeys = CustomSQLUtil.keywords(ddmStructureKeys, false);
1273                    ddmTemplateKeys = CustomSQLUtil.keywords(ddmTemplateKeys, false);
1274                    Timestamp displayDateGT_TS = CalendarUtil.getTimestamp(displayDateGT);
1275                    Timestamp displayDateLT_TS = CalendarUtil.getTimestamp(displayDateLT);
1276                    Timestamp reviewDate_TS = CalendarUtil.getTimestamp(reviewDate);
1277    
1278                    Session session = null;
1279    
1280                    try {
1281                            session = openSession();
1282    
1283                            String sql = CustomSQLUtil.get(
1284                                    FIND_BY_C_G_F_C_A_V_T_D_C_T_S_T_D_R, queryDefinition,
1285                                    "JournalArticle");
1286    
1287                            sql = replaceStatusJoin(sql, queryDefinition);
1288    
1289                            if (groupId <= 0) {
1290                                    sql = StringUtil.replace(
1291                                            sql, "(JournalArticle.groupId = ?) AND", StringPool.BLANK);
1292                            }
1293    
1294                            if (folderIds.isEmpty()) {
1295                                    sql = StringUtil.replace(
1296                                            sql, "([$FOLDER_ID$]) AND", StringPool.BLANK);
1297                            }
1298                            else {
1299                                    sql = StringUtil.replace(
1300                                            sql, "[$FOLDER_ID$]",
1301                                            getFolderIds(folderIds, JournalArticleImpl.TABLE_NAME));
1302                            }
1303    
1304                            sql = CustomSQLUtil.replaceKeywords(
1305                                    sql, "JournalArticle.articleId", StringPool.LIKE, false,
1306                                    articleIds);
1307    
1308                            if ((version == null) || (version <= 0)) {
1309                                    sql = StringUtil.replace(
1310                                            sql, "(JournalArticle.version = ?) [$AND_OR_CONNECTOR$]",
1311                                            StringPool.BLANK);
1312                            }
1313    
1314                            sql = CustomSQLUtil.replaceKeywords(
1315                                    sql, "lower(JournalArticle.title)", StringPool.LIKE, false,
1316                                    titles);
1317                            sql = CustomSQLUtil.replaceKeywords(
1318                                    sql, "JournalArticle.description", StringPool.LIKE, false,
1319                                    descriptions);
1320                            sql = CustomSQLUtil.replaceKeywords(
1321                                    sql, "JournalArticle.content", StringPool.LIKE, false,
1322                                    contents);
1323    
1324                            sql = replaceTypeStructureTemplate(
1325                                    sql, type, ddmStructureKeys, ddmTemplateKeys);
1326    
1327                            if (!isNullArray(ddmStructureKeys)) {
1328                                    sql = CustomSQLUtil.replaceKeywords(
1329                                            sql, "JournalArticle.structureId", StringPool.LIKE, false,
1330                                            ddmStructureKeys);
1331                            }
1332    
1333                            if (!isNullArray(ddmTemplateKeys)) {
1334                                    sql = CustomSQLUtil.replaceKeywords(
1335                                            sql, "JournalArticle.templateId", StringPool.LIKE, false,
1336                                            ddmTemplateKeys);
1337                            }
1338    
1339                            sql = CustomSQLUtil.replaceAndOperator(sql, andOperator);
1340                            sql = CustomSQLUtil.replaceOrderBy(
1341                                    sql, queryDefinition.getOrderByComparator("JournalArticle"));
1342    
1343                            if (inlineSQLHelper) {
1344                                    sql = InlineSQLHelperUtil.replacePermissionCheck(
1345                                            sql, JournalArticle.class.getName(),
1346                                            "JournalArticle.resourcePrimKey", groupId);
1347    
1348                                    sql = StringUtil.replace(
1349                                            sql, "(companyId", "(JournalArticle.companyId");
1350                            }
1351    
1352                            SQLQuery q = session.createSynchronizedSQLQuery(sql);
1353    
1354                            q.addEntity(
1355                                    JournalArticleImpl.TABLE_NAME, JournalArticleImpl.class);
1356    
1357                            QueryPos qPos = QueryPos.getInstance(q);
1358    
1359                            qPos.add(companyId);
1360    
1361                            if (groupId > 0) {
1362                                    qPos.add(groupId);
1363                            }
1364    
1365                            for (long folderId : folderIds) {
1366                                    qPos.add(folderId);
1367                            }
1368    
1369                            qPos.add(classNameId);
1370                            qPos.add(queryDefinition.getStatus());
1371    
1372                            if (Validator.isNotNull(type)) {
1373                                    qPos.add(type);
1374                                    qPos.add(type);
1375                            }
1376    
1377                            if (!isNullArray(ddmStructureKeys)) {
1378                                    qPos.add(ddmStructureKeys, 2);
1379                            }
1380    
1381                            if (!isNullArray(ddmTemplateKeys)) {
1382                                    qPos.add(ddmTemplateKeys, 2);
1383                            }
1384    
1385                            qPos.add(articleIds, 2);
1386    
1387                            if ((version != null) && (version > 0)) {
1388                                    qPos.add(version);
1389                            }
1390    
1391                            qPos.add(titles, 2);
1392                            qPos.add(descriptions, 2);
1393                            qPos.add(contents, 2);
1394                            qPos.add(displayDateGT_TS);
1395                            qPos.add(displayDateGT_TS);
1396                            qPos.add(displayDateLT_TS);
1397                            qPos.add(displayDateLT_TS);
1398                            qPos.add(reviewDate_TS);
1399                            qPos.add(reviewDate_TS);
1400    
1401                            return (List<JournalArticle>)QueryUtil.list(
1402                                    q, getDialect(), queryDefinition.getStart(),
1403                                    queryDefinition.getEnd());
1404                    }
1405                    catch (Exception e) {
1406                            throw new SystemException(e);
1407                    }
1408                    finally {
1409                            closeSession(session);
1410                    }
1411            }
1412    
1413            protected String getFolderIds(List<Long> folderIds, String tableName) {
1414                    if (folderIds.isEmpty()) {
1415                            return StringPool.BLANK;
1416                    }
1417    
1418                    StringBundler sb = new StringBundler(folderIds.size() * 3 + 1);
1419    
1420                    sb.append(StringPool.OPEN_PARENTHESIS);
1421    
1422                    for (int i = 0; i < folderIds.size(); i++) {
1423                            sb.append(tableName);
1424                            sb.append(".folderId = ? ");
1425    
1426                            if ((i + 1) != folderIds.size()) {
1427                                    sb.append(WHERE_OR);
1428                            }
1429                    }
1430    
1431                    sb.append(StringPool.CLOSE_PARENTHESIS);
1432    
1433                    return sb.toString();
1434            }
1435    
1436            protected JournalArticle getLatestArticle(
1437                    long groupId, String articleId, int status) {
1438    
1439                    List<JournalArticle> articles = null;
1440    
1441                    if (status == WorkflowConstants.STATUS_ANY) {
1442                            articles = JournalArticleUtil.findByG_A(groupId, articleId, 0, 1);
1443                    }
1444                    else {
1445                            articles = JournalArticleUtil.findByG_A_ST(
1446                                    groupId, articleId, status, 0, 1);
1447                    }
1448    
1449                    if (articles.isEmpty()) {
1450                            return null;
1451                    }
1452    
1453                    return articles.get(0);
1454            }
1455    
1456            protected boolean isNullArray(Object[] array) {
1457                    if (ArrayUtil.isEmpty(array)) {
1458                            return true;
1459                    }
1460    
1461                    for (Object obj : array) {
1462                            if (Validator.isNotNull(obj)) {
1463                                    return false;
1464                            }
1465                    }
1466    
1467                    return true;
1468            }
1469    
1470            protected String replaceStatusJoin(
1471                    String sql, QueryDefinition<JournalArticle> queryDefinition) {
1472    
1473                    if (queryDefinition.getStatus() == WorkflowConstants.STATUS_ANY) {
1474                            return StringUtil.replace(
1475                                    sql, "[$STATUS_JOIN$] AND", StringPool.BLANK);
1476                    }
1477    
1478                    if (queryDefinition.isExcludeStatus()) {
1479                            StringBundler sb = new StringBundler(5);
1480    
1481                            sb.append("(JournalArticle.status != ");
1482                            sb.append(queryDefinition.getStatus());
1483                            sb.append(") AND (tempJournalArticle.status != ");
1484                            sb.append(queryDefinition.getStatus());
1485                            sb.append(")");
1486    
1487                            sql = StringUtil.replace(sql, "[$STATUS_JOIN$]", sb.toString());
1488                    }
1489                    else {
1490                            StringBundler sb = new StringBundler(5);
1491    
1492                            sb.append("(JournalArticle.status = ");
1493                            sb.append(queryDefinition.getStatus());
1494                            sb.append(") AND (tempJournalArticle.status = ");
1495                            sb.append(queryDefinition.getStatus());
1496                            sb.append(")");
1497    
1498                            sql = StringUtil.replace(sql, "[$STATUS_JOIN$]", sb.toString());
1499                    }
1500    
1501                    return sql;
1502            }
1503    
1504            protected String replaceTypeStructureTemplate(
1505                    String sql, String type, String[] ddmStructureKeys,
1506                    String[] ddmTemplateKeys) {
1507    
1508                    StringBundler sb = new StringBundler(5);
1509    
1510                    if (Validator.isNull(type) && isNullArray(ddmStructureKeys) &&
1511                            isNullArray(ddmTemplateKeys)) {
1512    
1513                            return StringUtil.replace(
1514                                    sql, "([$TYPE_STRUCTURE_TEMPLATE$]) AND", StringPool.BLANK);
1515                    }
1516    
1517                    if (Validator.isNotNull(type)) {
1518                            sb.append(_TYPE_SQL);
1519                    }
1520    
1521                    if (!isNullArray(ddmStructureKeys)) {
1522                            if (Validator.isNotNull(type)) {
1523                                    sb.append(_AND_OR_CONNECTOR);
1524                            }
1525    
1526                            sb.append(_STRUCTURE_ID_SQL);
1527                    }
1528    
1529                    if (!isNullArray(ddmTemplateKeys)) {
1530                            if (Validator.isNotNull(type) || !isNullArray(ddmStructureKeys)) {
1531                                    sb.append(_AND_OR_CONNECTOR);
1532                            }
1533    
1534                            sb.append(_TEMPLATE_ID_SQL);
1535                    }
1536    
1537                    return StringUtil.replace(
1538                            sql, "[$TYPE_STRUCTURE_TEMPLATE$]", sb.toString());
1539            }
1540    
1541            private static final String _AND_OR_CONNECTOR = "[$AND_OR_CONNECTOR$] ";
1542    
1543            private static final String _STRUCTURE_ID_SQL =
1544                    "(JournalArticle.structureId LIKE ? [$AND_OR_NULL_CHECK$]) ";
1545    
1546            private static final String _TEMPLATE_ID_SQL =
1547                    "(JournalArticle.templateId LIKE ? [$AND_OR_NULL_CHECK$]) ";
1548    
1549            private static final String _TYPE_SQL =
1550                    "(JournalArticle.type_ = ? [$AND_OR_NULL_CHECK$]) ";
1551    
1552    }