001
014
015 package com.liferay.portlet.documentlibrary.service.impl;
016
017 import com.liferay.portal.NoSuchGroupException;
018 import com.liferay.portal.kernel.bean.BeanReference;
019 import com.liferay.portal.kernel.dao.orm.QueryUtil;
020 import com.liferay.portal.kernel.exception.PortalException;
021 import com.liferay.portal.kernel.exception.SystemException;
022 import com.liferay.portal.kernel.io.unsync.UnsyncByteArrayInputStream;
023 import com.liferay.portal.kernel.lock.Lock;
024 import com.liferay.portal.kernel.lock.LockManagerUtil;
025 import com.liferay.portal.kernel.log.Log;
026 import com.liferay.portal.kernel.log.LogFactoryUtil;
027 import com.liferay.portal.kernel.repository.InvalidRepositoryIdException;
028 import com.liferay.portal.kernel.repository.Repository;
029 import com.liferay.portal.kernel.repository.RepositoryException;
030 import com.liferay.portal.kernel.repository.RepositoryProvider;
031 import com.liferay.portal.kernel.repository.capabilities.TrashCapability;
032 import com.liferay.portal.kernel.repository.model.FileEntry;
033 import com.liferay.portal.kernel.repository.model.FileShortcut;
034 import com.liferay.portal.kernel.repository.model.FileVersion;
035 import com.liferay.portal.kernel.repository.model.Folder;
036 import com.liferay.portal.kernel.repository.model.RepositoryEntry;
037 import com.liferay.portal.kernel.search.Hits;
038 import com.liferay.portal.kernel.search.Query;
039 import com.liferay.portal.kernel.search.SearchContext;
040 import com.liferay.portal.kernel.search.SearchException;
041 import com.liferay.portal.kernel.transaction.TransactionCommitCallbackUtil;
042 import com.liferay.portal.kernel.util.ArrayUtil;
043 import com.liferay.portal.kernel.util.ContentTypes;
044 import com.liferay.portal.kernel.util.FileUtil;
045 import com.liferay.portal.kernel.util.GetterUtil;
046 import com.liferay.portal.kernel.util.MimeTypesUtil;
047 import com.liferay.portal.kernel.util.OrderByComparator;
048 import com.liferay.portal.kernel.util.StringBundler;
049 import com.liferay.portal.kernel.util.StringPool;
050 import com.liferay.portal.kernel.util.TempFileEntryUtil;
051 import com.liferay.portal.kernel.util.Validator;
052 import com.liferay.portal.kernel.workflow.WorkflowConstants;
053 import com.liferay.portal.security.permission.ActionKeys;
054 import com.liferay.portal.service.ServiceContext;
055 import com.liferay.portlet.documentlibrary.NoSuchFileEntryException;
056 import com.liferay.portlet.documentlibrary.model.DLFolderConstants;
057 import com.liferay.portlet.documentlibrary.service.base.DLAppServiceBaseImpl;
058 import com.liferay.portlet.documentlibrary.service.permission.DLFileEntryPermission;
059 import com.liferay.portlet.documentlibrary.service.permission.DLFileShortcutPermission;
060 import com.liferay.portlet.documentlibrary.service.permission.DLFolderPermission;
061 import com.liferay.portlet.documentlibrary.service.permission.DLPermission;
062 import com.liferay.portlet.documentlibrary.util.DLAppUtil;
063 import com.liferay.portlet.documentlibrary.util.DLProcessorRegistryUtil;
064 import com.liferay.portlet.documentlibrary.util.comparator.FolderNameComparator;
065 import com.liferay.portlet.documentlibrary.util.comparator.RepositoryModelModifiedDateComparator;
066 import com.liferay.portlet.documentlibrary.util.comparator.RepositoryModelTitleComparator;
067
068 import java.io.File;
069 import java.io.IOException;
070 import java.io.InputStream;
071
072 import java.util.ArrayList;
073 import java.util.LinkedList;
074 import java.util.List;
075 import java.util.Queue;
076 import java.util.concurrent.Callable;
077
078
107 public class DLAppServiceImpl extends DLAppServiceBaseImpl {
108
109
139 @Override
140 public FileEntry addFileEntry(
141 long repositoryId, long folderId, String sourceFileName,
142 String mimeType, String title, String description, String changeLog,
143 byte[] bytes, ServiceContext serviceContext)
144 throws PortalException {
145
146 File file = null;
147
148 try {
149 if (ArrayUtil.isNotEmpty(bytes)) {
150 file = FileUtil.createTempFile(bytes);
151 }
152
153 return addFileEntry(
154 repositoryId, folderId, sourceFileName, mimeType, title,
155 description, changeLog, file, serviceContext);
156 }
157 catch (IOException ioe) {
158 throw new SystemException("Unable to write temporary file", ioe);
159 }
160 finally {
161 FileUtil.delete(file);
162 }
163 }
164
165
195 @Override
196 public FileEntry addFileEntry(
197 long repositoryId, long folderId, String sourceFileName,
198 String mimeType, String title, String description, String changeLog,
199 File file, ServiceContext serviceContext)
200 throws PortalException {
201
202 if ((file == null) || !file.exists() || (file.length() == 0)) {
203 return addFileEntry(
204 repositoryId, folderId, sourceFileName, mimeType, title,
205 description, changeLog, null, 0, serviceContext);
206 }
207
208 mimeType = DLAppUtil.getMimeType(sourceFileName, mimeType, title, file);
209
210 Repository repository = getRepository(repositoryId);
211
212 FileEntry fileEntry = repository.addFileEntry(
213 getUserId(), folderId, sourceFileName, mimeType, title, description,
214 changeLog, file, serviceContext);
215
216 return fileEntry;
217 }
218
219
250 @Override
251 public FileEntry addFileEntry(
252 long repositoryId, long folderId, String sourceFileName,
253 String mimeType, String title, String description, String changeLog,
254 InputStream is, long size, ServiceContext serviceContext)
255 throws PortalException {
256
257 if (is == null) {
258 is = new UnsyncByteArrayInputStream(new byte[0]);
259 size = 0;
260 }
261
262 if (Validator.isNull(mimeType) ||
263 mimeType.equals(ContentTypes.APPLICATION_OCTET_STREAM)) {
264
265 String extension = DLAppUtil.getExtension(title, sourceFileName);
266
267 if (size == 0) {
268 mimeType = MimeTypesUtil.getExtensionContentType(extension);
269 }
270 else {
271 File file = null;
272
273 try {
274 file = FileUtil.createTempFile(is);
275
276 return addFileEntry(
277 repositoryId, folderId, sourceFileName, mimeType, title,
278 description, changeLog, file, serviceContext);
279 }
280 catch (IOException ioe) {
281 throw new SystemException(
282 "Unable to write temporary file", ioe);
283 }
284 finally {
285 FileUtil.delete(file);
286 }
287 }
288 }
289
290 Repository repository = getRepository(repositoryId);
291
292 FileEntry fileEntry = repository.addFileEntry(
293 getUserId(), folderId, sourceFileName, mimeType, title, description,
294 changeLog, is, size, serviceContext);
295
296 return fileEntry;
297 }
298
299
311 @Override
312 public FileShortcut addFileShortcut(
313 long repositoryId, long folderId, long toFileEntryId,
314 ServiceContext serviceContext)
315 throws PortalException {
316
317 Repository repository = getRepository(repositoryId);
318
319 return repository.addFileShortcut(
320 getUserId(), folderId, toFileEntryId, serviceContext);
321 }
322
323
335 @Override
336 public Folder addFolder(
337 long repositoryId, long parentFolderId, String name,
338 String description, ServiceContext serviceContext)
339 throws PortalException {
340
341 Repository repository = getRepository(repositoryId);
342
343 Folder folder = repository.addFolder(
344 getUserId(), parentFolderId, name, description, serviceContext);
345
346 dlAppHelperLocalService.addFolder(getUserId(), folder, serviceContext);
347
348 return folder;
349 }
350
351
370 @Override
371 public FileEntry addTempFileEntry(
372 long groupId, long folderId, String folderName, String fileName,
373 File file, String mimeType)
374 throws PortalException {
375
376 DLFolderPermission.check(
377 getPermissionChecker(), groupId, folderId, ActionKeys.ADD_DOCUMENT);
378
379 return TempFileEntryUtil.addTempFileEntry(
380 groupId, getUserId(), folderName, fileName, file, mimeType);
381 }
382
383
403 @Override
404 public FileEntry addTempFileEntry(
405 long groupId, long folderId, String folderName, String fileName,
406 InputStream inputStream, String mimeType)
407 throws PortalException {
408
409 DLFolderPermission.check(
410 getPermissionChecker(), groupId, folderId, ActionKeys.ADD_DOCUMENT);
411
412 return TempFileEntryUtil.addTempFileEntry(
413 groupId, getUserId(), folderName, fileName, inputStream, mimeType);
414 }
415
416
436 @Override
437 public void cancelCheckOut(long fileEntryId) throws PortalException {
438 Repository repository = repositoryProvider.getFileEntryRepository(
439 fileEntryId);
440
441 FileEntry fileEntry = repository.getFileEntry(fileEntryId);
442
443 FileVersion draftFileVersion = repository.cancelCheckOut(fileEntryId);
444
445 ServiceContext serviceContext = new ServiceContext();
446
447 serviceContext.setWorkflowAction(WorkflowConstants.ACTION_PUBLISH);
448
449 dlAppHelperLocalService.cancelCheckOut(
450 getUserId(), fileEntry, null, fileEntry.getFileVersion(),
451 draftFileVersion, serviceContext);
452 }
453
454
476 @Override
477 public void checkInFileEntry(
478 long fileEntryId, boolean majorVersion, String changeLog,
479 ServiceContext serviceContext)
480 throws PortalException {
481
482 Repository repository = repositoryProvider.getFileEntryRepository(
483 fileEntryId);
484
485 repository.checkInFileEntry(
486 getUserId(), fileEntryId, majorVersion, changeLog, serviceContext);
487
488 FileEntry fileEntry = getFileEntry(fileEntryId);
489
490 FileVersion fileVersion = fileEntry.getLatestFileVersion();
491
492 dlAppHelperLocalService.updateFileEntry(
493 getUserId(), fileEntry, null, fileVersion,
494 fileVersion.getFileVersionId());
495 }
496
497
501 @Deprecated
502 @Override
503 public void checkInFileEntry(long fileEntryId, String lockUuid)
504 throws PortalException {
505
506 checkInFileEntry(fileEntryId, lockUuid, new ServiceContext());
507 }
508
509
531 @Override
532 public void checkInFileEntry(
533 long fileEntryId, String lockUuid, ServiceContext serviceContext)
534 throws PortalException {
535
536 Repository repository = repositoryProvider.getFileEntryRepository(
537 fileEntryId);
538
539 repository.checkInFileEntry(
540 getUserId(), fileEntryId, lockUuid, serviceContext);
541
542 FileEntry fileEntry = getFileEntry(fileEntryId);
543
544 FileVersion fileVersion = fileEntry.getLatestFileVersion();
545
546 dlAppHelperLocalService.updateFileEntry(
547 getUserId(), fileEntry, null, fileVersion,
548 fileVersion.getFileVersionId());
549 }
550
551
570 @Override
571 public void checkOutFileEntry(
572 long fileEntryId, ServiceContext serviceContext)
573 throws PortalException {
574
575 Repository repository = repositoryProvider.getFileEntryRepository(
576 fileEntryId);
577
578 FileEntry fileEntry = repository.checkOutFileEntry(
579 fileEntryId, serviceContext);
580
581 FileVersion fileVersion = fileEntry.getLatestFileVersion();
582
583 dlAppHelperLocalService.updateFileEntry(
584 getUserId(), fileEntry, null, fileVersion, fileEntryId);
585 }
586
587
612 @Override
613 public FileEntry checkOutFileEntry(
614 long fileEntryId, String owner, long expirationTime,
615 ServiceContext serviceContext)
616 throws PortalException {
617
618 Repository repository = repositoryProvider.getFileEntryRepository(
619 fileEntryId);
620
621 FileEntry fileEntry = repository.checkOutFileEntry(
622 fileEntryId, owner, expirationTime, serviceContext);
623
624 FileVersion fileVersion = fileEntry.getLatestFileVersion();
625
626 dlAppHelperLocalService.updateFileEntry(
627 getUserId(), fileEntry, null, fileVersion, fileEntryId);
628
629 return fileEntry;
630 }
631
632
643 @Override
644 public Folder copyFolder(
645 long repositoryId, long sourceFolderId, long parentFolderId,
646 String name, String description, ServiceContext serviceContext)
647 throws PortalException {
648
649 Repository repository = getRepository(repositoryId);
650
651 Folder srcFolder = repository.getFolder(sourceFolderId);
652
653 Folder destFolder = repository.addFolder(
654 getUserId(), parentFolderId, name, description, serviceContext);
655
656 dlAppHelperLocalService.addFolder(
657 getUserId(), destFolder, serviceContext);
658
659 copyFolder(repository, srcFolder, destFolder, serviceContext);
660
661 return destFolder;
662 }
663
664
669 @Override
670 public void deleteFileEntry(long fileEntryId) throws PortalException {
671 Repository repository = repositoryProvider.getFileEntryRepository(
672 fileEntryId);
673
674 FileEntry fileEntry = repository.getFileEntry(fileEntryId);
675
676 dlAppHelperLocalService.deleteFileEntry(fileEntry);
677
678 repository.deleteFileEntry(fileEntryId);
679 }
680
681
688 @Override
689 public void deleteFileEntryByTitle(
690 long repositoryId, long folderId, String title)
691 throws PortalException {
692
693 Repository repository = getRepository(repositoryId);
694
695 FileEntry fileEntry = repository.getFileEntry(folderId, title);
696
697 dlAppHelperLocalService.deleteFileEntry(fileEntry);
698
699 repository.deleteFileEntry(folderId, title);
700 }
701
702
708 @Override
709 public void deleteFileShortcut(long fileShortcutId) throws PortalException {
710 Repository repository = repositoryProvider.getFileShortcutRepository(
711 fileShortcutId);
712
713 repository.deleteFileShortcut(fileShortcutId);
714 }
715
716
724 @Override
725 public void deleteFileVersion(long fileEntryId, String version)
726 throws PortalException {
727
728 Repository repository = repositoryProvider.getFileEntryRepository(
729 fileEntryId);
730
731 repository.deleteFileVersion(fileEntryId, version);
732 }
733
734
740 @Override
741 public void deleteFolder(long folderId) throws PortalException {
742 Repository repository = repositoryProvider.getFolderRepository(
743 folderId);
744
745 Folder folder = repository.getFolder(folderId);
746
747 if (repository.isCapabilityProvided(TrashCapability.class)) {
748 TrashCapability trashCapability = repository.getCapability(
749 TrashCapability.class);
750
751 if (trashCapability.isInTrash(folder)) {
752 trashEntryService.deleteEntry(
753 DLFolderConstants.getClassName(), folder.getFolderId());
754
755 return;
756 }
757 }
758
759 List<FileEntry> fileEntries = repository.getRepositoryFileEntries(
760 0, folderId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
761
762 for (FileEntry fileEntry : fileEntries) {
763 dlAppHelperLocalService.deleteFileEntry(fileEntry);
764 }
765
766 repository.deleteFolder(folderId);
767
768 dlAppHelperLocalService.deleteFolder(folder);
769 }
770
771
779 @Override
780 public void deleteFolder(
781 long repositoryId, long parentFolderId, String name)
782 throws PortalException {
783
784 Repository repository = getRepository(repositoryId);
785
786 Folder folder = repository.getFolder(parentFolderId, name);
787
788 if (repository.isCapabilityProvided(TrashCapability.class)) {
789 TrashCapability trashCapability = repository.getCapability(
790 TrashCapability.class);
791
792 if (trashCapability.isInTrash(folder)) {
793 trashEntryService.deleteEntry(
794 DLFolderConstants.getClassName(), folder.getFolderId());
795
796 return;
797 }
798 }
799
800 repository.deleteFolder(parentFolderId, name);
801 }
802
803
813 @Override
814 public void deleteTempFileEntry(
815 long groupId, long folderId, String folderName, String fileName)
816 throws PortalException {
817
818 DLFolderPermission.check(
819 getPermissionChecker(), groupId, folderId, ActionKeys.ADD_DOCUMENT);
820
821 TempFileEntryUtil.deleteTempFileEntry(
822 groupId, getUserId(), folderName, fileName);
823 }
824
825
832 @Override
833 public List<FileEntry> getFileEntries(long repositoryId, long folderId)
834 throws PortalException {
835
836 return getFileEntries(
837 repositoryId, folderId, QueryUtil.ALL_POS, QueryUtil.ALL_POS);
838 }
839
840
858 @Override
859 public List<FileEntry> getFileEntries(
860 long repositoryId, long folderId, int start, int end)
861 throws PortalException {
862
863 return getFileEntries(
864 repositoryId, folderId, start, end,
865 new RepositoryModelTitleComparator<FileEntry>(true));
866 }
867
868
889 @Override
890 public List<FileEntry> getFileEntries(
891 long repositoryId, long folderId, int start, int end,
892 OrderByComparator<FileEntry> obc)
893 throws PortalException {
894
895 Repository repository = getRepository(repositoryId);
896
897 return repository.getFileEntries(folderId, start, end, obc);
898 }
899
900
908 @Override
909 public List<FileEntry> getFileEntries(
910 long repositoryId, long folderId, long fileEntryTypeId)
911 throws PortalException {
912
913 return getFileEntries(
914 repositoryId, folderId, fileEntryTypeId, QueryUtil.ALL_POS,
915 QueryUtil.ALL_POS);
916 }
917
918
929 @Override
930 public List<FileEntry> getFileEntries(
931 long repositoryId, long folderId, long fileEntryTypeId, int start,
932 int end)
933 throws PortalException {
934
935 return getFileEntries(
936 repositoryId, folderId, fileEntryTypeId, start, end,
937 new RepositoryModelTitleComparator<FileEntry>(true));
938 }
939
940
954 @Override
955 public List<FileEntry> getFileEntries(
956 long repositoryId, long folderId, long fileEntryTypeId, int start,
957 int end, OrderByComparator<FileEntry> obc)
958 throws PortalException {
959
960 Repository repository = getRepository(repositoryId);
961
962 return repository.getFileEntries(
963 folderId, fileEntryTypeId, start, end, obc);
964 }
965
966 @Override
967 public List<FileEntry> getFileEntries(
968 long repositoryId, long folderId, String[] mimeTypes)
969 throws PortalException {
970
971 return getFileEntries(
972 repositoryId, folderId, mimeTypes, QueryUtil.ALL_POS,
973 QueryUtil.ALL_POS,
974 new RepositoryModelTitleComparator<FileEntry>(true));
975 }
976
977 @Override
978 public List<FileEntry> getFileEntries(
979 long repositoryId, long folderId, String[] mimeTypes, int start,
980 int end, OrderByComparator<FileEntry> obc)
981 throws PortalException {
982
983 Repository repository = getRepository(repositoryId);
984
985 return repository.getFileEntries(folderId, mimeTypes, start, end, obc);
986 }
987
988
1007 @Override
1008 @SuppressWarnings("rawtypes")
1009 public List<Object> getFileEntriesAndFileShortcuts(
1010 long repositoryId, long folderId, int status, int start, int end)
1011 throws PortalException {
1012
1013 Repository repository = getRepository(repositoryId);
1014
1015 return (List)repository.getFileEntriesAndFileShortcuts(
1016 folderId, status, start, end);
1017 }
1018
1019
1027 @Override
1028 public int getFileEntriesAndFileShortcutsCount(
1029 long repositoryId, long folderId, int status)
1030 throws PortalException {
1031
1032 Repository repository = getRepository(repositoryId);
1033
1034 return repository.getFileEntriesAndFileShortcutsCount(folderId, status);
1035 }
1036
1037
1046 @Override
1047 public int getFileEntriesAndFileShortcutsCount(
1048 long repositoryId, long folderId, int status, String[] mimeTypes)
1049 throws PortalException {
1050
1051 Repository repository = getRepository(repositoryId);
1052
1053 return repository.getFileEntriesAndFileShortcutsCount(
1054 folderId, status, mimeTypes);
1055 }
1056
1057
1064 @Override
1065 public int getFileEntriesCount(long repositoryId, long folderId)
1066 throws PortalException {
1067
1068 Repository repository = getRepository(repositoryId);
1069
1070 return repository.getFileEntriesCount(folderId);
1071 }
1072
1073
1082 @Override
1083 public int getFileEntriesCount(
1084 long repositoryId, long folderId, long fileEntryTypeId)
1085 throws PortalException {
1086
1087 Repository repository = getRepository(repositoryId);
1088
1089 return repository.getFileEntriesCount(folderId, fileEntryTypeId);
1090 }
1091
1092 @Override
1093 public int getFileEntriesCount(
1094 long repositoryId, long folderId, String[] mimeTypes)
1095 throws PortalException {
1096
1097 Repository repository = getRepository(repositoryId);
1098
1099 return repository.getFileEntriesCount(folderId, mimeTypes);
1100 }
1101
1102
1108 @Override
1109 public FileEntry getFileEntry(long fileEntryId) throws PortalException {
1110 Repository repository = repositoryProvider.getFileEntryRepository(
1111 fileEntryId);
1112
1113 return repository.getFileEntry(fileEntryId);
1114 }
1115
1116
1124 @Override
1125 public FileEntry getFileEntry(long groupId, long folderId, String title)
1126 throws PortalException {
1127
1128 try {
1129 Repository repository = getRepository(groupId);
1130
1131 return repository.getFileEntry(folderId, title);
1132 }
1133 catch (NoSuchFileEntryException nsfee) {
1134 if (folderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
1135 Repository repository = repositoryProvider.getFolderRepository(
1136 folderId);
1137
1138 return repository.getFileEntry(folderId, title);
1139 }
1140 else {
1141 throw nsfee;
1142 }
1143 }
1144 }
1145
1146
1153 @Override
1154 public FileEntry getFileEntryByUuidAndGroupId(String uuid, long groupId)
1155 throws PortalException {
1156
1157 FileEntry fileEntry = fetchFileEntryByUuidAndRepositoryId(
1158 uuid, groupId);
1159
1160 if (fileEntry != null) {
1161 return fileEntry;
1162 }
1163
1164 List<com.liferay.portal.model.Repository> repositories =
1165 repositoryPersistence.findByGroupId(groupId);
1166
1167 for (com.liferay.portal.model.Repository repository : repositories) {
1168 fileEntry = fetchFileEntryByUuidAndRepositoryId(
1169 uuid, repository.getRepositoryId());
1170
1171 if (fileEntry != null) {
1172 return fileEntry;
1173 }
1174 }
1175
1176 StringBundler msg = new StringBundler(6);
1177
1178 msg.append("No DLFileEntry exists with the key {");
1179 msg.append("uuid=");
1180 msg.append(uuid);
1181 msg.append(", groupId=");
1182 msg.append(groupId);
1183 msg.append(StringPool.CLOSE_CURLY_BRACE);
1184
1185 throw new NoSuchFileEntryException(msg.toString());
1186 }
1187
1188
1195 @Override
1196 public FileShortcut getFileShortcut(long fileShortcutId)
1197 throws PortalException {
1198
1199 Repository repository = repositoryProvider.getFileShortcutRepository(
1200 fileShortcutId);
1201
1202 return repository.getFileShortcut(fileShortcutId);
1203 }
1204
1205
1211 @Override
1212 public FileVersion getFileVersion(long fileVersionId)
1213 throws PortalException {
1214
1215 Repository repository = repositoryProvider.getFileVersionRepository(
1216 fileVersionId);
1217
1218 return repository.getFileVersion(fileVersionId);
1219 }
1220
1221
1227 @Override
1228 public Folder getFolder(long folderId) throws PortalException {
1229 Repository repository = repositoryProvider.getFolderRepository(
1230 folderId);
1231
1232 return repository.getFolder(folderId);
1233 }
1234
1235
1243 @Override
1244 public Folder getFolder(long repositoryId, long parentFolderId, String name)
1245 throws PortalException {
1246
1247 Repository repository = getRepository(repositoryId);
1248
1249 return repository.getFolder(parentFolderId, name);
1250 }
1251
1252
1259 @Override
1260 public List<Folder> getFolders(long repositoryId, long parentFolderId)
1261 throws PortalException {
1262
1263 return getFolders(
1264 repositoryId, parentFolderId, QueryUtil.ALL_POS, QueryUtil.ALL_POS);
1265 }
1266
1267
1277 @Override
1278 public List<Folder> getFolders(
1279 long repositoryId, long parentFolderId, boolean includeMountFolders)
1280 throws PortalException {
1281
1282 return getFolders(
1283 repositoryId, parentFolderId, includeMountFolders,
1284 QueryUtil.ALL_POS, QueryUtil.ALL_POS);
1285 }
1286
1287
1310 @Override
1311 public List<Folder> getFolders(
1312 long repositoryId, long parentFolderId, boolean includeMountFolders,
1313 int start, int end)
1314 throws PortalException {
1315
1316 return getFolders(
1317 repositoryId, parentFolderId, includeMountFolders, start, end,
1318 new FolderNameComparator(true));
1319 }
1320
1321
1345 @Override
1346 public List<Folder> getFolders(
1347 long repositoryId, long parentFolderId, boolean includeMountFolders,
1348 int start, int end, OrderByComparator<Folder> obc)
1349 throws PortalException {
1350
1351 Repository repository = getRepository(repositoryId);
1352
1353 return repository.getFolders(
1354 parentFolderId, includeMountFolders, start, end, obc);
1355 }
1356
1357
1382 @Override
1383 public List<Folder> getFolders(
1384 long repositoryId, long parentFolderId, int status,
1385 boolean includeMountFolders, int start, int end,
1386 OrderByComparator<Folder> obc)
1387 throws PortalException {
1388
1389 Repository repository = getRepository(repositoryId);
1390
1391 return repository.getFolders(
1392 parentFolderId, status, includeMountFolders, start, end, obc);
1393 }
1394
1395
1415 @Override
1416 public List<Folder> getFolders(
1417 long repositoryId, long parentFolderId, int start, int end)
1418 throws PortalException {
1419
1420 return getFolders(
1421 repositoryId, parentFolderId, start, end,
1422 new FolderNameComparator(true));
1423 }
1424
1425
1447 @Override
1448 public List<Folder> getFolders(
1449 long repositoryId, long parentFolderId, int start, int end,
1450 OrderByComparator<Folder> obc)
1451 throws PortalException {
1452
1453 Repository repository = getRepository(repositoryId);
1454
1455 return repository.getFolders(parentFolderId, true, start, end, obc);
1456 }
1457
1458
1481 @Override
1482 public List<Object> getFoldersAndFileEntriesAndFileShortcuts(
1483 long repositoryId, long folderId, int status,
1484 boolean includeMountFolders, int start, int end)
1485 throws PortalException {
1486
1487 return getFoldersAndFileEntriesAndFileShortcuts(
1488 repositoryId, folderId, status, includeMountFolders, start, end,
1489 new RepositoryModelTitleComparator<Object>(true));
1490 }
1491
1492
1518 @Override
1519 public List<Object> getFoldersAndFileEntriesAndFileShortcuts(
1520 long repositoryId, long folderId, int status,
1521 boolean includeMountFolders, int start, int end,
1522 OrderByComparator<?> obc)
1523 throws PortalException {
1524
1525 return getFoldersAndFileEntriesAndFileShortcuts(
1526 repositoryId, folderId, status, null, includeMountFolders, start,
1527 end, obc);
1528 }
1529
1530 @Override
1531 @SuppressWarnings("rawtypes")
1532 public List<Object> getFoldersAndFileEntriesAndFileShortcuts(
1533 long repositoryId, long folderId, int status, String[] mimeTypes,
1534 boolean includeMountFolders, int start, int end,
1535 OrderByComparator<?> obc)
1536 throws PortalException {
1537
1538 Repository repository = getRepository(repositoryId);
1539
1540 return (List)repository.getFoldersAndFileEntriesAndFileShortcuts(
1541 folderId, status, mimeTypes, includeMountFolders, start, end, obc);
1542 }
1543
1544
1556 @Override
1557 public int getFoldersAndFileEntriesAndFileShortcutsCount(
1558 long repositoryId, long folderId, int status,
1559 boolean includeMountFolders)
1560 throws PortalException {
1561
1562 return getFoldersAndFileEntriesAndFileShortcutsCount(
1563 repositoryId, folderId, status, null, includeMountFolders);
1564 }
1565
1566 @Override
1567 public int getFoldersAndFileEntriesAndFileShortcutsCount(
1568 long repositoryId, long folderId, int status, String[] mimeTypes,
1569 boolean includeMountFolders)
1570 throws PortalException {
1571
1572 Repository repository = getRepository(repositoryId);
1573
1574 return repository.getFoldersAndFileEntriesAndFileShortcutsCount(
1575 folderId, status, mimeTypes, includeMountFolders);
1576 }
1577
1578
1585 @Override
1586 public int getFoldersCount(long repositoryId, long parentFolderId)
1587 throws PortalException {
1588
1589 return getFoldersCount(repositoryId, parentFolderId, true);
1590 }
1591
1592
1602 @Override
1603 public int getFoldersCount(
1604 long repositoryId, long parentFolderId, boolean includeMountFolders)
1605 throws PortalException {
1606
1607 Repository repository = getRepository(repositoryId);
1608
1609 return repository.getFoldersCount(parentFolderId, includeMountFolders);
1610 }
1611
1612
1623 @Override
1624 public int getFoldersCount(
1625 long repositoryId, long parentFolderId, int status,
1626 boolean includeMountFolders)
1627 throws PortalException {
1628
1629 Repository repository = getRepository(repositoryId);
1630
1631 return repository.getFoldersCount(
1632 parentFolderId, status, includeMountFolders);
1633 }
1634
1635
1646 @Override
1647 public int getFoldersFileEntriesCount(
1648 long repositoryId, List<Long> folderIds, int status)
1649 throws PortalException {
1650
1651 Repository repository = getRepository(repositoryId);
1652
1653 return repository.getFoldersFileEntriesCount(folderIds, status);
1654 }
1655
1656
1679 @Override
1680 public List<FileEntry> getGroupFileEntries(
1681 long groupId, long userId, int start, int end)
1682 throws PortalException {
1683
1684 return getGroupFileEntries(
1685 groupId, userId, DLFolderConstants.DEFAULT_PARENT_FOLDER_ID, start,
1686 end, new RepositoryModelModifiedDateComparator<FileEntry>());
1687 }
1688
1689
1714 @Override
1715 public List<FileEntry> getGroupFileEntries(
1716 long groupId, long userId, int start, int end,
1717 OrderByComparator<FileEntry> obc)
1718 throws PortalException {
1719
1720 return getGroupFileEntries(
1721 groupId, userId, DLFolderConstants.DEFAULT_PARENT_FOLDER_ID, start,
1722 end, obc);
1723 }
1724
1725
1749 @Override
1750 public List<FileEntry> getGroupFileEntries(
1751 long groupId, long userId, long rootFolderId, int start, int end)
1752 throws PortalException {
1753
1754 return getGroupFileEntries(
1755 groupId, userId, rootFolderId, start, end,
1756 new RepositoryModelModifiedDateComparator<FileEntry>());
1757 }
1758
1759
1786 @Override
1787 public List<FileEntry> getGroupFileEntries(
1788 long groupId, long userId, long rootFolderId, int start, int end,
1789 OrderByComparator<FileEntry> obc)
1790 throws PortalException {
1791
1792 Repository repository = getRepository(groupId);
1793
1794 return repository.getRepositoryFileEntries(
1795 userId, rootFolderId, start, end, obc);
1796 }
1797
1798 @Override
1799 public List<FileEntry> getGroupFileEntries(
1800 long groupId, long userId, long rootFolderId, String[] mimeTypes,
1801 int status, int start, int end, OrderByComparator<FileEntry> obc)
1802 throws PortalException {
1803
1804 Repository repository = getRepository(groupId);
1805
1806 return repository.getRepositoryFileEntries(
1807 userId, rootFolderId, mimeTypes, status, start, end, obc);
1808 }
1809
1810
1821 @Override
1822 public int getGroupFileEntriesCount(long groupId, long userId)
1823 throws PortalException {
1824
1825 return getGroupFileEntriesCount(
1826 groupId, userId, DLFolderConstants.DEFAULT_PARENT_FOLDER_ID);
1827 }
1828
1829
1842 @Override
1843 public int getGroupFileEntriesCount(
1844 long groupId, long userId, long rootFolderId)
1845 throws PortalException {
1846
1847 Repository repository = getRepository(groupId);
1848
1849 return repository.getRepositoryFileEntriesCount(userId, rootFolderId);
1850 }
1851
1852 @Override
1853 public int getGroupFileEntriesCount(
1854 long groupId, long userId, long rootFolderId, String[] mimeTypes,
1855 int status)
1856 throws PortalException {
1857
1858 Repository repository = getRepository(groupId);
1859
1860 return repository.getRepositoryFileEntriesCount(
1861 userId, rootFolderId, mimeTypes, status);
1862 }
1863
1864
1874 @Override
1875 public List<Folder> getMountFolders(long repositoryId, long parentFolderId)
1876 throws PortalException {
1877
1878 return getMountFolders(
1879 repositoryId, parentFolderId, QueryUtil.ALL_POS, QueryUtil.ALL_POS);
1880 }
1881
1882
1903 @Override
1904 public List<Folder> getMountFolders(
1905 long repositoryId, long parentFolderId, int start, int end)
1906 throws PortalException {
1907
1908 return getMountFolders(
1909 repositoryId, parentFolderId, start, end,
1910 new FolderNameComparator(true));
1911 }
1912
1913
1937 @Override
1938 public List<Folder> getMountFolders(
1939 long repositoryId, long parentFolderId, int start, int end,
1940 OrderByComparator<Folder> obc)
1941 throws PortalException {
1942
1943 Repository repository = getRepository(repositoryId);
1944
1945 return repository.getMountFolders(parentFolderId, start, end, obc);
1946 }
1947
1948
1958 @Override
1959 public int getMountFoldersCount(long repositoryId, long parentFolderId)
1960 throws PortalException {
1961
1962 Repository repository = getRepository(repositoryId);
1963
1964 return repository.getMountFoldersCount(parentFolderId);
1965 }
1966
1967 @Override
1968 public void getSubfolderIds(
1969 long repositoryId, List<Long> folderIds, long folderId)
1970 throws PortalException {
1971
1972 Repository repository = getRepository(repositoryId);
1973
1974 repository.getSubfolderIds(folderIds, folderId);
1975 }
1976
1977
1984 @Override
1985 public List<Long> getSubfolderIds(long repositoryId, long folderId)
1986 throws PortalException {
1987
1988 return getSubfolderIds(repositoryId, folderId, true);
1989 }
1990
1991
2000 @Override
2001 public List<Long> getSubfolderIds(
2002 long repositoryId, long folderId, boolean recurse)
2003 throws PortalException {
2004
2005 Repository repository = getRepository(repositoryId);
2006
2007 return repository.getSubfolderIds(folderId, recurse);
2008 }
2009
2010
2021 @Override
2022 public String[] getTempFileNames(
2023 long groupId, long folderId, String folderName)
2024 throws PortalException {
2025
2026 DLFolderPermission.check(
2027 getPermissionChecker(), groupId, folderId, ActionKeys.ADD_DOCUMENT);
2028
2029 return TempFileEntryUtil.getTempFileNames(
2030 groupId, getUserId(), folderName);
2031 }
2032
2033
2040 @Override
2041 public Lock lockFolder(long repositoryId, long folderId)
2042 throws PortalException {
2043
2044 Repository repository = getRepository(repositoryId);
2045
2046 return repository.lockFolder(folderId);
2047 }
2048
2049
2062 @Override
2063 public Lock lockFolder(
2064 long repositoryId, long folderId, String owner, boolean inheritable,
2065 long expirationTime)
2066 throws PortalException {
2067
2068 Repository repository = getRepository(repositoryId);
2069
2070 return repository.lockFolder(
2071 folderId, owner, inheritable, expirationTime);
2072 }
2073
2074
2082 @Override
2083 public FileEntry moveFileEntry(
2084 long fileEntryId, long newFolderId, ServiceContext serviceContext)
2085 throws PortalException {
2086
2087 Repository fromRepository = repositoryProvider.getFileEntryRepository(
2088 fileEntryId);
2089 Repository toRepository = getFolderRepository(
2090 newFolderId, serviceContext.getScopeGroupId());
2091
2092 if (newFolderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
2093 Folder toFolder = toRepository.getFolder(newFolderId);
2094
2095 if (toFolder.isMountPoint()) {
2096 toRepository = getRepository(toFolder.getRepositoryId());
2097 }
2098 }
2099
2100 if (fromRepository.getRepositoryId() ==
2101 toRepository.getRepositoryId()) {
2102
2103
2104
2105 return fromRepository.moveFileEntry(
2106 getUserId(), fileEntryId, newFolderId, serviceContext);
2107 }
2108
2109
2110
2111 return moveFileEntries(
2112 fileEntryId, newFolderId, fromRepository, toRepository,
2113 serviceContext);
2114 }
2115
2116
2124 @Override
2125 public FileEntry moveFileEntryFromTrash(
2126 long fileEntryId, long newFolderId, ServiceContext serviceContext)
2127 throws PortalException {
2128
2129 Repository repository = repositoryProvider.getFileEntryRepository(
2130 fileEntryId);
2131
2132 TrashCapability trashCapability = repository.getCapability(
2133 TrashCapability.class);
2134
2135 FileEntry fileEntry = repository.getFileEntry(fileEntryId);
2136
2137 DLFileEntryPermission.check(
2138 getPermissionChecker(), fileEntry, ActionKeys.UPDATE);
2139
2140 Folder destinationFolder = repository.getFolder(newFolderId);
2141
2142 return trashCapability.moveFileEntryFromTrash(
2143 getUserId(), fileEntry, destinationFolder, serviceContext);
2144 }
2145
2146
2152 @Override
2153 public FileEntry moveFileEntryToTrash(long fileEntryId)
2154 throws PortalException {
2155
2156 Repository repository = repositoryProvider.getFileEntryRepository(
2157 fileEntryId);
2158
2159 TrashCapability trashCapability = repository.getCapability(
2160 TrashCapability.class);
2161
2162 FileEntry fileEntry = repository.getFileEntry(fileEntryId);
2163
2164 DLFileEntryPermission.check(
2165 getPermissionChecker(), fileEntry, ActionKeys.DELETE);
2166
2167 return trashCapability.moveFileEntryToTrash(getUserId(), fileEntry);
2168 }
2169
2170
2178 @Override
2179 public FileShortcut moveFileShortcutFromTrash(
2180 long fileShortcutId, long newFolderId,
2181 ServiceContext serviceContext)
2182 throws PortalException {
2183
2184 FileShortcut fileShortcut = getFileShortcut(fileShortcutId);
2185
2186 DLFileShortcutPermission.check(
2187 getPermissionChecker(), fileShortcut, ActionKeys.UPDATE);
2188
2189 return dlAppHelperLocalService.moveFileShortcutFromTrash(
2190 getUserId(), fileShortcut, newFolderId, serviceContext);
2191 }
2192
2193
2199 @Override
2200 public FileShortcut moveFileShortcutToTrash(long fileShortcutId)
2201 throws PortalException {
2202
2203 Repository repository = repositoryProvider.getFileShortcutRepository(
2204 fileShortcutId);
2205
2206 TrashCapability trashCapability = repository.getCapability(
2207 TrashCapability.class);
2208
2209 FileShortcut fileShortcut = repository.getFileShortcut(fileShortcutId);
2210
2211 DLFileShortcutPermission.check(
2212 getPermissionChecker(), fileShortcut, ActionKeys.DELETE);
2213
2214 return trashCapability.moveFileShortcutToTrash(
2215 getUserId(), fileShortcut);
2216 }
2217
2218
2226 @Override
2227 public Folder moveFolder(
2228 long folderId, long parentFolderId, ServiceContext serviceContext)
2229 throws PortalException {
2230
2231 Repository fromRepository = repositoryProvider.getFolderRepository(
2232 folderId);
2233 Repository toRepository = getFolderRepository(
2234 parentFolderId, serviceContext.getScopeGroupId());
2235
2236 if (parentFolderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
2237 Folder toFolder = toRepository.getFolder(parentFolderId);
2238
2239 if (toFolder.isMountPoint()) {
2240 toRepository = getRepository(toFolder.getRepositoryId());
2241 }
2242 }
2243
2244 if (fromRepository.getRepositoryId() ==
2245 toRepository.getRepositoryId()) {
2246
2247
2248
2249 return fromRepository.moveFolder(
2250 getUserId(), folderId, parentFolderId, serviceContext);
2251 }
2252
2253
2254
2255 return moveFolders(
2256 folderId, parentFolderId, fromRepository, toRepository,
2257 serviceContext);
2258 }
2259
2260
2269 @Override
2270 public Folder moveFolderFromTrash(
2271 long folderId, long parentFolderId, ServiceContext serviceContext)
2272 throws PortalException {
2273
2274 Repository repository = repositoryProvider.getFolderRepository(
2275 folderId);
2276
2277 TrashCapability trashCapability = repository.getCapability(
2278 TrashCapability.class);
2279
2280 Folder folder = repository.getFolder(folderId);
2281
2282 DLFolderPermission.check(
2283 getPermissionChecker(), folder, ActionKeys.UPDATE);
2284
2285 Folder destinationFolder = null;
2286
2287 if (parentFolderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
2288 destinationFolder = repository.getFolder(parentFolderId);
2289 }
2290
2291 return trashCapability.moveFolderFromTrash(
2292 getUserId(), folder, destinationFolder, serviceContext);
2293 }
2294
2295
2301 @Override
2302 public Folder moveFolderToTrash(long folderId) throws PortalException {
2303 Repository repository = repositoryProvider.getFolderRepository(
2304 folderId);
2305
2306 TrashCapability trashCapability = repository.getCapability(
2307 TrashCapability.class);
2308
2309 Folder folder = repository.getFolder(folderId);
2310
2311 DLFolderPermission.check(
2312 getPermissionChecker(), folder, ActionKeys.DELETE);
2313
2314 return trashCapability.moveFolderToTrash(getUserId(), folder);
2315 }
2316
2317
2328 @Override
2329 public Lock refreshFileEntryLock(
2330 String lockUuid, long companyId, long expirationTime)
2331 throws PortalException {
2332
2333 Lock lock = LockManagerUtil.getLockByUuidAndCompanyId(
2334 lockUuid, companyId);
2335
2336 long fileEntryId = GetterUtil.getLong(lock.getKey());
2337
2338 Repository repository = repositoryProvider.getFileEntryRepository(
2339 fileEntryId);
2340
2341 return repository.refreshFileEntryLock(
2342 lockUuid, companyId, expirationTime);
2343 }
2344
2345
2356 @Override
2357 public Lock refreshFolderLock(
2358 String lockUuid, long companyId, long expirationTime)
2359 throws PortalException {
2360
2361 Lock lock = LockManagerUtil.getLockByUuidAndCompanyId(
2362 lockUuid, companyId);
2363
2364 long folderId = GetterUtil.getLong(lock.getKey());
2365
2366 Repository repository = repositoryProvider.getFolderRepository(
2367 folderId);
2368
2369 return repository.refreshFolderLock(
2370 lockUuid, companyId, expirationTime);
2371 }
2372
2373
2378 @Override
2379 public void restoreFileEntryFromTrash(long fileEntryId)
2380 throws PortalException {
2381
2382 Repository repository = repositoryProvider.getFileEntryRepository(
2383 fileEntryId);
2384
2385 TrashCapability trashCapability = repository.getCapability(
2386 TrashCapability.class);
2387
2388 FileEntry fileEntry = repository.getFileEntry(fileEntryId);
2389
2390 DLFileEntryPermission.check(
2391 getPermissionChecker(), fileEntry, ActionKeys.DELETE);
2392
2393 trashCapability.restoreFileEntryFromTrash(getUserId(), fileEntry);
2394 }
2395
2396
2401 @Override
2402 public void restoreFileShortcutFromTrash(long fileShortcutId)
2403 throws PortalException {
2404
2405 FileShortcut fileShortcut = getFileShortcut(fileShortcutId);
2406
2407 DLFileShortcutPermission.check(
2408 getPermissionChecker(), fileShortcut, ActionKeys.DELETE);
2409
2410 dlAppHelperLocalService.restoreFileShortcutFromTrash(
2411 getUserId(), fileShortcut);
2412 }
2413
2414
2419 @Override
2420 public void restoreFolderFromTrash(long folderId) throws PortalException {
2421 Repository repository = repositoryProvider.getFolderRepository(
2422 folderId);
2423
2424 TrashCapability trashCapability = repository.getCapability(
2425 TrashCapability.class);
2426
2427 Folder folder = repository.getFolder(folderId);
2428
2429 DLFolderPermission.check(
2430 getPermissionChecker(), folder, ActionKeys.DELETE);
2431
2432 trashCapability.restoreFolderFromTrash(getUserId(), folder);
2433 }
2434
2435
2443 @Override
2444 public void revertFileEntry(
2445 long fileEntryId, String version, ServiceContext serviceContext)
2446 throws PortalException {
2447
2448 Repository repository = repositoryProvider.getFileEntryRepository(
2449 fileEntryId);
2450
2451 repository.revertFileEntry(
2452 getUserId(), fileEntryId, version, serviceContext);
2453
2454 FileEntry fileEntry = getFileEntry(fileEntryId);
2455
2456 dlAppHelperLocalService.updateFileEntry(
2457 getUserId(), fileEntry, null, fileEntry.getFileVersion(),
2458 serviceContext);
2459 }
2460
2461 @Override
2462 public Hits search(
2463 long repositoryId, long creatorUserId, int status, int start,
2464 int end)
2465 throws PortalException {
2466
2467 Repository repository = getRepository(repositoryId);
2468
2469 return repository.search(creatorUserId, status, start, end);
2470 }
2471
2472 @Override
2473 public Hits search(
2474 long repositoryId, long creatorUserId, long folderId,
2475 String[] mimeTypes, int status, int start, int end)
2476 throws PortalException {
2477
2478 Repository repository = getRepository(repositoryId);
2479
2480 return repository.search(
2481 creatorUserId, folderId, mimeTypes, status, start, end);
2482 }
2483
2484 @Override
2485 public Hits search(long repositoryId, SearchContext searchContext)
2486 throws SearchException {
2487
2488 try {
2489 Repository repository = getRepository(repositoryId);
2490
2491 return repository.search(searchContext);
2492 }
2493 catch (Exception e) {
2494 throw new SearchException(e);
2495 }
2496 }
2497
2498 @Override
2499 public Hits search(
2500 long repositoryId, SearchContext searchContext, Query query)
2501 throws SearchException {
2502
2503 try {
2504 Repository repository = getRepository(repositoryId);
2505
2506 return repository.search(searchContext, query);
2507 }
2508 catch (Exception e) {
2509 throw new SearchException(e);
2510 }
2511 }
2512
2513
2520 @Override
2521 public void subscribeFileEntryType(long groupId, long fileEntryTypeId)
2522 throws PortalException {
2523
2524 DLPermission.check(
2525 getPermissionChecker(), groupId, ActionKeys.SUBSCRIBE);
2526
2527 dlAppLocalService.subscribeFileEntryType(
2528 getUserId(), groupId, fileEntryTypeId);
2529 }
2530
2531
2538 @Override
2539 public void subscribeFolder(long groupId, long folderId)
2540 throws PortalException {
2541
2542 DLFolderPermission.check(
2543 getPermissionChecker(), groupId, folderId, ActionKeys.SUBSCRIBE);
2544
2545 dlAppLocalService.subscribeFolder(getUserId(), groupId, folderId);
2546 }
2547
2548
2552 @Deprecated
2553 @Override
2554 public void unlockFileEntry(long fileEntryId) throws PortalException {
2555 checkInFileEntry(
2556 fileEntryId, false, StringPool.BLANK, new ServiceContext());
2557 }
2558
2559
2563 @Deprecated
2564 @Override
2565 public void unlockFileEntry(long fileEntryId, String lockUuid)
2566 throws PortalException {
2567
2568 checkInFileEntry(fileEntryId, lockUuid);
2569 }
2570
2571
2578 @Override
2579 public void unlockFolder(long repositoryId, long folderId, String lockUuid)
2580 throws PortalException {
2581
2582 Repository repository = getRepository(repositoryId);
2583
2584 repository.unlockFolder(folderId, lockUuid);
2585 }
2586
2587
2595 @Override
2596 public void unlockFolder(
2597 long repositoryId, long parentFolderId, String name,
2598 String lockUuid)
2599 throws PortalException {
2600
2601 Repository repository = getRepository(repositoryId);
2602
2603 repository.unlockFolder(parentFolderId, name, lockUuid);
2604 }
2605
2606
2613 @Override
2614 public void unsubscribeFileEntryType(long groupId, long fileEntryTypeId)
2615 throws PortalException {
2616
2617 DLPermission.check(
2618 getPermissionChecker(), groupId, ActionKeys.SUBSCRIBE);
2619
2620 dlAppLocalService.unsubscribeFileEntryType(
2621 getUserId(), groupId, fileEntryTypeId);
2622 }
2623
2624
2631 @Override
2632 public void unsubscribeFolder(long groupId, long folderId)
2633 throws PortalException {
2634
2635 DLFolderPermission.check(
2636 getPermissionChecker(), groupId, folderId, ActionKeys.SUBSCRIBE);
2637
2638 dlAppLocalService.unsubscribeFolder(getUserId(), groupId, folderId);
2639 }
2640
2641
2674 @Override
2675 public FileEntry updateFileEntry(
2676 long fileEntryId, String sourceFileName, String mimeType,
2677 String title, String description, String changeLog,
2678 boolean majorVersion, byte[] bytes, ServiceContext serviceContext)
2679 throws PortalException {
2680
2681 File file = null;
2682
2683 try {
2684 if (ArrayUtil.isNotEmpty(bytes)) {
2685 file = FileUtil.createTempFile(bytes);
2686 }
2687
2688 return updateFileEntry(
2689 fileEntryId, sourceFileName, mimeType, title, description,
2690 changeLog, majorVersion, file, serviceContext);
2691 }
2692 catch (IOException ioe) {
2693 throw new SystemException("Unable to write temporary file", ioe);
2694 }
2695 finally {
2696 FileUtil.delete(file);
2697 }
2698 }
2699
2700
2733 @Override
2734 public FileEntry updateFileEntry(
2735 long fileEntryId, String sourceFileName, String mimeType,
2736 String title, String description, String changeLog,
2737 boolean majorVersion, File file, ServiceContext serviceContext)
2738 throws PortalException {
2739
2740 if ((file == null) || !file.exists() || (file.length() == 0)) {
2741 return updateFileEntry(
2742 fileEntryId, sourceFileName, mimeType, title, description,
2743 changeLog, majorVersion, null, 0, serviceContext);
2744 }
2745
2746 mimeType = DLAppUtil.getMimeType(sourceFileName, mimeType, title, file);
2747
2748 Repository repository = repositoryProvider.getFileEntryRepository(
2749 fileEntryId);
2750
2751 FileEntry fileEntry = repository.updateFileEntry(
2752 getUserId(), fileEntryId, sourceFileName, mimeType, title,
2753 description, changeLog, majorVersion, file, serviceContext);
2754
2755 dlAppHelperLocalService.updateFileEntry(
2756 getUserId(), fileEntry, null, fileEntry.getFileVersion(),
2757 serviceContext);
2758
2759 return fileEntry;
2760 }
2761
2762
2796 @Override
2797 public FileEntry updateFileEntry(
2798 long fileEntryId, String sourceFileName, String mimeType,
2799 String title, String description, String changeLog,
2800 boolean majorVersion, InputStream is, long size,
2801 ServiceContext serviceContext)
2802 throws PortalException {
2803
2804 if (Validator.isNull(mimeType) ||
2805 mimeType.equals(ContentTypes.APPLICATION_OCTET_STREAM)) {
2806
2807 String extension = DLAppUtil.getExtension(title, sourceFileName);
2808
2809 if (size == 0) {
2810 mimeType = MimeTypesUtil.getExtensionContentType(extension);
2811 }
2812 else {
2813 File file = null;
2814
2815 try {
2816 file = FileUtil.createTempFile(is);
2817
2818 return updateFileEntry(
2819 fileEntryId, sourceFileName, mimeType, title,
2820 description, changeLog, majorVersion, file,
2821 serviceContext);
2822 }
2823 catch (IOException ioe) {
2824 throw new SystemException(
2825 "Unable to write temporary file", ioe);
2826 }
2827 finally {
2828 FileUtil.delete(file);
2829 }
2830 }
2831 }
2832
2833 Repository repository = repositoryProvider.getFileEntryRepository(
2834 fileEntryId);
2835
2836 FileEntry fileEntry = repository.updateFileEntry(
2837 getUserId(), fileEntryId, sourceFileName, mimeType, title,
2838 description, changeLog, majorVersion, is, size, serviceContext);
2839
2840 dlAppHelperLocalService.updateFileEntry(
2841 getUserId(), fileEntry, null, fileEntry.getFileVersion(),
2842 serviceContext);
2843
2844 return fileEntry;
2845 }
2846
2847 @Override
2848 public FileEntry updateFileEntryAndCheckIn(
2849 long fileEntryId, String sourceFileName, String mimeType,
2850 String title, String description, String changeLog,
2851 boolean majorVersion, File file, ServiceContext serviceContext)
2852 throws PortalException {
2853
2854 if ((file == null) || !file.exists() || (file.length() == 0)) {
2855 return updateFileEntryAndCheckIn(
2856 fileEntryId, sourceFileName, mimeType, title, description,
2857 changeLog, majorVersion, null, 0, serviceContext);
2858 }
2859
2860 Repository repository = repositoryProvider.getFileEntryRepository(
2861 fileEntryId);
2862
2863 FileEntry fileEntry = repository.updateFileEntry(
2864 getUserId(), fileEntryId, sourceFileName, mimeType, title,
2865 description, changeLog, majorVersion, file, serviceContext);
2866
2867 repository.checkInFileEntry(
2868 getUserId(), fileEntryId, majorVersion, changeLog, serviceContext);
2869
2870 dlAppHelperLocalService.updateFileEntry(
2871 getUserId(), fileEntry, null, fileEntry.getFileVersion(),
2872 serviceContext);
2873
2874 return fileEntry;
2875 }
2876
2877 @Override
2878 public FileEntry updateFileEntryAndCheckIn(
2879 long fileEntryId, String sourceFileName, String mimeType,
2880 String title, String description, String changeLog,
2881 boolean majorVersion, InputStream is, long size,
2882 ServiceContext serviceContext)
2883 throws PortalException {
2884
2885 Repository repository = repositoryProvider.getFileEntryRepository(
2886 fileEntryId);
2887
2888 FileEntry fileEntry = repository.updateFileEntry(
2889 getUserId(), fileEntryId, sourceFileName, mimeType, title,
2890 description, changeLog, majorVersion, is, size, serviceContext);
2891
2892 repository.checkInFileEntry(
2893 getUserId(), fileEntryId, majorVersion, changeLog, serviceContext);
2894
2895 dlAppHelperLocalService.updateFileEntry(
2896 getUserId(), fileEntry, null, fileEntry.getFileVersion(),
2897 serviceContext);
2898
2899 return fileEntry;
2900 }
2901
2902
2914 @Override
2915 public FileShortcut updateFileShortcut(
2916 long fileShortcutId, long folderId, long toFileEntryId,
2917 ServiceContext serviceContext)
2918 throws PortalException {
2919
2920 Repository repository = repositoryProvider.getFileShortcutRepository(
2921 fileShortcutId);
2922
2923 return repository.updateFileShortcut(
2924 getUserId(), fileShortcutId, folderId, toFileEntryId,
2925 serviceContext);
2926 }
2927
2928
2948 @Override
2949 public Folder updateFolder(
2950 long folderId, String name, String description,
2951 ServiceContext serviceContext)
2952 throws PortalException {
2953
2954 Repository repository = getFolderRepository(
2955 folderId, serviceContext.getScopeGroupId());
2956
2957 Folder folder = repository.updateFolder(
2958 folderId, name, description, serviceContext);
2959
2960 if (folderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
2961 dlAppHelperLocalService.updateFolder(
2962 getUserId(), folder, serviceContext);
2963 }
2964
2965 return folder;
2966 }
2967
2968
2978 @Override
2979 public boolean verifyFileEntryCheckOut(
2980 long repositoryId, long fileEntryId, String lockUuid)
2981 throws PortalException {
2982
2983 Repository repository = getRepository(repositoryId);
2984
2985 return repository.verifyFileEntryCheckOut(fileEntryId, lockUuid);
2986 }
2987
2988 @Override
2989 public boolean verifyFileEntryLock(
2990 long repositoryId, long fileEntryId, String lockUuid)
2991 throws PortalException {
2992
2993 Repository repository = getRepository(repositoryId);
2994
2995 return repository.verifyFileEntryLock(fileEntryId, lockUuid);
2996 }
2997
2998
3008 @Override
3009 public boolean verifyInheritableLock(
3010 long repositoryId, long folderId, String lockUuid)
3011 throws PortalException {
3012
3013 Repository repository = getRepository(repositoryId);
3014
3015 return repository.verifyInheritableLock(folderId, lockUuid);
3016 }
3017
3018 protected FileEntry copyFileEntry(
3019 Repository toRepository, FileEntry fileEntry, long newFolderId,
3020 ServiceContext serviceContext)
3021 throws PortalException {
3022
3023 List<FileVersion> fileVersions = fileEntry.getFileVersions(
3024 WorkflowConstants.STATUS_ANY);
3025
3026 FileVersion latestFileVersion = fileVersions.get(
3027 fileVersions.size() - 1);
3028
3029 String sourceFileName = DLAppUtil.getSourceFileName(latestFileVersion);
3030
3031 FileEntry destinationFileEntry = toRepository.addFileEntry(
3032 getUserId(), newFolderId, sourceFileName,
3033 latestFileVersion.getMimeType(), latestFileVersion.getTitle(),
3034 latestFileVersion.getDescription(), StringPool.BLANK,
3035 latestFileVersion.getContentStream(false),
3036 latestFileVersion.getSize(), serviceContext);
3037
3038 for (int i = fileVersions.size() - 2; i >= 0; i--) {
3039 FileVersion fileVersion = fileVersions.get(i);
3040
3041 sourceFileName = DLAppUtil.getSourceFileName(fileVersion);
3042
3043 FileVersion previousFileVersion = fileVersions.get(i + 1);
3044
3045 try {
3046 destinationFileEntry = toRepository.updateFileEntry(
3047 getUserId(), destinationFileEntry.getFileEntryId(),
3048 sourceFileName, fileVersion.getMimeType(),
3049 fileVersion.getTitle(), fileVersion.getDescription(),
3050 StringPool.BLANK,
3051 DLAppUtil.isMajorVersion(previousFileVersion, fileVersion),
3052 fileVersion.getContentStream(false), fileVersion.getSize(),
3053 serviceContext);
3054
3055 FileVersion destinationFileVersion =
3056 destinationFileEntry.getFileVersion();
3057
3058 dlAppHelperLocalService.updateFileEntry(
3059 getUserId(), destinationFileEntry, null,
3060 destinationFileVersion, serviceContext);
3061 }
3062 catch (PortalException pe) {
3063 toRepository.deleteFileEntry(
3064 destinationFileEntry.getFileEntryId());
3065
3066 throw pe;
3067 }
3068 }
3069
3070 return destinationFileEntry;
3071 }
3072
3073 protected void copyFolder(
3074 Repository repository, Folder srcFolder, Folder destFolder,
3075 ServiceContext serviceContext)
3076 throws PortalException {
3077
3078 Queue<Folder[]> folders = new LinkedList<>();
3079 final List<FileEntry> fileEntries = new ArrayList<>();
3080
3081 Folder curSrcFolder = srcFolder;
3082 Folder curDestFolder = destFolder;
3083
3084 while (true) {
3085 List<FileEntry> srcFileEntries = repository.getFileEntries(
3086 curSrcFolder.getFolderId(), QueryUtil.ALL_POS,
3087 QueryUtil.ALL_POS, null);
3088
3089 for (FileEntry srcFileEntry : srcFileEntries) {
3090 try {
3091 FileEntry fileEntry = repository.copyFileEntry(
3092 getUserId(), curDestFolder.getGroupId(),
3093 srcFileEntry.getFileEntryId(),
3094 curDestFolder.getFolderId(), serviceContext);
3095
3096 fileEntries.add(fileEntry);
3097 }
3098 catch (Exception e) {
3099 _log.error(e, e);
3100 }
3101 }
3102
3103 List<Folder> srcSubfolders = repository.getFolders(
3104 curSrcFolder.getFolderId(), false, QueryUtil.ALL_POS,
3105 QueryUtil.ALL_POS, null);
3106
3107 for (Folder srcSubfolder : srcSubfolders) {
3108 Folder destSubfolder = repository.addFolder(
3109 getUserId(), curDestFolder.getFolderId(),
3110 srcSubfolder.getName(), srcSubfolder.getDescription(),
3111 serviceContext);
3112
3113 dlAppHelperLocalService.addFolder(
3114 getUserId(), destSubfolder, serviceContext);
3115
3116 folders.offer(new Folder[] {srcSubfolder, destSubfolder});
3117 }
3118
3119 Folder[] next = folders.poll();
3120
3121 if (next == null) {
3122 break;
3123 }
3124 else {
3125 curSrcFolder = next[0];
3126 curDestFolder = next[1];
3127 }
3128 }
3129
3130 TransactionCommitCallbackUtil.registerCallback(
3131 new Callable<Void>() {
3132
3133 @Override
3134 public Void call() throws Exception {
3135 for (FileEntry fileEntry : fileEntries) {
3136 DLProcessorRegistryUtil.trigger(fileEntry, null);
3137 }
3138
3139 return null;
3140 }
3141
3142 });
3143 }
3144
3145 protected void deleteFileEntry(
3146 long oldFileEntryId, long newFileEntryId, Repository fromRepository,
3147 Repository toRepository)
3148 throws PortalException {
3149
3150 try {
3151 FileEntry fileEntry = fromRepository.getFileEntry(oldFileEntryId);
3152
3153 dlAppHelperLocalService.deleteFileEntry(fileEntry);
3154
3155 fromRepository.deleteFileEntry(oldFileEntryId);
3156 }
3157 catch (PortalException pe) {
3158 FileEntry fileEntry = toRepository.getFileEntry(newFileEntryId);
3159
3160 toRepository.deleteFileEntry(newFileEntryId);
3161
3162 dlAppHelperLocalService.deleteFileEntry(fileEntry);
3163
3164 throw pe;
3165 }
3166 }
3167
3168 protected FileEntry fetchFileEntryByUuidAndRepositoryId(
3169 String uuid, long repositoryId)
3170 throws PortalException {
3171
3172 try {
3173 Repository repository = getRepository(repositoryId);
3174
3175 return repository.getFileEntryByUuid(uuid);
3176 }
3177 catch (NoSuchFileEntryException nsfee) {
3178 if (_log.isDebugEnabled()) {
3179 _log.debug(nsfee, nsfee);
3180 }
3181
3182 return null;
3183 }
3184 catch (RepositoryException re) {
3185 throw new NoSuchFileEntryException(re);
3186 }
3187 }
3188
3189 protected Repository getFolderRepository(long folderId, long groupId)
3190 throws PortalException {
3191
3192 if (folderId == DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
3193 return getRepository(groupId);
3194 }
3195
3196 return repositoryProvider.getFolderRepository(folderId);
3197 }
3198
3199 protected Repository getRepository(long repositoryId)
3200 throws PortalException {
3201
3202 try {
3203 return repositoryProvider.getRepository(repositoryId);
3204 }
3205 catch (InvalidRepositoryIdException irie) {
3206 StringBundler sb = new StringBundler(3);
3207
3208 sb.append("No Group exists with the key {repositoryId=");
3209 sb.append(repositoryId);
3210 sb.append("}");
3211
3212 throw new NoSuchGroupException(sb.toString(), irie);
3213 }
3214 }
3215
3216 protected FileEntry moveFileEntries(
3217 long fileEntryId, long newFolderId, Repository fromRepository,
3218 Repository toRepository, ServiceContext serviceContext)
3219 throws PortalException {
3220
3221 FileEntry sourceFileEntry = fromRepository.getFileEntry(fileEntryId);
3222
3223 FileEntry destinationFileEntry = copyFileEntry(
3224 toRepository, sourceFileEntry, newFolderId, serviceContext);
3225
3226 deleteFileEntry(
3227 fileEntryId, destinationFileEntry.getFileEntryId(), fromRepository,
3228 toRepository);
3229
3230 return destinationFileEntry;
3231 }
3232
3233 protected Folder moveFolders(
3234 long folderId, long parentFolderId, Repository fromRepository,
3235 Repository toRepository, ServiceContext serviceContext)
3236 throws PortalException {
3237
3238 Folder folder = fromRepository.getFolder(folderId);
3239
3240 Folder newFolder = toRepository.addFolder(
3241 getUserId(), parentFolderId, folder.getName(),
3242 folder.getDescription(), serviceContext);
3243
3244 dlAppHelperLocalService.addFolder(
3245 getUserId(), newFolder, serviceContext);
3246
3247 List<RepositoryEntry> repositoryEntries =
3248 fromRepository.getFoldersAndFileEntriesAndFileShortcuts(
3249 folderId, WorkflowConstants.STATUS_ANY, true, QueryUtil.ALL_POS,
3250 QueryUtil.ALL_POS, null);
3251
3252 try {
3253 for (RepositoryEntry repositoryEntry : repositoryEntries) {
3254 if (repositoryEntry instanceof FileEntry) {
3255 FileEntry fileEntry = (FileEntry)repositoryEntry;
3256
3257 moveFileEntry(
3258 fileEntry.getFileEntryId(), newFolder.getFolderId(),
3259 serviceContext);
3260 }
3261 else if (repositoryEntry instanceof Folder) {
3262 Folder currentFolder = (Folder)repositoryEntry;
3263
3264 moveFolders(
3265 currentFolder.getFolderId(), newFolder.getFolderId(),
3266 fromRepository, toRepository, serviceContext);
3267 }
3268 else if (repositoryEntry instanceof FileShortcut) {
3269 if (newFolder.isSupportsShortcuts()) {
3270 FileShortcut fileShortcut =
3271 (FileShortcut)repositoryEntry;
3272
3273 toRepository.addFileShortcut(
3274 getUserId(), newFolder.getFolderId(),
3275 fileShortcut.getToFileEntryId(), serviceContext);
3276 }
3277 }
3278 }
3279 }
3280 catch (PortalException pe) {
3281 int foldersAndFileEntriesAndFileShortcutsCount =
3282 getFoldersAndFileEntriesAndFileShortcutsCount(
3283 newFolder.getRepositoryId(), newFolder.getFolderId(),
3284 WorkflowConstants.STATUS_ANY, true);
3285
3286 if (foldersAndFileEntriesAndFileShortcutsCount == 0) {
3287 toRepository.deleteFolder(newFolder.getFolderId());
3288 }
3289
3290 throw pe;
3291 }
3292
3293 try {
3294 fromRepository.deleteFolder(folderId);
3295 }
3296 catch (PortalException pe) {
3297 toRepository.deleteFolder(newFolder.getFolderId());
3298
3299 throw pe;
3300 }
3301
3302 return newFolder;
3303 }
3304
3305 @BeanReference(type = RepositoryProvider.class)
3306 protected RepositoryProvider repositoryProvider;
3307
3308 private static final Log _log = LogFactoryUtil.getLog(
3309 DLAppServiceImpl.class);
3310
3311 }