001
014
015 package com.liferay.portlet.documentlibrary.service.impl;
016
017 import com.liferay.portal.NoSuchGroupException;
018 import com.liferay.portal.kernel.bean.BeanReference;
019 import com.liferay.portal.kernel.dao.orm.QueryUtil;
020 import com.liferay.portal.kernel.exception.PortalException;
021 import com.liferay.portal.kernel.exception.SystemException;
022 import com.liferay.portal.kernel.io.unsync.UnsyncByteArrayInputStream;
023 import com.liferay.portal.kernel.log.Log;
024 import com.liferay.portal.kernel.log.LogFactoryUtil;
025 import com.liferay.portal.kernel.repository.InvalidRepositoryIdException;
026 import com.liferay.portal.kernel.repository.LocalRepository;
027 import com.liferay.portal.kernel.repository.RepositoryProvider;
028 import com.liferay.portal.kernel.repository.model.FileEntry;
029 import com.liferay.portal.kernel.repository.model.FileShortcut;
030 import com.liferay.portal.kernel.repository.model.FileVersion;
031 import com.liferay.portal.kernel.repository.model.Folder;
032 import com.liferay.portal.kernel.repository.model.RepositoryEntry;
033 import com.liferay.portal.kernel.repository.util.RepositoryTrashUtil;
034 import com.liferay.portal.kernel.systemevent.SystemEventHierarchyEntryThreadLocal;
035 import com.liferay.portal.kernel.util.ArrayUtil;
036 import com.liferay.portal.kernel.util.ContentTypes;
037 import com.liferay.portal.kernel.util.FileUtil;
038 import com.liferay.portal.kernel.util.MimeTypesUtil;
039 import com.liferay.portal.kernel.util.StringBundler;
040 import com.liferay.portal.kernel.util.StringPool;
041 import com.liferay.portal.kernel.util.Validator;
042 import com.liferay.portal.kernel.workflow.WorkflowConstants;
043 import com.liferay.portal.model.Repository;
044 import com.liferay.portal.model.UserConstants;
045 import com.liferay.portal.repository.liferayrepository.model.LiferayFolder;
046 import com.liferay.portal.service.ServiceContext;
047 import com.liferay.portlet.documentlibrary.NoSuchFileEntryException;
048 import com.liferay.portlet.documentlibrary.model.DLFileEntryType;
049 import com.liferay.portlet.documentlibrary.model.DLFileEntryTypeConstants;
050 import com.liferay.portlet.documentlibrary.model.DLFileRank;
051 import com.liferay.portlet.documentlibrary.model.DLFolder;
052 import com.liferay.portlet.documentlibrary.model.DLFolderConstants;
053 import com.liferay.portlet.documentlibrary.service.base.DLAppLocalServiceBaseImpl;
054 import com.liferay.portlet.documentlibrary.util.DLAppUtil;
055
056 import java.io.File;
057 import java.io.IOException;
058 import java.io.InputStream;
059
060 import java.util.List;
061
062
089 public class DLAppLocalServiceImpl extends DLAppLocalServiceBaseImpl {
090
091 @Override
092 public FileEntry addFileEntry(
093 long userId, long repositoryId, long folderId,
094 String sourceFileName, String mimeType, byte[] bytes,
095 ServiceContext serviceContext)
096 throws PortalException {
097
098 return addFileEntry(
099 userId, repositoryId, folderId, sourceFileName, mimeType, null,
100 StringPool.BLANK, StringPool.BLANK, bytes, serviceContext);
101 }
102
103
133 @Override
134 public FileEntry addFileEntry(
135 long userId, long repositoryId, long folderId,
136 String sourceFileName, String mimeType, String title,
137 String description, String changeLog, byte[] bytes,
138 ServiceContext serviceContext)
139 throws PortalException {
140
141 File file = null;
142
143 try {
144 if (ArrayUtil.isNotEmpty(bytes)) {
145 file = FileUtil.createTempFile(bytes);
146 }
147
148 return addFileEntry(
149 userId, repositoryId, folderId, sourceFileName, mimeType, title,
150 description, changeLog, file, serviceContext);
151 }
152 catch (IOException ioe) {
153 throw new SystemException("Unable to write temporary file", ioe);
154 }
155 finally {
156 FileUtil.delete(file);
157 }
158 }
159
160
190 @Override
191 public FileEntry addFileEntry(
192 long userId, long repositoryId, long folderId,
193 String sourceFileName, String mimeType, String title,
194 String description, String changeLog, File file,
195 ServiceContext serviceContext)
196 throws PortalException {
197
198 if ((file == null) || !file.exists() || (file.length() == 0)) {
199 return addFileEntry(
200 userId, repositoryId, folderId, sourceFileName, mimeType, title,
201 description, changeLog, null, 0, serviceContext);
202 }
203
204 mimeType = DLAppUtil.getMimeType(sourceFileName, mimeType, title, file);
205
206 LocalRepository localRepository = getLocalRepository(repositoryId);
207
208 FileEntry fileEntry = localRepository.addFileEntry(
209 userId, folderId, sourceFileName, mimeType, title, description,
210 changeLog, file, serviceContext);
211
212 return fileEntry;
213 }
214
215
247 @Override
248 public FileEntry addFileEntry(
249 long userId, long repositoryId, long folderId,
250 String sourceFileName, String mimeType, String title,
251 String description, String changeLog, InputStream is, long size,
252 ServiceContext serviceContext)
253 throws PortalException {
254
255 if (is == null) {
256 is = new UnsyncByteArrayInputStream(new byte[0]);
257 size = 0;
258 }
259
260 if (Validator.isNull(mimeType) ||
261 mimeType.equals(ContentTypes.APPLICATION_OCTET_STREAM)) {
262
263 String extension = DLAppUtil.getExtension(title, sourceFileName);
264
265 if (size == 0) {
266 mimeType = MimeTypesUtil.getExtensionContentType(extension);
267 }
268 else {
269 File file = null;
270
271 try {
272 file = FileUtil.createTempFile(is);
273
274 return addFileEntry(
275 userId, repositoryId, folderId, sourceFileName,
276 mimeType, title, description, changeLog, file,
277 serviceContext);
278 }
279 catch (IOException ioe) {
280 throw new SystemException(
281 "Unable to write temporary file", ioe);
282 }
283 finally {
284 FileUtil.delete(file);
285 }
286 }
287 }
288
289 LocalRepository localRepository = getLocalRepository(repositoryId);
290
291 FileEntry fileEntry = localRepository.addFileEntry(
292 userId, folderId, sourceFileName, mimeType, title, description,
293 changeLog, is, size, serviceContext);
294
295 return fileEntry;
296 }
297
298
309 @Override
310 public DLFileRank addFileRank(
311 long repositoryId, long companyId, long userId, long fileEntryId,
312 ServiceContext serviceContext) {
313
314 return dlFileRankLocalService.addFileRank(
315 repositoryId, companyId, userId, fileEntryId, serviceContext);
316 }
317
318
331 @Override
332 public FileShortcut addFileShortcut(
333 long userId, long repositoryId, long folderId, long toFileEntryId,
334 ServiceContext serviceContext)
335 throws PortalException {
336
337 LocalRepository localRepository = getLocalRepository(repositoryId);
338
339 return localRepository.addFileShortcut(
340 userId, folderId, toFileEntryId, serviceContext);
341 }
342
343
357 @Override
358 public Folder addFolder(
359 long userId, long repositoryId, long parentFolderId, String name,
360 String description, ServiceContext serviceContext)
361 throws PortalException {
362
363 LocalRepository localRepository = getLocalRepository(repositoryId);
364
365 Folder folder = localRepository.addFolder(
366 userId, parentFolderId, name, description, serviceContext);
367
368 dlAppHelperLocalService.addFolder(userId, folder, serviceContext);
369
370 return folder;
371 }
372
373
379 @Override
380 public void deleteAll(long repositoryId) throws PortalException {
381 LocalRepository localRepository = getLocalRepository(repositoryId);
382
383 deleteRepository(localRepository);
384 }
385
386 @Override
387 public void deleteAllRepositories(long groupId) throws PortalException {
388 LocalRepository groupLocalRepository =
389 repositoryProvider.getLocalRepository(groupId);
390
391 deleteRepository(groupLocalRepository);
392
393 List<LocalRepository> localRepositories =
394 repositoryProvider.getGroupLocalRepositories(groupId);
395
396 for (LocalRepository localRepository : localRepositories) {
397 if (localRepository.getRepositoryId() !=
398 groupLocalRepository.getRepositoryId()) {
399
400 deleteRepository(localRepository);
401 }
402 }
403 }
404
405
410 @Override
411 public void deleteFileEntry(long fileEntryId) throws PortalException {
412 LocalRepository localRepository =
413 repositoryProvider.getFileEntryLocalRepository(fileEntryId);
414
415 FileEntry fileEntry = localRepository.getFileEntry(fileEntryId);
416
417 dlAppHelperLocalService.deleteFileEntry(fileEntry);
418
419 localRepository.deleteFileEntry(fileEntryId);
420 }
421
422
428 @Override
429 public void deleteFileRanksByFileEntryId(long fileEntryId) {
430 dlFileRankLocalService.deleteFileRanksByFileEntryId(fileEntryId);
431 }
432
433
439 @Override
440 public void deleteFileRanksByUserId(long userId) {
441 dlFileRankLocalService.deleteFileRanksByUserId(userId);
442 }
443
444
450 @Override
451 public void deleteFileShortcut(FileShortcut fileShortcut)
452 throws PortalException {
453
454 deleteFileShortcut(fileShortcut.getFileShortcutId());
455 }
456
457
463 @Override
464 public void deleteFileShortcut(long fileShortcutId) throws PortalException {
465 LocalRepository localRepository =
466 repositoryProvider.getFileShortcutLocalRepository(fileShortcutId);
467
468 localRepository.deleteFileShortcut(fileShortcutId);
469 }
470
471
477 @Override
478 public void deleteFileShortcuts(long toFileEntryId) throws PortalException {
479 LocalRepository localRepository =
480 repositoryProvider.getFileEntryLocalRepository(toFileEntryId);
481
482 localRepository.deleteFileShortcuts(toFileEntryId);
483 }
484
485
490 @Override
491 public void deleteFolder(long folderId) throws PortalException {
492 LocalRepository localRepository =
493 repositoryProvider.getFolderLocalRepository(folderId);
494
495 List<FileEntry> fileEntries = localRepository.getRepositoryFileEntries(
496 UserConstants.USER_ID_DEFAULT, folderId, QueryUtil.ALL_POS,
497 QueryUtil.ALL_POS, null);
498
499 for (FileEntry fileEntry : fileEntries) {
500 dlAppHelperLocalService.deleteFileEntry(fileEntry);
501 }
502
503 Folder folder = getFolder(folderId);
504
505 localRepository.deleteFolder(folderId);
506
507 dlAppHelperLocalService.deleteFolder(folder);
508 }
509
510
516 @Override
517 public FileEntry getFileEntry(long fileEntryId) throws PortalException {
518 LocalRepository localRepository =
519 repositoryProvider.getFileEntryLocalRepository(fileEntryId);
520
521 return localRepository.getFileEntry(fileEntryId);
522 }
523
524
532 @Override
533 public FileEntry getFileEntry(long groupId, long folderId, String title)
534 throws PortalException {
535
536 try {
537 LocalRepository localRepository = getLocalRepository(groupId);
538
539 return localRepository.getFileEntry(folderId, title);
540 }
541 catch (NoSuchFileEntryException nsfee) {
542 if (_log.isDebugEnabled()) {
543 _log.debug(nsfee, nsfee);
544 }
545 }
546
547 LocalRepository localRepository =
548 repositoryProvider.getFolderLocalRepository(folderId);
549
550 return localRepository.getFileEntry(folderId, title);
551 }
552
553
560 @Override
561 public FileEntry getFileEntryByUuidAndGroupId(String uuid, long groupId)
562 throws PortalException {
563
564 try {
565 LocalRepository localRepository = getLocalRepository(groupId);
566
567 return localRepository.getFileEntryByUuid(uuid);
568 }
569 catch (NoSuchFileEntryException nsfee) {
570 if (_log.isDebugEnabled()) {
571 _log.debug(nsfee, nsfee);
572 }
573 }
574
575 List<com.liferay.portal.model.Repository> repositories =
576 repositoryPersistence.findByGroupId(groupId);
577
578 for (Repository repository : repositories) {
579 try {
580 LocalRepository localRepository = getLocalRepository(
581 repository.getRepositoryId());
582
583 return localRepository.getFileEntryByUuid(uuid);
584 }
585 catch (NoSuchFileEntryException nsfee) {
586 if (_log.isDebugEnabled()) {
587 _log.debug(nsfee, nsfee);
588 }
589 }
590 }
591
592 StringBundler msg = new StringBundler(6);
593
594 msg.append("No DLFileEntry exists with the key {");
595 msg.append("uuid=");
596 msg.append(uuid);
597 msg.append(", groupId=");
598 msg.append(groupId);
599 msg.append(StringPool.CLOSE_CURLY_BRACE);
600
601 throw new NoSuchFileEntryException(msg.toString());
602 }
603
604
612 @Override
613 public List<DLFileRank> getFileRanks(long repositoryId, long userId) {
614 return dlFileRankLocalService.getFileRanks(repositoryId, userId);
615 }
616
617
624 @Override
625 public FileShortcut getFileShortcut(long fileShortcutId)
626 throws PortalException {
627
628 LocalRepository localRepository =
629 repositoryProvider.getFileShortcutLocalRepository(fileShortcutId);
630
631 return localRepository.getFileShortcut(fileShortcutId);
632 }
633
634
640 @Override
641 public FileVersion getFileVersion(long fileVersionId)
642 throws PortalException {
643
644 LocalRepository localRepository =
645 repositoryProvider.getFileVersionLocalRepository(fileVersionId);
646
647 return localRepository.getFileVersion(fileVersionId);
648 }
649
650
656 @Override
657 public Folder getFolder(long folderId) throws PortalException {
658 LocalRepository localRepository =
659 repositoryProvider.getFolderLocalRepository(folderId);
660
661 return localRepository.getFolder(folderId);
662 }
663
664
672 @Override
673 public Folder getFolder(long repositoryId, long parentFolderId, String name)
674 throws PortalException {
675
676 LocalRepository localRepository = getLocalRepository(repositoryId);
677
678 return localRepository.getFolder(parentFolderId, name);
679 }
680
681
688 @Override
689 public Folder getMountFolder(long repositoryId) throws PortalException {
690 DLFolder dlFolder = dlFolderLocalService.getMountFolder(repositoryId);
691
692 return new LiferayFolder(dlFolder);
693 }
694
695
704 @Override
705 public FileEntry moveFileEntry(
706 long userId, long fileEntryId, long newFolderId,
707 ServiceContext serviceContext)
708 throws PortalException {
709
710 SystemEventHierarchyEntryThreadLocal.push(FileEntry.class);
711
712 try {
713 LocalRepository fromLocalRepository =
714 repositoryProvider.getFileEntryLocalRepository(fileEntryId);
715
716 LocalRepository toLocalRepository = getFolderLocalRepository(
717 newFolderId, serviceContext.getScopeGroupId());
718
719 if (fromLocalRepository.getRepositoryId() ==
720 toLocalRepository.getRepositoryId()) {
721
722
723
724 return fromLocalRepository.moveFileEntry(
725 userId, fileEntryId, newFolderId, serviceContext);
726 }
727
728
729
730 return moveFileEntries(
731 userId, fileEntryId, newFolderId, fromLocalRepository,
732 toLocalRepository, serviceContext);
733 }
734 finally {
735 SystemEventHierarchyEntryThreadLocal.pop(FileEntry.class);
736 }
737 }
738
739
744 @Deprecated
745 @Override
746 public FileEntry moveFileEntryFromTrash(
747 long userId, long fileEntryId, long newFolderId,
748 ServiceContext serviceContext)
749 throws PortalException {
750
751 LocalRepository localRepository =
752 repositoryProvider.getFileEntryLocalRepository(fileEntryId);
753
754 return RepositoryTrashUtil.moveFileEntryFromTrash(
755 userId, localRepository.getRepositoryId(), fileEntryId, newFolderId,
756 serviceContext);
757 }
758
759
763 @Deprecated
764 @Override
765 public FileEntry moveFileEntryToTrash(long userId, long fileEntryId)
766 throws PortalException {
767
768 LocalRepository localRepository =
769 repositoryProvider.getFileEntryLocalRepository(fileEntryId);
770
771 return RepositoryTrashUtil.moveFileEntryToTrash(
772 userId, localRepository.getRepositoryId(), fileEntryId);
773 }
774
775 @Override
776 public Folder moveFolder(
777 long userId, long folderId, long parentFolderId,
778 ServiceContext serviceContext)
779 throws PortalException {
780
781 SystemEventHierarchyEntryThreadLocal.push(Folder.class);
782
783 try {
784 LocalRepository sourceLocalRepository =
785 repositoryProvider.getFolderLocalRepository(folderId);
786
787 LocalRepository destinationLocalRepository =
788 getFolderLocalRepository(
789 parentFolderId, serviceContext.getScopeGroupId());
790
791 if (parentFolderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
792 Folder toFolder = destinationLocalRepository.getFolder(
793 parentFolderId);
794
795 if (toFolder.isMountPoint()) {
796 destinationLocalRepository = getLocalRepository(
797 toFolder.getRepositoryId());
798 }
799 }
800
801 if (sourceLocalRepository.getRepositoryId() ==
802 destinationLocalRepository.getRepositoryId()) {
803
804
805
806 return sourceLocalRepository.moveFolder(
807 userId, folderId, parentFolderId, serviceContext);
808 }
809
810
811
812 return moveFolders(
813 userId, folderId, parentFolderId, sourceLocalRepository,
814 destinationLocalRepository, serviceContext);
815 }
816 finally {
817 SystemEventHierarchyEntryThreadLocal.pop(Folder.class);
818 }
819 }
820
821
826 @Deprecated
827 @Override
828 public void restoreFileEntryFromTrash(long userId, long fileEntryId)
829 throws PortalException {
830
831 LocalRepository localRepository =
832 repositoryProvider.getFileEntryLocalRepository(fileEntryId);
833
834 RepositoryTrashUtil.restoreFileEntryFromTrash(
835 userId, localRepository.getRepositoryId(), fileEntryId);
836 }
837
838
846 @Override
847 public void subscribeFileEntryType(
848 long userId, long groupId, long fileEntryTypeId)
849 throws PortalException {
850
851 if (fileEntryTypeId ==
852 DLFileEntryTypeConstants.FILE_ENTRY_TYPE_ID_BASIC_DOCUMENT) {
853
854 fileEntryTypeId = groupId;
855 }
856
857 subscriptionLocalService.addSubscription(
858 userId, groupId, DLFileEntryType.class.getName(), fileEntryTypeId);
859 }
860
861
869 @Override
870 public void subscribeFolder(long userId, long groupId, long folderId)
871 throws PortalException {
872
873 if (folderId == DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
874 folderId = groupId;
875 }
876
877 subscriptionLocalService.addSubscription(
878 userId, groupId, DLFolder.class.getName(), folderId);
879 }
880
881
889 @Override
890 public void unsubscribeFileEntryType(
891 long userId, long groupId, long fileEntryTypeId)
892 throws PortalException {
893
894 if (fileEntryTypeId ==
895 DLFileEntryTypeConstants.FILE_ENTRY_TYPE_ID_BASIC_DOCUMENT) {
896
897 fileEntryTypeId = groupId;
898 }
899
900 subscriptionLocalService.deleteSubscription(
901 userId, DLFileEntryType.class.getName(), fileEntryTypeId);
902 }
903
904
912 @Override
913 public void unsubscribeFolder(long userId, long groupId, long folderId)
914 throws PortalException {
915
916 if (folderId == DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
917 folderId = groupId;
918 }
919
920 subscriptionLocalService.deleteSubscription(
921 userId, DLFolder.class.getName(), folderId);
922 }
923
924
935 @Override
936 public void updateAsset(
937 long userId, FileEntry fileEntry, FileVersion fileVersion,
938 long[] assetCategoryIds, String[] assetTagNames,
939 long[] assetLinkEntryIds)
940 throws PortalException {
941
942 dlAppHelperLocalService.updateAsset(
943 userId, fileEntry, fileVersion, assetCategoryIds, assetTagNames,
944 assetLinkEntryIds);
945 }
946
947
981 @Override
982 public FileEntry updateFileEntry(
983 long userId, long fileEntryId, String sourceFileName,
984 String mimeType, String title, String description, String changeLog,
985 boolean majorVersion, byte[] bytes, ServiceContext serviceContext)
986 throws PortalException {
987
988 File file = null;
989
990 try {
991 if (ArrayUtil.isNotEmpty(bytes)) {
992 file = FileUtil.createTempFile(bytes);
993 }
994
995 return updateFileEntry(
996 userId, fileEntryId, sourceFileName, mimeType, title,
997 description, changeLog, majorVersion, file, serviceContext);
998 }
999 catch (IOException ioe) {
1000 throw new SystemException("Unable to write temporary file", ioe);
1001 }
1002 finally {
1003 FileUtil.delete(file);
1004 }
1005 }
1006
1007
1041 @Override
1042 public FileEntry updateFileEntry(
1043 long userId, long fileEntryId, String sourceFileName,
1044 String mimeType, String title, String description, String changeLog,
1045 boolean majorVersion, File file, ServiceContext serviceContext)
1046 throws PortalException {
1047
1048 if ((file == null) || !file.exists() || (file.length() == 0)) {
1049 return updateFileEntry(
1050 userId, fileEntryId, sourceFileName, mimeType, title,
1051 description, changeLog, majorVersion, null, 0, serviceContext);
1052 }
1053
1054 mimeType = DLAppUtil.getMimeType(sourceFileName, mimeType, title, file);
1055
1056 LocalRepository localRepository =
1057 repositoryProvider.getFileEntryLocalRepository(fileEntryId);
1058
1059 FileEntry fileEntry = localRepository.updateFileEntry(
1060 userId, fileEntryId, sourceFileName, mimeType, title, description,
1061 changeLog, majorVersion, file, serviceContext);
1062
1063 dlAppHelperLocalService.updateFileEntry(
1064 userId, fileEntry, null, fileEntry.getFileVersion(),
1065 serviceContext);
1066
1067 return fileEntry;
1068 }
1069
1070
1105 @Override
1106 public FileEntry updateFileEntry(
1107 long userId, long fileEntryId, String sourceFileName,
1108 String mimeType, String title, String description, String changeLog,
1109 boolean majorVersion, InputStream is, long size,
1110 ServiceContext serviceContext)
1111 throws PortalException {
1112
1113 if (Validator.isNull(mimeType) ||
1114 mimeType.equals(ContentTypes.APPLICATION_OCTET_STREAM)) {
1115
1116 String extension = DLAppUtil.getExtension(title, sourceFileName);
1117
1118 if (size == 0) {
1119 mimeType = MimeTypesUtil.getExtensionContentType(extension);
1120 }
1121 else {
1122 File file = null;
1123
1124 try {
1125 file = FileUtil.createTempFile(is);
1126
1127 return updateFileEntry(
1128 userId, fileEntryId, sourceFileName, mimeType, title,
1129 description, changeLog, majorVersion, file,
1130 serviceContext);
1131 }
1132 catch (IOException ioe) {
1133 throw new SystemException(
1134 "Unable to write temporary file", ioe);
1135 }
1136 finally {
1137 FileUtil.delete(file);
1138 }
1139 }
1140 }
1141
1142 LocalRepository localRepository =
1143 repositoryProvider.getFileEntryLocalRepository(fileEntryId);
1144
1145 FileEntry fileEntry = localRepository.updateFileEntry(
1146 userId, fileEntryId, sourceFileName, mimeType, title, description,
1147 changeLog, majorVersion, is, size, serviceContext);
1148
1149 dlAppHelperLocalService.updateFileEntry(
1150 userId, fileEntry, null, fileEntry.getFileVersion(),
1151 serviceContext);
1152
1153 return fileEntry;
1154 }
1155
1156
1167 @Override
1168 public DLFileRank updateFileRank(
1169 long repositoryId, long companyId, long userId, long fileEntryId,
1170 ServiceContext serviceContext) {
1171
1172 return dlFileRankLocalService.updateFileRank(
1173 repositoryId, companyId, userId, fileEntryId, serviceContext);
1174 }
1175
1176
1189 @Override
1190 public FileShortcut updateFileShortcut(
1191 long userId, long fileShortcutId, long folderId, long toFileEntryId,
1192 ServiceContext serviceContext)
1193 throws PortalException {
1194
1195 LocalRepository localRepository =
1196 repositoryProvider.getFileShortcutLocalRepository(fileShortcutId);
1197
1198 return localRepository.updateFileShortcut(
1199 userId, fileShortcutId, folderId, toFileEntryId, serviceContext);
1200 }
1201
1202
1209 @Override
1210 public void updateFileShortcuts(
1211 long oldToFileEntryId, long newToFileEntryId)
1212 throws PortalException {
1213
1214 LocalRepository localRepository =
1215 repositoryProvider.getFileEntryLocalRepository(newToFileEntryId);
1216
1217 localRepository.updateFileShortcuts(oldToFileEntryId, newToFileEntryId);
1218 }
1219
1220
1224 @Deprecated
1225 @Override
1226 public void updateFileShortcuts(
1227 long toRepositoryId, long oldToFileEntryId, long newToFileEntryId)
1228 throws PortalException {
1229
1230 updateFileShortcuts(oldToFileEntryId, newToFileEntryId);
1231 }
1232
1233
1254 @Override
1255 public Folder updateFolder(
1256 long folderId, long parentFolderId, String name, String description,
1257 ServiceContext serviceContext)
1258 throws PortalException {
1259
1260 LocalRepository localRepository =
1261 repositoryProvider.getFolderLocalRepository(folderId);
1262
1263 Folder folder = localRepository.updateFolder(
1264 folderId, parentFolderId, name, description, serviceContext);
1265
1266 if (folderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
1267 dlAppHelperLocalService.updateFolder(
1268 serviceContext.getUserId(), folder, serviceContext);
1269 }
1270
1271 return folder;
1272 }
1273
1274 protected FileEntry copyFileEntry(
1275 long userId, LocalRepository toLocalRepository, FileEntry fileEntry,
1276 long newFolderId, ServiceContext serviceContext)
1277 throws PortalException {
1278
1279 List<FileVersion> fileVersions = fileEntry.getFileVersions(
1280 WorkflowConstants.STATUS_ANY);
1281
1282 FileVersion latestFileVersion = fileVersions.get(
1283 fileVersions.size() - 1);
1284
1285 String sourceFileName = DLAppUtil.getSourceFileName(latestFileVersion);
1286
1287 FileEntry destinationFileEntry = toLocalRepository.addFileEntry(
1288 userId, newFolderId, sourceFileName,
1289 latestFileVersion.getMimeType(), latestFileVersion.getTitle(),
1290 latestFileVersion.getDescription(), StringPool.BLANK,
1291 latestFileVersion.getContentStream(false),
1292 latestFileVersion.getSize(), serviceContext);
1293
1294 for (int i = fileVersions.size() - 2; i >= 0; i--) {
1295 FileVersion fileVersion = fileVersions.get(i);
1296
1297 sourceFileName = DLAppUtil.getSourceFileName(fileVersion);
1298
1299 FileVersion previousFileVersion = fileVersions.get(i + 1);
1300
1301 try {
1302 destinationFileEntry = toLocalRepository.updateFileEntry(
1303 userId, destinationFileEntry.getFileEntryId(),
1304 sourceFileName, destinationFileEntry.getMimeType(),
1305 destinationFileEntry.getTitle(),
1306 destinationFileEntry.getDescription(), StringPool.BLANK,
1307 DLAppUtil.isMajorVersion(fileVersion, previousFileVersion),
1308 fileVersion.getContentStream(false), fileVersion.getSize(),
1309 serviceContext);
1310 }
1311 catch (PortalException pe) {
1312 toLocalRepository.deleteFileEntry(
1313 destinationFileEntry.getFileEntryId());
1314
1315 throw pe;
1316 }
1317 }
1318
1319 return destinationFileEntry;
1320 }
1321
1322 protected void deleteFileEntry(
1323 long oldFileEntryId, long newFileEntryId,
1324 LocalRepository fromLocalRepository,
1325 LocalRepository toLocalRepository)
1326 throws PortalException {
1327
1328 try {
1329 FileEntry fileEntry = fromLocalRepository.getFileEntry(
1330 oldFileEntryId);
1331
1332 fromLocalRepository.deleteFileEntry(oldFileEntryId);
1333
1334 dlAppHelperLocalService.deleteFileEntry(fileEntry);
1335 }
1336 catch (PortalException pe) {
1337 FileEntry fileEntry = toLocalRepository.getFileEntry(
1338 newFileEntryId);
1339
1340 toLocalRepository.deleteFileEntry(newFileEntryId);
1341
1342 dlAppHelperLocalService.deleteFileEntry(fileEntry);
1343
1344 throw pe;
1345 }
1346 }
1347
1348 protected void deleteRepository(LocalRepository localRepository)
1349 throws PortalException {
1350
1351 long repositoryId = localRepository.getRepositoryId();
1352
1353 dlAppHelperLocalService.deleteRepositoryFileEntries(repositoryId);
1354
1355 localRepository.deleteAll();
1356
1357 repositoryLocalService.deleteRepository(repositoryId);
1358 }
1359
1360 protected LocalRepository getFolderLocalRepository(
1361 long folderId, long groupId)
1362 throws PortalException {
1363
1364 if (folderId == DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
1365 return getLocalRepository(groupId);
1366 }
1367
1368 return repositoryProvider.getFolderLocalRepository(folderId);
1369 }
1370
1371 protected LocalRepository getLocalRepository(long repositoryId)
1372 throws PortalException {
1373
1374 try {
1375 return repositoryProvider.getLocalRepository(repositoryId);
1376 }
1377 catch (InvalidRepositoryIdException irie) {
1378 StringBundler sb = new StringBundler(3);
1379
1380 sb.append("No Group exists with the key {repositoryId=");
1381 sb.append(repositoryId);
1382 sb.append("}");
1383
1384 throw new NoSuchGroupException(sb.toString(), irie);
1385 }
1386 }
1387
1388 protected FileEntry moveFileEntries(
1389 long userId, long fileEntryId, long newFolderId,
1390 LocalRepository fromLocalRepository,
1391 LocalRepository toLocalRepository, ServiceContext serviceContext)
1392 throws PortalException {
1393
1394 FileEntry sourceFileEntry = fromLocalRepository.getFileEntry(
1395 fileEntryId);
1396
1397 FileEntry destinationFileEntry = copyFileEntry(
1398 userId, toLocalRepository, sourceFileEntry, newFolderId,
1399 serviceContext);
1400
1401 deleteFileEntry(
1402 fileEntryId, destinationFileEntry.getFileEntryId(),
1403 fromLocalRepository, toLocalRepository);
1404
1405 return destinationFileEntry;
1406 }
1407
1408 protected Folder moveFolders(
1409 long userId, long folderId, long parentFolderId,
1410 LocalRepository sourceLocalRepository,
1411 LocalRepository destinationLocalRepository,
1412 ServiceContext serviceContext)
1413 throws PortalException {
1414
1415 Folder sourceFolder = sourceLocalRepository.getFolder(folderId);
1416
1417 Folder destinationFolder = destinationLocalRepository.addFolder(
1418 userId, parentFolderId, sourceFolder.getName(),
1419 sourceFolder.getDescription(), serviceContext);
1420
1421 dlAppHelperLocalService.addFolder(
1422 userId, destinationFolder, serviceContext);
1423
1424 List<RepositoryEntry> foldersAndFileEntriesAndFileShortcuts =
1425 sourceLocalRepository.getFoldersAndFileEntriesAndFileShortcuts(
1426 folderId, WorkflowConstants.STATUS_ANY, true, QueryUtil.ALL_POS,
1427 QueryUtil.ALL_POS, null);
1428
1429 try {
1430 for (RepositoryEntry folderAndFileEntryAndFileShortcut :
1431 foldersAndFileEntriesAndFileShortcuts) {
1432
1433 if (folderAndFileEntryAndFileShortcut instanceof FileEntry) {
1434 FileEntry fileEntry =
1435 (FileEntry)folderAndFileEntryAndFileShortcut;
1436
1437 moveFileEntry(
1438 userId, fileEntry.getFileEntryId(),
1439 destinationFolder.getFolderId(), serviceContext);
1440 }
1441 else if (folderAndFileEntryAndFileShortcut instanceof Folder) {
1442 Folder folder = (Folder)folderAndFileEntryAndFileShortcut;
1443
1444 moveFolders(
1445 userId, folder.getFolderId(),
1446 destinationFolder.getFolderId(), sourceLocalRepository,
1447 destinationLocalRepository, serviceContext);
1448 }
1449 else if (folderAndFileEntryAndFileShortcut
1450 instanceof FileShortcut) {
1451
1452 if (destinationFolder.isSupportsShortcuts()) {
1453 FileShortcut fileShortcut =
1454 (FileShortcut)folderAndFileEntryAndFileShortcut;
1455
1456 destinationLocalRepository.addFileShortcut(
1457 userId, destinationFolder.getFolderId(),
1458 fileShortcut.getToFileEntryId(), serviceContext);
1459 }
1460 }
1461 }
1462 }
1463 catch (PortalException pe) {
1464 int fileEntriesAndFileShortcutsCount =
1465 destinationLocalRepository.getFileEntriesAndFileShortcutsCount(
1466 destinationFolder.getFolderId(),
1467 WorkflowConstants.STATUS_ANY);
1468
1469 if (fileEntriesAndFileShortcutsCount == 0) {
1470 destinationLocalRepository.deleteFolder(
1471 destinationFolder.getFolderId());
1472 }
1473
1474 throw pe;
1475 }
1476
1477 try {
1478 sourceLocalRepository.deleteFolder(folderId);
1479 }
1480 catch (PortalException pe) {
1481 destinationLocalRepository.deleteFolder(
1482 destinationFolder.getFolderId());
1483
1484 throw pe;
1485 }
1486
1487 return destinationFolder;
1488 }
1489
1490 @BeanReference(type = RepositoryProvider.class)
1491 protected RepositoryProvider repositoryProvider;
1492
1493 private static final Log _log = LogFactoryUtil.getLog(
1494 DLAppLocalServiceImpl.class);
1495
1496 }