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.SQLQuery;
027    import com.liferay.portal.kernel.dao.orm.Session;
028    import com.liferay.portal.kernel.exception.SystemException;
029    import com.liferay.portal.kernel.log.Log;
030    import com.liferay.portal.kernel.log.LogFactoryUtil;
031    import com.liferay.portal.kernel.util.GetterUtil;
032    import com.liferay.portal.kernel.util.InstanceFactory;
033    import com.liferay.portal.kernel.util.OrderByComparator;
034    import com.liferay.portal.kernel.util.StringBundler;
035    import com.liferay.portal.kernel.util.StringPool;
036    import com.liferay.portal.kernel.util.StringUtil;
037    import com.liferay.portal.kernel.util.Validator;
038    import com.liferay.portal.kernel.uuid.PortalUUIDUtil;
039    import com.liferay.portal.model.ModelListener;
040    import com.liferay.portal.security.permission.InlineSQLHelperUtil;
041    import com.liferay.portal.service.persistence.BatchSessionUtil;
042    import com.liferay.portal.service.persistence.LockPersistence;
043    import com.liferay.portal.service.persistence.ResourcePersistence;
044    import com.liferay.portal.service.persistence.UserPersistence;
045    import com.liferay.portal.service.persistence.WebDAVPropsPersistence;
046    import com.liferay.portal.service.persistence.WorkflowInstanceLinkPersistence;
047    import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
048    
049    import com.liferay.portlet.asset.service.persistence.AssetCategoryPersistence;
050    import com.liferay.portlet.asset.service.persistence.AssetEntryPersistence;
051    import com.liferay.portlet.asset.service.persistence.AssetTagPersistence;
052    import com.liferay.portlet.documentlibrary.NoSuchFileEntryException;
053    import com.liferay.portlet.documentlibrary.model.DLFileEntry;
054    import com.liferay.portlet.documentlibrary.model.impl.DLFileEntryImpl;
055    import com.liferay.portlet.documentlibrary.model.impl.DLFileEntryModelImpl;
056    import com.liferay.portlet.expando.service.persistence.ExpandoValuePersistence;
057    import com.liferay.portlet.messageboards.service.persistence.MBDiscussionPersistence;
058    import com.liferay.portlet.messageboards.service.persistence.MBMessagePersistence;
059    import com.liferay.portlet.ratings.service.persistence.RatingsEntryPersistence;
060    import com.liferay.portlet.ratings.service.persistence.RatingsStatsPersistence;
061    import com.liferay.portlet.social.service.persistence.SocialActivityPersistence;
062    
063    import java.io.Serializable;
064    
065    import java.util.ArrayList;
066    import java.util.Collections;
067    import java.util.List;
068    
069    /**
070     * @author    Brian Wing Shun Chan
071     * @see       DLFileEntryPersistence
072     * @see       DLFileEntryUtil
073     * @generated
074     */
075    public class DLFileEntryPersistenceImpl extends BasePersistenceImpl<DLFileEntry>
076            implements DLFileEntryPersistence {
077            public static final String FINDER_CLASS_NAME_ENTITY = DLFileEntryImpl.class.getName();
078            public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
079                    ".List";
080            public static final FinderPath FINDER_PATH_FIND_BY_UUID = new FinderPath(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
081                            DLFileEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
082                            "findByUuid",
083                            new String[] {
084                                    String.class.getName(),
085                                    
086                            "java.lang.Integer", "java.lang.Integer",
087                                    "com.liferay.portal.kernel.util.OrderByComparator"
088                            });
089            public static final FinderPath FINDER_PATH_COUNT_BY_UUID = new FinderPath(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
090                            DLFileEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
091                            "countByUuid", new String[] { String.class.getName() });
092            public static final FinderPath FINDER_PATH_FETCH_BY_UUID_G = new FinderPath(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
093                            DLFileEntryModelImpl.FINDER_CACHE_ENABLED,
094                            FINDER_CLASS_NAME_ENTITY, "fetchByUUID_G",
095                            new String[] { String.class.getName(), Long.class.getName() });
096            public static final FinderPath FINDER_PATH_COUNT_BY_UUID_G = new FinderPath(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
097                            DLFileEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
098                            "countByUUID_G",
099                            new String[] { String.class.getName(), Long.class.getName() });
100            public static final FinderPath FINDER_PATH_FIND_BY_GROUPID = new FinderPath(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
101                            DLFileEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
102                            "findByGroupId",
103                            new String[] {
104                                    Long.class.getName(),
105                                    
106                            "java.lang.Integer", "java.lang.Integer",
107                                    "com.liferay.portal.kernel.util.OrderByComparator"
108                            });
109            public static final FinderPath FINDER_PATH_COUNT_BY_GROUPID = new FinderPath(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
110                            DLFileEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
111                            "countByGroupId", new String[] { Long.class.getName() });
112            public static final FinderPath FINDER_PATH_FIND_BY_COMPANYID = new FinderPath(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
113                            DLFileEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
114                            "findByCompanyId",
115                            new String[] {
116                                    Long.class.getName(),
117                                    
118                            "java.lang.Integer", "java.lang.Integer",
119                                    "com.liferay.portal.kernel.util.OrderByComparator"
120                            });
121            public static final FinderPath FINDER_PATH_COUNT_BY_COMPANYID = new FinderPath(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
122                            DLFileEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
123                            "countByCompanyId", new String[] { Long.class.getName() });
124            public static final FinderPath FINDER_PATH_FIND_BY_G_U = new FinderPath(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
125                            DLFileEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
126                            "findByG_U",
127                            new String[] {
128                                    Long.class.getName(), Long.class.getName(),
129                                    
130                            "java.lang.Integer", "java.lang.Integer",
131                                    "com.liferay.portal.kernel.util.OrderByComparator"
132                            });
133            public static final FinderPath FINDER_PATH_COUNT_BY_G_U = new FinderPath(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
134                            DLFileEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
135                            "countByG_U",
136                            new String[] { Long.class.getName(), Long.class.getName() });
137            public static final FinderPath FINDER_PATH_FIND_BY_G_F = new FinderPath(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
138                            DLFileEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
139                            "findByG_F",
140                            new String[] {
141                                    Long.class.getName(), Long.class.getName(),
142                                    
143                            "java.lang.Integer", "java.lang.Integer",
144                                    "com.liferay.portal.kernel.util.OrderByComparator"
145                            });
146            public static final FinderPath FINDER_PATH_COUNT_BY_G_F = new FinderPath(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
147                            DLFileEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
148                            "countByG_F",
149                            new String[] { Long.class.getName(), Long.class.getName() });
150            public static final FinderPath FINDER_PATH_FIND_BY_G_U_F = new FinderPath(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
151                            DLFileEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
152                            "findByG_U_F",
153                            new String[] {
154                                    Long.class.getName(), Long.class.getName(), Long.class.getName(),
155                                    
156                            "java.lang.Integer", "java.lang.Integer",
157                                    "com.liferay.portal.kernel.util.OrderByComparator"
158                            });
159            public static final FinderPath FINDER_PATH_COUNT_BY_G_U_F = new FinderPath(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
160                            DLFileEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
161                            "countByG_U_F",
162                            new String[] {
163                                    Long.class.getName(), Long.class.getName(), Long.class.getName()
164                            });
165            public static final FinderPath FINDER_PATH_FETCH_BY_G_F_N = new FinderPath(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
166                            DLFileEntryModelImpl.FINDER_CACHE_ENABLED,
167                            FINDER_CLASS_NAME_ENTITY, "fetchByG_F_N",
168                            new String[] {
169                                    Long.class.getName(), Long.class.getName(),
170                                    String.class.getName()
171                            });
172            public static final FinderPath FINDER_PATH_COUNT_BY_G_F_N = new FinderPath(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
173                            DLFileEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
174                            "countByG_F_N",
175                            new String[] {
176                                    Long.class.getName(), Long.class.getName(),
177                                    String.class.getName()
178                            });
179            public static final FinderPath FINDER_PATH_FETCH_BY_G_F_T = new FinderPath(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
180                            DLFileEntryModelImpl.FINDER_CACHE_ENABLED,
181                            FINDER_CLASS_NAME_ENTITY, "fetchByG_F_T",
182                            new String[] {
183                                    Long.class.getName(), Long.class.getName(),
184                                    String.class.getName()
185                            });
186            public static final FinderPath FINDER_PATH_COUNT_BY_G_F_T = new FinderPath(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
187                            DLFileEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
188                            "countByG_F_T",
189                            new String[] {
190                                    Long.class.getName(), Long.class.getName(),
191                                    String.class.getName()
192                            });
193            public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
194                            DLFileEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
195                            "findAll", new String[0]);
196            public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
197                            DLFileEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
198                            "countAll", new String[0]);
199    
200            public void cacheResult(DLFileEntry dlFileEntry) {
201                    EntityCacheUtil.putResult(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
202                            DLFileEntryImpl.class, dlFileEntry.getPrimaryKey(), dlFileEntry);
203    
204                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
205                            new Object[] {
206                                    dlFileEntry.getUuid(), new Long(dlFileEntry.getGroupId())
207                            }, dlFileEntry);
208    
209                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_F_N,
210                            new Object[] {
211                                    new Long(dlFileEntry.getGroupId()),
212                                    new Long(dlFileEntry.getFolderId()),
213                                    
214                            dlFileEntry.getName()
215                            }, dlFileEntry);
216    
217                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_F_T,
218                            new Object[] {
219                                    new Long(dlFileEntry.getGroupId()),
220                                    new Long(dlFileEntry.getFolderId()),
221                                    
222                            dlFileEntry.getTitle()
223                            }, dlFileEntry);
224            }
225    
226            public void cacheResult(List<DLFileEntry> dlFileEntries) {
227                    for (DLFileEntry dlFileEntry : dlFileEntries) {
228                            if (EntityCacheUtil.getResult(
229                                                    DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
230                                                    DLFileEntryImpl.class, dlFileEntry.getPrimaryKey(), this) == null) {
231                                    cacheResult(dlFileEntry);
232                            }
233                    }
234            }
235    
236            public void clearCache() {
237                    CacheRegistryUtil.clear(DLFileEntryImpl.class.getName());
238                    EntityCacheUtil.clearCache(DLFileEntryImpl.class.getName());
239                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
240                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
241            }
242    
243            public void clearCache(DLFileEntry dlFileEntry) {
244                    EntityCacheUtil.removeResult(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
245                            DLFileEntryImpl.class, dlFileEntry.getPrimaryKey());
246    
247                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
248                            new Object[] {
249                                    dlFileEntry.getUuid(), new Long(dlFileEntry.getGroupId())
250                            });
251    
252                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_F_N,
253                            new Object[] {
254                                    new Long(dlFileEntry.getGroupId()),
255                                    new Long(dlFileEntry.getFolderId()),
256                                    
257                            dlFileEntry.getName()
258                            });
259    
260                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_F_T,
261                            new Object[] {
262                                    new Long(dlFileEntry.getGroupId()),
263                                    new Long(dlFileEntry.getFolderId()),
264                                    
265                            dlFileEntry.getTitle()
266                            });
267            }
268    
269            public DLFileEntry create(long fileEntryId) {
270                    DLFileEntry dlFileEntry = new DLFileEntryImpl();
271    
272                    dlFileEntry.setNew(true);
273                    dlFileEntry.setPrimaryKey(fileEntryId);
274    
275                    String uuid = PortalUUIDUtil.generate();
276    
277                    dlFileEntry.setUuid(uuid);
278    
279                    return dlFileEntry;
280            }
281    
282            public DLFileEntry remove(Serializable primaryKey)
283                    throws NoSuchModelException, SystemException {
284                    return remove(((Long)primaryKey).longValue());
285            }
286    
287            public DLFileEntry remove(long fileEntryId)
288                    throws NoSuchFileEntryException, SystemException {
289                    Session session = null;
290    
291                    try {
292                            session = openSession();
293    
294                            DLFileEntry dlFileEntry = (DLFileEntry)session.get(DLFileEntryImpl.class,
295                                            new Long(fileEntryId));
296    
297                            if (dlFileEntry == null) {
298                                    if (_log.isWarnEnabled()) {
299                                            _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + fileEntryId);
300                                    }
301    
302                                    throw new NoSuchFileEntryException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
303                                            fileEntryId);
304                            }
305    
306                            return remove(dlFileEntry);
307                    }
308                    catch (NoSuchFileEntryException nsee) {
309                            throw nsee;
310                    }
311                    catch (Exception e) {
312                            throw processException(e);
313                    }
314                    finally {
315                            closeSession(session);
316                    }
317            }
318    
319            protected DLFileEntry removeImpl(DLFileEntry dlFileEntry)
320                    throws SystemException {
321                    dlFileEntry = toUnwrappedModel(dlFileEntry);
322    
323                    Session session = null;
324    
325                    try {
326                            session = openSession();
327    
328                            if (dlFileEntry.isCachedModel() || BatchSessionUtil.isEnabled()) {
329                                    Object staleObject = session.get(DLFileEntryImpl.class,
330                                                    dlFileEntry.getPrimaryKeyObj());
331    
332                                    if (staleObject != null) {
333                                            session.evict(staleObject);
334                                    }
335                            }
336    
337                            session.delete(dlFileEntry);
338    
339                            session.flush();
340                    }
341                    catch (Exception e) {
342                            throw processException(e);
343                    }
344                    finally {
345                            closeSession(session);
346                    }
347    
348                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
349    
350                    DLFileEntryModelImpl dlFileEntryModelImpl = (DLFileEntryModelImpl)dlFileEntry;
351    
352                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
353                            new Object[] {
354                                    dlFileEntryModelImpl.getOriginalUuid(),
355                                    new Long(dlFileEntryModelImpl.getOriginalGroupId())
356                            });
357    
358                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_F_N,
359                            new Object[] {
360                                    new Long(dlFileEntryModelImpl.getOriginalGroupId()),
361                                    new Long(dlFileEntryModelImpl.getOriginalFolderId()),
362                                    
363                            dlFileEntryModelImpl.getOriginalName()
364                            });
365    
366                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_F_T,
367                            new Object[] {
368                                    new Long(dlFileEntryModelImpl.getOriginalGroupId()),
369                                    new Long(dlFileEntryModelImpl.getOriginalFolderId()),
370                                    
371                            dlFileEntryModelImpl.getOriginalTitle()
372                            });
373    
374                    EntityCacheUtil.removeResult(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
375                            DLFileEntryImpl.class, dlFileEntry.getPrimaryKey());
376    
377                    return dlFileEntry;
378            }
379    
380            public DLFileEntry updateImpl(
381                    com.liferay.portlet.documentlibrary.model.DLFileEntry dlFileEntry,
382                    boolean merge) throws SystemException {
383                    dlFileEntry = toUnwrappedModel(dlFileEntry);
384    
385                    boolean isNew = dlFileEntry.isNew();
386    
387                    DLFileEntryModelImpl dlFileEntryModelImpl = (DLFileEntryModelImpl)dlFileEntry;
388    
389                    if (Validator.isNull(dlFileEntry.getUuid())) {
390                            String uuid = PortalUUIDUtil.generate();
391    
392                            dlFileEntry.setUuid(uuid);
393                    }
394    
395                    Session session = null;
396    
397                    try {
398                            session = openSession();
399    
400                            BatchSessionUtil.update(session, dlFileEntry, merge);
401    
402                            dlFileEntry.setNew(false);
403                    }
404                    catch (Exception e) {
405                            throw processException(e);
406                    }
407                    finally {
408                            closeSession(session);
409                    }
410    
411                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
412    
413                    EntityCacheUtil.putResult(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
414                            DLFileEntryImpl.class, dlFileEntry.getPrimaryKey(), dlFileEntry);
415    
416                    if (!isNew &&
417                                    (!Validator.equals(dlFileEntry.getUuid(),
418                                            dlFileEntryModelImpl.getOriginalUuid()) ||
419                                    (dlFileEntry.getGroupId() != dlFileEntryModelImpl.getOriginalGroupId()))) {
420                            FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
421                                    new Object[] {
422                                            dlFileEntryModelImpl.getOriginalUuid(),
423                                            new Long(dlFileEntryModelImpl.getOriginalGroupId())
424                                    });
425                    }
426    
427                    if (isNew ||
428                                    (!Validator.equals(dlFileEntry.getUuid(),
429                                            dlFileEntryModelImpl.getOriginalUuid()) ||
430                                    (dlFileEntry.getGroupId() != dlFileEntryModelImpl.getOriginalGroupId()))) {
431                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
432                                    new Object[] {
433                                            dlFileEntry.getUuid(), new Long(dlFileEntry.getGroupId())
434                                    }, dlFileEntry);
435                    }
436    
437                    if (!isNew &&
438                                    ((dlFileEntry.getGroupId() != dlFileEntryModelImpl.getOriginalGroupId()) ||
439                                    (dlFileEntry.getFolderId() != dlFileEntryModelImpl.getOriginalFolderId()) ||
440                                    !Validator.equals(dlFileEntry.getName(),
441                                            dlFileEntryModelImpl.getOriginalName()))) {
442                            FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_F_N,
443                                    new Object[] {
444                                            new Long(dlFileEntryModelImpl.getOriginalGroupId()),
445                                            new Long(dlFileEntryModelImpl.getOriginalFolderId()),
446                                            
447                                    dlFileEntryModelImpl.getOriginalName()
448                                    });
449                    }
450    
451                    if (isNew ||
452                                    ((dlFileEntry.getGroupId() != dlFileEntryModelImpl.getOriginalGroupId()) ||
453                                    (dlFileEntry.getFolderId() != dlFileEntryModelImpl.getOriginalFolderId()) ||
454                                    !Validator.equals(dlFileEntry.getName(),
455                                            dlFileEntryModelImpl.getOriginalName()))) {
456                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_F_N,
457                                    new Object[] {
458                                            new Long(dlFileEntry.getGroupId()),
459                                            new Long(dlFileEntry.getFolderId()),
460                                            
461                                    dlFileEntry.getName()
462                                    }, dlFileEntry);
463                    }
464    
465                    if (!isNew &&
466                                    ((dlFileEntry.getGroupId() != dlFileEntryModelImpl.getOriginalGroupId()) ||
467                                    (dlFileEntry.getFolderId() != dlFileEntryModelImpl.getOriginalFolderId()) ||
468                                    !Validator.equals(dlFileEntry.getTitle(),
469                                            dlFileEntryModelImpl.getOriginalTitle()))) {
470                            FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_F_T,
471                                    new Object[] {
472                                            new Long(dlFileEntryModelImpl.getOriginalGroupId()),
473                                            new Long(dlFileEntryModelImpl.getOriginalFolderId()),
474                                            
475                                    dlFileEntryModelImpl.getOriginalTitle()
476                                    });
477                    }
478    
479                    if (isNew ||
480                                    ((dlFileEntry.getGroupId() != dlFileEntryModelImpl.getOriginalGroupId()) ||
481                                    (dlFileEntry.getFolderId() != dlFileEntryModelImpl.getOriginalFolderId()) ||
482                                    !Validator.equals(dlFileEntry.getTitle(),
483                                            dlFileEntryModelImpl.getOriginalTitle()))) {
484                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_F_T,
485                                    new Object[] {
486                                            new Long(dlFileEntry.getGroupId()),
487                                            new Long(dlFileEntry.getFolderId()),
488                                            
489                                    dlFileEntry.getTitle()
490                                    }, dlFileEntry);
491                    }
492    
493                    return dlFileEntry;
494            }
495    
496            protected DLFileEntry toUnwrappedModel(DLFileEntry dlFileEntry) {
497                    if (dlFileEntry instanceof DLFileEntryImpl) {
498                            return dlFileEntry;
499                    }
500    
501                    DLFileEntryImpl dlFileEntryImpl = new DLFileEntryImpl();
502    
503                    dlFileEntryImpl.setNew(dlFileEntry.isNew());
504                    dlFileEntryImpl.setPrimaryKey(dlFileEntry.getPrimaryKey());
505    
506                    dlFileEntryImpl.setUuid(dlFileEntry.getUuid());
507                    dlFileEntryImpl.setFileEntryId(dlFileEntry.getFileEntryId());
508                    dlFileEntryImpl.setGroupId(dlFileEntry.getGroupId());
509                    dlFileEntryImpl.setCompanyId(dlFileEntry.getCompanyId());
510                    dlFileEntryImpl.setUserId(dlFileEntry.getUserId());
511                    dlFileEntryImpl.setUserName(dlFileEntry.getUserName());
512                    dlFileEntryImpl.setVersionUserId(dlFileEntry.getVersionUserId());
513                    dlFileEntryImpl.setVersionUserName(dlFileEntry.getVersionUserName());
514                    dlFileEntryImpl.setCreateDate(dlFileEntry.getCreateDate());
515                    dlFileEntryImpl.setModifiedDate(dlFileEntry.getModifiedDate());
516                    dlFileEntryImpl.setFolderId(dlFileEntry.getFolderId());
517                    dlFileEntryImpl.setName(dlFileEntry.getName());
518                    dlFileEntryImpl.setExtension(dlFileEntry.getExtension());
519                    dlFileEntryImpl.setTitle(dlFileEntry.getTitle());
520                    dlFileEntryImpl.setDescription(dlFileEntry.getDescription());
521                    dlFileEntryImpl.setExtraSettings(dlFileEntry.getExtraSettings());
522                    dlFileEntryImpl.setVersion(dlFileEntry.getVersion());
523                    dlFileEntryImpl.setSize(dlFileEntry.getSize());
524                    dlFileEntryImpl.setReadCount(dlFileEntry.getReadCount());
525    
526                    return dlFileEntryImpl;
527            }
528    
529            public DLFileEntry findByPrimaryKey(Serializable primaryKey)
530                    throws NoSuchModelException, SystemException {
531                    return findByPrimaryKey(((Long)primaryKey).longValue());
532            }
533    
534            public DLFileEntry findByPrimaryKey(long fileEntryId)
535                    throws NoSuchFileEntryException, SystemException {
536                    DLFileEntry dlFileEntry = fetchByPrimaryKey(fileEntryId);
537    
538                    if (dlFileEntry == null) {
539                            if (_log.isWarnEnabled()) {
540                                    _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + fileEntryId);
541                            }
542    
543                            throw new NoSuchFileEntryException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
544                                    fileEntryId);
545                    }
546    
547                    return dlFileEntry;
548            }
549    
550            public DLFileEntry fetchByPrimaryKey(Serializable primaryKey)
551                    throws SystemException {
552                    return fetchByPrimaryKey(((Long)primaryKey).longValue());
553            }
554    
555            public DLFileEntry fetchByPrimaryKey(long fileEntryId)
556                    throws SystemException {
557                    DLFileEntry dlFileEntry = (DLFileEntry)EntityCacheUtil.getResult(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
558                                    DLFileEntryImpl.class, fileEntryId, this);
559    
560                    if (dlFileEntry == null) {
561                            Session session = null;
562    
563                            try {
564                                    session = openSession();
565    
566                                    dlFileEntry = (DLFileEntry)session.get(DLFileEntryImpl.class,
567                                                    new Long(fileEntryId));
568                            }
569                            catch (Exception e) {
570                                    throw processException(e);
571                            }
572                            finally {
573                                    if (dlFileEntry != null) {
574                                            cacheResult(dlFileEntry);
575                                    }
576    
577                                    closeSession(session);
578                            }
579                    }
580    
581                    return dlFileEntry;
582            }
583    
584            public List<DLFileEntry> findByUuid(String uuid) throws SystemException {
585                    return findByUuid(uuid, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
586            }
587    
588            public List<DLFileEntry> findByUuid(String uuid, int start, int end)
589                    throws SystemException {
590                    return findByUuid(uuid, start, end, null);
591            }
592    
593            public List<DLFileEntry> findByUuid(String uuid, int start, int end,
594                    OrderByComparator orderByComparator) throws SystemException {
595                    Object[] finderArgs = new Object[] {
596                                    uuid,
597                                    
598                                    String.valueOf(start), String.valueOf(end),
599                                    String.valueOf(orderByComparator)
600                            };
601    
602                    List<DLFileEntry> list = (List<DLFileEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_UUID,
603                                    finderArgs, this);
604    
605                    if (list == null) {
606                            Session session = null;
607    
608                            try {
609                                    session = openSession();
610    
611                                    StringBundler query = null;
612    
613                                    if (orderByComparator != null) {
614                                            query = new StringBundler(3 +
615                                                            (orderByComparator.getOrderByFields().length * 3));
616                                    }
617                                    else {
618                                            query = new StringBundler(3);
619                                    }
620    
621                                    query.append(_SQL_SELECT_DLFILEENTRY_WHERE);
622    
623                                    if (uuid == null) {
624                                            query.append(_FINDER_COLUMN_UUID_UUID_1);
625                                    }
626                                    else {
627                                            if (uuid.equals(StringPool.BLANK)) {
628                                                    query.append(_FINDER_COLUMN_UUID_UUID_3);
629                                            }
630                                            else {
631                                                    query.append(_FINDER_COLUMN_UUID_UUID_2);
632                                            }
633                                    }
634    
635                                    if (orderByComparator != null) {
636                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
637                                                    orderByComparator);
638                                    }
639    
640                                    else {
641                                            query.append(DLFileEntryModelImpl.ORDER_BY_JPQL);
642                                    }
643    
644                                    String sql = query.toString();
645    
646                                    Query q = session.createQuery(sql);
647    
648                                    QueryPos qPos = QueryPos.getInstance(q);
649    
650                                    if (uuid != null) {
651                                            qPos.add(uuid);
652                                    }
653    
654                                    list = (List<DLFileEntry>)QueryUtil.list(q, getDialect(),
655                                                    start, end);
656                            }
657                            catch (Exception e) {
658                                    throw processException(e);
659                            }
660                            finally {
661                                    if (list == null) {
662                                            list = new ArrayList<DLFileEntry>();
663                                    }
664    
665                                    cacheResult(list);
666    
667                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_UUID, finderArgs,
668                                            list);
669    
670                                    closeSession(session);
671                            }
672                    }
673    
674                    return list;
675            }
676    
677            public DLFileEntry findByUuid_First(String uuid,
678                    OrderByComparator orderByComparator)
679                    throws NoSuchFileEntryException, SystemException {
680                    List<DLFileEntry> list = findByUuid(uuid, 0, 1, orderByComparator);
681    
682                    if (list.isEmpty()) {
683                            StringBundler msg = new StringBundler(4);
684    
685                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
686    
687                            msg.append("uuid=");
688                            msg.append(uuid);
689    
690                            msg.append(StringPool.CLOSE_CURLY_BRACE);
691    
692                            throw new NoSuchFileEntryException(msg.toString());
693                    }
694                    else {
695                            return list.get(0);
696                    }
697            }
698    
699            public DLFileEntry findByUuid_Last(String uuid,
700                    OrderByComparator orderByComparator)
701                    throws NoSuchFileEntryException, SystemException {
702                    int count = countByUuid(uuid);
703    
704                    List<DLFileEntry> list = findByUuid(uuid, count - 1, count,
705                                    orderByComparator);
706    
707                    if (list.isEmpty()) {
708                            StringBundler msg = new StringBundler(4);
709    
710                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
711    
712                            msg.append("uuid=");
713                            msg.append(uuid);
714    
715                            msg.append(StringPool.CLOSE_CURLY_BRACE);
716    
717                            throw new NoSuchFileEntryException(msg.toString());
718                    }
719                    else {
720                            return list.get(0);
721                    }
722            }
723    
724            public DLFileEntry[] findByUuid_PrevAndNext(long fileEntryId, String uuid,
725                    OrderByComparator orderByComparator)
726                    throws NoSuchFileEntryException, SystemException {
727                    DLFileEntry dlFileEntry = findByPrimaryKey(fileEntryId);
728    
729                    Session session = null;
730    
731                    try {
732                            session = openSession();
733    
734                            DLFileEntry[] array = new DLFileEntryImpl[3];
735    
736                            array[0] = getByUuid_PrevAndNext(session, dlFileEntry, uuid,
737                                            orderByComparator, true);
738    
739                            array[1] = dlFileEntry;
740    
741                            array[2] = getByUuid_PrevAndNext(session, dlFileEntry, uuid,
742                                            orderByComparator, false);
743    
744                            return array;
745                    }
746                    catch (Exception e) {
747                            throw processException(e);
748                    }
749                    finally {
750                            closeSession(session);
751                    }
752            }
753    
754            protected DLFileEntry getByUuid_PrevAndNext(Session session,
755                    DLFileEntry dlFileEntry, String uuid,
756                    OrderByComparator orderByComparator, boolean previous) {
757                    StringBundler query = null;
758    
759                    if (orderByComparator != null) {
760                            query = new StringBundler(6 +
761                                            (orderByComparator.getOrderByFields().length * 6));
762                    }
763                    else {
764                            query = new StringBundler(3);
765                    }
766    
767                    query.append(_SQL_SELECT_DLFILEENTRY_WHERE);
768    
769                    if (uuid == null) {
770                            query.append(_FINDER_COLUMN_UUID_UUID_1);
771                    }
772                    else {
773                            if (uuid.equals(StringPool.BLANK)) {
774                                    query.append(_FINDER_COLUMN_UUID_UUID_3);
775                            }
776                            else {
777                                    query.append(_FINDER_COLUMN_UUID_UUID_2);
778                            }
779                    }
780    
781                    if (orderByComparator != null) {
782                            String[] orderByFields = orderByComparator.getOrderByFields();
783    
784                            if (orderByFields.length > 0) {
785                                    query.append(WHERE_AND);
786                            }
787    
788                            for (int i = 0; i < orderByFields.length; i++) {
789                                    query.append(_ORDER_BY_ENTITY_ALIAS);
790                                    query.append(orderByFields[i]);
791    
792                                    if ((i + 1) < orderByFields.length) {
793                                            if (orderByComparator.isAscending() ^ previous) {
794                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
795                                            }
796                                            else {
797                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
798                                            }
799                                    }
800                                    else {
801                                            if (orderByComparator.isAscending() ^ previous) {
802                                                    query.append(WHERE_GREATER_THAN);
803                                            }
804                                            else {
805                                                    query.append(WHERE_LESSER_THAN);
806                                            }
807                                    }
808                            }
809    
810                            query.append(ORDER_BY_CLAUSE);
811    
812                            for (int i = 0; i < orderByFields.length; i++) {
813                                    query.append(_ORDER_BY_ENTITY_ALIAS);
814                                    query.append(orderByFields[i]);
815    
816                                    if ((i + 1) < orderByFields.length) {
817                                            if (orderByComparator.isAscending() ^ previous) {
818                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
819                                            }
820                                            else {
821                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
822                                            }
823                                    }
824                                    else {
825                                            if (orderByComparator.isAscending() ^ previous) {
826                                                    query.append(ORDER_BY_ASC);
827                                            }
828                                            else {
829                                                    query.append(ORDER_BY_DESC);
830                                            }
831                                    }
832                            }
833                    }
834    
835                    else {
836                            query.append(DLFileEntryModelImpl.ORDER_BY_JPQL);
837                    }
838    
839                    String sql = query.toString();
840    
841                    Query q = session.createQuery(sql);
842    
843                    q.setFirstResult(0);
844                    q.setMaxResults(2);
845    
846                    QueryPos qPos = QueryPos.getInstance(q);
847    
848                    if (uuid != null) {
849                            qPos.add(uuid);
850                    }
851    
852                    if (orderByComparator != null) {
853                            Object[] values = orderByComparator.getOrderByValues(dlFileEntry);
854    
855                            for (Object value : values) {
856                                    qPos.add(value);
857                            }
858                    }
859    
860                    List<DLFileEntry> list = q.list();
861    
862                    if (list.size() == 2) {
863                            return list.get(1);
864                    }
865                    else {
866                            return null;
867                    }
868            }
869    
870            public DLFileEntry findByUUID_G(String uuid, long groupId)
871                    throws NoSuchFileEntryException, SystemException {
872                    DLFileEntry dlFileEntry = fetchByUUID_G(uuid, groupId);
873    
874                    if (dlFileEntry == null) {
875                            StringBundler msg = new StringBundler(6);
876    
877                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
878    
879                            msg.append("uuid=");
880                            msg.append(uuid);
881    
882                            msg.append(", groupId=");
883                            msg.append(groupId);
884    
885                            msg.append(StringPool.CLOSE_CURLY_BRACE);
886    
887                            if (_log.isWarnEnabled()) {
888                                    _log.warn(msg.toString());
889                            }
890    
891                            throw new NoSuchFileEntryException(msg.toString());
892                    }
893    
894                    return dlFileEntry;
895            }
896    
897            public DLFileEntry fetchByUUID_G(String uuid, long groupId)
898                    throws SystemException {
899                    return fetchByUUID_G(uuid, groupId, true);
900            }
901    
902            public DLFileEntry fetchByUUID_G(String uuid, long groupId,
903                    boolean retrieveFromCache) throws SystemException {
904                    Object[] finderArgs = new Object[] { uuid, groupId };
905    
906                    Object result = null;
907    
908                    if (retrieveFromCache) {
909                            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_UUID_G,
910                                            finderArgs, this);
911                    }
912    
913                    if (result == null) {
914                            Session session = null;
915    
916                            try {
917                                    session = openSession();
918    
919                                    StringBundler query = new StringBundler(4);
920    
921                                    query.append(_SQL_SELECT_DLFILEENTRY_WHERE);
922    
923                                    if (uuid == null) {
924                                            query.append(_FINDER_COLUMN_UUID_G_UUID_1);
925                                    }
926                                    else {
927                                            if (uuid.equals(StringPool.BLANK)) {
928                                                    query.append(_FINDER_COLUMN_UUID_G_UUID_3);
929                                            }
930                                            else {
931                                                    query.append(_FINDER_COLUMN_UUID_G_UUID_2);
932                                            }
933                                    }
934    
935                                    query.append(_FINDER_COLUMN_UUID_G_GROUPID_2);
936    
937                                    query.append(DLFileEntryModelImpl.ORDER_BY_JPQL);
938    
939                                    String sql = query.toString();
940    
941                                    Query q = session.createQuery(sql);
942    
943                                    QueryPos qPos = QueryPos.getInstance(q);
944    
945                                    if (uuid != null) {
946                                            qPos.add(uuid);
947                                    }
948    
949                                    qPos.add(groupId);
950    
951                                    List<DLFileEntry> list = q.list();
952    
953                                    result = list;
954    
955                                    DLFileEntry dlFileEntry = null;
956    
957                                    if (list.isEmpty()) {
958                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
959                                                    finderArgs, list);
960                                    }
961                                    else {
962                                            dlFileEntry = list.get(0);
963    
964                                            cacheResult(dlFileEntry);
965    
966                                            if ((dlFileEntry.getUuid() == null) ||
967                                                            !dlFileEntry.getUuid().equals(uuid) ||
968                                                            (dlFileEntry.getGroupId() != groupId)) {
969                                                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
970                                                            finderArgs, dlFileEntry);
971                                            }
972                                    }
973    
974                                    return dlFileEntry;
975                            }
976                            catch (Exception e) {
977                                    throw processException(e);
978                            }
979                            finally {
980                                    if (result == null) {
981                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
982                                                    finderArgs, new ArrayList<DLFileEntry>());
983                                    }
984    
985                                    closeSession(session);
986                            }
987                    }
988                    else {
989                            if (result instanceof List<?>) {
990                                    return null;
991                            }
992                            else {
993                                    return (DLFileEntry)result;
994                            }
995                    }
996            }
997    
998            public List<DLFileEntry> findByGroupId(long groupId)
999                    throws SystemException {
1000                    return findByGroupId(groupId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1001            }
1002    
1003            public List<DLFileEntry> findByGroupId(long groupId, int start, int end)
1004                    throws SystemException {
1005                    return findByGroupId(groupId, start, end, null);
1006            }
1007    
1008            public List<DLFileEntry> findByGroupId(long groupId, int start, int end,
1009                    OrderByComparator orderByComparator) throws SystemException {
1010                    Object[] finderArgs = new Object[] {
1011                                    groupId,
1012                                    
1013                                    String.valueOf(start), String.valueOf(end),
1014                                    String.valueOf(orderByComparator)
1015                            };
1016    
1017                    List<DLFileEntry> list = (List<DLFileEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_GROUPID,
1018                                    finderArgs, this);
1019    
1020                    if (list == null) {
1021                            Session session = null;
1022    
1023                            try {
1024                                    session = openSession();
1025    
1026                                    StringBundler query = null;
1027    
1028                                    if (orderByComparator != null) {
1029                                            query = new StringBundler(3 +
1030                                                            (orderByComparator.getOrderByFields().length * 3));
1031                                    }
1032                                    else {
1033                                            query = new StringBundler(3);
1034                                    }
1035    
1036                                    query.append(_SQL_SELECT_DLFILEENTRY_WHERE);
1037    
1038                                    query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1039    
1040                                    if (orderByComparator != null) {
1041                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1042                                                    orderByComparator);
1043                                    }
1044    
1045                                    else {
1046                                            query.append(DLFileEntryModelImpl.ORDER_BY_JPQL);
1047                                    }
1048    
1049                                    String sql = query.toString();
1050    
1051                                    Query q = session.createQuery(sql);
1052    
1053                                    QueryPos qPos = QueryPos.getInstance(q);
1054    
1055                                    qPos.add(groupId);
1056    
1057                                    list = (List<DLFileEntry>)QueryUtil.list(q, getDialect(),
1058                                                    start, end);
1059                            }
1060                            catch (Exception e) {
1061                                    throw processException(e);
1062                            }
1063                            finally {
1064                                    if (list == null) {
1065                                            list = new ArrayList<DLFileEntry>();
1066                                    }
1067    
1068                                    cacheResult(list);
1069    
1070                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_GROUPID,
1071                                            finderArgs, list);
1072    
1073                                    closeSession(session);
1074                            }
1075                    }
1076    
1077                    return list;
1078            }
1079    
1080            public DLFileEntry findByGroupId_First(long groupId,
1081                    OrderByComparator orderByComparator)
1082                    throws NoSuchFileEntryException, SystemException {
1083                    List<DLFileEntry> list = findByGroupId(groupId, 0, 1, orderByComparator);
1084    
1085                    if (list.isEmpty()) {
1086                            StringBundler msg = new StringBundler(4);
1087    
1088                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1089    
1090                            msg.append("groupId=");
1091                            msg.append(groupId);
1092    
1093                            msg.append(StringPool.CLOSE_CURLY_BRACE);
1094    
1095                            throw new NoSuchFileEntryException(msg.toString());
1096                    }
1097                    else {
1098                            return list.get(0);
1099                    }
1100            }
1101    
1102            public DLFileEntry findByGroupId_Last(long groupId,
1103                    OrderByComparator orderByComparator)
1104                    throws NoSuchFileEntryException, SystemException {
1105                    int count = countByGroupId(groupId);
1106    
1107                    List<DLFileEntry> list = findByGroupId(groupId, count - 1, count,
1108                                    orderByComparator);
1109    
1110                    if (list.isEmpty()) {
1111                            StringBundler msg = new StringBundler(4);
1112    
1113                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1114    
1115                            msg.append("groupId=");
1116                            msg.append(groupId);
1117    
1118                            msg.append(StringPool.CLOSE_CURLY_BRACE);
1119    
1120                            throw new NoSuchFileEntryException(msg.toString());
1121                    }
1122                    else {
1123                            return list.get(0);
1124                    }
1125            }
1126    
1127            public DLFileEntry[] findByGroupId_PrevAndNext(long fileEntryId,
1128                    long groupId, OrderByComparator orderByComparator)
1129                    throws NoSuchFileEntryException, SystemException {
1130                    DLFileEntry dlFileEntry = findByPrimaryKey(fileEntryId);
1131    
1132                    Session session = null;
1133    
1134                    try {
1135                            session = openSession();
1136    
1137                            DLFileEntry[] array = new DLFileEntryImpl[3];
1138    
1139                            array[0] = getByGroupId_PrevAndNext(session, dlFileEntry, groupId,
1140                                            orderByComparator, true);
1141    
1142                            array[1] = dlFileEntry;
1143    
1144                            array[2] = getByGroupId_PrevAndNext(session, dlFileEntry, groupId,
1145                                            orderByComparator, false);
1146    
1147                            return array;
1148                    }
1149                    catch (Exception e) {
1150                            throw processException(e);
1151                    }
1152                    finally {
1153                            closeSession(session);
1154                    }
1155            }
1156    
1157            protected DLFileEntry getByGroupId_PrevAndNext(Session session,
1158                    DLFileEntry dlFileEntry, long groupId,
1159                    OrderByComparator orderByComparator, boolean previous) {
1160                    StringBundler query = null;
1161    
1162                    if (orderByComparator != null) {
1163                            query = new StringBundler(6 +
1164                                            (orderByComparator.getOrderByFields().length * 6));
1165                    }
1166                    else {
1167                            query = new StringBundler(3);
1168                    }
1169    
1170                    query.append(_SQL_SELECT_DLFILEENTRY_WHERE);
1171    
1172                    query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1173    
1174                    if (orderByComparator != null) {
1175                            String[] orderByFields = orderByComparator.getOrderByFields();
1176    
1177                            if (orderByFields.length > 0) {
1178                                    query.append(WHERE_AND);
1179                            }
1180    
1181                            for (int i = 0; i < orderByFields.length; i++) {
1182                                    query.append(_ORDER_BY_ENTITY_ALIAS);
1183                                    query.append(orderByFields[i]);
1184    
1185                                    if ((i + 1) < orderByFields.length) {
1186                                            if (orderByComparator.isAscending() ^ previous) {
1187                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
1188                                            }
1189                                            else {
1190                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
1191                                            }
1192                                    }
1193                                    else {
1194                                            if (orderByComparator.isAscending() ^ previous) {
1195                                                    query.append(WHERE_GREATER_THAN);
1196                                            }
1197                                            else {
1198                                                    query.append(WHERE_LESSER_THAN);
1199                                            }
1200                                    }
1201                            }
1202    
1203                            query.append(ORDER_BY_CLAUSE);
1204    
1205                            for (int i = 0; i < orderByFields.length; i++) {
1206                                    query.append(_ORDER_BY_ENTITY_ALIAS);
1207                                    query.append(orderByFields[i]);
1208    
1209                                    if ((i + 1) < orderByFields.length) {
1210                                            if (orderByComparator.isAscending() ^ previous) {
1211                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
1212                                            }
1213                                            else {
1214                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
1215                                            }
1216                                    }
1217                                    else {
1218                                            if (orderByComparator.isAscending() ^ previous) {
1219                                                    query.append(ORDER_BY_ASC);
1220                                            }
1221                                            else {
1222                                                    query.append(ORDER_BY_DESC);
1223                                            }
1224                                    }
1225                            }
1226                    }
1227    
1228                    else {
1229                            query.append(DLFileEntryModelImpl.ORDER_BY_JPQL);
1230                    }
1231    
1232                    String sql = query.toString();
1233    
1234                    Query q = session.createQuery(sql);
1235    
1236                    q.setFirstResult(0);
1237                    q.setMaxResults(2);
1238    
1239                    QueryPos qPos = QueryPos.getInstance(q);
1240    
1241                    qPos.add(groupId);
1242    
1243                    if (orderByComparator != null) {
1244                            Object[] values = orderByComparator.getOrderByValues(dlFileEntry);
1245    
1246                            for (Object value : values) {
1247                                    qPos.add(value);
1248                            }
1249                    }
1250    
1251                    List<DLFileEntry> list = q.list();
1252    
1253                    if (list.size() == 2) {
1254                            return list.get(1);
1255                    }
1256                    else {
1257                            return null;
1258                    }
1259            }
1260    
1261            public List<DLFileEntry> filterFindByGroupId(long groupId)
1262                    throws SystemException {
1263                    return filterFindByGroupId(groupId, QueryUtil.ALL_POS,
1264                            QueryUtil.ALL_POS, null);
1265            }
1266    
1267            public List<DLFileEntry> filterFindByGroupId(long groupId, int start,
1268                    int end) throws SystemException {
1269                    return filterFindByGroupId(groupId, start, end, null);
1270            }
1271    
1272            public List<DLFileEntry> filterFindByGroupId(long groupId, int start,
1273                    int end, OrderByComparator orderByComparator) throws SystemException {
1274                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
1275                            return findByGroupId(groupId, start, end, orderByComparator);
1276                    }
1277    
1278                    Session session = null;
1279    
1280                    try {
1281                            session = openSession();
1282    
1283                            StringBundler query = null;
1284    
1285                            if (orderByComparator != null) {
1286                                    query = new StringBundler(3 +
1287                                                    (orderByComparator.getOrderByFields().length * 3));
1288                            }
1289                            else {
1290                                    query = new StringBundler(3);
1291                            }
1292    
1293                            query.append(_FILTER_SQL_SELECT_DLFILEENTRY_WHERE);
1294    
1295                            query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1296    
1297                            if (orderByComparator != null) {
1298                                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1299                                            orderByComparator);
1300                            }
1301    
1302                            else {
1303                                    query.append(DLFileEntryModelImpl.ORDER_BY_JPQL);
1304                            }
1305    
1306                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
1307                                            DLFileEntry.class.getName(), _FILTER_COLUMN_PK,
1308                                            _FILTER_COLUMN_USERID, groupId);
1309    
1310                            SQLQuery q = session.createSQLQuery(sql);
1311    
1312                            q.addEntity(_FILTER_ENTITY_ALIAS, DLFileEntryImpl.class);
1313    
1314                            QueryPos qPos = QueryPos.getInstance(q);
1315    
1316                            qPos.add(groupId);
1317    
1318                            return (List<DLFileEntry>)QueryUtil.list(q, getDialect(), start, end);
1319                    }
1320                    catch (Exception e) {
1321                            throw processException(e);
1322                    }
1323                    finally {
1324                            closeSession(session);
1325                    }
1326            }
1327    
1328            public List<DLFileEntry> findByCompanyId(long companyId)
1329                    throws SystemException {
1330                    return findByCompanyId(companyId, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
1331                            null);
1332            }
1333    
1334            public List<DLFileEntry> findByCompanyId(long companyId, int start, int end)
1335                    throws SystemException {
1336                    return findByCompanyId(companyId, start, end, null);
1337            }
1338    
1339            public List<DLFileEntry> findByCompanyId(long companyId, int start,
1340                    int end, OrderByComparator orderByComparator) throws SystemException {
1341                    Object[] finderArgs = new Object[] {
1342                                    companyId,
1343                                    
1344                                    String.valueOf(start), String.valueOf(end),
1345                                    String.valueOf(orderByComparator)
1346                            };
1347    
1348                    List<DLFileEntry> list = (List<DLFileEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_COMPANYID,
1349                                    finderArgs, this);
1350    
1351                    if (list == null) {
1352                            Session session = null;
1353    
1354                            try {
1355                                    session = openSession();
1356    
1357                                    StringBundler query = null;
1358    
1359                                    if (orderByComparator != null) {
1360                                            query = new StringBundler(3 +
1361                                                            (orderByComparator.getOrderByFields().length * 3));
1362                                    }
1363                                    else {
1364                                            query = new StringBundler(3);
1365                                    }
1366    
1367                                    query.append(_SQL_SELECT_DLFILEENTRY_WHERE);
1368    
1369                                    query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
1370    
1371                                    if (orderByComparator != null) {
1372                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1373                                                    orderByComparator);
1374                                    }
1375    
1376                                    else {
1377                                            query.append(DLFileEntryModelImpl.ORDER_BY_JPQL);
1378                                    }
1379    
1380                                    String sql = query.toString();
1381    
1382                                    Query q = session.createQuery(sql);
1383    
1384                                    QueryPos qPos = QueryPos.getInstance(q);
1385    
1386                                    qPos.add(companyId);
1387    
1388                                    list = (List<DLFileEntry>)QueryUtil.list(q, getDialect(),
1389                                                    start, end);
1390                            }
1391                            catch (Exception e) {
1392                                    throw processException(e);
1393                            }
1394                            finally {
1395                                    if (list == null) {
1396                                            list = new ArrayList<DLFileEntry>();
1397                                    }
1398    
1399                                    cacheResult(list);
1400    
1401                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_COMPANYID,
1402                                            finderArgs, list);
1403    
1404                                    closeSession(session);
1405                            }
1406                    }
1407    
1408                    return list;
1409            }
1410    
1411            public DLFileEntry findByCompanyId_First(long companyId,
1412                    OrderByComparator orderByComparator)
1413                    throws NoSuchFileEntryException, SystemException {
1414                    List<DLFileEntry> list = findByCompanyId(companyId, 0, 1,
1415                                    orderByComparator);
1416    
1417                    if (list.isEmpty()) {
1418                            StringBundler msg = new StringBundler(4);
1419    
1420                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1421    
1422                            msg.append("companyId=");
1423                            msg.append(companyId);
1424    
1425                            msg.append(StringPool.CLOSE_CURLY_BRACE);
1426    
1427                            throw new NoSuchFileEntryException(msg.toString());
1428                    }
1429                    else {
1430                            return list.get(0);
1431                    }
1432            }
1433    
1434            public DLFileEntry findByCompanyId_Last(long companyId,
1435                    OrderByComparator orderByComparator)
1436                    throws NoSuchFileEntryException, SystemException {
1437                    int count = countByCompanyId(companyId);
1438    
1439                    List<DLFileEntry> list = findByCompanyId(companyId, count - 1, count,
1440                                    orderByComparator);
1441    
1442                    if (list.isEmpty()) {
1443                            StringBundler msg = new StringBundler(4);
1444    
1445                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1446    
1447                            msg.append("companyId=");
1448                            msg.append(companyId);
1449    
1450                            msg.append(StringPool.CLOSE_CURLY_BRACE);
1451    
1452                            throw new NoSuchFileEntryException(msg.toString());
1453                    }
1454                    else {
1455                            return list.get(0);
1456                    }
1457            }
1458    
1459            public DLFileEntry[] findByCompanyId_PrevAndNext(long fileEntryId,
1460                    long companyId, OrderByComparator orderByComparator)
1461                    throws NoSuchFileEntryException, SystemException {
1462                    DLFileEntry dlFileEntry = findByPrimaryKey(fileEntryId);
1463    
1464                    Session session = null;
1465    
1466                    try {
1467                            session = openSession();
1468    
1469                            DLFileEntry[] array = new DLFileEntryImpl[3];
1470    
1471                            array[0] = getByCompanyId_PrevAndNext(session, dlFileEntry,
1472                                            companyId, orderByComparator, true);
1473    
1474                            array[1] = dlFileEntry;
1475    
1476                            array[2] = getByCompanyId_PrevAndNext(session, dlFileEntry,
1477                                            companyId, orderByComparator, false);
1478    
1479                            return array;
1480                    }
1481                    catch (Exception e) {
1482                            throw processException(e);
1483                    }
1484                    finally {
1485                            closeSession(session);
1486                    }
1487            }
1488    
1489            protected DLFileEntry getByCompanyId_PrevAndNext(Session session,
1490                    DLFileEntry dlFileEntry, long companyId,
1491                    OrderByComparator orderByComparator, boolean previous) {
1492                    StringBundler query = null;
1493    
1494                    if (orderByComparator != null) {
1495                            query = new StringBundler(6 +
1496                                            (orderByComparator.getOrderByFields().length * 6));
1497                    }
1498                    else {
1499                            query = new StringBundler(3);
1500                    }
1501    
1502                    query.append(_SQL_SELECT_DLFILEENTRY_WHERE);
1503    
1504                    query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
1505    
1506                    if (orderByComparator != null) {
1507                            String[] orderByFields = orderByComparator.getOrderByFields();
1508    
1509                            if (orderByFields.length > 0) {
1510                                    query.append(WHERE_AND);
1511                            }
1512    
1513                            for (int i = 0; i < orderByFields.length; i++) {
1514                                    query.append(_ORDER_BY_ENTITY_ALIAS);
1515                                    query.append(orderByFields[i]);
1516    
1517                                    if ((i + 1) < orderByFields.length) {
1518                                            if (orderByComparator.isAscending() ^ previous) {
1519                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
1520                                            }
1521                                            else {
1522                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
1523                                            }
1524                                    }
1525                                    else {
1526                                            if (orderByComparator.isAscending() ^ previous) {
1527                                                    query.append(WHERE_GREATER_THAN);
1528                                            }
1529                                            else {
1530                                                    query.append(WHERE_LESSER_THAN);
1531                                            }
1532                                    }
1533                            }
1534    
1535                            query.append(ORDER_BY_CLAUSE);
1536    
1537                            for (int i = 0; i < orderByFields.length; i++) {
1538                                    query.append(_ORDER_BY_ENTITY_ALIAS);
1539                                    query.append(orderByFields[i]);
1540    
1541                                    if ((i + 1) < orderByFields.length) {
1542                                            if (orderByComparator.isAscending() ^ previous) {
1543                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
1544                                            }
1545                                            else {
1546                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
1547                                            }
1548                                    }
1549                                    else {
1550                                            if (orderByComparator.isAscending() ^ previous) {
1551                                                    query.append(ORDER_BY_ASC);
1552                                            }
1553                                            else {
1554                                                    query.append(ORDER_BY_DESC);
1555                                            }
1556                                    }
1557                            }
1558                    }
1559    
1560                    else {
1561                            query.append(DLFileEntryModelImpl.ORDER_BY_JPQL);
1562                    }
1563    
1564                    String sql = query.toString();
1565    
1566                    Query q = session.createQuery(sql);
1567    
1568                    q.setFirstResult(0);
1569                    q.setMaxResults(2);
1570    
1571                    QueryPos qPos = QueryPos.getInstance(q);
1572    
1573                    qPos.add(companyId);
1574    
1575                    if (orderByComparator != null) {
1576                            Object[] values = orderByComparator.getOrderByValues(dlFileEntry);
1577    
1578                            for (Object value : values) {
1579                                    qPos.add(value);
1580                            }
1581                    }
1582    
1583                    List<DLFileEntry> list = q.list();
1584    
1585                    if (list.size() == 2) {
1586                            return list.get(1);
1587                    }
1588                    else {
1589                            return null;
1590                    }
1591            }
1592    
1593            public List<DLFileEntry> findByG_U(long groupId, long userId)
1594                    throws SystemException {
1595                    return findByG_U(groupId, userId, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
1596                            null);
1597            }
1598    
1599            public List<DLFileEntry> findByG_U(long groupId, long userId, int start,
1600                    int end) throws SystemException {
1601                    return findByG_U(groupId, userId, start, end, null);
1602            }
1603    
1604            public List<DLFileEntry> findByG_U(long groupId, long userId, int start,
1605                    int end, OrderByComparator orderByComparator) throws SystemException {
1606                    Object[] finderArgs = new Object[] {
1607                                    groupId, userId,
1608                                    
1609                                    String.valueOf(start), String.valueOf(end),
1610                                    String.valueOf(orderByComparator)
1611                            };
1612    
1613                    List<DLFileEntry> list = (List<DLFileEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_U,
1614                                    finderArgs, this);
1615    
1616                    if (list == null) {
1617                            Session session = null;
1618    
1619                            try {
1620                                    session = openSession();
1621    
1622                                    StringBundler query = null;
1623    
1624                                    if (orderByComparator != null) {
1625                                            query = new StringBundler(4 +
1626                                                            (orderByComparator.getOrderByFields().length * 3));
1627                                    }
1628                                    else {
1629                                            query = new StringBundler(4);
1630                                    }
1631    
1632                                    query.append(_SQL_SELECT_DLFILEENTRY_WHERE);
1633    
1634                                    query.append(_FINDER_COLUMN_G_U_GROUPID_2);
1635    
1636                                    query.append(_FINDER_COLUMN_G_U_USERID_2);
1637    
1638                                    if (orderByComparator != null) {
1639                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1640                                                    orderByComparator);
1641                                    }
1642    
1643                                    else {
1644                                            query.append(DLFileEntryModelImpl.ORDER_BY_JPQL);
1645                                    }
1646    
1647                                    String sql = query.toString();
1648    
1649                                    Query q = session.createQuery(sql);
1650    
1651                                    QueryPos qPos = QueryPos.getInstance(q);
1652    
1653                                    qPos.add(groupId);
1654    
1655                                    qPos.add(userId);
1656    
1657                                    list = (List<DLFileEntry>)QueryUtil.list(q, getDialect(),
1658                                                    start, end);
1659                            }
1660                            catch (Exception e) {
1661                                    throw processException(e);
1662                            }
1663                            finally {
1664                                    if (list == null) {
1665                                            list = new ArrayList<DLFileEntry>();
1666                                    }
1667    
1668                                    cacheResult(list);
1669    
1670                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_U, finderArgs,
1671                                            list);
1672    
1673                                    closeSession(session);
1674                            }
1675                    }
1676    
1677                    return list;
1678            }
1679    
1680            public DLFileEntry findByG_U_First(long groupId, long userId,
1681                    OrderByComparator orderByComparator)
1682                    throws NoSuchFileEntryException, SystemException {
1683                    List<DLFileEntry> list = findByG_U(groupId, userId, 0, 1,
1684                                    orderByComparator);
1685    
1686                    if (list.isEmpty()) {
1687                            StringBundler msg = new StringBundler(6);
1688    
1689                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1690    
1691                            msg.append("groupId=");
1692                            msg.append(groupId);
1693    
1694                            msg.append(", userId=");
1695                            msg.append(userId);
1696    
1697                            msg.append(StringPool.CLOSE_CURLY_BRACE);
1698    
1699                            throw new NoSuchFileEntryException(msg.toString());
1700                    }
1701                    else {
1702                            return list.get(0);
1703                    }
1704            }
1705    
1706            public DLFileEntry findByG_U_Last(long groupId, long userId,
1707                    OrderByComparator orderByComparator)
1708                    throws NoSuchFileEntryException, SystemException {
1709                    int count = countByG_U(groupId, userId);
1710    
1711                    List<DLFileEntry> list = findByG_U(groupId, userId, count - 1, count,
1712                                    orderByComparator);
1713    
1714                    if (list.isEmpty()) {
1715                            StringBundler msg = new StringBundler(6);
1716    
1717                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1718    
1719                            msg.append("groupId=");
1720                            msg.append(groupId);
1721    
1722                            msg.append(", userId=");
1723                            msg.append(userId);
1724    
1725                            msg.append(StringPool.CLOSE_CURLY_BRACE);
1726    
1727                            throw new NoSuchFileEntryException(msg.toString());
1728                    }
1729                    else {
1730                            return list.get(0);
1731                    }
1732            }
1733    
1734            public DLFileEntry[] findByG_U_PrevAndNext(long fileEntryId, long groupId,
1735                    long userId, OrderByComparator orderByComparator)
1736                    throws NoSuchFileEntryException, SystemException {
1737                    DLFileEntry dlFileEntry = findByPrimaryKey(fileEntryId);
1738    
1739                    Session session = null;
1740    
1741                    try {
1742                            session = openSession();
1743    
1744                            DLFileEntry[] array = new DLFileEntryImpl[3];
1745    
1746                            array[0] = getByG_U_PrevAndNext(session, dlFileEntry, groupId,
1747                                            userId, orderByComparator, true);
1748    
1749                            array[1] = dlFileEntry;
1750    
1751                            array[2] = getByG_U_PrevAndNext(session, dlFileEntry, groupId,
1752                                            userId, orderByComparator, false);
1753    
1754                            return array;
1755                    }
1756                    catch (Exception e) {
1757                            throw processException(e);
1758                    }
1759                    finally {
1760                            closeSession(session);
1761                    }
1762            }
1763    
1764            protected DLFileEntry getByG_U_PrevAndNext(Session session,
1765                    DLFileEntry dlFileEntry, long groupId, long userId,
1766                    OrderByComparator orderByComparator, boolean previous) {
1767                    StringBundler query = null;
1768    
1769                    if (orderByComparator != null) {
1770                            query = new StringBundler(6 +
1771                                            (orderByComparator.getOrderByFields().length * 6));
1772                    }
1773                    else {
1774                            query = new StringBundler(3);
1775                    }
1776    
1777                    query.append(_SQL_SELECT_DLFILEENTRY_WHERE);
1778    
1779                    query.append(_FINDER_COLUMN_G_U_GROUPID_2);
1780    
1781                    query.append(_FINDER_COLUMN_G_U_USERID_2);
1782    
1783                    if (orderByComparator != null) {
1784                            String[] orderByFields = orderByComparator.getOrderByFields();
1785    
1786                            if (orderByFields.length > 0) {
1787                                    query.append(WHERE_AND);
1788                            }
1789    
1790                            for (int i = 0; i < orderByFields.length; i++) {
1791                                    query.append(_ORDER_BY_ENTITY_ALIAS);
1792                                    query.append(orderByFields[i]);
1793    
1794                                    if ((i + 1) < orderByFields.length) {
1795                                            if (orderByComparator.isAscending() ^ previous) {
1796                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
1797                                            }
1798                                            else {
1799                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
1800                                            }
1801                                    }
1802                                    else {
1803                                            if (orderByComparator.isAscending() ^ previous) {
1804                                                    query.append(WHERE_GREATER_THAN);
1805                                            }
1806                                            else {
1807                                                    query.append(WHERE_LESSER_THAN);
1808                                            }
1809                                    }
1810                            }
1811    
1812                            query.append(ORDER_BY_CLAUSE);
1813    
1814                            for (int i = 0; i < orderByFields.length; i++) {
1815                                    query.append(_ORDER_BY_ENTITY_ALIAS);
1816                                    query.append(orderByFields[i]);
1817    
1818                                    if ((i + 1) < orderByFields.length) {
1819                                            if (orderByComparator.isAscending() ^ previous) {
1820                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
1821                                            }
1822                                            else {
1823                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
1824                                            }
1825                                    }
1826                                    else {
1827                                            if (orderByComparator.isAscending() ^ previous) {
1828                                                    query.append(ORDER_BY_ASC);
1829                                            }
1830                                            else {
1831                                                    query.append(ORDER_BY_DESC);
1832                                            }
1833                                    }
1834                            }
1835                    }
1836    
1837                    else {
1838                            query.append(DLFileEntryModelImpl.ORDER_BY_JPQL);
1839                    }
1840    
1841                    String sql = query.toString();
1842    
1843                    Query q = session.createQuery(sql);
1844    
1845                    q.setFirstResult(0);
1846                    q.setMaxResults(2);
1847    
1848                    QueryPos qPos = QueryPos.getInstance(q);
1849    
1850                    qPos.add(groupId);
1851    
1852                    qPos.add(userId);
1853    
1854                    if (orderByComparator != null) {
1855                            Object[] values = orderByComparator.getOrderByValues(dlFileEntry);
1856    
1857                            for (Object value : values) {
1858                                    qPos.add(value);
1859                            }
1860                    }
1861    
1862                    List<DLFileEntry> list = q.list();
1863    
1864                    if (list.size() == 2) {
1865                            return list.get(1);
1866                    }
1867                    else {
1868                            return null;
1869                    }
1870            }
1871    
1872            public List<DLFileEntry> filterFindByG_U(long groupId, long userId)
1873                    throws SystemException {
1874                    return filterFindByG_U(groupId, userId, QueryUtil.ALL_POS,
1875                            QueryUtil.ALL_POS, null);
1876            }
1877    
1878            public List<DLFileEntry> filterFindByG_U(long groupId, long userId,
1879                    int start, int end) throws SystemException {
1880                    return filterFindByG_U(groupId, userId, start, end, null);
1881            }
1882    
1883            public List<DLFileEntry> filterFindByG_U(long groupId, long userId,
1884                    int start, int end, OrderByComparator orderByComparator)
1885                    throws SystemException {
1886                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
1887                            return findByG_U(groupId, userId, start, end, orderByComparator);
1888                    }
1889    
1890                    Session session = null;
1891    
1892                    try {
1893                            session = openSession();
1894    
1895                            StringBundler query = null;
1896    
1897                            if (orderByComparator != null) {
1898                                    query = new StringBundler(4 +
1899                                                    (orderByComparator.getOrderByFields().length * 3));
1900                            }
1901                            else {
1902                                    query = new StringBundler(4);
1903                            }
1904    
1905                            query.append(_FILTER_SQL_SELECT_DLFILEENTRY_WHERE);
1906    
1907                            query.append(_FINDER_COLUMN_G_U_GROUPID_2);
1908    
1909                            query.append(_FINDER_COLUMN_G_U_USERID_2);
1910    
1911                            if (orderByComparator != null) {
1912                                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1913                                            orderByComparator);
1914                            }
1915    
1916                            else {
1917                                    query.append(DLFileEntryModelImpl.ORDER_BY_JPQL);
1918                            }
1919    
1920                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
1921                                            DLFileEntry.class.getName(), _FILTER_COLUMN_PK,
1922                                            _FILTER_COLUMN_USERID, groupId);
1923    
1924                            SQLQuery q = session.createSQLQuery(sql);
1925    
1926                            q.addEntity(_FILTER_ENTITY_ALIAS, DLFileEntryImpl.class);
1927    
1928                            QueryPos qPos = QueryPos.getInstance(q);
1929    
1930                            qPos.add(groupId);
1931    
1932                            qPos.add(userId);
1933    
1934                            return (List<DLFileEntry>)QueryUtil.list(q, getDialect(), start, end);
1935                    }
1936                    catch (Exception e) {
1937                            throw processException(e);
1938                    }
1939                    finally {
1940                            closeSession(session);
1941                    }
1942            }
1943    
1944            public List<DLFileEntry> findByG_F(long groupId, long folderId)
1945                    throws SystemException {
1946                    return findByG_F(groupId, folderId, QueryUtil.ALL_POS,
1947                            QueryUtil.ALL_POS, null);
1948            }
1949    
1950            public List<DLFileEntry> findByG_F(long groupId, long folderId, int start,
1951                    int end) throws SystemException {
1952                    return findByG_F(groupId, folderId, start, end, null);
1953            }
1954    
1955            public List<DLFileEntry> findByG_F(long groupId, long folderId, int start,
1956                    int end, OrderByComparator orderByComparator) throws SystemException {
1957                    Object[] finderArgs = new Object[] {
1958                                    groupId, folderId,
1959                                    
1960                                    String.valueOf(start), String.valueOf(end),
1961                                    String.valueOf(orderByComparator)
1962                            };
1963    
1964                    List<DLFileEntry> list = (List<DLFileEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_F,
1965                                    finderArgs, this);
1966    
1967                    if (list == null) {
1968                            Session session = null;
1969    
1970                            try {
1971                                    session = openSession();
1972    
1973                                    StringBundler query = null;
1974    
1975                                    if (orderByComparator != null) {
1976                                            query = new StringBundler(4 +
1977                                                            (orderByComparator.getOrderByFields().length * 3));
1978                                    }
1979                                    else {
1980                                            query = new StringBundler(4);
1981                                    }
1982    
1983                                    query.append(_SQL_SELECT_DLFILEENTRY_WHERE);
1984    
1985                                    query.append(_FINDER_COLUMN_G_F_GROUPID_2);
1986    
1987                                    query.append(_FINDER_COLUMN_G_F_FOLDERID_2);
1988    
1989                                    if (orderByComparator != null) {
1990                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1991                                                    orderByComparator);
1992                                    }
1993    
1994                                    else {
1995                                            query.append(DLFileEntryModelImpl.ORDER_BY_JPQL);
1996                                    }
1997    
1998                                    String sql = query.toString();
1999    
2000                                    Query q = session.createQuery(sql);
2001    
2002                                    QueryPos qPos = QueryPos.getInstance(q);
2003    
2004                                    qPos.add(groupId);
2005    
2006                                    qPos.add(folderId);
2007    
2008                                    list = (List<DLFileEntry>)QueryUtil.list(q, getDialect(),
2009                                                    start, end);
2010                            }
2011                            catch (Exception e) {
2012                                    throw processException(e);
2013                            }
2014                            finally {
2015                                    if (list == null) {
2016                                            list = new ArrayList<DLFileEntry>();
2017                                    }
2018    
2019                                    cacheResult(list);
2020    
2021                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_F, finderArgs,
2022                                            list);
2023    
2024                                    closeSession(session);
2025                            }
2026                    }
2027    
2028                    return list;
2029            }
2030    
2031            public DLFileEntry findByG_F_First(long groupId, long folderId,
2032                    OrderByComparator orderByComparator)
2033                    throws NoSuchFileEntryException, SystemException {
2034                    List<DLFileEntry> list = findByG_F(groupId, folderId, 0, 1,
2035                                    orderByComparator);
2036    
2037                    if (list.isEmpty()) {
2038                            StringBundler msg = new StringBundler(6);
2039    
2040                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2041    
2042                            msg.append("groupId=");
2043                            msg.append(groupId);
2044    
2045                            msg.append(", folderId=");
2046                            msg.append(folderId);
2047    
2048                            msg.append(StringPool.CLOSE_CURLY_BRACE);
2049    
2050                            throw new NoSuchFileEntryException(msg.toString());
2051                    }
2052                    else {
2053                            return list.get(0);
2054                    }
2055            }
2056    
2057            public DLFileEntry findByG_F_Last(long groupId, long folderId,
2058                    OrderByComparator orderByComparator)
2059                    throws NoSuchFileEntryException, SystemException {
2060                    int count = countByG_F(groupId, folderId);
2061    
2062                    List<DLFileEntry> list = findByG_F(groupId, folderId, count - 1, count,
2063                                    orderByComparator);
2064    
2065                    if (list.isEmpty()) {
2066                            StringBundler msg = new StringBundler(6);
2067    
2068                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2069    
2070                            msg.append("groupId=");
2071                            msg.append(groupId);
2072    
2073                            msg.append(", folderId=");
2074                            msg.append(folderId);
2075    
2076                            msg.append(StringPool.CLOSE_CURLY_BRACE);
2077    
2078                            throw new NoSuchFileEntryException(msg.toString());
2079                    }
2080                    else {
2081                            return list.get(0);
2082                    }
2083            }
2084    
2085            public DLFileEntry[] findByG_F_PrevAndNext(long fileEntryId, long groupId,
2086                    long folderId, OrderByComparator orderByComparator)
2087                    throws NoSuchFileEntryException, SystemException {
2088                    DLFileEntry dlFileEntry = findByPrimaryKey(fileEntryId);
2089    
2090                    Session session = null;
2091    
2092                    try {
2093                            session = openSession();
2094    
2095                            DLFileEntry[] array = new DLFileEntryImpl[3];
2096    
2097                            array[0] = getByG_F_PrevAndNext(session, dlFileEntry, groupId,
2098                                            folderId, orderByComparator, true);
2099    
2100                            array[1] = dlFileEntry;
2101    
2102                            array[2] = getByG_F_PrevAndNext(session, dlFileEntry, groupId,
2103                                            folderId, orderByComparator, false);
2104    
2105                            return array;
2106                    }
2107                    catch (Exception e) {
2108                            throw processException(e);
2109                    }
2110                    finally {
2111                            closeSession(session);
2112                    }
2113            }
2114    
2115            protected DLFileEntry getByG_F_PrevAndNext(Session session,
2116                    DLFileEntry dlFileEntry, long groupId, long folderId,
2117                    OrderByComparator orderByComparator, boolean previous) {
2118                    StringBundler query = null;
2119    
2120                    if (orderByComparator != null) {
2121                            query = new StringBundler(6 +
2122                                            (orderByComparator.getOrderByFields().length * 6));
2123                    }
2124                    else {
2125                            query = new StringBundler(3);
2126                    }
2127    
2128                    query.append(_SQL_SELECT_DLFILEENTRY_WHERE);
2129    
2130                    query.append(_FINDER_COLUMN_G_F_GROUPID_2);
2131    
2132                    query.append(_FINDER_COLUMN_G_F_FOLDERID_2);
2133    
2134                    if (orderByComparator != null) {
2135                            String[] orderByFields = orderByComparator.getOrderByFields();
2136    
2137                            if (orderByFields.length > 0) {
2138                                    query.append(WHERE_AND);
2139                            }
2140    
2141                            for (int i = 0; i < orderByFields.length; i++) {
2142                                    query.append(_ORDER_BY_ENTITY_ALIAS);
2143                                    query.append(orderByFields[i]);
2144    
2145                                    if ((i + 1) < orderByFields.length) {
2146                                            if (orderByComparator.isAscending() ^ previous) {
2147                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
2148                                            }
2149                                            else {
2150                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
2151                                            }
2152                                    }
2153                                    else {
2154                                            if (orderByComparator.isAscending() ^ previous) {
2155                                                    query.append(WHERE_GREATER_THAN);
2156                                            }
2157                                            else {
2158                                                    query.append(WHERE_LESSER_THAN);
2159                                            }
2160                                    }
2161                            }
2162    
2163                            query.append(ORDER_BY_CLAUSE);
2164    
2165                            for (int i = 0; i < orderByFields.length; i++) {
2166                                    query.append(_ORDER_BY_ENTITY_ALIAS);
2167                                    query.append(orderByFields[i]);
2168    
2169                                    if ((i + 1) < orderByFields.length) {
2170                                            if (orderByComparator.isAscending() ^ previous) {
2171                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
2172                                            }
2173                                            else {
2174                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
2175                                            }
2176                                    }
2177                                    else {
2178                                            if (orderByComparator.isAscending() ^ previous) {
2179                                                    query.append(ORDER_BY_ASC);
2180                                            }
2181                                            else {
2182                                                    query.append(ORDER_BY_DESC);
2183                                            }
2184                                    }
2185                            }
2186                    }
2187    
2188                    else {
2189                            query.append(DLFileEntryModelImpl.ORDER_BY_JPQL);
2190                    }
2191    
2192                    String sql = query.toString();
2193    
2194                    Query q = session.createQuery(sql);
2195    
2196                    q.setFirstResult(0);
2197                    q.setMaxResults(2);
2198    
2199                    QueryPos qPos = QueryPos.getInstance(q);
2200    
2201                    qPos.add(groupId);
2202    
2203                    qPos.add(folderId);
2204    
2205                    if (orderByComparator != null) {
2206                            Object[] values = orderByComparator.getOrderByValues(dlFileEntry);
2207    
2208                            for (Object value : values) {
2209                                    qPos.add(value);
2210                            }
2211                    }
2212    
2213                    List<DLFileEntry> list = q.list();
2214    
2215                    if (list.size() == 2) {
2216                            return list.get(1);
2217                    }
2218                    else {
2219                            return null;
2220                    }
2221            }
2222    
2223            public List<DLFileEntry> findByG_F(long groupId, long[] folderIds)
2224                    throws SystemException {
2225                    return findByG_F(groupId, folderIds, QueryUtil.ALL_POS,
2226                            QueryUtil.ALL_POS, null);
2227            }
2228    
2229            public List<DLFileEntry> findByG_F(long groupId, long[] folderIds,
2230                    int start, int end) throws SystemException {
2231                    return findByG_F(groupId, folderIds, start, end, null);
2232            }
2233    
2234            public List<DLFileEntry> findByG_F(long groupId, long[] folderIds,
2235                    int start, int end, OrderByComparator orderByComparator)
2236                    throws SystemException {
2237                    Object[] finderArgs = new Object[] {
2238                                    groupId, StringUtil.merge(folderIds),
2239                                    
2240                                    String.valueOf(start), String.valueOf(end),
2241                                    String.valueOf(orderByComparator)
2242                            };
2243    
2244                    List<DLFileEntry> list = (List<DLFileEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_F,
2245                                    finderArgs, this);
2246    
2247                    if (list == null) {
2248                            Session session = null;
2249    
2250                            try {
2251                                    session = openSession();
2252    
2253                                    StringBundler query = new StringBundler();
2254    
2255                                    query.append(_SQL_SELECT_DLFILEENTRY_WHERE);
2256    
2257                                    boolean conjunctionable = false;
2258    
2259                                    if (conjunctionable) {
2260                                            query.append(WHERE_AND);
2261                                    }
2262    
2263                                    query.append(_FINDER_COLUMN_G_F_GROUPID_5);
2264    
2265                                    conjunctionable = true;
2266    
2267                                    if ((folderIds == null) || (folderIds.length > 0)) {
2268                                            if (conjunctionable) {
2269                                                    query.append(WHERE_AND);
2270                                            }
2271    
2272                                            query.append(StringPool.OPEN_PARENTHESIS);
2273    
2274                                            for (int i = 0; i < folderIds.length; i++) {
2275                                                    query.append(_FINDER_COLUMN_G_F_FOLDERID_5);
2276    
2277                                                    if ((i + 1) < folderIds.length) {
2278                                                            query.append(WHERE_OR);
2279                                                    }
2280                                            }
2281    
2282                                            query.append(StringPool.CLOSE_PARENTHESIS);
2283    
2284                                            conjunctionable = true;
2285                                    }
2286    
2287                                    if (orderByComparator != null) {
2288                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2289                                                    orderByComparator);
2290                                    }
2291    
2292                                    else {
2293                                            query.append(DLFileEntryModelImpl.ORDER_BY_JPQL);
2294                                    }
2295    
2296                                    String sql = query.toString();
2297    
2298                                    Query q = session.createQuery(sql);
2299    
2300                                    QueryPos qPos = QueryPos.getInstance(q);
2301    
2302                                    qPos.add(groupId);
2303    
2304                                    if (folderIds != null) {
2305                                            qPos.add(folderIds);
2306                                    }
2307    
2308                                    list = (List<DLFileEntry>)QueryUtil.list(q, getDialect(),
2309                                                    start, end);
2310                            }
2311                            catch (Exception e) {
2312                                    throw processException(e);
2313                            }
2314                            finally {
2315                                    if (list == null) {
2316                                            list = new ArrayList<DLFileEntry>();
2317                                    }
2318    
2319                                    cacheResult(list);
2320    
2321                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_F, finderArgs,
2322                                            list);
2323    
2324                                    closeSession(session);
2325                            }
2326                    }
2327    
2328                    return list;
2329            }
2330    
2331            public List<DLFileEntry> filterFindByG_F(long groupId, long folderId)
2332                    throws SystemException {
2333                    return filterFindByG_F(groupId, folderId, QueryUtil.ALL_POS,
2334                            QueryUtil.ALL_POS, null);
2335            }
2336    
2337            public List<DLFileEntry> filterFindByG_F(long groupId, long folderId,
2338                    int start, int end) throws SystemException {
2339                    return filterFindByG_F(groupId, folderId, start, end, null);
2340            }
2341    
2342            public List<DLFileEntry> filterFindByG_F(long groupId, long folderId,
2343                    int start, int end, OrderByComparator orderByComparator)
2344                    throws SystemException {
2345                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
2346                            return findByG_F(groupId, folderId, start, end, orderByComparator);
2347                    }
2348    
2349                    Session session = null;
2350    
2351                    try {
2352                            session = openSession();
2353    
2354                            StringBundler query = null;
2355    
2356                            if (orderByComparator != null) {
2357                                    query = new StringBundler(4 +
2358                                                    (orderByComparator.getOrderByFields().length * 3));
2359                            }
2360                            else {
2361                                    query = new StringBundler(4);
2362                            }
2363    
2364                            query.append(_FILTER_SQL_SELECT_DLFILEENTRY_WHERE);
2365    
2366                            query.append(_FINDER_COLUMN_G_F_GROUPID_2);
2367    
2368                            query.append(_FINDER_COLUMN_G_F_FOLDERID_2);
2369    
2370                            if (orderByComparator != null) {
2371                                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2372                                            orderByComparator);
2373                            }
2374    
2375                            else {
2376                                    query.append(DLFileEntryModelImpl.ORDER_BY_JPQL);
2377                            }
2378    
2379                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
2380                                            DLFileEntry.class.getName(), _FILTER_COLUMN_PK,
2381                                            _FILTER_COLUMN_USERID, groupId);
2382    
2383                            SQLQuery q = session.createSQLQuery(sql);
2384    
2385                            q.addEntity(_FILTER_ENTITY_ALIAS, DLFileEntryImpl.class);
2386    
2387                            QueryPos qPos = QueryPos.getInstance(q);
2388    
2389                            qPos.add(groupId);
2390    
2391                            qPos.add(folderId);
2392    
2393                            return (List<DLFileEntry>)QueryUtil.list(q, getDialect(), start, end);
2394                    }
2395                    catch (Exception e) {
2396                            throw processException(e);
2397                    }
2398                    finally {
2399                            closeSession(session);
2400                    }
2401            }
2402    
2403            public List<DLFileEntry> filterFindByG_F(long groupId, long[] folderIds)
2404                    throws SystemException {
2405                    return filterFindByG_F(groupId, folderIds, QueryUtil.ALL_POS,
2406                            QueryUtil.ALL_POS, null);
2407            }
2408    
2409            public List<DLFileEntry> filterFindByG_F(long groupId, long[] folderIds,
2410                    int start, int end) throws SystemException {
2411                    return filterFindByG_F(groupId, folderIds, start, end, null);
2412            }
2413    
2414            public List<DLFileEntry> filterFindByG_F(long groupId, long[] folderIds,
2415                    int start, int end, OrderByComparator orderByComparator)
2416                    throws SystemException {
2417                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
2418                            return findByG_F(groupId, folderIds, start, end, orderByComparator);
2419                    }
2420    
2421                    Session session = null;
2422    
2423                    try {
2424                            session = openSession();
2425    
2426                            StringBundler query = new StringBundler();
2427    
2428                            query.append(_FILTER_SQL_SELECT_DLFILEENTRY_WHERE);
2429    
2430                            boolean conjunctionable = false;
2431    
2432                            if (conjunctionable) {
2433                                    query.append(WHERE_AND);
2434                            }
2435    
2436                            query.append(_FINDER_COLUMN_G_F_GROUPID_5);
2437    
2438                            conjunctionable = true;
2439    
2440                            if ((folderIds == null) || (folderIds.length > 0)) {
2441                                    if (conjunctionable) {
2442                                            query.append(WHERE_AND);
2443                                    }
2444    
2445                                    query.append(StringPool.OPEN_PARENTHESIS);
2446    
2447                                    for (int i = 0; i < folderIds.length; i++) {
2448                                            query.append(_FINDER_COLUMN_G_F_FOLDERID_5);
2449    
2450                                            if ((i + 1) < folderIds.length) {
2451                                                    query.append(WHERE_OR);
2452                                            }
2453                                    }
2454    
2455                                    query.append(StringPool.CLOSE_PARENTHESIS);
2456    
2457                                    conjunctionable = true;
2458                            }
2459    
2460                            if (orderByComparator != null) {
2461                                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2462                                            orderByComparator);
2463                            }
2464    
2465                            else {
2466                                    query.append(DLFileEntryModelImpl.ORDER_BY_JPQL);
2467                            }
2468    
2469                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
2470                                            DLFileEntry.class.getName(), _FILTER_COLUMN_PK,
2471                                            _FILTER_COLUMN_USERID, groupId);
2472    
2473                            SQLQuery q = session.createSQLQuery(sql);
2474    
2475                            q.addEntity(_FILTER_ENTITY_ALIAS, DLFileEntryImpl.class);
2476    
2477                            QueryPos qPos = QueryPos.getInstance(q);
2478    
2479                            qPos.add(groupId);
2480    
2481                            if (folderIds != null) {
2482                                    qPos.add(folderIds);
2483                            }
2484    
2485                            return (List<DLFileEntry>)QueryUtil.list(q, getDialect(), start, end);
2486                    }
2487                    catch (Exception e) {
2488                            throw processException(e);
2489                    }
2490                    finally {
2491                            closeSession(session);
2492                    }
2493            }
2494    
2495            public List<DLFileEntry> findByG_U_F(long groupId, long userId,
2496                    long folderId) throws SystemException {
2497                    return findByG_U_F(groupId, userId, folderId, QueryUtil.ALL_POS,
2498                            QueryUtil.ALL_POS, null);
2499            }
2500    
2501            public List<DLFileEntry> findByG_U_F(long groupId, long userId,
2502                    long folderId, int start, int end) throws SystemException {
2503                    return findByG_U_F(groupId, userId, folderId, start, end, null);
2504            }
2505    
2506            public List<DLFileEntry> findByG_U_F(long groupId, long userId,
2507                    long folderId, int start, int end, OrderByComparator orderByComparator)
2508                    throws SystemException {
2509                    Object[] finderArgs = new Object[] {
2510                                    groupId, userId, folderId,
2511                                    
2512                                    String.valueOf(start), String.valueOf(end),
2513                                    String.valueOf(orderByComparator)
2514                            };
2515    
2516                    List<DLFileEntry> list = (List<DLFileEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_U_F,
2517                                    finderArgs, this);
2518    
2519                    if (list == null) {
2520                            Session session = null;
2521    
2522                            try {
2523                                    session = openSession();
2524    
2525                                    StringBundler query = null;
2526    
2527                                    if (orderByComparator != null) {
2528                                            query = new StringBundler(5 +
2529                                                            (orderByComparator.getOrderByFields().length * 3));
2530                                    }
2531                                    else {
2532                                            query = new StringBundler(5);
2533                                    }
2534    
2535                                    query.append(_SQL_SELECT_DLFILEENTRY_WHERE);
2536    
2537                                    query.append(_FINDER_COLUMN_G_U_F_GROUPID_2);
2538    
2539                                    query.append(_FINDER_COLUMN_G_U_F_USERID_2);
2540    
2541                                    query.append(_FINDER_COLUMN_G_U_F_FOLDERID_2);
2542    
2543                                    if (orderByComparator != null) {
2544                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2545                                                    orderByComparator);
2546                                    }
2547    
2548                                    else {
2549                                            query.append(DLFileEntryModelImpl.ORDER_BY_JPQL);
2550                                    }
2551    
2552                                    String sql = query.toString();
2553    
2554                                    Query q = session.createQuery(sql);
2555    
2556                                    QueryPos qPos = QueryPos.getInstance(q);
2557    
2558                                    qPos.add(groupId);
2559    
2560                                    qPos.add(userId);
2561    
2562                                    qPos.add(folderId);
2563    
2564                                    list = (List<DLFileEntry>)QueryUtil.list(q, getDialect(),
2565                                                    start, end);
2566                            }
2567                            catch (Exception e) {
2568                                    throw processException(e);
2569                            }
2570                            finally {
2571                                    if (list == null) {
2572                                            list = new ArrayList<DLFileEntry>();
2573                                    }
2574    
2575                                    cacheResult(list);
2576    
2577                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_U_F,
2578                                            finderArgs, list);
2579    
2580                                    closeSession(session);
2581                            }
2582                    }
2583    
2584                    return list;
2585            }
2586    
2587            public DLFileEntry findByG_U_F_First(long groupId, long userId,
2588                    long folderId, OrderByComparator orderByComparator)
2589                    throws NoSuchFileEntryException, SystemException {
2590                    List<DLFileEntry> list = findByG_U_F(groupId, userId, folderId, 0, 1,
2591                                    orderByComparator);
2592    
2593                    if (list.isEmpty()) {
2594                            StringBundler msg = new StringBundler(8);
2595    
2596                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2597    
2598                            msg.append("groupId=");
2599                            msg.append(groupId);
2600    
2601                            msg.append(", userId=");
2602                            msg.append(userId);
2603    
2604                            msg.append(", folderId=");
2605                            msg.append(folderId);
2606    
2607                            msg.append(StringPool.CLOSE_CURLY_BRACE);
2608    
2609                            throw new NoSuchFileEntryException(msg.toString());
2610                    }
2611                    else {
2612                            return list.get(0);
2613                    }
2614            }
2615    
2616            public DLFileEntry findByG_U_F_Last(long groupId, long userId,
2617                    long folderId, OrderByComparator orderByComparator)
2618                    throws NoSuchFileEntryException, SystemException {
2619                    int count = countByG_U_F(groupId, userId, folderId);
2620    
2621                    List<DLFileEntry> list = findByG_U_F(groupId, userId, folderId,
2622                                    count - 1, count, orderByComparator);
2623    
2624                    if (list.isEmpty()) {
2625                            StringBundler msg = new StringBundler(8);
2626    
2627                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2628    
2629                            msg.append("groupId=");
2630                            msg.append(groupId);
2631    
2632                            msg.append(", userId=");
2633                            msg.append(userId);
2634    
2635                            msg.append(", folderId=");
2636                            msg.append(folderId);
2637    
2638                            msg.append(StringPool.CLOSE_CURLY_BRACE);
2639    
2640                            throw new NoSuchFileEntryException(msg.toString());
2641                    }
2642                    else {
2643                            return list.get(0);
2644                    }
2645            }
2646    
2647            public DLFileEntry[] findByG_U_F_PrevAndNext(long fileEntryId,
2648                    long groupId, long userId, long folderId,
2649                    OrderByComparator orderByComparator)
2650                    throws NoSuchFileEntryException, SystemException {
2651                    DLFileEntry dlFileEntry = findByPrimaryKey(fileEntryId);
2652    
2653                    Session session = null;
2654    
2655                    try {
2656                            session = openSession();
2657    
2658                            DLFileEntry[] array = new DLFileEntryImpl[3];
2659    
2660                            array[0] = getByG_U_F_PrevAndNext(session, dlFileEntry, groupId,
2661                                            userId, folderId, orderByComparator, true);
2662    
2663                            array[1] = dlFileEntry;
2664    
2665                            array[2] = getByG_U_F_PrevAndNext(session, dlFileEntry, groupId,
2666                                            userId, folderId, orderByComparator, false);
2667    
2668                            return array;
2669                    }
2670                    catch (Exception e) {
2671                            throw processException(e);
2672                    }
2673                    finally {
2674                            closeSession(session);
2675                    }
2676            }
2677    
2678            protected DLFileEntry getByG_U_F_PrevAndNext(Session session,
2679                    DLFileEntry dlFileEntry, long groupId, long userId, long folderId,
2680                    OrderByComparator orderByComparator, boolean previous) {
2681                    StringBundler query = null;
2682    
2683                    if (orderByComparator != null) {
2684                            query = new StringBundler(6 +
2685                                            (orderByComparator.getOrderByFields().length * 6));
2686                    }
2687                    else {
2688                            query = new StringBundler(3);
2689                    }
2690    
2691                    query.append(_SQL_SELECT_DLFILEENTRY_WHERE);
2692    
2693                    query.append(_FINDER_COLUMN_G_U_F_GROUPID_2);
2694    
2695                    query.append(_FINDER_COLUMN_G_U_F_USERID_2);
2696    
2697                    query.append(_FINDER_COLUMN_G_U_F_FOLDERID_2);
2698    
2699                    if (orderByComparator != null) {
2700                            String[] orderByFields = orderByComparator.getOrderByFields();
2701    
2702                            if (orderByFields.length > 0) {
2703                                    query.append(WHERE_AND);
2704                            }
2705    
2706                            for (int i = 0; i < orderByFields.length; i++) {
2707                                    query.append(_ORDER_BY_ENTITY_ALIAS);
2708                                    query.append(orderByFields[i]);
2709    
2710                                    if ((i + 1) < orderByFields.length) {
2711                                            if (orderByComparator.isAscending() ^ previous) {
2712                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
2713                                            }
2714                                            else {
2715                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
2716                                            }
2717                                    }
2718                                    else {
2719                                            if (orderByComparator.isAscending() ^ previous) {
2720                                                    query.append(WHERE_GREATER_THAN);
2721                                            }
2722                                            else {
2723                                                    query.append(WHERE_LESSER_THAN);
2724                                            }
2725                                    }
2726                            }
2727    
2728                            query.append(ORDER_BY_CLAUSE);
2729    
2730                            for (int i = 0; i < orderByFields.length; i++) {
2731                                    query.append(_ORDER_BY_ENTITY_ALIAS);
2732                                    query.append(orderByFields[i]);
2733    
2734                                    if ((i + 1) < orderByFields.length) {
2735                                            if (orderByComparator.isAscending() ^ previous) {
2736                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
2737                                            }
2738                                            else {
2739                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
2740                                            }
2741                                    }
2742                                    else {
2743                                            if (orderByComparator.isAscending() ^ previous) {
2744                                                    query.append(ORDER_BY_ASC);
2745                                            }
2746                                            else {
2747                                                    query.append(ORDER_BY_DESC);
2748                                            }
2749                                    }
2750                            }
2751                    }
2752    
2753                    else {
2754                            query.append(DLFileEntryModelImpl.ORDER_BY_JPQL);
2755                    }
2756    
2757                    String sql = query.toString();
2758    
2759                    Query q = session.createQuery(sql);
2760    
2761                    q.setFirstResult(0);
2762                    q.setMaxResults(2);
2763    
2764                    QueryPos qPos = QueryPos.getInstance(q);
2765    
2766                    qPos.add(groupId);
2767    
2768                    qPos.add(userId);
2769    
2770                    qPos.add(folderId);
2771    
2772                    if (orderByComparator != null) {
2773                            Object[] values = orderByComparator.getOrderByValues(dlFileEntry);
2774    
2775                            for (Object value : values) {
2776                                    qPos.add(value);
2777                            }
2778                    }
2779    
2780                    List<DLFileEntry> list = q.list();
2781    
2782                    if (list.size() == 2) {
2783                            return list.get(1);
2784                    }
2785                    else {
2786                            return null;
2787                    }
2788            }
2789    
2790            public List<DLFileEntry> findByG_U_F(long groupId, long userId,
2791                    long[] folderIds) throws SystemException {
2792                    return findByG_U_F(groupId, userId, folderIds, QueryUtil.ALL_POS,
2793                            QueryUtil.ALL_POS, null);
2794            }
2795    
2796            public List<DLFileEntry> findByG_U_F(long groupId, long userId,
2797                    long[] folderIds, int start, int end) throws SystemException {
2798                    return findByG_U_F(groupId, userId, folderIds, start, end, null);
2799            }
2800    
2801            public List<DLFileEntry> findByG_U_F(long groupId, long userId,
2802                    long[] folderIds, int start, int end,
2803                    OrderByComparator orderByComparator) throws SystemException {
2804                    Object[] finderArgs = new Object[] {
2805                                    groupId, userId, StringUtil.merge(folderIds),
2806                                    
2807                                    String.valueOf(start), String.valueOf(end),
2808                                    String.valueOf(orderByComparator)
2809                            };
2810    
2811                    List<DLFileEntry> list = (List<DLFileEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_U_F,
2812                                    finderArgs, this);
2813    
2814                    if (list == null) {
2815                            Session session = null;
2816    
2817                            try {
2818                                    session = openSession();
2819    
2820                                    StringBundler query = new StringBundler();
2821    
2822                                    query.append(_SQL_SELECT_DLFILEENTRY_WHERE);
2823    
2824                                    boolean conjunctionable = false;
2825    
2826                                    if (conjunctionable) {
2827                                            query.append(WHERE_AND);
2828                                    }
2829    
2830                                    query.append(_FINDER_COLUMN_G_U_F_GROUPID_5);
2831    
2832                                    conjunctionable = true;
2833    
2834                                    if (conjunctionable) {
2835                                            query.append(WHERE_AND);
2836                                    }
2837    
2838                                    query.append(_FINDER_COLUMN_G_U_F_USERID_5);
2839    
2840                                    conjunctionable = true;
2841    
2842                                    if ((folderIds == null) || (folderIds.length > 0)) {
2843                                            if (conjunctionable) {
2844                                                    query.append(WHERE_AND);
2845                                            }
2846    
2847                                            query.append(StringPool.OPEN_PARENTHESIS);
2848    
2849                                            for (int i = 0; i < folderIds.length; i++) {
2850                                                    query.append(_FINDER_COLUMN_G_U_F_FOLDERID_5);
2851    
2852                                                    if ((i + 1) < folderIds.length) {
2853                                                            query.append(WHERE_OR);
2854                                                    }
2855                                            }
2856    
2857                                            query.append(StringPool.CLOSE_PARENTHESIS);
2858    
2859                                            conjunctionable = true;
2860                                    }
2861    
2862                                    if (orderByComparator != null) {
2863                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2864                                                    orderByComparator);
2865                                    }
2866    
2867                                    else {
2868                                            query.append(DLFileEntryModelImpl.ORDER_BY_JPQL);
2869                                    }
2870    
2871                                    String sql = query.toString();
2872    
2873                                    Query q = session.createQuery(sql);
2874    
2875                                    QueryPos qPos = QueryPos.getInstance(q);
2876    
2877                                    qPos.add(groupId);
2878    
2879                                    qPos.add(userId);
2880    
2881                                    if (folderIds != null) {
2882                                            qPos.add(folderIds);
2883                                    }
2884    
2885                                    list = (List<DLFileEntry>)QueryUtil.list(q, getDialect(),
2886                                                    start, end);
2887                            }
2888                            catch (Exception e) {
2889                                    throw processException(e);
2890                            }
2891                            finally {
2892                                    if (list == null) {
2893                                            list = new ArrayList<DLFileEntry>();
2894                                    }
2895    
2896                                    cacheResult(list);
2897    
2898                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_U_F,
2899                                            finderArgs, list);
2900    
2901                                    closeSession(session);
2902                            }
2903                    }
2904    
2905                    return list;
2906            }
2907    
2908            public List<DLFileEntry> filterFindByG_U_F(long groupId, long userId,
2909                    long folderId) throws SystemException {
2910                    return filterFindByG_U_F(groupId, userId, folderId, QueryUtil.ALL_POS,
2911                            QueryUtil.ALL_POS, null);
2912            }
2913    
2914            public List<DLFileEntry> filterFindByG_U_F(long groupId, long userId,
2915                    long folderId, int start, int end) throws SystemException {
2916                    return filterFindByG_U_F(groupId, userId, folderId, start, end, null);
2917            }
2918    
2919            public List<DLFileEntry> filterFindByG_U_F(long groupId, long userId,
2920                    long folderId, int start, int end, OrderByComparator orderByComparator)
2921                    throws SystemException {
2922                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
2923                            return findByG_U_F(groupId, userId, folderId, start, end,
2924                                    orderByComparator);
2925                    }
2926    
2927                    Session session = null;
2928    
2929                    try {
2930                            session = openSession();
2931    
2932                            StringBundler query = null;
2933    
2934                            if (orderByComparator != null) {
2935                                    query = new StringBundler(5 +
2936                                                    (orderByComparator.getOrderByFields().length * 3));
2937                            }
2938                            else {
2939                                    query = new StringBundler(5);
2940                            }
2941    
2942                            query.append(_FILTER_SQL_SELECT_DLFILEENTRY_WHERE);
2943    
2944                            query.append(_FINDER_COLUMN_G_U_F_GROUPID_2);
2945    
2946                            query.append(_FINDER_COLUMN_G_U_F_USERID_2);
2947    
2948                            query.append(_FINDER_COLUMN_G_U_F_FOLDERID_2);
2949    
2950                            if (orderByComparator != null) {
2951                                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2952                                            orderByComparator);
2953                            }
2954    
2955                            else {
2956                                    query.append(DLFileEntryModelImpl.ORDER_BY_JPQL);
2957                            }
2958    
2959                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
2960                                            DLFileEntry.class.getName(), _FILTER_COLUMN_PK,
2961                                            _FILTER_COLUMN_USERID, groupId);
2962    
2963                            SQLQuery q = session.createSQLQuery(sql);
2964    
2965                            q.addEntity(_FILTER_ENTITY_ALIAS, DLFileEntryImpl.class);
2966    
2967                            QueryPos qPos = QueryPos.getInstance(q);
2968    
2969                            qPos.add(groupId);
2970    
2971                            qPos.add(userId);
2972    
2973                            qPos.add(folderId);
2974    
2975                            return (List<DLFileEntry>)QueryUtil.list(q, getDialect(), start, end);
2976                    }
2977                    catch (Exception e) {
2978                            throw processException(e);
2979                    }
2980                    finally {
2981                            closeSession(session);
2982                    }
2983            }
2984    
2985            public List<DLFileEntry> filterFindByG_U_F(long groupId, long userId,
2986                    long[] folderIds) throws SystemException {
2987                    return filterFindByG_U_F(groupId, userId, folderIds, QueryUtil.ALL_POS,
2988                            QueryUtil.ALL_POS, null);
2989            }
2990    
2991            public List<DLFileEntry> filterFindByG_U_F(long groupId, long userId,
2992                    long[] folderIds, int start, int end) throws SystemException {
2993                    return filterFindByG_U_F(groupId, userId, folderIds, start, end, null);
2994            }
2995    
2996            public List<DLFileEntry> filterFindByG_U_F(long groupId, long userId,
2997                    long[] folderIds, int start, int end,
2998                    OrderByComparator orderByComparator) throws SystemException {
2999                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
3000                            return findByG_U_F(groupId, userId, folderIds, start, end,
3001                                    orderByComparator);
3002                    }
3003    
3004                    Session session = null;
3005    
3006                    try {
3007                            session = openSession();
3008    
3009                            StringBundler query = new StringBundler();
3010    
3011                            query.append(_FILTER_SQL_SELECT_DLFILEENTRY_WHERE);
3012    
3013                            boolean conjunctionable = false;
3014    
3015                            if (conjunctionable) {
3016                                    query.append(WHERE_AND);
3017                            }
3018    
3019                            query.append(_FINDER_COLUMN_G_U_F_GROUPID_5);
3020    
3021                            conjunctionable = true;
3022    
3023                            if (conjunctionable) {
3024                                    query.append(WHERE_AND);
3025                            }
3026    
3027                            query.append(_FINDER_COLUMN_G_U_F_USERID_5);
3028    
3029                            conjunctionable = true;
3030    
3031                            if ((folderIds == null) || (folderIds.length > 0)) {
3032                                    if (conjunctionable) {
3033                                            query.append(WHERE_AND);
3034                                    }
3035    
3036                                    query.append(StringPool.OPEN_PARENTHESIS);
3037    
3038                                    for (int i = 0; i < folderIds.length; i++) {
3039                                            query.append(_FINDER_COLUMN_G_U_F_FOLDERID_5);
3040    
3041                                            if ((i + 1) < folderIds.length) {
3042                                                    query.append(WHERE_OR);
3043                                            }
3044                                    }
3045    
3046                                    query.append(StringPool.CLOSE_PARENTHESIS);
3047    
3048                                    conjunctionable = true;
3049                            }
3050    
3051                            if (orderByComparator != null) {
3052                                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
3053                                            orderByComparator);
3054                            }
3055    
3056                            else {
3057                                    query.append(DLFileEntryModelImpl.ORDER_BY_JPQL);
3058                            }
3059    
3060                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
3061                                            DLFileEntry.class.getName(), _FILTER_COLUMN_PK,
3062                                            _FILTER_COLUMN_USERID, groupId);
3063    
3064                            SQLQuery q = session.createSQLQuery(sql);
3065    
3066                            q.addEntity(_FILTER_ENTITY_ALIAS, DLFileEntryImpl.class);
3067    
3068                            QueryPos qPos = QueryPos.getInstance(q);
3069    
3070                            qPos.add(groupId);
3071    
3072                            qPos.add(userId);
3073    
3074                            if (folderIds != null) {
3075                                    qPos.add(folderIds);
3076                            }
3077    
3078                            return (List<DLFileEntry>)QueryUtil.list(q, getDialect(), start, end);
3079                    }
3080                    catch (Exception e) {
3081                            throw processException(e);
3082                    }
3083                    finally {
3084                            closeSession(session);
3085                    }
3086            }
3087    
3088            public DLFileEntry findByG_F_N(long groupId, long folderId, String name)
3089                    throws NoSuchFileEntryException, SystemException {
3090                    DLFileEntry dlFileEntry = fetchByG_F_N(groupId, folderId, name);
3091    
3092                    if (dlFileEntry == null) {
3093                            StringBundler msg = new StringBundler(8);
3094    
3095                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
3096    
3097                            msg.append("groupId=");
3098                            msg.append(groupId);
3099    
3100                            msg.append(", folderId=");
3101                            msg.append(folderId);
3102    
3103                            msg.append(", name=");
3104                            msg.append(name);
3105    
3106                            msg.append(StringPool.CLOSE_CURLY_BRACE);
3107    
3108                            if (_log.isWarnEnabled()) {
3109                                    _log.warn(msg.toString());
3110                            }
3111    
3112                            throw new NoSuchFileEntryException(msg.toString());
3113                    }
3114    
3115                    return dlFileEntry;
3116            }
3117    
3118            public DLFileEntry fetchByG_F_N(long groupId, long folderId, String name)
3119                    throws SystemException {
3120                    return fetchByG_F_N(groupId, folderId, name, true);
3121            }
3122    
3123            public DLFileEntry fetchByG_F_N(long groupId, long folderId, String name,
3124                    boolean retrieveFromCache) throws SystemException {
3125                    Object[] finderArgs = new Object[] { groupId, folderId, name };
3126    
3127                    Object result = null;
3128    
3129                    if (retrieveFromCache) {
3130                            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_G_F_N,
3131                                            finderArgs, this);
3132                    }
3133    
3134                    if (result == null) {
3135                            Session session = null;
3136    
3137                            try {
3138                                    session = openSession();
3139    
3140                                    StringBundler query = new StringBundler(5);
3141    
3142                                    query.append(_SQL_SELECT_DLFILEENTRY_WHERE);
3143    
3144                                    query.append(_FINDER_COLUMN_G_F_N_GROUPID_2);
3145    
3146                                    query.append(_FINDER_COLUMN_G_F_N_FOLDERID_2);
3147    
3148                                    if (name == null) {
3149                                            query.append(_FINDER_COLUMN_G_F_N_NAME_1);
3150                                    }
3151                                    else {
3152                                            if (name.equals(StringPool.BLANK)) {
3153                                                    query.append(_FINDER_COLUMN_G_F_N_NAME_3);
3154                                            }
3155                                            else {
3156                                                    query.append(_FINDER_COLUMN_G_F_N_NAME_2);
3157                                            }
3158                                    }
3159    
3160                                    query.append(DLFileEntryModelImpl.ORDER_BY_JPQL);
3161    
3162                                    String sql = query.toString();
3163    
3164                                    Query q = session.createQuery(sql);
3165    
3166                                    QueryPos qPos = QueryPos.getInstance(q);
3167    
3168                                    qPos.add(groupId);
3169    
3170                                    qPos.add(folderId);
3171    
3172                                    if (name != null) {
3173                                            qPos.add(name);
3174                                    }
3175    
3176                                    List<DLFileEntry> list = q.list();
3177    
3178                                    result = list;
3179    
3180                                    DLFileEntry dlFileEntry = null;
3181    
3182                                    if (list.isEmpty()) {
3183                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_F_N,
3184                                                    finderArgs, list);
3185                                    }
3186                                    else {
3187                                            dlFileEntry = list.get(0);
3188    
3189                                            cacheResult(dlFileEntry);
3190    
3191                                            if ((dlFileEntry.getGroupId() != groupId) ||
3192                                                            (dlFileEntry.getFolderId() != folderId) ||
3193                                                            (dlFileEntry.getName() == null) ||
3194                                                            !dlFileEntry.getName().equals(name)) {
3195                                                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_F_N,
3196                                                            finderArgs, dlFileEntry);
3197                                            }
3198                                    }
3199    
3200                                    return dlFileEntry;
3201                            }
3202                            catch (Exception e) {
3203                                    throw processException(e);
3204                            }
3205                            finally {
3206                                    if (result == null) {
3207                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_F_N,
3208                                                    finderArgs, new ArrayList<DLFileEntry>());
3209                                    }
3210    
3211                                    closeSession(session);
3212                            }
3213                    }
3214                    else {
3215                            if (result instanceof List<?>) {
3216                                    return null;
3217                            }
3218                            else {
3219                                    return (DLFileEntry)result;
3220                            }
3221                    }
3222            }
3223    
3224            public DLFileEntry findByG_F_T(long groupId, long folderId, String title)
3225                    throws NoSuchFileEntryException, SystemException {
3226                    DLFileEntry dlFileEntry = fetchByG_F_T(groupId, folderId, title);
3227    
3228                    if (dlFileEntry == null) {
3229                            StringBundler msg = new StringBundler(8);
3230    
3231                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
3232    
3233                            msg.append("groupId=");
3234                            msg.append(groupId);
3235    
3236                            msg.append(", folderId=");
3237                            msg.append(folderId);
3238    
3239                            msg.append(", title=");
3240                            msg.append(title);
3241    
3242                            msg.append(StringPool.CLOSE_CURLY_BRACE);
3243    
3244                            if (_log.isWarnEnabled()) {
3245                                    _log.warn(msg.toString());
3246                            }
3247    
3248                            throw new NoSuchFileEntryException(msg.toString());
3249                    }
3250    
3251                    return dlFileEntry;
3252            }
3253    
3254            public DLFileEntry fetchByG_F_T(long groupId, long folderId, String title)
3255                    throws SystemException {
3256                    return fetchByG_F_T(groupId, folderId, title, true);
3257            }
3258    
3259            public DLFileEntry fetchByG_F_T(long groupId, long folderId, String title,
3260                    boolean retrieveFromCache) throws SystemException {
3261                    Object[] finderArgs = new Object[] { groupId, folderId, title };
3262    
3263                    Object result = null;
3264    
3265                    if (retrieveFromCache) {
3266                            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_G_F_T,
3267                                            finderArgs, this);
3268                    }
3269    
3270                    if (result == null) {
3271                            Session session = null;
3272    
3273                            try {
3274                                    session = openSession();
3275    
3276                                    StringBundler query = new StringBundler(5);
3277    
3278                                    query.append(_SQL_SELECT_DLFILEENTRY_WHERE);
3279    
3280                                    query.append(_FINDER_COLUMN_G_F_T_GROUPID_2);
3281    
3282                                    query.append(_FINDER_COLUMN_G_F_T_FOLDERID_2);
3283    
3284                                    if (title == null) {
3285                                            query.append(_FINDER_COLUMN_G_F_T_TITLE_1);
3286                                    }
3287                                    else {
3288                                            if (title.equals(StringPool.BLANK)) {
3289                                                    query.append(_FINDER_COLUMN_G_F_T_TITLE_3);
3290                                            }
3291                                            else {
3292                                                    query.append(_FINDER_COLUMN_G_F_T_TITLE_2);
3293                                            }
3294                                    }
3295    
3296                                    query.append(DLFileEntryModelImpl.ORDER_BY_JPQL);
3297    
3298                                    String sql = query.toString();
3299    
3300                                    Query q = session.createQuery(sql);
3301    
3302                                    QueryPos qPos = QueryPos.getInstance(q);
3303    
3304                                    qPos.add(groupId);
3305    
3306                                    qPos.add(folderId);
3307    
3308                                    if (title != null) {
3309                                            qPos.add(title);
3310                                    }
3311    
3312                                    List<DLFileEntry> list = q.list();
3313    
3314                                    result = list;
3315    
3316                                    DLFileEntry dlFileEntry = null;
3317    
3318                                    if (list.isEmpty()) {
3319                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_F_T,
3320                                                    finderArgs, list);
3321                                    }
3322                                    else {
3323                                            dlFileEntry = list.get(0);
3324    
3325                                            cacheResult(dlFileEntry);
3326    
3327                                            if ((dlFileEntry.getGroupId() != groupId) ||
3328                                                            (dlFileEntry.getFolderId() != folderId) ||
3329                                                            (dlFileEntry.getTitle() == null) ||
3330                                                            !dlFileEntry.getTitle().equals(title)) {
3331                                                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_F_T,
3332                                                            finderArgs, dlFileEntry);
3333                                            }
3334                                    }
3335    
3336                                    return dlFileEntry;
3337                            }
3338                            catch (Exception e) {
3339                                    throw processException(e);
3340                            }
3341                            finally {
3342                                    if (result == null) {
3343                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_F_T,
3344                                                    finderArgs, new ArrayList<DLFileEntry>());
3345                                    }
3346    
3347                                    closeSession(session);
3348                            }
3349                    }
3350                    else {
3351                            if (result instanceof List<?>) {
3352                                    return null;
3353                            }
3354                            else {
3355                                    return (DLFileEntry)result;
3356                            }
3357                    }
3358            }
3359    
3360            public List<DLFileEntry> findAll() throws SystemException {
3361                    return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
3362            }
3363    
3364            public List<DLFileEntry> findAll(int start, int end)
3365                    throws SystemException {
3366                    return findAll(start, end, null);
3367            }
3368    
3369            public List<DLFileEntry> findAll(int start, int end,
3370                    OrderByComparator orderByComparator) throws SystemException {
3371                    Object[] finderArgs = new Object[] {
3372                                    String.valueOf(start), String.valueOf(end),
3373                                    String.valueOf(orderByComparator)
3374                            };
3375    
3376                    List<DLFileEntry> list = (List<DLFileEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
3377                                    finderArgs, this);
3378    
3379                    if (list == null) {
3380                            Session session = null;
3381    
3382                            try {
3383                                    session = openSession();
3384    
3385                                    StringBundler query = null;
3386                                    String sql = null;
3387    
3388                                    if (orderByComparator != null) {
3389                                            query = new StringBundler(2 +
3390                                                            (orderByComparator.getOrderByFields().length * 3));
3391    
3392                                            query.append(_SQL_SELECT_DLFILEENTRY);
3393    
3394                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
3395                                                    orderByComparator);
3396    
3397                                            sql = query.toString();
3398                                    }
3399                                    else {
3400                                            sql = _SQL_SELECT_DLFILEENTRY.concat(DLFileEntryModelImpl.ORDER_BY_JPQL);
3401                                    }
3402    
3403                                    Query q = session.createQuery(sql);
3404    
3405                                    if (orderByComparator == null) {
3406                                            list = (List<DLFileEntry>)QueryUtil.list(q, getDialect(),
3407                                                            start, end, false);
3408    
3409                                            Collections.sort(list);
3410                                    }
3411                                    else {
3412                                            list = (List<DLFileEntry>)QueryUtil.list(q, getDialect(),
3413                                                            start, end);
3414                                    }
3415                            }
3416                            catch (Exception e) {
3417                                    throw processException(e);
3418                            }
3419                            finally {
3420                                    if (list == null) {
3421                                            list = new ArrayList<DLFileEntry>();
3422                                    }
3423    
3424                                    cacheResult(list);
3425    
3426                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
3427    
3428                                    closeSession(session);
3429                            }
3430                    }
3431    
3432                    return list;
3433            }
3434    
3435            public void removeByUuid(String uuid) throws SystemException {
3436                    for (DLFileEntry dlFileEntry : findByUuid(uuid)) {
3437                            remove(dlFileEntry);
3438                    }
3439            }
3440    
3441            public void removeByUUID_G(String uuid, long groupId)
3442                    throws NoSuchFileEntryException, SystemException {
3443                    DLFileEntry dlFileEntry = findByUUID_G(uuid, groupId);
3444    
3445                    remove(dlFileEntry);
3446            }
3447    
3448            public void removeByGroupId(long groupId) throws SystemException {
3449                    for (DLFileEntry dlFileEntry : findByGroupId(groupId)) {
3450                            remove(dlFileEntry);
3451                    }
3452            }
3453    
3454            public void removeByCompanyId(long companyId) throws SystemException {
3455                    for (DLFileEntry dlFileEntry : findByCompanyId(companyId)) {
3456                            remove(dlFileEntry);
3457                    }
3458            }
3459    
3460            public void removeByG_U(long groupId, long userId)
3461                    throws SystemException {
3462                    for (DLFileEntry dlFileEntry : findByG_U(groupId, userId)) {
3463                            remove(dlFileEntry);
3464                    }
3465            }
3466    
3467            public void removeByG_F(long groupId, long folderId)
3468                    throws SystemException {
3469                    for (DLFileEntry dlFileEntry : findByG_F(groupId, folderId)) {
3470                            remove(dlFileEntry);
3471                    }
3472            }
3473    
3474            public void removeByG_U_F(long groupId, long userId, long folderId)
3475                    throws SystemException {
3476                    for (DLFileEntry dlFileEntry : findByG_U_F(groupId, userId, folderId)) {
3477                            remove(dlFileEntry);
3478                    }
3479            }
3480    
3481            public void removeByG_F_N(long groupId, long folderId, String name)
3482                    throws NoSuchFileEntryException, SystemException {
3483                    DLFileEntry dlFileEntry = findByG_F_N(groupId, folderId, name);
3484    
3485                    remove(dlFileEntry);
3486            }
3487    
3488            public void removeByG_F_T(long groupId, long folderId, String title)
3489                    throws NoSuchFileEntryException, SystemException {
3490                    DLFileEntry dlFileEntry = findByG_F_T(groupId, folderId, title);
3491    
3492                    remove(dlFileEntry);
3493            }
3494    
3495            public void removeAll() throws SystemException {
3496                    for (DLFileEntry dlFileEntry : findAll()) {
3497                            remove(dlFileEntry);
3498                    }
3499            }
3500    
3501            public int countByUuid(String uuid) throws SystemException {
3502                    Object[] finderArgs = new Object[] { uuid };
3503    
3504                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_UUID,
3505                                    finderArgs, this);
3506    
3507                    if (count == null) {
3508                            Session session = null;
3509    
3510                            try {
3511                                    session = openSession();
3512    
3513                                    StringBundler query = new StringBundler(2);
3514    
3515                                    query.append(_SQL_COUNT_DLFILEENTRY_WHERE);
3516    
3517                                    if (uuid == null) {
3518                                            query.append(_FINDER_COLUMN_UUID_UUID_1);
3519                                    }
3520                                    else {
3521                                            if (uuid.equals(StringPool.BLANK)) {
3522                                                    query.append(_FINDER_COLUMN_UUID_UUID_3);
3523                                            }
3524                                            else {
3525                                                    query.append(_FINDER_COLUMN_UUID_UUID_2);
3526                                            }
3527                                    }
3528    
3529                                    String sql = query.toString();
3530    
3531                                    Query q = session.createQuery(sql);
3532    
3533                                    QueryPos qPos = QueryPos.getInstance(q);
3534    
3535                                    if (uuid != null) {
3536                                            qPos.add(uuid);
3537                                    }
3538    
3539                                    count = (Long)q.uniqueResult();
3540                            }
3541                            catch (Exception e) {
3542                                    throw processException(e);
3543                            }
3544                            finally {
3545                                    if (count == null) {
3546                                            count = Long.valueOf(0);
3547                                    }
3548    
3549                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID,
3550                                            finderArgs, count);
3551    
3552                                    closeSession(session);
3553                            }
3554                    }
3555    
3556                    return count.intValue();
3557            }
3558    
3559            public int countByUUID_G(String uuid, long groupId)
3560                    throws SystemException {
3561                    Object[] finderArgs = new Object[] { uuid, groupId };
3562    
3563                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_UUID_G,
3564                                    finderArgs, this);
3565    
3566                    if (count == null) {
3567                            Session session = null;
3568    
3569                            try {
3570                                    session = openSession();
3571    
3572                                    StringBundler query = new StringBundler(3);
3573    
3574                                    query.append(_SQL_COUNT_DLFILEENTRY_WHERE);
3575    
3576                                    if (uuid == null) {
3577                                            query.append(_FINDER_COLUMN_UUID_G_UUID_1);
3578                                    }
3579                                    else {
3580                                            if (uuid.equals(StringPool.BLANK)) {
3581                                                    query.append(_FINDER_COLUMN_UUID_G_UUID_3);
3582                                            }
3583                                            else {
3584                                                    query.append(_FINDER_COLUMN_UUID_G_UUID_2);
3585                                            }
3586                                    }
3587    
3588                                    query.append(_FINDER_COLUMN_UUID_G_GROUPID_2);
3589    
3590                                    String sql = query.toString();
3591    
3592                                    Query q = session.createQuery(sql);
3593    
3594                                    QueryPos qPos = QueryPos.getInstance(q);
3595    
3596                                    if (uuid != null) {
3597                                            qPos.add(uuid);
3598                                    }
3599    
3600                                    qPos.add(groupId);
3601    
3602                                    count = (Long)q.uniqueResult();
3603                            }
3604                            catch (Exception e) {
3605                                    throw processException(e);
3606                            }
3607                            finally {
3608                                    if (count == null) {
3609                                            count = Long.valueOf(0);
3610                                    }
3611    
3612                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID_G,
3613                                            finderArgs, count);
3614    
3615                                    closeSession(session);
3616                            }
3617                    }
3618    
3619                    return count.intValue();
3620            }
3621    
3622            public int countByGroupId(long groupId) throws SystemException {
3623                    Object[] finderArgs = new Object[] { groupId };
3624    
3625                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_GROUPID,
3626                                    finderArgs, this);
3627    
3628                    if (count == null) {
3629                            Session session = null;
3630    
3631                            try {
3632                                    session = openSession();
3633    
3634                                    StringBundler query = new StringBundler(2);
3635    
3636                                    query.append(_SQL_COUNT_DLFILEENTRY_WHERE);
3637    
3638                                    query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
3639    
3640                                    String sql = query.toString();
3641    
3642                                    Query q = session.createQuery(sql);
3643    
3644                                    QueryPos qPos = QueryPos.getInstance(q);
3645    
3646                                    qPos.add(groupId);
3647    
3648                                    count = (Long)q.uniqueResult();
3649                            }
3650                            catch (Exception e) {
3651                                    throw processException(e);
3652                            }
3653                            finally {
3654                                    if (count == null) {
3655                                            count = Long.valueOf(0);
3656                                    }
3657    
3658                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_GROUPID,
3659                                            finderArgs, count);
3660    
3661                                    closeSession(session);
3662                            }
3663                    }
3664    
3665                    return count.intValue();
3666            }
3667    
3668            public int filterCountByGroupId(long groupId) throws SystemException {
3669                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
3670                            return countByGroupId(groupId);
3671                    }
3672    
3673                    Session session = null;
3674    
3675                    try {
3676                            session = openSession();
3677    
3678                            StringBundler query = new StringBundler(2);
3679    
3680                            query.append(_FILTER_SQL_COUNT_DLFILEENTRY_WHERE);
3681    
3682                            query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
3683    
3684                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
3685                                            DLFileEntry.class.getName(), _FILTER_COLUMN_PK,
3686                                            _FILTER_COLUMN_USERID, groupId);
3687    
3688                            SQLQuery q = session.createSQLQuery(sql);
3689    
3690                            q.addScalar(COUNT_COLUMN_NAME,
3691                                    com.liferay.portal.kernel.dao.orm.Type.LONG);
3692    
3693                            QueryPos qPos = QueryPos.getInstance(q);
3694    
3695                            qPos.add(groupId);
3696    
3697                            Long count = (Long)q.uniqueResult();
3698    
3699                            return count.intValue();
3700                    }
3701                    catch (Exception e) {
3702                            throw processException(e);
3703                    }
3704                    finally {
3705                            closeSession(session);
3706                    }
3707            }
3708    
3709            public int countByCompanyId(long companyId) throws SystemException {
3710                    Object[] finderArgs = new Object[] { companyId };
3711    
3712                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_COMPANYID,
3713                                    finderArgs, this);
3714    
3715                    if (count == null) {
3716                            Session session = null;
3717    
3718                            try {
3719                                    session = openSession();
3720    
3721                                    StringBundler query = new StringBundler(2);
3722    
3723                                    query.append(_SQL_COUNT_DLFILEENTRY_WHERE);
3724    
3725                                    query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
3726    
3727                                    String sql = query.toString();
3728    
3729                                    Query q = session.createQuery(sql);
3730    
3731                                    QueryPos qPos = QueryPos.getInstance(q);
3732    
3733                                    qPos.add(companyId);
3734    
3735                                    count = (Long)q.uniqueResult();
3736                            }
3737                            catch (Exception e) {
3738                                    throw processException(e);
3739                            }
3740                            finally {
3741                                    if (count == null) {
3742                                            count = Long.valueOf(0);
3743                                    }
3744    
3745                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_COMPANYID,
3746                                            finderArgs, count);
3747    
3748                                    closeSession(session);
3749                            }
3750                    }
3751    
3752                    return count.intValue();
3753            }
3754    
3755            public int countByG_U(long groupId, long userId) throws SystemException {
3756                    Object[] finderArgs = new Object[] { groupId, userId };
3757    
3758                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_U,
3759                                    finderArgs, this);
3760    
3761                    if (count == null) {
3762                            Session session = null;
3763    
3764                            try {
3765                                    session = openSession();
3766    
3767                                    StringBundler query = new StringBundler(3);
3768    
3769                                    query.append(_SQL_COUNT_DLFILEENTRY_WHERE);
3770    
3771                                    query.append(_FINDER_COLUMN_G_U_GROUPID_2);
3772    
3773                                    query.append(_FINDER_COLUMN_G_U_USERID_2);
3774    
3775                                    String sql = query.toString();
3776    
3777                                    Query q = session.createQuery(sql);
3778    
3779                                    QueryPos qPos = QueryPos.getInstance(q);
3780    
3781                                    qPos.add(groupId);
3782    
3783                                    qPos.add(userId);
3784    
3785                                    count = (Long)q.uniqueResult();
3786                            }
3787                            catch (Exception e) {
3788                                    throw processException(e);
3789                            }
3790                            finally {
3791                                    if (count == null) {
3792                                            count = Long.valueOf(0);
3793                                    }
3794    
3795                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_U, finderArgs,
3796                                            count);
3797    
3798                                    closeSession(session);
3799                            }
3800                    }
3801    
3802                    return count.intValue();
3803            }
3804    
3805            public int filterCountByG_U(long groupId, long userId)
3806                    throws SystemException {
3807                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
3808                            return countByG_U(groupId, userId);
3809                    }
3810    
3811                    Session session = null;
3812    
3813                    try {
3814                            session = openSession();
3815    
3816                            StringBundler query = new StringBundler(3);
3817    
3818                            query.append(_FILTER_SQL_COUNT_DLFILEENTRY_WHERE);
3819    
3820                            query.append(_FINDER_COLUMN_G_U_GROUPID_2);
3821    
3822                            query.append(_FINDER_COLUMN_G_U_USERID_2);
3823    
3824                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
3825                                            DLFileEntry.class.getName(), _FILTER_COLUMN_PK,
3826                                            _FILTER_COLUMN_USERID, groupId);
3827    
3828                            SQLQuery q = session.createSQLQuery(sql);
3829    
3830                            q.addScalar(COUNT_COLUMN_NAME,
3831                                    com.liferay.portal.kernel.dao.orm.Type.LONG);
3832    
3833                            QueryPos qPos = QueryPos.getInstance(q);
3834    
3835                            qPos.add(groupId);
3836    
3837                            qPos.add(userId);
3838    
3839                            Long count = (Long)q.uniqueResult();
3840    
3841                            return count.intValue();
3842                    }
3843                    catch (Exception e) {
3844                            throw processException(e);
3845                    }
3846                    finally {
3847                            closeSession(session);
3848                    }
3849            }
3850    
3851            public int countByG_F(long groupId, long folderId)
3852                    throws SystemException {
3853                    Object[] finderArgs = new Object[] { groupId, folderId };
3854    
3855                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_F,
3856                                    finderArgs, this);
3857    
3858                    if (count == null) {
3859                            Session session = null;
3860    
3861                            try {
3862                                    session = openSession();
3863    
3864                                    StringBundler query = new StringBundler(3);
3865    
3866                                    query.append(_SQL_COUNT_DLFILEENTRY_WHERE);
3867    
3868                                    query.append(_FINDER_COLUMN_G_F_GROUPID_2);
3869    
3870                                    query.append(_FINDER_COLUMN_G_F_FOLDERID_2);
3871    
3872                                    String sql = query.toString();
3873    
3874                                    Query q = session.createQuery(sql);
3875    
3876                                    QueryPos qPos = QueryPos.getInstance(q);
3877    
3878                                    qPos.add(groupId);
3879    
3880                                    qPos.add(folderId);
3881    
3882                                    count = (Long)q.uniqueResult();
3883                            }
3884                            catch (Exception e) {
3885                                    throw processException(e);
3886                            }
3887                            finally {
3888                                    if (count == null) {
3889                                            count = Long.valueOf(0);
3890                                    }
3891    
3892                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_F, finderArgs,
3893                                            count);
3894    
3895                                    closeSession(session);
3896                            }
3897                    }
3898    
3899                    return count.intValue();
3900            }
3901    
3902            public int countByG_F(long groupId, long[] folderIds)
3903                    throws SystemException {
3904                    Object[] finderArgs = new Object[] { groupId, StringUtil.merge(folderIds) };
3905    
3906                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_F,
3907                                    finderArgs, this);
3908    
3909                    if (count == null) {
3910                            Session session = null;
3911    
3912                            try {
3913                                    session = openSession();
3914    
3915                                    StringBundler query = new StringBundler();
3916    
3917                                    query.append(_SQL_COUNT_DLFILEENTRY_WHERE);
3918    
3919                                    boolean conjunctionable = false;
3920    
3921                                    if (conjunctionable) {
3922                                            query.append(WHERE_AND);
3923                                    }
3924    
3925                                    query.append(_FINDER_COLUMN_G_F_GROUPID_5);
3926    
3927                                    conjunctionable = true;
3928    
3929                                    if ((folderIds == null) || (folderIds.length > 0)) {
3930                                            if (conjunctionable) {
3931                                                    query.append(WHERE_AND);
3932                                            }
3933    
3934                                            query.append(StringPool.OPEN_PARENTHESIS);
3935    
3936                                            for (int i = 0; i < folderIds.length; i++) {
3937                                                    query.append(_FINDER_COLUMN_G_F_FOLDERID_5);
3938    
3939                                                    if ((i + 1) < folderIds.length) {
3940                                                            query.append(WHERE_OR);
3941                                                    }
3942                                            }
3943    
3944                                            query.append(StringPool.CLOSE_PARENTHESIS);
3945    
3946                                            conjunctionable = true;
3947                                    }
3948    
3949                                    String sql = query.toString();
3950    
3951                                    Query q = session.createQuery(sql);
3952    
3953                                    QueryPos qPos = QueryPos.getInstance(q);
3954    
3955                                    qPos.add(groupId);
3956    
3957                                    if (folderIds != null) {
3958                                            qPos.add(folderIds);
3959                                    }
3960    
3961                                    count = (Long)q.uniqueResult();
3962                            }
3963                            catch (Exception e) {
3964                                    throw processException(e);
3965                            }
3966                            finally {
3967                                    if (count == null) {
3968                                            count = Long.valueOf(0);
3969                                    }
3970    
3971                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_F, finderArgs,
3972                                            count);
3973    
3974                                    closeSession(session);
3975                            }
3976                    }
3977    
3978                    return count.intValue();
3979            }
3980    
3981            public int filterCountByG_F(long groupId, long folderId)
3982                    throws SystemException {
3983                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
3984                            return countByG_F(groupId, folderId);
3985                    }
3986    
3987                    Session session = null;
3988    
3989                    try {
3990                            session = openSession();
3991    
3992                            StringBundler query = new StringBundler(3);
3993    
3994                            query.append(_FILTER_SQL_COUNT_DLFILEENTRY_WHERE);
3995    
3996                            query.append(_FINDER_COLUMN_G_F_GROUPID_2);
3997    
3998                            query.append(_FINDER_COLUMN_G_F_FOLDERID_2);
3999    
4000                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
4001                                            DLFileEntry.class.getName(), _FILTER_COLUMN_PK,
4002                                            _FILTER_COLUMN_USERID, groupId);
4003    
4004                            SQLQuery q = session.createSQLQuery(sql);
4005    
4006                            q.addScalar(COUNT_COLUMN_NAME,
4007                                    com.liferay.portal.kernel.dao.orm.Type.LONG);
4008    
4009                            QueryPos qPos = QueryPos.getInstance(q);
4010    
4011                            qPos.add(groupId);
4012    
4013                            qPos.add(folderId);
4014    
4015                            Long count = (Long)q.uniqueResult();
4016    
4017                            return count.intValue();
4018                    }
4019                    catch (Exception e) {
4020                            throw processException(e);
4021                    }
4022                    finally {
4023                            closeSession(session);
4024                    }
4025            }
4026    
4027            public int filterCountByG_F(long groupId, long[] folderIds)
4028                    throws SystemException {
4029                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
4030                            return countByG_F(groupId, folderIds);
4031                    }
4032    
4033                    Session session = null;
4034    
4035                    try {
4036                            session = openSession();
4037    
4038                            StringBundler query = new StringBundler();
4039    
4040                            query.append(_FILTER_SQL_COUNT_DLFILEENTRY_WHERE);
4041    
4042                            boolean conjunctionable = false;
4043    
4044                            if (conjunctionable) {
4045                                    query.append(WHERE_AND);
4046                            }
4047    
4048                            query.append(_FINDER_COLUMN_G_F_GROUPID_5);
4049    
4050                            conjunctionable = true;
4051    
4052                            if ((folderIds == null) || (folderIds.length > 0)) {
4053                                    if (conjunctionable) {
4054                                            query.append(WHERE_AND);
4055                                    }
4056    
4057                                    query.append(StringPool.OPEN_PARENTHESIS);
4058    
4059                                    for (int i = 0; i < folderIds.length; i++) {
4060                                            query.append(_FINDER_COLUMN_G_F_FOLDERID_5);
4061    
4062                                            if ((i + 1) < folderIds.length) {
4063                                                    query.append(WHERE_OR);
4064                                            }
4065                                    }
4066    
4067                                    query.append(StringPool.CLOSE_PARENTHESIS);
4068    
4069                                    conjunctionable = true;
4070                            }
4071    
4072                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
4073                                            DLFileEntry.class.getName(), _FILTER_COLUMN_PK,
4074                                            _FILTER_COLUMN_USERID, groupId);
4075    
4076                            SQLQuery q = session.createSQLQuery(sql);
4077    
4078                            q.addScalar(COUNT_COLUMN_NAME,
4079                                    com.liferay.portal.kernel.dao.orm.Type.LONG);
4080    
4081                            QueryPos qPos = QueryPos.getInstance(q);
4082    
4083                            qPos.add(groupId);
4084    
4085                            if (folderIds != null) {
4086                                    qPos.add(folderIds);
4087                            }
4088    
4089                            Long count = (Long)q.uniqueResult();
4090    
4091                            return count.intValue();
4092                    }
4093                    catch (Exception e) {
4094                            throw processException(e);
4095                    }
4096                    finally {
4097                            closeSession(session);
4098                    }
4099            }
4100    
4101            public int countByG_U_F(long groupId, long userId, long folderId)
4102                    throws SystemException {
4103                    Object[] finderArgs = new Object[] { groupId, userId, folderId };
4104    
4105                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_U_F,
4106                                    finderArgs, this);
4107    
4108                    if (count == null) {
4109                            Session session = null;
4110    
4111                            try {
4112                                    session = openSession();
4113    
4114                                    StringBundler query = new StringBundler(4);
4115    
4116                                    query.append(_SQL_COUNT_DLFILEENTRY_WHERE);
4117    
4118                                    query.append(_FINDER_COLUMN_G_U_F_GROUPID_2);
4119    
4120                                    query.append(_FINDER_COLUMN_G_U_F_USERID_2);
4121    
4122                                    query.append(_FINDER_COLUMN_G_U_F_FOLDERID_2);
4123    
4124                                    String sql = query.toString();
4125    
4126                                    Query q = session.createQuery(sql);
4127    
4128                                    QueryPos qPos = QueryPos.getInstance(q);
4129    
4130                                    qPos.add(groupId);
4131    
4132                                    qPos.add(userId);
4133    
4134                                    qPos.add(folderId);
4135    
4136                                    count = (Long)q.uniqueResult();
4137                            }
4138                            catch (Exception e) {
4139                                    throw processException(e);
4140                            }
4141                            finally {
4142                                    if (count == null) {
4143                                            count = Long.valueOf(0);
4144                                    }
4145    
4146                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_U_F,
4147                                            finderArgs, count);
4148    
4149                                    closeSession(session);
4150                            }
4151                    }
4152    
4153                    return count.intValue();
4154            }
4155    
4156            public int countByG_U_F(long groupId, long userId, long[] folderIds)
4157                    throws SystemException {
4158                    Object[] finderArgs = new Object[] {
4159                                    groupId, userId, StringUtil.merge(folderIds)
4160                            };
4161    
4162                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_U_F,
4163                                    finderArgs, this);
4164    
4165                    if (count == null) {
4166                            Session session = null;
4167    
4168                            try {
4169                                    session = openSession();
4170    
4171                                    StringBundler query = new StringBundler();
4172    
4173                                    query.append(_SQL_COUNT_DLFILEENTRY_WHERE);
4174    
4175                                    boolean conjunctionable = false;
4176    
4177                                    if (conjunctionable) {
4178                                            query.append(WHERE_AND);
4179                                    }
4180    
4181                                    query.append(_FINDER_COLUMN_G_U_F_GROUPID_5);
4182    
4183                                    conjunctionable = true;
4184    
4185                                    if (conjunctionable) {
4186                                            query.append(WHERE_AND);
4187                                    }
4188    
4189                                    query.append(_FINDER_COLUMN_G_U_F_USERID_5);
4190    
4191                                    conjunctionable = true;
4192    
4193                                    if ((folderIds == null) || (folderIds.length > 0)) {
4194                                            if (conjunctionable) {
4195                                                    query.append(WHERE_AND);
4196                                            }
4197    
4198                                            query.append(StringPool.OPEN_PARENTHESIS);
4199    
4200                                            for (int i = 0; i < folderIds.length; i++) {
4201                                                    query.append(_FINDER_COLUMN_G_U_F_FOLDERID_5);
4202    
4203                                                    if ((i + 1) < folderIds.length) {
4204                                                            query.append(WHERE_OR);
4205                                                    }
4206                                            }
4207    
4208                                            query.append(StringPool.CLOSE_PARENTHESIS);
4209    
4210                                            conjunctionable = true;
4211                                    }
4212    
4213                                    String sql = query.toString();
4214    
4215                                    Query q = session.createQuery(sql);
4216    
4217                                    QueryPos qPos = QueryPos.getInstance(q);
4218    
4219                                    qPos.add(groupId);
4220    
4221                                    qPos.add(userId);
4222    
4223                                    if (folderIds != null) {
4224                                            qPos.add(folderIds);
4225                                    }
4226    
4227                                    count = (Long)q.uniqueResult();
4228                            }
4229                            catch (Exception e) {
4230                                    throw processException(e);
4231                            }
4232                            finally {
4233                                    if (count == null) {
4234                                            count = Long.valueOf(0);
4235                                    }
4236    
4237                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_U_F,
4238                                            finderArgs, count);
4239    
4240                                    closeSession(session);
4241                            }
4242                    }
4243    
4244                    return count.intValue();
4245            }
4246    
4247            public int filterCountByG_U_F(long groupId, long userId, long folderId)
4248                    throws SystemException {
4249                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
4250                            return countByG_U_F(groupId, userId, folderId);
4251                    }
4252    
4253                    Session session = null;
4254    
4255                    try {
4256                            session = openSession();
4257    
4258                            StringBundler query = new StringBundler(4);
4259    
4260                            query.append(_FILTER_SQL_COUNT_DLFILEENTRY_WHERE);
4261    
4262                            query.append(_FINDER_COLUMN_G_U_F_GROUPID_2);
4263    
4264                            query.append(_FINDER_COLUMN_G_U_F_USERID_2);
4265    
4266                            query.append(_FINDER_COLUMN_G_U_F_FOLDERID_2);
4267    
4268                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
4269                                            DLFileEntry.class.getName(), _FILTER_COLUMN_PK,
4270                                            _FILTER_COLUMN_USERID, groupId);
4271    
4272                            SQLQuery q = session.createSQLQuery(sql);
4273    
4274                            q.addScalar(COUNT_COLUMN_NAME,
4275                                    com.liferay.portal.kernel.dao.orm.Type.LONG);
4276    
4277                            QueryPos qPos = QueryPos.getInstance(q);
4278    
4279                            qPos.add(groupId);
4280    
4281                            qPos.add(userId);
4282    
4283                            qPos.add(folderId);
4284    
4285                            Long count = (Long)q.uniqueResult();
4286    
4287                            return count.intValue();
4288                    }
4289                    catch (Exception e) {
4290                            throw processException(e);
4291                    }
4292                    finally {
4293                            closeSession(session);
4294                    }
4295            }
4296    
4297            public int filterCountByG_U_F(long groupId, long userId, long[] folderIds)
4298                    throws SystemException {
4299                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
4300                            return countByG_U_F(groupId, userId, folderIds);
4301                    }
4302    
4303                    Session session = null;
4304    
4305                    try {
4306                            session = openSession();
4307    
4308                            StringBundler query = new StringBundler();
4309    
4310                            query.append(_FILTER_SQL_COUNT_DLFILEENTRY_WHERE);
4311    
4312                            boolean conjunctionable = false;
4313    
4314                            if (conjunctionable) {
4315                                    query.append(WHERE_AND);
4316                            }
4317    
4318                            query.append(_FINDER_COLUMN_G_U_F_GROUPID_5);
4319    
4320                            conjunctionable = true;
4321    
4322                            if (conjunctionable) {
4323                                    query.append(WHERE_AND);
4324                            }
4325    
4326                            query.append(_FINDER_COLUMN_G_U_F_USERID_5);
4327    
4328                            conjunctionable = true;
4329    
4330                            if ((folderIds == null) || (folderIds.length > 0)) {
4331                                    if (conjunctionable) {
4332                                            query.append(WHERE_AND);
4333                                    }
4334    
4335                                    query.append(StringPool.OPEN_PARENTHESIS);
4336    
4337                                    for (int i = 0; i < folderIds.length; i++) {
4338                                            query.append(_FINDER_COLUMN_G_U_F_FOLDERID_5);
4339    
4340                                            if ((i + 1) < folderIds.length) {
4341                                                    query.append(WHERE_OR);
4342                                            }
4343                                    }
4344    
4345                                    query.append(StringPool.CLOSE_PARENTHESIS);
4346    
4347                                    conjunctionable = true;
4348                            }
4349    
4350                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
4351                                            DLFileEntry.class.getName(), _FILTER_COLUMN_PK,
4352                                            _FILTER_COLUMN_USERID, groupId);
4353    
4354                            SQLQuery q = session.createSQLQuery(sql);
4355    
4356                            q.addScalar(COUNT_COLUMN_NAME,
4357                                    com.liferay.portal.kernel.dao.orm.Type.LONG);
4358    
4359                            QueryPos qPos = QueryPos.getInstance(q);
4360    
4361                            qPos.add(groupId);
4362    
4363                            qPos.add(userId);
4364    
4365                            if (folderIds != null) {
4366                                    qPos.add(folderIds);
4367                            }
4368    
4369                            Long count = (Long)q.uniqueResult();
4370    
4371                            return count.intValue();
4372                    }
4373                    catch (Exception e) {
4374                            throw processException(e);
4375                    }
4376                    finally {
4377                            closeSession(session);
4378                    }
4379            }
4380    
4381            public int countByG_F_N(long groupId, long folderId, String name)
4382                    throws SystemException {
4383                    Object[] finderArgs = new Object[] { groupId, folderId, name };
4384    
4385                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_F_N,
4386                                    finderArgs, this);
4387    
4388                    if (count == null) {
4389                            Session session = null;
4390    
4391                            try {
4392                                    session = openSession();
4393    
4394                                    StringBundler query = new StringBundler(4);
4395    
4396                                    query.append(_SQL_COUNT_DLFILEENTRY_WHERE);
4397    
4398                                    query.append(_FINDER_COLUMN_G_F_N_GROUPID_2);
4399    
4400                                    query.append(_FINDER_COLUMN_G_F_N_FOLDERID_2);
4401    
4402                                    if (name == null) {
4403                                            query.append(_FINDER_COLUMN_G_F_N_NAME_1);
4404                                    }
4405                                    else {
4406                                            if (name.equals(StringPool.BLANK)) {
4407                                                    query.append(_FINDER_COLUMN_G_F_N_NAME_3);
4408                                            }
4409                                            else {
4410                                                    query.append(_FINDER_COLUMN_G_F_N_NAME_2);
4411                                            }
4412                                    }
4413    
4414                                    String sql = query.toString();
4415    
4416                                    Query q = session.createQuery(sql);
4417    
4418                                    QueryPos qPos = QueryPos.getInstance(q);
4419    
4420                                    qPos.add(groupId);
4421    
4422                                    qPos.add(folderId);
4423    
4424                                    if (name != null) {
4425                                            qPos.add(name);
4426                                    }
4427    
4428                                    count = (Long)q.uniqueResult();
4429                            }
4430                            catch (Exception e) {
4431                                    throw processException(e);
4432                            }
4433                            finally {
4434                                    if (count == null) {
4435                                            count = Long.valueOf(0);
4436                                    }
4437    
4438                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_F_N,
4439                                            finderArgs, count);
4440    
4441                                    closeSession(session);
4442                            }
4443                    }
4444    
4445                    return count.intValue();
4446            }
4447    
4448            public int filterCountByG_F_N(long groupId, long folderId, String name)
4449                    throws SystemException {
4450                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
4451                            return countByG_F_N(groupId, folderId, name);
4452                    }
4453    
4454                    Session session = null;
4455    
4456                    try {
4457                            session = openSession();
4458    
4459                            StringBundler query = new StringBundler(4);
4460    
4461                            query.append(_FILTER_SQL_COUNT_DLFILEENTRY_WHERE);
4462    
4463                            query.append(_FINDER_COLUMN_G_F_N_GROUPID_2);
4464    
4465                            query.append(_FINDER_COLUMN_G_F_N_FOLDERID_2);
4466    
4467                            if (name == null) {
4468                                    query.append(_FINDER_COLUMN_G_F_N_NAME_1);
4469                            }
4470                            else {
4471                                    if (name.equals(StringPool.BLANK)) {
4472                                            query.append(_FINDER_COLUMN_G_F_N_NAME_3);
4473                                    }
4474                                    else {
4475                                            query.append(_FINDER_COLUMN_G_F_N_NAME_2);
4476                                    }
4477                            }
4478    
4479                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
4480                                            DLFileEntry.class.getName(), _FILTER_COLUMN_PK,
4481                                            _FILTER_COLUMN_USERID, groupId);
4482    
4483                            SQLQuery q = session.createSQLQuery(sql);
4484    
4485                            q.addScalar(COUNT_COLUMN_NAME,
4486                                    com.liferay.portal.kernel.dao.orm.Type.LONG);
4487    
4488                            QueryPos qPos = QueryPos.getInstance(q);
4489    
4490                            qPos.add(groupId);
4491    
4492                            qPos.add(folderId);
4493    
4494                            if (name != null) {
4495                                    qPos.add(name);
4496                            }
4497    
4498                            Long count = (Long)q.uniqueResult();
4499    
4500                            return count.intValue();
4501                    }
4502                    catch (Exception e) {
4503                            throw processException(e);
4504                    }
4505                    finally {
4506                            closeSession(session);
4507                    }
4508            }
4509    
4510            public int countByG_F_T(long groupId, long folderId, String title)
4511                    throws SystemException {
4512                    Object[] finderArgs = new Object[] { groupId, folderId, title };
4513    
4514                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_F_T,
4515                                    finderArgs, this);
4516    
4517                    if (count == null) {
4518                            Session session = null;
4519    
4520                            try {
4521                                    session = openSession();
4522    
4523                                    StringBundler query = new StringBundler(4);
4524    
4525                                    query.append(_SQL_COUNT_DLFILEENTRY_WHERE);
4526    
4527                                    query.append(_FINDER_COLUMN_G_F_T_GROUPID_2);
4528    
4529                                    query.append(_FINDER_COLUMN_G_F_T_FOLDERID_2);
4530    
4531                                    if (title == null) {
4532                                            query.append(_FINDER_COLUMN_G_F_T_TITLE_1);
4533                                    }
4534                                    else {
4535                                            if (title.equals(StringPool.BLANK)) {
4536                                                    query.append(_FINDER_COLUMN_G_F_T_TITLE_3);
4537                                            }
4538                                            else {
4539                                                    query.append(_FINDER_COLUMN_G_F_T_TITLE_2);
4540                                            }
4541                                    }
4542    
4543                                    String sql = query.toString();
4544    
4545                                    Query q = session.createQuery(sql);
4546    
4547                                    QueryPos qPos = QueryPos.getInstance(q);
4548    
4549                                    qPos.add(groupId);
4550    
4551                                    qPos.add(folderId);
4552    
4553                                    if (title != null) {
4554                                            qPos.add(title);
4555                                    }
4556    
4557                                    count = (Long)q.uniqueResult();
4558                            }
4559                            catch (Exception e) {
4560                                    throw processException(e);
4561                            }
4562                            finally {
4563                                    if (count == null) {
4564                                            count = Long.valueOf(0);
4565                                    }
4566    
4567                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_F_T,
4568                                            finderArgs, count);
4569    
4570                                    closeSession(session);
4571                            }
4572                    }
4573    
4574                    return count.intValue();
4575            }
4576    
4577            public int filterCountByG_F_T(long groupId, long folderId, String title)
4578                    throws SystemException {
4579                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
4580                            return countByG_F_T(groupId, folderId, title);
4581                    }
4582    
4583                    Session session = null;
4584    
4585                    try {
4586                            session = openSession();
4587    
4588                            StringBundler query = new StringBundler(4);
4589    
4590                            query.append(_FILTER_SQL_COUNT_DLFILEENTRY_WHERE);
4591    
4592                            query.append(_FINDER_COLUMN_G_F_T_GROUPID_2);
4593    
4594                            query.append(_FINDER_COLUMN_G_F_T_FOLDERID_2);
4595    
4596                            if (title == null) {
4597                                    query.append(_FINDER_COLUMN_G_F_T_TITLE_1);
4598                            }
4599                            else {
4600                                    if (title.equals(StringPool.BLANK)) {
4601                                            query.append(_FINDER_COLUMN_G_F_T_TITLE_3);
4602                                    }
4603                                    else {
4604                                            query.append(_FINDER_COLUMN_G_F_T_TITLE_2);
4605                                    }
4606                            }
4607    
4608                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
4609                                            DLFileEntry.class.getName(), _FILTER_COLUMN_PK,
4610                                            _FILTER_COLUMN_USERID, groupId);
4611    
4612                            SQLQuery q = session.createSQLQuery(sql);
4613    
4614                            q.addScalar(COUNT_COLUMN_NAME,
4615                                    com.liferay.portal.kernel.dao.orm.Type.LONG);
4616    
4617                            QueryPos qPos = QueryPos.getInstance(q);
4618    
4619                            qPos.add(groupId);
4620    
4621                            qPos.add(folderId);
4622    
4623                            if (title != null) {
4624                                    qPos.add(title);
4625                            }
4626    
4627                            Long count = (Long)q.uniqueResult();
4628    
4629                            return count.intValue();
4630                    }
4631                    catch (Exception e) {
4632                            throw processException(e);
4633                    }
4634                    finally {
4635                            closeSession(session);
4636                    }
4637            }
4638    
4639            public int countAll() throws SystemException {
4640                    Object[] finderArgs = new Object[0];
4641    
4642                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
4643                                    finderArgs, this);
4644    
4645                    if (count == null) {
4646                            Session session = null;
4647    
4648                            try {
4649                                    session = openSession();
4650    
4651                                    Query q = session.createQuery(_SQL_COUNT_DLFILEENTRY);
4652    
4653                                    count = (Long)q.uniqueResult();
4654                            }
4655                            catch (Exception e) {
4656                                    throw processException(e);
4657                            }
4658                            finally {
4659                                    if (count == null) {
4660                                            count = Long.valueOf(0);
4661                                    }
4662    
4663                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
4664                                            count);
4665    
4666                                    closeSession(session);
4667                            }
4668                    }
4669    
4670                    return count.intValue();
4671            }
4672    
4673            public void afterPropertiesSet() {
4674                    String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
4675                                            com.liferay.portal.util.PropsUtil.get(
4676                                                    "value.object.listener.com.liferay.portlet.documentlibrary.model.DLFileEntry")));
4677    
4678                    if (listenerClassNames.length > 0) {
4679                            try {
4680                                    List<ModelListener<DLFileEntry>> listenersList = new ArrayList<ModelListener<DLFileEntry>>();
4681    
4682                                    for (String listenerClassName : listenerClassNames) {
4683                                            listenersList.add((ModelListener<DLFileEntry>)InstanceFactory.newInstance(
4684                                                            listenerClassName));
4685                                    }
4686    
4687                                    listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
4688                            }
4689                            catch (Exception e) {
4690                                    _log.error(e);
4691                            }
4692                    }
4693            }
4694    
4695            @BeanReference(type = DLFileEntryPersistence.class)
4696            protected DLFileEntryPersistence dlFileEntryPersistence;
4697            @BeanReference(type = DLFileRankPersistence.class)
4698            protected DLFileRankPersistence dlFileRankPersistence;
4699            @BeanReference(type = DLFileShortcutPersistence.class)
4700            protected DLFileShortcutPersistence dlFileShortcutPersistence;
4701            @BeanReference(type = DLFileVersionPersistence.class)
4702            protected DLFileVersionPersistence dlFileVersionPersistence;
4703            @BeanReference(type = DLFolderPersistence.class)
4704            protected DLFolderPersistence dlFolderPersistence;
4705            @BeanReference(type = LockPersistence.class)
4706            protected LockPersistence lockPersistence;
4707            @BeanReference(type = ResourcePersistence.class)
4708            protected ResourcePersistence resourcePersistence;
4709            @BeanReference(type = UserPersistence.class)
4710            protected UserPersistence userPersistence;
4711            @BeanReference(type = WebDAVPropsPersistence.class)
4712            protected WebDAVPropsPersistence webDAVPropsPersistence;
4713            @BeanReference(type = WorkflowInstanceLinkPersistence.class)
4714            protected WorkflowInstanceLinkPersistence workflowInstanceLinkPersistence;
4715            @BeanReference(type = AssetCategoryPersistence.class)
4716            protected AssetCategoryPersistence assetCategoryPersistence;
4717            @BeanReference(type = AssetEntryPersistence.class)
4718            protected AssetEntryPersistence assetEntryPersistence;
4719            @BeanReference(type = AssetTagPersistence.class)
4720            protected AssetTagPersistence assetTagPersistence;
4721            @BeanReference(type = ExpandoValuePersistence.class)
4722            protected ExpandoValuePersistence expandoValuePersistence;
4723            @BeanReference(type = MBDiscussionPersistence.class)
4724            protected MBDiscussionPersistence mbDiscussionPersistence;
4725            @BeanReference(type = MBMessagePersistence.class)
4726            protected MBMessagePersistence mbMessagePersistence;
4727            @BeanReference(type = RatingsEntryPersistence.class)
4728            protected RatingsEntryPersistence ratingsEntryPersistence;
4729            @BeanReference(type = RatingsStatsPersistence.class)
4730            protected RatingsStatsPersistence ratingsStatsPersistence;
4731            @BeanReference(type = SocialActivityPersistence.class)
4732            protected SocialActivityPersistence socialActivityPersistence;
4733            private static final String _SQL_SELECT_DLFILEENTRY = "SELECT dlFileEntry FROM DLFileEntry dlFileEntry";
4734            private static final String _SQL_SELECT_DLFILEENTRY_WHERE = "SELECT dlFileEntry FROM DLFileEntry dlFileEntry WHERE ";
4735            private static final String _SQL_COUNT_DLFILEENTRY = "SELECT COUNT(dlFileEntry) FROM DLFileEntry dlFileEntry";
4736            private static final String _SQL_COUNT_DLFILEENTRY_WHERE = "SELECT COUNT(dlFileEntry) FROM DLFileEntry dlFileEntry WHERE ";
4737            private static final String _FINDER_COLUMN_UUID_UUID_1 = "dlFileEntry.uuid IS NULL";
4738            private static final String _FINDER_COLUMN_UUID_UUID_2 = "dlFileEntry.uuid = ?";
4739            private static final String _FINDER_COLUMN_UUID_UUID_3 = "(dlFileEntry.uuid IS NULL OR dlFileEntry.uuid = ?)";
4740            private static final String _FINDER_COLUMN_UUID_G_UUID_1 = "dlFileEntry.uuid IS NULL AND ";
4741            private static final String _FINDER_COLUMN_UUID_G_UUID_2 = "dlFileEntry.uuid = ? AND ";
4742            private static final String _FINDER_COLUMN_UUID_G_UUID_3 = "(dlFileEntry.uuid IS NULL OR dlFileEntry.uuid = ?) AND ";
4743            private static final String _FINDER_COLUMN_UUID_G_GROUPID_2 = "dlFileEntry.groupId = ?";
4744            private static final String _FINDER_COLUMN_GROUPID_GROUPID_2 = "dlFileEntry.groupId = ?";
4745            private static final String _FINDER_COLUMN_COMPANYID_COMPANYID_2 = "dlFileEntry.companyId = ?";
4746            private static final String _FINDER_COLUMN_G_U_GROUPID_2 = "dlFileEntry.groupId = ? AND ";
4747            private static final String _FINDER_COLUMN_G_U_USERID_2 = "dlFileEntry.userId = ?";
4748            private static final String _FINDER_COLUMN_G_F_GROUPID_2 = "dlFileEntry.groupId = ? AND ";
4749            private static final String _FINDER_COLUMN_G_F_GROUPID_5 = "(" +
4750                    _removeConjunction(_FINDER_COLUMN_G_F_GROUPID_2) + ")";
4751            private static final String _FINDER_COLUMN_G_F_FOLDERID_2 = "dlFileEntry.folderId = ?";
4752            private static final String _FINDER_COLUMN_G_F_FOLDERID_5 = "(" +
4753                    _removeConjunction(_FINDER_COLUMN_G_F_FOLDERID_2) + ")";
4754            private static final String _FINDER_COLUMN_G_U_F_GROUPID_2 = "dlFileEntry.groupId = ? AND ";
4755            private static final String _FINDER_COLUMN_G_U_F_GROUPID_5 = "(" +
4756                    _removeConjunction(_FINDER_COLUMN_G_U_F_GROUPID_2) + ")";
4757            private static final String _FINDER_COLUMN_G_U_F_USERID_2 = "dlFileEntry.userId = ? AND ";
4758            private static final String _FINDER_COLUMN_G_U_F_USERID_5 = "(" +
4759                    _removeConjunction(_FINDER_COLUMN_G_U_F_USERID_2) + ")";
4760            private static final String _FINDER_COLUMN_G_U_F_FOLDERID_2 = "dlFileEntry.folderId = ?";
4761            private static final String _FINDER_COLUMN_G_U_F_FOLDERID_5 = "(" +
4762                    _removeConjunction(_FINDER_COLUMN_G_U_F_FOLDERID_2) + ")";
4763            private static final String _FINDER_COLUMN_G_F_N_GROUPID_2 = "dlFileEntry.groupId = ? AND ";
4764            private static final String _FINDER_COLUMN_G_F_N_FOLDERID_2 = "dlFileEntry.folderId = ? AND ";
4765            private static final String _FINDER_COLUMN_G_F_N_NAME_1 = "dlFileEntry.name IS NULL";
4766            private static final String _FINDER_COLUMN_G_F_N_NAME_2 = "dlFileEntry.name = ?";
4767            private static final String _FINDER_COLUMN_G_F_N_NAME_3 = "(dlFileEntry.name IS NULL OR dlFileEntry.name = ?)";
4768            private static final String _FINDER_COLUMN_G_F_T_GROUPID_2 = "dlFileEntry.groupId = ? AND ";
4769            private static final String _FINDER_COLUMN_G_F_T_FOLDERID_2 = "dlFileEntry.folderId = ? AND ";
4770            private static final String _FINDER_COLUMN_G_F_T_TITLE_1 = "dlFileEntry.title IS NULL";
4771            private static final String _FINDER_COLUMN_G_F_T_TITLE_2 = "dlFileEntry.title = ?";
4772            private static final String _FINDER_COLUMN_G_F_T_TITLE_3 = "(dlFileEntry.title IS NULL OR dlFileEntry.title = ?)";
4773    
4774            private static String _removeConjunction(String sql) {
4775                    int pos = sql.indexOf(" AND ");
4776    
4777                    if (pos != -1) {
4778                            sql = sql.substring(0, pos);
4779                    }
4780    
4781                    return sql;
4782            }
4783    
4784            private static final String _FILTER_SQL_SELECT_DLFILEENTRY_WHERE = "SELECT DISTINCT {dlFileEntry.*} FROM DLFileEntry dlFileEntry WHERE ";
4785            private static final String _FILTER_SQL_COUNT_DLFILEENTRY_WHERE = "SELECT COUNT(DISTINCT dlFileEntry.fileEntryId) AS COUNT_VALUE FROM DLFileEntry dlFileEntry WHERE ";
4786            private static final String _FILTER_COLUMN_PK = "dlFileEntry.fileEntryId";
4787            private static final String _FILTER_COLUMN_USERID = "dlFileEntry.userId";
4788            private static final String _FILTER_ENTITY_ALIAS = "dlFileEntry";
4789            private static final String _ORDER_BY_ENTITY_ALIAS = "dlFileEntry.";
4790            private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No DLFileEntry exists with the primary key ";
4791            private static final String _NO_SUCH_ENTITY_WITH_KEY = "No DLFileEntry exists with the key {";
4792            private static Log _log = LogFactoryUtil.getLog(DLFileEntryPersistenceImpl.class);
4793    }