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