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