1   /**
2    * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
3    *
4    * The contents of this file are subject to the terms of the Liferay Enterprise
5    * Subscription License ("License"). You may not use this file except in
6    * compliance with the License. You can obtain a copy of the License by
7    * contacting Liferay, Inc. See the License for the specific language governing
8    * permissions and limitations under the License, including but not limited to
9    * distribution rights of the Software.
10   *
11   *
12   *
13   */
14  
15  package com.liferay.portlet.documentlibrary.service.persistence;
16  
17  import com.liferay.portal.NoSuchModelException;
18  import com.liferay.portal.SystemException;
19  import com.liferay.portal.kernel.annotation.BeanReference;
20  import com.liferay.portal.kernel.cache.CacheRegistry;
21  import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
22  import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
23  import com.liferay.portal.kernel.dao.orm.FinderPath;
24  import com.liferay.portal.kernel.dao.orm.Query;
25  import com.liferay.portal.kernel.dao.orm.QueryPos;
26  import com.liferay.portal.kernel.dao.orm.QueryUtil;
27  import com.liferay.portal.kernel.dao.orm.Session;
28  import com.liferay.portal.kernel.log.Log;
29  import com.liferay.portal.kernel.log.LogFactoryUtil;
30  import com.liferay.portal.kernel.util.GetterUtil;
31  import com.liferay.portal.kernel.util.InstanceFactory;
32  import com.liferay.portal.kernel.util.OrderByComparator;
33  import com.liferay.portal.kernel.util.StringBundler;
34  import com.liferay.portal.kernel.util.StringPool;
35  import com.liferay.portal.kernel.util.StringUtil;
36  import com.liferay.portal.kernel.util.Validator;
37  import com.liferay.portal.kernel.uuid.PortalUUIDUtil;
38  import com.liferay.portal.model.ModelListener;
39  import com.liferay.portal.service.persistence.BatchSessionUtil;
40  import com.liferay.portal.service.persistence.ResourcePersistence;
41  import com.liferay.portal.service.persistence.UserPersistence;
42  import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
43  
44  import com.liferay.portlet.documentlibrary.NoSuchFileShortcutException;
45  import com.liferay.portlet.documentlibrary.model.DLFileShortcut;
46  import com.liferay.portlet.documentlibrary.model.impl.DLFileShortcutImpl;
47  import com.liferay.portlet.documentlibrary.model.impl.DLFileShortcutModelImpl;
48  import com.liferay.portlet.tags.service.persistence.TagsAssetPersistence;
49  import com.liferay.portlet.tags.service.persistence.TagsEntryPersistence;
50  
51  import java.io.Serializable;
52  
53  import java.util.ArrayList;
54  import java.util.Collections;
55  import java.util.List;
56  
57  /**
58   * <a href="DLFileShortcutPersistenceImpl.java.html"><b><i>View Source</i></b></a>
59   *
60   * <p>
61   * ServiceBuilder generated this class. Modifications in this class will be
62   * overwritten the next time is generated.
63   * </p>
64   *
65   * @author    Brian Wing Shun Chan
66   * @see       DLFileShortcutPersistence
67   * @see       DLFileShortcutUtil
68   * @generated
69   */
70  public class DLFileShortcutPersistenceImpl extends BasePersistenceImpl<DLFileShortcut>
71      implements DLFileShortcutPersistence {
72      public static final String FINDER_CLASS_NAME_ENTITY = DLFileShortcutImpl.class.getName();
73      public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
74          ".List";
75      public static final FinderPath FINDER_PATH_FIND_BY_UUID = new FinderPath(DLFileShortcutModelImpl.ENTITY_CACHE_ENABLED,
76              DLFileShortcutModelImpl.FINDER_CACHE_ENABLED,
77              FINDER_CLASS_NAME_LIST, "findByUuid",
78              new String[] {
79                  String.class.getName(),
80                  
81              "java.lang.Integer", "java.lang.Integer",
82                  "com.liferay.portal.kernel.util.OrderByComparator"
83              });
84      public static final FinderPath FINDER_PATH_COUNT_BY_UUID = new FinderPath(DLFileShortcutModelImpl.ENTITY_CACHE_ENABLED,
85              DLFileShortcutModelImpl.FINDER_CACHE_ENABLED,
86              FINDER_CLASS_NAME_LIST, "countByUuid",
87              new String[] { String.class.getName() });
88      public static final FinderPath FINDER_PATH_FETCH_BY_UUID_G = new FinderPath(DLFileShortcutModelImpl.ENTITY_CACHE_ENABLED,
89              DLFileShortcutModelImpl.FINDER_CACHE_ENABLED,
90              FINDER_CLASS_NAME_ENTITY, "fetchByUUID_G",
91              new String[] { String.class.getName(), Long.class.getName() });
92      public static final FinderPath FINDER_PATH_COUNT_BY_UUID_G = new FinderPath(DLFileShortcutModelImpl.ENTITY_CACHE_ENABLED,
93              DLFileShortcutModelImpl.FINDER_CACHE_ENABLED,
94              FINDER_CLASS_NAME_LIST, "countByUUID_G",
95              new String[] { String.class.getName(), Long.class.getName() });
96      public static final FinderPath FINDER_PATH_FIND_BY_FOLDERID = new FinderPath(DLFileShortcutModelImpl.ENTITY_CACHE_ENABLED,
97              DLFileShortcutModelImpl.FINDER_CACHE_ENABLED,
98              FINDER_CLASS_NAME_LIST, "findByFolderId",
99              new String[] {
100                 Long.class.getName(),
101                 
102             "java.lang.Integer", "java.lang.Integer",
103                 "com.liferay.portal.kernel.util.OrderByComparator"
104             });
105     public static final FinderPath FINDER_PATH_COUNT_BY_FOLDERID = new FinderPath(DLFileShortcutModelImpl.ENTITY_CACHE_ENABLED,
106             DLFileShortcutModelImpl.FINDER_CACHE_ENABLED,
107             FINDER_CLASS_NAME_LIST, "countByFolderId",
108             new String[] { Long.class.getName() });
109     public static final FinderPath FINDER_PATH_FIND_BY_TF_TN = new FinderPath(DLFileShortcutModelImpl.ENTITY_CACHE_ENABLED,
110             DLFileShortcutModelImpl.FINDER_CACHE_ENABLED,
111             FINDER_CLASS_NAME_LIST, "findByTF_TN",
112             new String[] {
113                 Long.class.getName(), String.class.getName(),
114                 
115             "java.lang.Integer", "java.lang.Integer",
116                 "com.liferay.portal.kernel.util.OrderByComparator"
117             });
118     public static final FinderPath FINDER_PATH_COUNT_BY_TF_TN = new FinderPath(DLFileShortcutModelImpl.ENTITY_CACHE_ENABLED,
119             DLFileShortcutModelImpl.FINDER_CACHE_ENABLED,
120             FINDER_CLASS_NAME_LIST, "countByTF_TN",
121             new String[] { Long.class.getName(), String.class.getName() });
122     public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(DLFileShortcutModelImpl.ENTITY_CACHE_ENABLED,
123             DLFileShortcutModelImpl.FINDER_CACHE_ENABLED,
124             FINDER_CLASS_NAME_LIST, "findAll", new String[0]);
125     public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(DLFileShortcutModelImpl.ENTITY_CACHE_ENABLED,
126             DLFileShortcutModelImpl.FINDER_CACHE_ENABLED,
127             FINDER_CLASS_NAME_LIST, "countAll", new String[0]);
128 
129     public void cacheResult(DLFileShortcut dlFileShortcut) {
130         EntityCacheUtil.putResult(DLFileShortcutModelImpl.ENTITY_CACHE_ENABLED,
131             DLFileShortcutImpl.class, dlFileShortcut.getPrimaryKey(),
132             dlFileShortcut);
133 
134         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
135             new Object[] {
136                 dlFileShortcut.getUuid(), new Long(dlFileShortcut.getGroupId())
137             }, dlFileShortcut);
138     }
139 
140     public void cacheResult(List<DLFileShortcut> dlFileShortcuts) {
141         for (DLFileShortcut dlFileShortcut : dlFileShortcuts) {
142             if (EntityCacheUtil.getResult(
143                         DLFileShortcutModelImpl.ENTITY_CACHE_ENABLED,
144                         DLFileShortcutImpl.class,
145                         dlFileShortcut.getPrimaryKey(), this) == null) {
146                 cacheResult(dlFileShortcut);
147             }
148         }
149     }
150 
151     public void clearCache() {
152         CacheRegistry.clear(DLFileShortcutImpl.class.getName());
153         EntityCacheUtil.clearCache(DLFileShortcutImpl.class.getName());
154         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
155         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
156     }
157 
158     public void clearCache(DLFileShortcut dlFileShortcut) {
159         EntityCacheUtil.removeResult(DLFileShortcutModelImpl.ENTITY_CACHE_ENABLED,
160             DLFileShortcutImpl.class, dlFileShortcut.getPrimaryKey());
161 
162         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
163             new Object[] {
164                 dlFileShortcut.getUuid(), new Long(dlFileShortcut.getGroupId())
165             });
166     }
167 
168     public DLFileShortcut create(long fileShortcutId) {
169         DLFileShortcut dlFileShortcut = new DLFileShortcutImpl();
170 
171         dlFileShortcut.setNew(true);
172         dlFileShortcut.setPrimaryKey(fileShortcutId);
173 
174         String uuid = PortalUUIDUtil.generate();
175 
176         dlFileShortcut.setUuid(uuid);
177 
178         return dlFileShortcut;
179     }
180 
181     public DLFileShortcut remove(Serializable primaryKey)
182         throws NoSuchModelException, SystemException {
183         return remove(((Long)primaryKey).longValue());
184     }
185 
186     public DLFileShortcut remove(long fileShortcutId)
187         throws NoSuchFileShortcutException, SystemException {
188         Session session = null;
189 
190         try {
191             session = openSession();
192 
193             DLFileShortcut dlFileShortcut = (DLFileShortcut)session.get(DLFileShortcutImpl.class,
194                     new Long(fileShortcutId));
195 
196             if (dlFileShortcut == null) {
197                 if (_log.isWarnEnabled()) {
198                     _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
199                         fileShortcutId);
200                 }
201 
202                 throw new NoSuchFileShortcutException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
203                     fileShortcutId);
204             }
205 
206             return remove(dlFileShortcut);
207         }
208         catch (NoSuchFileShortcutException nsee) {
209             throw nsee;
210         }
211         catch (Exception e) {
212             throw processException(e);
213         }
214         finally {
215             closeSession(session);
216         }
217     }
218 
219     protected DLFileShortcut removeImpl(DLFileShortcut dlFileShortcut)
220         throws SystemException {
221         dlFileShortcut = toUnwrappedModel(dlFileShortcut);
222 
223         Session session = null;
224 
225         try {
226             session = openSession();
227 
228             BatchSessionUtil.delete(session, dlFileShortcut);
229         }
230         catch (Exception e) {
231             throw processException(e);
232         }
233         finally {
234             closeSession(session);
235         }
236 
237         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
238 
239         DLFileShortcutModelImpl dlFileShortcutModelImpl = (DLFileShortcutModelImpl)dlFileShortcut;
240 
241         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
242             new Object[] {
243                 dlFileShortcutModelImpl.getOriginalUuid(),
244                 new Long(dlFileShortcutModelImpl.getOriginalGroupId())
245             });
246 
247         EntityCacheUtil.removeResult(DLFileShortcutModelImpl.ENTITY_CACHE_ENABLED,
248             DLFileShortcutImpl.class, dlFileShortcut.getPrimaryKey());
249 
250         return dlFileShortcut;
251     }
252 
253     /**
254      * @deprecated Use {@link BasePersistence#update(com.liferay.portal.model.BaseModel, boolean)}.
255      */
256     public DLFileShortcut update(DLFileShortcut dlFileShortcut)
257         throws SystemException {
258         if (_log.isWarnEnabled()) {
259             _log.warn(
260                 "Using the deprecated update(DLFileShortcut dlFileShortcut) method. Use update(DLFileShortcut dlFileShortcut, boolean merge) instead.");
261         }
262 
263         return update(dlFileShortcut, false);
264     }
265 
266     public DLFileShortcut updateImpl(
267         com.liferay.portlet.documentlibrary.model.DLFileShortcut dlFileShortcut,
268         boolean merge) throws SystemException {
269         dlFileShortcut = toUnwrappedModel(dlFileShortcut);
270 
271         boolean isNew = dlFileShortcut.isNew();
272 
273         DLFileShortcutModelImpl dlFileShortcutModelImpl = (DLFileShortcutModelImpl)dlFileShortcut;
274 
275         if (Validator.isNull(dlFileShortcut.getUuid())) {
276             String uuid = PortalUUIDUtil.generate();
277 
278             dlFileShortcut.setUuid(uuid);
279         }
280 
281         Session session = null;
282 
283         try {
284             session = openSession();
285 
286             BatchSessionUtil.update(session, dlFileShortcut, merge);
287 
288             dlFileShortcut.setNew(false);
289         }
290         catch (Exception e) {
291             throw processException(e);
292         }
293         finally {
294             closeSession(session);
295         }
296 
297         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
298 
299         EntityCacheUtil.putResult(DLFileShortcutModelImpl.ENTITY_CACHE_ENABLED,
300             DLFileShortcutImpl.class, dlFileShortcut.getPrimaryKey(),
301             dlFileShortcut);
302 
303         if (!isNew &&
304                 (!Validator.equals(dlFileShortcut.getUuid(),
305                     dlFileShortcutModelImpl.getOriginalUuid()) ||
306                 (dlFileShortcut.getGroupId() != dlFileShortcutModelImpl.getOriginalGroupId()))) {
307             FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
308                 new Object[] {
309                     dlFileShortcutModelImpl.getOriginalUuid(),
310                     new Long(dlFileShortcutModelImpl.getOriginalGroupId())
311                 });
312         }
313 
314         if (isNew ||
315                 (!Validator.equals(dlFileShortcut.getUuid(),
316                     dlFileShortcutModelImpl.getOriginalUuid()) ||
317                 (dlFileShortcut.getGroupId() != dlFileShortcutModelImpl.getOriginalGroupId()))) {
318             FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
319                 new Object[] {
320                     dlFileShortcut.getUuid(),
321                     new Long(dlFileShortcut.getGroupId())
322                 }, dlFileShortcut);
323         }
324 
325         return dlFileShortcut;
326     }
327 
328     protected DLFileShortcut toUnwrappedModel(DLFileShortcut dlFileShortcut) {
329         if (dlFileShortcut instanceof DLFileShortcutImpl) {
330             return dlFileShortcut;
331         }
332 
333         DLFileShortcutImpl dlFileShortcutImpl = new DLFileShortcutImpl();
334 
335         dlFileShortcutImpl.setNew(dlFileShortcut.isNew());
336         dlFileShortcutImpl.setPrimaryKey(dlFileShortcut.getPrimaryKey());
337 
338         dlFileShortcutImpl.setUuid(dlFileShortcut.getUuid());
339         dlFileShortcutImpl.setFileShortcutId(dlFileShortcut.getFileShortcutId());
340         dlFileShortcutImpl.setGroupId(dlFileShortcut.getGroupId());
341         dlFileShortcutImpl.setCompanyId(dlFileShortcut.getCompanyId());
342         dlFileShortcutImpl.setUserId(dlFileShortcut.getUserId());
343         dlFileShortcutImpl.setUserName(dlFileShortcut.getUserName());
344         dlFileShortcutImpl.setCreateDate(dlFileShortcut.getCreateDate());
345         dlFileShortcutImpl.setModifiedDate(dlFileShortcut.getModifiedDate());
346         dlFileShortcutImpl.setFolderId(dlFileShortcut.getFolderId());
347         dlFileShortcutImpl.setToFolderId(dlFileShortcut.getToFolderId());
348         dlFileShortcutImpl.setToName(dlFileShortcut.getToName());
349 
350         return dlFileShortcutImpl;
351     }
352 
353     public DLFileShortcut findByPrimaryKey(Serializable primaryKey)
354         throws NoSuchModelException, SystemException {
355         return findByPrimaryKey(((Long)primaryKey).longValue());
356     }
357 
358     public DLFileShortcut findByPrimaryKey(long fileShortcutId)
359         throws NoSuchFileShortcutException, SystemException {
360         DLFileShortcut dlFileShortcut = fetchByPrimaryKey(fileShortcutId);
361 
362         if (dlFileShortcut == null) {
363             if (_log.isWarnEnabled()) {
364                 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + fileShortcutId);
365             }
366 
367             throw new NoSuchFileShortcutException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
368                 fileShortcutId);
369         }
370 
371         return dlFileShortcut;
372     }
373 
374     public DLFileShortcut fetchByPrimaryKey(Serializable primaryKey)
375         throws SystemException {
376         return fetchByPrimaryKey(((Long)primaryKey).longValue());
377     }
378 
379     public DLFileShortcut fetchByPrimaryKey(long fileShortcutId)
380         throws SystemException {
381         DLFileShortcut dlFileShortcut = (DLFileShortcut)EntityCacheUtil.getResult(DLFileShortcutModelImpl.ENTITY_CACHE_ENABLED,
382                 DLFileShortcutImpl.class, fileShortcutId, this);
383 
384         if (dlFileShortcut == null) {
385             Session session = null;
386 
387             try {
388                 session = openSession();
389 
390                 dlFileShortcut = (DLFileShortcut)session.get(DLFileShortcutImpl.class,
391                         new Long(fileShortcutId));
392             }
393             catch (Exception e) {
394                 throw processException(e);
395             }
396             finally {
397                 if (dlFileShortcut != null) {
398                     cacheResult(dlFileShortcut);
399                 }
400 
401                 closeSession(session);
402             }
403         }
404 
405         return dlFileShortcut;
406     }
407 
408     public List<DLFileShortcut> findByUuid(String uuid)
409         throws SystemException {
410         return findByUuid(uuid, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
411     }
412 
413     public List<DLFileShortcut> findByUuid(String uuid, int start, int end)
414         throws SystemException {
415         return findByUuid(uuid, start, end, null);
416     }
417 
418     public List<DLFileShortcut> findByUuid(String uuid, int start, int end,
419         OrderByComparator orderByComparator) throws SystemException {
420         Object[] finderArgs = new Object[] {
421                 uuid,
422                 
423                 String.valueOf(start), String.valueOf(end),
424                 String.valueOf(orderByComparator)
425             };
426 
427         List<DLFileShortcut> list = (List<DLFileShortcut>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_UUID,
428                 finderArgs, this);
429 
430         if (list == null) {
431             StringBundler query = null;
432 
433             if (orderByComparator != null) {
434                 query = new StringBundler(3 +
435                         (orderByComparator.getOrderByFields().length * 3));
436             }
437             else {
438                 query = new StringBundler(2);
439             }
440 
441             query.append(_SQL_SELECT_DLFILESHORTCUT_WHERE);
442 
443             if (uuid == null) {
444                 query.append(_FINDER_COLUMN_UUID_UUID_1);
445             }
446             else {
447                 if (uuid.equals(StringPool.BLANK)) {
448                     query.append(_FINDER_COLUMN_UUID_UUID_3);
449                 }
450                 else {
451                     query.append(_FINDER_COLUMN_UUID_UUID_2);
452                 }
453             }
454 
455             if (orderByComparator != null) {
456                 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
457                     orderByComparator);
458             }
459 
460             String sql = query.toString();
461 
462             Session session = null;
463 
464             try {
465                 session = openSession();
466 
467                 Query q = session.createQuery(sql);
468 
469                 QueryPos qPos = QueryPos.getInstance(q);
470 
471                 if (uuid != null) {
472                     qPos.add(uuid);
473                 }
474 
475                 list = (List<DLFileShortcut>)QueryUtil.list(q, getDialect(),
476                         start, end);
477             }
478             catch (Exception e) {
479                 throw processException(e);
480             }
481             finally {
482                 if (list == null) {
483                     list = new ArrayList<DLFileShortcut>();
484                 }
485 
486                 cacheResult(list);
487 
488                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_UUID, finderArgs,
489                     list);
490 
491                 closeSession(session);
492             }
493         }
494 
495         return list;
496     }
497 
498     public DLFileShortcut findByUuid_First(String uuid,
499         OrderByComparator orderByComparator)
500         throws NoSuchFileShortcutException, SystemException {
501         List<DLFileShortcut> list = findByUuid(uuid, 0, 1, orderByComparator);
502 
503         if (list.isEmpty()) {
504             StringBundler msg = new StringBundler(4);
505 
506             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
507 
508             msg.append("uuid=");
509             msg.append(uuid);
510 
511             msg.append(StringPool.CLOSE_CURLY_BRACE);
512 
513             throw new NoSuchFileShortcutException(msg.toString());
514         }
515         else {
516             return list.get(0);
517         }
518     }
519 
520     public DLFileShortcut findByUuid_Last(String uuid,
521         OrderByComparator orderByComparator)
522         throws NoSuchFileShortcutException, SystemException {
523         int count = countByUuid(uuid);
524 
525         List<DLFileShortcut> list = findByUuid(uuid, count - 1, count,
526                 orderByComparator);
527 
528         if (list.isEmpty()) {
529             StringBundler msg = new StringBundler(4);
530 
531             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
532 
533             msg.append("uuid=");
534             msg.append(uuid);
535 
536             msg.append(StringPool.CLOSE_CURLY_BRACE);
537 
538             throw new NoSuchFileShortcutException(msg.toString());
539         }
540         else {
541             return list.get(0);
542         }
543     }
544 
545     public DLFileShortcut[] findByUuid_PrevAndNext(long fileShortcutId,
546         String uuid, OrderByComparator orderByComparator)
547         throws NoSuchFileShortcutException, SystemException {
548         DLFileShortcut dlFileShortcut = findByPrimaryKey(fileShortcutId);
549 
550         Session session = null;
551 
552         try {
553             session = openSession();
554 
555             DLFileShortcut[] array = new DLFileShortcutImpl[3];
556 
557             array[0] = getByUuid_PrevAndNext(session, dlFileShortcut, uuid,
558                     orderByComparator, true);
559 
560             array[1] = dlFileShortcut;
561 
562             array[2] = getByUuid_PrevAndNext(session, dlFileShortcut, uuid,
563                     orderByComparator, false);
564 
565             return array;
566         }
567         catch (Exception e) {
568             throw processException(e);
569         }
570         finally {
571             closeSession(session);
572         }
573     }
574 
575     protected DLFileShortcut getByUuid_PrevAndNext(Session session,
576         DLFileShortcut dlFileShortcut, String uuid,
577         OrderByComparator orderByComparator, boolean previous) {
578         StringBundler query = null;
579 
580         if (orderByComparator != null) {
581             query = new StringBundler(6 +
582                     (orderByComparator.getOrderByFields().length * 6));
583         }
584         else {
585             query = new StringBundler(3);
586         }
587 
588         query.append(_SQL_SELECT_DLFILESHORTCUT_WHERE);
589 
590         if (uuid == null) {
591             query.append(_FINDER_COLUMN_UUID_UUID_1);
592         }
593         else {
594             if (uuid.equals(StringPool.BLANK)) {
595                 query.append(_FINDER_COLUMN_UUID_UUID_3);
596             }
597             else {
598                 query.append(_FINDER_COLUMN_UUID_UUID_2);
599             }
600         }
601 
602         if (orderByComparator != null) {
603             String[] orderByFields = orderByComparator.getOrderByFields();
604 
605             if (orderByFields.length > 0) {
606                 query.append(WHERE_AND);
607             }
608 
609             for (int i = 0; i < orderByFields.length; i++) {
610                 query.append(_ORDER_BY_ENTITY_ALIAS);
611                 query.append(orderByFields[i]);
612 
613                 if ((i + 1) < orderByFields.length) {
614                     if (orderByComparator.isAscending() ^ previous) {
615                         query.append(WHERE_GREATER_THAN_HAS_NEXT);
616                     }
617                     else {
618                         query.append(WHERE_LESSER_THAN_HAS_NEXT);
619                     }
620                 }
621                 else {
622                     if (orderByComparator.isAscending() ^ previous) {
623                         query.append(WHERE_GREATER_THAN);
624                     }
625                     else {
626                         query.append(WHERE_LESSER_THAN);
627                     }
628                 }
629             }
630 
631             query.append(ORDER_BY_CLAUSE);
632 
633             for (int i = 0; i < orderByFields.length; i++) {
634                 query.append(_ORDER_BY_ENTITY_ALIAS);
635                 query.append(orderByFields[i]);
636 
637                 if ((i + 1) < orderByFields.length) {
638                     if (orderByComparator.isAscending() ^ previous) {
639                         query.append(ORDER_BY_ASC_HAS_NEXT);
640                     }
641                     else {
642                         query.append(ORDER_BY_DESC_HAS_NEXT);
643                     }
644                 }
645                 else {
646                     if (orderByComparator.isAscending() ^ previous) {
647                         query.append(ORDER_BY_ASC);
648                     }
649                     else {
650                         query.append(ORDER_BY_DESC);
651                     }
652                 }
653             }
654         }
655 
656         String sql = query.toString();
657 
658         Query q = session.createQuery(sql);
659 
660         q.setFirstResult(0);
661         q.setMaxResults(2);
662 
663         QueryPos qPos = QueryPos.getInstance(q);
664 
665         if (uuid != null) {
666             qPos.add(uuid);
667         }
668 
669         if (orderByComparator != null) {
670             Object[] values = orderByComparator.getOrderByValues(dlFileShortcut);
671 
672             for (Object value : values) {
673                 qPos.add(value);
674             }
675         }
676 
677         List<DLFileShortcut> list = q.list();
678 
679         if (list.size() == 2) {
680             return list.get(1);
681         }
682         else {
683             return null;
684         }
685     }
686 
687     public DLFileShortcut findByUUID_G(String uuid, long groupId)
688         throws NoSuchFileShortcutException, SystemException {
689         DLFileShortcut dlFileShortcut = fetchByUUID_G(uuid, groupId);
690 
691         if (dlFileShortcut == null) {
692             StringBundler msg = new StringBundler(6);
693 
694             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
695 
696             msg.append("uuid=");
697             msg.append(uuid);
698 
699             msg.append(", groupId=");
700             msg.append(groupId);
701 
702             msg.append(StringPool.CLOSE_CURLY_BRACE);
703 
704             if (_log.isWarnEnabled()) {
705                 _log.warn(msg.toString());
706             }
707 
708             throw new NoSuchFileShortcutException(msg.toString());
709         }
710 
711         return dlFileShortcut;
712     }
713 
714     public DLFileShortcut fetchByUUID_G(String uuid, long groupId)
715         throws SystemException {
716         return fetchByUUID_G(uuid, groupId, true);
717     }
718 
719     public DLFileShortcut fetchByUUID_G(String uuid, long groupId,
720         boolean retrieveFromCache) throws SystemException {
721         Object[] finderArgs = new Object[] { uuid, groupId };
722 
723         Object result = null;
724 
725         if (retrieveFromCache) {
726             result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_UUID_G,
727                     finderArgs, this);
728         }
729 
730         if (result == null) {
731             StringBundler query = new StringBundler(3);
732 
733             query.append(_SQL_SELECT_DLFILESHORTCUT_WHERE);
734 
735             if (uuid == null) {
736                 query.append(_FINDER_COLUMN_UUID_G_UUID_1);
737             }
738             else {
739                 if (uuid.equals(StringPool.BLANK)) {
740                     query.append(_FINDER_COLUMN_UUID_G_UUID_3);
741                 }
742                 else {
743                     query.append(_FINDER_COLUMN_UUID_G_UUID_2);
744                 }
745             }
746 
747             query.append(_FINDER_COLUMN_UUID_G_GROUPID_2);
748 
749             String sql = query.toString();
750 
751             Session session = null;
752 
753             try {
754                 session = openSession();
755 
756                 Query q = session.createQuery(sql);
757 
758                 QueryPos qPos = QueryPos.getInstance(q);
759 
760                 if (uuid != null) {
761                     qPos.add(uuid);
762                 }
763 
764                 qPos.add(groupId);
765 
766                 List<DLFileShortcut> list = q.list();
767 
768                 result = list;
769 
770                 DLFileShortcut dlFileShortcut = null;
771 
772                 if (list.isEmpty()) {
773                     FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
774                         finderArgs, list);
775                 }
776                 else {
777                     dlFileShortcut = list.get(0);
778 
779                     cacheResult(dlFileShortcut);
780 
781                     if ((dlFileShortcut.getUuid() == null) ||
782                             !dlFileShortcut.getUuid().equals(uuid) ||
783                             (dlFileShortcut.getGroupId() != groupId)) {
784                         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
785                             finderArgs, dlFileShortcut);
786                     }
787                 }
788 
789                 return dlFileShortcut;
790             }
791             catch (Exception e) {
792                 throw processException(e);
793             }
794             finally {
795                 if (result == null) {
796                     FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
797                         finderArgs, new ArrayList<DLFileShortcut>());
798                 }
799 
800                 closeSession(session);
801             }
802         }
803         else {
804             if (result instanceof List<?>) {
805                 return null;
806             }
807             else {
808                 return (DLFileShortcut)result;
809             }
810         }
811     }
812 
813     public List<DLFileShortcut> findByFolderId(long folderId)
814         throws SystemException {
815         return findByFolderId(folderId, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
816             null);
817     }
818 
819     public List<DLFileShortcut> findByFolderId(long folderId, int start, int end)
820         throws SystemException {
821         return findByFolderId(folderId, start, end, null);
822     }
823 
824     public List<DLFileShortcut> findByFolderId(long folderId, int start,
825         int end, OrderByComparator orderByComparator) throws SystemException {
826         Object[] finderArgs = new Object[] {
827                 folderId,
828                 
829                 String.valueOf(start), String.valueOf(end),
830                 String.valueOf(orderByComparator)
831             };
832 
833         List<DLFileShortcut> list = (List<DLFileShortcut>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_FOLDERID,
834                 finderArgs, this);
835 
836         if (list == null) {
837             StringBundler query = null;
838 
839             if (orderByComparator != null) {
840                 query = new StringBundler(3 +
841                         (orderByComparator.getOrderByFields().length * 3));
842             }
843             else {
844                 query = new StringBundler(2);
845             }
846 
847             query.append(_SQL_SELECT_DLFILESHORTCUT_WHERE);
848 
849             query.append(_FINDER_COLUMN_FOLDERID_FOLDERID_2);
850 
851             if (orderByComparator != null) {
852                 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
853                     orderByComparator);
854             }
855 
856             String sql = query.toString();
857 
858             Session session = null;
859 
860             try {
861                 session = openSession();
862 
863                 Query q = session.createQuery(sql);
864 
865                 QueryPos qPos = QueryPos.getInstance(q);
866 
867                 qPos.add(folderId);
868 
869                 list = (List<DLFileShortcut>)QueryUtil.list(q, getDialect(),
870                         start, end);
871             }
872             catch (Exception e) {
873                 throw processException(e);
874             }
875             finally {
876                 if (list == null) {
877                     list = new ArrayList<DLFileShortcut>();
878                 }
879 
880                 cacheResult(list);
881 
882                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_FOLDERID,
883                     finderArgs, list);
884 
885                 closeSession(session);
886             }
887         }
888 
889         return list;
890     }
891 
892     public DLFileShortcut findByFolderId_First(long folderId,
893         OrderByComparator orderByComparator)
894         throws NoSuchFileShortcutException, SystemException {
895         List<DLFileShortcut> list = findByFolderId(folderId, 0, 1,
896                 orderByComparator);
897 
898         if (list.isEmpty()) {
899             StringBundler msg = new StringBundler(4);
900 
901             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
902 
903             msg.append("folderId=");
904             msg.append(folderId);
905 
906             msg.append(StringPool.CLOSE_CURLY_BRACE);
907 
908             throw new NoSuchFileShortcutException(msg.toString());
909         }
910         else {
911             return list.get(0);
912         }
913     }
914 
915     public DLFileShortcut findByFolderId_Last(long folderId,
916         OrderByComparator orderByComparator)
917         throws NoSuchFileShortcutException, SystemException {
918         int count = countByFolderId(folderId);
919 
920         List<DLFileShortcut> list = findByFolderId(folderId, count - 1, count,
921                 orderByComparator);
922 
923         if (list.isEmpty()) {
924             StringBundler msg = new StringBundler(4);
925 
926             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
927 
928             msg.append("folderId=");
929             msg.append(folderId);
930 
931             msg.append(StringPool.CLOSE_CURLY_BRACE);
932 
933             throw new NoSuchFileShortcutException(msg.toString());
934         }
935         else {
936             return list.get(0);
937         }
938     }
939 
940     public DLFileShortcut[] findByFolderId_PrevAndNext(long fileShortcutId,
941         long folderId, OrderByComparator orderByComparator)
942         throws NoSuchFileShortcutException, SystemException {
943         DLFileShortcut dlFileShortcut = findByPrimaryKey(fileShortcutId);
944 
945         Session session = null;
946 
947         try {
948             session = openSession();
949 
950             DLFileShortcut[] array = new DLFileShortcutImpl[3];
951 
952             array[0] = getByFolderId_PrevAndNext(session, dlFileShortcut,
953                     folderId, orderByComparator, true);
954 
955             array[1] = dlFileShortcut;
956 
957             array[2] = getByFolderId_PrevAndNext(session, dlFileShortcut,
958                     folderId, orderByComparator, false);
959 
960             return array;
961         }
962         catch (Exception e) {
963             throw processException(e);
964         }
965         finally {
966             closeSession(session);
967         }
968     }
969 
970     protected DLFileShortcut getByFolderId_PrevAndNext(Session session,
971         DLFileShortcut dlFileShortcut, long folderId,
972         OrderByComparator orderByComparator, boolean previous) {
973         StringBundler query = null;
974 
975         if (orderByComparator != null) {
976             query = new StringBundler(6 +
977                     (orderByComparator.getOrderByFields().length * 6));
978         }
979         else {
980             query = new StringBundler(3);
981         }
982 
983         query.append(_SQL_SELECT_DLFILESHORTCUT_WHERE);
984 
985         query.append(_FINDER_COLUMN_FOLDERID_FOLDERID_2);
986 
987         if (orderByComparator != null) {
988             String[] orderByFields = orderByComparator.getOrderByFields();
989 
990             if (orderByFields.length > 0) {
991                 query.append(WHERE_AND);
992             }
993 
994             for (int i = 0; i < orderByFields.length; i++) {
995                 query.append(_ORDER_BY_ENTITY_ALIAS);
996                 query.append(orderByFields[i]);
997 
998                 if ((i + 1) < orderByFields.length) {
999                     if (orderByComparator.isAscending() ^ previous) {
1000                        query.append(WHERE_GREATER_THAN_HAS_NEXT);
1001                    }
1002                    else {
1003                        query.append(WHERE_LESSER_THAN_HAS_NEXT);
1004                    }
1005                }
1006                else {
1007                    if (orderByComparator.isAscending() ^ previous) {
1008                        query.append(WHERE_GREATER_THAN);
1009                    }
1010                    else {
1011                        query.append(WHERE_LESSER_THAN);
1012                    }
1013                }
1014            }
1015
1016            query.append(ORDER_BY_CLAUSE);
1017
1018            for (int i = 0; i < orderByFields.length; i++) {
1019                query.append(_ORDER_BY_ENTITY_ALIAS);
1020                query.append(orderByFields[i]);
1021
1022                if ((i + 1) < orderByFields.length) {
1023                    if (orderByComparator.isAscending() ^ previous) {
1024                        query.append(ORDER_BY_ASC_HAS_NEXT);
1025                    }
1026                    else {
1027                        query.append(ORDER_BY_DESC_HAS_NEXT);
1028                    }
1029                }
1030                else {
1031                    if (orderByComparator.isAscending() ^ previous) {
1032                        query.append(ORDER_BY_ASC);
1033                    }
1034                    else {
1035                        query.append(ORDER_BY_DESC);
1036                    }
1037                }
1038            }
1039        }
1040
1041        String sql = query.toString();
1042
1043        Query q = session.createQuery(sql);
1044
1045        q.setFirstResult(0);
1046        q.setMaxResults(2);
1047
1048        QueryPos qPos = QueryPos.getInstance(q);
1049
1050        qPos.add(folderId);
1051
1052        if (orderByComparator != null) {
1053            Object[] values = orderByComparator.getOrderByValues(dlFileShortcut);
1054
1055            for (Object value : values) {
1056                qPos.add(value);
1057            }
1058        }
1059
1060        List<DLFileShortcut> list = q.list();
1061
1062        if (list.size() == 2) {
1063            return list.get(1);
1064        }
1065        else {
1066            return null;
1067        }
1068    }
1069
1070    public List<DLFileShortcut> findByTF_TN(long toFolderId, String toName)
1071        throws SystemException {
1072        return findByTF_TN(toFolderId, toName, QueryUtil.ALL_POS,
1073            QueryUtil.ALL_POS, null);
1074    }
1075
1076    public List<DLFileShortcut> findByTF_TN(long toFolderId, String toName,
1077        int start, int end) throws SystemException {
1078        return findByTF_TN(toFolderId, toName, start, end, null);
1079    }
1080
1081    public List<DLFileShortcut> findByTF_TN(long toFolderId, String toName,
1082        int start, int end, OrderByComparator orderByComparator)
1083        throws SystemException {
1084        Object[] finderArgs = new Object[] {
1085                toFolderId, toName,
1086                
1087                String.valueOf(start), String.valueOf(end),
1088                String.valueOf(orderByComparator)
1089            };
1090
1091        List<DLFileShortcut> list = (List<DLFileShortcut>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_TF_TN,
1092                finderArgs, this);
1093
1094        if (list == null) {
1095            StringBundler query = null;
1096
1097            if (orderByComparator != null) {
1098                query = new StringBundler(4 +
1099                        (orderByComparator.getOrderByFields().length * 3));
1100            }
1101            else {
1102                query = new StringBundler(3);
1103            }
1104
1105            query.append(_SQL_SELECT_DLFILESHORTCUT_WHERE);
1106
1107            query.append(_FINDER_COLUMN_TF_TN_TOFOLDERID_2);
1108
1109            if (toName == null) {
1110                query.append(_FINDER_COLUMN_TF_TN_TONAME_1);
1111            }
1112            else {
1113                if (toName.equals(StringPool.BLANK)) {
1114                    query.append(_FINDER_COLUMN_TF_TN_TONAME_3);
1115                }
1116                else {
1117                    query.append(_FINDER_COLUMN_TF_TN_TONAME_2);
1118                }
1119            }
1120
1121            if (orderByComparator != null) {
1122                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1123                    orderByComparator);
1124            }
1125
1126            String sql = query.toString();
1127
1128            Session session = null;
1129
1130            try {
1131                session = openSession();
1132
1133                Query q = session.createQuery(sql);
1134
1135                QueryPos qPos = QueryPos.getInstance(q);
1136
1137                qPos.add(toFolderId);
1138
1139                if (toName != null) {
1140                    qPos.add(toName);
1141                }
1142
1143                list = (List<DLFileShortcut>)QueryUtil.list(q, getDialect(),
1144                        start, end);
1145            }
1146            catch (Exception e) {
1147                throw processException(e);
1148            }
1149            finally {
1150                if (list == null) {
1151                    list = new ArrayList<DLFileShortcut>();
1152                }
1153
1154                cacheResult(list);
1155
1156                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_TF_TN,
1157                    finderArgs, list);
1158
1159                closeSession(session);
1160            }
1161        }
1162
1163        return list;
1164    }
1165
1166    public DLFileShortcut findByTF_TN_First(long toFolderId, String toName,
1167        OrderByComparator orderByComparator)
1168        throws NoSuchFileShortcutException, SystemException {
1169        List<DLFileShortcut> list = findByTF_TN(toFolderId, toName, 0, 1,
1170                orderByComparator);
1171
1172        if (list.isEmpty()) {
1173            StringBundler msg = new StringBundler(6);
1174
1175            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1176
1177            msg.append("toFolderId=");
1178            msg.append(toFolderId);
1179
1180            msg.append(", toName=");
1181            msg.append(toName);
1182
1183            msg.append(StringPool.CLOSE_CURLY_BRACE);
1184
1185            throw new NoSuchFileShortcutException(msg.toString());
1186        }
1187        else {
1188            return list.get(0);
1189        }
1190    }
1191
1192    public DLFileShortcut findByTF_TN_Last(long toFolderId, String toName,
1193        OrderByComparator orderByComparator)
1194        throws NoSuchFileShortcutException, SystemException {
1195        int count = countByTF_TN(toFolderId, toName);
1196
1197        List<DLFileShortcut> list = findByTF_TN(toFolderId, toName, count - 1,
1198                count, orderByComparator);
1199
1200        if (list.isEmpty()) {
1201            StringBundler msg = new StringBundler(6);
1202
1203            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1204
1205            msg.append("toFolderId=");
1206            msg.append(toFolderId);
1207
1208            msg.append(", toName=");
1209            msg.append(toName);
1210
1211            msg.append(StringPool.CLOSE_CURLY_BRACE);
1212
1213            throw new NoSuchFileShortcutException(msg.toString());
1214        }
1215        else {
1216            return list.get(0);
1217        }
1218    }
1219
1220    public DLFileShortcut[] findByTF_TN_PrevAndNext(long fileShortcutId,
1221        long toFolderId, String toName, OrderByComparator orderByComparator)
1222        throws NoSuchFileShortcutException, SystemException {
1223        DLFileShortcut dlFileShortcut = findByPrimaryKey(fileShortcutId);
1224
1225        Session session = null;
1226
1227        try {
1228            session = openSession();
1229
1230            DLFileShortcut[] array = new DLFileShortcutImpl[3];
1231
1232            array[0] = getByTF_TN_PrevAndNext(session, dlFileShortcut,
1233                    toFolderId, toName, orderByComparator, true);
1234
1235            array[1] = dlFileShortcut;
1236
1237            array[2] = getByTF_TN_PrevAndNext(session, dlFileShortcut,
1238                    toFolderId, toName, orderByComparator, false);
1239
1240            return array;
1241        }
1242        catch (Exception e) {
1243            throw processException(e);
1244        }
1245        finally {
1246            closeSession(session);
1247        }
1248    }
1249
1250    protected DLFileShortcut getByTF_TN_PrevAndNext(Session session,
1251        DLFileShortcut dlFileShortcut, long toFolderId, String toName,
1252        OrderByComparator orderByComparator, boolean previous) {
1253        StringBundler query = null;
1254
1255        if (orderByComparator != null) {
1256            query = new StringBundler(6 +
1257                    (orderByComparator.getOrderByFields().length * 6));
1258        }
1259        else {
1260            query = new StringBundler(3);
1261        }
1262
1263        query.append(_SQL_SELECT_DLFILESHORTCUT_WHERE);
1264
1265        query.append(_FINDER_COLUMN_TF_TN_TOFOLDERID_2);
1266
1267        if (toName == null) {
1268            query.append(_FINDER_COLUMN_TF_TN_TONAME_1);
1269        }
1270        else {
1271            if (toName.equals(StringPool.BLANK)) {
1272                query.append(_FINDER_COLUMN_TF_TN_TONAME_3);
1273            }
1274            else {
1275                query.append(_FINDER_COLUMN_TF_TN_TONAME_2);
1276            }
1277        }
1278
1279        if (orderByComparator != null) {
1280            String[] orderByFields = orderByComparator.getOrderByFields();
1281
1282            if (orderByFields.length > 0) {
1283                query.append(WHERE_AND);
1284            }
1285
1286            for (int i = 0; i < orderByFields.length; i++) {
1287                query.append(_ORDER_BY_ENTITY_ALIAS);
1288                query.append(orderByFields[i]);
1289
1290                if ((i + 1) < orderByFields.length) {
1291                    if (orderByComparator.isAscending() ^ previous) {
1292                        query.append(WHERE_GREATER_THAN_HAS_NEXT);
1293                    }
1294                    else {
1295                        query.append(WHERE_LESSER_THAN_HAS_NEXT);
1296                    }
1297                }
1298                else {
1299                    if (orderByComparator.isAscending() ^ previous) {
1300                        query.append(WHERE_GREATER_THAN);
1301                    }
1302                    else {
1303                        query.append(WHERE_LESSER_THAN);
1304                    }
1305                }
1306            }
1307
1308            query.append(ORDER_BY_CLAUSE);
1309
1310            for (int i = 0; i < orderByFields.length; i++) {
1311                query.append(_ORDER_BY_ENTITY_ALIAS);
1312                query.append(orderByFields[i]);
1313
1314                if ((i + 1) < orderByFields.length) {
1315                    if (orderByComparator.isAscending() ^ previous) {
1316                        query.append(ORDER_BY_ASC_HAS_NEXT);
1317                    }
1318                    else {
1319                        query.append(ORDER_BY_DESC_HAS_NEXT);
1320                    }
1321                }
1322                else {
1323                    if (orderByComparator.isAscending() ^ previous) {
1324                        query.append(ORDER_BY_ASC);
1325                    }
1326                    else {
1327                        query.append(ORDER_BY_DESC);
1328                    }
1329                }
1330            }
1331        }
1332
1333        String sql = query.toString();
1334
1335        Query q = session.createQuery(sql);
1336
1337        q.setFirstResult(0);
1338        q.setMaxResults(2);
1339
1340        QueryPos qPos = QueryPos.getInstance(q);
1341
1342        qPos.add(toFolderId);
1343
1344        if (toName != null) {
1345            qPos.add(toName);
1346        }
1347
1348        if (orderByComparator != null) {
1349            Object[] values = orderByComparator.getOrderByValues(dlFileShortcut);
1350
1351            for (Object value : values) {
1352                qPos.add(value);
1353            }
1354        }
1355
1356        List<DLFileShortcut> list = q.list();
1357
1358        if (list.size() == 2) {
1359            return list.get(1);
1360        }
1361        else {
1362            return null;
1363        }
1364    }
1365
1366    public List<DLFileShortcut> findAll() throws SystemException {
1367        return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1368    }
1369
1370    public List<DLFileShortcut> findAll(int start, int end)
1371        throws SystemException {
1372        return findAll(start, end, null);
1373    }
1374
1375    public List<DLFileShortcut> findAll(int start, int end,
1376        OrderByComparator orderByComparator) throws SystemException {
1377        Object[] finderArgs = new Object[] {
1378                String.valueOf(start), String.valueOf(end),
1379                String.valueOf(orderByComparator)
1380            };
1381
1382        List<DLFileShortcut> list = (List<DLFileShortcut>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
1383                finderArgs, this);
1384
1385        if (list == null) {
1386            StringBundler query = null;
1387            String sql = null;
1388
1389            if (orderByComparator != null) {
1390                query = new StringBundler(2 +
1391                        (orderByComparator.getOrderByFields().length * 3));
1392
1393                query.append(_SQL_SELECT_DLFILESHORTCUT);
1394
1395                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1396                    orderByComparator);
1397
1398                sql = query.toString();
1399            }
1400            else {
1401                sql = _SQL_SELECT_DLFILESHORTCUT;
1402            }
1403
1404            Session session = null;
1405
1406            try {
1407                session = openSession();
1408
1409                Query q = session.createQuery(sql);
1410
1411                if (orderByComparator == null) {
1412                    list = (List<DLFileShortcut>)QueryUtil.list(q,
1413                            getDialect(), start, end, false);
1414
1415                    Collections.sort(list);
1416                }
1417                else {
1418                    list = (List<DLFileShortcut>)QueryUtil.list(q,
1419                            getDialect(), start, end);
1420                }
1421            }
1422            catch (Exception e) {
1423                throw processException(e);
1424            }
1425            finally {
1426                if (list == null) {
1427                    list = new ArrayList<DLFileShortcut>();
1428                }
1429
1430                cacheResult(list);
1431
1432                FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
1433
1434                closeSession(session);
1435            }
1436        }
1437
1438        return list;
1439    }
1440
1441    public void removeByUuid(String uuid) throws SystemException {
1442        for (DLFileShortcut dlFileShortcut : findByUuid(uuid)) {
1443            remove(dlFileShortcut);
1444        }
1445    }
1446
1447    public void removeByUUID_G(String uuid, long groupId)
1448        throws NoSuchFileShortcutException, SystemException {
1449        DLFileShortcut dlFileShortcut = findByUUID_G(uuid, groupId);
1450
1451        remove(dlFileShortcut);
1452    }
1453
1454    public void removeByFolderId(long folderId) throws SystemException {
1455        for (DLFileShortcut dlFileShortcut : findByFolderId(folderId)) {
1456            remove(dlFileShortcut);
1457        }
1458    }
1459
1460    public void removeByTF_TN(long toFolderId, String toName)
1461        throws SystemException {
1462        for (DLFileShortcut dlFileShortcut : findByTF_TN(toFolderId, toName)) {
1463            remove(dlFileShortcut);
1464        }
1465    }
1466
1467    public void removeAll() throws SystemException {
1468        for (DLFileShortcut dlFileShortcut : findAll()) {
1469            remove(dlFileShortcut);
1470        }
1471    }
1472
1473    public int countByUuid(String uuid) throws SystemException {
1474        Object[] finderArgs = new Object[] { uuid };
1475
1476        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_UUID,
1477                finderArgs, this);
1478
1479        if (count == null) {
1480            StringBundler query = new StringBundler(2);
1481
1482            query.append(_SQL_COUNT_DLFILESHORTCUT_WHERE);
1483
1484            if (uuid == null) {
1485                query.append(_FINDER_COLUMN_UUID_UUID_1);
1486            }
1487            else {
1488                if (uuid.equals(StringPool.BLANK)) {
1489                    query.append(_FINDER_COLUMN_UUID_UUID_3);
1490                }
1491                else {
1492                    query.append(_FINDER_COLUMN_UUID_UUID_2);
1493                }
1494            }
1495
1496            String sql = query.toString();
1497
1498            Session session = null;
1499
1500            try {
1501                session = openSession();
1502
1503                Query q = session.createQuery(sql);
1504
1505                QueryPos qPos = QueryPos.getInstance(q);
1506
1507                if (uuid != null) {
1508                    qPos.add(uuid);
1509                }
1510
1511                count = (Long)q.uniqueResult();
1512            }
1513            catch (Exception e) {
1514                throw processException(e);
1515            }
1516            finally {
1517                if (count == null) {
1518                    count = Long.valueOf(0);
1519                }
1520
1521                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID,
1522                    finderArgs, count);
1523
1524                closeSession(session);
1525            }
1526        }
1527
1528        return count.intValue();
1529    }
1530
1531    public int countByUUID_G(String uuid, long groupId)
1532        throws SystemException {
1533        Object[] finderArgs = new Object[] { uuid, groupId };
1534
1535        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_UUID_G,
1536                finderArgs, this);
1537
1538        if (count == null) {
1539            StringBundler query = new StringBundler(3);
1540
1541            query.append(_SQL_COUNT_DLFILESHORTCUT_WHERE);
1542
1543            if (uuid == null) {
1544                query.append(_FINDER_COLUMN_UUID_G_UUID_1);
1545            }
1546            else {
1547                if (uuid.equals(StringPool.BLANK)) {
1548                    query.append(_FINDER_COLUMN_UUID_G_UUID_3);
1549                }
1550                else {
1551                    query.append(_FINDER_COLUMN_UUID_G_UUID_2);
1552                }
1553            }
1554
1555            query.append(_FINDER_COLUMN_UUID_G_GROUPID_2);
1556
1557            String sql = query.toString();
1558
1559            Session session = null;
1560
1561            try {
1562                session = openSession();
1563
1564                Query q = session.createQuery(sql);
1565
1566                QueryPos qPos = QueryPos.getInstance(q);
1567
1568                if (uuid != null) {
1569                    qPos.add(uuid);
1570                }
1571
1572                qPos.add(groupId);
1573
1574                count = (Long)q.uniqueResult();
1575            }
1576            catch (Exception e) {
1577                throw processException(e);
1578            }
1579            finally {
1580                if (count == null) {
1581                    count = Long.valueOf(0);
1582                }
1583
1584                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID_G,
1585                    finderArgs, count);
1586
1587                closeSession(session);
1588            }
1589        }
1590
1591        return count.intValue();
1592    }
1593
1594    public int countByFolderId(long folderId) throws SystemException {
1595        Object[] finderArgs = new Object[] { folderId };
1596
1597        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_FOLDERID,
1598                finderArgs, this);
1599
1600        if (count == null) {
1601            StringBundler query = new StringBundler(2);
1602
1603            query.append(_SQL_COUNT_DLFILESHORTCUT_WHERE);
1604
1605            query.append(_FINDER_COLUMN_FOLDERID_FOLDERID_2);
1606
1607            String sql = query.toString();
1608
1609            Session session = null;
1610
1611            try {
1612                session = openSession();
1613
1614                Query q = session.createQuery(sql);
1615
1616                QueryPos qPos = QueryPos.getInstance(q);
1617
1618                qPos.add(folderId);
1619
1620                count = (Long)q.uniqueResult();
1621            }
1622            catch (Exception e) {
1623                throw processException(e);
1624            }
1625            finally {
1626                if (count == null) {
1627                    count = Long.valueOf(0);
1628                }
1629
1630                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_FOLDERID,
1631                    finderArgs, count);
1632
1633                closeSession(session);
1634            }
1635        }
1636
1637        return count.intValue();
1638    }
1639
1640    public int countByTF_TN(long toFolderId, String toName)
1641        throws SystemException {
1642        Object[] finderArgs = new Object[] { toFolderId, toName };
1643
1644        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_TF_TN,
1645                finderArgs, this);
1646
1647        if (count == null) {
1648            StringBundler query = new StringBundler(3);
1649
1650            query.append(_SQL_COUNT_DLFILESHORTCUT_WHERE);
1651
1652            query.append(_FINDER_COLUMN_TF_TN_TOFOLDERID_2);
1653
1654            if (toName == null) {
1655                query.append(_FINDER_COLUMN_TF_TN_TONAME_1);
1656            }
1657            else {
1658                if (toName.equals(StringPool.BLANK)) {
1659                    query.append(_FINDER_COLUMN_TF_TN_TONAME_3);
1660                }
1661                else {
1662                    query.append(_FINDER_COLUMN_TF_TN_TONAME_2);
1663                }
1664            }
1665
1666            String sql = query.toString();
1667
1668            Session session = null;
1669
1670            try {
1671                session = openSession();
1672
1673                Query q = session.createQuery(sql);
1674
1675                QueryPos qPos = QueryPos.getInstance(q);
1676
1677                qPos.add(toFolderId);
1678
1679                if (toName != null) {
1680                    qPos.add(toName);
1681                }
1682
1683                count = (Long)q.uniqueResult();
1684            }
1685            catch (Exception e) {
1686                throw processException(e);
1687            }
1688            finally {
1689                if (count == null) {
1690                    count = Long.valueOf(0);
1691                }
1692
1693                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_TF_TN,
1694                    finderArgs, count);
1695
1696                closeSession(session);
1697            }
1698        }
1699
1700        return count.intValue();
1701    }
1702
1703    public int countAll() throws SystemException {
1704        Object[] finderArgs = new Object[0];
1705
1706        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
1707                finderArgs, this);
1708
1709        if (count == null) {
1710            Session session = null;
1711
1712            try {
1713                session = openSession();
1714
1715                Query q = session.createQuery(_SQL_COUNT_DLFILESHORTCUT);
1716
1717                count = (Long)q.uniqueResult();
1718            }
1719            catch (Exception e) {
1720                throw processException(e);
1721            }
1722            finally {
1723                if (count == null) {
1724                    count = Long.valueOf(0);
1725                }
1726
1727                FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
1728                    count);
1729
1730                closeSession(session);
1731            }
1732        }
1733
1734        return count.intValue();
1735    }
1736
1737    public void afterPropertiesSet() {
1738        String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
1739                    com.liferay.portal.util.PropsUtil.get(
1740                        "value.object.listener.com.liferay.portlet.documentlibrary.model.DLFileShortcut")));
1741
1742        if (listenerClassNames.length > 0) {
1743            try {
1744                List<ModelListener<DLFileShortcut>> listenersList = new ArrayList<ModelListener<DLFileShortcut>>();
1745
1746                for (String listenerClassName : listenerClassNames) {
1747                    listenersList.add((ModelListener<DLFileShortcut>)InstanceFactory.newInstance(
1748                            listenerClassName));
1749                }
1750
1751                listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
1752            }
1753            catch (Exception e) {
1754                _log.error(e);
1755            }
1756        }
1757    }
1758
1759    public void destroy() {
1760        EntityCacheUtil.removeCache(DLFileShortcutImpl.class.getName());
1761        FinderCacheUtil.removeCache(FINDER_CLASS_NAME_ENTITY);
1762        FinderCacheUtil.removeCache(FINDER_CLASS_NAME_LIST);
1763    }
1764
1765    @BeanReference(type = DLFileEntryPersistence.class)
1766    protected DLFileEntryPersistence dlFileEntryPersistence;
1767    @BeanReference(type = DLFileRankPersistence.class)
1768    protected DLFileRankPersistence dlFileRankPersistence;
1769    @BeanReference(type = DLFileShortcutPersistence.class)
1770    protected DLFileShortcutPersistence dlFileShortcutPersistence;
1771    @BeanReference(type = DLFileVersionPersistence.class)
1772    protected DLFileVersionPersistence dlFileVersionPersistence;
1773    @BeanReference(type = DLFolderPersistence.class)
1774    protected DLFolderPersistence dlFolderPersistence;
1775    @BeanReference(type = ResourcePersistence.class)
1776    protected ResourcePersistence resourcePersistence;
1777    @BeanReference(type = UserPersistence.class)
1778    protected UserPersistence userPersistence;
1779    @BeanReference(type = TagsAssetPersistence.class)
1780    protected TagsAssetPersistence tagsAssetPersistence;
1781    @BeanReference(type = TagsEntryPersistence.class)
1782    protected TagsEntryPersistence tagsEntryPersistence;
1783    private static final String _SQL_SELECT_DLFILESHORTCUT = "SELECT dlFileShortcut FROM DLFileShortcut dlFileShortcut";
1784    private static final String _SQL_SELECT_DLFILESHORTCUT_WHERE = "SELECT dlFileShortcut FROM DLFileShortcut dlFileShortcut WHERE ";
1785    private static final String _SQL_COUNT_DLFILESHORTCUT = "SELECT COUNT(dlFileShortcut) FROM DLFileShortcut dlFileShortcut";
1786    private static final String _SQL_COUNT_DLFILESHORTCUT_WHERE = "SELECT COUNT(dlFileShortcut) FROM DLFileShortcut dlFileShortcut WHERE ";
1787    private static final String _FINDER_COLUMN_UUID_UUID_1 = "dlFileShortcut.uuid IS NULL";
1788    private static final String _FINDER_COLUMN_UUID_UUID_2 = "dlFileShortcut.uuid = ?";
1789    private static final String _FINDER_COLUMN_UUID_UUID_3 = "(dlFileShortcut.uuid IS NULL OR dlFileShortcut.uuid = ?)";
1790    private static final String _FINDER_COLUMN_UUID_G_UUID_1 = "dlFileShortcut.uuid IS NULL AND ";
1791    private static final String _FINDER_COLUMN_UUID_G_UUID_2 = "dlFileShortcut.uuid = ? AND ";
1792    private static final String _FINDER_COLUMN_UUID_G_UUID_3 = "(dlFileShortcut.uuid IS NULL OR dlFileShortcut.uuid = ?) AND ";
1793    private static final String _FINDER_COLUMN_UUID_G_GROUPID_2 = "dlFileShortcut.groupId = ?";
1794    private static final String _FINDER_COLUMN_FOLDERID_FOLDERID_2 = "dlFileShortcut.folderId = ?";
1795    private static final String _FINDER_COLUMN_TF_TN_TOFOLDERID_2 = "dlFileShortcut.toFolderId = ? AND ";
1796    private static final String _FINDER_COLUMN_TF_TN_TONAME_1 = "dlFileShortcut.toName IS NULL";
1797    private static final String _FINDER_COLUMN_TF_TN_TONAME_2 = "dlFileShortcut.toName = ?";
1798    private static final String _FINDER_COLUMN_TF_TN_TONAME_3 = "(dlFileShortcut.toName IS NULL OR dlFileShortcut.toName = ?)";
1799    private static final String _ORDER_BY_ENTITY_ALIAS = "dlFileShortcut.";
1800    private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No DLFileShortcut exists with the primary key ";
1801    private static final String _NO_SUCH_ENTITY_WITH_KEY = "No DLFileShortcut exists with the key {";
1802    private static Log _log = LogFactoryUtil.getLog(DLFileShortcutPersistenceImpl.class);
1803}