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