1   /**
2    * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
3    *
4    * The contents of this file are subject to the terms of the Liferay Enterprise
5    * Subscription License ("License"). You may not use this file except in
6    * compliance with the License. You can obtain a copy of the License by
7    * contacting Liferay, Inc. See the License for the specific language governing
8    * permissions and limitations under the License, including but not limited to
9    * distribution rights of the Software.
10   *
11   *
12   * 
13   */
14  
15  package com.liferay.portlet.documentlibrary.service.persistence;
16  
17  import com.liferay.portal.NoSuchModelException;
18  import com.liferay.portal.SystemException;
19  import com.liferay.portal.kernel.annotation.BeanReference;
20  import com.liferay.portal.kernel.cache.CacheRegistry;
21  import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
22  import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
23  import com.liferay.portal.kernel.dao.orm.FinderPath;
24  import com.liferay.portal.kernel.dao.orm.Query;
25  import com.liferay.portal.kernel.dao.orm.QueryPos;
26  import com.liferay.portal.kernel.dao.orm.QueryUtil;
27  import com.liferay.portal.kernel.dao.orm.Session;
28  import com.liferay.portal.kernel.log.Log;
29  import com.liferay.portal.kernel.log.LogFactoryUtil;
30  import com.liferay.portal.kernel.util.GetterUtil;
31  import com.liferay.portal.kernel.util.OrderByComparator;
32  import com.liferay.portal.kernel.util.StringBundler;
33  import com.liferay.portal.kernel.util.StringPool;
34  import com.liferay.portal.kernel.util.StringUtil;
35  import com.liferay.portal.kernel.util.Validator;
36  import com.liferay.portal.model.ModelListener;
37  import com.liferay.portal.service.persistence.BatchSessionUtil;
38  import com.liferay.portal.service.persistence.LayoutPersistence;
39  import com.liferay.portal.service.persistence.ResourcePersistence;
40  import com.liferay.portal.service.persistence.UserPersistence;
41  import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
42  
43  import com.liferay.portlet.documentlibrary.NoSuchFileRankException;
44  import com.liferay.portlet.documentlibrary.model.DLFileRank;
45  import com.liferay.portlet.documentlibrary.model.impl.DLFileRankImpl;
46  import com.liferay.portlet.documentlibrary.model.impl.DLFileRankModelImpl;
47  
48  import java.io.Serializable;
49  
50  import java.util.ArrayList;
51  import java.util.Collections;
52  import java.util.List;
53  
54  /**
55   * <a href="DLFileRankPersistenceImpl.java.html"><b><i>View Source</i></b></a>
56   *
57   * <p>
58   * ServiceBuilder generated this class. Modifications in this class will be
59   * overwritten the next time is generated.
60   * </p>
61   *
62   * @author    Brian Wing Shun Chan
63   * @see       DLFileRankPersistence
64   * @see       DLFileRankUtil
65   * @generated
66   */
67  public class DLFileRankPersistenceImpl extends BasePersistenceImpl<DLFileRank>
68      implements DLFileRankPersistence {
69      public static final String FINDER_CLASS_NAME_ENTITY = DLFileRankImpl.class.getName();
70      public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
71          ".List";
72      public static final FinderPath FINDER_PATH_FIND_BY_USERID = new FinderPath(DLFileRankModelImpl.ENTITY_CACHE_ENABLED,
73              DLFileRankModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
74              "findByUserId", new String[] { Long.class.getName() });
75      public static final FinderPath FINDER_PATH_FIND_BY_OBC_USERID = new FinderPath(DLFileRankModelImpl.ENTITY_CACHE_ENABLED,
76              DLFileRankModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
77              "findByUserId",
78              new String[] {
79                  Long.class.getName(),
80                  
81              "java.lang.Integer", "java.lang.Integer",
82                  "com.liferay.portal.kernel.util.OrderByComparator"
83              });
84      public static final FinderPath FINDER_PATH_COUNT_BY_USERID = new FinderPath(DLFileRankModelImpl.ENTITY_CACHE_ENABLED,
85              DLFileRankModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
86              "countByUserId", new String[] { Long.class.getName() });
87      public static final FinderPath FINDER_PATH_FIND_BY_G_U = new FinderPath(DLFileRankModelImpl.ENTITY_CACHE_ENABLED,
88              DLFileRankModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
89              "findByG_U",
90              new String[] { Long.class.getName(), Long.class.getName() });
91      public static final FinderPath FINDER_PATH_FIND_BY_OBC_G_U = new FinderPath(DLFileRankModelImpl.ENTITY_CACHE_ENABLED,
92              DLFileRankModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
93              "findByG_U",
94              new String[] {
95                  Long.class.getName(), Long.class.getName(),
96                  
97              "java.lang.Integer", "java.lang.Integer",
98                  "com.liferay.portal.kernel.util.OrderByComparator"
99              });
100     public static final FinderPath FINDER_PATH_COUNT_BY_G_U = new FinderPath(DLFileRankModelImpl.ENTITY_CACHE_ENABLED,
101             DLFileRankModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
102             "countByG_U",
103             new String[] { Long.class.getName(), Long.class.getName() });
104     public static final FinderPath FINDER_PATH_FIND_BY_F_N = new FinderPath(DLFileRankModelImpl.ENTITY_CACHE_ENABLED,
105             DLFileRankModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
106             "findByF_N",
107             new String[] { Long.class.getName(), String.class.getName() });
108     public static final FinderPath FINDER_PATH_FIND_BY_OBC_F_N = new FinderPath(DLFileRankModelImpl.ENTITY_CACHE_ENABLED,
109             DLFileRankModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
110             "findByF_N",
111             new String[] {
112                 Long.class.getName(), String.class.getName(),
113                 
114             "java.lang.Integer", "java.lang.Integer",
115                 "com.liferay.portal.kernel.util.OrderByComparator"
116             });
117     public static final FinderPath FINDER_PATH_COUNT_BY_F_N = new FinderPath(DLFileRankModelImpl.ENTITY_CACHE_ENABLED,
118             DLFileRankModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
119             "countByF_N",
120             new String[] { Long.class.getName(), String.class.getName() });
121     public static final FinderPath FINDER_PATH_FETCH_BY_C_U_F_N = new FinderPath(DLFileRankModelImpl.ENTITY_CACHE_ENABLED,
122             DLFileRankModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_ENTITY,
123             "fetchByC_U_F_N",
124             new String[] {
125                 Long.class.getName(), Long.class.getName(), Long.class.getName(),
126                 String.class.getName()
127             });
128     public static final FinderPath FINDER_PATH_COUNT_BY_C_U_F_N = new FinderPath(DLFileRankModelImpl.ENTITY_CACHE_ENABLED,
129             DLFileRankModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
130             "countByC_U_F_N",
131             new String[] {
132                 Long.class.getName(), Long.class.getName(), Long.class.getName(),
133                 String.class.getName()
134             });
135     public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(DLFileRankModelImpl.ENTITY_CACHE_ENABLED,
136             DLFileRankModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
137             "findAll", new String[0]);
138     public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(DLFileRankModelImpl.ENTITY_CACHE_ENABLED,
139             DLFileRankModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
140             "countAll", new String[0]);
141 
142     public void cacheResult(DLFileRank dlFileRank) {
143         EntityCacheUtil.putResult(DLFileRankModelImpl.ENTITY_CACHE_ENABLED,
144             DLFileRankImpl.class, dlFileRank.getPrimaryKey(), dlFileRank);
145 
146         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_U_F_N,
147             new Object[] {
148                 new Long(dlFileRank.getCompanyId()),
149                 new Long(dlFileRank.getUserId()),
150                 new Long(dlFileRank.getFolderId()),
151                 
152             dlFileRank.getName()
153             }, dlFileRank);
154     }
155 
156     public void cacheResult(List<DLFileRank> dlFileRanks) {
157         for (DLFileRank dlFileRank : dlFileRanks) {
158             if (EntityCacheUtil.getResult(
159                         DLFileRankModelImpl.ENTITY_CACHE_ENABLED,
160                         DLFileRankImpl.class, dlFileRank.getPrimaryKey(), this) == null) {
161                 cacheResult(dlFileRank);
162             }
163         }
164     }
165 
166     public void clearCache() {
167         CacheRegistry.clear(DLFileRankImpl.class.getName());
168         EntityCacheUtil.clearCache(DLFileRankImpl.class.getName());
169         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
170         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
171     }
172 
173     public DLFileRank create(long fileRankId) {
174         DLFileRank dlFileRank = new DLFileRankImpl();
175 
176         dlFileRank.setNew(true);
177         dlFileRank.setPrimaryKey(fileRankId);
178 
179         return dlFileRank;
180     }
181 
182     public DLFileRank remove(Serializable primaryKey)
183         throws NoSuchModelException, SystemException {
184         return remove(((Long)primaryKey).longValue());
185     }
186 
187     public DLFileRank remove(long fileRankId)
188         throws NoSuchFileRankException, SystemException {
189         Session session = null;
190 
191         try {
192             session = openSession();
193 
194             DLFileRank dlFileRank = (DLFileRank)session.get(DLFileRankImpl.class,
195                     new Long(fileRankId));
196 
197             if (dlFileRank == null) {
198                 if (_log.isWarnEnabled()) {
199                     _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + fileRankId);
200                 }
201 
202                 throw new NoSuchFileRankException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
203                     fileRankId);
204             }
205 
206             return remove(dlFileRank);
207         }
208         catch (NoSuchFileRankException nsee) {
209             throw nsee;
210         }
211         catch (Exception e) {
212             throw processException(e);
213         }
214         finally {
215             closeSession(session);
216         }
217     }
218 
219     public DLFileRank remove(DLFileRank dlFileRank) throws SystemException {
220         for (ModelListener<DLFileRank> listener : listeners) {
221             listener.onBeforeRemove(dlFileRank);
222         }
223 
224         dlFileRank = removeImpl(dlFileRank);
225 
226         for (ModelListener<DLFileRank> listener : listeners) {
227             listener.onAfterRemove(dlFileRank);
228         }
229 
230         return dlFileRank;
231     }
232 
233     protected DLFileRank removeImpl(DLFileRank dlFileRank)
234         throws SystemException {
235         dlFileRank = toUnwrappedModel(dlFileRank);
236 
237         Session session = null;
238 
239         try {
240             session = openSession();
241 
242             if (dlFileRank.isCachedModel() || BatchSessionUtil.isEnabled()) {
243                 Object staleObject = session.get(DLFileRankImpl.class,
244                         dlFileRank.getPrimaryKeyObj());
245 
246                 if (staleObject != null) {
247                     session.evict(staleObject);
248                 }
249             }
250 
251             session.delete(dlFileRank);
252 
253             session.flush();
254         }
255         catch (Exception e) {
256             throw processException(e);
257         }
258         finally {
259             closeSession(session);
260         }
261 
262         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
263 
264         DLFileRankModelImpl dlFileRankModelImpl = (DLFileRankModelImpl)dlFileRank;
265 
266         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_C_U_F_N,
267             new Object[] {
268                 new Long(dlFileRankModelImpl.getOriginalCompanyId()),
269                 new Long(dlFileRankModelImpl.getOriginalUserId()),
270                 new Long(dlFileRankModelImpl.getOriginalFolderId()),
271                 
272             dlFileRankModelImpl.getOriginalName()
273             });
274 
275         EntityCacheUtil.removeResult(DLFileRankModelImpl.ENTITY_CACHE_ENABLED,
276             DLFileRankImpl.class, dlFileRank.getPrimaryKey());
277 
278         return dlFileRank;
279     }
280 
281     /**
282      * @deprecated Use {@link BasePersistence#update(com.liferay.portal.model.BaseModel, boolean)}.
283      */
284     public DLFileRank update(DLFileRank dlFileRank) throws SystemException {
285         if (_log.isWarnEnabled()) {
286             _log.warn(
287                 "Using the deprecated update(DLFileRank dlFileRank) method. Use update(DLFileRank dlFileRank, boolean merge) instead.");
288         }
289 
290         return update(dlFileRank, false);
291     }
292 
293     public DLFileRank updateImpl(
294         com.liferay.portlet.documentlibrary.model.DLFileRank dlFileRank,
295         boolean merge) throws SystemException {
296         dlFileRank = toUnwrappedModel(dlFileRank);
297 
298         boolean isNew = dlFileRank.isNew();
299 
300         DLFileRankModelImpl dlFileRankModelImpl = (DLFileRankModelImpl)dlFileRank;
301 
302         Session session = null;
303 
304         try {
305             session = openSession();
306 
307             BatchSessionUtil.update(session, dlFileRank, merge);
308 
309             dlFileRank.setNew(false);
310         }
311         catch (Exception e) {
312             throw processException(e);
313         }
314         finally {
315             closeSession(session);
316         }
317 
318         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
319 
320         EntityCacheUtil.putResult(DLFileRankModelImpl.ENTITY_CACHE_ENABLED,
321             DLFileRankImpl.class, dlFileRank.getPrimaryKey(), dlFileRank);
322 
323         if (!isNew &&
324                 ((dlFileRank.getCompanyId() != dlFileRankModelImpl.getOriginalCompanyId()) ||
325                 (dlFileRank.getUserId() != dlFileRankModelImpl.getOriginalUserId()) ||
326                 (dlFileRank.getFolderId() != dlFileRankModelImpl.getOriginalFolderId()) ||
327                 !Validator.equals(dlFileRank.getName(),
328                     dlFileRankModelImpl.getOriginalName()))) {
329             FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_C_U_F_N,
330                 new Object[] {
331                     new Long(dlFileRankModelImpl.getOriginalCompanyId()),
332                     new Long(dlFileRankModelImpl.getOriginalUserId()),
333                     new Long(dlFileRankModelImpl.getOriginalFolderId()),
334                     
335                 dlFileRankModelImpl.getOriginalName()
336                 });
337         }
338 
339         if (isNew ||
340                 ((dlFileRank.getCompanyId() != dlFileRankModelImpl.getOriginalCompanyId()) ||
341                 (dlFileRank.getUserId() != dlFileRankModelImpl.getOriginalUserId()) ||
342                 (dlFileRank.getFolderId() != dlFileRankModelImpl.getOriginalFolderId()) ||
343                 !Validator.equals(dlFileRank.getName(),
344                     dlFileRankModelImpl.getOriginalName()))) {
345             FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_U_F_N,
346                 new Object[] {
347                     new Long(dlFileRank.getCompanyId()),
348                     new Long(dlFileRank.getUserId()),
349                     new Long(dlFileRank.getFolderId()),
350                     
351                 dlFileRank.getName()
352                 }, dlFileRank);
353         }
354 
355         return dlFileRank;
356     }
357 
358     protected DLFileRank toUnwrappedModel(DLFileRank dlFileRank) {
359         if (dlFileRank instanceof DLFileRankImpl) {
360             return dlFileRank;
361         }
362 
363         DLFileRankImpl dlFileRankImpl = new DLFileRankImpl();
364 
365         dlFileRankImpl.setNew(dlFileRank.isNew());
366         dlFileRankImpl.setPrimaryKey(dlFileRank.getPrimaryKey());
367 
368         dlFileRankImpl.setFileRankId(dlFileRank.getFileRankId());
369         dlFileRankImpl.setGroupId(dlFileRank.getGroupId());
370         dlFileRankImpl.setCompanyId(dlFileRank.getCompanyId());
371         dlFileRankImpl.setUserId(dlFileRank.getUserId());
372         dlFileRankImpl.setCreateDate(dlFileRank.getCreateDate());
373         dlFileRankImpl.setFolderId(dlFileRank.getFolderId());
374         dlFileRankImpl.setName(dlFileRank.getName());
375 
376         return dlFileRankImpl;
377     }
378 
379     public DLFileRank findByPrimaryKey(Serializable primaryKey)
380         throws NoSuchModelException, SystemException {
381         return findByPrimaryKey(((Long)primaryKey).longValue());
382     }
383 
384     public DLFileRank findByPrimaryKey(long fileRankId)
385         throws NoSuchFileRankException, SystemException {
386         DLFileRank dlFileRank = fetchByPrimaryKey(fileRankId);
387 
388         if (dlFileRank == null) {
389             if (_log.isWarnEnabled()) {
390                 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + fileRankId);
391             }
392 
393             throw new NoSuchFileRankException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
394                 fileRankId);
395         }
396 
397         return dlFileRank;
398     }
399 
400     public DLFileRank fetchByPrimaryKey(Serializable primaryKey)
401         throws SystemException {
402         return fetchByPrimaryKey(((Long)primaryKey).longValue());
403     }
404 
405     public DLFileRank fetchByPrimaryKey(long fileRankId)
406         throws SystemException {
407         DLFileRank dlFileRank = (DLFileRank)EntityCacheUtil.getResult(DLFileRankModelImpl.ENTITY_CACHE_ENABLED,
408                 DLFileRankImpl.class, fileRankId, this);
409 
410         if (dlFileRank == null) {
411             Session session = null;
412 
413             try {
414                 session = openSession();
415 
416                 dlFileRank = (DLFileRank)session.get(DLFileRankImpl.class,
417                         new Long(fileRankId));
418             }
419             catch (Exception e) {
420                 throw processException(e);
421             }
422             finally {
423                 if (dlFileRank != null) {
424                     cacheResult(dlFileRank);
425                 }
426 
427                 closeSession(session);
428             }
429         }
430 
431         return dlFileRank;
432     }
433 
434     public List<DLFileRank> findByUserId(long userId) throws SystemException {
435         Object[] finderArgs = new Object[] { new Long(userId) };
436 
437         List<DLFileRank> list = (List<DLFileRank>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_USERID,
438                 finderArgs, this);
439 
440         if (list == null) {
441             Session session = null;
442 
443             try {
444                 session = openSession();
445 
446                 StringBundler query = new StringBundler(3);
447 
448                 query.append(_SQL_SELECT_DLFILERANK_WHERE);
449 
450                 query.append(_FINDER_COLUMN_USERID_USERID_2);
451 
452                 query.append(DLFileRankModelImpl.ORDER_BY_JPQL);
453 
454                 String sql = query.toString();
455 
456                 Query q = session.createQuery(sql);
457 
458                 QueryPos qPos = QueryPos.getInstance(q);
459 
460                 qPos.add(userId);
461 
462                 list = q.list();
463             }
464             catch (Exception e) {
465                 throw processException(e);
466             }
467             finally {
468                 if (list == null) {
469                     list = new ArrayList<DLFileRank>();
470                 }
471 
472                 cacheResult(list);
473 
474                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_USERID,
475                     finderArgs, list);
476 
477                 closeSession(session);
478             }
479         }
480 
481         return list;
482     }
483 
484     public List<DLFileRank> findByUserId(long userId, int start, int end)
485         throws SystemException {
486         return findByUserId(userId, start, end, null);
487     }
488 
489     public List<DLFileRank> findByUserId(long userId, int start, int end,
490         OrderByComparator orderByComparator) throws SystemException {
491         Object[] finderArgs = new Object[] {
492                 new Long(userId),
493                 
494                 String.valueOf(start), String.valueOf(end),
495                 String.valueOf(orderByComparator)
496             };
497 
498         List<DLFileRank> list = (List<DLFileRank>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_USERID,
499                 finderArgs, this);
500 
501         if (list == null) {
502             Session session = null;
503 
504             try {
505                 session = openSession();
506 
507                 StringBundler query = null;
508 
509                 if (orderByComparator != null) {
510                     query = new StringBundler(3 +
511                             (orderByComparator.getOrderByFields().length * 3));
512                 }
513                 else {
514                     query = new StringBundler(3);
515                 }
516 
517                 query.append(_SQL_SELECT_DLFILERANK_WHERE);
518 
519                 query.append(_FINDER_COLUMN_USERID_USERID_2);
520 
521                 if (orderByComparator != null) {
522                     appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
523                         orderByComparator);
524                 }
525 
526                 else {
527                     query.append(DLFileRankModelImpl.ORDER_BY_JPQL);
528                 }
529 
530                 String sql = query.toString();
531 
532                 Query q = session.createQuery(sql);
533 
534                 QueryPos qPos = QueryPos.getInstance(q);
535 
536                 qPos.add(userId);
537 
538                 list = (List<DLFileRank>)QueryUtil.list(q, getDialect(), start,
539                         end);
540             }
541             catch (Exception e) {
542                 throw processException(e);
543             }
544             finally {
545                 if (list == null) {
546                     list = new ArrayList<DLFileRank>();
547                 }
548 
549                 cacheResult(list);
550 
551                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_USERID,
552                     finderArgs, list);
553 
554                 closeSession(session);
555             }
556         }
557 
558         return list;
559     }
560 
561     public DLFileRank findByUserId_First(long userId,
562         OrderByComparator orderByComparator)
563         throws NoSuchFileRankException, SystemException {
564         List<DLFileRank> list = findByUserId(userId, 0, 1, orderByComparator);
565 
566         if (list.isEmpty()) {
567             StringBundler msg = new StringBundler(4);
568 
569             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
570 
571             msg.append("userId=");
572             msg.append(userId);
573 
574             msg.append(StringPool.CLOSE_CURLY_BRACE);
575 
576             throw new NoSuchFileRankException(msg.toString());
577         }
578         else {
579             return list.get(0);
580         }
581     }
582 
583     public DLFileRank findByUserId_Last(long userId,
584         OrderByComparator orderByComparator)
585         throws NoSuchFileRankException, SystemException {
586         int count = countByUserId(userId);
587 
588         List<DLFileRank> list = findByUserId(userId, count - 1, count,
589                 orderByComparator);
590 
591         if (list.isEmpty()) {
592             StringBundler msg = new StringBundler(4);
593 
594             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
595 
596             msg.append("userId=");
597             msg.append(userId);
598 
599             msg.append(StringPool.CLOSE_CURLY_BRACE);
600 
601             throw new NoSuchFileRankException(msg.toString());
602         }
603         else {
604             return list.get(0);
605         }
606     }
607 
608     public DLFileRank[] findByUserId_PrevAndNext(long fileRankId, long userId,
609         OrderByComparator orderByComparator)
610         throws NoSuchFileRankException, SystemException {
611         DLFileRank dlFileRank = findByPrimaryKey(fileRankId);
612 
613         int count = countByUserId(userId);
614 
615         Session session = null;
616 
617         try {
618             session = openSession();
619 
620             StringBundler query = null;
621 
622             if (orderByComparator != null) {
623                 query = new StringBundler(3 +
624                         (orderByComparator.getOrderByFields().length * 3));
625             }
626             else {
627                 query = new StringBundler(3);
628             }
629 
630             query.append(_SQL_SELECT_DLFILERANK_WHERE);
631 
632             query.append(_FINDER_COLUMN_USERID_USERID_2);
633 
634             if (orderByComparator != null) {
635                 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
636                     orderByComparator);
637             }
638 
639             else {
640                 query.append(DLFileRankModelImpl.ORDER_BY_JPQL);
641             }
642 
643             String sql = query.toString();
644 
645             Query q = session.createQuery(sql);
646 
647             QueryPos qPos = QueryPos.getInstance(q);
648 
649             qPos.add(userId);
650 
651             Object[] objArray = QueryUtil.getPrevAndNext(q, count,
652                     orderByComparator, dlFileRank);
653 
654             DLFileRank[] array = new DLFileRankImpl[3];
655 
656             array[0] = (DLFileRank)objArray[0];
657             array[1] = (DLFileRank)objArray[1];
658             array[2] = (DLFileRank)objArray[2];
659 
660             return array;
661         }
662         catch (Exception e) {
663             throw processException(e);
664         }
665         finally {
666             closeSession(session);
667         }
668     }
669 
670     public List<DLFileRank> findByG_U(long groupId, long userId)
671         throws SystemException {
672         Object[] finderArgs = new Object[] { new Long(groupId), new Long(userId) };
673 
674         List<DLFileRank> list = (List<DLFileRank>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_U,
675                 finderArgs, this);
676 
677         if (list == null) {
678             Session session = null;
679 
680             try {
681                 session = openSession();
682 
683                 StringBundler query = new StringBundler(4);
684 
685                 query.append(_SQL_SELECT_DLFILERANK_WHERE);
686 
687                 query.append(_FINDER_COLUMN_G_U_GROUPID_2);
688 
689                 query.append(_FINDER_COLUMN_G_U_USERID_2);
690 
691                 query.append(DLFileRankModelImpl.ORDER_BY_JPQL);
692 
693                 String sql = query.toString();
694 
695                 Query q = session.createQuery(sql);
696 
697                 QueryPos qPos = QueryPos.getInstance(q);
698 
699                 qPos.add(groupId);
700 
701                 qPos.add(userId);
702 
703                 list = q.list();
704             }
705             catch (Exception e) {
706                 throw processException(e);
707             }
708             finally {
709                 if (list == null) {
710                     list = new ArrayList<DLFileRank>();
711                 }
712 
713                 cacheResult(list);
714 
715                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_U, finderArgs,
716                     list);
717 
718                 closeSession(session);
719             }
720         }
721 
722         return list;
723     }
724 
725     public List<DLFileRank> findByG_U(long groupId, long userId, int start,
726         int end) throws SystemException {
727         return findByG_U(groupId, userId, start, end, null);
728     }
729 
730     public List<DLFileRank> findByG_U(long groupId, long userId, int start,
731         int end, OrderByComparator orderByComparator) throws SystemException {
732         Object[] finderArgs = new Object[] {
733                 new Long(groupId), new Long(userId),
734                 
735                 String.valueOf(start), String.valueOf(end),
736                 String.valueOf(orderByComparator)
737             };
738 
739         List<DLFileRank> list = (List<DLFileRank>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_G_U,
740                 finderArgs, this);
741 
742         if (list == null) {
743             Session session = null;
744 
745             try {
746                 session = openSession();
747 
748                 StringBundler query = null;
749 
750                 if (orderByComparator != null) {
751                     query = new StringBundler(4 +
752                             (orderByComparator.getOrderByFields().length * 3));
753                 }
754                 else {
755                     query = new StringBundler(4);
756                 }
757 
758                 query.append(_SQL_SELECT_DLFILERANK_WHERE);
759 
760                 query.append(_FINDER_COLUMN_G_U_GROUPID_2);
761 
762                 query.append(_FINDER_COLUMN_G_U_USERID_2);
763 
764                 if (orderByComparator != null) {
765                     appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
766                         orderByComparator);
767                 }
768 
769                 else {
770                     query.append(DLFileRankModelImpl.ORDER_BY_JPQL);
771                 }
772 
773                 String sql = query.toString();
774 
775                 Query q = session.createQuery(sql);
776 
777                 QueryPos qPos = QueryPos.getInstance(q);
778 
779                 qPos.add(groupId);
780 
781                 qPos.add(userId);
782 
783                 list = (List<DLFileRank>)QueryUtil.list(q, getDialect(), start,
784                         end);
785             }
786             catch (Exception e) {
787                 throw processException(e);
788             }
789             finally {
790                 if (list == null) {
791                     list = new ArrayList<DLFileRank>();
792                 }
793 
794                 cacheResult(list);
795 
796                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_G_U,
797                     finderArgs, list);
798 
799                 closeSession(session);
800             }
801         }
802 
803         return list;
804     }
805 
806     public DLFileRank findByG_U_First(long groupId, long userId,
807         OrderByComparator orderByComparator)
808         throws NoSuchFileRankException, SystemException {
809         List<DLFileRank> list = findByG_U(groupId, userId, 0, 1,
810                 orderByComparator);
811 
812         if (list.isEmpty()) {
813             StringBundler msg = new StringBundler(6);
814 
815             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
816 
817             msg.append("groupId=");
818             msg.append(groupId);
819 
820             msg.append(", userId=");
821             msg.append(userId);
822 
823             msg.append(StringPool.CLOSE_CURLY_BRACE);
824 
825             throw new NoSuchFileRankException(msg.toString());
826         }
827         else {
828             return list.get(0);
829         }
830     }
831 
832     public DLFileRank findByG_U_Last(long groupId, long userId,
833         OrderByComparator orderByComparator)
834         throws NoSuchFileRankException, SystemException {
835         int count = countByG_U(groupId, userId);
836 
837         List<DLFileRank> list = findByG_U(groupId, userId, count - 1, count,
838                 orderByComparator);
839 
840         if (list.isEmpty()) {
841             StringBundler msg = new StringBundler(6);
842 
843             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
844 
845             msg.append("groupId=");
846             msg.append(groupId);
847 
848             msg.append(", userId=");
849             msg.append(userId);
850 
851             msg.append(StringPool.CLOSE_CURLY_BRACE);
852 
853             throw new NoSuchFileRankException(msg.toString());
854         }
855         else {
856             return list.get(0);
857         }
858     }
859 
860     public DLFileRank[] findByG_U_PrevAndNext(long fileRankId, long groupId,
861         long userId, OrderByComparator orderByComparator)
862         throws NoSuchFileRankException, SystemException {
863         DLFileRank dlFileRank = findByPrimaryKey(fileRankId);
864 
865         int count = countByG_U(groupId, userId);
866 
867         Session session = null;
868 
869         try {
870             session = openSession();
871 
872             StringBundler query = null;
873 
874             if (orderByComparator != null) {
875                 query = new StringBundler(4 +
876                         (orderByComparator.getOrderByFields().length * 3));
877             }
878             else {
879                 query = new StringBundler(4);
880             }
881 
882             query.append(_SQL_SELECT_DLFILERANK_WHERE);
883 
884             query.append(_FINDER_COLUMN_G_U_GROUPID_2);
885 
886             query.append(_FINDER_COLUMN_G_U_USERID_2);
887 
888             if (orderByComparator != null) {
889                 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
890                     orderByComparator);
891             }
892 
893             else {
894                 query.append(DLFileRankModelImpl.ORDER_BY_JPQL);
895             }
896 
897             String sql = query.toString();
898 
899             Query q = session.createQuery(sql);
900 
901             QueryPos qPos = QueryPos.getInstance(q);
902 
903             qPos.add(groupId);
904 
905             qPos.add(userId);
906 
907             Object[] objArray = QueryUtil.getPrevAndNext(q, count,
908                     orderByComparator, dlFileRank);
909 
910             DLFileRank[] array = new DLFileRankImpl[3];
911 
912             array[0] = (DLFileRank)objArray[0];
913             array[1] = (DLFileRank)objArray[1];
914             array[2] = (DLFileRank)objArray[2];
915 
916             return array;
917         }
918         catch (Exception e) {
919             throw processException(e);
920         }
921         finally {
922             closeSession(session);
923         }
924     }
925 
926     public List<DLFileRank> findByF_N(long folderId, String name)
927         throws SystemException {
928         Object[] finderArgs = new Object[] { new Long(folderId), name };
929 
930         List<DLFileRank> list = (List<DLFileRank>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_F_N,
931                 finderArgs, this);
932 
933         if (list == null) {
934             Session session = null;
935 
936             try {
937                 session = openSession();
938 
939                 StringBundler query = new StringBundler(4);
940 
941                 query.append(_SQL_SELECT_DLFILERANK_WHERE);
942 
943                 query.append(_FINDER_COLUMN_F_N_FOLDERID_2);
944 
945                 if (name == null) {
946                     query.append(_FINDER_COLUMN_F_N_NAME_1);
947                 }
948                 else {
949                     if (name.equals(StringPool.BLANK)) {
950                         query.append(_FINDER_COLUMN_F_N_NAME_3);
951                     }
952                     else {
953                         query.append(_FINDER_COLUMN_F_N_NAME_2);
954                     }
955                 }
956 
957                 query.append(DLFileRankModelImpl.ORDER_BY_JPQL);
958 
959                 String sql = query.toString();
960 
961                 Query q = session.createQuery(sql);
962 
963                 QueryPos qPos = QueryPos.getInstance(q);
964 
965                 qPos.add(folderId);
966 
967                 if (name != null) {
968                     qPos.add(name);
969                 }
970 
971                 list = q.list();
972             }
973             catch (Exception e) {
974                 throw processException(e);
975             }
976             finally {
977                 if (list == null) {
978                     list = new ArrayList<DLFileRank>();
979                 }
980 
981                 cacheResult(list);
982 
983                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_F_N, finderArgs,
984                     list);
985 
986                 closeSession(session);
987             }
988         }
989 
990         return list;
991     }
992 
993     public List<DLFileRank> findByF_N(long folderId, String name, int start,
994         int end) throws SystemException {
995         return findByF_N(folderId, name, start, end, null);
996     }
997 
998     public List<DLFileRank> findByF_N(long folderId, String name, int start,
999         int end, OrderByComparator orderByComparator) throws SystemException {
1000        Object[] finderArgs = new Object[] {
1001                new Long(folderId),
1002                
1003                name,
1004                
1005                String.valueOf(start), String.valueOf(end),
1006                String.valueOf(orderByComparator)
1007            };
1008
1009        List<DLFileRank> list = (List<DLFileRank>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_F_N,
1010                finderArgs, this);
1011
1012        if (list == null) {
1013            Session session = null;
1014
1015            try {
1016                session = openSession();
1017
1018                StringBundler query = null;
1019
1020                if (orderByComparator != null) {
1021                    query = new StringBundler(4 +
1022                            (orderByComparator.getOrderByFields().length * 3));
1023                }
1024                else {
1025                    query = new StringBundler(4);
1026                }
1027
1028                query.append(_SQL_SELECT_DLFILERANK_WHERE);
1029
1030                query.append(_FINDER_COLUMN_F_N_FOLDERID_2);
1031
1032                if (name == null) {
1033                    query.append(_FINDER_COLUMN_F_N_NAME_1);
1034                }
1035                else {
1036                    if (name.equals(StringPool.BLANK)) {
1037                        query.append(_FINDER_COLUMN_F_N_NAME_3);
1038                    }
1039                    else {
1040                        query.append(_FINDER_COLUMN_F_N_NAME_2);
1041                    }
1042                }
1043
1044                if (orderByComparator != null) {
1045                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1046                        orderByComparator);
1047                }
1048
1049                else {
1050                    query.append(DLFileRankModelImpl.ORDER_BY_JPQL);
1051                }
1052
1053                String sql = query.toString();
1054
1055                Query q = session.createQuery(sql);
1056
1057                QueryPos qPos = QueryPos.getInstance(q);
1058
1059                qPos.add(folderId);
1060
1061                if (name != null) {
1062                    qPos.add(name);
1063                }
1064
1065                list = (List<DLFileRank>)QueryUtil.list(q, getDialect(), start,
1066                        end);
1067            }
1068            catch (Exception e) {
1069                throw processException(e);
1070            }
1071            finally {
1072                if (list == null) {
1073                    list = new ArrayList<DLFileRank>();
1074                }
1075
1076                cacheResult(list);
1077
1078                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_F_N,
1079                    finderArgs, list);
1080
1081                closeSession(session);
1082            }
1083        }
1084
1085        return list;
1086    }
1087
1088    public DLFileRank findByF_N_First(long folderId, String name,
1089        OrderByComparator orderByComparator)
1090        throws NoSuchFileRankException, SystemException {
1091        List<DLFileRank> list = findByF_N(folderId, name, 0, 1,
1092                orderByComparator);
1093
1094        if (list.isEmpty()) {
1095            StringBundler msg = new StringBundler(6);
1096
1097            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1098
1099            msg.append("folderId=");
1100            msg.append(folderId);
1101
1102            msg.append(", name=");
1103            msg.append(name);
1104
1105            msg.append(StringPool.CLOSE_CURLY_BRACE);
1106
1107            throw new NoSuchFileRankException(msg.toString());
1108        }
1109        else {
1110            return list.get(0);
1111        }
1112    }
1113
1114    public DLFileRank findByF_N_Last(long folderId, String name,
1115        OrderByComparator orderByComparator)
1116        throws NoSuchFileRankException, SystemException {
1117        int count = countByF_N(folderId, name);
1118
1119        List<DLFileRank> list = findByF_N(folderId, name, count - 1, count,
1120                orderByComparator);
1121
1122        if (list.isEmpty()) {
1123            StringBundler msg = new StringBundler(6);
1124
1125            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1126
1127            msg.append("folderId=");
1128            msg.append(folderId);
1129
1130            msg.append(", name=");
1131            msg.append(name);
1132
1133            msg.append(StringPool.CLOSE_CURLY_BRACE);
1134
1135            throw new NoSuchFileRankException(msg.toString());
1136        }
1137        else {
1138            return list.get(0);
1139        }
1140    }
1141
1142    public DLFileRank[] findByF_N_PrevAndNext(long fileRankId, long folderId,
1143        String name, OrderByComparator orderByComparator)
1144        throws NoSuchFileRankException, SystemException {
1145        DLFileRank dlFileRank = findByPrimaryKey(fileRankId);
1146
1147        int count = countByF_N(folderId, name);
1148
1149        Session session = null;
1150
1151        try {
1152            session = openSession();
1153
1154            StringBundler query = null;
1155
1156            if (orderByComparator != null) {
1157                query = new StringBundler(4 +
1158                        (orderByComparator.getOrderByFields().length * 3));
1159            }
1160            else {
1161                query = new StringBundler(4);
1162            }
1163
1164            query.append(_SQL_SELECT_DLFILERANK_WHERE);
1165
1166            query.append(_FINDER_COLUMN_F_N_FOLDERID_2);
1167
1168            if (name == null) {
1169                query.append(_FINDER_COLUMN_F_N_NAME_1);
1170            }
1171            else {
1172                if (name.equals(StringPool.BLANK)) {
1173                    query.append(_FINDER_COLUMN_F_N_NAME_3);
1174                }
1175                else {
1176                    query.append(_FINDER_COLUMN_F_N_NAME_2);
1177                }
1178            }
1179
1180            if (orderByComparator != null) {
1181                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1182                    orderByComparator);
1183            }
1184
1185            else {
1186                query.append(DLFileRankModelImpl.ORDER_BY_JPQL);
1187            }
1188
1189            String sql = query.toString();
1190
1191            Query q = session.createQuery(sql);
1192
1193            QueryPos qPos = QueryPos.getInstance(q);
1194
1195            qPos.add(folderId);
1196
1197            if (name != null) {
1198                qPos.add(name);
1199            }
1200
1201            Object[] objArray = QueryUtil.getPrevAndNext(q, count,
1202                    orderByComparator, dlFileRank);
1203
1204            DLFileRank[] array = new DLFileRankImpl[3];
1205
1206            array[0] = (DLFileRank)objArray[0];
1207            array[1] = (DLFileRank)objArray[1];
1208            array[2] = (DLFileRank)objArray[2];
1209
1210            return array;
1211        }
1212        catch (Exception e) {
1213            throw processException(e);
1214        }
1215        finally {
1216            closeSession(session);
1217        }
1218    }
1219
1220    public DLFileRank findByC_U_F_N(long companyId, long userId, long folderId,
1221        String name) throws NoSuchFileRankException, SystemException {
1222        DLFileRank dlFileRank = fetchByC_U_F_N(companyId, userId, folderId, name);
1223
1224        if (dlFileRank == null) {
1225            StringBundler msg = new StringBundler(10);
1226
1227            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1228
1229            msg.append("companyId=");
1230            msg.append(companyId);
1231
1232            msg.append(", userId=");
1233            msg.append(userId);
1234
1235            msg.append(", folderId=");
1236            msg.append(folderId);
1237
1238            msg.append(", name=");
1239            msg.append(name);
1240
1241            msg.append(StringPool.CLOSE_CURLY_BRACE);
1242
1243            if (_log.isWarnEnabled()) {
1244                _log.warn(msg.toString());
1245            }
1246
1247            throw new NoSuchFileRankException(msg.toString());
1248        }
1249
1250        return dlFileRank;
1251    }
1252
1253    public DLFileRank fetchByC_U_F_N(long companyId, long userId,
1254        long folderId, String name) throws SystemException {
1255        return fetchByC_U_F_N(companyId, userId, folderId, name, true);
1256    }
1257
1258    public DLFileRank fetchByC_U_F_N(long companyId, long userId,
1259        long folderId, String name, boolean retrieveFromCache)
1260        throws SystemException {
1261        Object[] finderArgs = new Object[] {
1262                new Long(companyId), new Long(userId), new Long(folderId),
1263                
1264                name
1265            };
1266
1267        Object result = null;
1268
1269        if (retrieveFromCache) {
1270            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_C_U_F_N,
1271                    finderArgs, this);
1272        }
1273
1274        if (result == null) {
1275            Session session = null;
1276
1277            try {
1278                session = openSession();
1279
1280                StringBundler query = new StringBundler(6);
1281
1282                query.append(_SQL_SELECT_DLFILERANK_WHERE);
1283
1284                query.append(_FINDER_COLUMN_C_U_F_N_COMPANYID_2);
1285
1286                query.append(_FINDER_COLUMN_C_U_F_N_USERID_2);
1287
1288                query.append(_FINDER_COLUMN_C_U_F_N_FOLDERID_2);
1289
1290                if (name == null) {
1291                    query.append(_FINDER_COLUMN_C_U_F_N_NAME_1);
1292                }
1293                else {
1294                    if (name.equals(StringPool.BLANK)) {
1295                        query.append(_FINDER_COLUMN_C_U_F_N_NAME_3);
1296                    }
1297                    else {
1298                        query.append(_FINDER_COLUMN_C_U_F_N_NAME_2);
1299                    }
1300                }
1301
1302                query.append(DLFileRankModelImpl.ORDER_BY_JPQL);
1303
1304                String sql = query.toString();
1305
1306                Query q = session.createQuery(sql);
1307
1308                QueryPos qPos = QueryPos.getInstance(q);
1309
1310                qPos.add(companyId);
1311
1312                qPos.add(userId);
1313
1314                qPos.add(folderId);
1315
1316                if (name != null) {
1317                    qPos.add(name);
1318                }
1319
1320                List<DLFileRank> list = q.list();
1321
1322                result = list;
1323
1324                DLFileRank dlFileRank = null;
1325
1326                if (list.isEmpty()) {
1327                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_U_F_N,
1328                        finderArgs, list);
1329                }
1330                else {
1331                    dlFileRank = list.get(0);
1332
1333                    cacheResult(dlFileRank);
1334
1335                    if ((dlFileRank.getCompanyId() != companyId) ||
1336                            (dlFileRank.getUserId() != userId) ||
1337                            (dlFileRank.getFolderId() != folderId) ||
1338                            (dlFileRank.getName() == null) ||
1339                            !dlFileRank.getName().equals(name)) {
1340                        FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_U_F_N,
1341                            finderArgs, dlFileRank);
1342                    }
1343                }
1344
1345                return dlFileRank;
1346            }
1347            catch (Exception e) {
1348                throw processException(e);
1349            }
1350            finally {
1351                if (result == null) {
1352                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_U_F_N,
1353                        finderArgs, new ArrayList<DLFileRank>());
1354                }
1355
1356                closeSession(session);
1357            }
1358        }
1359        else {
1360            if (result instanceof List<?>) {
1361                return null;
1362            }
1363            else {
1364                return (DLFileRank)result;
1365            }
1366        }
1367    }
1368
1369    public List<DLFileRank> findAll() throws SystemException {
1370        return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1371    }
1372
1373    public List<DLFileRank> findAll(int start, int end)
1374        throws SystemException {
1375        return findAll(start, end, null);
1376    }
1377
1378    public List<DLFileRank> findAll(int start, int end,
1379        OrderByComparator orderByComparator) throws SystemException {
1380        Object[] finderArgs = new Object[] {
1381                String.valueOf(start), String.valueOf(end),
1382                String.valueOf(orderByComparator)
1383            };
1384
1385        List<DLFileRank> list = (List<DLFileRank>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
1386                finderArgs, this);
1387
1388        if (list == null) {
1389            Session session = null;
1390
1391            try {
1392                session = openSession();
1393
1394                StringBundler query = null;
1395                String sql = null;
1396
1397                if (orderByComparator != null) {
1398                    query = new StringBundler(2 +
1399                            (orderByComparator.getOrderByFields().length * 3));
1400
1401                    query.append(_SQL_SELECT_DLFILERANK);
1402
1403                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1404                        orderByComparator);
1405
1406                    sql = query.toString();
1407                }
1408
1409                else {
1410                    sql = _SQL_SELECT_DLFILERANK.concat(DLFileRankModelImpl.ORDER_BY_JPQL);
1411                }
1412
1413                Query q = session.createQuery(sql);
1414
1415                if (orderByComparator == null) {
1416                    list = (List<DLFileRank>)QueryUtil.list(q, getDialect(),
1417                            start, end, false);
1418
1419                    Collections.sort(list);
1420                }
1421                else {
1422                    list = (List<DLFileRank>)QueryUtil.list(q, getDialect(),
1423                            start, end);
1424                }
1425            }
1426            catch (Exception e) {
1427                throw processException(e);
1428            }
1429            finally {
1430                if (list == null) {
1431                    list = new ArrayList<DLFileRank>();
1432                }
1433
1434                cacheResult(list);
1435
1436                FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
1437
1438                closeSession(session);
1439            }
1440        }
1441
1442        return list;
1443    }
1444
1445    public void removeByUserId(long userId) throws SystemException {
1446        for (DLFileRank dlFileRank : findByUserId(userId)) {
1447            remove(dlFileRank);
1448        }
1449    }
1450
1451    public void removeByG_U(long groupId, long userId)
1452        throws SystemException {
1453        for (DLFileRank dlFileRank : findByG_U(groupId, userId)) {
1454            remove(dlFileRank);
1455        }
1456    }
1457
1458    public void removeByF_N(long folderId, String name)
1459        throws SystemException {
1460        for (DLFileRank dlFileRank : findByF_N(folderId, name)) {
1461            remove(dlFileRank);
1462        }
1463    }
1464
1465    public void removeByC_U_F_N(long companyId, long userId, long folderId,
1466        String name) throws NoSuchFileRankException, SystemException {
1467        DLFileRank dlFileRank = findByC_U_F_N(companyId, userId, folderId, name);
1468
1469        remove(dlFileRank);
1470    }
1471
1472    public void removeAll() throws SystemException {
1473        for (DLFileRank dlFileRank : findAll()) {
1474            remove(dlFileRank);
1475        }
1476    }
1477
1478    public int countByUserId(long userId) throws SystemException {
1479        Object[] finderArgs = new Object[] { new Long(userId) };
1480
1481        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_USERID,
1482                finderArgs, this);
1483
1484        if (count == null) {
1485            Session session = null;
1486
1487            try {
1488                session = openSession();
1489
1490                StringBundler query = new StringBundler(2);
1491
1492                query.append(_SQL_COUNT_DLFILERANK_WHERE);
1493
1494                query.append(_FINDER_COLUMN_USERID_USERID_2);
1495
1496                String sql = query.toString();
1497
1498                Query q = session.createQuery(sql);
1499
1500                QueryPos qPos = QueryPos.getInstance(q);
1501
1502                qPos.add(userId);
1503
1504                count = (Long)q.uniqueResult();
1505            }
1506            catch (Exception e) {
1507                throw processException(e);
1508            }
1509            finally {
1510                if (count == null) {
1511                    count = Long.valueOf(0);
1512                }
1513
1514                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_USERID,
1515                    finderArgs, count);
1516
1517                closeSession(session);
1518            }
1519        }
1520
1521        return count.intValue();
1522    }
1523
1524    public int countByG_U(long groupId, long userId) throws SystemException {
1525        Object[] finderArgs = new Object[] { new Long(groupId), new Long(userId) };
1526
1527        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_U,
1528                finderArgs, this);
1529
1530        if (count == null) {
1531            Session session = null;
1532
1533            try {
1534                session = openSession();
1535
1536                StringBundler query = new StringBundler(3);
1537
1538                query.append(_SQL_COUNT_DLFILERANK_WHERE);
1539
1540                query.append(_FINDER_COLUMN_G_U_GROUPID_2);
1541
1542                query.append(_FINDER_COLUMN_G_U_USERID_2);
1543
1544                String sql = query.toString();
1545
1546                Query q = session.createQuery(sql);
1547
1548                QueryPos qPos = QueryPos.getInstance(q);
1549
1550                qPos.add(groupId);
1551
1552                qPos.add(userId);
1553
1554                count = (Long)q.uniqueResult();
1555            }
1556            catch (Exception e) {
1557                throw processException(e);
1558            }
1559            finally {
1560                if (count == null) {
1561                    count = Long.valueOf(0);
1562                }
1563
1564                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_U, finderArgs,
1565                    count);
1566
1567                closeSession(session);
1568            }
1569        }
1570
1571        return count.intValue();
1572    }
1573
1574    public int countByF_N(long folderId, String name) throws SystemException {
1575        Object[] finderArgs = new Object[] { new Long(folderId), name };
1576
1577        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_F_N,
1578                finderArgs, this);
1579
1580        if (count == null) {
1581            Session session = null;
1582
1583            try {
1584                session = openSession();
1585
1586                StringBundler query = new StringBundler(3);
1587
1588                query.append(_SQL_COUNT_DLFILERANK_WHERE);
1589
1590                query.append(_FINDER_COLUMN_F_N_FOLDERID_2);
1591
1592                if (name == null) {
1593                    query.append(_FINDER_COLUMN_F_N_NAME_1);
1594                }
1595                else {
1596                    if (name.equals(StringPool.BLANK)) {
1597                        query.append(_FINDER_COLUMN_F_N_NAME_3);
1598                    }
1599                    else {
1600                        query.append(_FINDER_COLUMN_F_N_NAME_2);
1601                    }
1602                }
1603
1604                String sql = query.toString();
1605
1606                Query q = session.createQuery(sql);
1607
1608                QueryPos qPos = QueryPos.getInstance(q);
1609
1610                qPos.add(folderId);
1611
1612                if (name != null) {
1613                    qPos.add(name);
1614                }
1615
1616                count = (Long)q.uniqueResult();
1617            }
1618            catch (Exception e) {
1619                throw processException(e);
1620            }
1621            finally {
1622                if (count == null) {
1623                    count = Long.valueOf(0);
1624                }
1625
1626                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_F_N, finderArgs,
1627                    count);
1628
1629                closeSession(session);
1630            }
1631        }
1632
1633        return count.intValue();
1634    }
1635
1636    public int countByC_U_F_N(long companyId, long userId, long folderId,
1637        String name) throws SystemException {
1638        Object[] finderArgs = new Object[] {
1639                new Long(companyId), new Long(userId), new Long(folderId),
1640                
1641                name
1642            };
1643
1644        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_C_U_F_N,
1645                finderArgs, this);
1646
1647        if (count == null) {
1648            Session session = null;
1649
1650            try {
1651                session = openSession();
1652
1653                StringBundler query = new StringBundler(5);
1654
1655                query.append(_SQL_COUNT_DLFILERANK_WHERE);
1656
1657                query.append(_FINDER_COLUMN_C_U_F_N_COMPANYID_2);
1658
1659                query.append(_FINDER_COLUMN_C_U_F_N_USERID_2);
1660
1661                query.append(_FINDER_COLUMN_C_U_F_N_FOLDERID_2);
1662
1663                if (name == null) {
1664                    query.append(_FINDER_COLUMN_C_U_F_N_NAME_1);
1665                }
1666                else {
1667                    if (name.equals(StringPool.BLANK)) {
1668                        query.append(_FINDER_COLUMN_C_U_F_N_NAME_3);
1669                    }
1670                    else {
1671                        query.append(_FINDER_COLUMN_C_U_F_N_NAME_2);
1672                    }
1673                }
1674
1675                String sql = query.toString();
1676
1677                Query q = session.createQuery(sql);
1678
1679                QueryPos qPos = QueryPos.getInstance(q);
1680
1681                qPos.add(companyId);
1682
1683                qPos.add(userId);
1684
1685                qPos.add(folderId);
1686
1687                if (name != null) {
1688                    qPos.add(name);
1689                }
1690
1691                count = (Long)q.uniqueResult();
1692            }
1693            catch (Exception e) {
1694                throw processException(e);
1695            }
1696            finally {
1697                if (count == null) {
1698                    count = Long.valueOf(0);
1699                }
1700
1701                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_C_U_F_N,
1702                    finderArgs, count);
1703
1704                closeSession(session);
1705            }
1706        }
1707
1708        return count.intValue();
1709    }
1710
1711    public int countAll() throws SystemException {
1712        Object[] finderArgs = new Object[0];
1713
1714        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
1715                finderArgs, this);
1716
1717        if (count == null) {
1718            Session session = null;
1719
1720            try {
1721                session = openSession();
1722
1723                Query q = session.createQuery(_SQL_COUNT_DLFILERANK);
1724
1725                count = (Long)q.uniqueResult();
1726            }
1727            catch (Exception e) {
1728                throw processException(e);
1729            }
1730            finally {
1731                if (count == null) {
1732                    count = Long.valueOf(0);
1733                }
1734
1735                FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
1736                    count);
1737
1738                closeSession(session);
1739            }
1740        }
1741
1742        return count.intValue();
1743    }
1744
1745    public void afterPropertiesSet() {
1746        String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
1747                    com.liferay.portal.util.PropsUtil.get(
1748                        "value.object.listener.com.liferay.portlet.documentlibrary.model.DLFileRank")));
1749
1750        if (listenerClassNames.length > 0) {
1751            try {
1752                List<ModelListener<DLFileRank>> listenersList = new ArrayList<ModelListener<DLFileRank>>();
1753
1754                for (String listenerClassName : listenerClassNames) {
1755                    listenersList.add((ModelListener<DLFileRank>)Class.forName(
1756                            listenerClassName).newInstance());
1757                }
1758
1759                listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
1760            }
1761            catch (Exception e) {
1762                _log.error(e);
1763            }
1764        }
1765    }
1766
1767    @BeanReference(type = DLFileEntryPersistence.class)
1768    protected DLFileEntryPersistence dlFileEntryPersistence;
1769    @BeanReference(type = DLFileRankPersistence.class)
1770    protected DLFileRankPersistence dlFileRankPersistence;
1771    @BeanReference(type = DLFileShortcutPersistence.class)
1772    protected DLFileShortcutPersistence dlFileShortcutPersistence;
1773    @BeanReference(type = DLFileVersionPersistence.class)
1774    protected DLFileVersionPersistence dlFileVersionPersistence;
1775    @BeanReference(type = DLFolderPersistence.class)
1776    protected DLFolderPersistence dlFolderPersistence;
1777    @BeanReference(type = LayoutPersistence.class)
1778    protected LayoutPersistence layoutPersistence;
1779    @BeanReference(type = ResourcePersistence.class)
1780    protected ResourcePersistence resourcePersistence;
1781    @BeanReference(type = UserPersistence.class)
1782    protected UserPersistence userPersistence;
1783    private static final String _SQL_SELECT_DLFILERANK = "SELECT dlFileRank FROM DLFileRank dlFileRank";
1784    private static final String _SQL_SELECT_DLFILERANK_WHERE = "SELECT dlFileRank FROM DLFileRank dlFileRank WHERE ";
1785    private static final String _SQL_COUNT_DLFILERANK = "SELECT COUNT(dlFileRank) FROM DLFileRank dlFileRank";
1786    private static final String _SQL_COUNT_DLFILERANK_WHERE = "SELECT COUNT(dlFileRank) FROM DLFileRank dlFileRank WHERE ";
1787    private static final String _FINDER_COLUMN_USERID_USERID_2 = "dlFileRank.userId = ?";
1788    private static final String _FINDER_COLUMN_G_U_GROUPID_2 = "dlFileRank.groupId = ? AND ";
1789    private static final String _FINDER_COLUMN_G_U_USERID_2 = "dlFileRank.userId = ?";
1790    private static final String _FINDER_COLUMN_F_N_FOLDERID_2 = "dlFileRank.folderId = ? AND ";
1791    private static final String _FINDER_COLUMN_F_N_NAME_1 = "dlFileRank.name IS NULL";
1792    private static final String _FINDER_COLUMN_F_N_NAME_2 = "dlFileRank.name = ?";
1793    private static final String _FINDER_COLUMN_F_N_NAME_3 = "(dlFileRank.name IS NULL OR dlFileRank.name = ?)";
1794    private static final String _FINDER_COLUMN_C_U_F_N_COMPANYID_2 = "dlFileRank.companyId = ? AND ";
1795    private static final String _FINDER_COLUMN_C_U_F_N_USERID_2 = "dlFileRank.userId = ? AND ";
1796    private static final String _FINDER_COLUMN_C_U_F_N_FOLDERID_2 = "dlFileRank.folderId = ? AND ";
1797    private static final String _FINDER_COLUMN_C_U_F_N_NAME_1 = "dlFileRank.name IS NULL";
1798    private static final String _FINDER_COLUMN_C_U_F_N_NAME_2 = "dlFileRank.name = ?";
1799    private static final String _FINDER_COLUMN_C_U_F_N_NAME_3 = "(dlFileRank.name IS NULL OR dlFileRank.name = ?)";
1800    private static final String _ORDER_BY_ENTITY_ALIAS = "dlFileRank.";
1801    private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No DLFileRank exists with the primary key ";
1802    private static final String _NO_SUCH_ENTITY_WITH_KEY = "No DLFileRank exists with the key {";
1803    private static Log _log = LogFactoryUtil.getLog(DLFileRankPersistenceImpl.class);
1804}