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