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