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