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