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