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.model.FileEntry;
025 import com.liferay.portal.kernel.repository.model.FileVersion;
026 import com.liferay.portal.kernel.repository.model.Folder;
027 import com.liferay.portal.kernel.util.ArrayUtil;
028 import com.liferay.portal.kernel.util.ContentTypes;
029 import com.liferay.portal.kernel.util.FileUtil;
030 import com.liferay.portal.kernel.util.MimeTypesUtil;
031 import com.liferay.portal.kernel.util.StringBundler;
032 import com.liferay.portal.kernel.util.StringPool;
033 import com.liferay.portal.kernel.util.Validator;
034 import com.liferay.portal.kernel.workflow.WorkflowConstants;
035 import com.liferay.portal.model.Repository;
036 import com.liferay.portal.repository.liferayrepository.model.LiferayFolder;
037 import com.liferay.portal.service.ServiceContext;
038 import com.liferay.portlet.documentlibrary.NoSuchFileEntryException;
039 import com.liferay.portlet.documentlibrary.NoSuchFileVersionException;
040 import com.liferay.portlet.documentlibrary.NoSuchFolderException;
041 import com.liferay.portlet.documentlibrary.model.DLFileEntryType;
042 import com.liferay.portlet.documentlibrary.model.DLFileEntryTypeConstants;
043 import com.liferay.portlet.documentlibrary.model.DLFileRank;
044 import com.liferay.portlet.documentlibrary.model.DLFileShortcut;
045 import com.liferay.portlet.documentlibrary.model.DLFolder;
046 import com.liferay.portlet.documentlibrary.model.DLFolderConstants;
047 import com.liferay.portlet.documentlibrary.service.base.DLAppLocalServiceBaseImpl;
048 import com.liferay.portlet.documentlibrary.util.DLAppUtil;
049 import com.liferay.portlet.documentlibrary.util.DLProcessorRegistryUtil;
050
051 import java.io.File;
052 import java.io.IOException;
053 import java.io.InputStream;
054
055 import java.util.List;
056
057
084 public class DLAppLocalServiceImpl extends DLAppLocalServiceBaseImpl {
085
086
119 @Override
120 public FileEntry addFileEntry(
121 long userId, long repositoryId, long folderId,
122 String sourceFileName, String mimeType, String title,
123 String description, String changeLog, byte[] bytes,
124 ServiceContext serviceContext)
125 throws PortalException, SystemException {
126
127 File file = null;
128
129 try {
130 if (ArrayUtil.isNotEmpty(bytes)) {
131 file = FileUtil.createTempFile(bytes);
132 }
133
134 return addFileEntry(
135 userId, repositoryId, folderId, sourceFileName, mimeType, title,
136 description, changeLog, file, serviceContext);
137 }
138 catch (IOException ioe) {
139 throw new SystemException("Unable to write temporary file", ioe);
140 }
141 finally {
142 FileUtil.delete(file);
143 }
144 }
145
146
180 @Override
181 public FileEntry addFileEntry(
182 long userId, long repositoryId, long folderId,
183 String sourceFileName, String mimeType, String title,
184 String description, String changeLog, File file,
185 ServiceContext serviceContext)
186 throws PortalException, SystemException {
187
188 if ((file == null) || !file.exists() || (file.length() == 0)) {
189 return addFileEntry(
190 userId, repositoryId, folderId, sourceFileName, mimeType, title,
191 description, changeLog, null, 0, serviceContext);
192 }
193
194 mimeType = DLAppUtil.getMimeType(sourceFileName, mimeType, title, file);
195
196 LocalRepository localRepository = getLocalRepository(repositoryId);
197
198 FileEntry fileEntry = localRepository.addFileEntry(
199 userId, folderId, sourceFileName, mimeType, title, description,
200 changeLog, file, serviceContext);
201
202 dlAppHelperLocalService.addFileEntry(
203 userId, fileEntry, fileEntry.getFileVersion(), serviceContext);
204
205 return fileEntry;
206 }
207
208
243 @Override
244 public FileEntry addFileEntry(
245 long userId, long repositoryId, long folderId,
246 String sourceFileName, String mimeType, String title,
247 String description, String changeLog, InputStream is, long size,
248 ServiceContext serviceContext)
249 throws PortalException, SystemException {
250
251 if (is == null) {
252 is = new UnsyncByteArrayInputStream(new byte[0]);
253 size = 0;
254 }
255
256 if (Validator.isNull(mimeType) ||
257 mimeType.equals(ContentTypes.APPLICATION_OCTET_STREAM)) {
258
259 String extension = DLAppUtil.getExtension(title, sourceFileName);
260
261 if (size == 0) {
262 mimeType = MimeTypesUtil.getExtensionContentType(extension);
263 }
264 else {
265 File file = null;
266
267 try {
268 file = FileUtil.createTempFile(is);
269
270 return addFileEntry(
271 userId, repositoryId, folderId, sourceFileName,
272 mimeType, title, description, changeLog, file,
273 serviceContext);
274 }
275 catch (IOException ioe) {
276 throw new SystemException(
277 "Unable to write temporary file", ioe);
278 }
279 finally {
280 FileUtil.delete(file);
281 }
282 }
283 }
284
285 LocalRepository localRepository = getLocalRepository(repositoryId);
286
287 FileEntry fileEntry = localRepository.addFileEntry(
288 userId, folderId, sourceFileName, mimeType, title, description,
289 changeLog, is, size, serviceContext);
290
291 dlAppHelperLocalService.addFileEntry(
292 userId, fileEntry, fileEntry.getFileVersion(), serviceContext);
293
294 return fileEntry;
295 }
296
297
309 @Override
310 public DLFileRank addFileRank(
311 long repositoryId, long companyId, long userId, long fileEntryId,
312 ServiceContext serviceContext)
313 throws SystemException {
314
315 return dlFileRankLocalService.addFileRank(
316 repositoryId, companyId, userId, fileEntryId, serviceContext);
317 }
318
319
335 @Override
336 public DLFileShortcut addFileShortcut(
337 long userId, long repositoryId, long folderId, long toFileEntryId,
338 ServiceContext serviceContext)
339 throws PortalException, SystemException {
340
341 return dlFileShortcutLocalService.addFileShortcut(
342 userId, repositoryId, folderId, toFileEntryId, serviceContext);
343 }
344
345
362 @Override
363 public Folder addFolder(
364 long userId, long repositoryId, long parentFolderId, String name,
365 String description, ServiceContext serviceContext)
366 throws PortalException, SystemException {
367
368 LocalRepository localRepository = getLocalRepository(repositoryId);
369
370 return localRepository.addFolder(
371 userId, parentFolderId, name, description, serviceContext);
372 }
373
374
382 @Override
383 public void deleteAll(long repositoryId)
384 throws PortalException, SystemException {
385
386 LocalRepository localRepository = getLocalRepository(repositoryId);
387
388 localRepository.deleteAll();
389 }
390
391
398 @Override
399 public void deleteFileEntry(long fileEntryId)
400 throws PortalException, SystemException {
401
402 LocalRepository localRepository = getFileEntryLocalRepository(
403 fileEntryId);
404
405 FileEntry fileEntry = localRepository.getFileEntry(fileEntryId);
406
407 dlAppHelperLocalService.deleteFileEntry(fileEntry);
408
409 localRepository.deleteFileEntry(fileEntryId);
410 }
411
412
419 @Override
420 public void deleteFileRanksByFileEntryId(long fileEntryId)
421 throws SystemException {
422
423 dlFileRankLocalService.deleteFileRanksByFileEntryId(fileEntryId);
424 }
425
426
433 @Override
434 public void deleteFileRanksByUserId(long userId) throws SystemException {
435 dlFileRankLocalService.deleteFileRanksByUserId(userId);
436 }
437
438
446 @Override
447 public void deleteFileShortcut(DLFileShortcut dlFileShortcut)
448 throws PortalException, SystemException {
449
450 dlFileShortcutLocalService.deleteFileShortcut(dlFileShortcut);
451 }
452
453
461 @Override
462 public void deleteFileShortcut(long fileShortcutId)
463 throws PortalException, SystemException {
464
465 dlFileShortcutLocalService.deleteFileShortcut(fileShortcutId);
466 }
467
468
477 @Override
478 public void deleteFileShortcuts(long toFileEntryId)
479 throws PortalException, SystemException {
480
481 dlFileShortcutLocalService.deleteFileShortcuts(toFileEntryId);
482 }
483
484
491 @Override
492 public void deleteFolder(long folderId)
493 throws PortalException, SystemException {
494
495 LocalRepository localRepository = getFolderLocalRepository(folderId);
496
497 localRepository.deleteFolder(folderId);
498 }
499
500
508 @Override
509 public FileEntry getFileEntry(long fileEntryId)
510 throws PortalException, SystemException {
511
512 LocalRepository localRepository = getFileEntryLocalRepository(
513 fileEntryId);
514
515 return localRepository.getFileEntry(fileEntryId);
516 }
517
518
528 @Override
529 public FileEntry getFileEntry(long groupId, long folderId, String title)
530 throws PortalException, SystemException {
531
532 try {
533 LocalRepository localRepository = getLocalRepository(groupId);
534
535 return localRepository.getFileEntry(folderId, title);
536 }
537 catch (NoSuchFileEntryException nsfee) {
538 }
539
540 LocalRepository localRepository = getFolderLocalRepository(folderId);
541
542 return localRepository.getFileEntry(folderId, title);
543 }
544
545
554 @Override
555 public FileEntry getFileEntryByUuidAndGroupId(String uuid, long groupId)
556 throws PortalException, SystemException {
557
558 try {
559 LocalRepository localRepository = getLocalRepository(groupId);
560
561 return localRepository.getFileEntryByUuid(uuid);
562 }
563 catch (NoSuchFileEntryException nsfee) {
564 }
565
566 List<com.liferay.portal.model.Repository> repositories =
567 repositoryPersistence.findByGroupId(groupId);
568
569 for (Repository repository : repositories) {
570 try {
571 LocalRepository localRepository = getLocalRepository(
572 repository.getRepositoryId());
573
574 return localRepository.getFileEntryByUuid(uuid);
575 }
576 catch (NoSuchFileEntryException nsfee) {
577 }
578 }
579
580 StringBundler msg = new StringBundler(6);
581
582 msg.append("No DLFileEntry exists with the key {");
583 msg.append("uuid=");
584 msg.append(uuid);
585 msg.append(", groupId=");
586 msg.append(groupId);
587 msg.append(StringPool.CLOSE_CURLY_BRACE);
588
589 throw new NoSuchFileEntryException(msg.toString());
590 }
591
592
601 @Override
602 public List<DLFileRank> getFileRanks(long repositoryId, long userId)
603 throws SystemException {
604
605 return dlFileRankLocalService.getFileRanks(repositoryId, userId);
606 }
607
608
617 @Override
618 public DLFileShortcut getFileShortcut(long fileShortcutId)
619 throws PortalException, SystemException {
620
621 return dlFileShortcutLocalService.getFileShortcut(fileShortcutId);
622 }
623
624
632 @Override
633 public FileVersion getFileVersion(long fileVersionId)
634 throws PortalException, SystemException {
635
636 LocalRepository localRepository = getFileVersionLocalRepository(
637 fileVersionId);
638
639 return localRepository.getFileVersion(fileVersionId);
640 }
641
642
650 @Override
651 public Folder getFolder(long folderId)
652 throws PortalException, SystemException {
653
654 LocalRepository localRepository = getFolderLocalRepository(folderId);
655
656 return localRepository.getFolder(folderId);
657 }
658
659
669 @Override
670 public Folder getFolder(long repositoryId, long parentFolderId, String name)
671 throws PortalException, SystemException {
672
673 LocalRepository localRepository = getLocalRepository(repositoryId);
674
675 return localRepository.getFolder(parentFolderId, name);
676 }
677
678
688 @Override
689 public Folder getMountFolder(long repositoryId)
690 throws PortalException, SystemException {
691
692 DLFolder dlFolder = dlFolderLocalService.getMountFolder(repositoryId);
693
694 return new LiferayFolder(dlFolder);
695 }
696
697
709 @Override
710 public FileEntry moveFileEntry(
711 long userId, long fileEntryId, long newFolderId,
712 ServiceContext serviceContext)
713 throws PortalException, SystemException {
714
715 LocalRepository fromLocalRepository = getFileEntryLocalRepository(
716 fileEntryId);
717 LocalRepository toLocalRepository = getFolderLocalRepository(
718 newFolderId, serviceContext.getScopeGroupId());
719
720 if (fromLocalRepository.getRepositoryId() ==
721 toLocalRepository.getRepositoryId()) {
722
723
724
725 return fromLocalRepository.moveFileEntry(
726 userId, fileEntryId, newFolderId, serviceContext);
727 }
728
729
730
731 return moveFileEntries(
732 userId, fileEntryId, newFolderId, fromLocalRepository,
733 toLocalRepository, serviceContext);
734 }
735
736
745 @Override
746 public FileEntry moveFileEntryToTrash(long userId, long fileEntryId)
747 throws PortalException, SystemException {
748
749 LocalRepository localRepository = getFileEntryLocalRepository(
750 fileEntryId);
751
752 FileEntry fileEntry = localRepository.getFileEntry(fileEntryId);
753
754 return dlAppHelperLocalService.moveFileEntryToTrash(userId, fileEntry);
755 }
756
757 @Override
758 public Folder moveFolder(
759 long userId, long folderId, long parentFolderId,
760 ServiceContext serviceContext)
761 throws PortalException, SystemException {
762
763 LocalRepository sourceLocalRepository = getFolderLocalRepository(
764 folderId);
765
766 LocalRepository destinationLocalRepository = getFolderLocalRepository(
767 parentFolderId, serviceContext.getScopeGroupId());
768
769 if (parentFolderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
770 Folder toFolder = destinationLocalRepository.getFolder(
771 parentFolderId);
772
773 if (toFolder.isMountPoint()) {
774 destinationLocalRepository = getLocalRepository(
775 toFolder.getRepositoryId());
776 }
777 }
778
779 if (sourceLocalRepository.getRepositoryId() ==
780 destinationLocalRepository.getRepositoryId()) {
781
782
783
784 Folder folder = sourceLocalRepository.moveFolder(
785 userId, folderId, parentFolderId, serviceContext);
786
787 return folder;
788 }
789
790
791
792 return moveFolders(
793 userId, folderId, parentFolderId, sourceLocalRepository,
794 destinationLocalRepository, serviceContext);
795 }
796
797
805 @Override
806 public void restoreFileEntryFromTrash(long userId, long fileEntryId)
807 throws PortalException, SystemException {
808
809 LocalRepository localRepository = getFileEntryLocalRepository(
810 fileEntryId);
811
812 FileEntry fileEntry = localRepository.getFileEntry(fileEntryId);
813
814 dlAppHelperLocalService.restoreFileEntryFromTrash(userId, fileEntry);
815 }
816
817
827 @Override
828 public void subscribeFileEntryType(
829 long userId, long groupId, long fileEntryTypeId)
830 throws PortalException, SystemException {
831
832 if (fileEntryTypeId ==
833 DLFileEntryTypeConstants.FILE_ENTRY_TYPE_ID_BASIC_DOCUMENT) {
834
835 fileEntryTypeId = groupId;
836 }
837
838 subscriptionLocalService.addSubscription(
839 userId, groupId, DLFileEntryType.class.getName(), fileEntryTypeId);
840 }
841
842
852 @Override
853 public void subscribeFolder(long userId, long groupId, long folderId)
854 throws PortalException, SystemException {
855
856 if (folderId == DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
857 folderId = groupId;
858 }
859
860 subscriptionLocalService.addSubscription(
861 userId, groupId, Folder.class.getName(), folderId);
862 }
863
864
874 @Override
875 public void unsubscribeFileEntryType(
876 long userId, long groupId, long fileEntryTypeId)
877 throws PortalException, SystemException {
878
879 if (fileEntryTypeId ==
880 DLFileEntryTypeConstants.FILE_ENTRY_TYPE_ID_BASIC_DOCUMENT) {
881
882 fileEntryTypeId = groupId;
883 }
884
885 subscriptionLocalService.deleteSubscription(
886 userId, DLFileEntryType.class.getName(), fileEntryTypeId);
887 }
888
889
899 @Override
900 public void unsubscribeFolder(long userId, long groupId, long folderId)
901 throws PortalException, SystemException {
902
903 if (folderId == DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
904 folderId = groupId;
905 }
906
907 subscriptionLocalService.deleteSubscription(
908 userId, Folder.class.getName(), folderId);
909 }
910
911
924 @Override
925 public void updateAsset(
926 long userId, FileEntry fileEntry, FileVersion fileVersion,
927 long[] assetCategoryIds, String[] assetTagNames,
928 long[] assetLinkEntryIds)
929 throws PortalException, SystemException {
930
931 LocalRepository localRepository = getFileEntryLocalRepository(
932 fileEntry.getFileEntryId());
933
934 localRepository.updateAsset(
935 userId, fileEntry, fileVersion, assetCategoryIds, assetTagNames,
936 assetLinkEntryIds);
937 }
938
939
975 @Override
976 public FileEntry updateFileEntry(
977 long userId, long fileEntryId, String sourceFileName,
978 String mimeType, String title, String description, String changeLog,
979 boolean majorVersion, byte[] bytes, ServiceContext serviceContext)
980 throws PortalException, SystemException {
981
982 File file = null;
983
984 try {
985 if (ArrayUtil.isNotEmpty(bytes)) {
986 file = FileUtil.createTempFile(bytes);
987 }
988
989 return updateFileEntry(
990 userId, fileEntryId, sourceFileName, mimeType, title,
991 description, changeLog, majorVersion, file, serviceContext);
992 }
993 catch (IOException ioe) {
994 throw new SystemException("Unable to write temporary file", ioe);
995 }
996 finally {
997 FileUtil.delete(file);
998 }
999 }
1000
1001
1038 @Override
1039 public FileEntry updateFileEntry(
1040 long userId, long fileEntryId, String sourceFileName,
1041 String mimeType, String title, String description, String changeLog,
1042 boolean majorVersion, File file, ServiceContext serviceContext)
1043 throws PortalException, SystemException {
1044
1045 if ((file == null) || !file.exists() || (file.length() == 0)) {
1046 return updateFileEntry(
1047 userId, fileEntryId, sourceFileName, mimeType, title,
1048 description, changeLog, majorVersion, null, 0, serviceContext);
1049 }
1050
1051 mimeType = DLAppUtil.getMimeType(sourceFileName, mimeType, title, file);
1052
1053 LocalRepository localRepository = getFileEntryLocalRepository(
1054 fileEntryId);
1055
1056 FileEntry fileEntry = localRepository.updateFileEntry(
1057 userId, fileEntryId, sourceFileName, mimeType, title, description,
1058 changeLog, majorVersion, file, serviceContext);
1059
1060 DLProcessorRegistryUtil.cleanUp(fileEntry.getLatestFileVersion());
1061
1062 dlAppHelperLocalService.updateFileEntry(
1063 userId, fileEntry, null, fileEntry.getFileVersion(),
1064 serviceContext);
1065
1066 return fileEntry;
1067 }
1068
1069
1106 @Override
1107 public FileEntry updateFileEntry(
1108 long userId, long fileEntryId, String sourceFileName,
1109 String mimeType, String title, String description, String changeLog,
1110 boolean majorVersion, InputStream is, long size,
1111 ServiceContext serviceContext)
1112 throws PortalException, SystemException {
1113
1114 if (Validator.isNull(mimeType) ||
1115 mimeType.equals(ContentTypes.APPLICATION_OCTET_STREAM)) {
1116
1117 String extension = DLAppUtil.getExtension(title, sourceFileName);
1118
1119 if (size == 0) {
1120 mimeType = MimeTypesUtil.getExtensionContentType(extension);
1121 }
1122 else {
1123 File file = null;
1124
1125 try {
1126 file = FileUtil.createTempFile(is);
1127
1128 return updateFileEntry(
1129 userId, fileEntryId, sourceFileName, mimeType, title,
1130 description, changeLog, majorVersion, file,
1131 serviceContext);
1132 }
1133 catch (IOException ioe) {
1134 throw new SystemException(
1135 "Unable to write temporary file", ioe);
1136 }
1137 finally {
1138 FileUtil.delete(file);
1139 }
1140 }
1141 }
1142
1143 LocalRepository localRepository = getFileEntryLocalRepository(
1144 fileEntryId);
1145
1146 FileEntry oldFileEntry = localRepository.getFileEntry(fileEntryId);
1147
1148 FileVersion oldFileVersion = oldFileEntry.getFileVersion();
1149
1150 FileEntry fileEntry = localRepository.updateFileEntry(
1151 userId, fileEntryId, sourceFileName, mimeType, title, description,
1152 changeLog, majorVersion, is, size, serviceContext);
1153
1154 if (is != null) {
1155 DLProcessorRegistryUtil.cleanUp(fileEntry.getLatestFileVersion());
1156
1157 oldFileVersion = null;
1158 }
1159
1160 dlAppHelperLocalService.updateFileEntry(
1161 userId, fileEntry, oldFileVersion, fileEntry.getFileVersion(),
1162 serviceContext);
1163
1164 return fileEntry;
1165 }
1166
1167
1179 @Override
1180 public DLFileRank updateFileRank(
1181 long repositoryId, long companyId, long userId, long fileEntryId,
1182 ServiceContext serviceContext)
1183 throws SystemException {
1184
1185 return dlFileRankLocalService.updateFileRank(
1186 repositoryId, companyId, userId, fileEntryId, serviceContext);
1187 }
1188
1189
1205 @Override
1206 public DLFileShortcut updateFileShortcut(
1207 long userId, long fileShortcutId, long folderId, long toFileEntryId,
1208 ServiceContext serviceContext)
1209 throws PortalException, SystemException {
1210
1211 return dlFileShortcutLocalService.updateFileShortcut(
1212 userId, fileShortcutId, folderId, toFileEntryId, serviceContext);
1213 }
1214
1215
1225 @Override
1226 public void updateFileShortcuts(
1227 long toRepositoryId, long oldToFileEntryId, long newToFileEntryId)
1228 throws SystemException {
1229
1230 dlFileShortcutLocalService.updateFileShortcuts(
1231 oldToFileEntryId, newToFileEntryId);
1232 }
1233
1234
1258 @Override
1259 public Folder updateFolder(
1260 long folderId, long parentFolderId, String name, String description,
1261 ServiceContext serviceContext)
1262 throws PortalException, SystemException {
1263
1264 LocalRepository localRepository = getFolderLocalRepository(folderId);
1265
1266 return localRepository.updateFolder(
1267 folderId, parentFolderId, name, description, serviceContext);
1268 }
1269
1270 protected FileEntry copyFileEntry(
1271 long userId, LocalRepository toLocalRepository, FileEntry fileEntry,
1272 long newFolderId, ServiceContext serviceContext)
1273 throws PortalException, SystemException {
1274
1275 List<FileVersion> fileVersions = fileEntry.getFileVersions(
1276 WorkflowConstants.STATUS_ANY);
1277
1278 FileVersion latestFileVersion = fileVersions.get(
1279 fileVersions.size() - 1);
1280
1281 FileEntry destinationFileEntry = toLocalRepository.addFileEntry(
1282 userId, newFolderId, fileEntry.getTitle(),
1283 latestFileVersion.getMimeType(), latestFileVersion.getTitle(),
1284 latestFileVersion.getDescription(), StringPool.BLANK,
1285 latestFileVersion.getContentStream(false),
1286 latestFileVersion.getSize(), serviceContext);
1287
1288 for (int i = fileVersions.size() - 2; i >= 0; i--) {
1289 FileVersion fileVersion = fileVersions.get(i);
1290
1291 FileVersion previousFileVersion = fileVersions.get(i + 1);
1292
1293 try {
1294 destinationFileEntry = toLocalRepository.updateFileEntry(
1295 userId, destinationFileEntry.getFileEntryId(),
1296 fileEntry.getTitle(), destinationFileEntry.getMimeType(),
1297 destinationFileEntry.getTitle(),
1298 destinationFileEntry.getDescription(), StringPool.BLANK,
1299 DLAppUtil.isMajorVersion(fileVersion, previousFileVersion),
1300 fileVersion.getContentStream(false), fileVersion.getSize(),
1301 serviceContext);
1302 }
1303 catch (PortalException pe) {
1304 toLocalRepository.deleteFileEntry(
1305 destinationFileEntry.getFileEntryId());
1306
1307 throw pe;
1308 }
1309 }
1310
1311 dlAppHelperLocalService.addFileEntry(
1312 userId, destinationFileEntry, destinationFileEntry.getFileVersion(),
1313 serviceContext);
1314
1315 return destinationFileEntry;
1316 }
1317
1318 protected void deleteFileEntry(
1319 long oldFileEntryId, long newFileEntryId,
1320 LocalRepository fromLocalRepository,
1321 LocalRepository toLocalRepository)
1322 throws PortalException, SystemException {
1323
1324 try {
1325 FileEntry fileEntry = fromLocalRepository.getFileEntry(
1326 oldFileEntryId);
1327
1328 fromLocalRepository.deleteFileEntry(oldFileEntryId);
1329
1330 dlAppHelperLocalService.deleteFileEntry(fileEntry);
1331 }
1332 catch (PortalException pe) {
1333 FileEntry fileEntry = toLocalRepository.getFileEntry(
1334 newFileEntryId);
1335
1336 toLocalRepository.deleteFileEntry(newFileEntryId);
1337
1338 dlAppHelperLocalService.deleteFileEntry(fileEntry);
1339
1340 throw pe;
1341 }
1342 }
1343
1344 protected LocalRepository getFileEntryLocalRepository(long fileEntryId)
1345 throws PortalException, SystemException {
1346
1347 try {
1348 return repositoryLocalService.getLocalRepositoryImpl(
1349 0, fileEntryId, 0);
1350 }
1351 catch (InvalidRepositoryIdException irie) {
1352 StringBundler sb = new StringBundler(3);
1353
1354 sb.append("No FileEntry exists with the key {fileEntryId=");
1355 sb.append(fileEntryId);
1356 sb.append("}");
1357
1358 throw new NoSuchFileEntryException(sb.toString(), irie);
1359 }
1360 }
1361
1362 protected LocalRepository getFileVersionLocalRepository(long fileVersionId)
1363 throws PortalException, SystemException {
1364
1365 try {
1366 return repositoryLocalService.getLocalRepositoryImpl(
1367 0, 0, fileVersionId);
1368 }
1369 catch (InvalidRepositoryIdException irie) {
1370 StringBundler sb = new StringBundler(3);
1371
1372 sb.append("No FileVersion exists with the key {fileVersionId=");
1373 sb.append(fileVersionId);
1374 sb.append("}");
1375
1376 throw new NoSuchFileVersionException(sb.toString(), irie);
1377 }
1378 }
1379
1380 protected LocalRepository getFolderLocalRepository(long folderId)
1381 throws PortalException, SystemException {
1382
1383 try {
1384 return repositoryLocalService.getLocalRepositoryImpl(
1385 folderId, 0, 0);
1386 }
1387 catch (InvalidRepositoryIdException irie) {
1388 StringBundler sb = new StringBundler(3);
1389
1390 sb.append("No Folder exists with the key {folderId=");
1391 sb.append(folderId);
1392 sb.append("}");
1393
1394 throw new NoSuchFolderException(sb.toString(), irie);
1395 }
1396 }
1397
1398 protected LocalRepository getFolderLocalRepository(
1399 long folderId, long groupId)
1400 throws PortalException, SystemException {
1401
1402 LocalRepository localRepository = null;
1403
1404 if (folderId == DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
1405 localRepository = getLocalRepository(groupId);
1406 }
1407 else {
1408 localRepository = getFolderLocalRepository(folderId);
1409 }
1410
1411 return localRepository;
1412 }
1413
1414 protected LocalRepository getLocalRepository(long repositoryId)
1415 throws PortalException, SystemException {
1416
1417 try {
1418 return repositoryLocalService.getLocalRepositoryImpl(repositoryId);
1419 }
1420 catch (InvalidRepositoryIdException irie) {
1421 StringBundler sb = new StringBundler(3);
1422
1423 sb.append("No Group exists with the key {repositoryId=");
1424 sb.append(repositoryId);
1425 sb.append("}");
1426
1427 throw new NoSuchGroupException(sb.toString(), irie);
1428 }
1429 }
1430
1431 protected FileEntry moveFileEntries(
1432 long userId, long fileEntryId, long newFolderId,
1433 LocalRepository fromLocalRepository,
1434 LocalRepository toLocalRepository, ServiceContext serviceContext)
1435 throws PortalException, SystemException {
1436
1437 FileEntry sourceFileEntry = fromLocalRepository.getFileEntry(
1438 fileEntryId);
1439
1440 FileEntry destinationFileEntry = copyFileEntry(
1441 userId, toLocalRepository, sourceFileEntry, newFolderId,
1442 serviceContext);
1443
1444 deleteFileEntry(
1445 fileEntryId, destinationFileEntry.getFileEntryId(),
1446 fromLocalRepository, toLocalRepository);
1447
1448 return destinationFileEntry;
1449 }
1450
1451 protected Folder moveFolders(
1452 long userId, long folderId, long parentFolderId,
1453 LocalRepository sourceLocalRepository,
1454 LocalRepository destinationLocalRepository,
1455 ServiceContext serviceContext)
1456 throws PortalException, SystemException {
1457
1458 Folder sourceFolder = sourceLocalRepository.getFolder(folderId);
1459
1460 Folder destinationFolder = destinationLocalRepository.addFolder(
1461 userId, parentFolderId, sourceFolder.getName(),
1462 sourceFolder.getDescription(), serviceContext);
1463
1464 List<Object> foldersAndFileEntriesAndFileShortcuts =
1465 dlAppService.getFoldersAndFileEntriesAndFileShortcuts(
1466 sourceLocalRepository.getRepositoryId(), folderId,
1467 WorkflowConstants.STATUS_ANY, true, QueryUtil.ALL_POS,
1468 QueryUtil.ALL_POS);
1469
1470 try {
1471 for (Object folderAndFileEntryAndFileShortcut :
1472 foldersAndFileEntriesAndFileShortcuts) {
1473
1474 if (folderAndFileEntryAndFileShortcut instanceof FileEntry) {
1475 FileEntry fileEntry =
1476 (FileEntry)folderAndFileEntryAndFileShortcut;
1477
1478 copyFileEntry(
1479 userId, destinationLocalRepository, fileEntry,
1480 destinationFolder.getFolderId(), serviceContext);
1481 }
1482 else if (folderAndFileEntryAndFileShortcut instanceof Folder) {
1483 Folder folder = (Folder)folderAndFileEntryAndFileShortcut;
1484
1485 moveFolders(
1486 userId, folder.getFolderId(),
1487 destinationFolder.getFolderId(), sourceLocalRepository,
1488 destinationLocalRepository, serviceContext);
1489 }
1490 else if (folderAndFileEntryAndFileShortcut
1491 instanceof DLFileShortcut) {
1492
1493 if (destinationFolder.isSupportsShortcuts()) {
1494 DLFileShortcut dlFileShorcut =
1495 (DLFileShortcut)folderAndFileEntryAndFileShortcut;
1496
1497 dlFileShortcutLocalService.addFileShortcut(
1498 userId, dlFileShorcut.getGroupId(),
1499 destinationFolder.getFolderId(),
1500 dlFileShorcut.getToFileEntryId(), serviceContext);
1501 }
1502 }
1503 }
1504 }
1505 catch (PortalException pe) {
1506 destinationLocalRepository.deleteFolder(
1507 destinationFolder.getFolderId());
1508
1509 throw pe;
1510 }
1511
1512 try {
1513 sourceLocalRepository.deleteFolder(folderId);
1514 }
1515 catch (PortalException pe) {
1516 destinationLocalRepository.deleteFolder(
1517 destinationFolder.getFolderId());
1518
1519 throw pe;
1520 }
1521
1522 return destinationFolder;
1523 }
1524
1525 }