1
14
15 package com.liferay.portlet.documentlibrary.service.persistence;
16
17 import com.liferay.portal.NoSuchModelException;
18 import com.liferay.portal.kernel.annotation.BeanReference;
19 import com.liferay.portal.kernel.cache.CacheRegistry;
20 import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
21 import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
22 import com.liferay.portal.kernel.dao.orm.FinderPath;
23 import com.liferay.portal.kernel.dao.orm.Query;
24 import com.liferay.portal.kernel.dao.orm.QueryPos;
25 import com.liferay.portal.kernel.dao.orm.QueryUtil;
26 import com.liferay.portal.kernel.dao.orm.SQLQuery;
27 import com.liferay.portal.kernel.dao.orm.Session;
28 import com.liferay.portal.kernel.dao.orm.Type;
29 import com.liferay.portal.kernel.exception.SystemException;
30 import com.liferay.portal.kernel.log.Log;
31 import com.liferay.portal.kernel.log.LogFactoryUtil;
32 import com.liferay.portal.kernel.util.GetterUtil;
33 import com.liferay.portal.kernel.util.InstanceFactory;
34 import com.liferay.portal.kernel.util.OrderByComparator;
35 import com.liferay.portal.kernel.util.StringBundler;
36 import com.liferay.portal.kernel.util.StringPool;
37 import com.liferay.portal.kernel.util.StringUtil;
38 import com.liferay.portal.kernel.util.Validator;
39 import com.liferay.portal.kernel.uuid.PortalUUIDUtil;
40 import com.liferay.portal.model.ModelListener;
41 import com.liferay.portal.security.permission.InlineSQLHelperUtil;
42 import com.liferay.portal.service.persistence.BatchSessionUtil;
43 import com.liferay.portal.service.persistence.LockPersistence;
44 import com.liferay.portal.service.persistence.ResourcePersistence;
45 import com.liferay.portal.service.persistence.UserPersistence;
46 import com.liferay.portal.service.persistence.WebDAVPropsPersistence;
47 import com.liferay.portal.service.persistence.WorkflowInstanceLinkPersistence;
48 import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
49
50 import com.liferay.portlet.asset.service.persistence.AssetCategoryPersistence;
51 import com.liferay.portlet.asset.service.persistence.AssetEntryPersistence;
52 import com.liferay.portlet.asset.service.persistence.AssetTagPersistence;
53 import com.liferay.portlet.documentlibrary.NoSuchFileEntryException;
54 import com.liferay.portlet.documentlibrary.model.DLFileEntry;
55 import com.liferay.portlet.documentlibrary.model.impl.DLFileEntryImpl;
56 import com.liferay.portlet.documentlibrary.model.impl.DLFileEntryModelImpl;
57 import com.liferay.portlet.expando.service.persistence.ExpandoValuePersistence;
58 import com.liferay.portlet.messageboards.service.persistence.MBDiscussionPersistence;
59 import com.liferay.portlet.messageboards.service.persistence.MBMessagePersistence;
60 import com.liferay.portlet.ratings.service.persistence.RatingsEntryPersistence;
61 import com.liferay.portlet.ratings.service.persistence.RatingsStatsPersistence;
62 import com.liferay.portlet.social.service.persistence.SocialActivityPersistence;
63
64 import java.io.Serializable;
65
66 import java.util.ArrayList;
67 import java.util.Collections;
68 import java.util.List;
69
70
83 public class DLFileEntryPersistenceImpl extends BasePersistenceImpl<DLFileEntry>
84 implements DLFileEntryPersistence {
85 public static final String FINDER_CLASS_NAME_ENTITY = DLFileEntryImpl.class.getName();
86 public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
87 ".List";
88 public static final FinderPath FINDER_PATH_FIND_BY_UUID = new FinderPath(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
89 DLFileEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
90 "findByUuid",
91 new String[] {
92 String.class.getName(),
93
94 "java.lang.Integer", "java.lang.Integer",
95 "com.liferay.portal.kernel.util.OrderByComparator"
96 });
97 public static final FinderPath FINDER_PATH_COUNT_BY_UUID = new FinderPath(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
98 DLFileEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
99 "countByUuid", new String[] { String.class.getName() });
100 public static final FinderPath FINDER_PATH_FETCH_BY_UUID_G = new FinderPath(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
101 DLFileEntryModelImpl.FINDER_CACHE_ENABLED,
102 FINDER_CLASS_NAME_ENTITY, "fetchByUUID_G",
103 new String[] { String.class.getName(), Long.class.getName() });
104 public static final FinderPath FINDER_PATH_COUNT_BY_UUID_G = new FinderPath(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
105 DLFileEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
106 "countByUUID_G",
107 new String[] { String.class.getName(), Long.class.getName() });
108 public static final FinderPath FINDER_PATH_FIND_BY_GROUPID = new FinderPath(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
109 DLFileEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
110 "findByGroupId",
111 new String[] {
112 Long.class.getName(),
113
114 "java.lang.Integer", "java.lang.Integer",
115 "com.liferay.portal.kernel.util.OrderByComparator"
116 });
117 public static final FinderPath FINDER_PATH_COUNT_BY_GROUPID = new FinderPath(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
118 DLFileEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
119 "countByGroupId", new String[] { Long.class.getName() });
120 public static final FinderPath FINDER_PATH_FIND_BY_COMPANYID = new FinderPath(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
121 DLFileEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
122 "findByCompanyId",
123 new String[] {
124 Long.class.getName(),
125
126 "java.lang.Integer", "java.lang.Integer",
127 "com.liferay.portal.kernel.util.OrderByComparator"
128 });
129 public static final FinderPath FINDER_PATH_COUNT_BY_COMPANYID = new FinderPath(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
130 DLFileEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
131 "countByCompanyId", new String[] { Long.class.getName() });
132 public static final FinderPath FINDER_PATH_FIND_BY_G_U = new FinderPath(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
133 DLFileEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
134 "findByG_U",
135 new String[] {
136 Long.class.getName(), Long.class.getName(),
137
138 "java.lang.Integer", "java.lang.Integer",
139 "com.liferay.portal.kernel.util.OrderByComparator"
140 });
141 public static final FinderPath FINDER_PATH_COUNT_BY_G_U = new FinderPath(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
142 DLFileEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
143 "countByG_U",
144 new String[] { Long.class.getName(), Long.class.getName() });
145 public static final FinderPath FINDER_PATH_FIND_BY_G_F = new FinderPath(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
146 DLFileEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
147 "findByG_F",
148 new String[] {
149 Long.class.getName(), Long.class.getName(),
150
151 "java.lang.Integer", "java.lang.Integer",
152 "com.liferay.portal.kernel.util.OrderByComparator"
153 });
154 public static final FinderPath FINDER_PATH_COUNT_BY_G_F = new FinderPath(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
155 DLFileEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
156 "countByG_F",
157 new String[] { Long.class.getName(), Long.class.getName() });
158 public static final FinderPath FINDER_PATH_FETCH_BY_G_F_N = new FinderPath(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
159 DLFileEntryModelImpl.FINDER_CACHE_ENABLED,
160 FINDER_CLASS_NAME_ENTITY, "fetchByG_F_N",
161 new String[] {
162 Long.class.getName(), Long.class.getName(),
163 String.class.getName()
164 });
165 public static final FinderPath FINDER_PATH_COUNT_BY_G_F_N = new FinderPath(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
166 DLFileEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
167 "countByG_F_N",
168 new String[] {
169 Long.class.getName(), Long.class.getName(),
170 String.class.getName()
171 });
172 public static final FinderPath FINDER_PATH_FETCH_BY_G_F_T = new FinderPath(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
173 DLFileEntryModelImpl.FINDER_CACHE_ENABLED,
174 FINDER_CLASS_NAME_ENTITY, "fetchByG_F_T",
175 new String[] {
176 Long.class.getName(), Long.class.getName(),
177 String.class.getName()
178 });
179 public static final FinderPath FINDER_PATH_COUNT_BY_G_F_T = new FinderPath(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
180 DLFileEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
181 "countByG_F_T",
182 new String[] {
183 Long.class.getName(), Long.class.getName(),
184 String.class.getName()
185 });
186 public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
187 DLFileEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
188 "findAll", new String[0]);
189 public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
190 DLFileEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
191 "countAll", new String[0]);
192
193 public void cacheResult(DLFileEntry dlFileEntry) {
194 EntityCacheUtil.putResult(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
195 DLFileEntryImpl.class, dlFileEntry.getPrimaryKey(), dlFileEntry);
196
197 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
198 new Object[] {
199 dlFileEntry.getUuid(), new Long(dlFileEntry.getGroupId())
200 }, dlFileEntry);
201
202 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_F_N,
203 new Object[] {
204 new Long(dlFileEntry.getGroupId()),
205 new Long(dlFileEntry.getFolderId()),
206
207 dlFileEntry.getName()
208 }, dlFileEntry);
209
210 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_F_T,
211 new Object[] {
212 new Long(dlFileEntry.getGroupId()),
213 new Long(dlFileEntry.getFolderId()),
214
215 dlFileEntry.getTitle()
216 }, dlFileEntry);
217 }
218
219 public void cacheResult(List<DLFileEntry> dlFileEntries) {
220 for (DLFileEntry dlFileEntry : dlFileEntries) {
221 if (EntityCacheUtil.getResult(
222 DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
223 DLFileEntryImpl.class, dlFileEntry.getPrimaryKey(), this) == null) {
224 cacheResult(dlFileEntry);
225 }
226 }
227 }
228
229 public void clearCache() {
230 CacheRegistry.clear(DLFileEntryImpl.class.getName());
231 EntityCacheUtil.clearCache(DLFileEntryImpl.class.getName());
232 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
233 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
234 }
235
236 public void clearCache(DLFileEntry dlFileEntry) {
237 EntityCacheUtil.removeResult(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
238 DLFileEntryImpl.class, dlFileEntry.getPrimaryKey());
239
240 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
241 new Object[] {
242 dlFileEntry.getUuid(), new Long(dlFileEntry.getGroupId())
243 });
244
245 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_F_N,
246 new Object[] {
247 new Long(dlFileEntry.getGroupId()),
248 new Long(dlFileEntry.getFolderId()),
249
250 dlFileEntry.getName()
251 });
252
253 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_F_T,
254 new Object[] {
255 new Long(dlFileEntry.getGroupId()),
256 new Long(dlFileEntry.getFolderId()),
257
258 dlFileEntry.getTitle()
259 });
260 }
261
262 public DLFileEntry create(long fileEntryId) {
263 DLFileEntry dlFileEntry = new DLFileEntryImpl();
264
265 dlFileEntry.setNew(true);
266 dlFileEntry.setPrimaryKey(fileEntryId);
267
268 String uuid = PortalUUIDUtil.generate();
269
270 dlFileEntry.setUuid(uuid);
271
272 return dlFileEntry;
273 }
274
275 public DLFileEntry remove(Serializable primaryKey)
276 throws NoSuchModelException, SystemException {
277 return remove(((Long)primaryKey).longValue());
278 }
279
280 public DLFileEntry remove(long fileEntryId)
281 throws NoSuchFileEntryException, SystemException {
282 Session session = null;
283
284 try {
285 session = openSession();
286
287 DLFileEntry dlFileEntry = (DLFileEntry)session.get(DLFileEntryImpl.class,
288 new Long(fileEntryId));
289
290 if (dlFileEntry == null) {
291 if (_log.isWarnEnabled()) {
292 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + fileEntryId);
293 }
294
295 throw new NoSuchFileEntryException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
296 fileEntryId);
297 }
298
299 return remove(dlFileEntry);
300 }
301 catch (NoSuchFileEntryException nsee) {
302 throw nsee;
303 }
304 catch (Exception e) {
305 throw processException(e);
306 }
307 finally {
308 closeSession(session);
309 }
310 }
311
312 public DLFileEntry remove(DLFileEntry dlFileEntry)
313 throws SystemException {
314 for (ModelListener<DLFileEntry> listener : listeners) {
315 listener.onBeforeRemove(dlFileEntry);
316 }
317
318 dlFileEntry = removeImpl(dlFileEntry);
319
320 for (ModelListener<DLFileEntry> listener : listeners) {
321 listener.onAfterRemove(dlFileEntry);
322 }
323
324 return dlFileEntry;
325 }
326
327 protected DLFileEntry removeImpl(DLFileEntry dlFileEntry)
328 throws SystemException {
329 dlFileEntry = toUnwrappedModel(dlFileEntry);
330
331 Session session = null;
332
333 try {
334 session = openSession();
335
336 if (dlFileEntry.isCachedModel() || BatchSessionUtil.isEnabled()) {
337 Object staleObject = session.get(DLFileEntryImpl.class,
338 dlFileEntry.getPrimaryKeyObj());
339
340 if (staleObject != null) {
341 session.evict(staleObject);
342 }
343 }
344
345 session.delete(dlFileEntry);
346
347 session.flush();
348 }
349 catch (Exception e) {
350 throw processException(e);
351 }
352 finally {
353 closeSession(session);
354 }
355
356 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
357
358 DLFileEntryModelImpl dlFileEntryModelImpl = (DLFileEntryModelImpl)dlFileEntry;
359
360 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
361 new Object[] {
362 dlFileEntryModelImpl.getOriginalUuid(),
363 new Long(dlFileEntryModelImpl.getOriginalGroupId())
364 });
365
366 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_F_N,
367 new Object[] {
368 new Long(dlFileEntryModelImpl.getOriginalGroupId()),
369 new Long(dlFileEntryModelImpl.getOriginalFolderId()),
370
371 dlFileEntryModelImpl.getOriginalName()
372 });
373
374 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_F_T,
375 new Object[] {
376 new Long(dlFileEntryModelImpl.getOriginalGroupId()),
377 new Long(dlFileEntryModelImpl.getOriginalFolderId()),
378
379 dlFileEntryModelImpl.getOriginalTitle()
380 });
381
382 EntityCacheUtil.removeResult(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
383 DLFileEntryImpl.class, dlFileEntry.getPrimaryKey());
384
385 return dlFileEntry;
386 }
387
388 public DLFileEntry updateImpl(
389 com.liferay.portlet.documentlibrary.model.DLFileEntry dlFileEntry,
390 boolean merge) throws SystemException {
391 dlFileEntry = toUnwrappedModel(dlFileEntry);
392
393 boolean isNew = dlFileEntry.isNew();
394
395 DLFileEntryModelImpl dlFileEntryModelImpl = (DLFileEntryModelImpl)dlFileEntry;
396
397 if (Validator.isNull(dlFileEntry.getUuid())) {
398 String uuid = PortalUUIDUtil.generate();
399
400 dlFileEntry.setUuid(uuid);
401 }
402
403 Session session = null;
404
405 try {
406 session = openSession();
407
408 BatchSessionUtil.update(session, dlFileEntry, merge);
409
410 dlFileEntry.setNew(false);
411 }
412 catch (Exception e) {
413 throw processException(e);
414 }
415 finally {
416 closeSession(session);
417 }
418
419 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
420
421 EntityCacheUtil.putResult(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
422 DLFileEntryImpl.class, dlFileEntry.getPrimaryKey(), dlFileEntry);
423
424 if (!isNew &&
425 (!Validator.equals(dlFileEntry.getUuid(),
426 dlFileEntryModelImpl.getOriginalUuid()) ||
427 (dlFileEntry.getGroupId() != dlFileEntryModelImpl.getOriginalGroupId()))) {
428 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
429 new Object[] {
430 dlFileEntryModelImpl.getOriginalUuid(),
431 new Long(dlFileEntryModelImpl.getOriginalGroupId())
432 });
433 }
434
435 if (isNew ||
436 (!Validator.equals(dlFileEntry.getUuid(),
437 dlFileEntryModelImpl.getOriginalUuid()) ||
438 (dlFileEntry.getGroupId() != dlFileEntryModelImpl.getOriginalGroupId()))) {
439 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
440 new Object[] {
441 dlFileEntry.getUuid(), new Long(dlFileEntry.getGroupId())
442 }, dlFileEntry);
443 }
444
445 if (!isNew &&
446 ((dlFileEntry.getGroupId() != dlFileEntryModelImpl.getOriginalGroupId()) ||
447 (dlFileEntry.getFolderId() != dlFileEntryModelImpl.getOriginalFolderId()) ||
448 !Validator.equals(dlFileEntry.getName(),
449 dlFileEntryModelImpl.getOriginalName()))) {
450 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_F_N,
451 new Object[] {
452 new Long(dlFileEntryModelImpl.getOriginalGroupId()),
453 new Long(dlFileEntryModelImpl.getOriginalFolderId()),
454
455 dlFileEntryModelImpl.getOriginalName()
456 });
457 }
458
459 if (isNew ||
460 ((dlFileEntry.getGroupId() != dlFileEntryModelImpl.getOriginalGroupId()) ||
461 (dlFileEntry.getFolderId() != dlFileEntryModelImpl.getOriginalFolderId()) ||
462 !Validator.equals(dlFileEntry.getName(),
463 dlFileEntryModelImpl.getOriginalName()))) {
464 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_F_N,
465 new Object[] {
466 new Long(dlFileEntry.getGroupId()),
467 new Long(dlFileEntry.getFolderId()),
468
469 dlFileEntry.getName()
470 }, dlFileEntry);
471 }
472
473 if (!isNew &&
474 ((dlFileEntry.getGroupId() != dlFileEntryModelImpl.getOriginalGroupId()) ||
475 (dlFileEntry.getFolderId() != dlFileEntryModelImpl.getOriginalFolderId()) ||
476 !Validator.equals(dlFileEntry.getTitle(),
477 dlFileEntryModelImpl.getOriginalTitle()))) {
478 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_F_T,
479 new Object[] {
480 new Long(dlFileEntryModelImpl.getOriginalGroupId()),
481 new Long(dlFileEntryModelImpl.getOriginalFolderId()),
482
483 dlFileEntryModelImpl.getOriginalTitle()
484 });
485 }
486
487 if (isNew ||
488 ((dlFileEntry.getGroupId() != dlFileEntryModelImpl.getOriginalGroupId()) ||
489 (dlFileEntry.getFolderId() != dlFileEntryModelImpl.getOriginalFolderId()) ||
490 !Validator.equals(dlFileEntry.getTitle(),
491 dlFileEntryModelImpl.getOriginalTitle()))) {
492 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_F_T,
493 new Object[] {
494 new Long(dlFileEntry.getGroupId()),
495 new Long(dlFileEntry.getFolderId()),
496
497 dlFileEntry.getTitle()
498 }, dlFileEntry);
499 }
500
501 return dlFileEntry;
502 }
503
504 protected DLFileEntry toUnwrappedModel(DLFileEntry dlFileEntry) {
505 if (dlFileEntry instanceof DLFileEntryImpl) {
506 return dlFileEntry;
507 }
508
509 DLFileEntryImpl dlFileEntryImpl = new DLFileEntryImpl();
510
511 dlFileEntryImpl.setNew(dlFileEntry.isNew());
512 dlFileEntryImpl.setPrimaryKey(dlFileEntry.getPrimaryKey());
513
514 dlFileEntryImpl.setUuid(dlFileEntry.getUuid());
515 dlFileEntryImpl.setFileEntryId(dlFileEntry.getFileEntryId());
516 dlFileEntryImpl.setGroupId(dlFileEntry.getGroupId());
517 dlFileEntryImpl.setCompanyId(dlFileEntry.getCompanyId());
518 dlFileEntryImpl.setUserId(dlFileEntry.getUserId());
519 dlFileEntryImpl.setUserName(dlFileEntry.getUserName());
520 dlFileEntryImpl.setVersionUserId(dlFileEntry.getVersionUserId());
521 dlFileEntryImpl.setVersionUserName(dlFileEntry.getVersionUserName());
522 dlFileEntryImpl.setCreateDate(dlFileEntry.getCreateDate());
523 dlFileEntryImpl.setModifiedDate(dlFileEntry.getModifiedDate());
524 dlFileEntryImpl.setFolderId(dlFileEntry.getFolderId());
525 dlFileEntryImpl.setName(dlFileEntry.getName());
526 dlFileEntryImpl.setTitle(dlFileEntry.getTitle());
527 dlFileEntryImpl.setDescription(dlFileEntry.getDescription());
528 dlFileEntryImpl.setVersion(dlFileEntry.getVersion());
529 dlFileEntryImpl.setSize(dlFileEntry.getSize());
530 dlFileEntryImpl.setReadCount(dlFileEntry.getReadCount());
531 dlFileEntryImpl.setExtraSettings(dlFileEntry.getExtraSettings());
532
533 return dlFileEntryImpl;
534 }
535
536 public DLFileEntry findByPrimaryKey(Serializable primaryKey)
537 throws NoSuchModelException, SystemException {
538 return findByPrimaryKey(((Long)primaryKey).longValue());
539 }
540
541 public DLFileEntry findByPrimaryKey(long fileEntryId)
542 throws NoSuchFileEntryException, SystemException {
543 DLFileEntry dlFileEntry = fetchByPrimaryKey(fileEntryId);
544
545 if (dlFileEntry == null) {
546 if (_log.isWarnEnabled()) {
547 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + fileEntryId);
548 }
549
550 throw new NoSuchFileEntryException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
551 fileEntryId);
552 }
553
554 return dlFileEntry;
555 }
556
557 public DLFileEntry fetchByPrimaryKey(Serializable primaryKey)
558 throws SystemException {
559 return fetchByPrimaryKey(((Long)primaryKey).longValue());
560 }
561
562 public DLFileEntry fetchByPrimaryKey(long fileEntryId)
563 throws SystemException {
564 DLFileEntry dlFileEntry = (DLFileEntry)EntityCacheUtil.getResult(DLFileEntryModelImpl.ENTITY_CACHE_ENABLED,
565 DLFileEntryImpl.class, fileEntryId, this);
566
567 if (dlFileEntry == null) {
568 Session session = null;
569
570 try {
571 session = openSession();
572
573 dlFileEntry = (DLFileEntry)session.get(DLFileEntryImpl.class,
574 new Long(fileEntryId));
575 }
576 catch (Exception e) {
577 throw processException(e);
578 }
579 finally {
580 if (dlFileEntry != null) {
581 cacheResult(dlFileEntry);
582 }
583
584 closeSession(session);
585 }
586 }
587
588 return dlFileEntry;
589 }
590
591 public List<DLFileEntry> findByUuid(String uuid) throws SystemException {
592 return findByUuid(uuid, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
593 }
594
595 public List<DLFileEntry> findByUuid(String uuid, int start, int end)
596 throws SystemException {
597 return findByUuid(uuid, start, end, null);
598 }
599
600 public List<DLFileEntry> findByUuid(String uuid, int start, int end,
601 OrderByComparator orderByComparator) throws SystemException {
602 Object[] finderArgs = new Object[] {
603 uuid,
604
605 String.valueOf(start), String.valueOf(end),
606 String.valueOf(orderByComparator)
607 };
608
609 List<DLFileEntry> list = (List<DLFileEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_UUID,
610 finderArgs, this);
611
612 if (list == null) {
613 Session session = null;
614
615 try {
616 session = openSession();
617
618 StringBundler query = null;
619
620 if (orderByComparator != null) {
621 query = new StringBundler(3 +
622 (orderByComparator.getOrderByFields().length * 3));
623 }
624 else {
625 query = new StringBundler(3);
626 }
627
628 query.append(_SQL_SELECT_DLFILEENTRY_WHERE);
629
630 if (uuid == null) {
631 query.append(_FINDER_COLUMN_UUID_UUID_1);
632 }
633 else {
634 if (uuid.equals(StringPool.BLANK)) {
635 query.append(_FINDER_COLUMN_UUID_UUID_3);
636 }
637 else {
638 query.append(_FINDER_COLUMN_UUID_UUID_2);
639 }
640 }
641
642 if (orderByComparator != null) {
643 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
644 orderByComparator);
645 }
646
647 else {
648 query.append(DLFileEntryModelImpl.ORDER_BY_JPQL);
649 }
650
651 String sql = query.toString();
652
653 Query q = session.createQuery(sql);
654
655 QueryPos qPos = QueryPos.getInstance(q);
656
657 if (uuid != null) {
658 qPos.add(uuid);
659 }
660
661 list = (List<DLFileEntry>)QueryUtil.list(q, getDialect(),
662 start, end);
663 }
664 catch (Exception e) {
665 throw processException(e);
666 }
667 finally {
668 if (list == null) {
669 list = new ArrayList<DLFileEntry>();
670 }
671
672 cacheResult(list);
673
674 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_UUID, finderArgs,
675 list);
676
677 closeSession(session);
678 }
679 }
680
681 return list;
682 }
683
684 public DLFileEntry findByUuid_First(String uuid,
685 OrderByComparator orderByComparator)
686 throws NoSuchFileEntryException, SystemException {
687 List<DLFileEntry> list = findByUuid(uuid, 0, 1, orderByComparator);
688
689 if (list.isEmpty()) {
690 StringBundler msg = new StringBundler(4);
691
692 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
693
694 msg.append("uuid=");
695 msg.append(uuid);
696
697 msg.append(StringPool.CLOSE_CURLY_BRACE);
698
699 throw new NoSuchFileEntryException(msg.toString());
700 }
701 else {
702 return list.get(0);
703 }
704 }
705
706 public DLFileEntry findByUuid_Last(String uuid,
707 OrderByComparator orderByComparator)
708 throws NoSuchFileEntryException, SystemException {
709 int count = countByUuid(uuid);
710
711 List<DLFileEntry> list = findByUuid(uuid, count - 1, count,
712 orderByComparator);
713
714 if (list.isEmpty()) {
715 StringBundler msg = new StringBundler(4);
716
717 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
718
719 msg.append("uuid=");
720 msg.append(uuid);
721
722 msg.append(StringPool.CLOSE_CURLY_BRACE);
723
724 throw new NoSuchFileEntryException(msg.toString());
725 }
726 else {
727 return list.get(0);
728 }
729 }
730
731 public DLFileEntry[] findByUuid_PrevAndNext(long fileEntryId, String uuid,
732 OrderByComparator orderByComparator)
733 throws NoSuchFileEntryException, SystemException {
734 DLFileEntry dlFileEntry = findByPrimaryKey(fileEntryId);
735
736 Session session = null;
737
738 try {
739 session = openSession();
740
741 DLFileEntry[] array = new DLFileEntryImpl[3];
742
743 array[0] = getByUuid_PrevAndNext(session, dlFileEntry, uuid,
744 orderByComparator, true);
745
746 array[1] = dlFileEntry;
747
748 array[2] = getByUuid_PrevAndNext(session, dlFileEntry, uuid,
749 orderByComparator, false);
750
751 return array;
752 }
753 catch (Exception e) {
754 throw processException(e);
755 }
756 finally {
757 closeSession(session);
758 }
759 }
760
761 protected DLFileEntry getByUuid_PrevAndNext(Session session,
762 DLFileEntry dlFileEntry, String uuid,
763 OrderByComparator orderByComparator, boolean previous) {
764 StringBundler query = null;
765
766 if (orderByComparator != null) {
767 query = new StringBundler(6 +
768 (orderByComparator.getOrderByFields().length * 6));
769 }
770 else {
771 query = new StringBundler(3);
772 }
773
774 query.append(_SQL_SELECT_DLFILEENTRY_WHERE);
775
776 if (uuid == null) {
777 query.append(_FINDER_COLUMN_UUID_UUID_1);
778 }
779 else {
780 if (uuid.equals(StringPool.BLANK)) {
781 query.append(_FINDER_COLUMN_UUID_UUID_3);
782 }
783 else {
784 query.append(_FINDER_COLUMN_UUID_UUID_2);
785 }
786 }
787
788 if (orderByComparator != null) {
789 String[] orderByFields = orderByComparator.getOrderByFields();
790
791 if (orderByFields.length > 0) {
792 query.append(WHERE_AND);
793 }
794
795 for (int i = 0; i < orderByFields.length; i++) {
796 query.append(_ORDER_BY_ENTITY_ALIAS);
797 query.append(orderByFields[i]);
798
799 if ((i + 1) < orderByFields.length) {
800 if (orderByComparator.isAscending() ^ previous) {
801 query.append(WHERE_GREATER_THAN_HAS_NEXT);
802 }
803 else {
804 query.append(WHERE_LESSER_THAN_HAS_NEXT);
805 }
806 }
807 else {
808 if (orderByComparator.isAscending() ^ previous) {
809 query.append(WHERE_GREATER_THAN);
810 }
811 else {
812 query.append(WHERE_LESSER_THAN);
813 }
814 }
815 }
816
817 query.append(ORDER_BY_CLAUSE);
818
819 for (int i = 0; i < orderByFields.length; i++) {
820 query.append(_ORDER_BY_ENTITY_ALIAS);
821 query.append(orderByFields[i]);
822
823 if ((i + 1) < orderByFields.length) {
824 if (orderByComparator.isAscending() ^ previous) {
825 query.append(ORDER_BY_ASC_HAS_NEXT);
826 }
827 else {
828 query.append(ORDER_BY_DESC_HAS_NEXT);
829 }
830 }
831 else {
832 if (orderByComparator.isAscending() ^ previous) {
833 query.append(ORDER_BY_ASC);
834 }
835 else {
836 query.append(ORDER_BY_DESC);
837 }
838 }
839 }
840 }
841
842 else {
843 query.append(DLFileEntryModelImpl.ORDER_BY_JPQL);
844 }
845
846 String sql = query.toString();
847
848 Query q = session.createQuery(sql);
849
850 q.setFirstResult(0);
851 q.setMaxResults(2);
852
853 QueryPos qPos = QueryPos.getInstance(q);
854
855 if (uuid != null) {
856 qPos.add(uuid);
857 }
858
859 if (orderByComparator != null) {
860 Object[] values = orderByComparator.getOrderByValues(dlFileEntry);
861
862 for (Object value : values) {
863 qPos.add(value);
864 }
865 }
866
867 List<DLFileEntry> list = q.list();
868
869 if (list.size() == 2) {
870 return list.get(1);
871 }
872 else {
873 return null;
874 }
875 }
876
877 public DLFileEntry findByUUID_G(String uuid, long groupId)
878 throws NoSuchFileEntryException, SystemException {
879 DLFileEntry dlFileEntry = fetchByUUID_G(uuid, groupId);
880
881 if (dlFileEntry == null) {
882 StringBundler msg = new StringBundler(6);
883
884 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
885
886 msg.append("uuid=");
887 msg.append(uuid);
888
889 msg.append(", groupId=");
890 msg.append(groupId);
891
892 msg.append(StringPool.CLOSE_CURLY_BRACE);
893
894 if (_log.isWarnEnabled()) {
895 _log.warn(msg.toString());
896 }
897
898 throw new NoSuchFileEntryException(msg.toString());
899 }
900
901 return dlFileEntry;
902 }
903
904 public DLFileEntry fetchByUUID_G(String uuid, long groupId)
905 throws SystemException {
906 return fetchByUUID_G(uuid, groupId, true);
907 }
908
909 public DLFileEntry fetchByUUID_G(String uuid, long groupId,
910 boolean retrieveFromCache) throws SystemException {
911 Object[] finderArgs = new Object[] { uuid, new Long(groupId) };
912
913 Object result = null;
914
915 if (retrieveFromCache) {
916 result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_UUID_G,
917 finderArgs, this);
918 }
919
920 if (result == null) {
921 Session session = null;
922
923 try {
924 session = openSession();
925
926 StringBundler query = new StringBundler(4);
927
928 query.append(_SQL_SELECT_DLFILEENTRY_WHERE);
929
930 if (uuid == null) {
931 query.append(_FINDER_COLUMN_UUID_G_UUID_1);
932 }
933 else {
934 if (uuid.equals(StringPool.BLANK)) {
935 query.append(_FINDER_COLUMN_UUID_G_UUID_3);
936 }
937 else {
938 query.append(_FINDER_COLUMN_UUID_G_UUID_2);
939 }
940 }
941
942 query.append(_FINDER_COLUMN_UUID_G_GROUPID_2);
943
944 query.append(DLFileEntryModelImpl.ORDER_BY_JPQL);
945
946 String sql = query.toString();
947
948 Query q = session.createQuery(sql);
949
950 QueryPos qPos = QueryPos.getInstance(q);
951
952 if (uuid != null) {
953 qPos.add(uuid);
954 }
955
956 qPos.add(groupId);
957
958 List<DLFileEntry> list = q.list();
959
960 result = list;
961
962 DLFileEntry dlFileEntry = null;
963
964 if (list.isEmpty()) {
965 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
966 finderArgs, list);
967 }
968 else {
969 dlFileEntry = list.get(0);
970
971 cacheResult(dlFileEntry);
972
973 if ((dlFileEntry.getUuid() == null) ||
974 !dlFileEntry.getUuid().equals(uuid) ||
975 (dlFileEntry.getGroupId() != groupId)) {
976 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
977 finderArgs, dlFileEntry);
978 }
979 }
980
981 return dlFileEntry;
982 }
983 catch (Exception e) {
984 throw processException(e);
985 }
986 finally {
987 if (result == null) {
988 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
989 finderArgs, new ArrayList<DLFileEntry>());
990 }
991
992 closeSession(session);
993 }
994 }
995 else {
996 if (result instanceof List<?>) {
997 return null;
998 }
999 else {
1000 return (DLFileEntry)result;
1001 }
1002 }
1003 }
1004
1005 public List<DLFileEntry> findByGroupId(long groupId)
1006 throws SystemException {
1007 return findByGroupId(groupId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1008 }
1009
1010 public List<DLFileEntry> findByGroupId(long groupId, int start, int end)
1011 throws SystemException {
1012 return findByGroupId(groupId, start, end, null);
1013 }
1014
1015 public List<DLFileEntry> findByGroupId(long groupId, int start, int end,
1016 OrderByComparator orderByComparator) throws SystemException {
1017 Object[] finderArgs = new Object[] {
1018 new Long(groupId),
1019
1020 String.valueOf(start), String.valueOf(end),
1021 String.valueOf(orderByComparator)
1022 };
1023
1024 List<DLFileEntry> list = (List<DLFileEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_GROUPID,
1025 finderArgs, this);
1026
1027 if (list == null) {
1028 Session session = null;
1029
1030 try {
1031 session = openSession();
1032
1033 StringBundler query = null;
1034
1035 if (orderByComparator != null) {
1036 query = new StringBundler(3 +
1037 (orderByComparator.getOrderByFields().length * 3));
1038 }
1039 else {
1040 query = new StringBundler(3);
1041 }
1042
1043 query.append(_SQL_SELECT_DLFILEENTRY_WHERE);
1044
1045 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1046
1047 if (orderByComparator != null) {
1048 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1049 orderByComparator);
1050 }
1051
1052 else {
1053 query.append(DLFileEntryModelImpl.ORDER_BY_JPQL);
1054 }
1055
1056 String sql = query.toString();
1057
1058 Query q = session.createQuery(sql);
1059
1060 QueryPos qPos = QueryPos.getInstance(q);
1061
1062 qPos.add(groupId);
1063
1064 list = (List<DLFileEntry>)QueryUtil.list(q, getDialect(),
1065 start, end);
1066 }
1067 catch (Exception e) {
1068 throw processException(e);
1069 }
1070 finally {
1071 if (list == null) {
1072 list = new ArrayList<DLFileEntry>();
1073 }
1074
1075 cacheResult(list);
1076
1077 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_GROUPID,
1078 finderArgs, list);
1079
1080 closeSession(session);
1081 }
1082 }
1083
1084 return list;
1085 }
1086
1087 public DLFileEntry findByGroupId_First(long groupId,
1088 OrderByComparator orderByComparator)
1089 throws NoSuchFileEntryException, SystemException {
1090 List<DLFileEntry> list = findByGroupId(groupId, 0, 1, orderByComparator);
1091
1092 if (list.isEmpty()) {
1093 StringBundler msg = new StringBundler(4);
1094
1095 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1096
1097 msg.append("groupId=");
1098 msg.append(groupId);
1099
1100 msg.append(StringPool.CLOSE_CURLY_BRACE);
1101
1102 throw new NoSuchFileEntryException(msg.toString());
1103 }
1104 else {
1105 return list.get(0);
1106 }
1107 }
1108
1109 public DLFileEntry findByGroupId_Last(long groupId,
1110 OrderByComparator orderByComparator)
1111 throws NoSuchFileEntryException, SystemException {
1112 int count = countByGroupId(groupId);
1113
1114 List<DLFileEntry> list = findByGroupId(groupId, count - 1, count,
1115 orderByComparator);
1116
1117 if (list.isEmpty()) {
1118 StringBundler msg = new StringBundler(4);
1119
1120 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1121
1122 msg.append("groupId=");
1123 msg.append(groupId);
1124
1125 msg.append(StringPool.CLOSE_CURLY_BRACE);
1126
1127 throw new NoSuchFileEntryException(msg.toString());
1128 }
1129 else {
1130 return list.get(0);
1131 }
1132 }
1133
1134 public DLFileEntry[] findByGroupId_PrevAndNext(long fileEntryId,
1135 long groupId, OrderByComparator orderByComparator)
1136 throws NoSuchFileEntryException, SystemException {
1137 DLFileEntry dlFileEntry = findByPrimaryKey(fileEntryId);
1138
1139 Session session = null;
1140
1141 try {
1142 session = openSession();
1143
1144 DLFileEntry[] array = new DLFileEntryImpl[3];
1145
1146 array[0] = getByGroupId_PrevAndNext(session, dlFileEntry, groupId,
1147 orderByComparator, true);
1148
1149 array[1] = dlFileEntry;
1150
1151 array[2] = getByGroupId_PrevAndNext(session, dlFileEntry, groupId,
1152 orderByComparator, false);
1153
1154 return array;
1155 }
1156 catch (Exception e) {
1157 throw processException(e);
1158 }
1159 finally {
1160 closeSession(session);
1161 }
1162 }
1163
1164 protected DLFileEntry getByGroupId_PrevAndNext(Session session,
1165 DLFileEntry dlFileEntry, long groupId,
1166 OrderByComparator orderByComparator, boolean previous) {
1167 StringBundler query = null;
1168
1169 if (orderByComparator != null) {
1170 query = new StringBundler(6 +
1171 (orderByComparator.getOrderByFields().length * 6));
1172 }
1173 else {
1174 query = new StringBundler(3);
1175 }
1176
1177 query.append(_SQL_SELECT_DLFILEENTRY_WHERE);
1178
1179 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1180
1181 if (orderByComparator != null) {
1182 String[] orderByFields = orderByComparator.getOrderByFields();
1183
1184 if (orderByFields.length > 0) {
1185 query.append(WHERE_AND);
1186 }
1187
1188 for (int i = 0; i < orderByFields.length; i++) {
1189 query.append(_ORDER_BY_ENTITY_ALIAS);
1190 query.append(orderByFields[i]);
1191
1192 if ((i + 1) < orderByFields.length) {
1193 if (orderByComparator.isAscending() ^ previous) {
1194 query.append(WHERE_GREATER_THAN_HAS_NEXT);
1195 }
1196 else {
1197 query.append(WHERE_LESSER_THAN_HAS_NEXT);
1198 }
1199 }
1200 else {
1201 if (orderByComparator.isAscending() ^ previous) {
1202 query.append(WHERE_GREATER_THAN);
1203 }
1204 else {
1205 query.append(WHERE_LESSER_THAN);
1206 }
1207 }
1208 }
1209
1210 query.append(ORDER_BY_CLAUSE);
1211
1212 for (int i = 0; i < orderByFields.length; i++) {
1213 query.append(_ORDER_BY_ENTITY_ALIAS);
1214 query.append(orderByFields[i]);
1215
1216 if ((i + 1) < orderByFields.length) {
1217 if (orderByComparator.isAscending() ^ previous) {
1218 query.append(ORDER_BY_ASC_HAS_NEXT);
1219 }
1220 else {
1221 query.append(ORDER_BY_DESC_HAS_NEXT);
1222 }
1223 }
1224 else {
1225 if (orderByComparator.isAscending() ^ previous) {
1226 query.append(ORDER_BY_ASC);
1227 }
1228 else {
1229 query.append(ORDER_BY_DESC);
1230 }
1231 }
1232 }
1233 }
1234
1235 else {
1236 query.append(DLFileEntryModelImpl.ORDER_BY_JPQL);
1237 }
1238
1239 String sql = query.toString();
1240
1241 Query q = session.createQuery(sql);
1242
1243 q.setFirstResult(0);
1244 q.setMaxResults(2);
1245
1246 QueryPos qPos = QueryPos.getInstance(q);
1247
1248 qPos.add(groupId);
1249
1250 if (orderByComparator != null) {
1251 Object[] values = orderByComparator.getOrderByValues(dlFileEntry);
1252
1253 for (Object value : values) {
1254 qPos.add(value);
1255 }
1256 }
1257
1258 List<DLFileEntry> list = q.list();
1259
1260 if (list.size() == 2) {
1261 return list.get(1);
1262 }
1263 else {
1264 return null;
1265 }
1266 }
1267
1268 public List<DLFileEntry> filterFindByGroupId(long groupId)
1269 throws SystemException {
1270 return filterFindByGroupId(groupId, QueryUtil.ALL_POS,
1271 QueryUtil.ALL_POS, null);
1272 }
1273
1274 public List<DLFileEntry> filterFindByGroupId(long groupId, int start,
1275 int end) throws SystemException {
1276 return filterFindByGroupId(groupId, start, end, null);
1277 }
1278
1279 public List<DLFileEntry> filterFindByGroupId(long groupId, int start,
1280 int end, OrderByComparator orderByComparator) throws SystemException {
1281 if (!InlineSQLHelperUtil.isEnabled(groupId)) {
1282 return findByGroupId(groupId, start, end, orderByComparator);
1283 }
1284
1285 Session session = null;
1286
1287 try {
1288 session = openSession();
1289
1290 StringBundler query = null;
1291
1292 if (orderByComparator != null) {
1293 query = new StringBundler(3 +
1294 (orderByComparator.getOrderByFields().length * 3));
1295 }
1296 else {
1297 query = new StringBundler(3);
1298 }
1299
1300 query.append(_FILTER_SQL_SELECT_DLFILEENTRY_WHERE);
1301
1302 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1303
1304 if (orderByComparator != null) {
1305 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1306 orderByComparator);
1307 }
1308
1309 else {
1310 query.append(DLFileEntryModelImpl.ORDER_BY_JPQL);
1311 }
1312
1313 String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
1314 DLFileEntry.class.getName(), _FILTER_COLUMN_FILEENTRYID,
1315 _FILTER_COLUMN_USERID, groupId);
1316
1317 SQLQuery q = session.createSQLQuery(sql);
1318
1319 q.addEntity(_FILTER_ENTITY_ALIAS, DLFileEntryImpl.class);
1320
1321 QueryPos qPos = QueryPos.getInstance(q);
1322
1323 qPos.add(groupId);
1324
1325 return (List<DLFileEntry>)QueryUtil.list(q, getDialect(), start, end);
1326 }
1327 catch (Exception e) {
1328 throw processException(e);
1329 }
1330 finally {
1331 closeSession(session);
1332 }
1333 }
1334
1335 public List<DLFileEntry> findByCompanyId(long companyId)
1336 throws SystemException {
1337 return findByCompanyId(companyId, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
1338 null);
1339 }
1340
1341 public List<DLFileEntry> findByCompanyId(long companyId, int start, int end)
1342 throws SystemException {
1343 return findByCompanyId(companyId, start, end, null);
1344 }
1345
1346 public List<DLFileEntry> findByCompanyId(long companyId, int start,
1347 int end, OrderByComparator orderByComparator) throws SystemException {
1348 Object[] finderArgs = new Object[] {
1349 new Long(companyId),
1350
1351 String.valueOf(start), String.valueOf(end),
1352 String.valueOf(orderByComparator)
1353 };
1354
1355 List<DLFileEntry> list = (List<DLFileEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_COMPANYID,
1356 finderArgs, this);
1357
1358 if (list == null) {
1359 Session session = null;
1360
1361 try {
1362 session = openSession();
1363
1364 StringBundler query = null;
1365
1366 if (orderByComparator != null) {
1367 query = new StringBundler(3 +
1368 (orderByComparator.getOrderByFields().length * 3));
1369 }
1370 else {
1371 query = new StringBundler(3);
1372 }
1373
1374 query.append(_SQL_SELECT_DLFILEENTRY_WHERE);
1375
1376 query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
1377
1378 if (orderByComparator != null) {
1379 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1380 orderByComparator);
1381 }
1382
1383 else {
1384 query.append(DLFileEntryModelImpl.ORDER_BY_JPQL);
1385 }
1386
1387 String sql = query.toString();
1388
1389 Query q = session.createQuery(sql);
1390
1391 QueryPos qPos = QueryPos.getInstance(q);
1392
1393 qPos.add(companyId);
1394
1395 list = (List<DLFileEntry>)QueryUtil.list(q, getDialect(),
1396 start, end);
1397 }
1398 catch (Exception e) {
1399 throw processException(e);
1400 }
1401 finally {
1402 if (list == null) {
1403 list = new ArrayList<DLFileEntry>();
1404 }
1405
1406 cacheResult(list);
1407
1408 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_COMPANYID,
1409 finderArgs, list);
1410
1411 closeSession(session);
1412 }
1413 }
1414
1415 return list;
1416 }
1417
1418 public DLFileEntry findByCompanyId_First(long companyId,
1419 OrderByComparator orderByComparator)
1420 throws NoSuchFileEntryException, SystemException {
1421 List<DLFileEntry> list = findByCompanyId(companyId, 0, 1,
1422 orderByComparator);
1423
1424 if (list.isEmpty()) {
1425 StringBundler msg = new StringBundler(4);
1426
1427 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1428
1429 msg.append("companyId=");
1430 msg.append(companyId);
1431
1432 msg.append(StringPool.CLOSE_CURLY_BRACE);
1433
1434 throw new NoSuchFileEntryException(msg.toString());
1435 }
1436 else {
1437 return list.get(0);
1438 }
1439 }
1440
1441 public DLFileEntry findByCompanyId_Last(long companyId,
1442 OrderByComparator orderByComparator)
1443 throws NoSuchFileEntryException, SystemException {
1444 int count = countByCompanyId(companyId);
1445
1446 List<DLFileEntry> list = findByCompanyId(companyId, count - 1, count,
1447 orderByComparator);
1448
1449 if (list.isEmpty()) {
1450 StringBundler msg = new StringBundler(4);
1451
1452 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1453
1454 msg.append("companyId=");
1455 msg.append(companyId);
1456
1457 msg.append(StringPool.CLOSE_CURLY_BRACE);
1458
1459 throw new NoSuchFileEntryException(msg.toString());
1460 }
1461 else {
1462 return list.get(0);
1463 }
1464 }
1465
1466 public DLFileEntry[] findByCompanyId_PrevAndNext(long fileEntryId,
1467 long companyId, OrderByComparator orderByComparator)
1468 throws NoSuchFileEntryException, SystemException {
1469 DLFileEntry dlFileEntry = findByPrimaryKey(fileEntryId);
1470
1471 Session session = null;
1472
1473 try {
1474 session = openSession();
1475
1476 DLFileEntry[] array = new DLFileEntryImpl[3];
1477
1478 array[0] = getByCompanyId_PrevAndNext(session, dlFileEntry,
1479 companyId, orderByComparator, true);
1480
1481 array[1] = dlFileEntry;
1482
1483 array[2] = getByCompanyId_PrevAndNext(session, dlFileEntry,
1484 companyId, orderByComparator, false);
1485
1486 return array;
1487 }
1488 catch (Exception e) {
1489 throw processException(e);
1490 }
1491 finally {
1492 closeSession(session);
1493 }
1494 }
1495
1496 protected DLFileEntry getByCompanyId_PrevAndNext(Session session,
1497 DLFileEntry dlFileEntry, long companyId,
1498 OrderByComparator orderByComparator, boolean previous) {
1499 StringBundler query = null;
1500
1501 if (orderByComparator != null) {
1502 query = new StringBundler(6 +
1503 (orderByComparator.getOrderByFields().length * 6));
1504 }
1505 else {
1506 query = new StringBundler(3);
1507 }
1508
1509 query.append(_SQL_SELECT_DLFILEENTRY_WHERE);
1510
1511 query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
1512
1513 if (orderByComparator != null) {
1514 String[] orderByFields = orderByComparator.getOrderByFields();
1515
1516 if (orderByFields.length > 0) {
1517 query.append(WHERE_AND);
1518 }
1519
1520 for (int i = 0; i < orderByFields.length; i++) {
1521 query.append(_ORDER_BY_ENTITY_ALIAS);
1522 query.append(orderByFields[i]);
1523
1524 if ((i + 1) < orderByFields.length) {
1525 if (orderByComparator.isAscending() ^ previous) {
1526 query.append(WHERE_GREATER_THAN_HAS_NEXT);
1527 }
1528 else {
1529 query.append(WHERE_LESSER_THAN_HAS_NEXT);
1530 }
1531 }
1532 else {
1533 if (orderByComparator.isAscending() ^ previous) {
1534 query.append(WHERE_GREATER_THAN);
1535 }
1536 else {
1537 query.append(WHERE_LESSER_THAN);
1538 }
1539 }
1540 }
1541
1542 query.append(ORDER_BY_CLAUSE);
1543
1544 for (int i = 0; i < orderByFields.length; i++) {
1545 query.append(_ORDER_BY_ENTITY_ALIAS);
1546 query.append(orderByFields[i]);
1547
1548 if ((i + 1) < orderByFields.length) {
1549 if (orderByComparator.isAscending() ^ previous) {
1550 query.append(ORDER_BY_ASC_HAS_NEXT);
1551 }
1552 else {
1553 query.append(ORDER_BY_DESC_HAS_NEXT);
1554 }
1555 }
1556 else {
1557 if (orderByComparator.isAscending() ^ previous) {
1558 query.append(ORDER_BY_ASC);
1559 }
1560 else {
1561 query.append(ORDER_BY_DESC);
1562 }
1563 }
1564 }
1565 }
1566
1567 else {
1568 query.append(DLFileEntryModelImpl.ORDER_BY_JPQL);
1569 }
1570
1571 String sql = query.toString();
1572
1573 Query q = session.createQuery(sql);
1574
1575 q.setFirstResult(0);
1576 q.setMaxResults(2);
1577
1578 QueryPos qPos = QueryPos.getInstance(q);
1579
1580 qPos.add(companyId);
1581
1582 if (orderByComparator != null) {
1583 Object[] values = orderByComparator.getOrderByValues(dlFileEntry);
1584
1585 for (Object value : values) {
1586 qPos.add(value);
1587 }
1588 }
1589
1590 List<DLFileEntry> list = q.list();
1591
1592 if (list.size() == 2) {
1593 return list.get(1);
1594 }
1595 else {
1596 return null;
1597 }
1598 }
1599
1600 public List<DLFileEntry> findByG_U(long groupId, long userId)
1601 throws SystemException {
1602 return findByG_U(groupId, userId, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
1603 null);
1604 }
1605
1606 public List<DLFileEntry> findByG_U(long groupId, long userId, int start,
1607 int end) throws SystemException {
1608 return findByG_U(groupId, userId, start, end, null);
1609 }
1610
1611 public List<DLFileEntry> findByG_U(long groupId, long userId, int start,
1612 int end, OrderByComparator orderByComparator) throws SystemException {
1613 Object[] finderArgs = new Object[] {
1614 new Long(groupId), new Long(userId),
1615
1616 String.valueOf(start), String.valueOf(end),
1617 String.valueOf(orderByComparator)
1618 };
1619
1620 List<DLFileEntry> list = (List<DLFileEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_U,
1621 finderArgs, this);
1622
1623 if (list == null) {
1624 Session session = null;
1625
1626 try {
1627 session = openSession();
1628
1629 StringBundler query = null;
1630
1631 if (orderByComparator != null) {
1632 query = new StringBundler(4 +
1633 (orderByComparator.getOrderByFields().length * 3));
1634 }
1635 else {
1636 query = new StringBundler(4);
1637 }
1638
1639 query.append(_SQL_SELECT_DLFILEENTRY_WHERE);
1640
1641 query.append(_FINDER_COLUMN_G_U_GROUPID_2);
1642
1643 query.append(_FINDER_COLUMN_G_U_USERID_2);
1644
1645 if (orderByComparator != null) {
1646 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1647 orderByComparator);
1648 }
1649
1650 else {
1651 query.append(DLFileEntryModelImpl.ORDER_BY_JPQL);
1652 }
1653
1654 String sql = query.toString();
1655
1656 Query q = session.createQuery(sql);
1657
1658 QueryPos qPos = QueryPos.getInstance(q);
1659
1660 qPos.add(groupId);
1661
1662 qPos.add(userId);
1663
1664 list = (List<DLFileEntry>)QueryUtil.list(q, getDialect(),
1665 start, end);
1666 }
1667 catch (Exception e) {
1668 throw processException(e);
1669 }
1670 finally {
1671 if (list == null) {
1672 list = new ArrayList<DLFileEntry>();
1673 }
1674
1675 cacheResult(list);
1676
1677 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_U, finderArgs,
1678 list);
1679
1680 closeSession(session);
1681 }
1682 }
1683
1684 return list;
1685 }
1686
1687 public DLFileEntry findByG_U_First(long groupId, long userId,
1688 OrderByComparator orderByComparator)
1689 throws NoSuchFileEntryException, SystemException {
1690 List<DLFileEntry> list = findByG_U(groupId, userId, 0, 1,
1691 orderByComparator);
1692
1693 if (list.isEmpty()) {
1694 StringBundler msg = new StringBundler(6);
1695
1696 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1697
1698 msg.append("groupId=");
1699 msg.append(groupId);
1700
1701 msg.append(", userId=");
1702 msg.append(userId);
1703
1704 msg.append(StringPool.CLOSE_CURLY_BRACE);
1705
1706 throw new NoSuchFileEntryException(msg.toString());
1707 }
1708 else {
1709 return list.get(0);
1710 }
1711 }
1712
1713 public DLFileEntry findByG_U_Last(long groupId, long userId,
1714 OrderByComparator orderByComparator)
1715 throws NoSuchFileEntryException, SystemException {
1716 int count = countByG_U(groupId, userId);
1717
1718 List<DLFileEntry> list = findByG_U(groupId, userId, count - 1, count,
1719 orderByComparator);
1720
1721 if (list.isEmpty()) {
1722 StringBundler msg = new StringBundler(6);
1723
1724 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1725
1726 msg.append("groupId=");
1727 msg.append(groupId);
1728
1729 msg.append(", userId=");
1730 msg.append(userId);
1731
1732 msg.append(StringPool.CLOSE_CURLY_BRACE);
1733
1734 throw new NoSuchFileEntryException(msg.toString());
1735 }
1736 else {
1737 return list.get(0);
1738 }
1739 }
1740
1741 public DLFileEntry[] findByG_U_PrevAndNext(long fileEntryId, long groupId,
1742 long userId, OrderByComparator orderByComparator)
1743 throws NoSuchFileEntryException, SystemException {
1744 DLFileEntry dlFileEntry = findByPrimaryKey(fileEntryId);
1745
1746 Session session = null;
1747
1748 try {
1749 session = openSession();
1750
1751 DLFileEntry[] array = new DLFileEntryImpl[3];
1752
1753 array[0] = getByG_U_PrevAndNext(session, dlFileEntry, groupId,
1754 userId, orderByComparator, true);
1755
1756 array[1] = dlFileEntry;
1757
1758 array[2] = getByG_U_PrevAndNext(session, dlFileEntry, groupId,
1759 userId, orderByComparator, false);
1760
1761 return array;
1762 }
1763 catch (Exception e) {
1764 throw processException(e);
1765 }
1766 finally {
1767 closeSession(session);
1768 }
1769 }
1770
1771 protected DLFileEntry getByG_U_PrevAndNext(Session session,
1772 DLFileEntry dlFileEntry, long groupId, long userId,
1773 OrderByComparator orderByComparator, boolean previous) {
1774 StringBundler query = null;
1775
1776 if (orderByComparator != null) {
1777 query = new StringBundler(6 +
1778 (orderByComparator.getOrderByFields().length * 6));
1779 }
1780 else {
1781 query = new StringBundler(3);
1782 }
1783
1784 query.append(_SQL_SELECT_DLFILEENTRY_WHERE);
1785
1786 query.append(_FINDER_COLUMN_G_U_GROUPID_2);
1787
1788 query.append(_FINDER_COLUMN_G_U_USERID_2);
1789
1790 if (orderByComparator != null) {
1791 String[] orderByFields = orderByComparator.getOrderByFields();
1792
1793 if (orderByFields.length > 0) {
1794 query.append(WHERE_AND);
1795 }
1796
1797 for (int i = 0; i < orderByFields.length; i++) {
1798 query.append(_ORDER_BY_ENTITY_ALIAS);
1799 query.append(orderByFields[i]);
1800
1801 if ((i + 1) < orderByFields.length) {
1802 if (orderByComparator.isAscending() ^ previous) {
1803 query.append(WHERE_GREATER_THAN_HAS_NEXT);
1804 }
1805 else {
1806 query.append(WHERE_LESSER_THAN_HAS_NEXT);
1807 }
1808 }
1809 else {
1810 if (orderByComparator.isAscending() ^ previous) {
1811 query.append(WHERE_GREATER_THAN);
1812 }
1813 else {
1814 query.append(WHERE_LESSER_THAN);
1815 }
1816 }
1817 }
1818
1819 query.append(ORDER_BY_CLAUSE);
1820
1821 for (int i = 0; i < orderByFields.length; i++) {
1822 query.append(_ORDER_BY_ENTITY_ALIAS);
1823 query.append(orderByFields[i]);
1824
1825 if ((i + 1) < orderByFields.length) {
1826 if (orderByComparator.isAscending() ^ previous) {
1827 query.append(ORDER_BY_ASC_HAS_NEXT);
1828 }
1829 else {
1830 query.append(ORDER_BY_DESC_HAS_NEXT);
1831 }
1832 }
1833 else {
1834 if (orderByComparator.isAscending() ^ previous) {
1835 query.append(ORDER_BY_ASC);
1836 }
1837 else {
1838 query.append(ORDER_BY_DESC);
1839 }
1840 }
1841 }
1842 }
1843
1844 else {
1845 query.append(DLFileEntryModelImpl.ORDER_BY_JPQL);
1846 }
1847
1848 String sql = query.toString();
1849
1850 Query q = session.createQuery(sql);
1851
1852 q.setFirstResult(0);
1853 q.setMaxResults(2);
1854
1855 QueryPos qPos = QueryPos.getInstance(q);
1856
1857 qPos.add(groupId);
1858
1859 qPos.add(userId);
1860
1861 if (orderByComparator != null) {
1862 Object[] values = orderByComparator.getOrderByValues(dlFileEntry);
1863
1864 for (Object value : values) {
1865 qPos.add(value);
1866 }
1867 }
1868
1869 List<DLFileEntry> list = q.list();
1870
1871 if (list.size() == 2) {
1872 return list.get(1);
1873 }
1874 else {
1875 return null;
1876 }
1877 }
1878
1879 public List<DLFileEntry> filterFindByG_U(long groupId, long userId)
1880 throws SystemException {
1881 return filterFindByG_U(groupId, userId, QueryUtil.ALL_POS,
1882 QueryUtil.ALL_POS, null);
1883 }
1884
1885 public List<DLFileEntry> filterFindByG_U(long groupId, long userId,
1886 int start, int end) throws SystemException {
1887 return filterFindByG_U(groupId, userId, start, end, null);
1888 }
1889
1890 public List<DLFileEntry> filterFindByG_U(long groupId, long userId,
1891 int start, int end, OrderByComparator orderByComparator)
1892 throws SystemException {
1893 if (!InlineSQLHelperUtil.isEnabled(groupId)) {
1894 return findByG_U(groupId, userId, start, end, orderByComparator);
1895 }
1896
1897 Session session = null;
1898
1899 try {
1900 session = openSession();
1901
1902 StringBundler query = null;
1903
1904 if (orderByComparator != null) {
1905 query = new StringBundler(4 +
1906 (orderByComparator.getOrderByFields().length * 3));
1907 }
1908 else {
1909 query = new StringBundler(4);
1910 }
1911
1912 query.append(_FILTER_SQL_SELECT_DLFILEENTRY_WHERE);
1913
1914 query.append(_FINDER_COLUMN_G_U_GROUPID_2);
1915
1916 query.append(_FINDER_COLUMN_G_U_USERID_2);
1917
1918 if (orderByComparator != null) {
1919 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1920 orderByComparator);
1921 }
1922
1923 else {
1924 query.append(DLFileEntryModelImpl.ORDER_BY_JPQL);
1925 }
1926
1927 String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
1928 DLFileEntry.class.getName(), _FILTER_COLUMN_FILEENTRYID,
1929 _FILTER_COLUMN_USERID, groupId);
1930
1931 SQLQuery q = session.createSQLQuery(sql);
1932
1933 q.addEntity(_FILTER_ENTITY_ALIAS, DLFileEntryImpl.class);
1934
1935 QueryPos qPos = QueryPos.getInstance(q);
1936
1937 qPos.add(groupId);
1938
1939 qPos.add(userId);
1940
1941 return (List<DLFileEntry>)QueryUtil.list(q, getDialect(), start, end);
1942 }
1943 catch (Exception e) {
1944 throw processException(e);
1945 }
1946 finally {
1947 closeSession(session);
1948 }
1949 }
1950
1951 public List<DLFileEntry> findByG_F(long groupId, long folderId)
1952 throws SystemException {
1953 return findByG_F(groupId, folderId, QueryUtil.ALL_POS,
1954 QueryUtil.ALL_POS, null);
1955 }
1956
1957 public List<DLFileEntry> findByG_F(long groupId, long folderId, int start,
1958 int end) throws SystemException {
1959 return findByG_F(groupId, folderId, start, end, null);
1960 }
1961
1962 public List<DLFileEntry> findByG_F(long groupId, long folderId, int start,
1963 int end, OrderByComparator orderByComparator) throws SystemException {
1964 Object[] finderArgs = new Object[] {
1965 new Long(groupId), new Long(folderId),
1966
1967 String.valueOf(start), String.valueOf(end),
1968 String.valueOf(orderByComparator)
1969 };
1970
1971 List<DLFileEntry> list = (List<DLFileEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_F,
1972 finderArgs, this);
1973
1974 if (list == null) {
1975 Session session = null;
1976
1977 try {
1978 session = openSession();
1979
1980 StringBundler query = null;
1981
1982 if (orderByComparator != null) {
1983 query = new StringBundler(4 +
1984 (orderByComparator.getOrderByFields().length * 3));
1985 }
1986 else {
1987 query = new StringBundler(4);
1988 }
1989
1990 query.append(_SQL_SELECT_DLFILEENTRY_WHERE);
1991
1992 query.append(_FINDER_COLUMN_G_F_GROUPID_2);
1993
1994 query.append(_FINDER_COLUMN_G_F_FOLDERID_2);
1995
1996 if (orderByComparator != null) {
1997 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1998 orderByComparator);
1999 }
2000
2001 else {
2002 query.append(DLFileEntryModelImpl.ORDER_BY_JPQL);
2003 }
2004
2005 String sql = query.toString();
2006
2007 Query q = session.createQuery(sql);
2008
2009 QueryPos qPos = QueryPos.getInstance(q);
2010
2011 qPos.add(groupId);
2012
2013 qPos.add(folderId);
2014
2015 list = (List<DLFileEntry>)QueryUtil.list(q, getDialect(),
2016 start, end);
2017 }
2018 catch (Exception e) {
2019 throw processException(e);
2020 }
2021 finally {
2022 if (list == null) {
2023 list = new ArrayList<DLFileEntry>();
2024 }
2025
2026 cacheResult(list);
2027
2028 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_F, finderArgs,
2029 list);
2030
2031 closeSession(session);
2032 }
2033 }
2034
2035 return list;
2036 }
2037
2038 public DLFileEntry findByG_F_First(long groupId, long folderId,
2039 OrderByComparator orderByComparator)
2040 throws NoSuchFileEntryException, SystemException {
2041 List<DLFileEntry> list = findByG_F(groupId, folderId, 0, 1,
2042 orderByComparator);
2043
2044 if (list.isEmpty()) {
2045 StringBundler msg = new StringBundler(6);
2046
2047 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2048
2049 msg.append("groupId=");
2050 msg.append(groupId);
2051
2052 msg.append(", folderId=");
2053 msg.append(folderId);
2054
2055 msg.append(StringPool.CLOSE_CURLY_BRACE);
2056
2057 throw new NoSuchFileEntryException(msg.toString());
2058 }
2059 else {
2060 return list.get(0);
2061 }
2062 }
2063
2064 public DLFileEntry findByG_F_Last(long groupId, long folderId,
2065 OrderByComparator orderByComparator)
2066 throws NoSuchFileEntryException, SystemException {
2067 int count = countByG_F(groupId, folderId);
2068
2069 List<DLFileEntry> list = findByG_F(groupId, folderId, count - 1, count,
2070 orderByComparator);
2071
2072 if (list.isEmpty()) {
2073 StringBundler msg = new StringBundler(6);
2074
2075 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2076
2077 msg.append("groupId=");
2078 msg.append(groupId);
2079
2080 msg.append(", folderId=");
2081 msg.append(folderId);
2082
2083 msg.append(StringPool.CLOSE_CURLY_BRACE);
2084
2085 throw new NoSuchFileEntryException(msg.toString());
2086 }
2087 else {
2088 return list.get(0);
2089 }
2090 }
2091
2092 public DLFileEntry[] findByG_F_PrevAndNext(long fileEntryId, long groupId,
2093 long folderId, OrderByComparator orderByComparator)
2094 throws NoSuchFileEntryException, SystemException {
2095 DLFileEntry dlFileEntry = findByPrimaryKey(fileEntryId);
2096
2097 Session session = null;
2098
2099 try {
2100 session = openSession();
2101
2102 DLFileEntry[] array = new DLFileEntryImpl[3];
2103
2104 array[0] = getByG_F_PrevAndNext(session, dlFileEntry, groupId,
2105 folderId, orderByComparator, true);
2106
2107 array[1] = dlFileEntry;
2108
2109 array[2] = getByG_F_PrevAndNext(session, dlFileEntry, groupId,
2110 folderId, orderByComparator, false);
2111
2112 return array;
2113 }
2114 catch (Exception e) {
2115 throw processException(e);
2116 }
2117 finally {
2118 closeSession(session);
2119 }
2120 }
2121
2122 protected DLFileEntry getByG_F_PrevAndNext(Session session,
2123 DLFileEntry dlFileEntry, long groupId, long folderId,
2124 OrderByComparator orderByComparator, boolean previous) {
2125 StringBundler query = null;
2126
2127 if (orderByComparator != null) {
2128 query = new StringBundler(6 +
2129 (orderByComparator.getOrderByFields().length * 6));
2130 }
2131 else {
2132 query = new StringBundler(3);
2133 }
2134
2135 query.append(_SQL_SELECT_DLFILEENTRY_WHERE);
2136
2137 query.append(_FINDER_COLUMN_G_F_GROUPID_2);
2138
2139 query.append(_FINDER_COLUMN_G_F_FOLDERID_2);
2140
2141 if (orderByComparator != null) {
2142 String[] orderByFields = orderByComparator.getOrderByFields();
2143
2144 if (orderByFields.length > 0) {
2145 query.append(WHERE_AND);
2146 }
2147
2148 for (int i = 0; i < orderByFields.length; i++) {
2149 query.append(_ORDER_BY_ENTITY_ALIAS);
2150 query.append(orderByFields[i]);
2151
2152 if ((i + 1) < orderByFields.length) {
2153 if (orderByComparator.isAscending() ^ previous) {
2154 query.append(WHERE_GREATER_THAN_HAS_NEXT);
2155 }
2156 else {
2157 query.append(WHERE_LESSER_THAN_HAS_NEXT);
2158 }
2159 }
2160 else {
2161 if (orderByComparator.isAscending() ^ previous) {
2162 query.append(WHERE_GREATER_THAN);
2163 }
2164 else {
2165 query.append(WHERE_LESSER_THAN);
2166 }
2167 }
2168 }
2169
2170 query.append(ORDER_BY_CLAUSE);
2171
2172 for (int i = 0; i < orderByFields.length; i++) {
2173 query.append(_ORDER_BY_ENTITY_ALIAS);
2174 query.append(orderByFields[i]);
2175
2176 if ((i + 1) < orderByFields.length) {
2177 if (orderByComparator.isAscending() ^ previous) {
2178 query.append(ORDER_BY_ASC_HAS_NEXT);
2179 }
2180 else {
2181 query.append(ORDER_BY_DESC_HAS_NEXT);
2182 }
2183 }
2184 else {
2185 if (orderByComparator.isAscending() ^ previous) {
2186 query.append(ORDER_BY_ASC);
2187 }
2188 else {
2189 query.append(ORDER_BY_DESC);
2190 }
2191 }
2192 }
2193 }
2194
2195 else {
2196 query.append(DLFileEntryModelImpl.ORDER_BY_JPQL);
2197 }
2198
2199 String sql = query.toString();
2200
2201 Query q = session.createQuery(sql);
2202
2203 q.setFirstResult(0);
2204 q.setMaxResults(2);
2205
2206 QueryPos qPos = QueryPos.getInstance(q);
2207
2208 qPos.add(groupId);
2209
2210 qPos.add(folderId);
2211
2212 if (orderByComparator != null) {
2213 Object[] values = orderByComparator.getOrderByValues(dlFileEntry);
2214
2215 for (Object value : values) {
2216 qPos.add(value);
2217 }
2218 }
2219
2220 List<DLFileEntry> list = q.list();
2221
2222 if (list.size() == 2) {
2223 return list.get(1);
2224 }
2225 else {
2226 return null;
2227 }
2228 }
2229
2230 public List<DLFileEntry> filterFindByG_F(long groupId, long folderId)
2231 throws SystemException {
2232 return filterFindByG_F(groupId, folderId, QueryUtil.ALL_POS,
2233 QueryUtil.ALL_POS, null);
2234 }
2235
2236 public List<DLFileEntry> filterFindByG_F(long groupId, long folderId,
2237 int start, int end) throws SystemException {
2238 return filterFindByG_F(groupId, folderId, start, end, null);
2239 }
2240
2241 public List<DLFileEntry> filterFindByG_F(long groupId, long folderId,
2242 int start, int end, OrderByComparator orderByComparator)
2243 throws SystemException {
2244 if (!InlineSQLHelperUtil.isEnabled(groupId)) {
2245 return findByG_F(groupId, folderId, start, end, orderByComparator);
2246 }
2247
2248 Session session = null;
2249
2250 try {
2251 session = openSession();
2252
2253 StringBundler query = null;
2254
2255 if (orderByComparator != null) {
2256 query = new StringBundler(4 +
2257 (orderByComparator.getOrderByFields().length * 3));
2258 }
2259 else {
2260 query = new StringBundler(4);
2261 }
2262
2263 query.append(_FILTER_SQL_SELECT_DLFILEENTRY_WHERE);
2264
2265 query.append(_FINDER_COLUMN_G_F_GROUPID_2);
2266
2267 query.append(_FINDER_COLUMN_G_F_FOLDERID_2);
2268
2269 if (orderByComparator != null) {
2270 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2271 orderByComparator);
2272 }
2273
2274 else {
2275 query.append(DLFileEntryModelImpl.ORDER_BY_JPQL);
2276 }
2277
2278 String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
2279 DLFileEntry.class.getName(), _FILTER_COLUMN_FILEENTRYID,
2280 _FILTER_COLUMN_USERID, groupId);
2281
2282 SQLQuery q = session.createSQLQuery(sql);
2283
2284 q.addEntity(_FILTER_ENTITY_ALIAS, DLFileEntryImpl.class);
2285
2286 QueryPos qPos = QueryPos.getInstance(q);
2287
2288 qPos.add(groupId);
2289
2290 qPos.add(folderId);
2291
2292 return (List<DLFileEntry>)QueryUtil.list(q, getDialect(), start, end);
2293 }
2294 catch (Exception e) {
2295 throw processException(e);
2296 }
2297 finally {
2298 closeSession(session);
2299 }
2300 }
2301
2302 public DLFileEntry findByG_F_N(long groupId, long folderId, String name)
2303 throws NoSuchFileEntryException, SystemException {
2304 DLFileEntry dlFileEntry = fetchByG_F_N(groupId, folderId, name);
2305
2306 if (dlFileEntry == null) {
2307 StringBundler msg = new StringBundler(8);
2308
2309 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2310
2311 msg.append("groupId=");
2312 msg.append(groupId);
2313
2314 msg.append(", folderId=");
2315 msg.append(folderId);
2316
2317 msg.append(", name=");
2318 msg.append(name);
2319
2320 msg.append(StringPool.CLOSE_CURLY_BRACE);
2321
2322 if (_log.isWarnEnabled()) {
2323 _log.warn(msg.toString());
2324 }
2325
2326 throw new NoSuchFileEntryException(msg.toString());
2327 }
2328
2329 return dlFileEntry;
2330 }
2331
2332 public DLFileEntry fetchByG_F_N(long groupId, long folderId, String name)
2333 throws SystemException {
2334 return fetchByG_F_N(groupId, folderId, name, true);
2335 }
2336
2337 public DLFileEntry fetchByG_F_N(long groupId, long folderId, String name,
2338 boolean retrieveFromCache) throws SystemException {
2339 Object[] finderArgs = new Object[] {
2340 new Long(groupId), new Long(folderId),
2341
2342 name
2343 };
2344
2345 Object result = null;
2346
2347 if (retrieveFromCache) {
2348 result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_G_F_N,
2349 finderArgs, this);
2350 }
2351
2352 if (result == null) {
2353 Session session = null;
2354
2355 try {
2356 session = openSession();
2357
2358 StringBundler query = new StringBundler(5);
2359
2360 query.append(_SQL_SELECT_DLFILEENTRY_WHERE);
2361
2362 query.append(_FINDER_COLUMN_G_F_N_GROUPID_2);
2363
2364 query.append(_FINDER_COLUMN_G_F_N_FOLDERID_2);
2365
2366 if (name == null) {
2367 query.append(_FINDER_COLUMN_G_F_N_NAME_1);
2368 }
2369 else {
2370 if (name.equals(StringPool.BLANK)) {
2371 query.append(_FINDER_COLUMN_G_F_N_NAME_3);
2372 }
2373 else {
2374 query.append(_FINDER_COLUMN_G_F_N_NAME_2);
2375 }
2376 }
2377
2378 query.append(DLFileEntryModelImpl.ORDER_BY_JPQL);
2379
2380 String sql = query.toString();
2381
2382 Query q = session.createQuery(sql);
2383
2384 QueryPos qPos = QueryPos.getInstance(q);
2385
2386 qPos.add(groupId);
2387
2388 qPos.add(folderId);
2389
2390 if (name != null) {
2391 qPos.add(name);
2392 }
2393
2394 List<DLFileEntry> list = q.list();
2395
2396 result = list;
2397
2398 DLFileEntry dlFileEntry = null;
2399
2400 if (list.isEmpty()) {
2401 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_F_N,
2402 finderArgs, list);
2403 }
2404 else {
2405 dlFileEntry = list.get(0);
2406
2407 cacheResult(dlFileEntry);
2408
2409 if ((dlFileEntry.getGroupId() != groupId) ||
2410 (dlFileEntry.getFolderId() != folderId) ||
2411 (dlFileEntry.getName() == null) ||
2412 !dlFileEntry.getName().equals(name)) {
2413 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_F_N,
2414 finderArgs, dlFileEntry);
2415 }
2416 }
2417
2418 return dlFileEntry;
2419 }
2420 catch (Exception e) {
2421 throw processException(e);
2422 }
2423 finally {
2424 if (result == null) {
2425 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_F_N,
2426 finderArgs, new ArrayList<DLFileEntry>());
2427 }
2428
2429 closeSession(session);
2430 }
2431 }
2432 else {
2433 if (result instanceof List<?>) {
2434 return null;
2435 }
2436 else {
2437 return (DLFileEntry)result;
2438 }
2439 }
2440 }
2441
2442 public DLFileEntry findByG_F_T(long groupId, long folderId, String title)
2443 throws NoSuchFileEntryException, SystemException {
2444 DLFileEntry dlFileEntry = fetchByG_F_T(groupId, folderId, title);
2445
2446 if (dlFileEntry == null) {
2447 StringBundler msg = new StringBundler(8);
2448
2449 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2450
2451 msg.append("groupId=");
2452 msg.append(groupId);
2453
2454 msg.append(", folderId=");
2455 msg.append(folderId);
2456
2457 msg.append(", title=");
2458 msg.append(title);
2459
2460 msg.append(StringPool.CLOSE_CURLY_BRACE);
2461
2462 if (_log.isWarnEnabled()) {
2463 _log.warn(msg.toString());
2464 }
2465
2466 throw new NoSuchFileEntryException(msg.toString());
2467 }
2468
2469 return dlFileEntry;
2470 }
2471
2472 public DLFileEntry fetchByG_F_T(long groupId, long folderId, String title)
2473 throws SystemException {
2474 return fetchByG_F_T(groupId, folderId, title, true);
2475 }
2476
2477 public DLFileEntry fetchByG_F_T(long groupId, long folderId, String title,
2478 boolean retrieveFromCache) throws SystemException {
2479 Object[] finderArgs = new Object[] {
2480 new Long(groupId), new Long(folderId),
2481
2482 title
2483 };
2484
2485 Object result = null;
2486
2487 if (retrieveFromCache) {
2488 result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_G_F_T,
2489 finderArgs, this);
2490 }
2491
2492 if (result == null) {
2493 Session session = null;
2494
2495 try {
2496 session = openSession();
2497
2498 StringBundler query = new StringBundler(5);
2499
2500 query.append(_SQL_SELECT_DLFILEENTRY_WHERE);
2501
2502 query.append(_FINDER_COLUMN_G_F_T_GROUPID_2);
2503
2504 query.append(_FINDER_COLUMN_G_F_T_FOLDERID_2);
2505
2506 if (title == null) {
2507 query.append(_FINDER_COLUMN_G_F_T_TITLE_1);
2508 }
2509 else {
2510 if (title.equals(StringPool.BLANK)) {
2511 query.append(_FINDER_COLUMN_G_F_T_TITLE_3);
2512 }
2513 else {
2514 query.append(_FINDER_COLUMN_G_F_T_TITLE_2);
2515 }
2516 }
2517
2518 query.append(DLFileEntryModelImpl.ORDER_BY_JPQL);
2519
2520 String sql = query.toString();
2521
2522 Query q = session.createQuery(sql);
2523
2524 QueryPos qPos = QueryPos.getInstance(q);
2525
2526 qPos.add(groupId);
2527
2528 qPos.add(folderId);
2529
2530 if (title != null) {
2531 qPos.add(title);
2532 }
2533
2534 List<DLFileEntry> list = q.list();
2535
2536 result = list;
2537
2538 DLFileEntry dlFileEntry = null;
2539
2540 if (list.isEmpty()) {
2541 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_F_T,
2542 finderArgs, list);
2543 }
2544 else {
2545 dlFileEntry = list.get(0);
2546
2547 cacheResult(dlFileEntry);
2548
2549 if ((dlFileEntry.getGroupId() != groupId) ||
2550 (dlFileEntry.getFolderId() != folderId) ||
2551 (dlFileEntry.getTitle() == null) ||
2552 !dlFileEntry.getTitle().equals(title)) {
2553 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_F_T,
2554 finderArgs, dlFileEntry);
2555 }
2556 }
2557
2558 return dlFileEntry;
2559 }
2560 catch (Exception e) {
2561 throw processException(e);
2562 }
2563 finally {
2564 if (result == null) {
2565 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_F_T,
2566 finderArgs, new ArrayList<DLFileEntry>());
2567 }
2568
2569 closeSession(session);
2570 }
2571 }
2572 else {
2573 if (result instanceof List<?>) {
2574 return null;
2575 }
2576 else {
2577 return (DLFileEntry)result;
2578 }
2579 }
2580 }
2581
2582 public List<DLFileEntry> findAll() throws SystemException {
2583 return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
2584 }
2585
2586 public List<DLFileEntry> findAll(int start, int end)
2587 throws SystemException {
2588 return findAll(start, end, null);
2589 }
2590
2591 public List<DLFileEntry> findAll(int start, int end,
2592 OrderByComparator orderByComparator) throws SystemException {
2593 Object[] finderArgs = new Object[] {
2594 String.valueOf(start), String.valueOf(end),
2595 String.valueOf(orderByComparator)
2596 };
2597
2598 List<DLFileEntry> list = (List<DLFileEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
2599 finderArgs, this);
2600
2601 if (list == null) {
2602 Session session = null;
2603
2604 try {
2605 session = openSession();
2606
2607 StringBundler query = null;
2608 String sql = null;
2609
2610 if (orderByComparator != null) {
2611 query = new StringBundler(2 +
2612 (orderByComparator.getOrderByFields().length * 3));
2613
2614 query.append(_SQL_SELECT_DLFILEENTRY);
2615
2616 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2617 orderByComparator);
2618
2619 sql = query.toString();
2620 }
2621
2622 else {
2623 sql = _SQL_SELECT_DLFILEENTRY.concat(DLFileEntryModelImpl.ORDER_BY_JPQL);
2624 }
2625
2626 Query q = session.createQuery(sql);
2627
2628 if (orderByComparator == null) {
2629 list = (List<DLFileEntry>)QueryUtil.list(q, getDialect(),
2630 start, end, false);
2631
2632 Collections.sort(list);
2633 }
2634 else {
2635 list = (List<DLFileEntry>)QueryUtil.list(q, getDialect(),
2636 start, end);
2637 }
2638 }
2639 catch (Exception e) {
2640 throw processException(e);
2641 }
2642 finally {
2643 if (list == null) {
2644 list = new ArrayList<DLFileEntry>();
2645 }
2646
2647 cacheResult(list);
2648
2649 FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
2650
2651 closeSession(session);
2652 }
2653 }
2654
2655 return list;
2656 }
2657
2658 public void removeByUuid(String uuid) throws SystemException {
2659 for (DLFileEntry dlFileEntry : findByUuid(uuid)) {
2660 remove(dlFileEntry);
2661 }
2662 }
2663
2664 public void removeByUUID_G(String uuid, long groupId)
2665 throws NoSuchFileEntryException, SystemException {
2666 DLFileEntry dlFileEntry = findByUUID_G(uuid, groupId);
2667
2668 remove(dlFileEntry);
2669 }
2670
2671 public void removeByGroupId(long groupId) throws SystemException {
2672 for (DLFileEntry dlFileEntry : findByGroupId(groupId)) {
2673 remove(dlFileEntry);
2674 }
2675 }
2676
2677 public void removeByCompanyId(long companyId) throws SystemException {
2678 for (DLFileEntry dlFileEntry : findByCompanyId(companyId)) {
2679 remove(dlFileEntry);
2680 }
2681 }
2682
2683 public void removeByG_U(long groupId, long userId)
2684 throws SystemException {
2685 for (DLFileEntry dlFileEntry : findByG_U(groupId, userId)) {
2686 remove(dlFileEntry);
2687 }
2688 }
2689
2690 public void removeByG_F(long groupId, long folderId)
2691 throws SystemException {
2692 for (DLFileEntry dlFileEntry : findByG_F(groupId, folderId)) {
2693 remove(dlFileEntry);
2694 }
2695 }
2696
2697 public void removeByG_F_N(long groupId, long folderId, String name)
2698 throws NoSuchFileEntryException, SystemException {
2699 DLFileEntry dlFileEntry = findByG_F_N(groupId, folderId, name);
2700
2701 remove(dlFileEntry);
2702 }
2703
2704 public void removeByG_F_T(long groupId, long folderId, String title)
2705 throws NoSuchFileEntryException, SystemException {
2706 DLFileEntry dlFileEntry = findByG_F_T(groupId, folderId, title);
2707
2708 remove(dlFileEntry);
2709 }
2710
2711 public void removeAll() throws SystemException {
2712 for (DLFileEntry dlFileEntry : findAll()) {
2713 remove(dlFileEntry);
2714 }
2715 }
2716
2717 public int countByUuid(String uuid) throws SystemException {
2718 Object[] finderArgs = new Object[] { uuid };
2719
2720 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_UUID,
2721 finderArgs, this);
2722
2723 if (count == null) {
2724 Session session = null;
2725
2726 try {
2727 session = openSession();
2728
2729 StringBundler query = new StringBundler(2);
2730
2731 query.append(_SQL_COUNT_DLFILEENTRY_WHERE);
2732
2733 if (uuid == null) {
2734 query.append(_FINDER_COLUMN_UUID_UUID_1);
2735 }
2736 else {
2737 if (uuid.equals(StringPool.BLANK)) {
2738 query.append(_FINDER_COLUMN_UUID_UUID_3);
2739 }
2740 else {
2741 query.append(_FINDER_COLUMN_UUID_UUID_2);
2742 }
2743 }
2744
2745 String sql = query.toString();
2746
2747 Query q = session.createQuery(sql);
2748
2749 QueryPos qPos = QueryPos.getInstance(q);
2750
2751 if (uuid != null) {
2752 qPos.add(uuid);
2753 }
2754
2755 count = (Long)q.uniqueResult();
2756 }
2757 catch (Exception e) {
2758 throw processException(e);
2759 }
2760 finally {
2761 if (count == null) {
2762 count = Long.valueOf(0);
2763 }
2764
2765 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID,
2766 finderArgs, count);
2767
2768 closeSession(session);
2769 }
2770 }
2771
2772 return count.intValue();
2773 }
2774
2775 public int countByUUID_G(String uuid, long groupId)
2776 throws SystemException {
2777 Object[] finderArgs = new Object[] { uuid, new Long(groupId) };
2778
2779 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_UUID_G,
2780 finderArgs, this);
2781
2782 if (count == null) {
2783 Session session = null;
2784
2785 try {
2786 session = openSession();
2787
2788 StringBundler query = new StringBundler(3);
2789
2790 query.append(_SQL_COUNT_DLFILEENTRY_WHERE);
2791
2792 if (uuid == null) {
2793 query.append(_FINDER_COLUMN_UUID_G_UUID_1);
2794 }
2795 else {
2796 if (uuid.equals(StringPool.BLANK)) {
2797 query.append(_FINDER_COLUMN_UUID_G_UUID_3);
2798 }
2799 else {
2800 query.append(_FINDER_COLUMN_UUID_G_UUID_2);
2801 }
2802 }
2803
2804 query.append(_FINDER_COLUMN_UUID_G_GROUPID_2);
2805
2806 String sql = query.toString();
2807
2808 Query q = session.createQuery(sql);
2809
2810 QueryPos qPos = QueryPos.getInstance(q);
2811
2812 if (uuid != null) {
2813 qPos.add(uuid);
2814 }
2815
2816 qPos.add(groupId);
2817
2818 count = (Long)q.uniqueResult();
2819 }
2820 catch (Exception e) {
2821 throw processException(e);
2822 }
2823 finally {
2824 if (count == null) {
2825 count = Long.valueOf(0);
2826 }
2827
2828 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID_G,
2829 finderArgs, count);
2830
2831 closeSession(session);
2832 }
2833 }
2834
2835 return count.intValue();
2836 }
2837
2838 public int countByGroupId(long groupId) throws SystemException {
2839 Object[] finderArgs = new Object[] { new Long(groupId) };
2840
2841 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_GROUPID,
2842 finderArgs, this);
2843
2844 if (count == null) {
2845 Session session = null;
2846
2847 try {
2848 session = openSession();
2849
2850 StringBundler query = new StringBundler(2);
2851
2852 query.append(_SQL_COUNT_DLFILEENTRY_WHERE);
2853
2854 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
2855
2856 String sql = query.toString();
2857
2858 Query q = session.createQuery(sql);
2859
2860 QueryPos qPos = QueryPos.getInstance(q);
2861
2862 qPos.add(groupId);
2863
2864 count = (Long)q.uniqueResult();
2865 }
2866 catch (Exception e) {
2867 throw processException(e);
2868 }
2869 finally {
2870 if (count == null) {
2871 count = Long.valueOf(0);
2872 }
2873
2874 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_GROUPID,
2875 finderArgs, count);
2876
2877 closeSession(session);
2878 }
2879 }
2880
2881 return count.intValue();
2882 }
2883
2884 public int filterCountByGroupId(long groupId) throws SystemException {
2885 if (!InlineSQLHelperUtil.isEnabled(groupId)) {
2886 return countByGroupId(groupId);
2887 }
2888
2889 Session session = null;
2890
2891 try {
2892 session = openSession();
2893
2894 StringBundler query = new StringBundler(2);
2895
2896 query.append(_FILTER_SQL_COUNT_DLFILEENTRY_WHERE);
2897
2898 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
2899
2900 String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
2901 DLFileEntry.class.getName(), _FILTER_COLUMN_FILEENTRYID,
2902 _FILTER_COLUMN_USERID, groupId);
2903
2904 SQLQuery q = session.createSQLQuery(sql);
2905
2906 q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
2907
2908 QueryPos qPos = QueryPos.getInstance(q);
2909
2910 qPos.add(groupId);
2911
2912 Long count = (Long)q.uniqueResult();
2913
2914 return count.intValue();
2915 }
2916 catch (Exception e) {
2917 throw processException(e);
2918 }
2919 finally {
2920 closeSession(session);
2921 }
2922 }
2923
2924 public int countByCompanyId(long companyId) throws SystemException {
2925 Object[] finderArgs = new Object[] { new Long(companyId) };
2926
2927 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_COMPANYID,
2928 finderArgs, this);
2929
2930 if (count == null) {
2931 Session session = null;
2932
2933 try {
2934 session = openSession();
2935
2936 StringBundler query = new StringBundler(2);
2937
2938 query.append(_SQL_COUNT_DLFILEENTRY_WHERE);
2939
2940 query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
2941
2942 String sql = query.toString();
2943
2944 Query q = session.createQuery(sql);
2945
2946 QueryPos qPos = QueryPos.getInstance(q);
2947
2948 qPos.add(companyId);
2949
2950 count = (Long)q.uniqueResult();
2951 }
2952 catch (Exception e) {
2953 throw processException(e);
2954 }
2955 finally {
2956 if (count == null) {
2957 count = Long.valueOf(0);
2958 }
2959
2960 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_COMPANYID,
2961 finderArgs, count);
2962
2963 closeSession(session);
2964 }
2965 }
2966
2967 return count.intValue();
2968 }
2969
2970 public int countByG_U(long groupId, long userId) throws SystemException {
2971 Object[] finderArgs = new Object[] { new Long(groupId), new Long(userId) };
2972
2973 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_U,
2974 finderArgs, this);
2975
2976 if (count == null) {
2977 Session session = null;
2978
2979 try {
2980 session = openSession();
2981
2982 StringBundler query = new StringBundler(3);
2983
2984 query.append(_SQL_COUNT_DLFILEENTRY_WHERE);
2985
2986 query.append(_FINDER_COLUMN_G_U_GROUPID_2);
2987
2988 query.append(_FINDER_COLUMN_G_U_USERID_2);
2989
2990 String sql = query.toString();
2991
2992 Query q = session.createQuery(sql);
2993
2994 QueryPos qPos = QueryPos.getInstance(q);
2995
2996 qPos.add(groupId);
2997
2998 qPos.add(userId);
2999
3000 count = (Long)q.uniqueResult();
3001 }
3002 catch (Exception e) {
3003 throw processException(e);
3004 }
3005 finally {
3006 if (count == null) {
3007 count = Long.valueOf(0);
3008 }
3009
3010 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_U, finderArgs,
3011 count);
3012
3013 closeSession(session);
3014 }
3015 }
3016
3017 return count.intValue();
3018 }
3019
3020 public int filterCountByG_U(long groupId, long userId)
3021 throws SystemException {
3022 if (!InlineSQLHelperUtil.isEnabled(groupId)) {
3023 return countByG_U(groupId, userId);
3024 }
3025
3026 Session session = null;
3027
3028 try {
3029 session = openSession();
3030
3031 StringBundler query = new StringBundler(3);
3032
3033 query.append(_FILTER_SQL_COUNT_DLFILEENTRY_WHERE);
3034
3035 query.append(_FINDER_COLUMN_G_U_GROUPID_2);
3036
3037 query.append(_FINDER_COLUMN_G_U_USERID_2);
3038
3039 String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
3040 DLFileEntry.class.getName(), _FILTER_COLUMN_FILEENTRYID,
3041 _FILTER_COLUMN_USERID, groupId);
3042
3043 SQLQuery q = session.createSQLQuery(sql);
3044
3045 q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
3046
3047 QueryPos qPos = QueryPos.getInstance(q);
3048
3049 qPos.add(groupId);
3050
3051 qPos.add(userId);
3052
3053 Long count = (Long)q.uniqueResult();
3054
3055 return count.intValue();
3056 }
3057 catch (Exception e) {
3058 throw processException(e);
3059 }
3060 finally {
3061 closeSession(session);
3062 }
3063 }
3064
3065 public int countByG_F(long groupId, long folderId)
3066 throws SystemException {
3067 Object[] finderArgs = new Object[] { new Long(groupId), new Long(folderId) };
3068
3069 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_F,
3070 finderArgs, this);
3071
3072 if (count == null) {
3073 Session session = null;
3074
3075 try {
3076 session = openSession();
3077
3078 StringBundler query = new StringBundler(3);
3079
3080 query.append(_SQL_COUNT_DLFILEENTRY_WHERE);
3081
3082 query.append(_FINDER_COLUMN_G_F_GROUPID_2);
3083
3084 query.append(_FINDER_COLUMN_G_F_FOLDERID_2);
3085
3086 String sql = query.toString();
3087
3088 Query q = session.createQuery(sql);
3089
3090 QueryPos qPos = QueryPos.getInstance(q);
3091
3092 qPos.add(groupId);
3093
3094 qPos.add(folderId);
3095
3096 count = (Long)q.uniqueResult();
3097 }
3098 catch (Exception e) {
3099 throw processException(e);
3100 }
3101 finally {
3102 if (count == null) {
3103 count = Long.valueOf(0);
3104 }
3105
3106 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_F, finderArgs,
3107 count);
3108
3109 closeSession(session);
3110 }
3111 }
3112
3113 return count.intValue();
3114 }
3115
3116 public int filterCountByG_F(long groupId, long folderId)
3117 throws SystemException {
3118 if (!InlineSQLHelperUtil.isEnabled(groupId)) {
3119 return countByG_F(groupId, folderId);
3120 }
3121
3122 Session session = null;
3123
3124 try {
3125 session = openSession();
3126
3127 StringBundler query = new StringBundler(3);
3128
3129 query.append(_FILTER_SQL_COUNT_DLFILEENTRY_WHERE);
3130
3131 query.append(_FINDER_COLUMN_G_F_GROUPID_2);
3132
3133 query.append(_FINDER_COLUMN_G_F_FOLDERID_2);
3134
3135 String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
3136 DLFileEntry.class.getName(), _FILTER_COLUMN_FILEENTRYID,
3137 _FILTER_COLUMN_USERID, groupId);
3138
3139 SQLQuery q = session.createSQLQuery(sql);
3140
3141 q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
3142
3143 QueryPos qPos = QueryPos.getInstance(q);
3144
3145 qPos.add(groupId);
3146
3147 qPos.add(folderId);
3148
3149 Long count = (Long)q.uniqueResult();
3150
3151 return count.intValue();
3152 }
3153 catch (Exception e) {
3154 throw processException(e);
3155 }
3156 finally {
3157 closeSession(session);
3158 }
3159 }
3160
3161 public int countByG_F_N(long groupId, long folderId, String name)
3162 throws SystemException {
3163 Object[] finderArgs = new Object[] {
3164 new Long(groupId), new Long(folderId),
3165
3166 name
3167 };
3168
3169 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_F_N,
3170 finderArgs, this);
3171
3172 if (count == null) {
3173 Session session = null;
3174
3175 try {
3176 session = openSession();
3177
3178 StringBundler query = new StringBundler(4);
3179
3180 query.append(_SQL_COUNT_DLFILEENTRY_WHERE);
3181
3182 query.append(_FINDER_COLUMN_G_F_N_GROUPID_2);
3183
3184 query.append(_FINDER_COLUMN_G_F_N_FOLDERID_2);
3185
3186 if (name == null) {
3187 query.append(_FINDER_COLUMN_G_F_N_NAME_1);
3188 }
3189 else {
3190 if (name.equals(StringPool.BLANK)) {
3191 query.append(_FINDER_COLUMN_G_F_N_NAME_3);
3192 }
3193 else {
3194 query.append(_FINDER_COLUMN_G_F_N_NAME_2);
3195 }
3196 }
3197
3198 String sql = query.toString();
3199
3200 Query q = session.createQuery(sql);
3201
3202 QueryPos qPos = QueryPos.getInstance(q);
3203
3204 qPos.add(groupId);
3205
3206 qPos.add(folderId);
3207
3208 if (name != null) {
3209 qPos.add(name);
3210 }
3211
3212 count = (Long)q.uniqueResult();
3213 }
3214 catch (Exception e) {
3215 throw processException(e);
3216 }
3217 finally {
3218 if (count == null) {
3219 count = Long.valueOf(0);
3220 }
3221
3222 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_F_N,
3223 finderArgs, count);
3224
3225 closeSession(session);
3226 }
3227 }
3228
3229 return count.intValue();
3230 }
3231
3232 public int filterCountByG_F_N(long groupId, long folderId, String name)
3233 throws SystemException {
3234 if (!InlineSQLHelperUtil.isEnabled(groupId)) {
3235 return countByG_F_N(groupId, folderId, name);
3236 }
3237
3238 Session session = null;
3239
3240 try {
3241 session = openSession();
3242
3243 StringBundler query = new StringBundler(4);
3244
3245 query.append(_FILTER_SQL_COUNT_DLFILEENTRY_WHERE);
3246
3247 query.append(_FINDER_COLUMN_G_F_N_GROUPID_2);
3248
3249 query.append(_FINDER_COLUMN_G_F_N_FOLDERID_2);
3250
3251 if (name == null) {
3252 query.append(_FINDER_COLUMN_G_F_N_NAME_1);
3253 }
3254 else {
3255 if (name.equals(StringPool.BLANK)) {
3256 query.append(_FINDER_COLUMN_G_F_N_NAME_3);
3257 }
3258 else {
3259 query.append(_FINDER_COLUMN_G_F_N_NAME_2);
3260 }
3261 }
3262
3263 String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
3264 DLFileEntry.class.getName(), _FILTER_COLUMN_FILEENTRYID,
3265 _FILTER_COLUMN_USERID, groupId);
3266
3267 SQLQuery q = session.createSQLQuery(sql);
3268
3269 q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
3270
3271 QueryPos qPos = QueryPos.getInstance(q);
3272
3273 qPos.add(groupId);
3274
3275 qPos.add(folderId);
3276
3277 if (name != null) {
3278 qPos.add(name);
3279 }
3280
3281 Long count = (Long)q.uniqueResult();
3282
3283 return count.intValue();
3284 }
3285 catch (Exception e) {
3286 throw processException(e);
3287 }
3288 finally {
3289 closeSession(session);
3290 }
3291 }
3292
3293 public int countByG_F_T(long groupId, long folderId, String title)
3294 throws SystemException {
3295 Object[] finderArgs = new Object[] {
3296 new Long(groupId), new Long(folderId),
3297
3298 title
3299 };
3300
3301 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_F_T,
3302 finderArgs, this);
3303
3304 if (count == null) {
3305 Session session = null;
3306
3307 try {
3308 session = openSession();
3309
3310 StringBundler query = new StringBundler(4);
3311
3312 query.append(_SQL_COUNT_DLFILEENTRY_WHERE);
3313
3314 query.append(_FINDER_COLUMN_G_F_T_GROUPID_2);
3315
3316 query.append(_FINDER_COLUMN_G_F_T_FOLDERID_2);
3317
3318 if (title == null) {
3319 query.append(_FINDER_COLUMN_G_F_T_TITLE_1);
3320 }
3321 else {
3322 if (title.equals(StringPool.BLANK)) {
3323 query.append(_FINDER_COLUMN_G_F_T_TITLE_3);
3324 }
3325 else {
3326 query.append(_FINDER_COLUMN_G_F_T_TITLE_2);
3327 }
3328 }
3329
3330 String sql = query.toString();
3331
3332 Query q = session.createQuery(sql);
3333
3334 QueryPos qPos = QueryPos.getInstance(q);
3335
3336 qPos.add(groupId);
3337
3338 qPos.add(folderId);
3339
3340 if (title != null) {
3341 qPos.add(title);
3342 }
3343
3344 count = (Long)q.uniqueResult();
3345 }
3346 catch (Exception e) {
3347 throw processException(e);
3348 }
3349 finally {
3350 if (count == null) {
3351 count = Long.valueOf(0);
3352 }
3353
3354 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_F_T,
3355 finderArgs, count);
3356
3357 closeSession(session);
3358 }
3359 }
3360
3361 return count.intValue();
3362 }
3363
3364 public int filterCountByG_F_T(long groupId, long folderId, String title)
3365 throws SystemException {
3366 if (!InlineSQLHelperUtil.isEnabled(groupId)) {
3367 return countByG_F_T(groupId, folderId, title);
3368 }
3369
3370 Session session = null;
3371
3372 try {
3373 session = openSession();
3374
3375 StringBundler query = new StringBundler(4);
3376
3377 query.append(_FILTER_SQL_COUNT_DLFILEENTRY_WHERE);
3378
3379 query.append(_FINDER_COLUMN_G_F_T_GROUPID_2);
3380
3381 query.append(_FINDER_COLUMN_G_F_T_FOLDERID_2);
3382
3383 if (title == null) {
3384 query.append(_FINDER_COLUMN_G_F_T_TITLE_1);
3385 }
3386 else {
3387 if (title.equals(StringPool.BLANK)) {
3388 query.append(_FINDER_COLUMN_G_F_T_TITLE_3);
3389 }
3390 else {
3391 query.append(_FINDER_COLUMN_G_F_T_TITLE_2);
3392 }
3393 }
3394
3395 String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
3396 DLFileEntry.class.getName(), _FILTER_COLUMN_FILEENTRYID,
3397 _FILTER_COLUMN_USERID, groupId);
3398
3399 SQLQuery q = session.createSQLQuery(sql);
3400
3401 q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
3402
3403 QueryPos qPos = QueryPos.getInstance(q);
3404
3405 qPos.add(groupId);
3406
3407 qPos.add(folderId);
3408
3409 if (title != null) {
3410 qPos.add(title);
3411 }
3412
3413 Long count = (Long)q.uniqueResult();
3414
3415 return count.intValue();
3416 }
3417 catch (Exception e) {
3418 throw processException(e);
3419 }
3420 finally {
3421 closeSession(session);
3422 }
3423 }
3424
3425 public int countAll() throws SystemException {
3426 Object[] finderArgs = new Object[0];
3427
3428 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
3429 finderArgs, this);
3430
3431 if (count == null) {
3432 Session session = null;
3433
3434 try {
3435 session = openSession();
3436
3437 Query q = session.createQuery(_SQL_COUNT_DLFILEENTRY);
3438
3439 count = (Long)q.uniqueResult();
3440 }
3441 catch (Exception e) {
3442 throw processException(e);
3443 }
3444 finally {
3445 if (count == null) {
3446 count = Long.valueOf(0);
3447 }
3448
3449 FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
3450 count);
3451
3452 closeSession(session);
3453 }
3454 }
3455
3456 return count.intValue();
3457 }
3458
3459 public void afterPropertiesSet() {
3460 String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
3461 com.liferay.portal.util.PropsUtil.get(
3462 "value.object.listener.com.liferay.portlet.documentlibrary.model.DLFileEntry")));
3463
3464 if (listenerClassNames.length > 0) {
3465 try {
3466 List<ModelListener<DLFileEntry>> listenersList = new ArrayList<ModelListener<DLFileEntry>>();
3467
3468 for (String listenerClassName : listenerClassNames) {
3469 listenersList.add((ModelListener<DLFileEntry>)InstanceFactory.newInstance(
3470 listenerClassName));
3471 }
3472
3473 listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
3474 }
3475 catch (Exception e) {
3476 _log.error(e);
3477 }
3478 }
3479 }
3480
3481 @BeanReference(type = DLFileEntryPersistence.class)
3482 protected DLFileEntryPersistence dlFileEntryPersistence;
3483 @BeanReference(type = DLFileRankPersistence.class)
3484 protected DLFileRankPersistence dlFileRankPersistence;
3485 @BeanReference(type = DLFileShortcutPersistence.class)
3486 protected DLFileShortcutPersistence dlFileShortcutPersistence;
3487 @BeanReference(type = DLFileVersionPersistence.class)
3488 protected DLFileVersionPersistence dlFileVersionPersistence;
3489 @BeanReference(type = DLFolderPersistence.class)
3490 protected DLFolderPersistence dlFolderPersistence;
3491 @BeanReference(type = LockPersistence.class)
3492 protected LockPersistence lockPersistence;
3493 @BeanReference(type = ResourcePersistence.class)
3494 protected ResourcePersistence resourcePersistence;
3495 @BeanReference(type = UserPersistence.class)
3496 protected UserPersistence userPersistence;
3497 @BeanReference(type = WebDAVPropsPersistence.class)
3498 protected WebDAVPropsPersistence webDAVPropsPersistence;
3499 @BeanReference(type = WorkflowInstanceLinkPersistence.class)
3500 protected WorkflowInstanceLinkPersistence workflowInstanceLinkPersistence;
3501 @BeanReference(type = AssetCategoryPersistence.class)
3502 protected AssetCategoryPersistence assetCategoryPersistence;
3503 @BeanReference(type = AssetEntryPersistence.class)
3504 protected AssetEntryPersistence assetEntryPersistence;
3505 @BeanReference(type = AssetTagPersistence.class)
3506 protected AssetTagPersistence assetTagPersistence;
3507 @BeanReference(type = ExpandoValuePersistence.class)
3508 protected ExpandoValuePersistence expandoValuePersistence;
3509 @BeanReference(type = MBDiscussionPersistence.class)
3510 protected MBDiscussionPersistence mbDiscussionPersistence;
3511 @BeanReference(type = MBMessagePersistence.class)
3512 protected MBMessagePersistence mbMessagePersistence;
3513 @BeanReference(type = RatingsEntryPersistence.class)
3514 protected RatingsEntryPersistence ratingsEntryPersistence;
3515 @BeanReference(type = RatingsStatsPersistence.class)
3516 protected RatingsStatsPersistence ratingsStatsPersistence;
3517 @BeanReference(type = SocialActivityPersistence.class)
3518 protected SocialActivityPersistence socialActivityPersistence;
3519 private static final String _SQL_SELECT_DLFILEENTRY = "SELECT dlFileEntry FROM DLFileEntry dlFileEntry";
3520 private static final String _SQL_SELECT_DLFILEENTRY_WHERE = "SELECT dlFileEntry FROM DLFileEntry dlFileEntry WHERE ";
3521 private static final String _SQL_COUNT_DLFILEENTRY = "SELECT COUNT(dlFileEntry) FROM DLFileEntry dlFileEntry";
3522 private static final String _SQL_COUNT_DLFILEENTRY_WHERE = "SELECT COUNT(dlFileEntry) FROM DLFileEntry dlFileEntry WHERE ";
3523 private static final String _FINDER_COLUMN_UUID_UUID_1 = "dlFileEntry.uuid IS NULL";
3524 private static final String _FINDER_COLUMN_UUID_UUID_2 = "dlFileEntry.uuid = ?";
3525 private static final String _FINDER_COLUMN_UUID_UUID_3 = "(dlFileEntry.uuid IS NULL OR dlFileEntry.uuid = ?)";
3526 private static final String _FINDER_COLUMN_UUID_G_UUID_1 = "dlFileEntry.uuid IS NULL AND ";
3527 private static final String _FINDER_COLUMN_UUID_G_UUID_2 = "dlFileEntry.uuid = ? AND ";
3528 private static final String _FINDER_COLUMN_UUID_G_UUID_3 = "(dlFileEntry.uuid IS NULL OR dlFileEntry.uuid = ?) AND ";
3529 private static final String _FINDER_COLUMN_UUID_G_GROUPID_2 = "dlFileEntry.groupId = ?";
3530 private static final String _FINDER_COLUMN_GROUPID_GROUPID_2 = "dlFileEntry.groupId = ?";
3531 private static final String _FINDER_COLUMN_COMPANYID_COMPANYID_2 = "dlFileEntry.companyId = ?";
3532 private static final String _FINDER_COLUMN_G_U_GROUPID_2 = "dlFileEntry.groupId = ? AND ";
3533 private static final String _FINDER_COLUMN_G_U_USERID_2 = "dlFileEntry.userId = ?";
3534 private static final String _FINDER_COLUMN_G_F_GROUPID_2 = "dlFileEntry.groupId = ? AND ";
3535 private static final String _FINDER_COLUMN_G_F_FOLDERID_2 = "dlFileEntry.folderId = ?";
3536 private static final String _FINDER_COLUMN_G_F_N_GROUPID_2 = "dlFileEntry.groupId = ? AND ";
3537 private static final String _FINDER_COLUMN_G_F_N_FOLDERID_2 = "dlFileEntry.folderId = ? AND ";
3538 private static final String _FINDER_COLUMN_G_F_N_NAME_1 = "dlFileEntry.name IS NULL";
3539 private static final String _FINDER_COLUMN_G_F_N_NAME_2 = "dlFileEntry.name = ?";
3540 private static final String _FINDER_COLUMN_G_F_N_NAME_3 = "(dlFileEntry.name IS NULL OR dlFileEntry.name = ?)";
3541 private static final String _FINDER_COLUMN_G_F_T_GROUPID_2 = "dlFileEntry.groupId = ? AND ";
3542 private static final String _FINDER_COLUMN_G_F_T_FOLDERID_2 = "dlFileEntry.folderId = ? AND ";
3543 private static final String _FINDER_COLUMN_G_F_T_TITLE_1 = "dlFileEntry.title IS NULL";
3544 private static final String _FINDER_COLUMN_G_F_T_TITLE_2 = "dlFileEntry.title = ?";
3545 private static final String _FINDER_COLUMN_G_F_T_TITLE_3 = "(dlFileEntry.title IS NULL OR dlFileEntry.title = ?)";
3546 private static final String _FILTER_SQL_SELECT_DLFILEENTRY_WHERE = "SELECT DISTINCT {dlFileEntry.*} FROM DLFileEntry dlFileEntry WHERE ";
3547 private static final String _FILTER_SQL_COUNT_DLFILEENTRY_WHERE = "SELECT COUNT(DISTINCT dlFileEntry.fileEntryId) AS COUNT_VALUE FROM DLFileEntry dlFileEntry WHERE ";
3548 private static final String _FILTER_COLUMN_FILEENTRYID = "dlFileEntry.fileEntryId";
3549 private static final String _FILTER_COLUMN_USERID = "dlFileEntry.userId";
3550 private static final String _FILTER_ENTITY_ALIAS = "dlFileEntry";
3551 private static final String _ORDER_BY_ENTITY_ALIAS = "dlFileEntry.";
3552 private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No DLFileEntry exists with the primary key ";
3553 private static final String _NO_SUCH_ENTITY_WITH_KEY = "No DLFileEntry exists with the key {";
3554 private static Log _log = LogFactoryUtil.getLog(DLFileEntryPersistenceImpl.class);
3555}