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