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