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