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