001
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
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 }