001
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
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 }