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 dlFileEntryTypeLocalService.cascadeFileEntryTypes(
863 serviceContext.getUserId(), dlFolder);
864 }
865
866
867
868 List<ObjectValuePair<Long, String>> workflowDefinitionOVPs =
869 new ArrayList<>();
870
871 if (restrictionType ==
872 DLFolderConstants.
873 RESTRICTION_TYPE_FILE_ENTRY_TYPES_AND_WORKFLOW) {
874
875 workflowDefinitionOVPs.add(
876 new ObjectValuePair<Long, String>(
877 DLFileEntryTypeConstants.FILE_ENTRY_TYPE_ID_ALL,
878 StringPool.BLANK));
879
880 for (long fileEntryTypeId : fileEntryTypeIds) {
881 String workflowDefinition = ParamUtil.getString(
882 serviceContext, "workflowDefinition" + fileEntryTypeId);
883
884 workflowDefinitionOVPs.add(
885 new ObjectValuePair<Long, String>(
886 fileEntryTypeId, workflowDefinition));
887 }
888 }
889 else if (restrictionType ==
890 DLFolderConstants.RESTRICTION_TYPE_INHERIT) {
891
892 if (originalFileEntryTypeIds.isEmpty()) {
893 originalFileEntryTypeIds.add(
894 DLFileEntryTypeConstants.FILE_ENTRY_TYPE_ID_ALL);
895 }
896
897 for (long originalFileEntryTypeId : originalFileEntryTypeIds) {
898 workflowDefinitionOVPs.add(
899 new ObjectValuePair<Long, String>(
900 originalFileEntryTypeId, StringPool.BLANK));
901 }
902 }
903 else if (restrictionType ==
904 DLFolderConstants.RESTRICTION_TYPE_WORKFLOW) {
905
906 String workflowDefinition = ParamUtil.getString(
907 serviceContext,
908 "workflowDefinition" +
909 DLFileEntryTypeConstants.FILE_ENTRY_TYPE_ID_ALL);
910
911 workflowDefinitionOVPs.add(
912 new ObjectValuePair<Long, String>(
913 DLFileEntryTypeConstants.FILE_ENTRY_TYPE_ID_ALL,
914 workflowDefinition));
915
916 for (long originalFileEntryTypeId : originalFileEntryTypeIds) {
917 workflowDefinitionOVPs.add(
918 new ObjectValuePair<Long, String>(
919 originalFileEntryTypeId, StringPool.BLANK));
920 }
921 }
922
923 workflowDefinitionLinkLocalService.updateWorkflowDefinitionLinks(
924 serviceContext.getUserId(), serviceContext.getCompanyId(),
925 serviceContext.getScopeGroupId(), DLFolder.class.getName(),
926 folderId, workflowDefinitionOVPs);
927
928 return dlFolder;
929 }
930 finally {
931 if (!hasLock) {
932
933
934
935 unlockFolder(folderId, lock.getUuid());
936 }
937 }
938 }
939
940
944 @Deprecated
945 @Override
946 public DLFolder updateFolder(
947 long folderId, String name, String description,
948 long defaultFileEntryTypeId, List<Long> fileEntryTypeIds,
949 boolean overrideFileEntryTypes, ServiceContext serviceContext)
950 throws PortalException {
951
952 int restrictionType = DLFolderConstants.RESTRICTION_TYPE_INHERIT;
953
954 if (overrideFileEntryTypes) {
955 restrictionType =
956 DLFolderConstants.
957 RESTRICTION_TYPE_FILE_ENTRY_TYPES_AND_WORKFLOW;
958 }
959
960 return updateFolder(
961 serviceContext.getScopeGroupId(), folderId, name, description,
962 defaultFileEntryTypeId, fileEntryTypeIds, restrictionType,
963 serviceContext);
964 }
965
966 @Indexable(type = IndexableType.REINDEX)
967 @Override
968 public DLFolder updateFolder(
969 long folderId, String name, String description,
970 long defaultFileEntryTypeId, List<Long> fileEntryTypeIds,
971 int restrictionType, ServiceContext serviceContext)
972 throws PortalException {
973
974 long parentFolderId = DLFolderConstants.DEFAULT_PARENT_FOLDER_ID;
975
976 if (folderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
977 DLFolder dlFolder = getDLFolder(folderId);
978
979 parentFolderId = dlFolder.getParentFolderId();
980 }
981
982 return updateFolder(
983 folderId, parentFolderId, name, description, defaultFileEntryTypeId,
984 fileEntryTypeIds, restrictionType, serviceContext);
985 }
986
987
992 @Deprecated
993 @Override
994 public DLFolder updateFolderAndFileEntryTypes(
995 long userId, long folderId, long parentFolderId, String name,
996 String description, long defaultFileEntryTypeId,
997 List<Long> fileEntryTypeIds, boolean overrideFileEntryTypes,
998 ServiceContext serviceContext)
999 throws PortalException {
1000
1001 int restrictionType = DLFolderConstants.RESTRICTION_TYPE_INHERIT;
1002
1003 if (overrideFileEntryTypes) {
1004 restrictionType =
1005 DLFolderConstants.
1006 RESTRICTION_TYPE_FILE_ENTRY_TYPES_AND_WORKFLOW;
1007 }
1008
1009 return updateFolderAndFileEntryTypes(
1010 userId, folderId, parentFolderId, name, description,
1011 defaultFileEntryTypeId, fileEntryTypeIds, restrictionType,
1012 serviceContext);
1013 }
1014
1015 @Override
1016 public DLFolder updateFolderAndFileEntryTypes(
1017 long userId, long folderId, long parentFolderId, String name,
1018 String description, long defaultFileEntryTypeId,
1019 List<Long> fileEntryTypeIds, int restrictionType,
1020 ServiceContext serviceContext)
1021 throws PortalException {
1022
1023 if ((restrictionType ==
1024 DLFolderConstants.
1025 RESTRICTION_TYPE_FILE_ENTRY_TYPES_AND_WORKFLOW) &&
1026 fileEntryTypeIds.isEmpty()) {
1027
1028 throw new RequiredFileEntryTypeException(
1029 "File entry type IDs is empty");
1030 }
1031
1032 boolean hasLock = hasFolderLock(userId, folderId);
1033
1034 Lock lock = null;
1035
1036 if (!hasLock) {
1037
1038
1039
1040 lock = lockFolder(
1041 userId, folderId, null, false,
1042 DLFolderImpl.LOCK_EXPIRATION_TIME);
1043 }
1044
1045 try {
1046
1047
1048
1049 if (restrictionType == DLFolderConstants.RESTRICTION_TYPE_INHERIT) {
1050 fileEntryTypeIds = Collections.emptyList();
1051 }
1052
1053 DLFolder dlFolder = dlFolderPersistence.findByPrimaryKey(folderId);
1054
1055 parentFolderId = getParentFolderId(dlFolder, parentFolderId);
1056
1057 validateFolder(
1058 folderId, dlFolder.getGroupId(), parentFolderId, name);
1059
1060 long oldParentFolderId = dlFolder.getParentFolderId();
1061
1062 if (oldParentFolderId != parentFolderId) {
1063 dlFolder.setParentFolderId(parentFolderId);
1064 dlFolder.setTreePath(dlFolder.buildTreePath());
1065 }
1066
1067 dlFolder.setName(name);
1068 dlFolder.setDescription(description);
1069 dlFolder.setExpandoBridgeAttributes(serviceContext);
1070 dlFolder.setRestrictionType(restrictionType);
1071 dlFolder.setDefaultFileEntryTypeId(defaultFileEntryTypeId);
1072
1073 dlFolderPersistence.update(dlFolder);
1074
1075
1076
1077 if (fileEntryTypeIds != null) {
1078 dlFileEntryTypeLocalService.updateFolderFileEntryTypes(
1079 dlFolder, fileEntryTypeIds, defaultFileEntryTypeId,
1080 serviceContext);
1081 }
1082
1083 if (oldParentFolderId != parentFolderId) {
1084 rebuildTree(
1085 dlFolder.getCompanyId(), folderId, dlFolder.getTreePath(),
1086 true);
1087 }
1088
1089 return dlFolder;
1090 }
1091 finally {
1092 if (!hasLock) {
1093
1094
1095
1096 unlockFolder(folderId, lock.getUuid());
1097 }
1098 }
1099 }
1100
1101 @BufferedIncrement(
1102 configuration = "DLFolderEntry",
1103 incrementClass = DateOverrideIncrement.class
1104 )
1105 @Override
1106 public void updateLastPostDate(long folderId, Date lastPostDate)
1107 throws PortalException {
1108
1109 if (ExportImportThreadLocal.isImportInProcess() ||
1110 (folderId == DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) ||
1111 (lastPostDate == null)) {
1112
1113 return;
1114 }
1115
1116 DLFolder dlFolder = dlFolderPersistence.findByPrimaryKey(folderId);
1117
1118 if (lastPostDate.before(dlFolder.getLastPostDate())) {
1119 return;
1120 }
1121
1122 dlFolder.setModifiedDate(dlFolder.getModifiedDate());
1123 dlFolder.setLastPostDate(lastPostDate);
1124
1125 dlFolderPersistence.update(dlFolder);
1126 }
1127
1128 @Override
1129 public DLFolder updateStatus(
1130 long userId, long folderId, int status,
1131 Map<String, Serializable> workflowContext,
1132 ServiceContext serviceContext)
1133 throws PortalException {
1134
1135
1136
1137 User user = userPersistence.findByPrimaryKey(userId);
1138
1139 DLFolder dlFolder = dlFolderPersistence.findByPrimaryKey(folderId);
1140
1141 int oldStatus = dlFolder.getStatus();
1142
1143 dlFolder.setStatus(status);
1144 dlFolder.setStatusByUserId(user.getUserId());
1145 dlFolder.setStatusByUserName(user.getFullName());
1146 dlFolder.setStatusDate(new Date());
1147
1148 dlFolderPersistence.update(dlFolder);
1149
1150
1151
1152 if (status == WorkflowConstants.STATUS_APPROVED) {
1153 assetEntryLocalService.updateVisible(
1154 DLFolder.class.getName(), dlFolder.getFolderId(), true);
1155 }
1156 else if (status == WorkflowConstants.STATUS_IN_TRASH) {
1157 assetEntryLocalService.updateVisible(
1158 DLFolder.class.getName(), dlFolder.getFolderId(), false);
1159 }
1160
1161
1162
1163 if (((status == WorkflowConstants.STATUS_APPROVED) ||
1164 (status == WorkflowConstants.STATUS_IN_TRASH) ||
1165 (oldStatus == WorkflowConstants.STATUS_IN_TRASH)) &&
1166 ((serviceContext == null) || serviceContext.isIndexingEnabled())) {
1167
1168 Indexer<DLFolder> indexer = IndexerRegistryUtil.nullSafeGetIndexer(
1169 DLFolder.class);
1170
1171 indexer.reindex(dlFolder);
1172 }
1173
1174 return dlFolder;
1175 }
1176
1177 @Override
1178 public boolean verifyInheritableLock(long folderId, String lockUuid)
1179 throws PortalException {
1180
1181 boolean verified = false;
1182
1183 try {
1184 Lock lock = LockManagerUtil.getLock(
1185 DLFolder.class.getName(), folderId);
1186
1187 if (!lock.isInheritable()) {
1188 throw new NoSuchLockException("{folderId=" + folderId + "}");
1189 }
1190
1191 if (lock.getUuid().equals(lockUuid)) {
1192 verified = true;
1193 }
1194 }
1195 catch (ExpiredLockException ele) {
1196 throw new NoSuchLockException(ele);
1197 }
1198
1199 return verified;
1200 }
1201
1202 protected void addFolderResources(
1203 DLFolder dlFolder, boolean addGroupPermissions,
1204 boolean addGuestPermissions)
1205 throws PortalException {
1206
1207 resourceLocalService.addResources(
1208 dlFolder.getCompanyId(), dlFolder.getGroupId(),
1209 dlFolder.getUserId(), DLFolder.class.getName(),
1210 dlFolder.getFolderId(), false, addGroupPermissions,
1211 addGuestPermissions);
1212 }
1213
1214 protected void addFolderResources(
1215 DLFolder dlFolder, ModelPermissions modelPermissions)
1216 throws PortalException {
1217
1218 resourceLocalService.addModelResources(
1219 dlFolder.getCompanyId(), dlFolder.getGroupId(),
1220 dlFolder.getUserId(), DLFolder.class.getName(),
1221 dlFolder.getFolderId(), modelPermissions);
1222 }
1223
1224 protected void addFolderResources(
1225 long folderId, boolean addGroupPermissions,
1226 boolean addGuestPermissions)
1227 throws PortalException {
1228
1229 DLFolder dlFolder = dlFolderPersistence.findByPrimaryKey(folderId);
1230
1231 addFolderResources(dlFolder, addGroupPermissions, addGuestPermissions);
1232 }
1233
1234 protected void addFolderResources(
1235 long folderId, ModelPermissions modelPermissions)
1236 throws PortalException {
1237
1238 DLFolder dlFolder = dlFolderPersistence.findByPrimaryKey(folderId);
1239
1240 addFolderResources(dlFolder, modelPermissions);
1241 }
1242
1243 protected void deleteFolderDependencies(
1244 DLFolder dlFolder, boolean includeTrashedEntries)
1245 throws PortalException {
1246
1247
1248
1249 resourceLocalService.deleteResource(
1250 dlFolder.getCompanyId(), DLFolder.class.getName(),
1251 ResourceConstants.SCOPE_INDIVIDUAL, dlFolder.getFolderId());
1252
1253
1254
1255 webDAVPropsLocalService.deleteWebDAVProps(
1256 DLFolder.class.getName(), dlFolder.getFolderId());
1257
1258
1259
1260 dlFileEntryLocalService.deleteFileEntries(
1261 dlFolder.getGroupId(), dlFolder.getFolderId(),
1262 includeTrashedEntries);
1263
1264
1265
1266 List<Long> fileEntryTypeIds = new ArrayList<>();
1267
1268 for (DLFileEntryType dlFileEntryType :
1269 dlFileEntryTypeLocalService.getDLFolderDLFileEntryTypes(
1270 dlFolder.getFolderId())) {
1271
1272 fileEntryTypeIds.add(dlFileEntryType.getFileEntryTypeId());
1273 }
1274
1275 if (fileEntryTypeIds.isEmpty()) {
1276 fileEntryTypeIds.add(
1277 DLFileEntryTypeConstants.FILE_ENTRY_TYPE_ID_ALL);
1278 }
1279
1280 dlFileEntryTypeLocalService.unsetFolderFileEntryTypes(
1281 dlFolder.getFolderId());
1282
1283
1284
1285 dlFileShortcutLocalService.deleteFileShortcuts(
1286 dlFolder.getGroupId(), dlFolder.getFolderId(),
1287 includeTrashedEntries);
1288
1289
1290
1291 expandoRowLocalService.deleteRows(dlFolder.getFolderId());
1292
1293
1294
1295 ratingsStatsLocalService.deleteStats(
1296 DLFolder.class.getName(), dlFolder.getFolderId());
1297
1298
1299
1300 dlFolderPersistence.remove(dlFolder);
1301
1302
1303
1304 if (includeTrashedEntries) {
1305 DLStoreUtil.deleteDirectory(
1306 dlFolder.getCompanyId(), dlFolder.getFolderId(),
1307 StringPool.BLANK);
1308 }
1309
1310
1311
1312 for (long fileEntryTypeId : fileEntryTypeIds) {
1313 WorkflowDefinitionLink workflowDefinitionLink =
1314 workflowDefinitionLinkLocalService.fetchWorkflowDefinitionLink(
1315 dlFolder.getCompanyId(), dlFolder.getGroupId(),
1316 DLFolder.class.getName(), dlFolder.getFolderId(),
1317 fileEntryTypeId);
1318
1319 if (workflowDefinitionLink != null) {
1320 workflowDefinitionLinkLocalService.deleteWorkflowDefinitionLink(
1321 workflowDefinitionLink);
1322 }
1323 }
1324 }
1325
1326 protected void deleteSubfolders(
1327 DLFolder dlFolder, boolean includeTrashedEntries)
1328 throws PortalException {
1329
1330 RepositoryEventTrigger repositoryEventTrigger =
1331 RepositoryUtil.getRepositoryEventTrigger(
1332 dlFolder.getRepositoryId());
1333
1334 List<DLFolder> dlFolders = dlFolderPersistence.findByG_P(
1335 dlFolder.getGroupId(), dlFolder.getFolderId());
1336
1337 for (DLFolder curDLFolder : dlFolders) {
1338 if (includeTrashedEntries || !curDLFolder.isInTrashExplicitly()) {
1339 repositoryEventTrigger.trigger(
1340 RepositoryEventType.Delete.class, Folder.class,
1341 new LiferayFolder(curDLFolder));
1342
1343 dlFolderLocalService.deleteFolder(
1344 curDLFolder, includeTrashedEntries);
1345 }
1346 }
1347 }
1348
1349 protected Set<Long> getFileEntryTypeIds(
1350 List<DLFileEntryType> dlFileEntryTypes) {
1351
1352 Set<Long> fileEntryTypeIds = new HashSet<>();
1353
1354 for (DLFileEntryType dlFileEntryType : dlFileEntryTypes) {
1355 fileEntryTypeIds.add(dlFileEntryType.getFileEntryTypeId());
1356 }
1357
1358 return fileEntryTypeIds;
1359 }
1360
1361 protected long getParentFolderId(DLFolder dlFolder, long parentFolderId)
1362 throws PortalException {
1363
1364 parentFolderId = getParentFolderId(
1365 dlFolder.getGroupId(), dlFolder.getRepositoryId(), parentFolderId);
1366
1367 if (parentFolderId == DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
1368 return parentFolderId;
1369 }
1370
1371 if (dlFolder.getFolderId() == parentFolderId) {
1372 throw new InvalidFolderException(
1373 InvalidFolderException.CANNOT_MOVE_INTO_ITSELF, parentFolderId);
1374 }
1375
1376 List<Long> subfolderIds = new ArrayList<>();
1377
1378 getGroupSubfolderIds(
1379 subfolderIds, dlFolder.getGroupId(), dlFolder.getFolderId());
1380
1381 if (subfolderIds.contains(parentFolderId)) {
1382 throw new InvalidFolderException(
1383 InvalidFolderException.CANNOT_MOVE_INTO_CHILD_FOLDER,
1384 parentFolderId);
1385 }
1386
1387 return parentFolderId;
1388 }
1389
1390 protected long getParentFolderId(
1391 long groupId, long repositoryId, long parentFolderId)
1392 throws PortalException {
1393
1394 if (parentFolderId == DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
1395 return parentFolderId;
1396 }
1397
1398 DLFolder parentDLFolder = dlFolderPersistence.findByPrimaryKey(
1399 parentFolderId);
1400
1401 if (parentDLFolder.getGroupId() != groupId) {
1402 throw new NoSuchFolderException(
1403 String.format(
1404 "No folder exists with the primary key %s in group %s",
1405 parentFolderId, groupId));
1406 }
1407
1408 if ((parentDLFolder.getRepositoryId() != repositoryId) &&
1409 (parentDLFolder.getRepositoryId() != groupId)) {
1410
1411 Repository repository = repositoryLocalService.getRepository(
1412 repositoryId);
1413
1414 if (repository.getGroupId() != parentDLFolder.getGroupId()) {
1415 throw new NoSuchFolderException(
1416 String.format(
1417 "No folder exists with the primary key %s in " +
1418 "repository %s",
1419 parentFolderId, repositoryId));
1420 }
1421 }
1422
1423 return parentDLFolder.getFolderId();
1424 }
1425
1426 protected void validateFolder(
1427 long folderId, long groupId, long parentFolderId, String name)
1428 throws PortalException {
1429
1430 validateFolderName(name);
1431
1432 DLValidatorUtil.validateDirectoryName(name);
1433
1434 DLFileEntry dlFileEntry = dlFileEntryLocalService.fetchFileEntry(
1435 groupId, parentFolderId, name);
1436
1437 if (dlFileEntry != null) {
1438 throw new DuplicateFileEntryException(name);
1439 }
1440
1441 DLFolder dlFolder = dlFolderPersistence.fetchByG_P_N(
1442 groupId, parentFolderId, name);
1443
1444 if ((dlFolder != null) && (dlFolder.getFolderId() != folderId)) {
1445 throw new DuplicateFolderNameException(name);
1446 }
1447 }
1448
1449 protected void validateFolder(
1450 long groupId, long parentFolderId, String name)
1451 throws PortalException {
1452
1453 long folderId = 0;
1454
1455 validateFolder(folderId, groupId, parentFolderId, name);
1456 }
1457
1458 protected void validateFolderName(String folderName)
1459 throws PortalException {
1460
1461 if (folderName.contains(StringPool.SLASH)) {
1462 throw new FolderNameException(folderName);
1463 }
1464 }
1465
1466 private static final Log _log = LogFactoryUtil.getLog(
1467 DLFolderLocalServiceImpl.class);
1468
1469 }