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