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