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