1
22
23 package com.liferay.portlet.journal.service.persistence;
24
25 import com.liferay.portal.SystemException;
26 import com.liferay.portal.kernel.annotation.BeanReference;
27 import com.liferay.portal.kernel.cache.CacheRegistry;
28 import com.liferay.portal.kernel.dao.orm.DynamicQuery;
29 import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
30 import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
31 import com.liferay.portal.kernel.dao.orm.FinderPath;
32 import com.liferay.portal.kernel.dao.orm.Query;
33 import com.liferay.portal.kernel.dao.orm.QueryPos;
34 import com.liferay.portal.kernel.dao.orm.QueryUtil;
35 import com.liferay.portal.kernel.dao.orm.Session;
36 import com.liferay.portal.kernel.log.Log;
37 import com.liferay.portal.kernel.log.LogFactoryUtil;
38 import com.liferay.portal.kernel.util.GetterUtil;
39 import com.liferay.portal.kernel.util.OrderByComparator;
40 import com.liferay.portal.kernel.util.StringPool;
41 import com.liferay.portal.kernel.util.StringUtil;
42 import com.liferay.portal.kernel.util.Validator;
43 import com.liferay.portal.model.ModelListener;
44 import com.liferay.portal.service.persistence.BatchSessionUtil;
45 import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
46
47 import com.liferay.portlet.journal.NoSuchArticleImageException;
48 import com.liferay.portlet.journal.model.JournalArticleImage;
49 import com.liferay.portlet.journal.model.impl.JournalArticleImageImpl;
50 import com.liferay.portlet.journal.model.impl.JournalArticleImageModelImpl;
51
52 import java.util.ArrayList;
53 import java.util.Collections;
54 import java.util.List;
55
56
69 public class JournalArticleImagePersistenceImpl extends BasePersistenceImpl
70 implements JournalArticleImagePersistence {
71 public static final String FINDER_CLASS_NAME_ENTITY = JournalArticleImageImpl.class.getName();
72 public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
73 ".List";
74 public static final FinderPath FINDER_PATH_FIND_BY_GROUPID = new FinderPath(JournalArticleImageModelImpl.ENTITY_CACHE_ENABLED,
75 JournalArticleImageModelImpl.FINDER_CACHE_ENABLED,
76 FINDER_CLASS_NAME_LIST, "findByGroupId",
77 new String[] { Long.class.getName() });
78 public static final FinderPath FINDER_PATH_FIND_BY_OBC_GROUPID = new FinderPath(JournalArticleImageModelImpl.ENTITY_CACHE_ENABLED,
79 JournalArticleImageModelImpl.FINDER_CACHE_ENABLED,
80 FINDER_CLASS_NAME_LIST, "findByGroupId",
81 new String[] {
82 Long.class.getName(),
83
84 "java.lang.Integer", "java.lang.Integer",
85 "com.liferay.portal.kernel.util.OrderByComparator"
86 });
87 public static final FinderPath FINDER_PATH_COUNT_BY_GROUPID = new FinderPath(JournalArticleImageModelImpl.ENTITY_CACHE_ENABLED,
88 JournalArticleImageModelImpl.FINDER_CACHE_ENABLED,
89 FINDER_CLASS_NAME_LIST, "countByGroupId",
90 new String[] { Long.class.getName() });
91 public static final FinderPath FINDER_PATH_FIND_BY_TEMPIMAGE = new FinderPath(JournalArticleImageModelImpl.ENTITY_CACHE_ENABLED,
92 JournalArticleImageModelImpl.FINDER_CACHE_ENABLED,
93 FINDER_CLASS_NAME_LIST, "findByTempImage",
94 new String[] { Boolean.class.getName() });
95 public static final FinderPath FINDER_PATH_FIND_BY_OBC_TEMPIMAGE = new FinderPath(JournalArticleImageModelImpl.ENTITY_CACHE_ENABLED,
96 JournalArticleImageModelImpl.FINDER_CACHE_ENABLED,
97 FINDER_CLASS_NAME_LIST, "findByTempImage",
98 new String[] {
99 Boolean.class.getName(),
100
101 "java.lang.Integer", "java.lang.Integer",
102 "com.liferay.portal.kernel.util.OrderByComparator"
103 });
104 public static final FinderPath FINDER_PATH_COUNT_BY_TEMPIMAGE = new FinderPath(JournalArticleImageModelImpl.ENTITY_CACHE_ENABLED,
105 JournalArticleImageModelImpl.FINDER_CACHE_ENABLED,
106 FINDER_CLASS_NAME_LIST, "countByTempImage",
107 new String[] { Boolean.class.getName() });
108 public static final FinderPath FINDER_PATH_FIND_BY_G_A_V = new FinderPath(JournalArticleImageModelImpl.ENTITY_CACHE_ENABLED,
109 JournalArticleImageModelImpl.FINDER_CACHE_ENABLED,
110 FINDER_CLASS_NAME_LIST, "findByG_A_V",
111 new String[] {
112 Long.class.getName(), String.class.getName(),
113 Double.class.getName()
114 });
115 public static final FinderPath FINDER_PATH_FIND_BY_OBC_G_A_V = new FinderPath(JournalArticleImageModelImpl.ENTITY_CACHE_ENABLED,
116 JournalArticleImageModelImpl.FINDER_CACHE_ENABLED,
117 FINDER_CLASS_NAME_LIST, "findByG_A_V",
118 new String[] {
119 Long.class.getName(), String.class.getName(),
120 Double.class.getName(),
121
122 "java.lang.Integer", "java.lang.Integer",
123 "com.liferay.portal.kernel.util.OrderByComparator"
124 });
125 public static final FinderPath FINDER_PATH_COUNT_BY_G_A_V = new FinderPath(JournalArticleImageModelImpl.ENTITY_CACHE_ENABLED,
126 JournalArticleImageModelImpl.FINDER_CACHE_ENABLED,
127 FINDER_CLASS_NAME_LIST, "countByG_A_V",
128 new String[] {
129 Long.class.getName(), String.class.getName(),
130 Double.class.getName()
131 });
132 public static final FinderPath FINDER_PATH_FETCH_BY_G_A_V_E_L = new FinderPath(JournalArticleImageModelImpl.ENTITY_CACHE_ENABLED,
133 JournalArticleImageModelImpl.FINDER_CACHE_ENABLED,
134 FINDER_CLASS_NAME_ENTITY, "fetchByG_A_V_E_L",
135 new String[] {
136 Long.class.getName(), String.class.getName(),
137 Double.class.getName(), String.class.getName(),
138 String.class.getName()
139 });
140 public static final FinderPath FINDER_PATH_COUNT_BY_G_A_V_E_L = new FinderPath(JournalArticleImageModelImpl.ENTITY_CACHE_ENABLED,
141 JournalArticleImageModelImpl.FINDER_CACHE_ENABLED,
142 FINDER_CLASS_NAME_LIST, "countByG_A_V_E_L",
143 new String[] {
144 Long.class.getName(), String.class.getName(),
145 Double.class.getName(), String.class.getName(),
146 String.class.getName()
147 });
148 public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(JournalArticleImageModelImpl.ENTITY_CACHE_ENABLED,
149 JournalArticleImageModelImpl.FINDER_CACHE_ENABLED,
150 FINDER_CLASS_NAME_LIST, "findAll", new String[0]);
151 public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(JournalArticleImageModelImpl.ENTITY_CACHE_ENABLED,
152 JournalArticleImageModelImpl.FINDER_CACHE_ENABLED,
153 FINDER_CLASS_NAME_LIST, "countAll", new String[0]);
154
155 public void cacheResult(JournalArticleImage journalArticleImage) {
156 EntityCacheUtil.putResult(JournalArticleImageModelImpl.ENTITY_CACHE_ENABLED,
157 JournalArticleImageImpl.class, journalArticleImage.getPrimaryKey(),
158 journalArticleImage);
159
160 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A_V_E_L,
161 new Object[] {
162 new Long(journalArticleImage.getGroupId()),
163
164 journalArticleImage.getArticleId(),
165 new Double(journalArticleImage.getVersion()),
166
167 journalArticleImage.getElName(),
168
169 journalArticleImage.getLanguageId()
170 }, journalArticleImage);
171 }
172
173 public void cacheResult(List<JournalArticleImage> journalArticleImages) {
174 for (JournalArticleImage journalArticleImage : journalArticleImages) {
175 if (EntityCacheUtil.getResult(
176 JournalArticleImageModelImpl.ENTITY_CACHE_ENABLED,
177 JournalArticleImageImpl.class,
178 journalArticleImage.getPrimaryKey(), this) == null) {
179 cacheResult(journalArticleImage);
180 }
181 }
182 }
183
184 public void clearCache() {
185 CacheRegistry.clear(JournalArticleImageImpl.class.getName());
186 EntityCacheUtil.clearCache(JournalArticleImageImpl.class.getName());
187 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
188 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
189 }
190
191 public JournalArticleImage create(long articleImageId) {
192 JournalArticleImage journalArticleImage = new JournalArticleImageImpl();
193
194 journalArticleImage.setNew(true);
195 journalArticleImage.setPrimaryKey(articleImageId);
196
197 return journalArticleImage;
198 }
199
200 public JournalArticleImage remove(long articleImageId)
201 throws NoSuchArticleImageException, SystemException {
202 Session session = null;
203
204 try {
205 session = openSession();
206
207 JournalArticleImage journalArticleImage = (JournalArticleImage)session.get(JournalArticleImageImpl.class,
208 new Long(articleImageId));
209
210 if (journalArticleImage == null) {
211 if (_log.isWarnEnabled()) {
212 _log.warn(
213 "No JournalArticleImage exists with the primary key " +
214 articleImageId);
215 }
216
217 throw new NoSuchArticleImageException(
218 "No JournalArticleImage exists with the primary key " +
219 articleImageId);
220 }
221
222 return remove(journalArticleImage);
223 }
224 catch (NoSuchArticleImageException nsee) {
225 throw nsee;
226 }
227 catch (Exception e) {
228 throw processException(e);
229 }
230 finally {
231 closeSession(session);
232 }
233 }
234
235 public JournalArticleImage remove(JournalArticleImage journalArticleImage)
236 throws SystemException {
237 for (ModelListener<JournalArticleImage> listener : listeners) {
238 listener.onBeforeRemove(journalArticleImage);
239 }
240
241 journalArticleImage = removeImpl(journalArticleImage);
242
243 for (ModelListener<JournalArticleImage> listener : listeners) {
244 listener.onAfterRemove(journalArticleImage);
245 }
246
247 return journalArticleImage;
248 }
249
250 protected JournalArticleImage removeImpl(
251 JournalArticleImage journalArticleImage) throws SystemException {
252 Session session = null;
253
254 try {
255 session = openSession();
256
257 if (journalArticleImage.isCachedModel() ||
258 BatchSessionUtil.isEnabled()) {
259 Object staleObject = session.get(JournalArticleImageImpl.class,
260 journalArticleImage.getPrimaryKeyObj());
261
262 if (staleObject != null) {
263 session.evict(staleObject);
264 }
265 }
266
267 session.delete(journalArticleImage);
268
269 session.flush();
270 }
271 catch (Exception e) {
272 throw processException(e);
273 }
274 finally {
275 closeSession(session);
276 }
277
278 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
279
280 JournalArticleImageModelImpl journalArticleImageModelImpl = (JournalArticleImageModelImpl)journalArticleImage;
281
282 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_A_V_E_L,
283 new Object[] {
284 new Long(journalArticleImageModelImpl.getOriginalGroupId()),
285
286 journalArticleImageModelImpl.getOriginalArticleId(),
287 new Double(journalArticleImageModelImpl.getOriginalVersion()),
288
289 journalArticleImageModelImpl.getOriginalElName(),
290
291 journalArticleImageModelImpl.getOriginalLanguageId()
292 });
293
294 EntityCacheUtil.removeResult(JournalArticleImageModelImpl.ENTITY_CACHE_ENABLED,
295 JournalArticleImageImpl.class, journalArticleImage.getPrimaryKey());
296
297 return journalArticleImage;
298 }
299
300
303 public JournalArticleImage update(JournalArticleImage journalArticleImage)
304 throws SystemException {
305 if (_log.isWarnEnabled()) {
306 _log.warn(
307 "Using the deprecated update(JournalArticleImage journalArticleImage) method. Use update(JournalArticleImage journalArticleImage, boolean merge) instead.");
308 }
309
310 return update(journalArticleImage, false);
311 }
312
313
325 public JournalArticleImage update(JournalArticleImage journalArticleImage,
326 boolean merge) throws SystemException {
327 boolean isNew = journalArticleImage.isNew();
328
329 for (ModelListener<JournalArticleImage> listener : listeners) {
330 if (isNew) {
331 listener.onBeforeCreate(journalArticleImage);
332 }
333 else {
334 listener.onBeforeUpdate(journalArticleImage);
335 }
336 }
337
338 journalArticleImage = updateImpl(journalArticleImage, merge);
339
340 for (ModelListener<JournalArticleImage> listener : listeners) {
341 if (isNew) {
342 listener.onAfterCreate(journalArticleImage);
343 }
344 else {
345 listener.onAfterUpdate(journalArticleImage);
346 }
347 }
348
349 return journalArticleImage;
350 }
351
352 public JournalArticleImage updateImpl(
353 com.liferay.portlet.journal.model.JournalArticleImage journalArticleImage,
354 boolean merge) throws SystemException {
355 boolean isNew = journalArticleImage.isNew();
356
357 JournalArticleImageModelImpl journalArticleImageModelImpl = (JournalArticleImageModelImpl)journalArticleImage;
358
359 Session session = null;
360
361 try {
362 session = openSession();
363
364 BatchSessionUtil.update(session, journalArticleImage, merge);
365
366 journalArticleImage.setNew(false);
367 }
368 catch (Exception e) {
369 throw processException(e);
370 }
371 finally {
372 closeSession(session);
373 }
374
375 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
376
377 EntityCacheUtil.putResult(JournalArticleImageModelImpl.ENTITY_CACHE_ENABLED,
378 JournalArticleImageImpl.class, journalArticleImage.getPrimaryKey(),
379 journalArticleImage);
380
381 if (!isNew &&
382 ((journalArticleImage.getGroupId() != journalArticleImageModelImpl.getOriginalGroupId()) ||
383 !Validator.equals(journalArticleImage.getArticleId(),
384 journalArticleImageModelImpl.getOriginalArticleId()) ||
385 (journalArticleImage.getVersion() != journalArticleImageModelImpl.getOriginalVersion()) ||
386 !Validator.equals(journalArticleImage.getElName(),
387 journalArticleImageModelImpl.getOriginalElName()) ||
388 !Validator.equals(journalArticleImage.getLanguageId(),
389 journalArticleImageModelImpl.getOriginalLanguageId()))) {
390 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_A_V_E_L,
391 new Object[] {
392 new Long(journalArticleImageModelImpl.getOriginalGroupId()),
393
394 journalArticleImageModelImpl.getOriginalArticleId(),
395 new Double(journalArticleImageModelImpl.getOriginalVersion()),
396
397 journalArticleImageModelImpl.getOriginalElName(),
398
399 journalArticleImageModelImpl.getOriginalLanguageId()
400 });
401 }
402
403 if (isNew ||
404 ((journalArticleImage.getGroupId() != journalArticleImageModelImpl.getOriginalGroupId()) ||
405 !Validator.equals(journalArticleImage.getArticleId(),
406 journalArticleImageModelImpl.getOriginalArticleId()) ||
407 (journalArticleImage.getVersion() != journalArticleImageModelImpl.getOriginalVersion()) ||
408 !Validator.equals(journalArticleImage.getElName(),
409 journalArticleImageModelImpl.getOriginalElName()) ||
410 !Validator.equals(journalArticleImage.getLanguageId(),
411 journalArticleImageModelImpl.getOriginalLanguageId()))) {
412 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A_V_E_L,
413 new Object[] {
414 new Long(journalArticleImage.getGroupId()),
415
416 journalArticleImage.getArticleId(),
417 new Double(journalArticleImage.getVersion()),
418
419 journalArticleImage.getElName(),
420
421 journalArticleImage.getLanguageId()
422 }, journalArticleImage);
423 }
424
425 return journalArticleImage;
426 }
427
428 public JournalArticleImage findByPrimaryKey(long articleImageId)
429 throws NoSuchArticleImageException, SystemException {
430 JournalArticleImage journalArticleImage = fetchByPrimaryKey(articleImageId);
431
432 if (journalArticleImage == null) {
433 if (_log.isWarnEnabled()) {
434 _log.warn("No JournalArticleImage exists with the primary key " +
435 articleImageId);
436 }
437
438 throw new NoSuchArticleImageException(
439 "No JournalArticleImage exists with the primary key " +
440 articleImageId);
441 }
442
443 return journalArticleImage;
444 }
445
446 public JournalArticleImage fetchByPrimaryKey(long articleImageId)
447 throws SystemException {
448 JournalArticleImage journalArticleImage = (JournalArticleImage)EntityCacheUtil.getResult(JournalArticleImageModelImpl.ENTITY_CACHE_ENABLED,
449 JournalArticleImageImpl.class, articleImageId, this);
450
451 if (journalArticleImage == null) {
452 Session session = null;
453
454 try {
455 session = openSession();
456
457 journalArticleImage = (JournalArticleImage)session.get(JournalArticleImageImpl.class,
458 new Long(articleImageId));
459 }
460 catch (Exception e) {
461 throw processException(e);
462 }
463 finally {
464 if (journalArticleImage != null) {
465 cacheResult(journalArticleImage);
466 }
467
468 closeSession(session);
469 }
470 }
471
472 return journalArticleImage;
473 }
474
475 public List<JournalArticleImage> findByGroupId(long groupId)
476 throws SystemException {
477 Object[] finderArgs = new Object[] { new Long(groupId) };
478
479 List<JournalArticleImage> list = (List<JournalArticleImage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_GROUPID,
480 finderArgs, this);
481
482 if (list == null) {
483 Session session = null;
484
485 try {
486 session = openSession();
487
488 StringBuilder query = new StringBuilder();
489
490 query.append(
491 "SELECT journalArticleImage FROM JournalArticleImage journalArticleImage WHERE ");
492
493 query.append("journalArticleImage.groupId = ?");
494
495 query.append(" ");
496
497 Query q = session.createQuery(query.toString());
498
499 QueryPos qPos = QueryPos.getInstance(q);
500
501 qPos.add(groupId);
502
503 list = q.list();
504 }
505 catch (Exception e) {
506 throw processException(e);
507 }
508 finally {
509 if (list == null) {
510 list = new ArrayList<JournalArticleImage>();
511 }
512
513 cacheResult(list);
514
515 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_GROUPID,
516 finderArgs, list);
517
518 closeSession(session);
519 }
520 }
521
522 return list;
523 }
524
525 public List<JournalArticleImage> findByGroupId(long groupId, int start,
526 int end) throws SystemException {
527 return findByGroupId(groupId, start, end, null);
528 }
529
530 public List<JournalArticleImage> findByGroupId(long groupId, int start,
531 int end, OrderByComparator obc) throws SystemException {
532 Object[] finderArgs = new Object[] {
533 new Long(groupId),
534
535 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
536 };
537
538 List<JournalArticleImage> list = (List<JournalArticleImage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_GROUPID,
539 finderArgs, this);
540
541 if (list == null) {
542 Session session = null;
543
544 try {
545 session = openSession();
546
547 StringBuilder query = new StringBuilder();
548
549 query.append(
550 "SELECT journalArticleImage FROM JournalArticleImage journalArticleImage WHERE ");
551
552 query.append("journalArticleImage.groupId = ?");
553
554 query.append(" ");
555
556 if (obc != null) {
557 query.append("ORDER BY ");
558
559 String[] orderByFields = obc.getOrderByFields();
560
561 for (int i = 0; i < orderByFields.length; i++) {
562 query.append("journalArticleImage.");
563 query.append(orderByFields[i]);
564
565 if (obc.isAscending()) {
566 query.append(" ASC");
567 }
568 else {
569 query.append(" DESC");
570 }
571
572 if ((i + 1) < orderByFields.length) {
573 query.append(", ");
574 }
575 }
576 }
577
578 Query q = session.createQuery(query.toString());
579
580 QueryPos qPos = QueryPos.getInstance(q);
581
582 qPos.add(groupId);
583
584 list = (List<JournalArticleImage>)QueryUtil.list(q,
585 getDialect(), start, end);
586 }
587 catch (Exception e) {
588 throw processException(e);
589 }
590 finally {
591 if (list == null) {
592 list = new ArrayList<JournalArticleImage>();
593 }
594
595 cacheResult(list);
596
597 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_GROUPID,
598 finderArgs, list);
599
600 closeSession(session);
601 }
602 }
603
604 return list;
605 }
606
607 public JournalArticleImage findByGroupId_First(long groupId,
608 OrderByComparator obc)
609 throws NoSuchArticleImageException, SystemException {
610 List<JournalArticleImage> list = findByGroupId(groupId, 0, 1, obc);
611
612 if (list.isEmpty()) {
613 StringBuilder msg = new StringBuilder();
614
615 msg.append("No JournalArticleImage exists with the key {");
616
617 msg.append("groupId=" + groupId);
618
619 msg.append(StringPool.CLOSE_CURLY_BRACE);
620
621 throw new NoSuchArticleImageException(msg.toString());
622 }
623 else {
624 return list.get(0);
625 }
626 }
627
628 public JournalArticleImage findByGroupId_Last(long groupId,
629 OrderByComparator obc)
630 throws NoSuchArticleImageException, SystemException {
631 int count = countByGroupId(groupId);
632
633 List<JournalArticleImage> list = findByGroupId(groupId, count - 1,
634 count, obc);
635
636 if (list.isEmpty()) {
637 StringBuilder msg = new StringBuilder();
638
639 msg.append("No JournalArticleImage exists with the key {");
640
641 msg.append("groupId=" + groupId);
642
643 msg.append(StringPool.CLOSE_CURLY_BRACE);
644
645 throw new NoSuchArticleImageException(msg.toString());
646 }
647 else {
648 return list.get(0);
649 }
650 }
651
652 public JournalArticleImage[] findByGroupId_PrevAndNext(
653 long articleImageId, long groupId, OrderByComparator obc)
654 throws NoSuchArticleImageException, SystemException {
655 JournalArticleImage journalArticleImage = findByPrimaryKey(articleImageId);
656
657 int count = countByGroupId(groupId);
658
659 Session session = null;
660
661 try {
662 session = openSession();
663
664 StringBuilder query = new StringBuilder();
665
666 query.append(
667 "SELECT journalArticleImage FROM JournalArticleImage journalArticleImage WHERE ");
668
669 query.append("journalArticleImage.groupId = ?");
670
671 query.append(" ");
672
673 if (obc != null) {
674 query.append("ORDER BY ");
675
676 String[] orderByFields = obc.getOrderByFields();
677
678 for (int i = 0; i < orderByFields.length; i++) {
679 query.append("journalArticleImage.");
680 query.append(orderByFields[i]);
681
682 if (obc.isAscending()) {
683 query.append(" ASC");
684 }
685 else {
686 query.append(" DESC");
687 }
688
689 if ((i + 1) < orderByFields.length) {
690 query.append(", ");
691 }
692 }
693 }
694
695 Query q = session.createQuery(query.toString());
696
697 QueryPos qPos = QueryPos.getInstance(q);
698
699 qPos.add(groupId);
700
701 Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
702 journalArticleImage);
703
704 JournalArticleImage[] array = new JournalArticleImageImpl[3];
705
706 array[0] = (JournalArticleImage)objArray[0];
707 array[1] = (JournalArticleImage)objArray[1];
708 array[2] = (JournalArticleImage)objArray[2];
709
710 return array;
711 }
712 catch (Exception e) {
713 throw processException(e);
714 }
715 finally {
716 closeSession(session);
717 }
718 }
719
720 public List<JournalArticleImage> findByTempImage(boolean tempImage)
721 throws SystemException {
722 Object[] finderArgs = new Object[] { Boolean.valueOf(tempImage) };
723
724 List<JournalArticleImage> list = (List<JournalArticleImage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_TEMPIMAGE,
725 finderArgs, this);
726
727 if (list == null) {
728 Session session = null;
729
730 try {
731 session = openSession();
732
733 StringBuilder query = new StringBuilder();
734
735 query.append(
736 "SELECT journalArticleImage FROM JournalArticleImage journalArticleImage WHERE ");
737
738 query.append("journalArticleImage.tempImage = ?");
739
740 query.append(" ");
741
742 Query q = session.createQuery(query.toString());
743
744 QueryPos qPos = QueryPos.getInstance(q);
745
746 qPos.add(tempImage);
747
748 list = q.list();
749 }
750 catch (Exception e) {
751 throw processException(e);
752 }
753 finally {
754 if (list == null) {
755 list = new ArrayList<JournalArticleImage>();
756 }
757
758 cacheResult(list);
759
760 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_TEMPIMAGE,
761 finderArgs, list);
762
763 closeSession(session);
764 }
765 }
766
767 return list;
768 }
769
770 public List<JournalArticleImage> findByTempImage(boolean tempImage,
771 int start, int end) throws SystemException {
772 return findByTempImage(tempImage, start, end, null);
773 }
774
775 public List<JournalArticleImage> findByTempImage(boolean tempImage,
776 int start, int end, OrderByComparator obc) throws SystemException {
777 Object[] finderArgs = new Object[] {
778 Boolean.valueOf(tempImage),
779
780 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
781 };
782
783 List<JournalArticleImage> list = (List<JournalArticleImage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_TEMPIMAGE,
784 finderArgs, this);
785
786 if (list == null) {
787 Session session = null;
788
789 try {
790 session = openSession();
791
792 StringBuilder query = new StringBuilder();
793
794 query.append(
795 "SELECT journalArticleImage FROM JournalArticleImage journalArticleImage WHERE ");
796
797 query.append("journalArticleImage.tempImage = ?");
798
799 query.append(" ");
800
801 if (obc != null) {
802 query.append("ORDER BY ");
803
804 String[] orderByFields = obc.getOrderByFields();
805
806 for (int i = 0; i < orderByFields.length; i++) {
807 query.append("journalArticleImage.");
808 query.append(orderByFields[i]);
809
810 if (obc.isAscending()) {
811 query.append(" ASC");
812 }
813 else {
814 query.append(" DESC");
815 }
816
817 if ((i + 1) < orderByFields.length) {
818 query.append(", ");
819 }
820 }
821 }
822
823 Query q = session.createQuery(query.toString());
824
825 QueryPos qPos = QueryPos.getInstance(q);
826
827 qPos.add(tempImage);
828
829 list = (List<JournalArticleImage>)QueryUtil.list(q,
830 getDialect(), start, end);
831 }
832 catch (Exception e) {
833 throw processException(e);
834 }
835 finally {
836 if (list == null) {
837 list = new ArrayList<JournalArticleImage>();
838 }
839
840 cacheResult(list);
841
842 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_TEMPIMAGE,
843 finderArgs, list);
844
845 closeSession(session);
846 }
847 }
848
849 return list;
850 }
851
852 public JournalArticleImage findByTempImage_First(boolean tempImage,
853 OrderByComparator obc)
854 throws NoSuchArticleImageException, SystemException {
855 List<JournalArticleImage> list = findByTempImage(tempImage, 0, 1, obc);
856
857 if (list.isEmpty()) {
858 StringBuilder msg = new StringBuilder();
859
860 msg.append("No JournalArticleImage exists with the key {");
861
862 msg.append("tempImage=" + tempImage);
863
864 msg.append(StringPool.CLOSE_CURLY_BRACE);
865
866 throw new NoSuchArticleImageException(msg.toString());
867 }
868 else {
869 return list.get(0);
870 }
871 }
872
873 public JournalArticleImage findByTempImage_Last(boolean tempImage,
874 OrderByComparator obc)
875 throws NoSuchArticleImageException, SystemException {
876 int count = countByTempImage(tempImage);
877
878 List<JournalArticleImage> list = findByTempImage(tempImage, count - 1,
879 count, obc);
880
881 if (list.isEmpty()) {
882 StringBuilder msg = new StringBuilder();
883
884 msg.append("No JournalArticleImage exists with the key {");
885
886 msg.append("tempImage=" + tempImage);
887
888 msg.append(StringPool.CLOSE_CURLY_BRACE);
889
890 throw new NoSuchArticleImageException(msg.toString());
891 }
892 else {
893 return list.get(0);
894 }
895 }
896
897 public JournalArticleImage[] findByTempImage_PrevAndNext(
898 long articleImageId, boolean tempImage, OrderByComparator obc)
899 throws NoSuchArticleImageException, SystemException {
900 JournalArticleImage journalArticleImage = findByPrimaryKey(articleImageId);
901
902 int count = countByTempImage(tempImage);
903
904 Session session = null;
905
906 try {
907 session = openSession();
908
909 StringBuilder query = new StringBuilder();
910
911 query.append(
912 "SELECT journalArticleImage FROM JournalArticleImage journalArticleImage WHERE ");
913
914 query.append("journalArticleImage.tempImage = ?");
915
916 query.append(" ");
917
918 if (obc != null) {
919 query.append("ORDER BY ");
920
921 String[] orderByFields = obc.getOrderByFields();
922
923 for (int i = 0; i < orderByFields.length; i++) {
924 query.append("journalArticleImage.");
925 query.append(orderByFields[i]);
926
927 if (obc.isAscending()) {
928 query.append(" ASC");
929 }
930 else {
931 query.append(" DESC");
932 }
933
934 if ((i + 1) < orderByFields.length) {
935 query.append(", ");
936 }
937 }
938 }
939
940 Query q = session.createQuery(query.toString());
941
942 QueryPos qPos = QueryPos.getInstance(q);
943
944 qPos.add(tempImage);
945
946 Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
947 journalArticleImage);
948
949 JournalArticleImage[] array = new JournalArticleImageImpl[3];
950
951 array[0] = (JournalArticleImage)objArray[0];
952 array[1] = (JournalArticleImage)objArray[1];
953 array[2] = (JournalArticleImage)objArray[2];
954
955 return array;
956 }
957 catch (Exception e) {
958 throw processException(e);
959 }
960 finally {
961 closeSession(session);
962 }
963 }
964
965 public List<JournalArticleImage> findByG_A_V(long groupId,
966 String articleId, double version) throws SystemException {
967 Object[] finderArgs = new Object[] {
968 new Long(groupId),
969
970 articleId, new Double(version)
971 };
972
973 List<JournalArticleImage> list = (List<JournalArticleImage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_A_V,
974 finderArgs, this);
975
976 if (list == null) {
977 Session session = null;
978
979 try {
980 session = openSession();
981
982 StringBuilder query = new StringBuilder();
983
984 query.append(
985 "SELECT journalArticleImage FROM JournalArticleImage journalArticleImage WHERE ");
986
987 query.append("journalArticleImage.groupId = ?");
988
989 query.append(" AND ");
990
991 if (articleId == null) {
992 query.append("journalArticleImage.articleId IS NULL");
993 }
994 else {
995 query.append("journalArticleImage.articleId = ?");
996 }
997
998 query.append(" AND ");
999
1000 query.append("journalArticleImage.version = ?");
1001
1002 query.append(" ");
1003
1004 Query q = session.createQuery(query.toString());
1005
1006 QueryPos qPos = QueryPos.getInstance(q);
1007
1008 qPos.add(groupId);
1009
1010 if (articleId != null) {
1011 qPos.add(articleId);
1012 }
1013
1014 qPos.add(version);
1015
1016 list = q.list();
1017 }
1018 catch (Exception e) {
1019 throw processException(e);
1020 }
1021 finally {
1022 if (list == null) {
1023 list = new ArrayList<JournalArticleImage>();
1024 }
1025
1026 cacheResult(list);
1027
1028 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_A_V,
1029 finderArgs, list);
1030
1031 closeSession(session);
1032 }
1033 }
1034
1035 return list;
1036 }
1037
1038 public List<JournalArticleImage> findByG_A_V(long groupId,
1039 String articleId, double version, int start, int end)
1040 throws SystemException {
1041 return findByG_A_V(groupId, articleId, version, start, end, null);
1042 }
1043
1044 public List<JournalArticleImage> findByG_A_V(long groupId,
1045 String articleId, double version, int start, int end,
1046 OrderByComparator obc) throws SystemException {
1047 Object[] finderArgs = new Object[] {
1048 new Long(groupId),
1049
1050 articleId, new Double(version),
1051
1052 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
1053 };
1054
1055 List<JournalArticleImage> list = (List<JournalArticleImage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_G_A_V,
1056 finderArgs, this);
1057
1058 if (list == null) {
1059 Session session = null;
1060
1061 try {
1062 session = openSession();
1063
1064 StringBuilder query = new StringBuilder();
1065
1066 query.append(
1067 "SELECT journalArticleImage FROM JournalArticleImage journalArticleImage WHERE ");
1068
1069 query.append("journalArticleImage.groupId = ?");
1070
1071 query.append(" AND ");
1072
1073 if (articleId == null) {
1074 query.append("journalArticleImage.articleId IS NULL");
1075 }
1076 else {
1077 query.append("journalArticleImage.articleId = ?");
1078 }
1079
1080 query.append(" AND ");
1081
1082 query.append("journalArticleImage.version = ?");
1083
1084 query.append(" ");
1085
1086 if (obc != null) {
1087 query.append("ORDER BY ");
1088
1089 String[] orderByFields = obc.getOrderByFields();
1090
1091 for (int i = 0; i < orderByFields.length; i++) {
1092 query.append("journalArticleImage.");
1093 query.append(orderByFields[i]);
1094
1095 if (obc.isAscending()) {
1096 query.append(" ASC");
1097 }
1098 else {
1099 query.append(" DESC");
1100 }
1101
1102 if ((i + 1) < orderByFields.length) {
1103 query.append(", ");
1104 }
1105 }
1106 }
1107
1108 Query q = session.createQuery(query.toString());
1109
1110 QueryPos qPos = QueryPos.getInstance(q);
1111
1112 qPos.add(groupId);
1113
1114 if (articleId != null) {
1115 qPos.add(articleId);
1116 }
1117
1118 qPos.add(version);
1119
1120 list = (List<JournalArticleImage>)QueryUtil.list(q,
1121 getDialect(), start, end);
1122 }
1123 catch (Exception e) {
1124 throw processException(e);
1125 }
1126 finally {
1127 if (list == null) {
1128 list = new ArrayList<JournalArticleImage>();
1129 }
1130
1131 cacheResult(list);
1132
1133 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_G_A_V,
1134 finderArgs, list);
1135
1136 closeSession(session);
1137 }
1138 }
1139
1140 return list;
1141 }
1142
1143 public JournalArticleImage findByG_A_V_First(long groupId,
1144 String articleId, double version, OrderByComparator obc)
1145 throws NoSuchArticleImageException, SystemException {
1146 List<JournalArticleImage> list = findByG_A_V(groupId, articleId,
1147 version, 0, 1, obc);
1148
1149 if (list.isEmpty()) {
1150 StringBuilder msg = new StringBuilder();
1151
1152 msg.append("No JournalArticleImage exists with the key {");
1153
1154 msg.append("groupId=" + groupId);
1155
1156 msg.append(", ");
1157 msg.append("articleId=" + articleId);
1158
1159 msg.append(", ");
1160 msg.append("version=" + version);
1161
1162 msg.append(StringPool.CLOSE_CURLY_BRACE);
1163
1164 throw new NoSuchArticleImageException(msg.toString());
1165 }
1166 else {
1167 return list.get(0);
1168 }
1169 }
1170
1171 public JournalArticleImage findByG_A_V_Last(long groupId, String articleId,
1172 double version, OrderByComparator obc)
1173 throws NoSuchArticleImageException, SystemException {
1174 int count = countByG_A_V(groupId, articleId, version);
1175
1176 List<JournalArticleImage> list = findByG_A_V(groupId, articleId,
1177 version, count - 1, count, obc);
1178
1179 if (list.isEmpty()) {
1180 StringBuilder msg = new StringBuilder();
1181
1182 msg.append("No JournalArticleImage exists with the key {");
1183
1184 msg.append("groupId=" + groupId);
1185
1186 msg.append(", ");
1187 msg.append("articleId=" + articleId);
1188
1189 msg.append(", ");
1190 msg.append("version=" + version);
1191
1192 msg.append(StringPool.CLOSE_CURLY_BRACE);
1193
1194 throw new NoSuchArticleImageException(msg.toString());
1195 }
1196 else {
1197 return list.get(0);
1198 }
1199 }
1200
1201 public JournalArticleImage[] findByG_A_V_PrevAndNext(long articleImageId,
1202 long groupId, String articleId, double version, OrderByComparator obc)
1203 throws NoSuchArticleImageException, SystemException {
1204 JournalArticleImage journalArticleImage = findByPrimaryKey(articleImageId);
1205
1206 int count = countByG_A_V(groupId, articleId, version);
1207
1208 Session session = null;
1209
1210 try {
1211 session = openSession();
1212
1213 StringBuilder query = new StringBuilder();
1214
1215 query.append(
1216 "SELECT journalArticleImage FROM JournalArticleImage journalArticleImage WHERE ");
1217
1218 query.append("journalArticleImage.groupId = ?");
1219
1220 query.append(" AND ");
1221
1222 if (articleId == null) {
1223 query.append("journalArticleImage.articleId IS NULL");
1224 }
1225 else {
1226 query.append("journalArticleImage.articleId = ?");
1227 }
1228
1229 query.append(" AND ");
1230
1231 query.append("journalArticleImage.version = ?");
1232
1233 query.append(" ");
1234
1235 if (obc != null) {
1236 query.append("ORDER BY ");
1237
1238 String[] orderByFields = obc.getOrderByFields();
1239
1240 for (int i = 0; i < orderByFields.length; i++) {
1241 query.append("journalArticleImage.");
1242 query.append(orderByFields[i]);
1243
1244 if (obc.isAscending()) {
1245 query.append(" ASC");
1246 }
1247 else {
1248 query.append(" DESC");
1249 }
1250
1251 if ((i + 1) < orderByFields.length) {
1252 query.append(", ");
1253 }
1254 }
1255 }
1256
1257 Query q = session.createQuery(query.toString());
1258
1259 QueryPos qPos = QueryPos.getInstance(q);
1260
1261 qPos.add(groupId);
1262
1263 if (articleId != null) {
1264 qPos.add(articleId);
1265 }
1266
1267 qPos.add(version);
1268
1269 Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
1270 journalArticleImage);
1271
1272 JournalArticleImage[] array = new JournalArticleImageImpl[3];
1273
1274 array[0] = (JournalArticleImage)objArray[0];
1275 array[1] = (JournalArticleImage)objArray[1];
1276 array[2] = (JournalArticleImage)objArray[2];
1277
1278 return array;
1279 }
1280 catch (Exception e) {
1281 throw processException(e);
1282 }
1283 finally {
1284 closeSession(session);
1285 }
1286 }
1287
1288 public JournalArticleImage findByG_A_V_E_L(long groupId, String articleId,
1289 double version, String elName, String languageId)
1290 throws NoSuchArticleImageException, SystemException {
1291 JournalArticleImage journalArticleImage = fetchByG_A_V_E_L(groupId,
1292 articleId, version, elName, languageId);
1293
1294 if (journalArticleImage == null) {
1295 StringBuilder msg = new StringBuilder();
1296
1297 msg.append("No JournalArticleImage exists with the key {");
1298
1299 msg.append("groupId=" + groupId);
1300
1301 msg.append(", ");
1302 msg.append("articleId=" + articleId);
1303
1304 msg.append(", ");
1305 msg.append("version=" + version);
1306
1307 msg.append(", ");
1308 msg.append("elName=" + elName);
1309
1310 msg.append(", ");
1311 msg.append("languageId=" + languageId);
1312
1313 msg.append(StringPool.CLOSE_CURLY_BRACE);
1314
1315 if (_log.isWarnEnabled()) {
1316 _log.warn(msg.toString());
1317 }
1318
1319 throw new NoSuchArticleImageException(msg.toString());
1320 }
1321
1322 return journalArticleImage;
1323 }
1324
1325 public JournalArticleImage fetchByG_A_V_E_L(long groupId, String articleId,
1326 double version, String elName, String languageId)
1327 throws SystemException {
1328 return fetchByG_A_V_E_L(groupId, articleId, version, elName,
1329 languageId, true);
1330 }
1331
1332 public JournalArticleImage fetchByG_A_V_E_L(long groupId, String articleId,
1333 double version, String elName, String languageId,
1334 boolean retrieveFromCache) throws SystemException {
1335 Object[] finderArgs = new Object[] {
1336 new Long(groupId),
1337
1338 articleId, new Double(version),
1339
1340 elName,
1341
1342 languageId
1343 };
1344
1345 Object result = null;
1346
1347 if (retrieveFromCache) {
1348 result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_G_A_V_E_L,
1349 finderArgs, this);
1350 }
1351
1352 if (result == null) {
1353 Session session = null;
1354
1355 try {
1356 session = openSession();
1357
1358 StringBuilder query = new StringBuilder();
1359
1360 query.append(
1361 "SELECT journalArticleImage FROM JournalArticleImage journalArticleImage WHERE ");
1362
1363 query.append("journalArticleImage.groupId = ?");
1364
1365 query.append(" AND ");
1366
1367 if (articleId == null) {
1368 query.append("journalArticleImage.articleId IS NULL");
1369 }
1370 else {
1371 query.append("journalArticleImage.articleId = ?");
1372 }
1373
1374 query.append(" AND ");
1375
1376 query.append("journalArticleImage.version = ?");
1377
1378 query.append(" AND ");
1379
1380 if (elName == null) {
1381 query.append("journalArticleImage.elName IS NULL");
1382 }
1383 else {
1384 query.append("journalArticleImage.elName = ?");
1385 }
1386
1387 query.append(" AND ");
1388
1389 if (languageId == null) {
1390 query.append("journalArticleImage.languageId IS NULL");
1391 }
1392 else {
1393 query.append("journalArticleImage.languageId = ?");
1394 }
1395
1396 query.append(" ");
1397
1398 Query q = session.createQuery(query.toString());
1399
1400 QueryPos qPos = QueryPos.getInstance(q);
1401
1402 qPos.add(groupId);
1403
1404 if (articleId != null) {
1405 qPos.add(articleId);
1406 }
1407
1408 qPos.add(version);
1409
1410 if (elName != null) {
1411 qPos.add(elName);
1412 }
1413
1414 if (languageId != null) {
1415 qPos.add(languageId);
1416 }
1417
1418 List<JournalArticleImage> list = q.list();
1419
1420 result = list;
1421
1422 JournalArticleImage journalArticleImage = null;
1423
1424 if (list.isEmpty()) {
1425 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A_V_E_L,
1426 finderArgs, list);
1427 }
1428 else {
1429 journalArticleImage = list.get(0);
1430
1431 cacheResult(journalArticleImage);
1432
1433 if ((journalArticleImage.getGroupId() != groupId) ||
1434 (journalArticleImage.getArticleId() == null) ||
1435 !journalArticleImage.getArticleId().equals(articleId) ||
1436 (journalArticleImage.getVersion() != version) ||
1437 (journalArticleImage.getElName() == null) ||
1438 !journalArticleImage.getElName().equals(elName) ||
1439 (journalArticleImage.getLanguageId() == null) ||
1440 !journalArticleImage.getLanguageId()
1441 .equals(languageId)) {
1442 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A_V_E_L,
1443 finderArgs, journalArticleImage);
1444 }
1445 }
1446
1447 return journalArticleImage;
1448 }
1449 catch (Exception e) {
1450 throw processException(e);
1451 }
1452 finally {
1453 if (result == null) {
1454 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A_V_E_L,
1455 finderArgs, new ArrayList<JournalArticleImage>());
1456 }
1457
1458 closeSession(session);
1459 }
1460 }
1461 else {
1462 if (result instanceof List<?>) {
1463 return null;
1464 }
1465 else {
1466 return (JournalArticleImage)result;
1467 }
1468 }
1469 }
1470
1471 public List<Object> findWithDynamicQuery(DynamicQuery dynamicQuery)
1472 throws SystemException {
1473 Session session = null;
1474
1475 try {
1476 session = openSession();
1477
1478 dynamicQuery.compile(session);
1479
1480 return dynamicQuery.list();
1481 }
1482 catch (Exception e) {
1483 throw processException(e);
1484 }
1485 finally {
1486 closeSession(session);
1487 }
1488 }
1489
1490 public List<Object> findWithDynamicQuery(DynamicQuery dynamicQuery,
1491 int start, int end) throws SystemException {
1492 Session session = null;
1493
1494 try {
1495 session = openSession();
1496
1497 dynamicQuery.setLimit(start, end);
1498
1499 dynamicQuery.compile(session);
1500
1501 return dynamicQuery.list();
1502 }
1503 catch (Exception e) {
1504 throw processException(e);
1505 }
1506 finally {
1507 closeSession(session);
1508 }
1509 }
1510
1511 public List<JournalArticleImage> findAll() throws SystemException {
1512 return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1513 }
1514
1515 public List<JournalArticleImage> findAll(int start, int end)
1516 throws SystemException {
1517 return findAll(start, end, null);
1518 }
1519
1520 public List<JournalArticleImage> findAll(int start, int end,
1521 OrderByComparator obc) throws SystemException {
1522 Object[] finderArgs = new Object[] {
1523 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
1524 };
1525
1526 List<JournalArticleImage> list = (List<JournalArticleImage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
1527 finderArgs, this);
1528
1529 if (list == null) {
1530 Session session = null;
1531
1532 try {
1533 session = openSession();
1534
1535 StringBuilder query = new StringBuilder();
1536
1537 query.append(
1538 "SELECT journalArticleImage FROM JournalArticleImage journalArticleImage ");
1539
1540 if (obc != null) {
1541 query.append("ORDER BY ");
1542
1543 String[] orderByFields = obc.getOrderByFields();
1544
1545 for (int i = 0; i < orderByFields.length; i++) {
1546 query.append("journalArticleImage.");
1547 query.append(orderByFields[i]);
1548
1549 if (obc.isAscending()) {
1550 query.append(" ASC");
1551 }
1552 else {
1553 query.append(" DESC");
1554 }
1555
1556 if ((i + 1) < orderByFields.length) {
1557 query.append(", ");
1558 }
1559 }
1560 }
1561
1562 Query q = session.createQuery(query.toString());
1563
1564 if (obc == null) {
1565 list = (List<JournalArticleImage>)QueryUtil.list(q,
1566 getDialect(), start, end, false);
1567
1568 Collections.sort(list);
1569 }
1570 else {
1571 list = (List<JournalArticleImage>)QueryUtil.list(q,
1572 getDialect(), start, end);
1573 }
1574 }
1575 catch (Exception e) {
1576 throw processException(e);
1577 }
1578 finally {
1579 if (list == null) {
1580 list = new ArrayList<JournalArticleImage>();
1581 }
1582
1583 cacheResult(list);
1584
1585 FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
1586
1587 closeSession(session);
1588 }
1589 }
1590
1591 return list;
1592 }
1593
1594 public void removeByGroupId(long groupId) throws SystemException {
1595 for (JournalArticleImage journalArticleImage : findByGroupId(groupId)) {
1596 remove(journalArticleImage);
1597 }
1598 }
1599
1600 public void removeByTempImage(boolean tempImage) throws SystemException {
1601 for (JournalArticleImage journalArticleImage : findByTempImage(
1602 tempImage)) {
1603 remove(journalArticleImage);
1604 }
1605 }
1606
1607 public void removeByG_A_V(long groupId, String articleId, double version)
1608 throws SystemException {
1609 for (JournalArticleImage journalArticleImage : findByG_A_V(groupId,
1610 articleId, version)) {
1611 remove(journalArticleImage);
1612 }
1613 }
1614
1615 public void removeByG_A_V_E_L(long groupId, String articleId,
1616 double version, String elName, String languageId)
1617 throws NoSuchArticleImageException, SystemException {
1618 JournalArticleImage journalArticleImage = findByG_A_V_E_L(groupId,
1619 articleId, version, elName, languageId);
1620
1621 remove(journalArticleImage);
1622 }
1623
1624 public void removeAll() throws SystemException {
1625 for (JournalArticleImage journalArticleImage : findAll()) {
1626 remove(journalArticleImage);
1627 }
1628 }
1629
1630 public int countByGroupId(long groupId) throws SystemException {
1631 Object[] finderArgs = new Object[] { new Long(groupId) };
1632
1633 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_GROUPID,
1634 finderArgs, this);
1635
1636 if (count == null) {
1637 Session session = null;
1638
1639 try {
1640 session = openSession();
1641
1642 StringBuilder query = new StringBuilder();
1643
1644 query.append("SELECT COUNT(journalArticleImage) ");
1645 query.append(
1646 "FROM JournalArticleImage journalArticleImage WHERE ");
1647
1648 query.append("journalArticleImage.groupId = ?");
1649
1650 query.append(" ");
1651
1652 Query q = session.createQuery(query.toString());
1653
1654 QueryPos qPos = QueryPos.getInstance(q);
1655
1656 qPos.add(groupId);
1657
1658 count = (Long)q.uniqueResult();
1659 }
1660 catch (Exception e) {
1661 throw processException(e);
1662 }
1663 finally {
1664 if (count == null) {
1665 count = Long.valueOf(0);
1666 }
1667
1668 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_GROUPID,
1669 finderArgs, count);
1670
1671 closeSession(session);
1672 }
1673 }
1674
1675 return count.intValue();
1676 }
1677
1678 public int countByTempImage(boolean tempImage) throws SystemException {
1679 Object[] finderArgs = new Object[] { Boolean.valueOf(tempImage) };
1680
1681 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_TEMPIMAGE,
1682 finderArgs, this);
1683
1684 if (count == null) {
1685 Session session = null;
1686
1687 try {
1688 session = openSession();
1689
1690 StringBuilder query = new StringBuilder();
1691
1692 query.append("SELECT COUNT(journalArticleImage) ");
1693 query.append(
1694 "FROM JournalArticleImage journalArticleImage WHERE ");
1695
1696 query.append("journalArticleImage.tempImage = ?");
1697
1698 query.append(" ");
1699
1700 Query q = session.createQuery(query.toString());
1701
1702 QueryPos qPos = QueryPos.getInstance(q);
1703
1704 qPos.add(tempImage);
1705
1706 count = (Long)q.uniqueResult();
1707 }
1708 catch (Exception e) {
1709 throw processException(e);
1710 }
1711 finally {
1712 if (count == null) {
1713 count = Long.valueOf(0);
1714 }
1715
1716 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_TEMPIMAGE,
1717 finderArgs, count);
1718
1719 closeSession(session);
1720 }
1721 }
1722
1723 return count.intValue();
1724 }
1725
1726 public int countByG_A_V(long groupId, String articleId, double version)
1727 throws SystemException {
1728 Object[] finderArgs = new Object[] {
1729 new Long(groupId),
1730
1731 articleId, new Double(version)
1732 };
1733
1734 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_A_V,
1735 finderArgs, this);
1736
1737 if (count == null) {
1738 Session session = null;
1739
1740 try {
1741 session = openSession();
1742
1743 StringBuilder query = new StringBuilder();
1744
1745 query.append("SELECT COUNT(journalArticleImage) ");
1746 query.append(
1747 "FROM JournalArticleImage journalArticleImage WHERE ");
1748
1749 query.append("journalArticleImage.groupId = ?");
1750
1751 query.append(" AND ");
1752
1753 if (articleId == null) {
1754 query.append("journalArticleImage.articleId IS NULL");
1755 }
1756 else {
1757 query.append("journalArticleImage.articleId = ?");
1758 }
1759
1760 query.append(" AND ");
1761
1762 query.append("journalArticleImage.version = ?");
1763
1764 query.append(" ");
1765
1766 Query q = session.createQuery(query.toString());
1767
1768 QueryPos qPos = QueryPos.getInstance(q);
1769
1770 qPos.add(groupId);
1771
1772 if (articleId != null) {
1773 qPos.add(articleId);
1774 }
1775
1776 qPos.add(version);
1777
1778 count = (Long)q.uniqueResult();
1779 }
1780 catch (Exception e) {
1781 throw processException(e);
1782 }
1783 finally {
1784 if (count == null) {
1785 count = Long.valueOf(0);
1786 }
1787
1788 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_A_V,
1789 finderArgs, count);
1790
1791 closeSession(session);
1792 }
1793 }
1794
1795 return count.intValue();
1796 }
1797
1798 public int countByG_A_V_E_L(long groupId, String articleId, double version,
1799 String elName, String languageId) throws SystemException {
1800 Object[] finderArgs = new Object[] {
1801 new Long(groupId),
1802
1803 articleId, new Double(version),
1804
1805 elName,
1806
1807 languageId
1808 };
1809
1810 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_A_V_E_L,
1811 finderArgs, this);
1812
1813 if (count == null) {
1814 Session session = null;
1815
1816 try {
1817 session = openSession();
1818
1819 StringBuilder query = new StringBuilder();
1820
1821 query.append("SELECT COUNT(journalArticleImage) ");
1822 query.append(
1823 "FROM JournalArticleImage journalArticleImage WHERE ");
1824
1825 query.append("journalArticleImage.groupId = ?");
1826
1827 query.append(" AND ");
1828
1829 if (articleId == null) {
1830 query.append("journalArticleImage.articleId IS NULL");
1831 }
1832 else {
1833 query.append("journalArticleImage.articleId = ?");
1834 }
1835
1836 query.append(" AND ");
1837
1838 query.append("journalArticleImage.version = ?");
1839
1840 query.append(" AND ");
1841
1842 if (elName == null) {
1843 query.append("journalArticleImage.elName IS NULL");
1844 }
1845 else {
1846 query.append("journalArticleImage.elName = ?");
1847 }
1848
1849 query.append(" AND ");
1850
1851 if (languageId == null) {
1852 query.append("journalArticleImage.languageId IS NULL");
1853 }
1854 else {
1855 query.append("journalArticleImage.languageId = ?");
1856 }
1857
1858 query.append(" ");
1859
1860 Query q = session.createQuery(query.toString());
1861
1862 QueryPos qPos = QueryPos.getInstance(q);
1863
1864 qPos.add(groupId);
1865
1866 if (articleId != null) {
1867 qPos.add(articleId);
1868 }
1869
1870 qPos.add(version);
1871
1872 if (elName != null) {
1873 qPos.add(elName);
1874 }
1875
1876 if (languageId != null) {
1877 qPos.add(languageId);
1878 }
1879
1880 count = (Long)q.uniqueResult();
1881 }
1882 catch (Exception e) {
1883 throw processException(e);
1884 }
1885 finally {
1886 if (count == null) {
1887 count = Long.valueOf(0);
1888 }
1889
1890 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_A_V_E_L,
1891 finderArgs, count);
1892
1893 closeSession(session);
1894 }
1895 }
1896
1897 return count.intValue();
1898 }
1899
1900 public int countAll() throws SystemException {
1901 Object[] finderArgs = new Object[0];
1902
1903 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
1904 finderArgs, this);
1905
1906 if (count == null) {
1907 Session session = null;
1908
1909 try {
1910 session = openSession();
1911
1912 Query q = session.createQuery(
1913 "SELECT COUNT(journalArticleImage) FROM JournalArticleImage journalArticleImage");
1914
1915 count = (Long)q.uniqueResult();
1916 }
1917 catch (Exception e) {
1918 throw processException(e);
1919 }
1920 finally {
1921 if (count == null) {
1922 count = Long.valueOf(0);
1923 }
1924
1925 FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
1926 count);
1927
1928 closeSession(session);
1929 }
1930 }
1931
1932 return count.intValue();
1933 }
1934
1935 public void afterPropertiesSet() {
1936 String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
1937 com.liferay.portal.util.PropsUtil.get(
1938 "value.object.listener.com.liferay.portlet.journal.model.JournalArticleImage")));
1939
1940 if (listenerClassNames.length > 0) {
1941 try {
1942 List<ModelListener<JournalArticleImage>> listenersList = new ArrayList<ModelListener<JournalArticleImage>>();
1943
1944 for (String listenerClassName : listenerClassNames) {
1945 listenersList.add((ModelListener<JournalArticleImage>)Class.forName(
1946 listenerClassName).newInstance());
1947 }
1948
1949 listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
1950 }
1951 catch (Exception e) {
1952 _log.error(e);
1953 }
1954 }
1955 }
1956
1957 @BeanReference(name = "com.liferay.portlet.journal.service.persistence.JournalArticlePersistence.impl")
1958 protected com.liferay.portlet.journal.service.persistence.JournalArticlePersistence journalArticlePersistence;
1959 @BeanReference(name = "com.liferay.portlet.journal.service.persistence.JournalArticleImagePersistence.impl")
1960 protected com.liferay.portlet.journal.service.persistence.JournalArticleImagePersistence journalArticleImagePersistence;
1961 @BeanReference(name = "com.liferay.portlet.journal.service.persistence.JournalArticleResourcePersistence.impl")
1962 protected com.liferay.portlet.journal.service.persistence.JournalArticleResourcePersistence journalArticleResourcePersistence;
1963 @BeanReference(name = "com.liferay.portlet.journal.service.persistence.JournalContentSearchPersistence.impl")
1964 protected com.liferay.portlet.journal.service.persistence.JournalContentSearchPersistence journalContentSearchPersistence;
1965 @BeanReference(name = "com.liferay.portlet.journal.service.persistence.JournalFeedPersistence.impl")
1966 protected com.liferay.portlet.journal.service.persistence.JournalFeedPersistence journalFeedPersistence;
1967 @BeanReference(name = "com.liferay.portlet.journal.service.persistence.JournalStructurePersistence.impl")
1968 protected com.liferay.portlet.journal.service.persistence.JournalStructurePersistence journalStructurePersistence;
1969 @BeanReference(name = "com.liferay.portlet.journal.service.persistence.JournalTemplatePersistence.impl")
1970 protected com.liferay.portlet.journal.service.persistence.JournalTemplatePersistence journalTemplatePersistence;
1971 @BeanReference(name = "com.liferay.portal.service.persistence.ImagePersistence.impl")
1972 protected com.liferay.portal.service.persistence.ImagePersistence imagePersistence;
1973 @BeanReference(name = "com.liferay.portal.service.persistence.ResourcePersistence.impl")
1974 protected com.liferay.portal.service.persistence.ResourcePersistence resourcePersistence;
1975 @BeanReference(name = "com.liferay.portal.service.persistence.UserPersistence.impl")
1976 protected com.liferay.portal.service.persistence.UserPersistence userPersistence;
1977 private static Log _log = LogFactoryUtil.getLog(JournalArticleImagePersistenceImpl.class);
1978}