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