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