001
014
015 package com.liferay.portlet.documentlibrary.service.impl;
016
017 import com.liferay.portal.NoSuchGroupException;
018 import com.liferay.portal.kernel.dao.orm.QueryUtil;
019 import com.liferay.portal.kernel.exception.PortalException;
020 import com.liferay.portal.kernel.exception.SystemException;
021 import com.liferay.portal.kernel.io.unsync.UnsyncByteArrayInputStream;
022 import com.liferay.portal.kernel.repository.InvalidRepositoryIdException;
023 import com.liferay.portal.kernel.repository.LocalRepository;
024 import com.liferay.portal.kernel.repository.RepositoryProviderUtil;
025 import com.liferay.portal.kernel.repository.model.FileEntry;
026 import com.liferay.portal.kernel.repository.model.FileShortcut;
027 import com.liferay.portal.kernel.repository.model.FileVersion;
028 import com.liferay.portal.kernel.repository.model.Folder;
029 import com.liferay.portal.kernel.repository.util.RepositoryTrashUtil;
030 import com.liferay.portal.kernel.systemevent.SystemEventHierarchyEntryThreadLocal;
031 import com.liferay.portal.kernel.util.ArrayUtil;
032 import com.liferay.portal.kernel.util.ContentTypes;
033 import com.liferay.portal.kernel.util.FileUtil;
034 import com.liferay.portal.kernel.util.MimeTypesUtil;
035 import com.liferay.portal.kernel.util.StringBundler;
036 import com.liferay.portal.kernel.util.StringPool;
037 import com.liferay.portal.kernel.util.Validator;
038 import com.liferay.portal.kernel.workflow.WorkflowConstants;
039 import com.liferay.portal.model.Repository;
040 import com.liferay.portal.model.UserConstants;
041 import com.liferay.portal.repository.liferayrepository.model.LiferayFolder;
042 import com.liferay.portal.service.ServiceContext;
043 import com.liferay.portlet.documentlibrary.NoSuchFileEntryException;
044 import com.liferay.portlet.documentlibrary.NoSuchFileShortcutException;
045 import com.liferay.portlet.documentlibrary.NoSuchFileVersionException;
046 import com.liferay.portlet.documentlibrary.NoSuchFolderException;
047 import com.liferay.portlet.documentlibrary.model.DLFileEntryType;
048 import com.liferay.portlet.documentlibrary.model.DLFileEntryTypeConstants;
049 import com.liferay.portlet.documentlibrary.model.DLFileRank;
050 import com.liferay.portlet.documentlibrary.model.DLFolder;
051 import com.liferay.portlet.documentlibrary.model.DLFolderConstants;
052 import com.liferay.portlet.documentlibrary.service.base.DLAppLocalServiceBaseImpl;
053 import com.liferay.portlet.documentlibrary.util.DLAppUtil;
054
055 import java.io.File;
056 import java.io.IOException;
057 import java.io.InputStream;
058
059 import java.util.List;
060
061
088 public class DLAppLocalServiceImpl extends DLAppLocalServiceBaseImpl {
089
090 @Override
091 public FileEntry addFileEntry(
092 long userId, long repositoryId, long folderId,
093 String sourceFileName, String mimeType, byte[] bytes,
094 ServiceContext serviceContext)
095 throws PortalException {
096
097 return addFileEntry(
098 userId, repositoryId, folderId, sourceFileName, mimeType, null,
099 StringPool.BLANK, StringPool.BLANK, bytes, serviceContext);
100 }
101
102
134 @Override
135 public FileEntry addFileEntry(
136 long userId, long repositoryId, long folderId,
137 String sourceFileName, String mimeType, String title,
138 String description, String changeLog, byte[] bytes,
139 ServiceContext serviceContext)
140 throws PortalException {
141
142 File file = null;
143
144 try {
145 if (ArrayUtil.isNotEmpty(bytes)) {
146 file = FileUtil.createTempFile(bytes);
147 }
148
149 return addFileEntry(
150 userId, repositoryId, folderId, sourceFileName, mimeType, title,
151 description, changeLog, file, serviceContext);
152 }
153 catch (IOException ioe) {
154 throw new SystemException("Unable to write temporary file", ioe);
155 }
156 finally {
157 FileUtil.delete(file);
158 }
159 }
160
161
194 @Override
195 public FileEntry addFileEntry(
196 long userId, long repositoryId, long folderId,
197 String sourceFileName, String mimeType, String title,
198 String description, String changeLog, File file,
199 ServiceContext serviceContext)
200 throws PortalException {
201
202 if ((file == null) || !file.exists() || (file.length() == 0)) {
203 return addFileEntry(
204 userId, repositoryId, folderId, sourceFileName, mimeType, title,
205 description, changeLog, null, 0, serviceContext);
206 }
207
208 mimeType = DLAppUtil.getMimeType(sourceFileName, mimeType, title, file);
209
210 LocalRepository localRepository = getLocalRepository(repositoryId);
211
212 FileEntry fileEntry = localRepository.addFileEntry(
213 userId, folderId, sourceFileName, mimeType, title, description,
214 changeLog, file, serviceContext);
215
216 return fileEntry;
217 }
218
219
253 @Override
254 public FileEntry addFileEntry(
255 long userId, long repositoryId, long folderId,
256 String sourceFileName, String mimeType, String title,
257 String description, String changeLog, InputStream is, long size,
258 ServiceContext serviceContext)
259 throws PortalException {
260
261 if (is == null) {
262 is = new UnsyncByteArrayInputStream(new byte[0]);
263 size = 0;
264 }
265
266 if (Validator.isNull(mimeType) ||
267 mimeType.equals(ContentTypes.APPLICATION_OCTET_STREAM)) {
268
269 String extension = DLAppUtil.getExtension(title, sourceFileName);
270
271 if (size == 0) {
272 mimeType = MimeTypesUtil.getExtensionContentType(extension);
273 }
274 else {
275 File file = null;
276
277 try {
278 file = FileUtil.createTempFile(is);
279
280 return addFileEntry(
281 userId, repositoryId, folderId, sourceFileName,
282 mimeType, title, description, changeLog, file,
283 serviceContext);
284 }
285 catch (IOException ioe) {
286 throw new SystemException(
287 "Unable to write temporary file", ioe);
288 }
289 finally {
290 FileUtil.delete(file);
291 }
292 }
293 }
294
295 LocalRepository localRepository = getLocalRepository(repositoryId);
296
297 FileEntry fileEntry = localRepository.addFileEntry(
298 userId, folderId, sourceFileName, mimeType, title, description,
299 changeLog, is, size, serviceContext);
300
301 return fileEntry;
302 }
303
304
315 @Override
316 public DLFileRank addFileRank(
317 long repositoryId, long companyId, long userId, long fileEntryId,
318 ServiceContext serviceContext) {
319
320 return dlFileRankLocalService.addFileRank(
321 repositoryId, companyId, userId, fileEntryId, serviceContext);
322 }
323
324
339 @Override
340 public FileShortcut addFileShortcut(
341 long userId, long repositoryId, long folderId, long toFileEntryId,
342 ServiceContext serviceContext)
343 throws PortalException {
344
345 LocalRepository localRepository = getLocalRepository(repositoryId);
346
347 return localRepository.addFileShortcut(
348 userId, folderId, toFileEntryId, serviceContext);
349 }
350
351
367 @Override
368 public Folder addFolder(
369 long userId, long repositoryId, long parentFolderId, String name,
370 String description, ServiceContext serviceContext)
371 throws PortalException {
372
373 LocalRepository localRepository = getLocalRepository(repositoryId);
374
375 Folder folder = localRepository.addFolder(
376 userId, parentFolderId, name, description, serviceContext);
377
378 dlAppHelperLocalService.addFolder(userId, folder, serviceContext);
379
380 return folder;
381 }
382
383
390 @Override
391 public void deleteAll(long repositoryId) throws PortalException {
392 LocalRepository localRepository = getLocalRepository(repositoryId);
393
394 deleteRepository(localRepository);
395 }
396
397 @Override
398 public void deleteAllRepositories(long groupId) throws PortalException {
399 LocalRepository groupLocalRepository =
400 RepositoryProviderUtil.getLocalRepository(groupId);
401
402 deleteRepository(groupLocalRepository);
403
404 List<LocalRepository> localRepositories =
405 RepositoryProviderUtil.getLocalRepositoriesByGroupId(groupId);
406
407 for (LocalRepository localRepository : localRepositories) {
408 if (localRepository.getRepositoryId() !=
409 groupLocalRepository.getRepositoryId()) {
410
411 deleteRepository(localRepository);
412 }
413 }
414 }
415
416
422 @Override
423 public void deleteFileEntry(long fileEntryId) throws PortalException {
424 LocalRepository localRepository = getFileEntryLocalRepository(
425 fileEntryId);
426
427 FileEntry fileEntry = localRepository.getFileEntry(fileEntryId);
428
429 dlAppHelperLocalService.deleteFileEntry(fileEntry);
430
431 localRepository.deleteFileEntry(fileEntryId);
432 }
433
434
440 @Override
441 public void deleteFileRanksByFileEntryId(long fileEntryId) {
442 dlFileRankLocalService.deleteFileRanksByFileEntryId(fileEntryId);
443 }
444
445
451 @Override
452 public void deleteFileRanksByUserId(long userId) {
453 dlFileRankLocalService.deleteFileRanksByUserId(userId);
454 }
455
456
463 @Override
464 public void deleteFileShortcut(FileShortcut fileShortcut)
465 throws PortalException {
466
467 deleteFileShortcut(fileShortcut.getFileShortcutId());
468 }
469
470
477 @Override
478 public void deleteFileShortcut(long fileShortcutId) throws PortalException {
479 LocalRepository localRepository = getFileShortcutLocalRepository(
480 fileShortcutId);
481
482 localRepository.deleteFileShortcut(fileShortcutId);
483 }
484
485
493 @Override
494 public void deleteFileShortcuts(long toFileEntryId) throws PortalException {
495 LocalRepository localRepository = getFileEntryLocalRepository(
496 toFileEntryId);
497
498 localRepository.deleteFileShortcuts(toFileEntryId);
499 }
500
501
507 @Override
508 public void deleteFolder(long folderId) throws PortalException {
509 LocalRepository localRepository = getFolderLocalRepository(folderId);
510
511 List<FileEntry> fileEntries = localRepository.getRepositoryFileEntries(
512 UserConstants.USER_ID_DEFAULT, folderId, QueryUtil.ALL_POS,
513 QueryUtil.ALL_POS, null);
514
515 for (FileEntry fileEntry : fileEntries) {
516 dlAppHelperLocalService.deleteFileEntry(fileEntry);
517 }
518
519 Folder folder = getFolder(folderId);
520
521 localRepository.deleteFolder(folderId);
522
523 dlAppHelperLocalService.deleteFolder(folder);
524 }
525
526
533 @Override
534 public FileEntry getFileEntry(long fileEntryId) throws PortalException {
535 LocalRepository localRepository = getFileEntryLocalRepository(
536 fileEntryId);
537
538 return localRepository.getFileEntry(fileEntryId);
539 }
540
541
550 @Override
551 public FileEntry getFileEntry(long groupId, long folderId, String title)
552 throws PortalException {
553
554 try {
555 LocalRepository localRepository = getLocalRepository(groupId);
556
557 return localRepository.getFileEntry(folderId, title);
558 }
559 catch (NoSuchFileEntryException nsfee) {
560 }
561
562 LocalRepository localRepository = getFolderLocalRepository(folderId);
563
564 return localRepository.getFileEntry(folderId, title);
565 }
566
567
575 @Override
576 public FileEntry getFileEntryByUuidAndGroupId(String uuid, long groupId)
577 throws PortalException {
578
579 try {
580 LocalRepository localRepository = getLocalRepository(groupId);
581
582 return localRepository.getFileEntryByUuid(uuid);
583 }
584 catch (NoSuchFileEntryException nsfee) {
585 }
586
587 List<com.liferay.portal.model.Repository> repositories =
588 repositoryPersistence.findByGroupId(groupId);
589
590 for (Repository repository : repositories) {
591 try {
592 LocalRepository localRepository = getLocalRepository(
593 repository.getRepositoryId());
594
595 return localRepository.getFileEntryByUuid(uuid);
596 }
597 catch (NoSuchFileEntryException nsfee) {
598 }
599 }
600
601 StringBundler msg = new StringBundler(6);
602
603 msg.append("No DLFileEntry exists with the key {");
604 msg.append("uuid=");
605 msg.append(uuid);
606 msg.append(", groupId=");
607 msg.append(groupId);
608 msg.append(StringPool.CLOSE_CURLY_BRACE);
609
610 throw new NoSuchFileEntryException(msg.toString());
611 }
612
613
621 @Override
622 public List<DLFileRank> getFileRanks(long repositoryId, long userId) {
623 return dlFileRankLocalService.getFileRanks(repositoryId, userId);
624 }
625
626
634 @Override
635 public FileShortcut getFileShortcut(long fileShortcutId)
636 throws PortalException {
637
638 LocalRepository localRepository = getFileShortcutLocalRepository(
639 fileShortcutId);
640
641 return localRepository.getFileShortcut(fileShortcutId);
642 }
643
644
651 @Override
652 public FileVersion getFileVersion(long fileVersionId)
653 throws PortalException {
654
655 LocalRepository localRepository = getFileVersionLocalRepository(
656 fileVersionId);
657
658 return localRepository.getFileVersion(fileVersionId);
659 }
660
661
668 @Override
669 public Folder getFolder(long folderId) throws PortalException {
670 LocalRepository localRepository = getFolderLocalRepository(folderId);
671
672 return localRepository.getFolder(folderId);
673 }
674
675
684 @Override
685 public Folder getFolder(long repositoryId, long parentFolderId, String name)
686 throws PortalException {
687
688 LocalRepository localRepository = getLocalRepository(repositoryId);
689
690 return localRepository.getFolder(parentFolderId, name);
691 }
692
693
702 @Override
703 public Folder getMountFolder(long repositoryId) throws PortalException {
704 DLFolder dlFolder = dlFolderLocalService.getMountFolder(repositoryId);
705
706 return new LiferayFolder(dlFolder);
707 }
708
709
720 @Override
721 public FileEntry moveFileEntry(
722 long userId, long fileEntryId, long newFolderId,
723 ServiceContext serviceContext)
724 throws PortalException {
725
726 SystemEventHierarchyEntryThreadLocal.push(FileEntry.class);
727
728 try {
729 LocalRepository fromLocalRepository = getFileEntryLocalRepository(
730 fileEntryId);
731 LocalRepository toLocalRepository = getFolderLocalRepository(
732 newFolderId, serviceContext.getScopeGroupId());
733
734 if (fromLocalRepository.getRepositoryId() ==
735 toLocalRepository.getRepositoryId()) {
736
737
738
739 return fromLocalRepository.moveFileEntry(
740 userId, fileEntryId, newFolderId, serviceContext);
741 }
742
743
744
745 return moveFileEntries(
746 userId, fileEntryId, newFolderId, fromLocalRepository,
747 toLocalRepository, serviceContext);
748 }
749 finally {
750 SystemEventHierarchyEntryThreadLocal.pop(FileEntry.class);
751 }
752 }
753
754
759 @Deprecated
760 @Override
761 public FileEntry moveFileEntryFromTrash(
762 long userId, long fileEntryId, long newFolderId,
763 ServiceContext serviceContext)
764 throws PortalException {
765
766 LocalRepository localRepository = getFileEntryLocalRepository(
767 fileEntryId);
768
769 return RepositoryTrashUtil.moveFileEntryFromTrash(
770 userId, localRepository.getRepositoryId(), fileEntryId, newFolderId,
771 serviceContext);
772 }
773
774
778 @Deprecated
779 @Override
780 public FileEntry moveFileEntryToTrash(long userId, long fileEntryId)
781 throws PortalException {
782
783 LocalRepository localRepository = getFileEntryLocalRepository(
784 fileEntryId);
785
786 return RepositoryTrashUtil.moveFileEntryToTrash(
787 userId, localRepository.getRepositoryId(), fileEntryId);
788 }
789
790 @Override
791 public Folder moveFolder(
792 long userId, long folderId, long parentFolderId,
793 ServiceContext serviceContext)
794 throws PortalException {
795
796 SystemEventHierarchyEntryThreadLocal.push(Folder.class);
797
798 try {
799 LocalRepository sourceLocalRepository = getFolderLocalRepository(
800 folderId);
801
802 LocalRepository destinationLocalRepository =
803 getFolderLocalRepository(
804 parentFolderId, serviceContext.getScopeGroupId());
805
806 if (parentFolderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
807 Folder toFolder = destinationLocalRepository.getFolder(
808 parentFolderId);
809
810 if (toFolder.isMountPoint()) {
811 destinationLocalRepository = getLocalRepository(
812 toFolder.getRepositoryId());
813 }
814 }
815
816 if (sourceLocalRepository.getRepositoryId() ==
817 destinationLocalRepository.getRepositoryId()) {
818
819
820
821 return sourceLocalRepository.moveFolder(
822 userId, folderId, parentFolderId, serviceContext);
823 }
824
825
826
827 return moveFolders(
828 userId, folderId, parentFolderId, sourceLocalRepository,
829 destinationLocalRepository, serviceContext);
830 }
831 finally {
832 SystemEventHierarchyEntryThreadLocal.pop(Folder.class);
833 }
834 }
835
836
841 @Deprecated
842 @Override
843 public void restoreFileEntryFromTrash(long userId, long fileEntryId)
844 throws PortalException {
845
846 LocalRepository localRepository = getFileEntryLocalRepository(
847 fileEntryId);
848
849 RepositoryTrashUtil.restoreFileEntryFromTrash(
850 userId, localRepository.getRepositoryId(), fileEntryId);
851 }
852
853
862 @Override
863 public void subscribeFileEntryType(
864 long userId, long groupId, long fileEntryTypeId)
865 throws PortalException {
866
867 if (fileEntryTypeId ==
868 DLFileEntryTypeConstants.FILE_ENTRY_TYPE_ID_BASIC_DOCUMENT) {
869
870 fileEntryTypeId = groupId;
871 }
872
873 subscriptionLocalService.addSubscription(
874 userId, groupId, DLFileEntryType.class.getName(), fileEntryTypeId);
875 }
876
877
886 @Override
887 public void subscribeFolder(long userId, long groupId, long folderId)
888 throws PortalException {
889
890 if (folderId == DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
891 folderId = groupId;
892 }
893
894 subscriptionLocalService.addSubscription(
895 userId, groupId, DLFolder.class.getName(), folderId);
896 }
897
898
907 @Override
908 public void unsubscribeFileEntryType(
909 long userId, long groupId, long fileEntryTypeId)
910 throws PortalException {
911
912 if (fileEntryTypeId ==
913 DLFileEntryTypeConstants.FILE_ENTRY_TYPE_ID_BASIC_DOCUMENT) {
914
915 fileEntryTypeId = groupId;
916 }
917
918 subscriptionLocalService.deleteSubscription(
919 userId, DLFileEntryType.class.getName(), fileEntryTypeId);
920 }
921
922
931 @Override
932 public void unsubscribeFolder(long userId, long groupId, long folderId)
933 throws PortalException {
934
935 if (folderId == DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
936 folderId = groupId;
937 }
938
939 subscriptionLocalService.deleteSubscription(
940 userId, DLFolder.class.getName(), folderId);
941 }
942
943
955 @Override
956 public void updateAsset(
957 long userId, FileEntry fileEntry, FileVersion fileVersion,
958 long[] assetCategoryIds, String[] assetTagNames,
959 long[] assetLinkEntryIds)
960 throws PortalException {
961
962 dlAppHelperLocalService.updateAsset(
963 userId, fileEntry, fileVersion, assetCategoryIds, assetTagNames,
964 assetLinkEntryIds);
965 }
966
967
1002 @Override
1003 public FileEntry updateFileEntry(
1004 long userId, long fileEntryId, String sourceFileName,
1005 String mimeType, String title, String description, String changeLog,
1006 boolean majorVersion, byte[] bytes, ServiceContext serviceContext)
1007 throws PortalException {
1008
1009 File file = null;
1010
1011 try {
1012 if (ArrayUtil.isNotEmpty(bytes)) {
1013 file = FileUtil.createTempFile(bytes);
1014 }
1015
1016 return updateFileEntry(
1017 userId, fileEntryId, sourceFileName, mimeType, title,
1018 description, changeLog, majorVersion, file, serviceContext);
1019 }
1020 catch (IOException ioe) {
1021 throw new SystemException("Unable to write temporary file", ioe);
1022 }
1023 finally {
1024 FileUtil.delete(file);
1025 }
1026 }
1027
1028
1064 @Override
1065 public FileEntry updateFileEntry(
1066 long userId, long fileEntryId, String sourceFileName,
1067 String mimeType, String title, String description, String changeLog,
1068 boolean majorVersion, File file, ServiceContext serviceContext)
1069 throws PortalException {
1070
1071 if ((file == null) || !file.exists() || (file.length() == 0)) {
1072 return updateFileEntry(
1073 userId, fileEntryId, sourceFileName, mimeType, title,
1074 description, changeLog, majorVersion, null, 0, serviceContext);
1075 }
1076
1077 mimeType = DLAppUtil.getMimeType(sourceFileName, mimeType, title, file);
1078
1079 LocalRepository localRepository = getFileEntryLocalRepository(
1080 fileEntryId);
1081
1082 FileEntry fileEntry = localRepository.updateFileEntry(
1083 userId, fileEntryId, sourceFileName, mimeType, title, description,
1084 changeLog, majorVersion, file, serviceContext);
1085
1086 dlAppHelperLocalService.updateFileEntry(
1087 userId, fileEntry, null, fileEntry.getFileVersion(),
1088 serviceContext);
1089
1090 return fileEntry;
1091 }
1092
1093
1129 @Override
1130 public FileEntry updateFileEntry(
1131 long userId, long fileEntryId, String sourceFileName,
1132 String mimeType, String title, String description, String changeLog,
1133 boolean majorVersion, InputStream is, long size,
1134 ServiceContext serviceContext)
1135 throws PortalException {
1136
1137 if (Validator.isNull(mimeType) ||
1138 mimeType.equals(ContentTypes.APPLICATION_OCTET_STREAM)) {
1139
1140 String extension = DLAppUtil.getExtension(title, sourceFileName);
1141
1142 if (size == 0) {
1143 mimeType = MimeTypesUtil.getExtensionContentType(extension);
1144 }
1145 else {
1146 File file = null;
1147
1148 try {
1149 file = FileUtil.createTempFile(is);
1150
1151 return updateFileEntry(
1152 userId, fileEntryId, sourceFileName, mimeType, title,
1153 description, changeLog, majorVersion, file,
1154 serviceContext);
1155 }
1156 catch (IOException ioe) {
1157 throw new SystemException(
1158 "Unable to write temporary file", ioe);
1159 }
1160 finally {
1161 FileUtil.delete(file);
1162 }
1163 }
1164 }
1165
1166 LocalRepository localRepository = getFileEntryLocalRepository(
1167 fileEntryId);
1168
1169 FileEntry fileEntry = localRepository.updateFileEntry(
1170 userId, fileEntryId, sourceFileName, mimeType, title, description,
1171 changeLog, majorVersion, is, size, serviceContext);
1172
1173 dlAppHelperLocalService.updateFileEntry(
1174 userId, fileEntry, null, fileEntry.getFileVersion(),
1175 serviceContext);
1176
1177 return fileEntry;
1178 }
1179
1180
1191 @Override
1192 public DLFileRank updateFileRank(
1193 long repositoryId, long companyId, long userId, long fileEntryId,
1194 ServiceContext serviceContext) {
1195
1196 return dlFileRankLocalService.updateFileRank(
1197 repositoryId, companyId, userId, fileEntryId, serviceContext);
1198 }
1199
1200
1215 @Override
1216 public FileShortcut updateFileShortcut(
1217 long userId, long fileShortcutId, long folderId, long toFileEntryId,
1218 ServiceContext serviceContext)
1219 throws PortalException {
1220
1221 LocalRepository localRepository = getFileShortcutLocalRepository(
1222 fileShortcutId);
1223
1224 return localRepository.updateFileShortcut(
1225 userId, fileShortcutId, folderId, toFileEntryId, serviceContext);
1226 }
1227
1228
1236 @Override
1237 public void updateFileShortcuts(
1238 long oldToFileEntryId, long newToFileEntryId)
1239 throws PortalException {
1240
1241 LocalRepository localRepository = getFileEntryLocalRepository(
1242 newToFileEntryId);
1243
1244 localRepository.updateFileShortcuts(oldToFileEntryId, newToFileEntryId);
1245 }
1246
1247
1251 @Deprecated
1252 @Override
1253 public void updateFileShortcuts(
1254 long toRepositoryId, long oldToFileEntryId, long newToFileEntryId)
1255 throws PortalException {
1256
1257 updateFileShortcuts(oldToFileEntryId, newToFileEntryId);
1258 }
1259
1260
1283 @Override
1284 public Folder updateFolder(
1285 long folderId, long parentFolderId, String name, String description,
1286 ServiceContext serviceContext)
1287 throws PortalException {
1288
1289 LocalRepository localRepository = getFolderLocalRepository(folderId);
1290
1291 Folder folder = localRepository.updateFolder(
1292 folderId, parentFolderId, name, description, serviceContext);
1293
1294 if (folderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
1295 dlAppHelperLocalService.updateFolder(
1296 serviceContext.getUserId(), folder, serviceContext);
1297 }
1298
1299 return folder;
1300 }
1301
1302 protected FileEntry copyFileEntry(
1303 long userId, LocalRepository toLocalRepository, FileEntry fileEntry,
1304 long newFolderId, ServiceContext serviceContext)
1305 throws PortalException {
1306
1307 List<FileVersion> fileVersions = fileEntry.getFileVersions(
1308 WorkflowConstants.STATUS_ANY);
1309
1310 FileVersion latestFileVersion = fileVersions.get(
1311 fileVersions.size() - 1);
1312
1313 FileEntry destinationFileEntry = toLocalRepository.addFileEntry(
1314 userId, newFolderId, fileEntry.getTitle(),
1315 latestFileVersion.getMimeType(), latestFileVersion.getTitle(),
1316 latestFileVersion.getDescription(), StringPool.BLANK,
1317 latestFileVersion.getContentStream(false),
1318 latestFileVersion.getSize(), serviceContext);
1319
1320 for (int i = fileVersions.size() - 2; i >= 0; i--) {
1321 FileVersion fileVersion = fileVersions.get(i);
1322
1323 FileVersion previousFileVersion = fileVersions.get(i + 1);
1324
1325 try {
1326 destinationFileEntry = toLocalRepository.updateFileEntry(
1327 userId, destinationFileEntry.getFileEntryId(),
1328 fileEntry.getTitle(), destinationFileEntry.getMimeType(),
1329 destinationFileEntry.getTitle(),
1330 destinationFileEntry.getDescription(), StringPool.BLANK,
1331 DLAppUtil.isMajorVersion(fileVersion, previousFileVersion),
1332 fileVersion.getContentStream(false), fileVersion.getSize(),
1333 serviceContext);
1334 }
1335 catch (PortalException pe) {
1336 toLocalRepository.deleteFileEntry(
1337 destinationFileEntry.getFileEntryId());
1338
1339 throw pe;
1340 }
1341 }
1342
1343 return destinationFileEntry;
1344 }
1345
1346 protected void deleteFileEntry(
1347 long oldFileEntryId, long newFileEntryId,
1348 LocalRepository fromLocalRepository,
1349 LocalRepository toLocalRepository)
1350 throws PortalException {
1351
1352 try {
1353 FileEntry fileEntry = fromLocalRepository.getFileEntry(
1354 oldFileEntryId);
1355
1356 fromLocalRepository.deleteFileEntry(oldFileEntryId);
1357
1358 dlAppHelperLocalService.deleteFileEntry(fileEntry);
1359 }
1360 catch (PortalException pe) {
1361 FileEntry fileEntry = toLocalRepository.getFileEntry(
1362 newFileEntryId);
1363
1364 toLocalRepository.deleteFileEntry(newFileEntryId);
1365
1366 dlAppHelperLocalService.deleteFileEntry(fileEntry);
1367
1368 throw pe;
1369 }
1370 }
1371
1372 protected void deleteRepository(LocalRepository localRepository)
1373 throws PortalException {
1374
1375 long repositoryId = localRepository.getRepositoryId();
1376
1377 dlAppHelperLocalService.deleteRepositoryFileEntries(repositoryId);
1378
1379 localRepository.deleteAll();
1380
1381 repositoryLocalService.deleteRepository(repositoryId);
1382 }
1383
1384 protected LocalRepository getFileEntryLocalRepository(long fileEntryId)
1385 throws PortalException {
1386
1387 try {
1388 return RepositoryProviderUtil.getFileEntryLocalRepository(
1389 fileEntryId);
1390 }
1391 catch (InvalidRepositoryIdException irie) {
1392 StringBundler sb = new StringBundler(3);
1393
1394 sb.append("No FileEntry exists with the key {fileEntryId=");
1395 sb.append(fileEntryId);
1396 sb.append("}");
1397
1398 throw new NoSuchFileEntryException(sb.toString(), irie);
1399 }
1400 }
1401
1402 protected LocalRepository getFileShortcutLocalRepository(
1403 long fileShortcutId)
1404 throws PortalException {
1405
1406 try {
1407 return RepositoryProviderUtil.getFileShortcutLocalRepository(
1408 fileShortcutId);
1409 }
1410 catch (InvalidRepositoryIdException irie) {
1411 StringBundler sb = new StringBundler(3);
1412
1413 sb.append("No FileShortcut exists with the key {fileShortcutId=");
1414 sb.append(fileShortcutId);
1415 sb.append("}");
1416
1417 throw new NoSuchFileShortcutException(sb.toString(), irie);
1418 }
1419 }
1420
1421 protected LocalRepository getFileVersionLocalRepository(long fileVersionId)
1422 throws PortalException {
1423
1424 try {
1425 return RepositoryProviderUtil.getFileVersionLocalRepository(
1426 fileVersionId);
1427 }
1428 catch (InvalidRepositoryIdException irie) {
1429 StringBundler sb = new StringBundler(3);
1430
1431 sb.append("No FileVersion exists with the key {fileVersionId=");
1432 sb.append(fileVersionId);
1433 sb.append("}");
1434
1435 throw new NoSuchFileVersionException(sb.toString(), irie);
1436 }
1437 }
1438
1439 protected LocalRepository getFolderLocalRepository(long folderId)
1440 throws PortalException {
1441
1442 try {
1443 return RepositoryProviderUtil.getFolderLocalRepository(folderId);
1444 }
1445 catch (InvalidRepositoryIdException irie) {
1446 StringBundler sb = new StringBundler(3);
1447
1448 sb.append("No Folder exists with the key {folderId=");
1449 sb.append(folderId);
1450 sb.append("}");
1451
1452 throw new NoSuchFolderException(sb.toString(), irie);
1453 }
1454 }
1455
1456 protected LocalRepository getFolderLocalRepository(
1457 long folderId, long groupId)
1458 throws PortalException {
1459
1460 if (folderId == DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
1461 return getLocalRepository(groupId);
1462 }
1463
1464 return getFolderLocalRepository(folderId);
1465 }
1466
1467 protected LocalRepository getLocalRepository(long repositoryId)
1468 throws PortalException {
1469
1470 try {
1471 return RepositoryProviderUtil.getLocalRepository(repositoryId);
1472 }
1473 catch (InvalidRepositoryIdException irie) {
1474 StringBundler sb = new StringBundler(3);
1475
1476 sb.append("No Group exists with the key {repositoryId=");
1477 sb.append(repositoryId);
1478 sb.append("}");
1479
1480 throw new NoSuchGroupException(sb.toString(), irie);
1481 }
1482 }
1483
1484 protected FileEntry moveFileEntries(
1485 long userId, long fileEntryId, long newFolderId,
1486 LocalRepository fromLocalRepository,
1487 LocalRepository toLocalRepository, ServiceContext serviceContext)
1488 throws PortalException {
1489
1490 FileEntry sourceFileEntry = fromLocalRepository.getFileEntry(
1491 fileEntryId);
1492
1493 FileEntry destinationFileEntry = copyFileEntry(
1494 userId, toLocalRepository, sourceFileEntry, newFolderId,
1495 serviceContext);
1496
1497 deleteFileEntry(
1498 fileEntryId, destinationFileEntry.getFileEntryId(),
1499 fromLocalRepository, toLocalRepository);
1500
1501 return destinationFileEntry;
1502 }
1503
1504 protected Folder moveFolders(
1505 long userId, long folderId, long parentFolderId,
1506 LocalRepository sourceLocalRepository,
1507 LocalRepository destinationLocalRepository,
1508 ServiceContext serviceContext)
1509 throws PortalException {
1510
1511 Folder sourceFolder = sourceLocalRepository.getFolder(folderId);
1512
1513 Folder destinationFolder = destinationLocalRepository.addFolder(
1514 userId, parentFolderId, sourceFolder.getName(),
1515 sourceFolder.getDescription(), serviceContext);
1516
1517 dlAppHelperLocalService.addFolder(
1518 userId, destinationFolder, serviceContext);
1519
1520 List<Object> foldersAndFileEntriesAndFileShortcuts =
1521 dlAppService.getFoldersAndFileEntriesAndFileShortcuts(
1522 sourceLocalRepository.getRepositoryId(), folderId,
1523 WorkflowConstants.STATUS_ANY, true, QueryUtil.ALL_POS,
1524 QueryUtil.ALL_POS);
1525
1526 try {
1527 for (Object folderAndFileEntryAndFileShortcut :
1528 foldersAndFileEntriesAndFileShortcuts) {
1529
1530 if (folderAndFileEntryAndFileShortcut instanceof FileEntry) {
1531 FileEntry fileEntry =
1532 (FileEntry)folderAndFileEntryAndFileShortcut;
1533
1534 copyFileEntry(
1535 userId, destinationLocalRepository, fileEntry,
1536 destinationFolder.getFolderId(), serviceContext);
1537 }
1538 else if (folderAndFileEntryAndFileShortcut instanceof Folder) {
1539 Folder folder = (Folder)folderAndFileEntryAndFileShortcut;
1540
1541 moveFolders(
1542 userId, folder.getFolderId(),
1543 destinationFolder.getFolderId(), sourceLocalRepository,
1544 destinationLocalRepository, serviceContext);
1545 }
1546 else if (folderAndFileEntryAndFileShortcut
1547 instanceof FileShortcut) {
1548
1549 if (destinationFolder.isSupportsShortcuts()) {
1550 FileShortcut fileShortcut =
1551 (FileShortcut)folderAndFileEntryAndFileShortcut;
1552
1553 destinationLocalRepository.addFileShortcut(
1554 userId, destinationFolder.getFolderId(),
1555 fileShortcut.getToFileEntryId(), serviceContext);
1556 }
1557 }
1558 }
1559 }
1560 catch (PortalException pe) {
1561 destinationLocalRepository.deleteFolder(
1562 destinationFolder.getFolderId());
1563
1564 throw pe;
1565 }
1566
1567 try {
1568 sourceLocalRepository.deleteFolder(folderId);
1569 }
1570 catch (PortalException pe) {
1571 destinationLocalRepository.deleteFolder(
1572 destinationFolder.getFolderId());
1573
1574 throw pe;
1575 }
1576
1577 return destinationFolder;
1578 }
1579
1580 }