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