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