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