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