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