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