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