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