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