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