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