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