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