001
014
015 package com.liferay.portlet.documentlibrary.service.impl;
016
017 import com.liferay.document.library.kernel.exception.DuplicateFileEntryException;
018 import com.liferay.document.library.kernel.exception.DuplicateFolderNameException;
019 import com.liferay.document.library.kernel.exception.FolderNameException;
020 import com.liferay.document.library.kernel.exception.InvalidFolderException;
021 import com.liferay.document.library.kernel.exception.NoSuchFolderException;
022 import com.liferay.document.library.kernel.exception.RequiredFileEntryTypeException;
023 import com.liferay.document.library.kernel.model.DLFileEntry;
024 import com.liferay.document.library.kernel.model.DLFileEntryType;
025 import com.liferay.document.library.kernel.model.DLFileEntryTypeConstants;
026 import com.liferay.document.library.kernel.model.DLFolder;
027 import com.liferay.document.library.kernel.model.DLFolderConstants;
028 import com.liferay.document.library.kernel.store.DLStoreUtil;
029 import com.liferay.document.library.kernel.util.DLValidatorUtil;
030 import com.liferay.document.library.kernel.util.comparator.FolderIdComparator;
031 import com.liferay.exportimport.kernel.lar.ExportImportThreadLocal;
032 import com.liferay.portal.kernel.dao.orm.QueryDefinition;
033 import com.liferay.portal.kernel.dao.orm.QueryUtil;
034 import com.liferay.portal.kernel.exception.PortalException;
035 import com.liferay.portal.kernel.increment.BufferedIncrement;
036 import com.liferay.portal.kernel.increment.DateOverrideIncrement;
037 import com.liferay.portal.kernel.lock.ExpiredLockException;
038 import com.liferay.portal.kernel.lock.InvalidLockException;
039 import com.liferay.portal.kernel.lock.Lock;
040 import com.liferay.portal.kernel.lock.LockManagerUtil;
041 import com.liferay.portal.kernel.lock.NoSuchLockException;
042 import com.liferay.portal.kernel.log.Log;
043 import com.liferay.portal.kernel.log.LogFactoryUtil;
044 import com.liferay.portal.kernel.model.Group;
045 import com.liferay.portal.kernel.model.Repository;
046 import com.liferay.portal.kernel.model.ResourceConstants;
047 import com.liferay.portal.kernel.model.SystemEventConstants;
048 import com.liferay.portal.kernel.model.TreeModel;
049 import com.liferay.portal.kernel.model.User;
050 import com.liferay.portal.kernel.model.WorkflowDefinitionLink;
051 import com.liferay.portal.kernel.repository.event.RepositoryEventTrigger;
052 import com.liferay.portal.kernel.repository.event.RepositoryEventType;
053 import com.liferay.portal.kernel.repository.model.Folder;
054 import com.liferay.portal.kernel.search.Indexable;
055 import com.liferay.portal.kernel.search.IndexableType;
056 import com.liferay.portal.kernel.search.Indexer;
057 import com.liferay.portal.kernel.search.IndexerRegistryUtil;
058 import com.liferay.portal.kernel.service.ServiceContext;
059 import com.liferay.portal.kernel.service.permission.ModelPermissions;
060 import com.liferay.portal.kernel.systemevent.SystemEvent;
061 import com.liferay.portal.kernel.util.ObjectValuePair;
062 import com.liferay.portal.kernel.util.OrderByComparator;
063 import com.liferay.portal.kernel.util.ParamUtil;
064 import com.liferay.portal.kernel.util.StringPool;
065 import com.liferay.portal.kernel.util.TreeModelTasksAdapter;
066 import com.liferay.portal.kernel.util.TreePathUtil;
067 import com.liferay.portal.kernel.util.Validator;
068 import com.liferay.portal.kernel.workflow.WorkflowConstants;
069 import com.liferay.portal.repository.liferayrepository.model.LiferayFolder;
070 import com.liferay.portal.util.RepositoryUtil;
071 import com.liferay.portlet.documentlibrary.model.impl.DLFolderImpl;
072 import com.liferay.portlet.documentlibrary.service.base.DLFolderLocalServiceBaseImpl;
073
074 import java.io.Serializable;
075
076 import java.util.ArrayList;
077 import java.util.Collections;
078 import java.util.Date;
079 import java.util.HashSet;
080 import java.util.List;
081 import java.util.Map;
082 import java.util.Set;
083
084
088 public class DLFolderLocalServiceImpl extends DLFolderLocalServiceBaseImpl {
089
090 @Override
091 public DLFolder addFolder(
092 long userId, long groupId, long repositoryId, boolean mountPoint,
093 long parentFolderId, String name, String description,
094 boolean hidden, ServiceContext serviceContext)
095 throws PortalException {
096
097
098
099 User user = userPersistence.findByPrimaryKey(userId);
100 parentFolderId = getParentFolderId(
101 groupId, repositoryId, parentFolderId);
102 Date now = new Date();
103
104 validateFolder(groupId, parentFolderId, name);
105
106 long folderId = counterLocalService.increment();
107
108 DLFolder dlFolder = dlFolderPersistence.create(folderId);
109
110 dlFolder.setUuid(serviceContext.getUuid());
111 dlFolder.setGroupId(groupId);
112 dlFolder.setCompanyId(user.getCompanyId());
113 dlFolder.setUserId(user.getUserId());
114 dlFolder.setUserName(user.getFullName());
115 dlFolder.setRepositoryId(repositoryId);
116 dlFolder.setMountPoint(mountPoint);
117 dlFolder.setParentFolderId(parentFolderId);
118 dlFolder.setTreePath(dlFolder.buildTreePath());
119 dlFolder.setName(name);
120 dlFolder.setDescription(description);
121 dlFolder.setLastPostDate(now);
122 dlFolder.setHidden(hidden);
123 dlFolder.setRestrictionType(DLFolderConstants.RESTRICTION_TYPE_INHERIT);
124 dlFolder.setExpandoBridgeAttributes(serviceContext);
125
126 dlFolderPersistence.update(dlFolder);
127
128
129
130 if (serviceContext.isAddGroupPermissions() ||
131 serviceContext.isAddGuestPermissions()) {
132
133 addFolderResources(
134 dlFolder, serviceContext.isAddGroupPermissions(),
135 serviceContext.isAddGuestPermissions());
136 }
137 else {
138 if (serviceContext.isDeriveDefaultPermissions()) {
139 serviceContext.deriveDefaultPermissions(
140 repositoryId, DLFolderConstants.getClassName());
141 }
142
143 addFolderResources(dlFolder, serviceContext.getModelPermissions());
144 }
145
146
147
148 if (parentFolderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
149 dlFolderLocalService.updateLastPostDate(parentFolderId, now);
150 }
151
152 return dlFolder;
153 }
154
155
158 @Deprecated
159 @Override
160 public void deleteAll(long groupId) throws PortalException {
161 deleteAllByGroup(groupId);
162 }
163
164 @Override
165 public void deleteAllByGroup(long groupId) throws PortalException {
166 Group group = groupLocalService.getGroup(groupId);
167
168 List<DLFolder> dlFolders = dlFolderPersistence.findByGroupId(groupId);
169
170 for (DLFolder dlFolder : dlFolders) {
171 dlFolderLocalService.deleteFolder(dlFolder);
172 }
173
174 dlFileEntryLocalService.deleteFileEntries(
175 groupId, DLFolderConstants.DEFAULT_PARENT_FOLDER_ID);
176
177 dlFileEntryTypeLocalService.deleteFileEntryTypes(groupId);
178
179 dlFileShortcutLocalService.deleteFileShortcuts(
180 groupId, DLFolderConstants.DEFAULT_PARENT_FOLDER_ID);
181
182 DLStoreUtil.deleteDirectory(
183 group.getCompanyId(), groupId, StringPool.BLANK);
184 }
185
186 @Override
187 public void deleteAllByRepository(long repositoryId)
188 throws PortalException {
189
190 Repository repository = repositoryLocalService.fetchRepository(
191 repositoryId);
192
193 long groupId = repositoryId;
194
195 if (repository != null) {
196 groupId = repository.getGroupId();
197 }
198
199 Group group = groupLocalService.getGroup(groupId);
200
201 RepositoryEventTrigger repositoryEventTrigger =
202 RepositoryUtil.getRepositoryEventTrigger(repositoryId);
203
204 List<DLFolder> dlFolders = dlFolderPersistence.findByRepositoryId(
205 repositoryId);
206
207 for (DLFolder dlFolder : dlFolders) {
208 deleteFolderDependencies(dlFolder, true);
209
210 repositoryEventTrigger.trigger(
211 RepositoryEventType.Delete.class, Folder.class,
212 new LiferayFolder(dlFolder));
213 }
214
215 if (repository != null) {
216 dlFileEntryLocalService.deleteRepositoryFileEntries(
217 repository.getRepositoryId(), repository.getDlFolderId());
218 }
219 else {
220 dlFileEntryLocalService.deleteFileEntries(
221 groupId, DLFolderConstants.DEFAULT_PARENT_FOLDER_ID);
222
223 dlFileShortcutLocalService.deleteFileShortcuts(
224 groupId, DLFolderConstants.DEFAULT_PARENT_FOLDER_ID);
225 }
226
227 DLStoreUtil.deleteDirectory(
228 group.getCompanyId(), repositoryId, StringPool.BLANK);
229 }
230
231 @Indexable(type = IndexableType.DELETE)
232 @Override
233 @SystemEvent(
234 action = SystemEventConstants.ACTION_SKIP,
235 type = SystemEventConstants.TYPE_DELETE
236 )
237 public DLFolder deleteFolder(DLFolder dlFolder) throws PortalException {
238 return deleteFolder(dlFolder, true);
239 }
240
241 @Indexable(type = IndexableType.DELETE)
242 @Override
243 @SystemEvent(
244 action = SystemEventConstants.ACTION_SKIP,
245 type = SystemEventConstants.TYPE_DELETE
246 )
247 public DLFolder deleteFolder(
248 DLFolder dlFolder, boolean includeTrashedEntries)
249 throws PortalException {
250
251 deleteSubfolders(dlFolder, includeTrashedEntries);
252
253 deleteFolderDependencies(dlFolder, includeTrashedEntries);
254
255 return dlFolder;
256 }
257
258 @Indexable(type = IndexableType.DELETE)
259 @Override
260 public DLFolder deleteFolder(long folderId) throws PortalException {
261 return dlFolderLocalService.deleteFolder(folderId, true);
262 }
263
264 @Indexable(type = IndexableType.DELETE)
265 @Override
266 public DLFolder deleteFolder(long folderId, boolean includeTrashedEntries)
267 throws PortalException {
268
269 DLFolder dlFolder = dlFolderPersistence.findByPrimaryKey(folderId);
270
271 return dlFolderLocalService.deleteFolder(
272 dlFolder, includeTrashedEntries);
273 }
274
275 @Indexable(type = IndexableType.DELETE)
276 @Override
277 public DLFolder deleteFolder(
278 long userId, long folderId, boolean includeTrashedEntries)
279 throws PortalException {
280
281 boolean hasLock = hasFolderLock(userId, folderId);
282
283 Lock lock = null;
284
285 if (!hasLock) {
286
287
288
289 lock = lockFolder(
290 userId, folderId, null, false,
291 DLFolderImpl.LOCK_EXPIRATION_TIME);
292 }
293
294 try {
295 return deleteFolder(folderId, includeTrashedEntries);
296 }
297 finally {
298 if (!hasLock) {
299
300
301
302 unlockFolder(folderId, lock.getUuid());
303 }
304 }
305 }
306
307 @Override
308 public DLFolder fetchFolder(long folderId) {
309 return dlFolderPersistence.fetchByPrimaryKey(folderId);
310 }
311
312 @Override
313 public DLFolder fetchFolder(
314 long groupId, long parentFolderId, String name) {
315
316 return dlFolderPersistence.fetchByG_P_N(groupId, parentFolderId, name);
317 }
318
319 @Override
320 public List<DLFolder> getCompanyFolders(
321 long companyId, int start, int end) {
322
323 return dlFolderPersistence.findByCompanyId(companyId, start, end);
324 }
325
326 @Override
327 public int getCompanyFoldersCount(long companyId) {
328 return dlFolderPersistence.countByCompanyId(companyId);
329 }
330
331 @Override
332 public List<Object> getFileEntriesAndFileShortcuts(
333 long groupId, long folderId, QueryDefinition<?> queryDefinition) {
334
335 return dlFolderFinder.findFE_FS_ByG_F(
336 groupId, folderId, queryDefinition);
337 }
338
339 @Override
340 public int getFileEntriesAndFileShortcutsCount(
341 long groupId, long folderId, QueryDefinition<?> queryDefinition) {
342
343 return dlFolderFinder.countFE_FS_ByG_F(
344 groupId, folderId, queryDefinition);
345 }
346
347 @Override
348 public DLFolder getFolder(long folderId) throws PortalException {
349 return dlFolderPersistence.findByPrimaryKey(folderId);
350 }
351
352 @Override
353 public DLFolder getFolder(long groupId, long parentFolderId, String name)
354 throws PortalException {
355
356 return dlFolderPersistence.findByG_P_N(groupId, parentFolderId, name);
357 }
358
359 @Override
360 public long getFolderId(long companyId, long folderId) {
361 if (folderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
362
363
364
365 DLFolder dlFolder = dlFolderPersistence.fetchByPrimaryKey(folderId);
366
367 if ((dlFolder == null) || (companyId != dlFolder.getCompanyId())) {
368 folderId = DLFolderConstants.DEFAULT_PARENT_FOLDER_ID;
369 }
370 }
371
372 return folderId;
373 }
374
375
379 @Deprecated
380 @Override
381 public List<Long> getFolderIds(long groupId, long parentFolderId) {
382 return getGroupFolderIds(groupId, parentFolderId);
383 }
384
385 @Override
386 public List<DLFolder> getFolders(long groupId, long parentFolderId) {
387 return getFolders(groupId, parentFolderId, true);
388 }
389
390 @Override
391 public List<DLFolder> getFolders(
392 long groupId, long parentFolderId, boolean includeMountfolders) {
393
394 if (includeMountfolders) {
395 return dlFolderPersistence.findByG_P(groupId, parentFolderId);
396 }
397 else {
398 return dlFolderPersistence.findByG_M_P_H(
399 groupId, false, parentFolderId, false);
400 }
401 }
402
403 @Override
404 public List<DLFolder> getFolders(
405 long groupId, long parentFolderId, boolean includeMountfolders,
406 int start, int end, OrderByComparator<DLFolder> obc) {
407
408 if (includeMountfolders) {
409 return dlFolderPersistence.findByG_P(
410 groupId, parentFolderId, start, end, obc);
411 }
412 else {
413 return dlFolderPersistence.findByG_M_P_H(
414 groupId, false, parentFolderId, false, start, end, obc);
415 }
416 }
417
418 @Override
419 public List<DLFolder> getFolders(
420 long groupId, long parentFolderId, int status,
421 boolean includeMountfolders, int start, int end,
422 OrderByComparator<DLFolder> obc) {
423
424 if (includeMountfolders) {
425 return dlFolderPersistence.findByG_P_H_S(
426 groupId, parentFolderId, false, status, start, end, obc);
427 }
428 else {
429 return dlFolderPersistence.findByG_M_P_H_S(
430 groupId, false, parentFolderId, false, status, start, end, obc);
431 }
432 }
433
434 @Override
435 public List<DLFolder> getFolders(
436 long groupId, long parentFolderId, int start, int end,
437 OrderByComparator<DLFolder> obc) {
438
439 return getFolders(groupId, parentFolderId, true, start, end, obc);
440 }
441
442 @Override
443 public List<Object> getFoldersAndFileEntriesAndFileShortcuts(
444 long groupId, long folderId, String[] mimeTypes,
445 boolean includeMountFolders, QueryDefinition<?> queryDefinition) {
446
447 return dlFolderFinder.findF_FE_FS_ByG_F_M_M(
448 groupId, folderId, mimeTypes, includeMountFolders, queryDefinition);
449 }
450
451 @Override
452 public int getFoldersAndFileEntriesAndFileShortcutsCount(
453 long groupId, long folderId, String[] mimeTypes,
454 boolean includeMountFolders, QueryDefinition<?> queryDefinition) {
455
456 return dlFolderFinder.countF_FE_FS_ByG_F_M_M(
457 groupId, folderId, mimeTypes, includeMountFolders, queryDefinition);
458 }
459
460 @Override
461 public int getFoldersCount(long groupId, long parentFolderId) {
462 return getFoldersCount(groupId, parentFolderId, true);
463 }
464
465 @Override
466 public int getFoldersCount(
467 long groupId, long parentFolderId, boolean includeMountfolders) {
468
469 if (includeMountfolders) {
470 return dlFolderPersistence.countByG_P(groupId, parentFolderId);
471 }
472 else {
473 return dlFolderPersistence.countByG_M_P_H(
474 groupId, false, parentFolderId, false);
475 }
476 }
477
478 @Override
479 public int getFoldersCount(
480 long groupId, long parentFolderId, int status,
481 boolean includeMountfolders) {
482
483 if (status == WorkflowConstants.STATUS_ANY) {
484 return getFoldersCount(
485 groupId, parentFolderId, includeMountfolders);
486 }
487 else if (includeMountfolders) {
488 return dlFolderPersistence.countByG_P_H_S(
489 groupId, parentFolderId, false, status);
490 }
491 else {
492 return dlFolderPersistence.countByG_M_P_H_S(
493 groupId, false, parentFolderId, false, status);
494 }
495 }
496
497 @Override
498 public List<Long> getGroupFolderIds(long groupId, long parentFolderId) {
499 List<Long> folderIds = new ArrayList<>();
500
501 folderIds.add(parentFolderId);
502
503 getGroupSubfolderIds(folderIds, groupId, parentFolderId);
504
505 return folderIds;
506 }
507
508 @Override
509 public void getGroupSubfolderIds(
510 List<Long> folderIds, long groupId, long folderId) {
511
512 List<DLFolder> dlFolders = dlFolderPersistence.findByG_P(
513 groupId, folderId);
514
515 for (DLFolder dlFolder : dlFolders) {
516 folderIds.add(dlFolder.getFolderId());
517
518 getGroupSubfolderIds(
519 folderIds, dlFolder.getGroupId(), dlFolder.getFolderId());
520 }
521 }
522
523 @Override
524 public DLFolder getMountFolder(long repositoryId) throws PortalException {
525 return dlFolderPersistence.findByR_M(repositoryId, true);
526 }
527
528 @Override
529 public List<DLFolder> getMountFolders(
530 long groupId, long parentFolderId, int start, int end,
531 OrderByComparator<DLFolder> obc) {
532
533 return dlFolderPersistence.findByG_M_P_H(
534 groupId, true, parentFolderId, false, start, end, obc);
535 }
536
537 @Override
538 public int getMountFoldersCount(long groupId, long parentFolderId) {
539 return dlFolderPersistence.countByG_M_P_H(
540 groupId, true, parentFolderId, false);
541 }
542
543 @Override
544 public List<DLFolder> getNoAssetFolders() {
545 return dlFolderFinder.findF_ByNoAssets();
546 }
547
548 @Override
549 public List<Long> getRepositoryFolderIds(
550 long repositoryId, long parentFolderId) {
551
552 List<Long> folderIds = new ArrayList<>();
553
554 folderIds.add(parentFolderId);
555
556 getRepositorySubfolderIds(folderIds, repositoryId, parentFolderId);
557
558 return folderIds;
559 }
560
561 @Override
562 public List<DLFolder> getRepositoryFolders(
563 long repositoryId, int start, int end) {
564
565 return dlFolderPersistence.findByRepositoryId(repositoryId, start, end);
566 }
567
568 @Override
569 public int getRepositoryFoldersCount(long repositoryId) {
570 return dlFolderPersistence.countByRepositoryId(repositoryId);
571 }
572
573 @Override
574 public void getRepositorySubfolderIds(
575 List<Long> folderIds, long repositoryId, long folderId) {
576
577 List<DLFolder> dlFolders = dlFolderPersistence.findByR_P(
578 repositoryId, folderId);
579
580 for (DLFolder dlFolder : dlFolders) {
581 folderIds.add(dlFolder.getFolderId());
582
583 getRepositorySubfolderIds(
584 folderIds, dlFolder.getRepositoryId(), dlFolder.getFolderId());
585 }
586 }
587
588
592 @Deprecated
593 @Override
594 public void getSubfolderIds(
595 List<Long> folderIds, long groupId, long folderId) {
596
597 getGroupSubfolderIds(folderIds, groupId, folderId);
598 }
599
600 @Override
601 public boolean hasFolderLock(long userId, long folderId) {
602 return LockManagerUtil.hasLock(
603 userId, DLFolder.class.getName(), folderId);
604 }
605
606 @Override
607 public boolean hasInheritableLock(long folderId) throws PortalException {
608 boolean inheritable = false;
609
610 try {
611 Lock lock = LockManagerUtil.getLock(
612 DLFolder.class.getName(), folderId);
613
614 inheritable = lock.isInheritable();
615 }
616 catch (ExpiredLockException ele) {
617 if (_log.isDebugEnabled()) {
618 _log.debug(ele, ele);
619 }
620 }
621 catch (NoSuchLockException nsle) {
622 if (_log.isDebugEnabled()) {
623 _log.debug(nsle, nsle);
624 }
625 }
626
627 return inheritable;
628 }
629
630 @Override
631 public Lock lockFolder(long userId, long folderId) throws PortalException {
632 return lockFolder(
633 userId, folderId, null, false, DLFolderImpl.LOCK_EXPIRATION_TIME);
634 }
635
636 @Override
637 public Lock lockFolder(
638 long userId, long folderId, String owner, boolean inheritable,
639 long expirationTime)
640 throws PortalException {
641
642 if ((expirationTime <= 0) ||
643 (expirationTime > DLFolderImpl.LOCK_EXPIRATION_TIME)) {
644
645 expirationTime = DLFolderImpl.LOCK_EXPIRATION_TIME;
646 }
647
648 return LockManagerUtil.lock(
649 userId, DLFolder.class.getName(), folderId, owner, inheritable,
650 expirationTime);
651 }
652
653 @Indexable(type = IndexableType.REINDEX)
654 @Override
655 public DLFolder moveFolder(
656 long userId, long folderId, long parentFolderId,
657 ServiceContext serviceContext)
658 throws PortalException {
659
660 DLFolder dlFolder = dlFolderPersistence.findByPrimaryKey(folderId);
661
662 parentFolderId = getParentFolderId(dlFolder, parentFolderId);
663
664 if (dlFolder.getParentFolderId() == parentFolderId) {
665 return dlFolder;
666 }
667
668 boolean hasLock = hasFolderLock(userId, folderId);
669
670 Lock lock = null;
671
672 if (!hasLock) {
673
674
675
676 lock = lockFolder(userId, folderId);
677 }
678
679 try {
680 validateFolder(
681 dlFolder.getFolderId(), dlFolder.getGroupId(), parentFolderId,
682 dlFolder.getName());
683
684 dlFolder.setParentFolderId(parentFolderId);
685 dlFolder.setTreePath(dlFolder.buildTreePath());
686 dlFolder.setExpandoBridgeAttributes(serviceContext);
687
688 dlFolderPersistence.update(dlFolder);
689
690 rebuildTree(
691 dlFolder.getCompanyId(), folderId, dlFolder.getTreePath(),
692 true);
693
694 return dlFolder;
695 }
696 finally {
697 if (!hasLock) {
698
699
700
701 unlockFolder(folderId, lock.getUuid());
702 }
703 }
704 }
705
706 @Override
707 public void rebuildTree(long companyId) throws PortalException {
708 rebuildTree(
709 companyId, DLFolderConstants.DEFAULT_PARENT_FOLDER_ID,
710 StringPool.SLASH, false);
711 }
712
713 @Override
714 public void rebuildTree(
715 long companyId, long parentFolderId, String parentTreePath,
716 final boolean reindex)
717 throws PortalException {
718
719 TreePathUtil.rebuildTree(
720 companyId, parentFolderId, parentTreePath,
721 new TreeModelTasksAdapter<DLFolder>() {
722
723 @Override
724 public List<DLFolder> findTreeModels(
725 long previousId, long companyId, long parentPrimaryKey,
726 int size) {
727
728 return dlFolderPersistence.findByF_C_P_NotS(
729 previousId, companyId, parentPrimaryKey,
730 WorkflowConstants.STATUS_IN_TRASH, QueryUtil.ALL_POS,
731 size, new FolderIdComparator(true));
732 }
733
734 @Override
735 public void rebuildDependentModelsTreePaths(
736 long parentPrimaryKey, String treePath)
737 throws PortalException {
738
739 dlFileEntryLocalService.setTreePaths(
740 parentPrimaryKey, treePath, false);
741 dlFileShortcutLocalService.setTreePaths(
742 parentPrimaryKey, treePath);
743 dlFileVersionLocalService.setTreePaths(
744 parentPrimaryKey, treePath);
745 }
746
747 @Override
748 public void reindexTreeModels(List<TreeModel> treeModels)
749 throws PortalException {
750
751 if (!reindex) {
752 return;
753 }
754
755 Indexer<DLFolder> indexer =
756 IndexerRegistryUtil.nullSafeGetIndexer(DLFolder.class);
757
758 for (TreeModel treeModel : treeModels) {
759 DLFolder dlFolder = (DLFolder)treeModel;
760
761 indexer.reindex(dlFolder);
762 }
763 }
764
765 }
766 );
767 }
768
769 @Override
770 public void unlockFolder(
771 long groupId, long parentFolderId, String name, String lockUuid)
772 throws PortalException {
773
774 DLFolder dlFolder = getFolder(groupId, parentFolderId, name);
775
776 unlockFolder(dlFolder.getFolderId(), lockUuid);
777 }
778
779 @Override
780 public void unlockFolder(long folderId, String lockUuid)
781 throws PortalException {
782
783 if (Validator.isNotNull(lockUuid)) {
784 try {
785 Lock lock = LockManagerUtil.getLock(
786 DLFolder.class.getName(), folderId);
787
788 if (!lockUuid.equals(lock.getUuid())) {
789 throw new InvalidLockException("UUIDs do not match");
790 }
791 }
792 catch (ExpiredLockException | NoSuchLockException e) {
793 }
794 }
795
796 LockManagerUtil.unlock(DLFolder.class.getName(), folderId);
797 }
798
799
803 @Deprecated
804 @Override
805 public DLFolder updateFolder(
806 long folderId, long parentFolderId, String name, String description,
807 long defaultFileEntryTypeId, List<Long> fileEntryTypeIds,
808 boolean overrideFileEntryTypes, ServiceContext serviceContext)
809 throws PortalException {
810
811 int restrictionType = DLFolderConstants.RESTRICTION_TYPE_INHERIT;
812
813 if (overrideFileEntryTypes) {
814 restrictionType =
815 DLFolderConstants.
816 RESTRICTION_TYPE_FILE_ENTRY_TYPES_AND_WORKFLOW;
817 }
818
819 return updateFolder(
820 folderId, name, description, defaultFileEntryTypeId,
821 fileEntryTypeIds, restrictionType, serviceContext);
822 }
823
824 @Indexable(type = IndexableType.REINDEX)
825 @Override
826 public DLFolder updateFolder(
827 long folderId, long parentFolderId, String name, String description,
828 long defaultFileEntryTypeId, List<Long> fileEntryTypeIds,
829 int restrictionType, ServiceContext serviceContext)
830 throws PortalException {
831
832 boolean hasLock = hasFolderLock(serviceContext.getUserId(), folderId);
833
834 Lock lock = null;
835
836 if (!hasLock) {
837
838
839
840 lock = lockFolder(
841 serviceContext.getUserId(), folderId, null, false,
842 DLFolderImpl.LOCK_EXPIRATION_TIME);
843 }
844
845 try {
846
847
848
849 DLFolder dlFolder = null;
850
851 Set<Long> originalFileEntryTypeIds = new HashSet<>();
852
853 if (folderId > DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
854 originalFileEntryTypeIds = getFileEntryTypeIds(
855 dlFolderPersistence.getDLFileEntryTypes(folderId));
856
857 dlFolder = dlFolderLocalService.updateFolderAndFileEntryTypes(
858 serviceContext.getUserId(), folderId, parentFolderId, name,
859 description, defaultFileEntryTypeId, fileEntryTypeIds,
860 restrictionType, serviceContext);
861
862 if (!ExportImportThreadLocal.isImportInProcess()) {
863 dlFileEntryTypeLocalService.cascadeFileEntryTypes(
864 serviceContext.getUserId(), dlFolder);
865 }
866 }
867
868
869
870 List<ObjectValuePair<Long, String>> workflowDefinitionOVPs =
871 new ArrayList<>();
872
873 if (restrictionType ==
874 DLFolderConstants.
875 RESTRICTION_TYPE_FILE_ENTRY_TYPES_AND_WORKFLOW) {
876
877 workflowDefinitionOVPs.add(
878 new ObjectValuePair<Long, String>(
879 DLFileEntryTypeConstants.FILE_ENTRY_TYPE_ID_ALL,
880 StringPool.BLANK));
881
882 for (long fileEntryTypeId : fileEntryTypeIds) {
883 String workflowDefinition = ParamUtil.getString(
884 serviceContext, "workflowDefinition" + fileEntryTypeId);
885
886 workflowDefinitionOVPs.add(
887 new ObjectValuePair<Long, String>(
888 fileEntryTypeId, workflowDefinition));
889 }
890 }
891 else if (restrictionType ==
892 DLFolderConstants.RESTRICTION_TYPE_INHERIT) {
893
894 if (originalFileEntryTypeIds.isEmpty()) {
895 originalFileEntryTypeIds.add(
896 DLFileEntryTypeConstants.FILE_ENTRY_TYPE_ID_ALL);
897 }
898
899 for (long originalFileEntryTypeId : originalFileEntryTypeIds) {
900 workflowDefinitionOVPs.add(
901 new ObjectValuePair<Long, String>(
902 originalFileEntryTypeId, StringPool.BLANK));
903 }
904 }
905 else if (restrictionType ==
906 DLFolderConstants.RESTRICTION_TYPE_WORKFLOW) {
907
908 String workflowDefinition = ParamUtil.getString(
909 serviceContext,
910 "workflowDefinition" +
911 DLFileEntryTypeConstants.FILE_ENTRY_TYPE_ID_ALL);
912
913 workflowDefinitionOVPs.add(
914 new ObjectValuePair<Long, String>(
915 DLFileEntryTypeConstants.FILE_ENTRY_TYPE_ID_ALL,
916 workflowDefinition));
917
918 for (long originalFileEntryTypeId : originalFileEntryTypeIds) {
919 workflowDefinitionOVPs.add(
920 new ObjectValuePair<Long, String>(
921 originalFileEntryTypeId, StringPool.BLANK));
922 }
923 }
924
925 workflowDefinitionLinkLocalService.updateWorkflowDefinitionLinks(
926 serviceContext.getUserId(), serviceContext.getCompanyId(),
927 serviceContext.getScopeGroupId(), DLFolder.class.getName(),
928 folderId, workflowDefinitionOVPs);
929
930 return dlFolder;
931 }
932 finally {
933 if (!hasLock) {
934
935
936
937 unlockFolder(folderId, lock.getUuid());
938 }
939 }
940 }
941
942
946 @Deprecated
947 @Override
948 public DLFolder updateFolder(
949 long folderId, String name, String description,
950 long defaultFileEntryTypeId, List<Long> fileEntryTypeIds,
951 boolean overrideFileEntryTypes, ServiceContext serviceContext)
952 throws PortalException {
953
954 int restrictionType = DLFolderConstants.RESTRICTION_TYPE_INHERIT;
955
956 if (overrideFileEntryTypes) {
957 restrictionType =
958 DLFolderConstants.
959 RESTRICTION_TYPE_FILE_ENTRY_TYPES_AND_WORKFLOW;
960 }
961
962 return updateFolder(
963 serviceContext.getScopeGroupId(), folderId, name, description,
964 defaultFileEntryTypeId, fileEntryTypeIds, restrictionType,
965 serviceContext);
966 }
967
968 @Indexable(type = IndexableType.REINDEX)
969 @Override
970 public DLFolder updateFolder(
971 long folderId, String name, String description,
972 long defaultFileEntryTypeId, List<Long> fileEntryTypeIds,
973 int restrictionType, ServiceContext serviceContext)
974 throws PortalException {
975
976 long parentFolderId = DLFolderConstants.DEFAULT_PARENT_FOLDER_ID;
977
978 if (folderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
979 DLFolder dlFolder = getDLFolder(folderId);
980
981 parentFolderId = dlFolder.getParentFolderId();
982 }
983
984 return updateFolder(
985 folderId, parentFolderId, name, description, defaultFileEntryTypeId,
986 fileEntryTypeIds, restrictionType, serviceContext);
987 }
988
989
994 @Deprecated
995 @Override
996 public DLFolder updateFolderAndFileEntryTypes(
997 long userId, long folderId, long parentFolderId, String name,
998 String description, long defaultFileEntryTypeId,
999 List<Long> fileEntryTypeIds, boolean overrideFileEntryTypes,
1000 ServiceContext serviceContext)
1001 throws PortalException {
1002
1003 int restrictionType = DLFolderConstants.RESTRICTION_TYPE_INHERIT;
1004
1005 if (overrideFileEntryTypes) {
1006 restrictionType =
1007 DLFolderConstants.
1008 RESTRICTION_TYPE_FILE_ENTRY_TYPES_AND_WORKFLOW;
1009 }
1010
1011 return updateFolderAndFileEntryTypes(
1012 userId, folderId, parentFolderId, name, description,
1013 defaultFileEntryTypeId, fileEntryTypeIds, restrictionType,
1014 serviceContext);
1015 }
1016
1017 @Override
1018 public DLFolder updateFolderAndFileEntryTypes(
1019 long userId, long folderId, long parentFolderId, String name,
1020 String description, long defaultFileEntryTypeId,
1021 List<Long> fileEntryTypeIds, int restrictionType,
1022 ServiceContext serviceContext)
1023 throws PortalException {
1024
1025 if ((restrictionType ==
1026 DLFolderConstants.
1027 RESTRICTION_TYPE_FILE_ENTRY_TYPES_AND_WORKFLOW) &&
1028 fileEntryTypeIds.isEmpty()) {
1029
1030 throw new RequiredFileEntryTypeException(
1031 "File entry type IDs is empty");
1032 }
1033
1034 boolean hasLock = hasFolderLock(userId, folderId);
1035
1036 Lock lock = null;
1037
1038 if (!hasLock) {
1039
1040
1041
1042 lock = lockFolder(
1043 userId, folderId, null, false,
1044 DLFolderImpl.LOCK_EXPIRATION_TIME);
1045 }
1046
1047 try {
1048
1049
1050
1051 if (restrictionType == DLFolderConstants.RESTRICTION_TYPE_INHERIT) {
1052 fileEntryTypeIds = Collections.emptyList();
1053 }
1054
1055 DLFolder dlFolder = dlFolderPersistence.findByPrimaryKey(folderId);
1056
1057 parentFolderId = getParentFolderId(dlFolder, parentFolderId);
1058
1059 validateFolder(
1060 folderId, dlFolder.getGroupId(), parentFolderId, name);
1061
1062 long oldParentFolderId = dlFolder.getParentFolderId();
1063
1064 if (oldParentFolderId != parentFolderId) {
1065 dlFolder.setParentFolderId(parentFolderId);
1066 dlFolder.setTreePath(dlFolder.buildTreePath());
1067 }
1068
1069 dlFolder.setName(name);
1070 dlFolder.setDescription(description);
1071 dlFolder.setExpandoBridgeAttributes(serviceContext);
1072 dlFolder.setRestrictionType(restrictionType);
1073 dlFolder.setDefaultFileEntryTypeId(defaultFileEntryTypeId);
1074
1075 dlFolderPersistence.update(dlFolder);
1076
1077
1078
1079 if (fileEntryTypeIds != null) {
1080 dlFileEntryTypeLocalService.updateFolderFileEntryTypes(
1081 dlFolder, fileEntryTypeIds, defaultFileEntryTypeId,
1082 serviceContext);
1083 }
1084
1085 if (oldParentFolderId != parentFolderId) {
1086 rebuildTree(
1087 dlFolder.getCompanyId(), folderId, dlFolder.getTreePath(),
1088 true);
1089 }
1090
1091 return dlFolder;
1092 }
1093 finally {
1094 if (!hasLock) {
1095
1096
1097
1098 unlockFolder(folderId, lock.getUuid());
1099 }
1100 }
1101 }
1102
1103 @BufferedIncrement(
1104 configuration = "DLFolderEntry",
1105 incrementClass = DateOverrideIncrement.class
1106 )
1107 @Override
1108 public void updateLastPostDate(long folderId, Date lastPostDate)
1109 throws PortalException {
1110
1111 if (ExportImportThreadLocal.isImportInProcess() ||
1112 (folderId == DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) ||
1113 (lastPostDate == null)) {
1114
1115 return;
1116 }
1117
1118 DLFolder dlFolder = dlFolderPersistence.findByPrimaryKey(folderId);
1119
1120 if (lastPostDate.before(dlFolder.getLastPostDate())) {
1121 return;
1122 }
1123
1124 dlFolder.setModifiedDate(dlFolder.getModifiedDate());
1125 dlFolder.setLastPostDate(lastPostDate);
1126
1127 dlFolderPersistence.update(dlFolder);
1128 }
1129
1130 @Override
1131 public DLFolder updateStatus(
1132 long userId, long folderId, int status,
1133 Map<String, Serializable> workflowContext,
1134 ServiceContext serviceContext)
1135 throws PortalException {
1136
1137
1138
1139 User user = userPersistence.findByPrimaryKey(userId);
1140
1141 DLFolder dlFolder = dlFolderPersistence.findByPrimaryKey(folderId);
1142
1143 int oldStatus = dlFolder.getStatus();
1144
1145 dlFolder.setStatus(status);
1146 dlFolder.setStatusByUserId(user.getUserId());
1147 dlFolder.setStatusByUserName(user.getFullName());
1148 dlFolder.setStatusDate(new Date());
1149
1150 dlFolderPersistence.update(dlFolder);
1151
1152
1153
1154 if (status == WorkflowConstants.STATUS_APPROVED) {
1155 assetEntryLocalService.updateVisible(
1156 DLFolder.class.getName(), dlFolder.getFolderId(), true);
1157 }
1158 else if (status == WorkflowConstants.STATUS_IN_TRASH) {
1159 assetEntryLocalService.updateVisible(
1160 DLFolder.class.getName(), dlFolder.getFolderId(), false);
1161 }
1162
1163
1164
1165 if (((status == WorkflowConstants.STATUS_APPROVED) ||
1166 (status == WorkflowConstants.STATUS_IN_TRASH) ||
1167 (oldStatus == WorkflowConstants.STATUS_IN_TRASH)) &&
1168 ((serviceContext == null) || serviceContext.isIndexingEnabled())) {
1169
1170 Indexer<DLFolder> indexer = IndexerRegistryUtil.nullSafeGetIndexer(
1171 DLFolder.class);
1172
1173 indexer.reindex(dlFolder);
1174 }
1175
1176 return dlFolder;
1177 }
1178
1179 @Override
1180 public boolean verifyInheritableLock(long folderId, String lockUuid)
1181 throws PortalException {
1182
1183 boolean verified = false;
1184
1185 try {
1186 Lock lock = LockManagerUtil.getLock(
1187 DLFolder.class.getName(), folderId);
1188
1189 if (!lock.isInheritable()) {
1190 throw new NoSuchLockException("{folderId=" + folderId + "}");
1191 }
1192
1193 if (lock.getUuid().equals(lockUuid)) {
1194 verified = true;
1195 }
1196 }
1197 catch (ExpiredLockException ele) {
1198 throw new NoSuchLockException(ele);
1199 }
1200
1201 return verified;
1202 }
1203
1204 protected void addFolderResources(
1205 DLFolder dlFolder, boolean addGroupPermissions,
1206 boolean addGuestPermissions)
1207 throws PortalException {
1208
1209 resourceLocalService.addResources(
1210 dlFolder.getCompanyId(), dlFolder.getGroupId(),
1211 dlFolder.getUserId(), DLFolder.class.getName(),
1212 dlFolder.getFolderId(), false, addGroupPermissions,
1213 addGuestPermissions);
1214 }
1215
1216 protected void addFolderResources(
1217 DLFolder dlFolder, ModelPermissions modelPermissions)
1218 throws PortalException {
1219
1220 resourceLocalService.addModelResources(
1221 dlFolder.getCompanyId(), dlFolder.getGroupId(),
1222 dlFolder.getUserId(), DLFolder.class.getName(),
1223 dlFolder.getFolderId(), modelPermissions);
1224 }
1225
1226 protected void addFolderResources(
1227 long folderId, boolean addGroupPermissions,
1228 boolean addGuestPermissions)
1229 throws PortalException {
1230
1231 DLFolder dlFolder = dlFolderPersistence.findByPrimaryKey(folderId);
1232
1233 addFolderResources(dlFolder, addGroupPermissions, addGuestPermissions);
1234 }
1235
1236 protected void addFolderResources(
1237 long folderId, ModelPermissions modelPermissions)
1238 throws PortalException {
1239
1240 DLFolder dlFolder = dlFolderPersistence.findByPrimaryKey(folderId);
1241
1242 addFolderResources(dlFolder, modelPermissions);
1243 }
1244
1245 protected void deleteFolderDependencies(
1246 DLFolder dlFolder, boolean includeTrashedEntries)
1247 throws PortalException {
1248
1249
1250
1251 resourceLocalService.deleteResource(
1252 dlFolder.getCompanyId(), DLFolder.class.getName(),
1253 ResourceConstants.SCOPE_INDIVIDUAL, dlFolder.getFolderId());
1254
1255
1256
1257 webDAVPropsLocalService.deleteWebDAVProps(
1258 DLFolder.class.getName(), dlFolder.getFolderId());
1259
1260
1261
1262 dlFileEntryLocalService.deleteFileEntries(
1263 dlFolder.getGroupId(), dlFolder.getFolderId(),
1264 includeTrashedEntries);
1265
1266
1267
1268 List<Long> fileEntryTypeIds = new ArrayList<>();
1269
1270 for (DLFileEntryType dlFileEntryType :
1271 dlFileEntryTypeLocalService.getDLFolderDLFileEntryTypes(
1272 dlFolder.getFolderId())) {
1273
1274 fileEntryTypeIds.add(dlFileEntryType.getFileEntryTypeId());
1275 }
1276
1277 if (fileEntryTypeIds.isEmpty()) {
1278 fileEntryTypeIds.add(
1279 DLFileEntryTypeConstants.FILE_ENTRY_TYPE_ID_ALL);
1280 }
1281
1282 dlFileEntryTypeLocalService.unsetFolderFileEntryTypes(
1283 dlFolder.getFolderId());
1284
1285
1286
1287 dlFileShortcutLocalService.deleteFileShortcuts(
1288 dlFolder.getGroupId(), dlFolder.getFolderId(),
1289 includeTrashedEntries);
1290
1291
1292
1293 expandoRowLocalService.deleteRows(dlFolder.getFolderId());
1294
1295
1296
1297 ratingsStatsLocalService.deleteStats(
1298 DLFolder.class.getName(), dlFolder.getFolderId());
1299
1300
1301
1302 dlFolderPersistence.remove(dlFolder);
1303
1304
1305
1306 if (includeTrashedEntries) {
1307 DLStoreUtil.deleteDirectory(
1308 dlFolder.getCompanyId(), dlFolder.getFolderId(),
1309 StringPool.BLANK);
1310 }
1311
1312
1313
1314 for (long fileEntryTypeId : fileEntryTypeIds) {
1315 WorkflowDefinitionLink workflowDefinitionLink =
1316 workflowDefinitionLinkLocalService.fetchWorkflowDefinitionLink(
1317 dlFolder.getCompanyId(), dlFolder.getGroupId(),
1318 DLFolder.class.getName(), dlFolder.getFolderId(),
1319 fileEntryTypeId);
1320
1321 if (workflowDefinitionLink != null) {
1322 workflowDefinitionLinkLocalService.deleteWorkflowDefinitionLink(
1323 workflowDefinitionLink);
1324 }
1325 }
1326 }
1327
1328 protected void deleteSubfolders(
1329 DLFolder dlFolder, boolean includeTrashedEntries)
1330 throws PortalException {
1331
1332 RepositoryEventTrigger repositoryEventTrigger =
1333 RepositoryUtil.getRepositoryEventTrigger(
1334 dlFolder.getRepositoryId());
1335
1336 List<DLFolder> dlFolders = dlFolderPersistence.findByG_P(
1337 dlFolder.getGroupId(), dlFolder.getFolderId());
1338
1339 for (DLFolder curDLFolder : dlFolders) {
1340 if (includeTrashedEntries || !curDLFolder.isInTrashExplicitly()) {
1341 repositoryEventTrigger.trigger(
1342 RepositoryEventType.Delete.class, Folder.class,
1343 new LiferayFolder(curDLFolder));
1344
1345 dlFolderLocalService.deleteFolder(
1346 curDLFolder, includeTrashedEntries);
1347 }
1348 }
1349 }
1350
1351 protected Set<Long> getFileEntryTypeIds(
1352 List<DLFileEntryType> dlFileEntryTypes) {
1353
1354 Set<Long> fileEntryTypeIds = new HashSet<>();
1355
1356 for (DLFileEntryType dlFileEntryType : dlFileEntryTypes) {
1357 fileEntryTypeIds.add(dlFileEntryType.getFileEntryTypeId());
1358 }
1359
1360 return fileEntryTypeIds;
1361 }
1362
1363 protected long getParentFolderId(DLFolder dlFolder, long parentFolderId)
1364 throws PortalException {
1365
1366 parentFolderId = getParentFolderId(
1367 dlFolder.getGroupId(), dlFolder.getRepositoryId(), parentFolderId);
1368
1369 if (parentFolderId == DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
1370 return parentFolderId;
1371 }
1372
1373 if (dlFolder.getFolderId() == parentFolderId) {
1374 throw new InvalidFolderException(
1375 InvalidFolderException.CANNOT_MOVE_INTO_ITSELF, parentFolderId);
1376 }
1377
1378 List<Long> subfolderIds = new ArrayList<>();
1379
1380 getGroupSubfolderIds(
1381 subfolderIds, dlFolder.getGroupId(), dlFolder.getFolderId());
1382
1383 if (subfolderIds.contains(parentFolderId)) {
1384 throw new InvalidFolderException(
1385 InvalidFolderException.CANNOT_MOVE_INTO_CHILD_FOLDER,
1386 parentFolderId);
1387 }
1388
1389 return parentFolderId;
1390 }
1391
1392 protected long getParentFolderId(
1393 long groupId, long repositoryId, long parentFolderId)
1394 throws PortalException {
1395
1396 if (parentFolderId == DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
1397 return parentFolderId;
1398 }
1399
1400 DLFolder parentDLFolder = dlFolderPersistence.findByPrimaryKey(
1401 parentFolderId);
1402
1403 if (parentDLFolder.getGroupId() != groupId) {
1404 throw new NoSuchFolderException(
1405 String.format(
1406 "No folder exists with the primary key %s in group %s",
1407 parentFolderId, groupId));
1408 }
1409
1410 if ((parentDLFolder.getRepositoryId() != repositoryId) &&
1411 (parentDLFolder.getRepositoryId() != groupId)) {
1412
1413 Repository repository = repositoryLocalService.getRepository(
1414 repositoryId);
1415
1416 if (repository.getGroupId() != parentDLFolder.getGroupId()) {
1417 throw new NoSuchFolderException(
1418 String.format(
1419 "No folder exists with the primary key %s in " +
1420 "repository %s",
1421 parentFolderId, repositoryId));
1422 }
1423 }
1424
1425 return parentDLFolder.getFolderId();
1426 }
1427
1428 protected void validateFolder(
1429 long folderId, long groupId, long parentFolderId, String name)
1430 throws PortalException {
1431
1432 validateFolderName(name);
1433
1434 DLValidatorUtil.validateDirectoryName(name);
1435
1436 DLFileEntry dlFileEntry = dlFileEntryLocalService.fetchFileEntry(
1437 groupId, parentFolderId, name);
1438
1439 if (dlFileEntry != null) {
1440 throw new DuplicateFileEntryException(name);
1441 }
1442
1443 DLFolder dlFolder = dlFolderPersistence.fetchByG_P_N(
1444 groupId, parentFolderId, name);
1445
1446 if ((dlFolder != null) && (dlFolder.getFolderId() != folderId)) {
1447 throw new DuplicateFolderNameException(name);
1448 }
1449 }
1450
1451 protected void validateFolder(
1452 long groupId, long parentFolderId, String name)
1453 throws PortalException {
1454
1455 long folderId = 0;
1456
1457 validateFolder(folderId, groupId, parentFolderId, name);
1458 }
1459
1460 protected void validateFolderName(String folderName)
1461 throws PortalException {
1462
1463 if (folderName.contains(StringPool.SLASH)) {
1464 throw new FolderNameException(folderName);
1465 }
1466 }
1467
1468 private static final Log _log = LogFactoryUtil.getLog(
1469 DLFolderLocalServiceImpl.class);
1470
1471 }