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