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