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