001
014
015 package com.liferay.portlet.documentlibrary.service.impl;
016
017 import com.liferay.portal.NoSuchGroupException;
018 import com.liferay.portal.NoSuchRepositoryEntryException;
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.repository.InvalidRepositoryIdException;
024 import com.liferay.portal.kernel.repository.LocalRepository;
025 import com.liferay.portal.kernel.repository.model.FileEntry;
026 import com.liferay.portal.kernel.repository.model.FileVersion;
027 import com.liferay.portal.kernel.repository.model.Folder;
028 import com.liferay.portal.kernel.systemevent.SystemEventHierarchyEntryThreadLocal;
029 import com.liferay.portal.kernel.util.ArrayUtil;
030 import com.liferay.portal.kernel.util.ContentTypes;
031 import com.liferay.portal.kernel.util.FileUtil;
032 import com.liferay.portal.kernel.util.MimeTypesUtil;
033 import com.liferay.portal.kernel.util.StringBundler;
034 import com.liferay.portal.kernel.util.StringPool;
035 import com.liferay.portal.kernel.util.Validator;
036 import com.liferay.portal.kernel.workflow.WorkflowConstants;
037 import com.liferay.portal.model.Repository;
038 import com.liferay.portal.repository.liferayrepository.model.LiferayFolder;
039 import com.liferay.portal.service.ServiceContext;
040 import com.liferay.portlet.documentlibrary.NoSuchFileEntryException;
041 import com.liferay.portlet.documentlibrary.NoSuchFileVersionException;
042 import com.liferay.portlet.documentlibrary.NoSuchFolderException;
043 import com.liferay.portlet.documentlibrary.model.DLFileEntryType;
044 import com.liferay.portlet.documentlibrary.model.DLFileEntryTypeConstants;
045 import com.liferay.portlet.documentlibrary.model.DLFileRank;
046 import com.liferay.portlet.documentlibrary.model.DLFileShortcut;
047 import com.liferay.portlet.documentlibrary.model.DLFolder;
048 import com.liferay.portlet.documentlibrary.model.DLFolderConstants;
049 import com.liferay.portlet.documentlibrary.service.base.DLAppLocalServiceBaseImpl;
050 import com.liferay.portlet.documentlibrary.util.DLAppUtil;
051 import com.liferay.portlet.documentlibrary.util.DLImpl;
052 import com.liferay.portlet.documentlibrary.util.DLProcessorRegistryUtil;
053
054 import java.io.File;
055 import java.io.IOException;
056 import java.io.InputStream;
057
058 import java.util.List;
059
060
087 public class DLAppLocalServiceImpl extends DLAppLocalServiceBaseImpl {
088
089
122 @Override
123 public FileEntry addFileEntry(
124 long userId, long repositoryId, long folderId,
125 String sourceFileName, String mimeType, String title,
126 String description, String changeLog, byte[] bytes,
127 ServiceContext serviceContext)
128 throws PortalException, SystemException {
129
130 File file = null;
131
132 try {
133 if (ArrayUtil.isNotEmpty(bytes)) {
134 file = FileUtil.createTempFile(bytes);
135 }
136
137 return addFileEntry(
138 userId, repositoryId, folderId, sourceFileName, mimeType, title,
139 description, changeLog, file, serviceContext);
140 }
141 catch (IOException ioe) {
142 throw new SystemException("Unable to write temporary file", ioe);
143 }
144 finally {
145 FileUtil.delete(file);
146 }
147 }
148
149
183 @Override
184 public FileEntry addFileEntry(
185 long userId, long repositoryId, long folderId,
186 String sourceFileName, String mimeType, String title,
187 String description, String changeLog, File file,
188 ServiceContext serviceContext)
189 throws PortalException, SystemException {
190
191 if ((file == null) || !file.exists() || (file.length() == 0)) {
192 return addFileEntry(
193 userId, repositoryId, folderId, sourceFileName, mimeType, title,
194 description, changeLog, null, 0, serviceContext);
195 }
196
197 mimeType = DLAppUtil.getMimeType(sourceFileName, mimeType, title, file);
198
199 LocalRepository localRepository = getLocalRepository(repositoryId);
200
201 FileEntry fileEntry = localRepository.addFileEntry(
202 userId, folderId, sourceFileName, mimeType, title, description,
203 changeLog, file, serviceContext);
204
205 dlAppHelperLocalService.addFileEntry(
206 userId, fileEntry, fileEntry.getFileVersion(), serviceContext);
207
208 return fileEntry;
209 }
210
211
246 @Override
247 public FileEntry addFileEntry(
248 long userId, long repositoryId, long folderId,
249 String sourceFileName, String mimeType, String title,
250 String description, String changeLog, InputStream is, long size,
251 ServiceContext serviceContext)
252 throws PortalException, SystemException {
253
254 if (is == null) {
255 is = new UnsyncByteArrayInputStream(new byte[0]);
256 size = 0;
257 }
258
259 if (Validator.isNull(mimeType) ||
260 mimeType.equals(ContentTypes.APPLICATION_OCTET_STREAM)) {
261
262 String extension = DLAppUtil.getExtension(title, sourceFileName);
263
264 if (size == 0) {
265 mimeType = MimeTypesUtil.getExtensionContentType(extension);
266 }
267 else {
268 File file = null;
269
270 try {
271 file = FileUtil.createTempFile(is);
272
273 return addFileEntry(
274 userId, repositoryId, folderId, sourceFileName,
275 mimeType, title, description, changeLog, file,
276 serviceContext);
277 }
278 catch (IOException ioe) {
279 throw new SystemException(
280 "Unable to write temporary file", ioe);
281 }
282 finally {
283 FileUtil.delete(file);
284 }
285 }
286 }
287
288 LocalRepository localRepository = getLocalRepository(repositoryId);
289
290 FileEntry fileEntry = localRepository.addFileEntry(
291 userId, folderId, sourceFileName, mimeType, title, description,
292 changeLog, is, size, serviceContext);
293
294 dlAppHelperLocalService.addFileEntry(
295 userId, fileEntry, fileEntry.getFileVersion(), serviceContext);
296
297 return fileEntry;
298 }
299
300
312 @Override
313 public DLFileRank addFileRank(
314 long repositoryId, long companyId, long userId, long fileEntryId,
315 ServiceContext serviceContext)
316 throws SystemException {
317
318 return dlFileRankLocalService.addFileRank(
319 repositoryId, companyId, userId, fileEntryId, serviceContext);
320 }
321
322
338 @Override
339 public DLFileShortcut addFileShortcut(
340 long userId, long repositoryId, long folderId, long toFileEntryId,
341 ServiceContext serviceContext)
342 throws PortalException, SystemException {
343
344 return dlFileShortcutLocalService.addFileShortcut(
345 userId, repositoryId, folderId, toFileEntryId, serviceContext);
346 }
347
348
365 @Override
366 public Folder addFolder(
367 long userId, long repositoryId, long parentFolderId, String name,
368 String description, ServiceContext serviceContext)
369 throws PortalException, SystemException {
370
371 LocalRepository localRepository = getLocalRepository(repositoryId);
372
373 return localRepository.addFolder(
374 userId, parentFolderId, name, description, serviceContext);
375 }
376
377
385 @Override
386 public void deleteAll(long repositoryId)
387 throws PortalException, SystemException {
388
389 LocalRepository localRepository = getLocalRepository(repositoryId);
390
391 localRepository.deleteAll();
392 }
393
394
401 @Override
402 public void deleteFileEntry(long fileEntryId)
403 throws PortalException, SystemException {
404
405 LocalRepository localRepository = getFileEntryLocalRepository(
406 fileEntryId);
407
408 FileEntry fileEntry = localRepository.getFileEntry(fileEntryId);
409
410 dlAppHelperLocalService.deleteFileEntry(fileEntry);
411
412 SystemEventHierarchyEntryThreadLocal.push(FileEntry.class);
413
414 try {
415 localRepository.deleteFileEntry(fileEntryId);
416 }
417 finally {
418 SystemEventHierarchyEntryThreadLocal.pop(FileEntry.class);
419 }
420 }
421
422
429 @Override
430 public void deleteFileRanksByFileEntryId(long fileEntryId)
431 throws SystemException {
432
433 dlFileRankLocalService.deleteFileRanksByFileEntryId(fileEntryId);
434 }
435
436
443 @Override
444 public void deleteFileRanksByUserId(long userId) throws SystemException {
445 dlFileRankLocalService.deleteFileRanksByUserId(userId);
446 }
447
448
456 @Override
457 public void deleteFileShortcut(DLFileShortcut dlFileShortcut)
458 throws PortalException, SystemException {
459
460 dlFileShortcutLocalService.deleteFileShortcut(dlFileShortcut);
461 }
462
463
471 @Override
472 public void deleteFileShortcut(long fileShortcutId)
473 throws PortalException, SystemException {
474
475 dlFileShortcutLocalService.deleteFileShortcut(fileShortcutId);
476 }
477
478
487 @Override
488 public void deleteFileShortcuts(long toFileEntryId)
489 throws PortalException, SystemException {
490
491 dlFileShortcutLocalService.deleteFileShortcuts(toFileEntryId);
492 }
493
494
501 @Override
502 public void deleteFolder(long folderId)
503 throws PortalException, SystemException {
504
505 LocalRepository localRepository = getFolderLocalRepository(folderId);
506
507 localRepository.deleteFolder(folderId);
508 }
509
510
518 @Override
519 public FileEntry getFileEntry(long fileEntryId)
520 throws PortalException, SystemException {
521
522 LocalRepository localRepository = getFileEntryLocalRepository(
523 fileEntryId);
524
525 return localRepository.getFileEntry(fileEntryId);
526 }
527
528
538 @Override
539 public FileEntry getFileEntry(long groupId, long folderId, String title)
540 throws PortalException, SystemException {
541
542 try {
543 LocalRepository localRepository = getLocalRepository(groupId);
544
545 return localRepository.getFileEntry(folderId, title);
546 }
547 catch (NoSuchFileEntryException nsfee) {
548 }
549
550 LocalRepository localRepository = getFolderLocalRepository(folderId);
551
552 return localRepository.getFileEntry(folderId, title);
553 }
554
555
564 @Override
565 public FileEntry getFileEntryByUuidAndGroupId(String uuid, long groupId)
566 throws PortalException, SystemException {
567
568 try {
569 LocalRepository localRepository = getLocalRepository(groupId);
570
571 return localRepository.getFileEntryByUuid(uuid);
572 }
573 catch (NoSuchFileEntryException nsfee) {
574 }
575
576 List<com.liferay.portal.model.Repository> repositories =
577 repositoryPersistence.findByGroupId(groupId);
578
579 for (Repository repository : repositories) {
580 try {
581 LocalRepository localRepository = getLocalRepository(
582 repository.getRepositoryId());
583
584 return localRepository.getFileEntryByUuid(uuid);
585 }
586 catch (NoSuchFileEntryException nsfee) {
587 }
588 }
589
590 StringBundler msg = new StringBundler(6);
591
592 msg.append("No DLFileEntry exists with the key {");
593 msg.append("uuid=");
594 msg.append(uuid);
595 msg.append(", groupId=");
596 msg.append(groupId);
597 msg.append(StringPool.CLOSE_CURLY_BRACE);
598
599 throw new NoSuchFileEntryException(msg.toString());
600 }
601
602
611 @Override
612 public List<DLFileRank> getFileRanks(long repositoryId, long userId)
613 throws SystemException {
614
615 return dlFileRankLocalService.getFileRanks(repositoryId, userId);
616 }
617
618
627 @Override
628 public DLFileShortcut getFileShortcut(long fileShortcutId)
629 throws PortalException, SystemException {
630
631 return dlFileShortcutLocalService.getFileShortcut(fileShortcutId);
632 }
633
634
642 @Override
643 public FileVersion getFileVersion(long fileVersionId)
644 throws PortalException, SystemException {
645
646 LocalRepository localRepository = getFileVersionLocalRepository(
647 fileVersionId);
648
649 return localRepository.getFileVersion(fileVersionId);
650 }
651
652
660 @Override
661 public Folder getFolder(long folderId)
662 throws PortalException, SystemException {
663
664 LocalRepository localRepository = getFolderLocalRepository(folderId);
665
666 return localRepository.getFolder(folderId);
667 }
668
669
679 @Override
680 public Folder getFolder(long repositoryId, long parentFolderId, String name)
681 throws PortalException, SystemException {
682
683 LocalRepository localRepository = getLocalRepository(repositoryId);
684
685 return localRepository.getFolder(parentFolderId, name);
686 }
687
688
698 @Override
699 public Folder getMountFolder(long repositoryId)
700 throws PortalException, SystemException {
701
702 DLFolder dlFolder = dlFolderLocalService.getMountFolder(repositoryId);
703
704 return new LiferayFolder(dlFolder);
705 }
706
707
719 @Override
720 public FileEntry moveFileEntry(
721 long userId, long fileEntryId, long newFolderId,
722 ServiceContext serviceContext)
723 throws PortalException, SystemException {
724
725 SystemEventHierarchyEntryThreadLocal.push(FileEntry.class);
726
727 try {
728 LocalRepository fromLocalRepository = getFileEntryLocalRepository(
729 fileEntryId);
730 LocalRepository toLocalRepository = getFolderLocalRepository(
731 newFolderId, serviceContext.getScopeGroupId());
732
733 if (fromLocalRepository.getRepositoryId() ==
734 toLocalRepository.getRepositoryId()) {
735
736
737
738 return fromLocalRepository.moveFileEntry(
739 userId, fileEntryId, newFolderId, serviceContext);
740 }
741
742
743
744 return moveFileEntries(
745 userId, fileEntryId, newFolderId, fromLocalRepository,
746 toLocalRepository, serviceContext);
747 }
748 finally {
749 SystemEventHierarchyEntryThreadLocal.pop(FileEntry.class);
750 }
751 }
752
753
762 @Override
763 public FileEntry moveFileEntryToTrash(long userId, long fileEntryId)
764 throws PortalException, SystemException {
765
766 LocalRepository localRepository = getFileEntryLocalRepository(
767 fileEntryId);
768
769 FileEntry fileEntry = localRepository.getFileEntry(fileEntryId);
770
771 return dlAppHelperLocalService.moveFileEntryToTrash(userId, fileEntry);
772 }
773
774 @Override
775 public Folder moveFolder(
776 long userId, long folderId, long parentFolderId,
777 ServiceContext serviceContext)
778 throws PortalException, SystemException {
779
780 SystemEventHierarchyEntryThreadLocal.push(Folder.class);
781
782 try {
783 LocalRepository sourceLocalRepository = getFolderLocalRepository(
784 folderId);
785
786 LocalRepository destinationLocalRepository =
787 getFolderLocalRepository(
788 parentFolderId, serviceContext.getScopeGroupId());
789
790 if (parentFolderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
791 Folder toFolder = destinationLocalRepository.getFolder(
792 parentFolderId);
793
794 if (toFolder.isMountPoint()) {
795 destinationLocalRepository = getLocalRepository(
796 toFolder.getRepositoryId());
797 }
798 }
799
800 if (sourceLocalRepository.getRepositoryId() ==
801 destinationLocalRepository.getRepositoryId()) {
802
803
804
805 Folder folder = sourceLocalRepository.moveFolder(
806 userId, folderId, parentFolderId, serviceContext);
807
808 return folder;
809 }
810
811
812
813 return moveFolders(
814 userId, folderId, parentFolderId, sourceLocalRepository,
815 destinationLocalRepository, serviceContext);
816 }
817 finally {
818 SystemEventHierarchyEntryThreadLocal.pop(Folder.class);
819 }
820 }
821
822
830 @Override
831 public void restoreFileEntryFromTrash(long userId, long fileEntryId)
832 throws PortalException, SystemException {
833
834 LocalRepository localRepository = getFileEntryLocalRepository(
835 fileEntryId);
836
837 FileEntry fileEntry = localRepository.getFileEntry(fileEntryId);
838
839 dlAppHelperLocalService.restoreFileEntryFromTrash(userId, fileEntry);
840 }
841
842
852 @Override
853 public void subscribeFileEntryType(
854 long userId, long groupId, long fileEntryTypeId)
855 throws PortalException, SystemException {
856
857 if (fileEntryTypeId ==
858 DLFileEntryTypeConstants.FILE_ENTRY_TYPE_ID_BASIC_DOCUMENT) {
859
860 fileEntryTypeId = groupId;
861 }
862
863 subscriptionLocalService.addSubscription(
864 userId, groupId, DLFileEntryType.class.getName(), fileEntryTypeId);
865 }
866
867
877 @Override
878 public void subscribeFolder(long userId, long groupId, long folderId)
879 throws PortalException, SystemException {
880
881 if (folderId == DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
882 folderId = groupId;
883 }
884
885 subscriptionLocalService.addSubscription(
886 userId, groupId, Folder.class.getName(), folderId);
887 }
888
889
899 @Override
900 public void unsubscribeFileEntryType(
901 long userId, long groupId, long fileEntryTypeId)
902 throws PortalException, SystemException {
903
904 if (fileEntryTypeId ==
905 DLFileEntryTypeConstants.FILE_ENTRY_TYPE_ID_BASIC_DOCUMENT) {
906
907 fileEntryTypeId = groupId;
908 }
909
910 subscriptionLocalService.deleteSubscription(
911 userId, DLFileEntryType.class.getName(), fileEntryTypeId);
912 }
913
914
924 @Override
925 public void unsubscribeFolder(long userId, long groupId, long folderId)
926 throws PortalException, SystemException {
927
928 if (folderId == DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
929 folderId = groupId;
930 }
931
932 subscriptionLocalService.deleteSubscription(
933 userId, Folder.class.getName(), folderId);
934 }
935
936
949 @Override
950 public void updateAsset(
951 long userId, FileEntry fileEntry, FileVersion fileVersion,
952 long[] assetCategoryIds, String[] assetTagNames,
953 long[] assetLinkEntryIds)
954 throws PortalException, SystemException {
955
956 LocalRepository localRepository = getFileEntryLocalRepository(
957 fileEntry.getFileEntryId());
958
959 localRepository.updateAsset(
960 userId, fileEntry, fileVersion, assetCategoryIds, assetTagNames,
961 assetLinkEntryIds);
962 }
963
964
1000 @Override
1001 public FileEntry updateFileEntry(
1002 long userId, long fileEntryId, String sourceFileName,
1003 String mimeType, String title, String description, String changeLog,
1004 boolean majorVersion, byte[] bytes, ServiceContext serviceContext)
1005 throws PortalException, SystemException {
1006
1007 File file = null;
1008
1009 try {
1010 if (ArrayUtil.isNotEmpty(bytes)) {
1011 file = FileUtil.createTempFile(bytes);
1012 }
1013
1014 return updateFileEntry(
1015 userId, fileEntryId, sourceFileName, mimeType, title,
1016 description, changeLog, majorVersion, file, serviceContext);
1017 }
1018 catch (IOException ioe) {
1019 throw new SystemException("Unable to write temporary file", ioe);
1020 }
1021 finally {
1022 FileUtil.delete(file);
1023 }
1024 }
1025
1026
1063 @Override
1064 public FileEntry updateFileEntry(
1065 long userId, long fileEntryId, String sourceFileName,
1066 String mimeType, String title, String description, String changeLog,
1067 boolean majorVersion, File file, ServiceContext serviceContext)
1068 throws PortalException, SystemException {
1069
1070 if ((file == null) || !file.exists() || (file.length() == 0)) {
1071 return updateFileEntry(
1072 userId, fileEntryId, sourceFileName, mimeType, title,
1073 description, changeLog, majorVersion, null, 0, serviceContext);
1074 }
1075
1076 mimeType = DLAppUtil.getMimeType(sourceFileName, mimeType, title, file);
1077
1078 LocalRepository localRepository = getFileEntryLocalRepository(
1079 fileEntryId);
1080
1081 FileEntry fileEntry = localRepository.updateFileEntry(
1082 userId, fileEntryId, sourceFileName, mimeType, title, description,
1083 changeLog, majorVersion, file, serviceContext);
1084
1085 DLProcessorRegistryUtil.cleanUp(
1086 DLImpl.getLatestFileVersion(fileEntry, true));
1087
1088 dlAppHelperLocalService.updateFileEntry(
1089 userId, fileEntry, null, fileEntry.getFileVersion(),
1090 serviceContext);
1091
1092 return fileEntry;
1093 }
1094
1095
1132 @Override
1133 public FileEntry updateFileEntry(
1134 long userId, long fileEntryId, String sourceFileName,
1135 String mimeType, String title, String description, String changeLog,
1136 boolean majorVersion, InputStream is, long size,
1137 ServiceContext serviceContext)
1138 throws PortalException, SystemException {
1139
1140 if (Validator.isNull(mimeType) ||
1141 mimeType.equals(ContentTypes.APPLICATION_OCTET_STREAM)) {
1142
1143 String extension = DLAppUtil.getExtension(title, sourceFileName);
1144
1145 if (size == 0) {
1146 mimeType = MimeTypesUtil.getExtensionContentType(extension);
1147 }
1148 else {
1149 File file = null;
1150
1151 try {
1152 file = FileUtil.createTempFile(is);
1153
1154 return updateFileEntry(
1155 userId, fileEntryId, sourceFileName, mimeType, title,
1156 description, changeLog, majorVersion, file,
1157 serviceContext);
1158 }
1159 catch (IOException ioe) {
1160 throw new SystemException(
1161 "Unable to write temporary file", ioe);
1162 }
1163 finally {
1164 FileUtil.delete(file);
1165 }
1166 }
1167 }
1168
1169 LocalRepository localRepository = getFileEntryLocalRepository(
1170 fileEntryId);
1171
1172 FileEntry oldFileEntry = localRepository.getFileEntry(fileEntryId);
1173
1174 FileVersion oldFileVersion = oldFileEntry.getFileVersion();
1175
1176 FileEntry fileEntry = localRepository.updateFileEntry(
1177 userId, fileEntryId, sourceFileName, mimeType, title, description,
1178 changeLog, majorVersion, is, size, serviceContext);
1179
1180 if (is != null) {
1181 DLProcessorRegistryUtil.cleanUp(
1182 DLImpl.getLatestFileVersion(fileEntry, true));
1183
1184 oldFileVersion = null;
1185 }
1186
1187 dlAppHelperLocalService.updateFileEntry(
1188 userId, fileEntry, oldFileVersion, fileEntry.getFileVersion(),
1189 serviceContext);
1190
1191 return fileEntry;
1192 }
1193
1194
1206 @Override
1207 public DLFileRank updateFileRank(
1208 long repositoryId, long companyId, long userId, long fileEntryId,
1209 ServiceContext serviceContext)
1210 throws SystemException {
1211
1212 return dlFileRankLocalService.updateFileRank(
1213 repositoryId, companyId, userId, fileEntryId, serviceContext);
1214 }
1215
1216
1232 @Override
1233 public DLFileShortcut updateFileShortcut(
1234 long userId, long fileShortcutId, long folderId, long toFileEntryId,
1235 ServiceContext serviceContext)
1236 throws PortalException, SystemException {
1237
1238 return dlFileShortcutLocalService.updateFileShortcut(
1239 userId, fileShortcutId, folderId, toFileEntryId, serviceContext);
1240 }
1241
1242
1252 @Override
1253 public void updateFileShortcuts(
1254 long toRepositoryId, long oldToFileEntryId, long newToFileEntryId)
1255 throws SystemException {
1256
1257 dlFileShortcutLocalService.updateFileShortcuts(
1258 oldToFileEntryId, newToFileEntryId);
1259 }
1260
1261
1285 @Override
1286 public Folder updateFolder(
1287 long folderId, long parentFolderId, String name, String description,
1288 ServiceContext serviceContext)
1289 throws PortalException, SystemException {
1290
1291 LocalRepository localRepository = getFolderLocalRepository(folderId);
1292
1293 return localRepository.updateFolder(
1294 folderId, parentFolderId, name, description, serviceContext);
1295 }
1296
1297 protected FileEntry copyFileEntry(
1298 long userId, LocalRepository toLocalRepository, FileEntry fileEntry,
1299 long newFolderId, ServiceContext serviceContext)
1300 throws PortalException, SystemException {
1301
1302 List<FileVersion> fileVersions = fileEntry.getFileVersions(
1303 WorkflowConstants.STATUS_ANY);
1304
1305 FileVersion latestFileVersion = fileVersions.get(
1306 fileVersions.size() - 1);
1307
1308 FileEntry destinationFileEntry = toLocalRepository.addFileEntry(
1309 userId, newFolderId, fileEntry.getTitle(),
1310 latestFileVersion.getMimeType(), latestFileVersion.getTitle(),
1311 latestFileVersion.getDescription(), StringPool.BLANK,
1312 latestFileVersion.getContentStream(false),
1313 latestFileVersion.getSize(), serviceContext);
1314
1315 for (int i = fileVersions.size() - 2; i >= 0; i--) {
1316 FileVersion fileVersion = fileVersions.get(i);
1317
1318 FileVersion previousFileVersion = fileVersions.get(i + 1);
1319
1320 try {
1321 destinationFileEntry = toLocalRepository.updateFileEntry(
1322 userId, destinationFileEntry.getFileEntryId(),
1323 fileEntry.getTitle(), destinationFileEntry.getMimeType(),
1324 destinationFileEntry.getTitle(),
1325 destinationFileEntry.getDescription(), StringPool.BLANK,
1326 DLAppUtil.isMajorVersion(fileVersion, previousFileVersion),
1327 fileVersion.getContentStream(false), fileVersion.getSize(),
1328 serviceContext);
1329 }
1330 catch (PortalException pe) {
1331 toLocalRepository.deleteFileEntry(
1332 destinationFileEntry.getFileEntryId());
1333
1334 throw pe;
1335 }
1336 }
1337
1338 dlAppHelperLocalService.addFileEntry(
1339 userId, destinationFileEntry, destinationFileEntry.getFileVersion(),
1340 serviceContext);
1341
1342 return destinationFileEntry;
1343 }
1344
1345 protected void deleteFileEntry(
1346 long oldFileEntryId, long newFileEntryId,
1347 LocalRepository fromLocalRepository,
1348 LocalRepository toLocalRepository)
1349 throws PortalException, SystemException {
1350
1351 try {
1352 FileEntry fileEntry = fromLocalRepository.getFileEntry(
1353 oldFileEntryId);
1354
1355 fromLocalRepository.deleteFileEntry(oldFileEntryId);
1356
1357 dlAppHelperLocalService.deleteFileEntry(fileEntry);
1358 }
1359 catch (PortalException pe) {
1360 FileEntry fileEntry = toLocalRepository.getFileEntry(
1361 newFileEntryId);
1362
1363 toLocalRepository.deleteFileEntry(newFileEntryId);
1364
1365 dlAppHelperLocalService.deleteFileEntry(fileEntry);
1366
1367 throw pe;
1368 }
1369 }
1370
1371 protected LocalRepository getFileEntryLocalRepository(long fileEntryId)
1372 throws PortalException, SystemException {
1373
1374 try {
1375 return repositoryLocalService.getLocalRepositoryImpl(
1376 0, fileEntryId, 0);
1377 }
1378 catch (InvalidRepositoryIdException irie) {
1379 StringBundler sb = new StringBundler(3);
1380
1381 sb.append("No FileEntry exists with the key {fileEntryId=");
1382 sb.append(fileEntryId);
1383 sb.append("}");
1384
1385 throw new NoSuchFileEntryException(sb.toString(), irie);
1386 }
1387 }
1388
1389 protected LocalRepository getFileVersionLocalRepository(long fileVersionId)
1390 throws PortalException, SystemException {
1391
1392 try {
1393 return repositoryLocalService.getLocalRepositoryImpl(
1394 0, 0, fileVersionId);
1395 }
1396 catch (InvalidRepositoryIdException irie) {
1397 StringBundler sb = new StringBundler(3);
1398
1399 sb.append("No FileVersion exists with the key {fileVersionId=");
1400 sb.append(fileVersionId);
1401 sb.append("}");
1402
1403 throw new NoSuchFileVersionException(sb.toString(), irie);
1404 }
1405 }
1406
1407 protected LocalRepository getFolderLocalRepository(long folderId)
1408 throws PortalException, SystemException {
1409
1410 try {
1411 return repositoryLocalService.getLocalRepositoryImpl(
1412 folderId, 0, 0);
1413 }
1414 catch (Exception e) {
1415 if (e instanceof InvalidRepositoryIdException ||
1416 e instanceof NoSuchRepositoryEntryException) {
1417
1418 StringBundler sb = new StringBundler(3);
1419
1420 sb.append("No Folder exists with the key {folderId=");
1421 sb.append(folderId);
1422 sb.append("}");
1423
1424 throw new NoSuchFolderException(sb.toString(), e);
1425 }
1426 else {
1427 throw new PortalException(e);
1428 }
1429 }
1430 }
1431
1432 protected LocalRepository getFolderLocalRepository(
1433 long folderId, long groupId)
1434 throws PortalException, SystemException {
1435
1436 LocalRepository localRepository = null;
1437
1438 if (folderId == DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
1439 localRepository = getLocalRepository(groupId);
1440 }
1441 else {
1442 localRepository = getFolderLocalRepository(folderId);
1443 }
1444
1445 return localRepository;
1446 }
1447
1448 protected LocalRepository getLocalRepository(long repositoryId)
1449 throws PortalException, SystemException {
1450
1451 try {
1452 return repositoryLocalService.getLocalRepositoryImpl(repositoryId);
1453 }
1454 catch (InvalidRepositoryIdException irie) {
1455 StringBundler sb = new StringBundler(3);
1456
1457 sb.append("No Group exists with the key {repositoryId=");
1458 sb.append(repositoryId);
1459 sb.append("}");
1460
1461 throw new NoSuchGroupException(sb.toString(), irie);
1462 }
1463 }
1464
1465 protected FileEntry moveFileEntries(
1466 long userId, long fileEntryId, long newFolderId,
1467 LocalRepository fromLocalRepository,
1468 LocalRepository toLocalRepository, ServiceContext serviceContext)
1469 throws PortalException, SystemException {
1470
1471 FileEntry sourceFileEntry = fromLocalRepository.getFileEntry(
1472 fileEntryId);
1473
1474 FileEntry destinationFileEntry = copyFileEntry(
1475 userId, toLocalRepository, sourceFileEntry, newFolderId,
1476 serviceContext);
1477
1478 deleteFileEntry(
1479 fileEntryId, destinationFileEntry.getFileEntryId(),
1480 fromLocalRepository, toLocalRepository);
1481
1482 return destinationFileEntry;
1483 }
1484
1485 protected Folder moveFolders(
1486 long userId, long folderId, long parentFolderId,
1487 LocalRepository sourceLocalRepository,
1488 LocalRepository destinationLocalRepository,
1489 ServiceContext serviceContext)
1490 throws PortalException, SystemException {
1491
1492 Folder sourceFolder = sourceLocalRepository.getFolder(folderId);
1493
1494 Folder destinationFolder = destinationLocalRepository.addFolder(
1495 userId, parentFolderId, sourceFolder.getName(),
1496 sourceFolder.getDescription(), serviceContext);
1497
1498 List<Object> foldersAndFileEntriesAndFileShortcuts =
1499 dlAppService.getFoldersAndFileEntriesAndFileShortcuts(
1500 sourceLocalRepository.getRepositoryId(), folderId,
1501 WorkflowConstants.STATUS_ANY, true, QueryUtil.ALL_POS,
1502 QueryUtil.ALL_POS);
1503
1504 try {
1505 for (Object folderAndFileEntryAndFileShortcut :
1506 foldersAndFileEntriesAndFileShortcuts) {
1507
1508 if (folderAndFileEntryAndFileShortcut instanceof FileEntry) {
1509 FileEntry fileEntry =
1510 (FileEntry)folderAndFileEntryAndFileShortcut;
1511
1512 copyFileEntry(
1513 userId, destinationLocalRepository, fileEntry,
1514 destinationFolder.getFolderId(), serviceContext);
1515 }
1516 else if (folderAndFileEntryAndFileShortcut instanceof Folder) {
1517 Folder folder = (Folder)folderAndFileEntryAndFileShortcut;
1518
1519 moveFolders(
1520 userId, folder.getFolderId(),
1521 destinationFolder.getFolderId(), sourceLocalRepository,
1522 destinationLocalRepository, serviceContext);
1523 }
1524 else if (folderAndFileEntryAndFileShortcut
1525 instanceof DLFileShortcut) {
1526
1527 if (destinationFolder.isSupportsShortcuts()) {
1528 DLFileShortcut dlFileShorcut =
1529 (DLFileShortcut)folderAndFileEntryAndFileShortcut;
1530
1531 dlFileShortcutLocalService.addFileShortcut(
1532 userId, dlFileShorcut.getGroupId(),
1533 destinationFolder.getFolderId(),
1534 dlFileShorcut.getToFileEntryId(), serviceContext);
1535 }
1536 }
1537 }
1538 }
1539 catch (PortalException pe) {
1540 destinationLocalRepository.deleteFolder(
1541 destinationFolder.getFolderId());
1542
1543 throw pe;
1544 }
1545
1546 try {
1547 sourceLocalRepository.deleteFolder(folderId);
1548 }
1549 catch (PortalException pe) {
1550 destinationLocalRepository.deleteFolder(
1551 destinationFolder.getFolderId());
1552
1553 throw pe;
1554 }
1555
1556 return destinationFolder;
1557 }
1558
1559 }