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   * @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                     "SELECT journalArticleImage FROM JournalArticleImage journalArticleImage WHERE ");
498 
499                 query.append("journalArticleImage.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                     "SELECT journalArticleImage FROM JournalArticleImage journalArticleImage WHERE ");
557 
558                 query.append("journalArticleImage.groupId = ?");
559 
560                 query.append(" ");
561 
562                 if (obc != null) {
563                     query.append("ORDER BY ");
564 
565                     String[] orderByFields = obc.getOrderByFields();
566 
567                     for (int i = 0; i < orderByFields.length; i++) {
568                         query.append("journalArticleImage.");
569                         query.append(orderByFields[i]);
570 
571                         if (obc.isAscending()) {
572                             query.append(" ASC");
573                         }
574                         else {
575                             query.append(" DESC");
576                         }
577 
578                         if ((i + 1) < orderByFields.length) {
579                             query.append(", ");
580                         }
581                     }
582                 }
583 
584                 Query q = session.createQuery(query.toString());
585 
586                 QueryPos qPos = QueryPos.getInstance(q);
587 
588                 qPos.add(groupId);
589 
590                 list = (List<JournalArticleImage>)QueryUtil.list(q,
591                         getDialect(), start, end);
592             }
593             catch (Exception e) {
594                 throw processException(e);
595             }
596             finally {
597                 if (list == null) {
598                     list = new ArrayList<JournalArticleImage>();
599                 }
600 
601                 cacheResult(list);
602 
603                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_GROUPID,
604                     finderArgs, list);
605 
606                 closeSession(session);
607             }
608         }
609 
610         return list;
611     }
612 
613     public JournalArticleImage findByGroupId_First(long groupId,
614         OrderByComparator obc)
615         throws NoSuchArticleImageException, SystemException {
616         List<JournalArticleImage> list = findByGroupId(groupId, 0, 1, obc);
617 
618         if (list.isEmpty()) {
619             StringBuilder msg = new StringBuilder();
620 
621             msg.append("No JournalArticleImage exists with the key {");
622 
623             msg.append("groupId=" + groupId);
624 
625             msg.append(StringPool.CLOSE_CURLY_BRACE);
626 
627             throw new NoSuchArticleImageException(msg.toString());
628         }
629         else {
630             return list.get(0);
631         }
632     }
633 
634     public JournalArticleImage findByGroupId_Last(long groupId,
635         OrderByComparator obc)
636         throws NoSuchArticleImageException, SystemException {
637         int count = countByGroupId(groupId);
638 
639         List<JournalArticleImage> list = findByGroupId(groupId, count - 1,
640                 count, obc);
641 
642         if (list.isEmpty()) {
643             StringBuilder msg = new StringBuilder();
644 
645             msg.append("No JournalArticleImage exists with the key {");
646 
647             msg.append("groupId=" + groupId);
648 
649             msg.append(StringPool.CLOSE_CURLY_BRACE);
650 
651             throw new NoSuchArticleImageException(msg.toString());
652         }
653         else {
654             return list.get(0);
655         }
656     }
657 
658     public JournalArticleImage[] findByGroupId_PrevAndNext(
659         long articleImageId, long groupId, OrderByComparator obc)
660         throws NoSuchArticleImageException, SystemException {
661         JournalArticleImage journalArticleImage = findByPrimaryKey(articleImageId);
662 
663         int count = countByGroupId(groupId);
664 
665         Session session = null;
666 
667         try {
668             session = openSession();
669 
670             StringBuilder query = new StringBuilder();
671 
672             query.append(
673                 "SELECT journalArticleImage FROM JournalArticleImage journalArticleImage WHERE ");
674 
675             query.append("journalArticleImage.groupId = ?");
676 
677             query.append(" ");
678 
679             if (obc != null) {
680                 query.append("ORDER BY ");
681 
682                 String[] orderByFields = obc.getOrderByFields();
683 
684                 for (int i = 0; i < orderByFields.length; i++) {
685                     query.append("journalArticleImage.");
686                     query.append(orderByFields[i]);
687 
688                     if (obc.isAscending()) {
689                         query.append(" ASC");
690                     }
691                     else {
692                         query.append(" DESC");
693                     }
694 
695                     if ((i + 1) < orderByFields.length) {
696                         query.append(", ");
697                     }
698                 }
699             }
700 
701             Query q = session.createQuery(query.toString());
702 
703             QueryPos qPos = QueryPos.getInstance(q);
704 
705             qPos.add(groupId);
706 
707             Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
708                     journalArticleImage);
709 
710             JournalArticleImage[] array = new JournalArticleImageImpl[3];
711 
712             array[0] = (JournalArticleImage)objArray[0];
713             array[1] = (JournalArticleImage)objArray[1];
714             array[2] = (JournalArticleImage)objArray[2];
715 
716             return array;
717         }
718         catch (Exception e) {
719             throw processException(e);
720         }
721         finally {
722             closeSession(session);
723         }
724     }
725 
726     public List<JournalArticleImage> findByTempImage(boolean tempImage)
727         throws SystemException {
728         Object[] finderArgs = new Object[] { Boolean.valueOf(tempImage) };
729 
730         List<JournalArticleImage> list = (List<JournalArticleImage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_TEMPIMAGE,
731                 finderArgs, this);
732 
733         if (list == null) {
734             Session session = null;
735 
736             try {
737                 session = openSession();
738 
739                 StringBuilder query = new StringBuilder();
740 
741                 query.append(
742                     "SELECT journalArticleImage FROM JournalArticleImage journalArticleImage WHERE ");
743 
744                 query.append("journalArticleImage.tempImage = ?");
745 
746                 query.append(" ");
747 
748                 Query q = session.createQuery(query.toString());
749 
750                 QueryPos qPos = QueryPos.getInstance(q);
751 
752                 qPos.add(tempImage);
753 
754                 list = q.list();
755             }
756             catch (Exception e) {
757                 throw processException(e);
758             }
759             finally {
760                 if (list == null) {
761                     list = new ArrayList<JournalArticleImage>();
762                 }
763 
764                 cacheResult(list);
765 
766                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_TEMPIMAGE,
767                     finderArgs, list);
768 
769                 closeSession(session);
770             }
771         }
772 
773         return list;
774     }
775 
776     public List<JournalArticleImage> findByTempImage(boolean tempImage,
777         int start, int end) throws SystemException {
778         return findByTempImage(tempImage, start, end, null);
779     }
780 
781     public List<JournalArticleImage> findByTempImage(boolean tempImage,
782         int start, int end, OrderByComparator obc) throws SystemException {
783         Object[] finderArgs = new Object[] {
784                 Boolean.valueOf(tempImage),
785                 
786                 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
787             };
788 
789         List<JournalArticleImage> list = (List<JournalArticleImage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_TEMPIMAGE,
790                 finderArgs, this);
791 
792         if (list == null) {
793             Session session = null;
794 
795             try {
796                 session = openSession();
797 
798                 StringBuilder query = new StringBuilder();
799 
800                 query.append(
801                     "SELECT journalArticleImage FROM JournalArticleImage journalArticleImage WHERE ");
802 
803                 query.append("journalArticleImage.tempImage = ?");
804 
805                 query.append(" ");
806 
807                 if (obc != null) {
808                     query.append("ORDER BY ");
809 
810                     String[] orderByFields = obc.getOrderByFields();
811 
812                     for (int i = 0; i < orderByFields.length; i++) {
813                         query.append("journalArticleImage.");
814                         query.append(orderByFields[i]);
815 
816                         if (obc.isAscending()) {
817                             query.append(" ASC");
818                         }
819                         else {
820                             query.append(" DESC");
821                         }
822 
823                         if ((i + 1) < orderByFields.length) {
824                             query.append(", ");
825                         }
826                     }
827                 }
828 
829                 Query q = session.createQuery(query.toString());
830 
831                 QueryPos qPos = QueryPos.getInstance(q);
832 
833                 qPos.add(tempImage);
834 
835                 list = (List<JournalArticleImage>)QueryUtil.list(q,
836                         getDialect(), start, end);
837             }
838             catch (Exception e) {
839                 throw processException(e);
840             }
841             finally {
842                 if (list == null) {
843                     list = new ArrayList<JournalArticleImage>();
844                 }
845 
846                 cacheResult(list);
847 
848                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_TEMPIMAGE,
849                     finderArgs, list);
850 
851                 closeSession(session);
852             }
853         }
854 
855         return list;
856     }
857 
858     public JournalArticleImage findByTempImage_First(boolean tempImage,
859         OrderByComparator obc)
860         throws NoSuchArticleImageException, SystemException {
861         List<JournalArticleImage> list = findByTempImage(tempImage, 0, 1, obc);
862 
863         if (list.isEmpty()) {
864             StringBuilder msg = new StringBuilder();
865 
866             msg.append("No JournalArticleImage exists with the key {");
867 
868             msg.append("tempImage=" + tempImage);
869 
870             msg.append(StringPool.CLOSE_CURLY_BRACE);
871 
872             throw new NoSuchArticleImageException(msg.toString());
873         }
874         else {
875             return list.get(0);
876         }
877     }
878 
879     public JournalArticleImage findByTempImage_Last(boolean tempImage,
880         OrderByComparator obc)
881         throws NoSuchArticleImageException, SystemException {
882         int count = countByTempImage(tempImage);
883 
884         List<JournalArticleImage> list = findByTempImage(tempImage, count - 1,
885                 count, obc);
886 
887         if (list.isEmpty()) {
888             StringBuilder msg = new StringBuilder();
889 
890             msg.append("No JournalArticleImage exists with the key {");
891 
892             msg.append("tempImage=" + tempImage);
893 
894             msg.append(StringPool.CLOSE_CURLY_BRACE);
895 
896             throw new NoSuchArticleImageException(msg.toString());
897         }
898         else {
899             return list.get(0);
900         }
901     }
902 
903     public JournalArticleImage[] findByTempImage_PrevAndNext(
904         long articleImageId, boolean tempImage, OrderByComparator obc)
905         throws NoSuchArticleImageException, SystemException {
906         JournalArticleImage journalArticleImage = findByPrimaryKey(articleImageId);
907 
908         int count = countByTempImage(tempImage);
909 
910         Session session = null;
911 
912         try {
913             session = openSession();
914 
915             StringBuilder query = new StringBuilder();
916 
917             query.append(
918                 "SELECT journalArticleImage FROM JournalArticleImage journalArticleImage WHERE ");
919 
920             query.append("journalArticleImage.tempImage = ?");
921 
922             query.append(" ");
923 
924             if (obc != null) {
925                 query.append("ORDER BY ");
926 
927                 String[] orderByFields = obc.getOrderByFields();
928 
929                 for (int i = 0; i < orderByFields.length; i++) {
930                     query.append("journalArticleImage.");
931                     query.append(orderByFields[i]);
932 
933                     if (obc.isAscending()) {
934                         query.append(" ASC");
935                     }
936                     else {
937                         query.append(" DESC");
938                     }
939 
940                     if ((i + 1) < orderByFields.length) {
941                         query.append(", ");
942                     }
943                 }
944             }
945 
946             Query q = session.createQuery(query.toString());
947 
948             QueryPos qPos = QueryPos.getInstance(q);
949 
950             qPos.add(tempImage);
951 
952             Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
953                     journalArticleImage);
954 
955             JournalArticleImage[] array = new JournalArticleImageImpl[3];
956 
957             array[0] = (JournalArticleImage)objArray[0];
958             array[1] = (JournalArticleImage)objArray[1];
959             array[2] = (JournalArticleImage)objArray[2];
960 
961             return array;
962         }
963         catch (Exception e) {
964             throw processException(e);
965         }
966         finally {
967             closeSession(session);
968         }
969     }
970 
971     public List<JournalArticleImage> findByG_A_V(long groupId,
972         String articleId, double version) throws SystemException {
973         Object[] finderArgs = new Object[] {
974                 new Long(groupId),
975                 
976                 articleId, new Double(version)
977             };
978 
979         List<JournalArticleImage> list = (List<JournalArticleImage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_A_V,
980                 finderArgs, this);
981 
982         if (list == null) {
983             Session session = null;
984 
985             try {
986                 session = openSession();
987 
988                 StringBuilder query = new StringBuilder();
989 
990                 query.append(
991                     "SELECT journalArticleImage FROM JournalArticleImage journalArticleImage WHERE ");
992 
993                 query.append("journalArticleImage.groupId = ?");
994 
995                 query.append(" AND ");
996 
997                 if (articleId == null) {
998                     query.append("journalArticleImage.articleId IS NULL");
999                 }
1000                else {
1001                    query.append("journalArticleImage.articleId = ?");
1002                }
1003
1004                query.append(" AND ");
1005
1006                query.append("journalArticleImage.version = ?");
1007
1008                query.append(" ");
1009
1010                Query q = session.createQuery(query.toString());
1011
1012                QueryPos qPos = QueryPos.getInstance(q);
1013
1014                qPos.add(groupId);
1015
1016                if (articleId != null) {
1017                    qPos.add(articleId);
1018                }
1019
1020                qPos.add(version);
1021
1022                list = q.list();
1023            }
1024            catch (Exception e) {
1025                throw processException(e);
1026            }
1027            finally {
1028                if (list == null) {
1029                    list = new ArrayList<JournalArticleImage>();
1030                }
1031
1032                cacheResult(list);
1033
1034                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_A_V,
1035                    finderArgs, list);
1036
1037                closeSession(session);
1038            }
1039        }
1040
1041        return list;
1042    }
1043
1044    public List<JournalArticleImage> findByG_A_V(long groupId,
1045        String articleId, double version, int start, int end)
1046        throws SystemException {
1047        return findByG_A_V(groupId, articleId, version, start, end, null);
1048    }
1049
1050    public List<JournalArticleImage> findByG_A_V(long groupId,
1051        String articleId, double version, int start, int end,
1052        OrderByComparator obc) throws SystemException {
1053        Object[] finderArgs = new Object[] {
1054                new Long(groupId),
1055                
1056                articleId, new Double(version),
1057                
1058                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
1059            };
1060
1061        List<JournalArticleImage> list = (List<JournalArticleImage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_G_A_V,
1062                finderArgs, this);
1063
1064        if (list == null) {
1065            Session session = null;
1066
1067            try {
1068                session = openSession();
1069
1070                StringBuilder query = new StringBuilder();
1071
1072                query.append(
1073                    "SELECT journalArticleImage FROM JournalArticleImage journalArticleImage WHERE ");
1074
1075                query.append("journalArticleImage.groupId = ?");
1076
1077                query.append(" AND ");
1078
1079                if (articleId == null) {
1080                    query.append("journalArticleImage.articleId IS NULL");
1081                }
1082                else {
1083                    query.append("journalArticleImage.articleId = ?");
1084                }
1085
1086                query.append(" AND ");
1087
1088                query.append("journalArticleImage.version = ?");
1089
1090                query.append(" ");
1091
1092                if (obc != null) {
1093                    query.append("ORDER BY ");
1094
1095                    String[] orderByFields = obc.getOrderByFields();
1096
1097                    for (int i = 0; i < orderByFields.length; i++) {
1098                        query.append("journalArticleImage.");
1099                        query.append(orderByFields[i]);
1100
1101                        if (obc.isAscending()) {
1102                            query.append(" ASC");
1103                        }
1104                        else {
1105                            query.append(" DESC");
1106                        }
1107
1108                        if ((i + 1) < orderByFields.length) {
1109                            query.append(", ");
1110                        }
1111                    }
1112                }
1113
1114                Query q = session.createQuery(query.toString());
1115
1116                QueryPos qPos = QueryPos.getInstance(q);
1117
1118                qPos.add(groupId);
1119
1120                if (articleId != null) {
1121                    qPos.add(articleId);
1122                }
1123
1124                qPos.add(version);
1125
1126                list = (List<JournalArticleImage>)QueryUtil.list(q,
1127                        getDialect(), start, end);
1128            }
1129            catch (Exception e) {
1130                throw processException(e);
1131            }
1132            finally {
1133                if (list == null) {
1134                    list = new ArrayList<JournalArticleImage>();
1135                }
1136
1137                cacheResult(list);
1138
1139                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_G_A_V,
1140                    finderArgs, list);
1141
1142                closeSession(session);
1143            }
1144        }
1145
1146        return list;
1147    }
1148
1149    public JournalArticleImage findByG_A_V_First(long groupId,
1150        String articleId, double version, OrderByComparator obc)
1151        throws NoSuchArticleImageException, SystemException {
1152        List<JournalArticleImage> list = findByG_A_V(groupId, articleId,
1153                version, 0, 1, obc);
1154
1155        if (list.isEmpty()) {
1156            StringBuilder msg = new StringBuilder();
1157
1158            msg.append("No JournalArticleImage exists with the key {");
1159
1160            msg.append("groupId=" + groupId);
1161
1162            msg.append(", ");
1163            msg.append("articleId=" + articleId);
1164
1165            msg.append(", ");
1166            msg.append("version=" + version);
1167
1168            msg.append(StringPool.CLOSE_CURLY_BRACE);
1169
1170            throw new NoSuchArticleImageException(msg.toString());
1171        }
1172        else {
1173            return list.get(0);
1174        }
1175    }
1176
1177    public JournalArticleImage findByG_A_V_Last(long groupId, String articleId,
1178        double version, OrderByComparator obc)
1179        throws NoSuchArticleImageException, SystemException {
1180        int count = countByG_A_V(groupId, articleId, version);
1181
1182        List<JournalArticleImage> list = findByG_A_V(groupId, articleId,
1183                version, count - 1, count, obc);
1184
1185        if (list.isEmpty()) {
1186            StringBuilder msg = new StringBuilder();
1187
1188            msg.append("No JournalArticleImage exists with the key {");
1189
1190            msg.append("groupId=" + groupId);
1191
1192            msg.append(", ");
1193            msg.append("articleId=" + articleId);
1194
1195            msg.append(", ");
1196            msg.append("version=" + version);
1197
1198            msg.append(StringPool.CLOSE_CURLY_BRACE);
1199
1200            throw new NoSuchArticleImageException(msg.toString());
1201        }
1202        else {
1203            return list.get(0);
1204        }
1205    }
1206
1207    public JournalArticleImage[] findByG_A_V_PrevAndNext(long articleImageId,
1208        long groupId, String articleId, double version, OrderByComparator obc)
1209        throws NoSuchArticleImageException, SystemException {
1210        JournalArticleImage journalArticleImage = findByPrimaryKey(articleImageId);
1211
1212        int count = countByG_A_V(groupId, articleId, version);
1213
1214        Session session = null;
1215
1216        try {
1217            session = openSession();
1218
1219            StringBuilder query = new StringBuilder();
1220
1221            query.append(
1222                "SELECT journalArticleImage FROM JournalArticleImage journalArticleImage WHERE ");
1223
1224            query.append("journalArticleImage.groupId = ?");
1225
1226            query.append(" AND ");
1227
1228            if (articleId == null) {
1229                query.append("journalArticleImage.articleId IS NULL");
1230            }
1231            else {
1232                query.append("journalArticleImage.articleId = ?");
1233            }
1234
1235            query.append(" AND ");
1236
1237            query.append("journalArticleImage.version = ?");
1238
1239            query.append(" ");
1240
1241            if (obc != null) {
1242                query.append("ORDER BY ");
1243
1244                String[] orderByFields = obc.getOrderByFields();
1245
1246                for (int i = 0; i < orderByFields.length; i++) {
1247                    query.append("journalArticleImage.");
1248                    query.append(orderByFields[i]);
1249
1250                    if (obc.isAscending()) {
1251                        query.append(" ASC");
1252                    }
1253                    else {
1254                        query.append(" DESC");
1255                    }
1256
1257                    if ((i + 1) < orderByFields.length) {
1258                        query.append(", ");
1259                    }
1260                }
1261            }
1262
1263            Query q = session.createQuery(query.toString());
1264
1265            QueryPos qPos = QueryPos.getInstance(q);
1266
1267            qPos.add(groupId);
1268
1269            if (articleId != null) {
1270                qPos.add(articleId);
1271            }
1272
1273            qPos.add(version);
1274
1275            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
1276                    journalArticleImage);
1277
1278            JournalArticleImage[] array = new JournalArticleImageImpl[3];
1279
1280            array[0] = (JournalArticleImage)objArray[0];
1281            array[1] = (JournalArticleImage)objArray[1];
1282            array[2] = (JournalArticleImage)objArray[2];
1283
1284            return array;
1285        }
1286        catch (Exception e) {
1287            throw processException(e);
1288        }
1289        finally {
1290            closeSession(session);
1291        }
1292    }
1293
1294    public JournalArticleImage findByG_A_V_E_E_L(long groupId,
1295        String articleId, double version, String elInstanceId, String elName,
1296        String languageId) throws NoSuchArticleImageException, SystemException {
1297        JournalArticleImage journalArticleImage = fetchByG_A_V_E_E_L(groupId,
1298                articleId, version, elInstanceId, elName, languageId);
1299
1300        if (journalArticleImage == null) {
1301            StringBuilder msg = new StringBuilder();
1302
1303            msg.append("No JournalArticleImage exists with the key {");
1304
1305            msg.append("groupId=" + groupId);
1306
1307            msg.append(", ");
1308            msg.append("articleId=" + articleId);
1309
1310            msg.append(", ");
1311            msg.append("version=" + version);
1312
1313            msg.append(", ");
1314            msg.append("elInstanceId=" + elInstanceId);
1315
1316            msg.append(", ");
1317            msg.append("elName=" + elName);
1318
1319            msg.append(", ");
1320            msg.append("languageId=" + languageId);
1321
1322            msg.append(StringPool.CLOSE_CURLY_BRACE);
1323
1324            if (_log.isWarnEnabled()) {
1325                _log.warn(msg.toString());
1326            }
1327
1328            throw new NoSuchArticleImageException(msg.toString());
1329        }
1330
1331        return journalArticleImage;
1332    }
1333
1334    public JournalArticleImage fetchByG_A_V_E_E_L(long groupId,
1335        String articleId, double version, String elInstanceId, String elName,
1336        String languageId) throws SystemException {
1337        return fetchByG_A_V_E_E_L(groupId, articleId, version, elInstanceId,
1338            elName, languageId, true);
1339    }
1340
1341    public JournalArticleImage fetchByG_A_V_E_E_L(long groupId,
1342        String articleId, double version, String elInstanceId, String elName,
1343        String languageId, boolean retrieveFromCache) throws SystemException {
1344        Object[] finderArgs = new Object[] {
1345                new Long(groupId),
1346                
1347                articleId, new Double(version),
1348                
1349                elInstanceId,
1350                
1351                elName,
1352                
1353                languageId
1354            };
1355
1356        Object result = null;
1357
1358        if (retrieveFromCache) {
1359            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_G_A_V_E_E_L,
1360                    finderArgs, this);
1361        }
1362
1363        if (result == null) {
1364            Session session = null;
1365
1366            try {
1367                session = openSession();
1368
1369                StringBuilder query = new StringBuilder();
1370
1371                query.append(
1372                    "SELECT journalArticleImage FROM JournalArticleImage journalArticleImage WHERE ");
1373
1374                query.append("journalArticleImage.groupId = ?");
1375
1376                query.append(" AND ");
1377
1378                if (articleId == null) {
1379                    query.append("journalArticleImage.articleId IS NULL");
1380                }
1381                else {
1382                    query.append("journalArticleImage.articleId = ?");
1383                }
1384
1385                query.append(" AND ");
1386
1387                query.append("journalArticleImage.version = ?");
1388
1389                query.append(" AND ");
1390
1391                if (elInstanceId == null) {
1392                    query.append("journalArticleImage.elInstanceId IS NULL");
1393                }
1394                else {
1395                    query.append("journalArticleImage.elInstanceId = ?");
1396                }
1397
1398                query.append(" AND ");
1399
1400                if (elName == null) {
1401                    query.append("journalArticleImage.elName IS NULL");
1402                }
1403                else {
1404                    query.append("journalArticleImage.elName = ?");
1405                }
1406
1407                query.append(" AND ");
1408
1409                if (languageId == null) {
1410                    query.append("journalArticleImage.languageId IS NULL");
1411                }
1412                else {
1413                    query.append("journalArticleImage.languageId = ?");
1414                }
1415
1416                query.append(" ");
1417
1418                Query q = session.createQuery(query.toString());
1419
1420                QueryPos qPos = QueryPos.getInstance(q);
1421
1422                qPos.add(groupId);
1423
1424                if (articleId != null) {
1425                    qPos.add(articleId);
1426                }
1427
1428                qPos.add(version);
1429
1430                if (elInstanceId != null) {
1431                    qPos.add(elInstanceId);
1432                }
1433
1434                if (elName != null) {
1435                    qPos.add(elName);
1436                }
1437
1438                if (languageId != null) {
1439                    qPos.add(languageId);
1440                }
1441
1442                List<JournalArticleImage> list = q.list();
1443
1444                result = list;
1445
1446                JournalArticleImage journalArticleImage = null;
1447
1448                if (list.isEmpty()) {
1449                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A_V_E_E_L,
1450                        finderArgs, list);
1451                }
1452                else {
1453                    journalArticleImage = list.get(0);
1454
1455                    cacheResult(journalArticleImage);
1456
1457                    if ((journalArticleImage.getGroupId() != groupId) ||
1458                            (journalArticleImage.getArticleId() == null) ||
1459                            !journalArticleImage.getArticleId().equals(articleId) ||
1460                            (journalArticleImage.getVersion() != version) ||
1461                            (journalArticleImage.getElInstanceId() == null) ||
1462                            !journalArticleImage.getElInstanceId()
1463                                                    .equals(elInstanceId) ||
1464                            (journalArticleImage.getElName() == null) ||
1465                            !journalArticleImage.getElName().equals(elName) ||
1466                            (journalArticleImage.getLanguageId() == null) ||
1467                            !journalArticleImage.getLanguageId()
1468                                                    .equals(languageId)) {
1469                        FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A_V_E_E_L,
1470                            finderArgs, journalArticleImage);
1471                    }
1472                }
1473
1474                return journalArticleImage;
1475            }
1476            catch (Exception e) {
1477                throw processException(e);
1478            }
1479            finally {
1480                if (result == null) {
1481                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A_V_E_E_L,
1482                        finderArgs, new ArrayList<JournalArticleImage>());
1483                }
1484
1485                closeSession(session);
1486            }
1487        }
1488        else {
1489            if (result instanceof List) {
1490                return null;
1491            }
1492            else {
1493                return (JournalArticleImage)result;
1494            }
1495        }
1496    }
1497
1498    public List<Object> findWithDynamicQuery(DynamicQuery dynamicQuery)
1499        throws SystemException {
1500        Session session = null;
1501
1502        try {
1503            session = openSession();
1504
1505            dynamicQuery.compile(session);
1506
1507            return dynamicQuery.list();
1508        }
1509        catch (Exception e) {
1510            throw processException(e);
1511        }
1512        finally {
1513            closeSession(session);
1514        }
1515    }
1516
1517    public List<Object> findWithDynamicQuery(DynamicQuery dynamicQuery,
1518        int start, int end) throws SystemException {
1519        Session session = null;
1520
1521        try {
1522            session = openSession();
1523
1524            dynamicQuery.setLimit(start, end);
1525
1526            dynamicQuery.compile(session);
1527
1528            return dynamicQuery.list();
1529        }
1530        catch (Exception e) {
1531            throw processException(e);
1532        }
1533        finally {
1534            closeSession(session);
1535        }
1536    }
1537
1538    public List<JournalArticleImage> findAll() throws SystemException {
1539        return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1540    }
1541
1542    public List<JournalArticleImage> findAll(int start, int end)
1543        throws SystemException {
1544        return findAll(start, end, null);
1545    }
1546
1547    public List<JournalArticleImage> findAll(int start, int end,
1548        OrderByComparator obc) throws SystemException {
1549        Object[] finderArgs = new Object[] {
1550                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
1551            };
1552
1553        List<JournalArticleImage> list = (List<JournalArticleImage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
1554                finderArgs, this);
1555
1556        if (list == null) {
1557            Session session = null;
1558
1559            try {
1560                session = openSession();
1561
1562                StringBuilder query = new StringBuilder();
1563
1564                query.append(
1565                    "SELECT journalArticleImage FROM JournalArticleImage journalArticleImage ");
1566
1567                if (obc != null) {
1568                    query.append("ORDER BY ");
1569
1570                    String[] orderByFields = obc.getOrderByFields();
1571
1572                    for (int i = 0; i < orderByFields.length; i++) {
1573                        query.append("journalArticleImage.");
1574                        query.append(orderByFields[i]);
1575
1576                        if (obc.isAscending()) {
1577                            query.append(" ASC");
1578                        }
1579                        else {
1580                            query.append(" DESC");
1581                        }
1582
1583                        if ((i + 1) < orderByFields.length) {
1584                            query.append(", ");
1585                        }
1586                    }
1587                }
1588
1589                Query q = session.createQuery(query.toString());
1590
1591                if (obc == null) {
1592                    list = (List<JournalArticleImage>)QueryUtil.list(q,
1593                            getDialect(), start, end, false);
1594
1595                    Collections.sort(list);
1596                }
1597                else {
1598                    list = (List<JournalArticleImage>)QueryUtil.list(q,
1599                            getDialect(), start, end);
1600                }
1601            }
1602            catch (Exception e) {
1603                throw processException(e);
1604            }
1605            finally {
1606                if (list == null) {
1607                    list = new ArrayList<JournalArticleImage>();
1608                }
1609
1610                cacheResult(list);
1611
1612                FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
1613
1614                closeSession(session);
1615            }
1616        }
1617
1618        return list;
1619    }
1620
1621    public void removeByGroupId(long groupId) throws SystemException {
1622        for (JournalArticleImage journalArticleImage : findByGroupId(groupId)) {
1623            remove(journalArticleImage);
1624        }
1625    }
1626
1627    public void removeByTempImage(boolean tempImage) throws SystemException {
1628        for (JournalArticleImage journalArticleImage : findByTempImage(
1629                tempImage)) {
1630            remove(journalArticleImage);
1631        }
1632    }
1633
1634    public void removeByG_A_V(long groupId, String articleId, double version)
1635        throws SystemException {
1636        for (JournalArticleImage journalArticleImage : findByG_A_V(groupId,
1637                articleId, version)) {
1638            remove(journalArticleImage);
1639        }
1640    }
1641
1642    public void removeByG_A_V_E_E_L(long groupId, String articleId,
1643        double version, String elInstanceId, String elName, String languageId)
1644        throws NoSuchArticleImageException, SystemException {
1645        JournalArticleImage journalArticleImage = findByG_A_V_E_E_L(groupId,
1646                articleId, version, elInstanceId, elName, languageId);
1647
1648        remove(journalArticleImage);
1649    }
1650
1651    public void removeAll() throws SystemException {
1652        for (JournalArticleImage journalArticleImage : findAll()) {
1653            remove(journalArticleImage);
1654        }
1655    }
1656
1657    public int countByGroupId(long groupId) throws SystemException {
1658        Object[] finderArgs = new Object[] { new Long(groupId) };
1659
1660        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_GROUPID,
1661                finderArgs, this);
1662
1663        if (count == null) {
1664            Session session = null;
1665
1666            try {
1667                session = openSession();
1668
1669                StringBuilder query = new StringBuilder();
1670
1671                query.append("SELECT COUNT(journalArticleImage) ");
1672                query.append(
1673                    "FROM JournalArticleImage journalArticleImage WHERE ");
1674
1675                query.append("journalArticleImage.groupId = ?");
1676
1677                query.append(" ");
1678
1679                Query q = session.createQuery(query.toString());
1680
1681                QueryPos qPos = QueryPos.getInstance(q);
1682
1683                qPos.add(groupId);
1684
1685                count = (Long)q.uniqueResult();
1686            }
1687            catch (Exception e) {
1688                throw processException(e);
1689            }
1690            finally {
1691                if (count == null) {
1692                    count = Long.valueOf(0);
1693                }
1694
1695                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_GROUPID,
1696                    finderArgs, count);
1697
1698                closeSession(session);
1699            }
1700        }
1701
1702        return count.intValue();
1703    }
1704
1705    public int countByTempImage(boolean tempImage) throws SystemException {
1706        Object[] finderArgs = new Object[] { Boolean.valueOf(tempImage) };
1707
1708        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_TEMPIMAGE,
1709                finderArgs, this);
1710
1711        if (count == null) {
1712            Session session = null;
1713
1714            try {
1715                session = openSession();
1716
1717                StringBuilder query = new StringBuilder();
1718
1719                query.append("SELECT COUNT(journalArticleImage) ");
1720                query.append(
1721                    "FROM JournalArticleImage journalArticleImage WHERE ");
1722
1723                query.append("journalArticleImage.tempImage = ?");
1724
1725                query.append(" ");
1726
1727                Query q = session.createQuery(query.toString());
1728
1729                QueryPos qPos = QueryPos.getInstance(q);
1730
1731                qPos.add(tempImage);
1732
1733                count = (Long)q.uniqueResult();
1734            }
1735            catch (Exception e) {
1736                throw processException(e);
1737            }
1738            finally {
1739                if (count == null) {
1740                    count = Long.valueOf(0);
1741                }
1742
1743                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_TEMPIMAGE,
1744                    finderArgs, count);
1745
1746                closeSession(session);
1747            }
1748        }
1749
1750        return count.intValue();
1751    }
1752
1753    public int countByG_A_V(long groupId, String articleId, double version)
1754        throws SystemException {
1755        Object[] finderArgs = new Object[] {
1756                new Long(groupId),
1757                
1758                articleId, new Double(version)
1759            };
1760
1761        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_A_V,
1762                finderArgs, this);
1763
1764        if (count == null) {
1765            Session session = null;
1766
1767            try {
1768                session = openSession();
1769
1770                StringBuilder query = new StringBuilder();
1771
1772                query.append("SELECT COUNT(journalArticleImage) ");
1773                query.append(
1774                    "FROM JournalArticleImage journalArticleImage WHERE ");
1775
1776                query.append("journalArticleImage.groupId = ?");
1777
1778                query.append(" AND ");
1779
1780                if (articleId == null) {
1781                    query.append("journalArticleImage.articleId IS NULL");
1782                }
1783                else {
1784                    query.append("journalArticleImage.articleId = ?");
1785                }
1786
1787                query.append(" AND ");
1788
1789                query.append("journalArticleImage.version = ?");
1790
1791                query.append(" ");
1792
1793                Query q = session.createQuery(query.toString());
1794
1795                QueryPos qPos = QueryPos.getInstance(q);
1796
1797                qPos.add(groupId);
1798
1799                if (articleId != null) {
1800                    qPos.add(articleId);
1801                }
1802
1803                qPos.add(version);
1804
1805                count = (Long)q.uniqueResult();
1806            }
1807            catch (Exception e) {
1808                throw processException(e);
1809            }
1810            finally {
1811                if (count == null) {
1812                    count = Long.valueOf(0);
1813                }
1814
1815                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_A_V,
1816                    finderArgs, count);
1817
1818                closeSession(session);
1819            }
1820        }
1821
1822        return count.intValue();
1823    }
1824
1825    public int countByG_A_V_E_E_L(long groupId, String articleId,
1826        double version, String elInstanceId, String elName, String languageId)
1827        throws SystemException {
1828        Object[] finderArgs = new Object[] {
1829                new Long(groupId),
1830                
1831                articleId, new Double(version),
1832                
1833                elInstanceId,
1834                
1835                elName,
1836                
1837                languageId
1838            };
1839
1840        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_A_V_E_E_L,
1841                finderArgs, this);
1842
1843        if (count == null) {
1844            Session session = null;
1845
1846            try {
1847                session = openSession();
1848
1849                StringBuilder query = new StringBuilder();
1850
1851                query.append("SELECT COUNT(journalArticleImage) ");
1852                query.append(
1853                    "FROM JournalArticleImage journalArticleImage WHERE ");
1854
1855                query.append("journalArticleImage.groupId = ?");
1856
1857                query.append(" AND ");
1858
1859                if (articleId == null) {
1860                    query.append("journalArticleImage.articleId IS NULL");
1861                }
1862                else {
1863                    query.append("journalArticleImage.articleId = ?");
1864                }
1865
1866                query.append(" AND ");
1867
1868                query.append("journalArticleImage.version = ?");
1869
1870                query.append(" AND ");
1871
1872                if (elInstanceId == null) {
1873                    query.append("journalArticleImage.elInstanceId IS NULL");
1874                }
1875                else {
1876                    query.append("journalArticleImage.elInstanceId = ?");
1877                }
1878
1879                query.append(" AND ");
1880
1881                if (elName == null) {
1882                    query.append("journalArticleImage.elName IS NULL");
1883                }
1884                else {
1885                    query.append("journalArticleImage.elName = ?");
1886                }
1887
1888                query.append(" AND ");
1889
1890                if (languageId == null) {
1891                    query.append("journalArticleImage.languageId IS NULL");
1892                }
1893                else {
1894                    query.append("journalArticleImage.languageId = ?");
1895                }
1896
1897                query.append(" ");
1898
1899                Query q = session.createQuery(query.toString());
1900
1901                QueryPos qPos = QueryPos.getInstance(q);
1902
1903                qPos.add(groupId);
1904
1905                if (articleId != null) {
1906                    qPos.add(articleId);
1907                }
1908
1909                qPos.add(version);
1910
1911                if (elInstanceId != null) {
1912                    qPos.add(elInstanceId);
1913                }
1914
1915                if (elName != null) {
1916                    qPos.add(elName);
1917                }
1918
1919                if (languageId != null) {
1920                    qPos.add(languageId);
1921                }
1922
1923                count = (Long)q.uniqueResult();
1924            }
1925            catch (Exception e) {
1926                throw processException(e);
1927            }
1928            finally {
1929                if (count == null) {
1930                    count = Long.valueOf(0);
1931                }
1932
1933                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_A_V_E_E_L,
1934                    finderArgs, count);
1935
1936                closeSession(session);
1937            }
1938        }
1939
1940        return count.intValue();
1941    }
1942
1943    public int countAll() throws SystemException {
1944        Object[] finderArgs = new Object[0];
1945
1946        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
1947                finderArgs, this);
1948
1949        if (count == null) {
1950            Session session = null;
1951
1952            try {
1953                session = openSession();
1954
1955                Query q = session.createQuery(
1956                        "SELECT COUNT(journalArticleImage) FROM JournalArticleImage journalArticleImage");
1957
1958                count = (Long)q.uniqueResult();
1959            }
1960            catch (Exception e) {
1961                throw processException(e);
1962            }
1963            finally {
1964                if (count == null) {
1965                    count = Long.valueOf(0);
1966                }
1967
1968                FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
1969                    count);
1970
1971                closeSession(session);
1972            }
1973        }
1974
1975        return count.intValue();
1976    }
1977
1978    public void afterPropertiesSet() {
1979        String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
1980                    com.liferay.portal.util.PropsUtil.get(
1981                        "value.object.listener.com.liferay.portlet.journal.model.JournalArticleImage")));
1982
1983        if (listenerClassNames.length > 0) {
1984            try {
1985                List<ModelListener<JournalArticleImage>> listenersList = new ArrayList<ModelListener<JournalArticleImage>>();
1986
1987                for (String listenerClassName : listenerClassNames) {
1988                    listenersList.add((ModelListener<JournalArticleImage>)Class.forName(
1989                            listenerClassName).newInstance());
1990                }
1991
1992                listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
1993            }
1994            catch (Exception e) {
1995                _log.error(e);
1996            }
1997        }
1998    }
1999
2000    @BeanReference(name = "com.liferay.portlet.journal.service.persistence.JournalArticlePersistence.impl")
2001    protected com.liferay.portlet.journal.service.persistence.JournalArticlePersistence journalArticlePersistence;
2002    @BeanReference(name = "com.liferay.portlet.journal.service.persistence.JournalArticleImagePersistence.impl")
2003    protected com.liferay.portlet.journal.service.persistence.JournalArticleImagePersistence journalArticleImagePersistence;
2004    @BeanReference(name = "com.liferay.portlet.journal.service.persistence.JournalArticleResourcePersistence.impl")
2005    protected com.liferay.portlet.journal.service.persistence.JournalArticleResourcePersistence journalArticleResourcePersistence;
2006    @BeanReference(name = "com.liferay.portlet.journal.service.persistence.JournalContentSearchPersistence.impl")
2007    protected com.liferay.portlet.journal.service.persistence.JournalContentSearchPersistence journalContentSearchPersistence;
2008    @BeanReference(name = "com.liferay.portlet.journal.service.persistence.JournalFeedPersistence.impl")
2009    protected com.liferay.portlet.journal.service.persistence.JournalFeedPersistence journalFeedPersistence;
2010    @BeanReference(name = "com.liferay.portlet.journal.service.persistence.JournalStructurePersistence.impl")
2011    protected com.liferay.portlet.journal.service.persistence.JournalStructurePersistence journalStructurePersistence;
2012    @BeanReference(name = "com.liferay.portlet.journal.service.persistence.JournalTemplatePersistence.impl")
2013    protected com.liferay.portlet.journal.service.persistence.JournalTemplatePersistence journalTemplatePersistence;
2014    @BeanReference(name = "com.liferay.portal.service.persistence.ImagePersistence.impl")
2015    protected com.liferay.portal.service.persistence.ImagePersistence imagePersistence;
2016    private static Log _log = LogFactoryUtil.getLog(JournalArticleImagePersistenceImpl.class);
2017}