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