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