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