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