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.documentlibrary.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.ResourcePersistence;
043    import com.liferay.portal.service.persistence.UserPersistence;
044    import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
045    
046    import com.liferay.portlet.asset.service.persistence.AssetEntryPersistence;
047    import com.liferay.portlet.asset.service.persistence.AssetTagPersistence;
048    import com.liferay.portlet.documentlibrary.NoSuchFileShortcutException;
049    import com.liferay.portlet.documentlibrary.model.DLFileShortcut;
050    import com.liferay.portlet.documentlibrary.model.impl.DLFileShortcutImpl;
051    import com.liferay.portlet.documentlibrary.model.impl.DLFileShortcutModelImpl;
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       DLFileShortcutPersistence
062     * @see       DLFileShortcutUtil
063     * @generated
064     */
065    public class DLFileShortcutPersistenceImpl extends BasePersistenceImpl<DLFileShortcut>
066            implements DLFileShortcutPersistence {
067            public static final String FINDER_CLASS_NAME_ENTITY = DLFileShortcutImpl.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(DLFileShortcutModelImpl.ENTITY_CACHE_ENABLED,
071                            DLFileShortcutModelImpl.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(DLFileShortcutModelImpl.ENTITY_CACHE_ENABLED,
080                            DLFileShortcutModelImpl.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(DLFileShortcutModelImpl.ENTITY_CACHE_ENABLED,
084                            DLFileShortcutModelImpl.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(DLFileShortcutModelImpl.ENTITY_CACHE_ENABLED,
088                            DLFileShortcutModelImpl.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_G_F = new FinderPath(DLFileShortcutModelImpl.ENTITY_CACHE_ENABLED,
092                            DLFileShortcutModelImpl.FINDER_CACHE_ENABLED,
093                            FINDER_CLASS_NAME_LIST, "findByG_F",
094                            new String[] {
095                                    Long.class.getName(), 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_G_F = new FinderPath(DLFileShortcutModelImpl.ENTITY_CACHE_ENABLED,
101                            DLFileShortcutModelImpl.FINDER_CACHE_ENABLED,
102                            FINDER_CLASS_NAME_LIST, "countByG_F",
103                            new String[] { Long.class.getName(), Long.class.getName() });
104            public static final FinderPath FINDER_PATH_FIND_BY_G_F_S = new FinderPath(DLFileShortcutModelImpl.ENTITY_CACHE_ENABLED,
105                            DLFileShortcutModelImpl.FINDER_CACHE_ENABLED,
106                            FINDER_CLASS_NAME_LIST, "findByG_F_S",
107                            new String[] {
108                                    Long.class.getName(), Long.class.getName(),
109                                    Integer.class.getName(),
110                                    
111                            "java.lang.Integer", "java.lang.Integer",
112                                    "com.liferay.portal.kernel.util.OrderByComparator"
113                            });
114            public static final FinderPath FINDER_PATH_COUNT_BY_G_F_S = new FinderPath(DLFileShortcutModelImpl.ENTITY_CACHE_ENABLED,
115                            DLFileShortcutModelImpl.FINDER_CACHE_ENABLED,
116                            FINDER_CLASS_NAME_LIST, "countByG_F_S",
117                            new String[] {
118                                    Long.class.getName(), Long.class.getName(),
119                                    Integer.class.getName()
120                            });
121            public static final FinderPath FINDER_PATH_FIND_BY_G_TF_TN = new FinderPath(DLFileShortcutModelImpl.ENTITY_CACHE_ENABLED,
122                            DLFileShortcutModelImpl.FINDER_CACHE_ENABLED,
123                            FINDER_CLASS_NAME_LIST, "findByG_TF_TN",
124                            new String[] {
125                                    Long.class.getName(), Long.class.getName(),
126                                    String.class.getName(),
127                                    
128                            "java.lang.Integer", "java.lang.Integer",
129                                    "com.liferay.portal.kernel.util.OrderByComparator"
130                            });
131            public static final FinderPath FINDER_PATH_COUNT_BY_G_TF_TN = new FinderPath(DLFileShortcutModelImpl.ENTITY_CACHE_ENABLED,
132                            DLFileShortcutModelImpl.FINDER_CACHE_ENABLED,
133                            FINDER_CLASS_NAME_LIST, "countByG_TF_TN",
134                            new String[] {
135                                    Long.class.getName(), Long.class.getName(),
136                                    String.class.getName()
137                            });
138            public static final FinderPath FINDER_PATH_FIND_BY_G_TF_TN_S = new FinderPath(DLFileShortcutModelImpl.ENTITY_CACHE_ENABLED,
139                            DLFileShortcutModelImpl.FINDER_CACHE_ENABLED,
140                            FINDER_CLASS_NAME_LIST, "findByG_TF_TN_S",
141                            new String[] {
142                                    Long.class.getName(), Long.class.getName(),
143                                    String.class.getName(), Integer.class.getName(),
144                                    
145                            "java.lang.Integer", "java.lang.Integer",
146                                    "com.liferay.portal.kernel.util.OrderByComparator"
147                            });
148            public static final FinderPath FINDER_PATH_COUNT_BY_G_TF_TN_S = new FinderPath(DLFileShortcutModelImpl.ENTITY_CACHE_ENABLED,
149                            DLFileShortcutModelImpl.FINDER_CACHE_ENABLED,
150                            FINDER_CLASS_NAME_LIST, "countByG_TF_TN_S",
151                            new String[] {
152                                    Long.class.getName(), Long.class.getName(),
153                                    String.class.getName(), Integer.class.getName()
154                            });
155            public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(DLFileShortcutModelImpl.ENTITY_CACHE_ENABLED,
156                            DLFileShortcutModelImpl.FINDER_CACHE_ENABLED,
157                            FINDER_CLASS_NAME_LIST, "findAll", new String[0]);
158            public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(DLFileShortcutModelImpl.ENTITY_CACHE_ENABLED,
159                            DLFileShortcutModelImpl.FINDER_CACHE_ENABLED,
160                            FINDER_CLASS_NAME_LIST, "countAll", new String[0]);
161    
162            public void cacheResult(DLFileShortcut dlFileShortcut) {
163                    EntityCacheUtil.putResult(DLFileShortcutModelImpl.ENTITY_CACHE_ENABLED,
164                            DLFileShortcutImpl.class, dlFileShortcut.getPrimaryKey(),
165                            dlFileShortcut);
166    
167                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
168                            new Object[] {
169                                    dlFileShortcut.getUuid(), new Long(dlFileShortcut.getGroupId())
170                            }, dlFileShortcut);
171            }
172    
173            public void cacheResult(List<DLFileShortcut> dlFileShortcuts) {
174                    for (DLFileShortcut dlFileShortcut : dlFileShortcuts) {
175                            if (EntityCacheUtil.getResult(
176                                                    DLFileShortcutModelImpl.ENTITY_CACHE_ENABLED,
177                                                    DLFileShortcutImpl.class,
178                                                    dlFileShortcut.getPrimaryKey(), this) == null) {
179                                    cacheResult(dlFileShortcut);
180                            }
181                    }
182            }
183    
184            public void clearCache() {
185                    CacheRegistryUtil.clear(DLFileShortcutImpl.class.getName());
186                    EntityCacheUtil.clearCache(DLFileShortcutImpl.class.getName());
187                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
188                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
189            }
190    
191            public void clearCache(DLFileShortcut dlFileShortcut) {
192                    EntityCacheUtil.removeResult(DLFileShortcutModelImpl.ENTITY_CACHE_ENABLED,
193                            DLFileShortcutImpl.class, dlFileShortcut.getPrimaryKey());
194    
195                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
196                            new Object[] {
197                                    dlFileShortcut.getUuid(), new Long(dlFileShortcut.getGroupId())
198                            });
199            }
200    
201            public DLFileShortcut create(long fileShortcutId) {
202                    DLFileShortcut dlFileShortcut = new DLFileShortcutImpl();
203    
204                    dlFileShortcut.setNew(true);
205                    dlFileShortcut.setPrimaryKey(fileShortcutId);
206    
207                    String uuid = PortalUUIDUtil.generate();
208    
209                    dlFileShortcut.setUuid(uuid);
210    
211                    return dlFileShortcut;
212            }
213    
214            public DLFileShortcut remove(Serializable primaryKey)
215                    throws NoSuchModelException, SystemException {
216                    return remove(((Long)primaryKey).longValue());
217            }
218    
219            public DLFileShortcut remove(long fileShortcutId)
220                    throws NoSuchFileShortcutException, SystemException {
221                    Session session = null;
222    
223                    try {
224                            session = openSession();
225    
226                            DLFileShortcut dlFileShortcut = (DLFileShortcut)session.get(DLFileShortcutImpl.class,
227                                            new Long(fileShortcutId));
228    
229                            if (dlFileShortcut == null) {
230                                    if (_log.isWarnEnabled()) {
231                                            _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
232                                                    fileShortcutId);
233                                    }
234    
235                                    throw new NoSuchFileShortcutException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
236                                            fileShortcutId);
237                            }
238    
239                            return remove(dlFileShortcut);
240                    }
241                    catch (NoSuchFileShortcutException nsee) {
242                            throw nsee;
243                    }
244                    catch (Exception e) {
245                            throw processException(e);
246                    }
247                    finally {
248                            closeSession(session);
249                    }
250            }
251    
252            protected DLFileShortcut removeImpl(DLFileShortcut dlFileShortcut)
253                    throws SystemException {
254                    dlFileShortcut = toUnwrappedModel(dlFileShortcut);
255    
256                    Session session = null;
257    
258                    try {
259                            session = openSession();
260    
261                            if (dlFileShortcut.isCachedModel() || BatchSessionUtil.isEnabled()) {
262                                    Object staleObject = session.get(DLFileShortcutImpl.class,
263                                                    dlFileShortcut.getPrimaryKeyObj());
264    
265                                    if (staleObject != null) {
266                                            session.evict(staleObject);
267                                    }
268                            }
269    
270                            session.delete(dlFileShortcut);
271    
272                            session.flush();
273                    }
274                    catch (Exception e) {
275                            throw processException(e);
276                    }
277                    finally {
278                            closeSession(session);
279                    }
280    
281                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
282    
283                    DLFileShortcutModelImpl dlFileShortcutModelImpl = (DLFileShortcutModelImpl)dlFileShortcut;
284    
285                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
286                            new Object[] {
287                                    dlFileShortcutModelImpl.getOriginalUuid(),
288                                    new Long(dlFileShortcutModelImpl.getOriginalGroupId())
289                            });
290    
291                    EntityCacheUtil.removeResult(DLFileShortcutModelImpl.ENTITY_CACHE_ENABLED,
292                            DLFileShortcutImpl.class, dlFileShortcut.getPrimaryKey());
293    
294                    return dlFileShortcut;
295            }
296    
297            public DLFileShortcut updateImpl(
298                    com.liferay.portlet.documentlibrary.model.DLFileShortcut dlFileShortcut,
299                    boolean merge) throws SystemException {
300                    dlFileShortcut = toUnwrappedModel(dlFileShortcut);
301    
302                    boolean isNew = dlFileShortcut.isNew();
303    
304                    DLFileShortcutModelImpl dlFileShortcutModelImpl = (DLFileShortcutModelImpl)dlFileShortcut;
305    
306                    if (Validator.isNull(dlFileShortcut.getUuid())) {
307                            String uuid = PortalUUIDUtil.generate();
308    
309                            dlFileShortcut.setUuid(uuid);
310                    }
311    
312                    Session session = null;
313    
314                    try {
315                            session = openSession();
316    
317                            BatchSessionUtil.update(session, dlFileShortcut, merge);
318    
319                            dlFileShortcut.setNew(false);
320                    }
321                    catch (Exception e) {
322                            throw processException(e);
323                    }
324                    finally {
325                            closeSession(session);
326                    }
327    
328                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
329    
330                    EntityCacheUtil.putResult(DLFileShortcutModelImpl.ENTITY_CACHE_ENABLED,
331                            DLFileShortcutImpl.class, dlFileShortcut.getPrimaryKey(),
332                            dlFileShortcut);
333    
334                    if (!isNew &&
335                                    (!Validator.equals(dlFileShortcut.getUuid(),
336                                            dlFileShortcutModelImpl.getOriginalUuid()) ||
337                                    (dlFileShortcut.getGroupId() != dlFileShortcutModelImpl.getOriginalGroupId()))) {
338                            FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
339                                    new Object[] {
340                                            dlFileShortcutModelImpl.getOriginalUuid(),
341                                            new Long(dlFileShortcutModelImpl.getOriginalGroupId())
342                                    });
343                    }
344    
345                    if (isNew ||
346                                    (!Validator.equals(dlFileShortcut.getUuid(),
347                                            dlFileShortcutModelImpl.getOriginalUuid()) ||
348                                    (dlFileShortcut.getGroupId() != dlFileShortcutModelImpl.getOriginalGroupId()))) {
349                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
350                                    new Object[] {
351                                            dlFileShortcut.getUuid(),
352                                            new Long(dlFileShortcut.getGroupId())
353                                    }, dlFileShortcut);
354                    }
355    
356                    return dlFileShortcut;
357            }
358    
359            protected DLFileShortcut toUnwrappedModel(DLFileShortcut dlFileShortcut) {
360                    if (dlFileShortcut instanceof DLFileShortcutImpl) {
361                            return dlFileShortcut;
362                    }
363    
364                    DLFileShortcutImpl dlFileShortcutImpl = new DLFileShortcutImpl();
365    
366                    dlFileShortcutImpl.setNew(dlFileShortcut.isNew());
367                    dlFileShortcutImpl.setPrimaryKey(dlFileShortcut.getPrimaryKey());
368    
369                    dlFileShortcutImpl.setUuid(dlFileShortcut.getUuid());
370                    dlFileShortcutImpl.setFileShortcutId(dlFileShortcut.getFileShortcutId());
371                    dlFileShortcutImpl.setGroupId(dlFileShortcut.getGroupId());
372                    dlFileShortcutImpl.setCompanyId(dlFileShortcut.getCompanyId());
373                    dlFileShortcutImpl.setUserId(dlFileShortcut.getUserId());
374                    dlFileShortcutImpl.setUserName(dlFileShortcut.getUserName());
375                    dlFileShortcutImpl.setCreateDate(dlFileShortcut.getCreateDate());
376                    dlFileShortcutImpl.setModifiedDate(dlFileShortcut.getModifiedDate());
377                    dlFileShortcutImpl.setFolderId(dlFileShortcut.getFolderId());
378                    dlFileShortcutImpl.setToFolderId(dlFileShortcut.getToFolderId());
379                    dlFileShortcutImpl.setToName(dlFileShortcut.getToName());
380                    dlFileShortcutImpl.setStatus(dlFileShortcut.getStatus());
381                    dlFileShortcutImpl.setStatusByUserId(dlFileShortcut.getStatusByUserId());
382                    dlFileShortcutImpl.setStatusByUserName(dlFileShortcut.getStatusByUserName());
383                    dlFileShortcutImpl.setStatusDate(dlFileShortcut.getStatusDate());
384    
385                    return dlFileShortcutImpl;
386            }
387    
388            public DLFileShortcut findByPrimaryKey(Serializable primaryKey)
389                    throws NoSuchModelException, SystemException {
390                    return findByPrimaryKey(((Long)primaryKey).longValue());
391            }
392    
393            public DLFileShortcut findByPrimaryKey(long fileShortcutId)
394                    throws NoSuchFileShortcutException, SystemException {
395                    DLFileShortcut dlFileShortcut = fetchByPrimaryKey(fileShortcutId);
396    
397                    if (dlFileShortcut == null) {
398                            if (_log.isWarnEnabled()) {
399                                    _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + fileShortcutId);
400                            }
401    
402                            throw new NoSuchFileShortcutException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
403                                    fileShortcutId);
404                    }
405    
406                    return dlFileShortcut;
407            }
408    
409            public DLFileShortcut fetchByPrimaryKey(Serializable primaryKey)
410                    throws SystemException {
411                    return fetchByPrimaryKey(((Long)primaryKey).longValue());
412            }
413    
414            public DLFileShortcut fetchByPrimaryKey(long fileShortcutId)
415                    throws SystemException {
416                    DLFileShortcut dlFileShortcut = (DLFileShortcut)EntityCacheUtil.getResult(DLFileShortcutModelImpl.ENTITY_CACHE_ENABLED,
417                                    DLFileShortcutImpl.class, fileShortcutId, this);
418    
419                    if (dlFileShortcut == null) {
420                            Session session = null;
421    
422                            try {
423                                    session = openSession();
424    
425                                    dlFileShortcut = (DLFileShortcut)session.get(DLFileShortcutImpl.class,
426                                                    new Long(fileShortcutId));
427                            }
428                            catch (Exception e) {
429                                    throw processException(e);
430                            }
431                            finally {
432                                    if (dlFileShortcut != null) {
433                                            cacheResult(dlFileShortcut);
434                                    }
435    
436                                    closeSession(session);
437                            }
438                    }
439    
440                    return dlFileShortcut;
441            }
442    
443            public List<DLFileShortcut> findByUuid(String uuid)
444                    throws SystemException {
445                    return findByUuid(uuid, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
446            }
447    
448            public List<DLFileShortcut> findByUuid(String uuid, int start, int end)
449                    throws SystemException {
450                    return findByUuid(uuid, start, end, null);
451            }
452    
453            public List<DLFileShortcut> findByUuid(String uuid, int start, int end,
454                    OrderByComparator orderByComparator) throws SystemException {
455                    Object[] finderArgs = new Object[] {
456                                    uuid,
457                                    
458                                    String.valueOf(start), String.valueOf(end),
459                                    String.valueOf(orderByComparator)
460                            };
461    
462                    List<DLFileShortcut> list = (List<DLFileShortcut>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_UUID,
463                                    finderArgs, this);
464    
465                    if (list == null) {
466                            Session session = null;
467    
468                            try {
469                                    session = openSession();
470    
471                                    StringBundler query = null;
472    
473                                    if (orderByComparator != null) {
474                                            query = new StringBundler(3 +
475                                                            (orderByComparator.getOrderByFields().length * 3));
476                                    }
477                                    else {
478                                            query = new StringBundler(2);
479                                    }
480    
481                                    query.append(_SQL_SELECT_DLFILESHORTCUT_WHERE);
482    
483                                    if (uuid == null) {
484                                            query.append(_FINDER_COLUMN_UUID_UUID_1);
485                                    }
486                                    else {
487                                            if (uuid.equals(StringPool.BLANK)) {
488                                                    query.append(_FINDER_COLUMN_UUID_UUID_3);
489                                            }
490                                            else {
491                                                    query.append(_FINDER_COLUMN_UUID_UUID_2);
492                                            }
493                                    }
494    
495                                    if (orderByComparator != null) {
496                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
497                                                    orderByComparator);
498                                    }
499    
500                                    String sql = query.toString();
501    
502                                    Query q = session.createQuery(sql);
503    
504                                    QueryPos qPos = QueryPos.getInstance(q);
505    
506                                    if (uuid != null) {
507                                            qPos.add(uuid);
508                                    }
509    
510                                    list = (List<DLFileShortcut>)QueryUtil.list(q, getDialect(),
511                                                    start, end);
512                            }
513                            catch (Exception e) {
514                                    throw processException(e);
515                            }
516                            finally {
517                                    if (list == null) {
518                                            list = new ArrayList<DLFileShortcut>();
519                                    }
520    
521                                    cacheResult(list);
522    
523                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_UUID, finderArgs,
524                                            list);
525    
526                                    closeSession(session);
527                            }
528                    }
529    
530                    return list;
531            }
532    
533            public DLFileShortcut findByUuid_First(String uuid,
534                    OrderByComparator orderByComparator)
535                    throws NoSuchFileShortcutException, SystemException {
536                    List<DLFileShortcut> list = findByUuid(uuid, 0, 1, orderByComparator);
537    
538                    if (list.isEmpty()) {
539                            StringBundler msg = new StringBundler(4);
540    
541                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
542    
543                            msg.append("uuid=");
544                            msg.append(uuid);
545    
546                            msg.append(StringPool.CLOSE_CURLY_BRACE);
547    
548                            throw new NoSuchFileShortcutException(msg.toString());
549                    }
550                    else {
551                            return list.get(0);
552                    }
553            }
554    
555            public DLFileShortcut findByUuid_Last(String uuid,
556                    OrderByComparator orderByComparator)
557                    throws NoSuchFileShortcutException, SystemException {
558                    int count = countByUuid(uuid);
559    
560                    List<DLFileShortcut> list = findByUuid(uuid, count - 1, count,
561                                    orderByComparator);
562    
563                    if (list.isEmpty()) {
564                            StringBundler msg = new StringBundler(4);
565    
566                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
567    
568                            msg.append("uuid=");
569                            msg.append(uuid);
570    
571                            msg.append(StringPool.CLOSE_CURLY_BRACE);
572    
573                            throw new NoSuchFileShortcutException(msg.toString());
574                    }
575                    else {
576                            return list.get(0);
577                    }
578            }
579    
580            public DLFileShortcut[] findByUuid_PrevAndNext(long fileShortcutId,
581                    String uuid, OrderByComparator orderByComparator)
582                    throws NoSuchFileShortcutException, SystemException {
583                    DLFileShortcut dlFileShortcut = findByPrimaryKey(fileShortcutId);
584    
585                    Session session = null;
586    
587                    try {
588                            session = openSession();
589    
590                            DLFileShortcut[] array = new DLFileShortcutImpl[3];
591    
592                            array[0] = getByUuid_PrevAndNext(session, dlFileShortcut, uuid,
593                                            orderByComparator, true);
594    
595                            array[1] = dlFileShortcut;
596    
597                            array[2] = getByUuid_PrevAndNext(session, dlFileShortcut, uuid,
598                                            orderByComparator, false);
599    
600                            return array;
601                    }
602                    catch (Exception e) {
603                            throw processException(e);
604                    }
605                    finally {
606                            closeSession(session);
607                    }
608            }
609    
610            protected DLFileShortcut getByUuid_PrevAndNext(Session session,
611                    DLFileShortcut dlFileShortcut, String uuid,
612                    OrderByComparator orderByComparator, boolean previous) {
613                    StringBundler query = null;
614    
615                    if (orderByComparator != null) {
616                            query = new StringBundler(6 +
617                                            (orderByComparator.getOrderByFields().length * 6));
618                    }
619                    else {
620                            query = new StringBundler(3);
621                    }
622    
623                    query.append(_SQL_SELECT_DLFILESHORTCUT_WHERE);
624    
625                    if (uuid == null) {
626                            query.append(_FINDER_COLUMN_UUID_UUID_1);
627                    }
628                    else {
629                            if (uuid.equals(StringPool.BLANK)) {
630                                    query.append(_FINDER_COLUMN_UUID_UUID_3);
631                            }
632                            else {
633                                    query.append(_FINDER_COLUMN_UUID_UUID_2);
634                            }
635                    }
636    
637                    if (orderByComparator != null) {
638                            String[] orderByFields = orderByComparator.getOrderByFields();
639    
640                            if (orderByFields.length > 0) {
641                                    query.append(WHERE_AND);
642                            }
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(WHERE_GREATER_THAN_HAS_NEXT);
651                                            }
652                                            else {
653                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
654                                            }
655                                    }
656                                    else {
657                                            if (orderByComparator.isAscending() ^ previous) {
658                                                    query.append(WHERE_GREATER_THAN);
659                                            }
660                                            else {
661                                                    query.append(WHERE_LESSER_THAN);
662                                            }
663                                    }
664                            }
665    
666                            query.append(ORDER_BY_CLAUSE);
667    
668                            for (int i = 0; i < orderByFields.length; i++) {
669                                    query.append(_ORDER_BY_ENTITY_ALIAS);
670                                    query.append(orderByFields[i]);
671    
672                                    if ((i + 1) < orderByFields.length) {
673                                            if (orderByComparator.isAscending() ^ previous) {
674                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
675                                            }
676                                            else {
677                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
678                                            }
679                                    }
680                                    else {
681                                            if (orderByComparator.isAscending() ^ previous) {
682                                                    query.append(ORDER_BY_ASC);
683                                            }
684                                            else {
685                                                    query.append(ORDER_BY_DESC);
686                                            }
687                                    }
688                            }
689                    }
690    
691                    String sql = query.toString();
692    
693                    Query q = session.createQuery(sql);
694    
695                    q.setFirstResult(0);
696                    q.setMaxResults(2);
697    
698                    QueryPos qPos = QueryPos.getInstance(q);
699    
700                    if (uuid != null) {
701                            qPos.add(uuid);
702                    }
703    
704                    if (orderByComparator != null) {
705                            Object[] values = orderByComparator.getOrderByValues(dlFileShortcut);
706    
707                            for (Object value : values) {
708                                    qPos.add(value);
709                            }
710                    }
711    
712                    List<DLFileShortcut> list = q.list();
713    
714                    if (list.size() == 2) {
715                            return list.get(1);
716                    }
717                    else {
718                            return null;
719                    }
720            }
721    
722            public DLFileShortcut findByUUID_G(String uuid, long groupId)
723                    throws NoSuchFileShortcutException, SystemException {
724                    DLFileShortcut dlFileShortcut = fetchByUUID_G(uuid, groupId);
725    
726                    if (dlFileShortcut == null) {
727                            StringBundler msg = new StringBundler(6);
728    
729                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
730    
731                            msg.append("uuid=");
732                            msg.append(uuid);
733    
734                            msg.append(", groupId=");
735                            msg.append(groupId);
736    
737                            msg.append(StringPool.CLOSE_CURLY_BRACE);
738    
739                            if (_log.isWarnEnabled()) {
740                                    _log.warn(msg.toString());
741                            }
742    
743                            throw new NoSuchFileShortcutException(msg.toString());
744                    }
745    
746                    return dlFileShortcut;
747            }
748    
749            public DLFileShortcut fetchByUUID_G(String uuid, long groupId)
750                    throws SystemException {
751                    return fetchByUUID_G(uuid, groupId, true);
752            }
753    
754            public DLFileShortcut fetchByUUID_G(String uuid, long groupId,
755                    boolean retrieveFromCache) throws SystemException {
756                    Object[] finderArgs = new Object[] { uuid, groupId };
757    
758                    Object result = null;
759    
760                    if (retrieveFromCache) {
761                            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_UUID_G,
762                                            finderArgs, this);
763                    }
764    
765                    if (result == null) {
766                            Session session = null;
767    
768                            try {
769                                    session = openSession();
770    
771                                    StringBundler query = new StringBundler(3);
772    
773                                    query.append(_SQL_SELECT_DLFILESHORTCUT_WHERE);
774    
775                                    if (uuid == null) {
776                                            query.append(_FINDER_COLUMN_UUID_G_UUID_1);
777                                    }
778                                    else {
779                                            if (uuid.equals(StringPool.BLANK)) {
780                                                    query.append(_FINDER_COLUMN_UUID_G_UUID_3);
781                                            }
782                                            else {
783                                                    query.append(_FINDER_COLUMN_UUID_G_UUID_2);
784                                            }
785                                    }
786    
787                                    query.append(_FINDER_COLUMN_UUID_G_GROUPID_2);
788    
789                                    String sql = query.toString();
790    
791                                    Query q = session.createQuery(sql);
792    
793                                    QueryPos qPos = QueryPos.getInstance(q);
794    
795                                    if (uuid != null) {
796                                            qPos.add(uuid);
797                                    }
798    
799                                    qPos.add(groupId);
800    
801                                    List<DLFileShortcut> list = q.list();
802    
803                                    result = list;
804    
805                                    DLFileShortcut dlFileShortcut = null;
806    
807                                    if (list.isEmpty()) {
808                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
809                                                    finderArgs, list);
810                                    }
811                                    else {
812                                            dlFileShortcut = list.get(0);
813    
814                                            cacheResult(dlFileShortcut);
815    
816                                            if ((dlFileShortcut.getUuid() == null) ||
817                                                            !dlFileShortcut.getUuid().equals(uuid) ||
818                                                            (dlFileShortcut.getGroupId() != groupId)) {
819                                                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
820                                                            finderArgs, dlFileShortcut);
821                                            }
822                                    }
823    
824                                    return dlFileShortcut;
825                            }
826                            catch (Exception e) {
827                                    throw processException(e);
828                            }
829                            finally {
830                                    if (result == null) {
831                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
832                                                    finderArgs, new ArrayList<DLFileShortcut>());
833                                    }
834    
835                                    closeSession(session);
836                            }
837                    }
838                    else {
839                            if (result instanceof List<?>) {
840                                    return null;
841                            }
842                            else {
843                                    return (DLFileShortcut)result;
844                            }
845                    }
846            }
847    
848            public List<DLFileShortcut> findByG_F(long groupId, long folderId)
849                    throws SystemException {
850                    return findByG_F(groupId, folderId, QueryUtil.ALL_POS,
851                            QueryUtil.ALL_POS, null);
852            }
853    
854            public List<DLFileShortcut> findByG_F(long groupId, long folderId,
855                    int start, int end) throws SystemException {
856                    return findByG_F(groupId, folderId, start, end, null);
857            }
858    
859            public List<DLFileShortcut> findByG_F(long groupId, long folderId,
860                    int start, int end, OrderByComparator orderByComparator)
861                    throws SystemException {
862                    Object[] finderArgs = new Object[] {
863                                    groupId, folderId,
864                                    
865                                    String.valueOf(start), String.valueOf(end),
866                                    String.valueOf(orderByComparator)
867                            };
868    
869                    List<DLFileShortcut> list = (List<DLFileShortcut>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_F,
870                                    finderArgs, this);
871    
872                    if (list == null) {
873                            Session session = null;
874    
875                            try {
876                                    session = openSession();
877    
878                                    StringBundler query = null;
879    
880                                    if (orderByComparator != null) {
881                                            query = new StringBundler(4 +
882                                                            (orderByComparator.getOrderByFields().length * 3));
883                                    }
884                                    else {
885                                            query = new StringBundler(3);
886                                    }
887    
888                                    query.append(_SQL_SELECT_DLFILESHORTCUT_WHERE);
889    
890                                    query.append(_FINDER_COLUMN_G_F_GROUPID_2);
891    
892                                    query.append(_FINDER_COLUMN_G_F_FOLDERID_2);
893    
894                                    if (orderByComparator != null) {
895                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
896                                                    orderByComparator);
897                                    }
898    
899                                    String sql = query.toString();
900    
901                                    Query q = session.createQuery(sql);
902    
903                                    QueryPos qPos = QueryPos.getInstance(q);
904    
905                                    qPos.add(groupId);
906    
907                                    qPos.add(folderId);
908    
909                                    list = (List<DLFileShortcut>)QueryUtil.list(q, getDialect(),
910                                                    start, end);
911                            }
912                            catch (Exception e) {
913                                    throw processException(e);
914                            }
915                            finally {
916                                    if (list == null) {
917                                            list = new ArrayList<DLFileShortcut>();
918                                    }
919    
920                                    cacheResult(list);
921    
922                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_F, finderArgs,
923                                            list);
924    
925                                    closeSession(session);
926                            }
927                    }
928    
929                    return list;
930            }
931    
932            public DLFileShortcut findByG_F_First(long groupId, long folderId,
933                    OrderByComparator orderByComparator)
934                    throws NoSuchFileShortcutException, SystemException {
935                    List<DLFileShortcut> list = findByG_F(groupId, folderId, 0, 1,
936                                    orderByComparator);
937    
938                    if (list.isEmpty()) {
939                            StringBundler msg = new StringBundler(6);
940    
941                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
942    
943                            msg.append("groupId=");
944                            msg.append(groupId);
945    
946                            msg.append(", folderId=");
947                            msg.append(folderId);
948    
949                            msg.append(StringPool.CLOSE_CURLY_BRACE);
950    
951                            throw new NoSuchFileShortcutException(msg.toString());
952                    }
953                    else {
954                            return list.get(0);
955                    }
956            }
957    
958            public DLFileShortcut findByG_F_Last(long groupId, long folderId,
959                    OrderByComparator orderByComparator)
960                    throws NoSuchFileShortcutException, SystemException {
961                    int count = countByG_F(groupId, folderId);
962    
963                    List<DLFileShortcut> list = findByG_F(groupId, folderId, count - 1,
964                                    count, orderByComparator);
965    
966                    if (list.isEmpty()) {
967                            StringBundler msg = new StringBundler(6);
968    
969                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
970    
971                            msg.append("groupId=");
972                            msg.append(groupId);
973    
974                            msg.append(", folderId=");
975                            msg.append(folderId);
976    
977                            msg.append(StringPool.CLOSE_CURLY_BRACE);
978    
979                            throw new NoSuchFileShortcutException(msg.toString());
980                    }
981                    else {
982                            return list.get(0);
983                    }
984            }
985    
986            public DLFileShortcut[] findByG_F_PrevAndNext(long fileShortcutId,
987                    long groupId, long folderId, OrderByComparator orderByComparator)
988                    throws NoSuchFileShortcutException, SystemException {
989                    DLFileShortcut dlFileShortcut = findByPrimaryKey(fileShortcutId);
990    
991                    Session session = null;
992    
993                    try {
994                            session = openSession();
995    
996                            DLFileShortcut[] array = new DLFileShortcutImpl[3];
997    
998                            array[0] = getByG_F_PrevAndNext(session, dlFileShortcut, groupId,
999                                            folderId, orderByComparator, true);
1000    
1001                            array[1] = dlFileShortcut;
1002    
1003                            array[2] = getByG_F_PrevAndNext(session, dlFileShortcut, groupId,
1004                                            folderId, orderByComparator, false);
1005    
1006                            return array;
1007                    }
1008                    catch (Exception e) {
1009                            throw processException(e);
1010                    }
1011                    finally {
1012                            closeSession(session);
1013                    }
1014            }
1015    
1016            protected DLFileShortcut getByG_F_PrevAndNext(Session session,
1017                    DLFileShortcut dlFileShortcut, long groupId, long folderId,
1018                    OrderByComparator orderByComparator, boolean previous) {
1019                    StringBundler query = null;
1020    
1021                    if (orderByComparator != null) {
1022                            query = new StringBundler(6 +
1023                                            (orderByComparator.getOrderByFields().length * 6));
1024                    }
1025                    else {
1026                            query = new StringBundler(3);
1027                    }
1028    
1029                    query.append(_SQL_SELECT_DLFILESHORTCUT_WHERE);
1030    
1031                    query.append(_FINDER_COLUMN_G_F_GROUPID_2);
1032    
1033                    query.append(_FINDER_COLUMN_G_F_FOLDERID_2);
1034    
1035                    if (orderByComparator != null) {
1036                            String[] orderByFields = orderByComparator.getOrderByFields();
1037    
1038                            if (orderByFields.length > 0) {
1039                                    query.append(WHERE_AND);
1040                            }
1041    
1042                            for (int i = 0; i < orderByFields.length; i++) {
1043                                    query.append(_ORDER_BY_ENTITY_ALIAS);
1044                                    query.append(orderByFields[i]);
1045    
1046                                    if ((i + 1) < orderByFields.length) {
1047                                            if (orderByComparator.isAscending() ^ previous) {
1048                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
1049                                            }
1050                                            else {
1051                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
1052                                            }
1053                                    }
1054                                    else {
1055                                            if (orderByComparator.isAscending() ^ previous) {
1056                                                    query.append(WHERE_GREATER_THAN);
1057                                            }
1058                                            else {
1059                                                    query.append(WHERE_LESSER_THAN);
1060                                            }
1061                                    }
1062                            }
1063    
1064                            query.append(ORDER_BY_CLAUSE);
1065    
1066                            for (int i = 0; i < orderByFields.length; i++) {
1067                                    query.append(_ORDER_BY_ENTITY_ALIAS);
1068                                    query.append(orderByFields[i]);
1069    
1070                                    if ((i + 1) < orderByFields.length) {
1071                                            if (orderByComparator.isAscending() ^ previous) {
1072                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
1073                                            }
1074                                            else {
1075                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
1076                                            }
1077                                    }
1078                                    else {
1079                                            if (orderByComparator.isAscending() ^ previous) {
1080                                                    query.append(ORDER_BY_ASC);
1081                                            }
1082                                            else {
1083                                                    query.append(ORDER_BY_DESC);
1084                                            }
1085                                    }
1086                            }
1087                    }
1088    
1089                    String sql = query.toString();
1090    
1091                    Query q = session.createQuery(sql);
1092    
1093                    q.setFirstResult(0);
1094                    q.setMaxResults(2);
1095    
1096                    QueryPos qPos = QueryPos.getInstance(q);
1097    
1098                    qPos.add(groupId);
1099    
1100                    qPos.add(folderId);
1101    
1102                    if (orderByComparator != null) {
1103                            Object[] values = orderByComparator.getOrderByValues(dlFileShortcut);
1104    
1105                            for (Object value : values) {
1106                                    qPos.add(value);
1107                            }
1108                    }
1109    
1110                    List<DLFileShortcut> list = q.list();
1111    
1112                    if (list.size() == 2) {
1113                            return list.get(1);
1114                    }
1115                    else {
1116                            return null;
1117                    }
1118            }
1119    
1120            public List<DLFileShortcut> filterFindByG_F(long groupId, long folderId)
1121                    throws SystemException {
1122                    return filterFindByG_F(groupId, folderId, QueryUtil.ALL_POS,
1123                            QueryUtil.ALL_POS, null);
1124            }
1125    
1126            public List<DLFileShortcut> filterFindByG_F(long groupId, long folderId,
1127                    int start, int end) throws SystemException {
1128                    return filterFindByG_F(groupId, folderId, start, end, null);
1129            }
1130    
1131            public List<DLFileShortcut> filterFindByG_F(long groupId, long folderId,
1132                    int start, int end, OrderByComparator orderByComparator)
1133                    throws SystemException {
1134                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
1135                            return findByG_F(groupId, folderId, start, end, orderByComparator);
1136                    }
1137    
1138                    Session session = null;
1139    
1140                    try {
1141                            session = openSession();
1142    
1143                            StringBundler query = null;
1144    
1145                            if (orderByComparator != null) {
1146                                    query = new StringBundler(4 +
1147                                                    (orderByComparator.getOrderByFields().length * 3));
1148                            }
1149                            else {
1150                                    query = new StringBundler(3);
1151                            }
1152    
1153                            query.append(_FILTER_SQL_SELECT_DLFILESHORTCUT_WHERE);
1154    
1155                            query.append(_FINDER_COLUMN_G_F_GROUPID_2);
1156    
1157                            query.append(_FINDER_COLUMN_G_F_FOLDERID_2);
1158    
1159                            if (orderByComparator != null) {
1160                                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1161                                            orderByComparator);
1162                            }
1163    
1164                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
1165                                            DLFileShortcut.class.getName(), _FILTER_COLUMN_PK,
1166                                            _FILTER_COLUMN_USERID, groupId);
1167    
1168                            SQLQuery q = session.createSQLQuery(sql);
1169    
1170                            q.addEntity(_FILTER_ENTITY_ALIAS, DLFileShortcutImpl.class);
1171    
1172                            QueryPos qPos = QueryPos.getInstance(q);
1173    
1174                            qPos.add(groupId);
1175    
1176                            qPos.add(folderId);
1177    
1178                            return (List<DLFileShortcut>)QueryUtil.list(q, getDialect(), start,
1179                                    end);
1180                    }
1181                    catch (Exception e) {
1182                            throw processException(e);
1183                    }
1184                    finally {
1185                            closeSession(session);
1186                    }
1187            }
1188    
1189            public List<DLFileShortcut> findByG_F_S(long groupId, long folderId,
1190                    int status) throws SystemException {
1191                    return findByG_F_S(groupId, folderId, status, QueryUtil.ALL_POS,
1192                            QueryUtil.ALL_POS, null);
1193            }
1194    
1195            public List<DLFileShortcut> findByG_F_S(long groupId, long folderId,
1196                    int status, int start, int end) throws SystemException {
1197                    return findByG_F_S(groupId, folderId, status, start, end, null);
1198            }
1199    
1200            public List<DLFileShortcut> findByG_F_S(long groupId, long folderId,
1201                    int status, int start, int end, OrderByComparator orderByComparator)
1202                    throws SystemException {
1203                    Object[] finderArgs = new Object[] {
1204                                    groupId, folderId, status,
1205                                    
1206                                    String.valueOf(start), String.valueOf(end),
1207                                    String.valueOf(orderByComparator)
1208                            };
1209    
1210                    List<DLFileShortcut> list = (List<DLFileShortcut>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_F_S,
1211                                    finderArgs, this);
1212    
1213                    if (list == null) {
1214                            Session session = null;
1215    
1216                            try {
1217                                    session = openSession();
1218    
1219                                    StringBundler query = null;
1220    
1221                                    if (orderByComparator != null) {
1222                                            query = new StringBundler(5 +
1223                                                            (orderByComparator.getOrderByFields().length * 3));
1224                                    }
1225                                    else {
1226                                            query = new StringBundler(4);
1227                                    }
1228    
1229                                    query.append(_SQL_SELECT_DLFILESHORTCUT_WHERE);
1230    
1231                                    query.append(_FINDER_COLUMN_G_F_S_GROUPID_2);
1232    
1233                                    query.append(_FINDER_COLUMN_G_F_S_FOLDERID_2);
1234    
1235                                    query.append(_FINDER_COLUMN_G_F_S_STATUS_2);
1236    
1237                                    if (orderByComparator != null) {
1238                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1239                                                    orderByComparator);
1240                                    }
1241    
1242                                    String sql = query.toString();
1243    
1244                                    Query q = session.createQuery(sql);
1245    
1246                                    QueryPos qPos = QueryPos.getInstance(q);
1247    
1248                                    qPos.add(groupId);
1249    
1250                                    qPos.add(folderId);
1251    
1252                                    qPos.add(status);
1253    
1254                                    list = (List<DLFileShortcut>)QueryUtil.list(q, getDialect(),
1255                                                    start, end);
1256                            }
1257                            catch (Exception e) {
1258                                    throw processException(e);
1259                            }
1260                            finally {
1261                                    if (list == null) {
1262                                            list = new ArrayList<DLFileShortcut>();
1263                                    }
1264    
1265                                    cacheResult(list);
1266    
1267                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_F_S,
1268                                            finderArgs, list);
1269    
1270                                    closeSession(session);
1271                            }
1272                    }
1273    
1274                    return list;
1275            }
1276    
1277            public DLFileShortcut findByG_F_S_First(long groupId, long folderId,
1278                    int status, OrderByComparator orderByComparator)
1279                    throws NoSuchFileShortcutException, SystemException {
1280                    List<DLFileShortcut> list = findByG_F_S(groupId, folderId, status, 0,
1281                                    1, orderByComparator);
1282    
1283                    if (list.isEmpty()) {
1284                            StringBundler msg = new StringBundler(8);
1285    
1286                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1287    
1288                            msg.append("groupId=");
1289                            msg.append(groupId);
1290    
1291                            msg.append(", folderId=");
1292                            msg.append(folderId);
1293    
1294                            msg.append(", status=");
1295                            msg.append(status);
1296    
1297                            msg.append(StringPool.CLOSE_CURLY_BRACE);
1298    
1299                            throw new NoSuchFileShortcutException(msg.toString());
1300                    }
1301                    else {
1302                            return list.get(0);
1303                    }
1304            }
1305    
1306            public DLFileShortcut findByG_F_S_Last(long groupId, long folderId,
1307                    int status, OrderByComparator orderByComparator)
1308                    throws NoSuchFileShortcutException, SystemException {
1309                    int count = countByG_F_S(groupId, folderId, status);
1310    
1311                    List<DLFileShortcut> list = findByG_F_S(groupId, folderId, status,
1312                                    count - 1, count, orderByComparator);
1313    
1314                    if (list.isEmpty()) {
1315                            StringBundler msg = new StringBundler(8);
1316    
1317                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1318    
1319                            msg.append("groupId=");
1320                            msg.append(groupId);
1321    
1322                            msg.append(", folderId=");
1323                            msg.append(folderId);
1324    
1325                            msg.append(", status=");
1326                            msg.append(status);
1327    
1328                            msg.append(StringPool.CLOSE_CURLY_BRACE);
1329    
1330                            throw new NoSuchFileShortcutException(msg.toString());
1331                    }
1332                    else {
1333                            return list.get(0);
1334                    }
1335            }
1336    
1337            public DLFileShortcut[] findByG_F_S_PrevAndNext(long fileShortcutId,
1338                    long groupId, long folderId, int status,
1339                    OrderByComparator orderByComparator)
1340                    throws NoSuchFileShortcutException, SystemException {
1341                    DLFileShortcut dlFileShortcut = findByPrimaryKey(fileShortcutId);
1342    
1343                    Session session = null;
1344    
1345                    try {
1346                            session = openSession();
1347    
1348                            DLFileShortcut[] array = new DLFileShortcutImpl[3];
1349    
1350                            array[0] = getByG_F_S_PrevAndNext(session, dlFileShortcut, groupId,
1351                                            folderId, status, orderByComparator, true);
1352    
1353                            array[1] = dlFileShortcut;
1354    
1355                            array[2] = getByG_F_S_PrevAndNext(session, dlFileShortcut, groupId,
1356                                            folderId, status, orderByComparator, false);
1357    
1358                            return array;
1359                    }
1360                    catch (Exception e) {
1361                            throw processException(e);
1362                    }
1363                    finally {
1364                            closeSession(session);
1365                    }
1366            }
1367    
1368            protected DLFileShortcut getByG_F_S_PrevAndNext(Session session,
1369                    DLFileShortcut dlFileShortcut, long groupId, long folderId, int status,
1370                    OrderByComparator orderByComparator, boolean previous) {
1371                    StringBundler query = null;
1372    
1373                    if (orderByComparator != null) {
1374                            query = new StringBundler(6 +
1375                                            (orderByComparator.getOrderByFields().length * 6));
1376                    }
1377                    else {
1378                            query = new StringBundler(3);
1379                    }
1380    
1381                    query.append(_SQL_SELECT_DLFILESHORTCUT_WHERE);
1382    
1383                    query.append(_FINDER_COLUMN_G_F_S_GROUPID_2);
1384    
1385                    query.append(_FINDER_COLUMN_G_F_S_FOLDERID_2);
1386    
1387                    query.append(_FINDER_COLUMN_G_F_S_STATUS_2);
1388    
1389                    if (orderByComparator != null) {
1390                            String[] orderByFields = orderByComparator.getOrderByFields();
1391    
1392                            if (orderByFields.length > 0) {
1393                                    query.append(WHERE_AND);
1394                            }
1395    
1396                            for (int i = 0; i < orderByFields.length; i++) {
1397                                    query.append(_ORDER_BY_ENTITY_ALIAS);
1398                                    query.append(orderByFields[i]);
1399    
1400                                    if ((i + 1) < orderByFields.length) {
1401                                            if (orderByComparator.isAscending() ^ previous) {
1402                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
1403                                            }
1404                                            else {
1405                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
1406                                            }
1407                                    }
1408                                    else {
1409                                            if (orderByComparator.isAscending() ^ previous) {
1410                                                    query.append(WHERE_GREATER_THAN);
1411                                            }
1412                                            else {
1413                                                    query.append(WHERE_LESSER_THAN);
1414                                            }
1415                                    }
1416                            }
1417    
1418                            query.append(ORDER_BY_CLAUSE);
1419    
1420                            for (int i = 0; i < orderByFields.length; i++) {
1421                                    query.append(_ORDER_BY_ENTITY_ALIAS);
1422                                    query.append(orderByFields[i]);
1423    
1424                                    if ((i + 1) < orderByFields.length) {
1425                                            if (orderByComparator.isAscending() ^ previous) {
1426                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
1427                                            }
1428                                            else {
1429                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
1430                                            }
1431                                    }
1432                                    else {
1433                                            if (orderByComparator.isAscending() ^ previous) {
1434                                                    query.append(ORDER_BY_ASC);
1435                                            }
1436                                            else {
1437                                                    query.append(ORDER_BY_DESC);
1438                                            }
1439                                    }
1440                            }
1441                    }
1442    
1443                    String sql = query.toString();
1444    
1445                    Query q = session.createQuery(sql);
1446    
1447                    q.setFirstResult(0);
1448                    q.setMaxResults(2);
1449    
1450                    QueryPos qPos = QueryPos.getInstance(q);
1451    
1452                    qPos.add(groupId);
1453    
1454                    qPos.add(folderId);
1455    
1456                    qPos.add(status);
1457    
1458                    if (orderByComparator != null) {
1459                            Object[] values = orderByComparator.getOrderByValues(dlFileShortcut);
1460    
1461                            for (Object value : values) {
1462                                    qPos.add(value);
1463                            }
1464                    }
1465    
1466                    List<DLFileShortcut> list = q.list();
1467    
1468                    if (list.size() == 2) {
1469                            return list.get(1);
1470                    }
1471                    else {
1472                            return null;
1473                    }
1474            }
1475    
1476            public List<DLFileShortcut> filterFindByG_F_S(long groupId, long folderId,
1477                    int status) throws SystemException {
1478                    return filterFindByG_F_S(groupId, folderId, status, QueryUtil.ALL_POS,
1479                            QueryUtil.ALL_POS, null);
1480            }
1481    
1482            public List<DLFileShortcut> filterFindByG_F_S(long groupId, long folderId,
1483                    int status, int start, int end) throws SystemException {
1484                    return filterFindByG_F_S(groupId, folderId, status, start, end, null);
1485            }
1486    
1487            public List<DLFileShortcut> filterFindByG_F_S(long groupId, long folderId,
1488                    int status, int start, int end, OrderByComparator orderByComparator)
1489                    throws SystemException {
1490                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
1491                            return findByG_F_S(groupId, folderId, status, start, end,
1492                                    orderByComparator);
1493                    }
1494    
1495                    Session session = null;
1496    
1497                    try {
1498                            session = openSession();
1499    
1500                            StringBundler query = null;
1501    
1502                            if (orderByComparator != null) {
1503                                    query = new StringBundler(5 +
1504                                                    (orderByComparator.getOrderByFields().length * 3));
1505                            }
1506                            else {
1507                                    query = new StringBundler(4);
1508                            }
1509    
1510                            query.append(_FILTER_SQL_SELECT_DLFILESHORTCUT_WHERE);
1511    
1512                            query.append(_FINDER_COLUMN_G_F_S_GROUPID_2);
1513    
1514                            query.append(_FINDER_COLUMN_G_F_S_FOLDERID_2);
1515    
1516                            query.append(_FINDER_COLUMN_G_F_S_STATUS_2);
1517    
1518                            if (orderByComparator != null) {
1519                                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1520                                            orderByComparator);
1521                            }
1522    
1523                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
1524                                            DLFileShortcut.class.getName(), _FILTER_COLUMN_PK,
1525                                            _FILTER_COLUMN_USERID, groupId);
1526    
1527                            SQLQuery q = session.createSQLQuery(sql);
1528    
1529                            q.addEntity(_FILTER_ENTITY_ALIAS, DLFileShortcutImpl.class);
1530    
1531                            QueryPos qPos = QueryPos.getInstance(q);
1532    
1533                            qPos.add(groupId);
1534    
1535                            qPos.add(folderId);
1536    
1537                            qPos.add(status);
1538    
1539                            return (List<DLFileShortcut>)QueryUtil.list(q, getDialect(), start,
1540                                    end);
1541                    }
1542                    catch (Exception e) {
1543                            throw processException(e);
1544                    }
1545                    finally {
1546                            closeSession(session);
1547                    }
1548            }
1549    
1550            public List<DLFileShortcut> findByG_TF_TN(long groupId, long toFolderId,
1551                    String toName) throws SystemException {
1552                    return findByG_TF_TN(groupId, toFolderId, toName, QueryUtil.ALL_POS,
1553                            QueryUtil.ALL_POS, null);
1554            }
1555    
1556            public List<DLFileShortcut> findByG_TF_TN(long groupId, long toFolderId,
1557                    String toName, int start, int end) throws SystemException {
1558                    return findByG_TF_TN(groupId, toFolderId, toName, start, end, null);
1559            }
1560    
1561            public List<DLFileShortcut> findByG_TF_TN(long groupId, long toFolderId,
1562                    String toName, int start, int end, OrderByComparator orderByComparator)
1563                    throws SystemException {
1564                    Object[] finderArgs = new Object[] {
1565                                    groupId, toFolderId, toName,
1566                                    
1567                                    String.valueOf(start), String.valueOf(end),
1568                                    String.valueOf(orderByComparator)
1569                            };
1570    
1571                    List<DLFileShortcut> list = (List<DLFileShortcut>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_TF_TN,
1572                                    finderArgs, this);
1573    
1574                    if (list == null) {
1575                            Session session = null;
1576    
1577                            try {
1578                                    session = openSession();
1579    
1580                                    StringBundler query = null;
1581    
1582                                    if (orderByComparator != null) {
1583                                            query = new StringBundler(5 +
1584                                                            (orderByComparator.getOrderByFields().length * 3));
1585                                    }
1586                                    else {
1587                                            query = new StringBundler(4);
1588                                    }
1589    
1590                                    query.append(_SQL_SELECT_DLFILESHORTCUT_WHERE);
1591    
1592                                    query.append(_FINDER_COLUMN_G_TF_TN_GROUPID_2);
1593    
1594                                    query.append(_FINDER_COLUMN_G_TF_TN_TOFOLDERID_2);
1595    
1596                                    if (toName == null) {
1597                                            query.append(_FINDER_COLUMN_G_TF_TN_TONAME_1);
1598                                    }
1599                                    else {
1600                                            if (toName.equals(StringPool.BLANK)) {
1601                                                    query.append(_FINDER_COLUMN_G_TF_TN_TONAME_3);
1602                                            }
1603                                            else {
1604                                                    query.append(_FINDER_COLUMN_G_TF_TN_TONAME_2);
1605                                            }
1606                                    }
1607    
1608                                    if (orderByComparator != null) {
1609                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1610                                                    orderByComparator);
1611                                    }
1612    
1613                                    String sql = query.toString();
1614    
1615                                    Query q = session.createQuery(sql);
1616    
1617                                    QueryPos qPos = QueryPos.getInstance(q);
1618    
1619                                    qPos.add(groupId);
1620    
1621                                    qPos.add(toFolderId);
1622    
1623                                    if (toName != null) {
1624                                            qPos.add(toName);
1625                                    }
1626    
1627                                    list = (List<DLFileShortcut>)QueryUtil.list(q, getDialect(),
1628                                                    start, end);
1629                            }
1630                            catch (Exception e) {
1631                                    throw processException(e);
1632                            }
1633                            finally {
1634                                    if (list == null) {
1635                                            list = new ArrayList<DLFileShortcut>();
1636                                    }
1637    
1638                                    cacheResult(list);
1639    
1640                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_TF_TN,
1641                                            finderArgs, list);
1642    
1643                                    closeSession(session);
1644                            }
1645                    }
1646    
1647                    return list;
1648            }
1649    
1650            public DLFileShortcut findByG_TF_TN_First(long groupId, long toFolderId,
1651                    String toName, OrderByComparator orderByComparator)
1652                    throws NoSuchFileShortcutException, SystemException {
1653                    List<DLFileShortcut> list = findByG_TF_TN(groupId, toFolderId, toName,
1654                                    0, 1, orderByComparator);
1655    
1656                    if (list.isEmpty()) {
1657                            StringBundler msg = new StringBundler(8);
1658    
1659                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1660    
1661                            msg.append("groupId=");
1662                            msg.append(groupId);
1663    
1664                            msg.append(", toFolderId=");
1665                            msg.append(toFolderId);
1666    
1667                            msg.append(", toName=");
1668                            msg.append(toName);
1669    
1670                            msg.append(StringPool.CLOSE_CURLY_BRACE);
1671    
1672                            throw new NoSuchFileShortcutException(msg.toString());
1673                    }
1674                    else {
1675                            return list.get(0);
1676                    }
1677            }
1678    
1679            public DLFileShortcut findByG_TF_TN_Last(long groupId, long toFolderId,
1680                    String toName, OrderByComparator orderByComparator)
1681                    throws NoSuchFileShortcutException, SystemException {
1682                    int count = countByG_TF_TN(groupId, toFolderId, toName);
1683    
1684                    List<DLFileShortcut> list = findByG_TF_TN(groupId, toFolderId, toName,
1685                                    count - 1, count, orderByComparator);
1686    
1687                    if (list.isEmpty()) {
1688                            StringBundler msg = new StringBundler(8);
1689    
1690                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1691    
1692                            msg.append("groupId=");
1693                            msg.append(groupId);
1694    
1695                            msg.append(", toFolderId=");
1696                            msg.append(toFolderId);
1697    
1698                            msg.append(", toName=");
1699                            msg.append(toName);
1700    
1701                            msg.append(StringPool.CLOSE_CURLY_BRACE);
1702    
1703                            throw new NoSuchFileShortcutException(msg.toString());
1704                    }
1705                    else {
1706                            return list.get(0);
1707                    }
1708            }
1709    
1710            public DLFileShortcut[] findByG_TF_TN_PrevAndNext(long fileShortcutId,
1711                    long groupId, long toFolderId, String toName,
1712                    OrderByComparator orderByComparator)
1713                    throws NoSuchFileShortcutException, SystemException {
1714                    DLFileShortcut dlFileShortcut = findByPrimaryKey(fileShortcutId);
1715    
1716                    Session session = null;
1717    
1718                    try {
1719                            session = openSession();
1720    
1721                            DLFileShortcut[] array = new DLFileShortcutImpl[3];
1722    
1723                            array[0] = getByG_TF_TN_PrevAndNext(session, dlFileShortcut,
1724                                            groupId, toFolderId, toName, orderByComparator, true);
1725    
1726                            array[1] = dlFileShortcut;
1727    
1728                            array[2] = getByG_TF_TN_PrevAndNext(session, dlFileShortcut,
1729                                            groupId, toFolderId, toName, orderByComparator, false);
1730    
1731                            return array;
1732                    }
1733                    catch (Exception e) {
1734                            throw processException(e);
1735                    }
1736                    finally {
1737                            closeSession(session);
1738                    }
1739            }
1740    
1741            protected DLFileShortcut getByG_TF_TN_PrevAndNext(Session session,
1742                    DLFileShortcut dlFileShortcut, long groupId, long toFolderId,
1743                    String toName, OrderByComparator orderByComparator, boolean previous) {
1744                    StringBundler query = null;
1745    
1746                    if (orderByComparator != null) {
1747                            query = new StringBundler(6 +
1748                                            (orderByComparator.getOrderByFields().length * 6));
1749                    }
1750                    else {
1751                            query = new StringBundler(3);
1752                    }
1753    
1754                    query.append(_SQL_SELECT_DLFILESHORTCUT_WHERE);
1755    
1756                    query.append(_FINDER_COLUMN_G_TF_TN_GROUPID_2);
1757    
1758                    query.append(_FINDER_COLUMN_G_TF_TN_TOFOLDERID_2);
1759    
1760                    if (toName == null) {
1761                            query.append(_FINDER_COLUMN_G_TF_TN_TONAME_1);
1762                    }
1763                    else {
1764                            if (toName.equals(StringPool.BLANK)) {
1765                                    query.append(_FINDER_COLUMN_G_TF_TN_TONAME_3);
1766                            }
1767                            else {
1768                                    query.append(_FINDER_COLUMN_G_TF_TN_TONAME_2);
1769                            }
1770                    }
1771    
1772                    if (orderByComparator != null) {
1773                            String[] orderByFields = orderByComparator.getOrderByFields();
1774    
1775                            if (orderByFields.length > 0) {
1776                                    query.append(WHERE_AND);
1777                            }
1778    
1779                            for (int i = 0; i < orderByFields.length; i++) {
1780                                    query.append(_ORDER_BY_ENTITY_ALIAS);
1781                                    query.append(orderByFields[i]);
1782    
1783                                    if ((i + 1) < orderByFields.length) {
1784                                            if (orderByComparator.isAscending() ^ previous) {
1785                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
1786                                            }
1787                                            else {
1788                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
1789                                            }
1790                                    }
1791                                    else {
1792                                            if (orderByComparator.isAscending() ^ previous) {
1793                                                    query.append(WHERE_GREATER_THAN);
1794                                            }
1795                                            else {
1796                                                    query.append(WHERE_LESSER_THAN);
1797                                            }
1798                                    }
1799                            }
1800    
1801                            query.append(ORDER_BY_CLAUSE);
1802    
1803                            for (int i = 0; i < orderByFields.length; i++) {
1804                                    query.append(_ORDER_BY_ENTITY_ALIAS);
1805                                    query.append(orderByFields[i]);
1806    
1807                                    if ((i + 1) < orderByFields.length) {
1808                                            if (orderByComparator.isAscending() ^ previous) {
1809                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
1810                                            }
1811                                            else {
1812                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
1813                                            }
1814                                    }
1815                                    else {
1816                                            if (orderByComparator.isAscending() ^ previous) {
1817                                                    query.append(ORDER_BY_ASC);
1818                                            }
1819                                            else {
1820                                                    query.append(ORDER_BY_DESC);
1821                                            }
1822                                    }
1823                            }
1824                    }
1825    
1826                    String sql = query.toString();
1827    
1828                    Query q = session.createQuery(sql);
1829    
1830                    q.setFirstResult(0);
1831                    q.setMaxResults(2);
1832    
1833                    QueryPos qPos = QueryPos.getInstance(q);
1834    
1835                    qPos.add(groupId);
1836    
1837                    qPos.add(toFolderId);
1838    
1839                    if (toName != null) {
1840                            qPos.add(toName);
1841                    }
1842    
1843                    if (orderByComparator != null) {
1844                            Object[] values = orderByComparator.getOrderByValues(dlFileShortcut);
1845    
1846                            for (Object value : values) {
1847                                    qPos.add(value);
1848                            }
1849                    }
1850    
1851                    List<DLFileShortcut> list = q.list();
1852    
1853                    if (list.size() == 2) {
1854                            return list.get(1);
1855                    }
1856                    else {
1857                            return null;
1858                    }
1859            }
1860    
1861            public List<DLFileShortcut> filterFindByG_TF_TN(long groupId,
1862                    long toFolderId, String toName) throws SystemException {
1863                    return filterFindByG_TF_TN(groupId, toFolderId, toName,
1864                            QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1865            }
1866    
1867            public List<DLFileShortcut> filterFindByG_TF_TN(long groupId,
1868                    long toFolderId, String toName, int start, int end)
1869                    throws SystemException {
1870                    return filterFindByG_TF_TN(groupId, toFolderId, toName, start, end, null);
1871            }
1872    
1873            public List<DLFileShortcut> filterFindByG_TF_TN(long groupId,
1874                    long toFolderId, String toName, int start, int end,
1875                    OrderByComparator orderByComparator) throws SystemException {
1876                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
1877                            return findByG_TF_TN(groupId, toFolderId, toName, start, end,
1878                                    orderByComparator);
1879                    }
1880    
1881                    Session session = null;
1882    
1883                    try {
1884                            session = openSession();
1885    
1886                            StringBundler query = null;
1887    
1888                            if (orderByComparator != null) {
1889                                    query = new StringBundler(5 +
1890                                                    (orderByComparator.getOrderByFields().length * 3));
1891                            }
1892                            else {
1893                                    query = new StringBundler(4);
1894                            }
1895    
1896                            query.append(_FILTER_SQL_SELECT_DLFILESHORTCUT_WHERE);
1897    
1898                            query.append(_FINDER_COLUMN_G_TF_TN_GROUPID_2);
1899    
1900                            query.append(_FINDER_COLUMN_G_TF_TN_TOFOLDERID_2);
1901    
1902                            if (toName == null) {
1903                                    query.append(_FINDER_COLUMN_G_TF_TN_TONAME_1);
1904                            }
1905                            else {
1906                                    if (toName.equals(StringPool.BLANK)) {
1907                                            query.append(_FINDER_COLUMN_G_TF_TN_TONAME_3);
1908                                    }
1909                                    else {
1910                                            query.append(_FINDER_COLUMN_G_TF_TN_TONAME_2);
1911                                    }
1912                            }
1913    
1914                            if (orderByComparator != null) {
1915                                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1916                                            orderByComparator);
1917                            }
1918    
1919                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
1920                                            DLFileShortcut.class.getName(), _FILTER_COLUMN_PK,
1921                                            _FILTER_COLUMN_USERID, groupId);
1922    
1923                            SQLQuery q = session.createSQLQuery(sql);
1924    
1925                            q.addEntity(_FILTER_ENTITY_ALIAS, DLFileShortcutImpl.class);
1926    
1927                            QueryPos qPos = QueryPos.getInstance(q);
1928    
1929                            qPos.add(groupId);
1930    
1931                            qPos.add(toFolderId);
1932    
1933                            if (toName != null) {
1934                                    qPos.add(toName);
1935                            }
1936    
1937                            return (List<DLFileShortcut>)QueryUtil.list(q, getDialect(), start,
1938                                    end);
1939                    }
1940                    catch (Exception e) {
1941                            throw processException(e);
1942                    }
1943                    finally {
1944                            closeSession(session);
1945                    }
1946            }
1947    
1948            public List<DLFileShortcut> findByG_TF_TN_S(long groupId, long toFolderId,
1949                    String toName, int status) throws SystemException {
1950                    return findByG_TF_TN_S(groupId, toFolderId, toName, status,
1951                            QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1952            }
1953    
1954            public List<DLFileShortcut> findByG_TF_TN_S(long groupId, long toFolderId,
1955                    String toName, int status, int start, int end)
1956                    throws SystemException {
1957                    return findByG_TF_TN_S(groupId, toFolderId, toName, status, start, end,
1958                            null);
1959            }
1960    
1961            public List<DLFileShortcut> findByG_TF_TN_S(long groupId, long toFolderId,
1962                    String toName, int status, int start, int end,
1963                    OrderByComparator orderByComparator) throws SystemException {
1964                    Object[] finderArgs = new Object[] {
1965                                    groupId, toFolderId, toName, status,
1966                                    
1967                                    String.valueOf(start), String.valueOf(end),
1968                                    String.valueOf(orderByComparator)
1969                            };
1970    
1971                    List<DLFileShortcut> list = (List<DLFileShortcut>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_TF_TN_S,
1972                                    finderArgs, this);
1973    
1974                    if (list == null) {
1975                            Session session = null;
1976    
1977                            try {
1978                                    session = openSession();
1979    
1980                                    StringBundler query = null;
1981    
1982                                    if (orderByComparator != null) {
1983                                            query = new StringBundler(6 +
1984                                                            (orderByComparator.getOrderByFields().length * 3));
1985                                    }
1986                                    else {
1987                                            query = new StringBundler(5);
1988                                    }
1989    
1990                                    query.append(_SQL_SELECT_DLFILESHORTCUT_WHERE);
1991    
1992                                    query.append(_FINDER_COLUMN_G_TF_TN_S_GROUPID_2);
1993    
1994                                    query.append(_FINDER_COLUMN_G_TF_TN_S_TOFOLDERID_2);
1995    
1996                                    if (toName == null) {
1997                                            query.append(_FINDER_COLUMN_G_TF_TN_S_TONAME_1);
1998                                    }
1999                                    else {
2000                                            if (toName.equals(StringPool.BLANK)) {
2001                                                    query.append(_FINDER_COLUMN_G_TF_TN_S_TONAME_3);
2002                                            }
2003                                            else {
2004                                                    query.append(_FINDER_COLUMN_G_TF_TN_S_TONAME_2);
2005                                            }
2006                                    }
2007    
2008                                    query.append(_FINDER_COLUMN_G_TF_TN_S_STATUS_2);
2009    
2010                                    if (orderByComparator != null) {
2011                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2012                                                    orderByComparator);
2013                                    }
2014    
2015                                    String sql = query.toString();
2016    
2017                                    Query q = session.createQuery(sql);
2018    
2019                                    QueryPos qPos = QueryPos.getInstance(q);
2020    
2021                                    qPos.add(groupId);
2022    
2023                                    qPos.add(toFolderId);
2024    
2025                                    if (toName != null) {
2026                                            qPos.add(toName);
2027                                    }
2028    
2029                                    qPos.add(status);
2030    
2031                                    list = (List<DLFileShortcut>)QueryUtil.list(q, getDialect(),
2032                                                    start, end);
2033                            }
2034                            catch (Exception e) {
2035                                    throw processException(e);
2036                            }
2037                            finally {
2038                                    if (list == null) {
2039                                            list = new ArrayList<DLFileShortcut>();
2040                                    }
2041    
2042                                    cacheResult(list);
2043    
2044                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_TF_TN_S,
2045                                            finderArgs, list);
2046    
2047                                    closeSession(session);
2048                            }
2049                    }
2050    
2051                    return list;
2052            }
2053    
2054            public DLFileShortcut findByG_TF_TN_S_First(long groupId, long toFolderId,
2055                    String toName, int status, OrderByComparator orderByComparator)
2056                    throws NoSuchFileShortcutException, SystemException {
2057                    List<DLFileShortcut> list = findByG_TF_TN_S(groupId, toFolderId,
2058                                    toName, status, 0, 1, orderByComparator);
2059    
2060                    if (list.isEmpty()) {
2061                            StringBundler msg = new StringBundler(10);
2062    
2063                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2064    
2065                            msg.append("groupId=");
2066                            msg.append(groupId);
2067    
2068                            msg.append(", toFolderId=");
2069                            msg.append(toFolderId);
2070    
2071                            msg.append(", toName=");
2072                            msg.append(toName);
2073    
2074                            msg.append(", status=");
2075                            msg.append(status);
2076    
2077                            msg.append(StringPool.CLOSE_CURLY_BRACE);
2078    
2079                            throw new NoSuchFileShortcutException(msg.toString());
2080                    }
2081                    else {
2082                            return list.get(0);
2083                    }
2084            }
2085    
2086            public DLFileShortcut findByG_TF_TN_S_Last(long groupId, long toFolderId,
2087                    String toName, int status, OrderByComparator orderByComparator)
2088                    throws NoSuchFileShortcutException, SystemException {
2089                    int count = countByG_TF_TN_S(groupId, toFolderId, toName, status);
2090    
2091                    List<DLFileShortcut> list = findByG_TF_TN_S(groupId, toFolderId,
2092                                    toName, status, count - 1, count, orderByComparator);
2093    
2094                    if (list.isEmpty()) {
2095                            StringBundler msg = new StringBundler(10);
2096    
2097                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2098    
2099                            msg.append("groupId=");
2100                            msg.append(groupId);
2101    
2102                            msg.append(", toFolderId=");
2103                            msg.append(toFolderId);
2104    
2105                            msg.append(", toName=");
2106                            msg.append(toName);
2107    
2108                            msg.append(", status=");
2109                            msg.append(status);
2110    
2111                            msg.append(StringPool.CLOSE_CURLY_BRACE);
2112    
2113                            throw new NoSuchFileShortcutException(msg.toString());
2114                    }
2115                    else {
2116                            return list.get(0);
2117                    }
2118            }
2119    
2120            public DLFileShortcut[] findByG_TF_TN_S_PrevAndNext(long fileShortcutId,
2121                    long groupId, long toFolderId, String toName, int status,
2122                    OrderByComparator orderByComparator)
2123                    throws NoSuchFileShortcutException, SystemException {
2124                    DLFileShortcut dlFileShortcut = findByPrimaryKey(fileShortcutId);
2125    
2126                    Session session = null;
2127    
2128                    try {
2129                            session = openSession();
2130    
2131                            DLFileShortcut[] array = new DLFileShortcutImpl[3];
2132    
2133                            array[0] = getByG_TF_TN_S_PrevAndNext(session, dlFileShortcut,
2134                                            groupId, toFolderId, toName, status, orderByComparator, true);
2135    
2136                            array[1] = dlFileShortcut;
2137    
2138                            array[2] = getByG_TF_TN_S_PrevAndNext(session, dlFileShortcut,
2139                                            groupId, toFolderId, toName, status, orderByComparator,
2140                                            false);
2141    
2142                            return array;
2143                    }
2144                    catch (Exception e) {
2145                            throw processException(e);
2146                    }
2147                    finally {
2148                            closeSession(session);
2149                    }
2150            }
2151    
2152            protected DLFileShortcut getByG_TF_TN_S_PrevAndNext(Session session,
2153                    DLFileShortcut dlFileShortcut, long groupId, long toFolderId,
2154                    String toName, int status, OrderByComparator orderByComparator,
2155                    boolean previous) {
2156                    StringBundler query = null;
2157    
2158                    if (orderByComparator != null) {
2159                            query = new StringBundler(6 +
2160                                            (orderByComparator.getOrderByFields().length * 6));
2161                    }
2162                    else {
2163                            query = new StringBundler(3);
2164                    }
2165    
2166                    query.append(_SQL_SELECT_DLFILESHORTCUT_WHERE);
2167    
2168                    query.append(_FINDER_COLUMN_G_TF_TN_S_GROUPID_2);
2169    
2170                    query.append(_FINDER_COLUMN_G_TF_TN_S_TOFOLDERID_2);
2171    
2172                    if (toName == null) {
2173                            query.append(_FINDER_COLUMN_G_TF_TN_S_TONAME_1);
2174                    }
2175                    else {
2176                            if (toName.equals(StringPool.BLANK)) {
2177                                    query.append(_FINDER_COLUMN_G_TF_TN_S_TONAME_3);
2178                            }
2179                            else {
2180                                    query.append(_FINDER_COLUMN_G_TF_TN_S_TONAME_2);
2181                            }
2182                    }
2183    
2184                    query.append(_FINDER_COLUMN_G_TF_TN_S_STATUS_2);
2185    
2186                    if (orderByComparator != null) {
2187                            String[] orderByFields = orderByComparator.getOrderByFields();
2188    
2189                            if (orderByFields.length > 0) {
2190                                    query.append(WHERE_AND);
2191                            }
2192    
2193                            for (int i = 0; i < orderByFields.length; i++) {
2194                                    query.append(_ORDER_BY_ENTITY_ALIAS);
2195                                    query.append(orderByFields[i]);
2196    
2197                                    if ((i + 1) < orderByFields.length) {
2198                                            if (orderByComparator.isAscending() ^ previous) {
2199                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
2200                                            }
2201                                            else {
2202                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
2203                                            }
2204                                    }
2205                                    else {
2206                                            if (orderByComparator.isAscending() ^ previous) {
2207                                                    query.append(WHERE_GREATER_THAN);
2208                                            }
2209                                            else {
2210                                                    query.append(WHERE_LESSER_THAN);
2211                                            }
2212                                    }
2213                            }
2214    
2215                            query.append(ORDER_BY_CLAUSE);
2216    
2217                            for (int i = 0; i < orderByFields.length; i++) {
2218                                    query.append(_ORDER_BY_ENTITY_ALIAS);
2219                                    query.append(orderByFields[i]);
2220    
2221                                    if ((i + 1) < orderByFields.length) {
2222                                            if (orderByComparator.isAscending() ^ previous) {
2223                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
2224                                            }
2225                                            else {
2226                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
2227                                            }
2228                                    }
2229                                    else {
2230                                            if (orderByComparator.isAscending() ^ previous) {
2231                                                    query.append(ORDER_BY_ASC);
2232                                            }
2233                                            else {
2234                                                    query.append(ORDER_BY_DESC);
2235                                            }
2236                                    }
2237                            }
2238                    }
2239    
2240                    String sql = query.toString();
2241    
2242                    Query q = session.createQuery(sql);
2243    
2244                    q.setFirstResult(0);
2245                    q.setMaxResults(2);
2246    
2247                    QueryPos qPos = QueryPos.getInstance(q);
2248    
2249                    qPos.add(groupId);
2250    
2251                    qPos.add(toFolderId);
2252    
2253                    if (toName != null) {
2254                            qPos.add(toName);
2255                    }
2256    
2257                    qPos.add(status);
2258    
2259                    if (orderByComparator != null) {
2260                            Object[] values = orderByComparator.getOrderByValues(dlFileShortcut);
2261    
2262                            for (Object value : values) {
2263                                    qPos.add(value);
2264                            }
2265                    }
2266    
2267                    List<DLFileShortcut> list = q.list();
2268    
2269                    if (list.size() == 2) {
2270                            return list.get(1);
2271                    }
2272                    else {
2273                            return null;
2274                    }
2275            }
2276    
2277            public List<DLFileShortcut> filterFindByG_TF_TN_S(long groupId,
2278                    long toFolderId, String toName, int status) throws SystemException {
2279                    return filterFindByG_TF_TN_S(groupId, toFolderId, toName, status,
2280                            QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
2281            }
2282    
2283            public List<DLFileShortcut> filterFindByG_TF_TN_S(long groupId,
2284                    long toFolderId, String toName, int status, int start, int end)
2285                    throws SystemException {
2286                    return filterFindByG_TF_TN_S(groupId, toFolderId, toName, status,
2287                            start, end, null);
2288            }
2289    
2290            public List<DLFileShortcut> filterFindByG_TF_TN_S(long groupId,
2291                    long toFolderId, String toName, int status, int start, int end,
2292                    OrderByComparator orderByComparator) throws SystemException {
2293                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
2294                            return findByG_TF_TN_S(groupId, toFolderId, toName, status, start,
2295                                    end, orderByComparator);
2296                    }
2297    
2298                    Session session = null;
2299    
2300                    try {
2301                            session = openSession();
2302    
2303                            StringBundler query = null;
2304    
2305                            if (orderByComparator != null) {
2306                                    query = new StringBundler(6 +
2307                                                    (orderByComparator.getOrderByFields().length * 3));
2308                            }
2309                            else {
2310                                    query = new StringBundler(5);
2311                            }
2312    
2313                            query.append(_FILTER_SQL_SELECT_DLFILESHORTCUT_WHERE);
2314    
2315                            query.append(_FINDER_COLUMN_G_TF_TN_S_GROUPID_2);
2316    
2317                            query.append(_FINDER_COLUMN_G_TF_TN_S_TOFOLDERID_2);
2318    
2319                            if (toName == null) {
2320                                    query.append(_FINDER_COLUMN_G_TF_TN_S_TONAME_1);
2321                            }
2322                            else {
2323                                    if (toName.equals(StringPool.BLANK)) {
2324                                            query.append(_FINDER_COLUMN_G_TF_TN_S_TONAME_3);
2325                                    }
2326                                    else {
2327                                            query.append(_FINDER_COLUMN_G_TF_TN_S_TONAME_2);
2328                                    }
2329                            }
2330    
2331                            query.append(_FINDER_COLUMN_G_TF_TN_S_STATUS_2);
2332    
2333                            if (orderByComparator != null) {
2334                                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2335                                            orderByComparator);
2336                            }
2337    
2338                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
2339                                            DLFileShortcut.class.getName(), _FILTER_COLUMN_PK,
2340                                            _FILTER_COLUMN_USERID, groupId);
2341    
2342                            SQLQuery q = session.createSQLQuery(sql);
2343    
2344                            q.addEntity(_FILTER_ENTITY_ALIAS, DLFileShortcutImpl.class);
2345    
2346                            QueryPos qPos = QueryPos.getInstance(q);
2347    
2348                            qPos.add(groupId);
2349    
2350                            qPos.add(toFolderId);
2351    
2352                            if (toName != null) {
2353                                    qPos.add(toName);
2354                            }
2355    
2356                            qPos.add(status);
2357    
2358                            return (List<DLFileShortcut>)QueryUtil.list(q, getDialect(), start,
2359                                    end);
2360                    }
2361                    catch (Exception e) {
2362                            throw processException(e);
2363                    }
2364                    finally {
2365                            closeSession(session);
2366                    }
2367            }
2368    
2369            public List<DLFileShortcut> findAll() throws SystemException {
2370                    return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
2371            }
2372    
2373            public List<DLFileShortcut> findAll(int start, int end)
2374                    throws SystemException {
2375                    return findAll(start, end, null);
2376            }
2377    
2378            public List<DLFileShortcut> findAll(int start, int end,
2379                    OrderByComparator orderByComparator) throws SystemException {
2380                    Object[] finderArgs = new Object[] {
2381                                    String.valueOf(start), String.valueOf(end),
2382                                    String.valueOf(orderByComparator)
2383                            };
2384    
2385                    List<DLFileShortcut> list = (List<DLFileShortcut>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
2386                                    finderArgs, this);
2387    
2388                    if (list == null) {
2389                            Session session = null;
2390    
2391                            try {
2392                                    session = openSession();
2393    
2394                                    StringBundler query = null;
2395                                    String sql = null;
2396    
2397                                    if (orderByComparator != null) {
2398                                            query = new StringBundler(2 +
2399                                                            (orderByComparator.getOrderByFields().length * 3));
2400    
2401                                            query.append(_SQL_SELECT_DLFILESHORTCUT);
2402    
2403                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2404                                                    orderByComparator);
2405    
2406                                            sql = query.toString();
2407                                    }
2408                                    else {
2409                                            sql = _SQL_SELECT_DLFILESHORTCUT;
2410                                    }
2411    
2412                                    Query q = session.createQuery(sql);
2413    
2414                                    if (orderByComparator == null) {
2415                                            list = (List<DLFileShortcut>)QueryUtil.list(q,
2416                                                            getDialect(), start, end, false);
2417    
2418                                            Collections.sort(list);
2419                                    }
2420                                    else {
2421                                            list = (List<DLFileShortcut>)QueryUtil.list(q,
2422                                                            getDialect(), start, end);
2423                                    }
2424                            }
2425                            catch (Exception e) {
2426                                    throw processException(e);
2427                            }
2428                            finally {
2429                                    if (list == null) {
2430                                            list = new ArrayList<DLFileShortcut>();
2431                                    }
2432    
2433                                    cacheResult(list);
2434    
2435                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
2436    
2437                                    closeSession(session);
2438                            }
2439                    }
2440    
2441                    return list;
2442            }
2443    
2444            public void removeByUuid(String uuid) throws SystemException {
2445                    for (DLFileShortcut dlFileShortcut : findByUuid(uuid)) {
2446                            remove(dlFileShortcut);
2447                    }
2448            }
2449    
2450            public void removeByUUID_G(String uuid, long groupId)
2451                    throws NoSuchFileShortcutException, SystemException {
2452                    DLFileShortcut dlFileShortcut = findByUUID_G(uuid, groupId);
2453    
2454                    remove(dlFileShortcut);
2455            }
2456    
2457            public void removeByG_F(long groupId, long folderId)
2458                    throws SystemException {
2459                    for (DLFileShortcut dlFileShortcut : findByG_F(groupId, folderId)) {
2460                            remove(dlFileShortcut);
2461                    }
2462            }
2463    
2464            public void removeByG_F_S(long groupId, long folderId, int status)
2465                    throws SystemException {
2466                    for (DLFileShortcut dlFileShortcut : findByG_F_S(groupId, folderId,
2467                                    status)) {
2468                            remove(dlFileShortcut);
2469                    }
2470            }
2471    
2472            public void removeByG_TF_TN(long groupId, long toFolderId, String toName)
2473                    throws SystemException {
2474                    for (DLFileShortcut dlFileShortcut : findByG_TF_TN(groupId, toFolderId,
2475                                    toName)) {
2476                            remove(dlFileShortcut);
2477                    }
2478            }
2479    
2480            public void removeByG_TF_TN_S(long groupId, long toFolderId, String toName,
2481                    int status) throws SystemException {
2482                    for (DLFileShortcut dlFileShortcut : findByG_TF_TN_S(groupId,
2483                                    toFolderId, toName, status)) {
2484                            remove(dlFileShortcut);
2485                    }
2486            }
2487    
2488            public void removeAll() throws SystemException {
2489                    for (DLFileShortcut dlFileShortcut : findAll()) {
2490                            remove(dlFileShortcut);
2491                    }
2492            }
2493    
2494            public int countByUuid(String uuid) throws SystemException {
2495                    Object[] finderArgs = new Object[] { uuid };
2496    
2497                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_UUID,
2498                                    finderArgs, this);
2499    
2500                    if (count == null) {
2501                            Session session = null;
2502    
2503                            try {
2504                                    session = openSession();
2505    
2506                                    StringBundler query = new StringBundler(2);
2507    
2508                                    query.append(_SQL_COUNT_DLFILESHORTCUT_WHERE);
2509    
2510                                    if (uuid == null) {
2511                                            query.append(_FINDER_COLUMN_UUID_UUID_1);
2512                                    }
2513                                    else {
2514                                            if (uuid.equals(StringPool.BLANK)) {
2515                                                    query.append(_FINDER_COLUMN_UUID_UUID_3);
2516                                            }
2517                                            else {
2518                                                    query.append(_FINDER_COLUMN_UUID_UUID_2);
2519                                            }
2520                                    }
2521    
2522                                    String sql = query.toString();
2523    
2524                                    Query q = session.createQuery(sql);
2525    
2526                                    QueryPos qPos = QueryPos.getInstance(q);
2527    
2528                                    if (uuid != null) {
2529                                            qPos.add(uuid);
2530                                    }
2531    
2532                                    count = (Long)q.uniqueResult();
2533                            }
2534                            catch (Exception e) {
2535                                    throw processException(e);
2536                            }
2537                            finally {
2538                                    if (count == null) {
2539                                            count = Long.valueOf(0);
2540                                    }
2541    
2542                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID,
2543                                            finderArgs, count);
2544    
2545                                    closeSession(session);
2546                            }
2547                    }
2548    
2549                    return count.intValue();
2550            }
2551    
2552            public int countByUUID_G(String uuid, long groupId)
2553                    throws SystemException {
2554                    Object[] finderArgs = new Object[] { uuid, groupId };
2555    
2556                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_UUID_G,
2557                                    finderArgs, this);
2558    
2559                    if (count == null) {
2560                            Session session = null;
2561    
2562                            try {
2563                                    session = openSession();
2564    
2565                                    StringBundler query = new StringBundler(3);
2566    
2567                                    query.append(_SQL_COUNT_DLFILESHORTCUT_WHERE);
2568    
2569                                    if (uuid == null) {
2570                                            query.append(_FINDER_COLUMN_UUID_G_UUID_1);
2571                                    }
2572                                    else {
2573                                            if (uuid.equals(StringPool.BLANK)) {
2574                                                    query.append(_FINDER_COLUMN_UUID_G_UUID_3);
2575                                            }
2576                                            else {
2577                                                    query.append(_FINDER_COLUMN_UUID_G_UUID_2);
2578                                            }
2579                                    }
2580    
2581                                    query.append(_FINDER_COLUMN_UUID_G_GROUPID_2);
2582    
2583                                    String sql = query.toString();
2584    
2585                                    Query q = session.createQuery(sql);
2586    
2587                                    QueryPos qPos = QueryPos.getInstance(q);
2588    
2589                                    if (uuid != null) {
2590                                            qPos.add(uuid);
2591                                    }
2592    
2593                                    qPos.add(groupId);
2594    
2595                                    count = (Long)q.uniqueResult();
2596                            }
2597                            catch (Exception e) {
2598                                    throw processException(e);
2599                            }
2600                            finally {
2601                                    if (count == null) {
2602                                            count = Long.valueOf(0);
2603                                    }
2604    
2605                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID_G,
2606                                            finderArgs, count);
2607    
2608                                    closeSession(session);
2609                            }
2610                    }
2611    
2612                    return count.intValue();
2613            }
2614    
2615            public int countByG_F(long groupId, long folderId)
2616                    throws SystemException {
2617                    Object[] finderArgs = new Object[] { groupId, folderId };
2618    
2619                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_F,
2620                                    finderArgs, this);
2621    
2622                    if (count == null) {
2623                            Session session = null;
2624    
2625                            try {
2626                                    session = openSession();
2627    
2628                                    StringBundler query = new StringBundler(3);
2629    
2630                                    query.append(_SQL_COUNT_DLFILESHORTCUT_WHERE);
2631    
2632                                    query.append(_FINDER_COLUMN_G_F_GROUPID_2);
2633    
2634                                    query.append(_FINDER_COLUMN_G_F_FOLDERID_2);
2635    
2636                                    String sql = query.toString();
2637    
2638                                    Query q = session.createQuery(sql);
2639    
2640                                    QueryPos qPos = QueryPos.getInstance(q);
2641    
2642                                    qPos.add(groupId);
2643    
2644                                    qPos.add(folderId);
2645    
2646                                    count = (Long)q.uniqueResult();
2647                            }
2648                            catch (Exception e) {
2649                                    throw processException(e);
2650                            }
2651                            finally {
2652                                    if (count == null) {
2653                                            count = Long.valueOf(0);
2654                                    }
2655    
2656                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_F, finderArgs,
2657                                            count);
2658    
2659                                    closeSession(session);
2660                            }
2661                    }
2662    
2663                    return count.intValue();
2664            }
2665    
2666            public int filterCountByG_F(long groupId, long folderId)
2667                    throws SystemException {
2668                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
2669                            return countByG_F(groupId, folderId);
2670                    }
2671    
2672                    Session session = null;
2673    
2674                    try {
2675                            session = openSession();
2676    
2677                            StringBundler query = new StringBundler(3);
2678    
2679                            query.append(_FILTER_SQL_COUNT_DLFILESHORTCUT_WHERE);
2680    
2681                            query.append(_FINDER_COLUMN_G_F_GROUPID_2);
2682    
2683                            query.append(_FINDER_COLUMN_G_F_FOLDERID_2);
2684    
2685                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
2686                                            DLFileShortcut.class.getName(), _FILTER_COLUMN_PK,
2687                                            _FILTER_COLUMN_USERID, groupId);
2688    
2689                            SQLQuery q = session.createSQLQuery(sql);
2690    
2691                            q.addScalar(COUNT_COLUMN_NAME,
2692                                    com.liferay.portal.kernel.dao.orm.Type.LONG);
2693    
2694                            QueryPos qPos = QueryPos.getInstance(q);
2695    
2696                            qPos.add(groupId);
2697    
2698                            qPos.add(folderId);
2699    
2700                            Long count = (Long)q.uniqueResult();
2701    
2702                            return count.intValue();
2703                    }
2704                    catch (Exception e) {
2705                            throw processException(e);
2706                    }
2707                    finally {
2708                            closeSession(session);
2709                    }
2710            }
2711    
2712            public int countByG_F_S(long groupId, long folderId, int status)
2713                    throws SystemException {
2714                    Object[] finderArgs = new Object[] { groupId, folderId, status };
2715    
2716                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_F_S,
2717                                    finderArgs, this);
2718    
2719                    if (count == null) {
2720                            Session session = null;
2721    
2722                            try {
2723                                    session = openSession();
2724    
2725                                    StringBundler query = new StringBundler(4);
2726    
2727                                    query.append(_SQL_COUNT_DLFILESHORTCUT_WHERE);
2728    
2729                                    query.append(_FINDER_COLUMN_G_F_S_GROUPID_2);
2730    
2731                                    query.append(_FINDER_COLUMN_G_F_S_FOLDERID_2);
2732    
2733                                    query.append(_FINDER_COLUMN_G_F_S_STATUS_2);
2734    
2735                                    String sql = query.toString();
2736    
2737                                    Query q = session.createQuery(sql);
2738    
2739                                    QueryPos qPos = QueryPos.getInstance(q);
2740    
2741                                    qPos.add(groupId);
2742    
2743                                    qPos.add(folderId);
2744    
2745                                    qPos.add(status);
2746    
2747                                    count = (Long)q.uniqueResult();
2748                            }
2749                            catch (Exception e) {
2750                                    throw processException(e);
2751                            }
2752                            finally {
2753                                    if (count == null) {
2754                                            count = Long.valueOf(0);
2755                                    }
2756    
2757                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_F_S,
2758                                            finderArgs, count);
2759    
2760                                    closeSession(session);
2761                            }
2762                    }
2763    
2764                    return count.intValue();
2765            }
2766    
2767            public int filterCountByG_F_S(long groupId, long folderId, int status)
2768                    throws SystemException {
2769                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
2770                            return countByG_F_S(groupId, folderId, status);
2771                    }
2772    
2773                    Session session = null;
2774    
2775                    try {
2776                            session = openSession();
2777    
2778                            StringBundler query = new StringBundler(4);
2779    
2780                            query.append(_FILTER_SQL_COUNT_DLFILESHORTCUT_WHERE);
2781    
2782                            query.append(_FINDER_COLUMN_G_F_S_GROUPID_2);
2783    
2784                            query.append(_FINDER_COLUMN_G_F_S_FOLDERID_2);
2785    
2786                            query.append(_FINDER_COLUMN_G_F_S_STATUS_2);
2787    
2788                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
2789                                            DLFileShortcut.class.getName(), _FILTER_COLUMN_PK,
2790                                            _FILTER_COLUMN_USERID, groupId);
2791    
2792                            SQLQuery q = session.createSQLQuery(sql);
2793    
2794                            q.addScalar(COUNT_COLUMN_NAME,
2795                                    com.liferay.portal.kernel.dao.orm.Type.LONG);
2796    
2797                            QueryPos qPos = QueryPos.getInstance(q);
2798    
2799                            qPos.add(groupId);
2800    
2801                            qPos.add(folderId);
2802    
2803                            qPos.add(status);
2804    
2805                            Long count = (Long)q.uniqueResult();
2806    
2807                            return count.intValue();
2808                    }
2809                    catch (Exception e) {
2810                            throw processException(e);
2811                    }
2812                    finally {
2813                            closeSession(session);
2814                    }
2815            }
2816    
2817            public int countByG_TF_TN(long groupId, long toFolderId, String toName)
2818                    throws SystemException {
2819                    Object[] finderArgs = new Object[] { groupId, toFolderId, toName };
2820    
2821                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_TF_TN,
2822                                    finderArgs, this);
2823    
2824                    if (count == null) {
2825                            Session session = null;
2826    
2827                            try {
2828                                    session = openSession();
2829    
2830                                    StringBundler query = new StringBundler(4);
2831    
2832                                    query.append(_SQL_COUNT_DLFILESHORTCUT_WHERE);
2833    
2834                                    query.append(_FINDER_COLUMN_G_TF_TN_GROUPID_2);
2835    
2836                                    query.append(_FINDER_COLUMN_G_TF_TN_TOFOLDERID_2);
2837    
2838                                    if (toName == null) {
2839                                            query.append(_FINDER_COLUMN_G_TF_TN_TONAME_1);
2840                                    }
2841                                    else {
2842                                            if (toName.equals(StringPool.BLANK)) {
2843                                                    query.append(_FINDER_COLUMN_G_TF_TN_TONAME_3);
2844                                            }
2845                                            else {
2846                                                    query.append(_FINDER_COLUMN_G_TF_TN_TONAME_2);
2847                                            }
2848                                    }
2849    
2850                                    String sql = query.toString();
2851    
2852                                    Query q = session.createQuery(sql);
2853    
2854                                    QueryPos qPos = QueryPos.getInstance(q);
2855    
2856                                    qPos.add(groupId);
2857    
2858                                    qPos.add(toFolderId);
2859    
2860                                    if (toName != null) {
2861                                            qPos.add(toName);
2862                                    }
2863    
2864                                    count = (Long)q.uniqueResult();
2865                            }
2866                            catch (Exception e) {
2867                                    throw processException(e);
2868                            }
2869                            finally {
2870                                    if (count == null) {
2871                                            count = Long.valueOf(0);
2872                                    }
2873    
2874                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_TF_TN,
2875                                            finderArgs, count);
2876    
2877                                    closeSession(session);
2878                            }
2879                    }
2880    
2881                    return count.intValue();
2882            }
2883    
2884            public int filterCountByG_TF_TN(long groupId, long toFolderId, String toName)
2885                    throws SystemException {
2886                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
2887                            return countByG_TF_TN(groupId, toFolderId, toName);
2888                    }
2889    
2890                    Session session = null;
2891    
2892                    try {
2893                            session = openSession();
2894    
2895                            StringBundler query = new StringBundler(4);
2896    
2897                            query.append(_FILTER_SQL_COUNT_DLFILESHORTCUT_WHERE);
2898    
2899                            query.append(_FINDER_COLUMN_G_TF_TN_GROUPID_2);
2900    
2901                            query.append(_FINDER_COLUMN_G_TF_TN_TOFOLDERID_2);
2902    
2903                            if (toName == null) {
2904                                    query.append(_FINDER_COLUMN_G_TF_TN_TONAME_1);
2905                            }
2906                            else {
2907                                    if (toName.equals(StringPool.BLANK)) {
2908                                            query.append(_FINDER_COLUMN_G_TF_TN_TONAME_3);
2909                                    }
2910                                    else {
2911                                            query.append(_FINDER_COLUMN_G_TF_TN_TONAME_2);
2912                                    }
2913                            }
2914    
2915                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
2916                                            DLFileShortcut.class.getName(), _FILTER_COLUMN_PK,
2917                                            _FILTER_COLUMN_USERID, groupId);
2918    
2919                            SQLQuery q = session.createSQLQuery(sql);
2920    
2921                            q.addScalar(COUNT_COLUMN_NAME,
2922                                    com.liferay.portal.kernel.dao.orm.Type.LONG);
2923    
2924                            QueryPos qPos = QueryPos.getInstance(q);
2925    
2926                            qPos.add(groupId);
2927    
2928                            qPos.add(toFolderId);
2929    
2930                            if (toName != null) {
2931                                    qPos.add(toName);
2932                            }
2933    
2934                            Long count = (Long)q.uniqueResult();
2935    
2936                            return count.intValue();
2937                    }
2938                    catch (Exception e) {
2939                            throw processException(e);
2940                    }
2941                    finally {
2942                            closeSession(session);
2943                    }
2944            }
2945    
2946            public int countByG_TF_TN_S(long groupId, long toFolderId, String toName,
2947                    int status) throws SystemException {
2948                    Object[] finderArgs = new Object[] { groupId, toFolderId, toName, status };
2949    
2950                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_TF_TN_S,
2951                                    finderArgs, this);
2952    
2953                    if (count == null) {
2954                            Session session = null;
2955    
2956                            try {
2957                                    session = openSession();
2958    
2959                                    StringBundler query = new StringBundler(5);
2960    
2961                                    query.append(_SQL_COUNT_DLFILESHORTCUT_WHERE);
2962    
2963                                    query.append(_FINDER_COLUMN_G_TF_TN_S_GROUPID_2);
2964    
2965                                    query.append(_FINDER_COLUMN_G_TF_TN_S_TOFOLDERID_2);
2966    
2967                                    if (toName == null) {
2968                                            query.append(_FINDER_COLUMN_G_TF_TN_S_TONAME_1);
2969                                    }
2970                                    else {
2971                                            if (toName.equals(StringPool.BLANK)) {
2972                                                    query.append(_FINDER_COLUMN_G_TF_TN_S_TONAME_3);
2973                                            }
2974                                            else {
2975                                                    query.append(_FINDER_COLUMN_G_TF_TN_S_TONAME_2);
2976                                            }
2977                                    }
2978    
2979                                    query.append(_FINDER_COLUMN_G_TF_TN_S_STATUS_2);
2980    
2981                                    String sql = query.toString();
2982    
2983                                    Query q = session.createQuery(sql);
2984    
2985                                    QueryPos qPos = QueryPos.getInstance(q);
2986    
2987                                    qPos.add(groupId);
2988    
2989                                    qPos.add(toFolderId);
2990    
2991                                    if (toName != null) {
2992                                            qPos.add(toName);
2993                                    }
2994    
2995                                    qPos.add(status);
2996    
2997                                    count = (Long)q.uniqueResult();
2998                            }
2999                            catch (Exception e) {
3000                                    throw processException(e);
3001                            }
3002                            finally {
3003                                    if (count == null) {
3004                                            count = Long.valueOf(0);
3005                                    }
3006    
3007                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_TF_TN_S,
3008                                            finderArgs, count);
3009    
3010                                    closeSession(session);
3011                            }
3012                    }
3013    
3014                    return count.intValue();
3015            }
3016    
3017            public int filterCountByG_TF_TN_S(long groupId, long toFolderId,
3018                    String toName, int status) throws SystemException {
3019                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
3020                            return countByG_TF_TN_S(groupId, toFolderId, toName, status);
3021                    }
3022    
3023                    Session session = null;
3024    
3025                    try {
3026                            session = openSession();
3027    
3028                            StringBundler query = new StringBundler(5);
3029    
3030                            query.append(_FILTER_SQL_COUNT_DLFILESHORTCUT_WHERE);
3031    
3032                            query.append(_FINDER_COLUMN_G_TF_TN_S_GROUPID_2);
3033    
3034                            query.append(_FINDER_COLUMN_G_TF_TN_S_TOFOLDERID_2);
3035    
3036                            if (toName == null) {
3037                                    query.append(_FINDER_COLUMN_G_TF_TN_S_TONAME_1);
3038                            }
3039                            else {
3040                                    if (toName.equals(StringPool.BLANK)) {
3041                                            query.append(_FINDER_COLUMN_G_TF_TN_S_TONAME_3);
3042                                    }
3043                                    else {
3044                                            query.append(_FINDER_COLUMN_G_TF_TN_S_TONAME_2);
3045                                    }
3046                            }
3047    
3048                            query.append(_FINDER_COLUMN_G_TF_TN_S_STATUS_2);
3049    
3050                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
3051                                            DLFileShortcut.class.getName(), _FILTER_COLUMN_PK,
3052                                            _FILTER_COLUMN_USERID, groupId);
3053    
3054                            SQLQuery q = session.createSQLQuery(sql);
3055    
3056                            q.addScalar(COUNT_COLUMN_NAME,
3057                                    com.liferay.portal.kernel.dao.orm.Type.LONG);
3058    
3059                            QueryPos qPos = QueryPos.getInstance(q);
3060    
3061                            qPos.add(groupId);
3062    
3063                            qPos.add(toFolderId);
3064    
3065                            if (toName != null) {
3066                                    qPos.add(toName);
3067                            }
3068    
3069                            qPos.add(status);
3070    
3071                            Long count = (Long)q.uniqueResult();
3072    
3073                            return count.intValue();
3074                    }
3075                    catch (Exception e) {
3076                            throw processException(e);
3077                    }
3078                    finally {
3079                            closeSession(session);
3080                    }
3081            }
3082    
3083            public int countAll() throws SystemException {
3084                    Object[] finderArgs = new Object[0];
3085    
3086                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
3087                                    finderArgs, this);
3088    
3089                    if (count == null) {
3090                            Session session = null;
3091    
3092                            try {
3093                                    session = openSession();
3094    
3095                                    Query q = session.createQuery(_SQL_COUNT_DLFILESHORTCUT);
3096    
3097                                    count = (Long)q.uniqueResult();
3098                            }
3099                            catch (Exception e) {
3100                                    throw processException(e);
3101                            }
3102                            finally {
3103                                    if (count == null) {
3104                                            count = Long.valueOf(0);
3105                                    }
3106    
3107                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
3108                                            count);
3109    
3110                                    closeSession(session);
3111                            }
3112                    }
3113    
3114                    return count.intValue();
3115            }
3116    
3117            public void afterPropertiesSet() {
3118                    String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
3119                                            com.liferay.portal.util.PropsUtil.get(
3120                                                    "value.object.listener.com.liferay.portlet.documentlibrary.model.DLFileShortcut")));
3121    
3122                    if (listenerClassNames.length > 0) {
3123                            try {
3124                                    List<ModelListener<DLFileShortcut>> listenersList = new ArrayList<ModelListener<DLFileShortcut>>();
3125    
3126                                    for (String listenerClassName : listenerClassNames) {
3127                                            listenersList.add((ModelListener<DLFileShortcut>)InstanceFactory.newInstance(
3128                                                            listenerClassName));
3129                                    }
3130    
3131                                    listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
3132                            }
3133                            catch (Exception e) {
3134                                    _log.error(e);
3135                            }
3136                    }
3137            }
3138    
3139            @BeanReference(type = DLFileEntryPersistence.class)
3140            protected DLFileEntryPersistence dlFileEntryPersistence;
3141            @BeanReference(type = DLFileRankPersistence.class)
3142            protected DLFileRankPersistence dlFileRankPersistence;
3143            @BeanReference(type = DLFileShortcutPersistence.class)
3144            protected DLFileShortcutPersistence dlFileShortcutPersistence;
3145            @BeanReference(type = DLFileVersionPersistence.class)
3146            protected DLFileVersionPersistence dlFileVersionPersistence;
3147            @BeanReference(type = DLFolderPersistence.class)
3148            protected DLFolderPersistence dlFolderPersistence;
3149            @BeanReference(type = ResourcePersistence.class)
3150            protected ResourcePersistence resourcePersistence;
3151            @BeanReference(type = UserPersistence.class)
3152            protected UserPersistence userPersistence;
3153            @BeanReference(type = AssetEntryPersistence.class)
3154            protected AssetEntryPersistence assetEntryPersistence;
3155            @BeanReference(type = AssetTagPersistence.class)
3156            protected AssetTagPersistence assetTagPersistence;
3157            private static final String _SQL_SELECT_DLFILESHORTCUT = "SELECT dlFileShortcut FROM DLFileShortcut dlFileShortcut";
3158            private static final String _SQL_SELECT_DLFILESHORTCUT_WHERE = "SELECT dlFileShortcut FROM DLFileShortcut dlFileShortcut WHERE ";
3159            private static final String _SQL_COUNT_DLFILESHORTCUT = "SELECT COUNT(dlFileShortcut) FROM DLFileShortcut dlFileShortcut";
3160            private static final String _SQL_COUNT_DLFILESHORTCUT_WHERE = "SELECT COUNT(dlFileShortcut) FROM DLFileShortcut dlFileShortcut WHERE ";
3161            private static final String _FINDER_COLUMN_UUID_UUID_1 = "dlFileShortcut.uuid IS NULL";
3162            private static final String _FINDER_COLUMN_UUID_UUID_2 = "dlFileShortcut.uuid = ?";
3163            private static final String _FINDER_COLUMN_UUID_UUID_3 = "(dlFileShortcut.uuid IS NULL OR dlFileShortcut.uuid = ?)";
3164            private static final String _FINDER_COLUMN_UUID_G_UUID_1 = "dlFileShortcut.uuid IS NULL AND ";
3165            private static final String _FINDER_COLUMN_UUID_G_UUID_2 = "dlFileShortcut.uuid = ? AND ";
3166            private static final String _FINDER_COLUMN_UUID_G_UUID_3 = "(dlFileShortcut.uuid IS NULL OR dlFileShortcut.uuid = ?) AND ";
3167            private static final String _FINDER_COLUMN_UUID_G_GROUPID_2 = "dlFileShortcut.groupId = ?";
3168            private static final String _FINDER_COLUMN_G_F_GROUPID_2 = "dlFileShortcut.groupId = ? AND ";
3169            private static final String _FINDER_COLUMN_G_F_FOLDERID_2 = "dlFileShortcut.folderId = ?";
3170            private static final String _FINDER_COLUMN_G_F_S_GROUPID_2 = "dlFileShortcut.groupId = ? AND ";
3171            private static final String _FINDER_COLUMN_G_F_S_FOLDERID_2 = "dlFileShortcut.folderId = ? AND ";
3172            private static final String _FINDER_COLUMN_G_F_S_STATUS_2 = "dlFileShortcut.status = ?";
3173            private static final String _FINDER_COLUMN_G_TF_TN_GROUPID_2 = "dlFileShortcut.groupId = ? AND ";
3174            private static final String _FINDER_COLUMN_G_TF_TN_TOFOLDERID_2 = "dlFileShortcut.toFolderId = ? AND ";
3175            private static final String _FINDER_COLUMN_G_TF_TN_TONAME_1 = "dlFileShortcut.toName IS NULL";
3176            private static final String _FINDER_COLUMN_G_TF_TN_TONAME_2 = "dlFileShortcut.toName = ?";
3177            private static final String _FINDER_COLUMN_G_TF_TN_TONAME_3 = "(dlFileShortcut.toName IS NULL OR dlFileShortcut.toName = ?)";
3178            private static final String _FINDER_COLUMN_G_TF_TN_S_GROUPID_2 = "dlFileShortcut.groupId = ? AND ";
3179            private static final String _FINDER_COLUMN_G_TF_TN_S_TOFOLDERID_2 = "dlFileShortcut.toFolderId = ? AND ";
3180            private static final String _FINDER_COLUMN_G_TF_TN_S_TONAME_1 = "dlFileShortcut.toName IS NULL AND ";
3181            private static final String _FINDER_COLUMN_G_TF_TN_S_TONAME_2 = "dlFileShortcut.toName = ? AND ";
3182            private static final String _FINDER_COLUMN_G_TF_TN_S_TONAME_3 = "(dlFileShortcut.toName IS NULL OR dlFileShortcut.toName = ?) AND ";
3183            private static final String _FINDER_COLUMN_G_TF_TN_S_STATUS_2 = "dlFileShortcut.status = ?";
3184            private static final String _FILTER_SQL_SELECT_DLFILESHORTCUT_WHERE = "SELECT DISTINCT {dlFileShortcut.*} FROM DLFileShortcut dlFileShortcut WHERE ";
3185            private static final String _FILTER_SQL_COUNT_DLFILESHORTCUT_WHERE = "SELECT COUNT(DISTINCT dlFileShortcut.fileShortcutId) AS COUNT_VALUE FROM DLFileShortcut dlFileShortcut WHERE ";
3186            private static final String _FILTER_COLUMN_PK = "dlFileShortcut.fileShortcutId";
3187            private static final String _FILTER_COLUMN_USERID = "dlFileShortcut.userId";
3188            private static final String _FILTER_ENTITY_ALIAS = "dlFileShortcut";
3189            private static final String _ORDER_BY_ENTITY_ALIAS = "dlFileShortcut.";
3190            private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No DLFileShortcut exists with the primary key ";
3191            private static final String _NO_SUCH_ENTITY_WITH_KEY = "No DLFileShortcut exists with the key {";
3192            private static Log _log = LogFactoryUtil.getLog(DLFileShortcutPersistenceImpl.class);
3193    }