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