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