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