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