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