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