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