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