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