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