001
014
015 package com.liferay.portlet.documentlibrary.service.impl;
016
017 import com.liferay.portal.exception.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.systemevent.SystemEventHierarchyEntryThreadLocal;
034 import com.liferay.portal.kernel.util.ArrayUtil;
035 import com.liferay.portal.kernel.util.ContentTypes;
036 import com.liferay.portal.kernel.util.FileUtil;
037 import com.liferay.portal.kernel.util.MimeTypesUtil;
038 import com.liferay.portal.kernel.util.StringBundler;
039 import com.liferay.portal.kernel.util.StringPool;
040 import com.liferay.portal.kernel.util.Validator;
041 import com.liferay.portal.kernel.workflow.WorkflowConstants;
042 import com.liferay.portal.model.Repository;
043 import com.liferay.portal.model.UserConstants;
044 import com.liferay.portal.repository.liferayrepository.model.LiferayFolder;
045 import com.liferay.portal.service.ServiceContext;
046 import com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException;
047 import com.liferay.portlet.documentlibrary.model.DLFileEntryType;
048 import com.liferay.portlet.documentlibrary.model.DLFileEntryTypeConstants;
049 import com.liferay.portlet.documentlibrary.model.DLFileRank;
050 import com.liferay.portlet.documentlibrary.model.DLFolder;
051 import com.liferay.portlet.documentlibrary.model.DLFolderConstants;
052 import com.liferay.portlet.documentlibrary.service.base.DLAppLocalServiceBaseImpl;
053 import com.liferay.portlet.documentlibrary.util.DLAppUtil;
054
055 import java.io.File;
056 import java.io.IOException;
057 import java.io.InputStream;
058
059 import java.util.List;
060
061
088 public class DLAppLocalServiceImpl extends DLAppLocalServiceBaseImpl {
089
090 @Override
091 public FileEntry addFileEntry(
092 long userId, long repositoryId, long folderId,
093 String sourceFileName, String mimeType, byte[] bytes,
094 ServiceContext serviceContext)
095 throws PortalException {
096
097 return addFileEntry(
098 userId, repositoryId, folderId, sourceFileName, mimeType,
099 sourceFileName, StringPool.BLANK, StringPool.BLANK, bytes,
100 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 moveFileEntry(
731 userId, fileEntryId, newFolderId, fromLocalRepository,
732 toLocalRepository, serviceContext);
733 }
734 finally {
735 SystemEventHierarchyEntryThreadLocal.pop(FileEntry.class);
736 }
737 }
738
739 @Override
740 public Folder moveFolder(
741 long userId, long folderId, long parentFolderId,
742 ServiceContext serviceContext)
743 throws PortalException {
744
745 SystemEventHierarchyEntryThreadLocal.push(Folder.class);
746
747 try {
748 LocalRepository fromLocalRepository =
749 repositoryProvider.getFolderLocalRepository(folderId);
750
751 LocalRepository toLocalRepository = getFolderLocalRepository(
752 parentFolderId, serviceContext.getScopeGroupId());
753
754 if (parentFolderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
755 Folder toFolder = toLocalRepository.getFolder(parentFolderId);
756
757 if (toFolder.isMountPoint()) {
758 toLocalRepository = getLocalRepository(
759 toFolder.getRepositoryId());
760 }
761 }
762
763 if (fromLocalRepository.getRepositoryId() ==
764 toLocalRepository.getRepositoryId()) {
765
766
767
768 return fromLocalRepository.moveFolder(
769 userId, folderId, parentFolderId, serviceContext);
770 }
771
772
773
774 return moveFolder(
775 userId, folderId, parentFolderId, fromLocalRepository,
776 toLocalRepository, serviceContext);
777 }
778 finally {
779 SystemEventHierarchyEntryThreadLocal.pop(Folder.class);
780 }
781 }
782
783
791 @Override
792 public void subscribeFileEntryType(
793 long userId, long groupId, long fileEntryTypeId)
794 throws PortalException {
795
796 if (fileEntryTypeId ==
797 DLFileEntryTypeConstants.FILE_ENTRY_TYPE_ID_BASIC_DOCUMENT) {
798
799 fileEntryTypeId = groupId;
800 }
801
802 subscriptionLocalService.addSubscription(
803 userId, groupId, DLFileEntryType.class.getName(), fileEntryTypeId);
804 }
805
806
814 @Override
815 public void subscribeFolder(long userId, long groupId, long folderId)
816 throws PortalException {
817
818 if (folderId == DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
819 folderId = groupId;
820 }
821
822 subscriptionLocalService.addSubscription(
823 userId, groupId, DLFolder.class.getName(), folderId);
824 }
825
826
834 @Override
835 public void unsubscribeFileEntryType(
836 long userId, long groupId, long fileEntryTypeId)
837 throws PortalException {
838
839 if (fileEntryTypeId ==
840 DLFileEntryTypeConstants.FILE_ENTRY_TYPE_ID_BASIC_DOCUMENT) {
841
842 fileEntryTypeId = groupId;
843 }
844
845 subscriptionLocalService.deleteSubscription(
846 userId, DLFileEntryType.class.getName(), fileEntryTypeId);
847 }
848
849
857 @Override
858 public void unsubscribeFolder(long userId, long groupId, long folderId)
859 throws PortalException {
860
861 if (folderId == DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
862 folderId = groupId;
863 }
864
865 subscriptionLocalService.deleteSubscription(
866 userId, DLFolder.class.getName(), folderId);
867 }
868
869
880 @Override
881 public void updateAsset(
882 long userId, FileEntry fileEntry, FileVersion fileVersion,
883 long[] assetCategoryIds, String[] assetTagNames,
884 long[] assetLinkEntryIds)
885 throws PortalException {
886
887 dlAppHelperLocalService.updateAsset(
888 userId, fileEntry, fileVersion, assetCategoryIds, assetTagNames,
889 assetLinkEntryIds);
890 }
891
892
926 @Override
927 public FileEntry updateFileEntry(
928 long userId, long fileEntryId, String sourceFileName,
929 String mimeType, String title, String description, String changeLog,
930 boolean majorVersion, byte[] bytes, ServiceContext serviceContext)
931 throws PortalException {
932
933 File file = null;
934
935 try {
936 if (ArrayUtil.isNotEmpty(bytes)) {
937 file = FileUtil.createTempFile(bytes);
938 }
939
940 return updateFileEntry(
941 userId, fileEntryId, sourceFileName, mimeType, title,
942 description, changeLog, majorVersion, file, serviceContext);
943 }
944 catch (IOException ioe) {
945 throw new SystemException("Unable to write temporary file", ioe);
946 }
947 finally {
948 FileUtil.delete(file);
949 }
950 }
951
952
986 @Override
987 public FileEntry updateFileEntry(
988 long userId, long fileEntryId, String sourceFileName,
989 String mimeType, String title, String description, String changeLog,
990 boolean majorVersion, File file, ServiceContext serviceContext)
991 throws PortalException {
992
993 if ((file == null) || !file.exists() || (file.length() == 0)) {
994 return updateFileEntry(
995 userId, fileEntryId, sourceFileName, mimeType, title,
996 description, changeLog, majorVersion, null, 0, serviceContext);
997 }
998
999 mimeType = DLAppUtil.getMimeType(sourceFileName, mimeType, title, file);
1000
1001 LocalRepository localRepository =
1002 repositoryProvider.getFileEntryLocalRepository(fileEntryId);
1003
1004 FileEntry fileEntry = localRepository.updateFileEntry(
1005 userId, fileEntryId, sourceFileName, mimeType, title, description,
1006 changeLog, majorVersion, file, serviceContext);
1007
1008 dlAppHelperLocalService.updateFileEntry(
1009 userId, fileEntry, null, fileEntry.getFileVersion(),
1010 serviceContext);
1011
1012 return fileEntry;
1013 }
1014
1015
1050 @Override
1051 public FileEntry updateFileEntry(
1052 long userId, long fileEntryId, String sourceFileName,
1053 String mimeType, String title, String description, String changeLog,
1054 boolean majorVersion, InputStream is, long size,
1055 ServiceContext serviceContext)
1056 throws PortalException {
1057
1058 if (Validator.isNull(mimeType) ||
1059 mimeType.equals(ContentTypes.APPLICATION_OCTET_STREAM)) {
1060
1061 String extension = DLAppUtil.getExtension(title, sourceFileName);
1062
1063 if (size == 0) {
1064 mimeType = MimeTypesUtil.getExtensionContentType(extension);
1065 }
1066 else {
1067 File file = null;
1068
1069 try {
1070 file = FileUtil.createTempFile(is);
1071
1072 return updateFileEntry(
1073 userId, fileEntryId, sourceFileName, mimeType, title,
1074 description, changeLog, majorVersion, file,
1075 serviceContext);
1076 }
1077 catch (IOException ioe) {
1078 throw new SystemException(
1079 "Unable to write temporary file", ioe);
1080 }
1081 finally {
1082 FileUtil.delete(file);
1083 }
1084 }
1085 }
1086
1087 LocalRepository localRepository =
1088 repositoryProvider.getFileEntryLocalRepository(fileEntryId);
1089
1090 FileEntry fileEntry = localRepository.updateFileEntry(
1091 userId, fileEntryId, sourceFileName, mimeType, title, description,
1092 changeLog, majorVersion, is, size, serviceContext);
1093
1094 dlAppHelperLocalService.updateFileEntry(
1095 userId, fileEntry, null, fileEntry.getFileVersion(),
1096 serviceContext);
1097
1098 return fileEntry;
1099 }
1100
1101
1112 @Override
1113 public DLFileRank updateFileRank(
1114 long repositoryId, long companyId, long userId, long fileEntryId,
1115 ServiceContext serviceContext) {
1116
1117 return dlFileRankLocalService.updateFileRank(
1118 repositoryId, companyId, userId, fileEntryId, serviceContext);
1119 }
1120
1121
1134 @Override
1135 public FileShortcut updateFileShortcut(
1136 long userId, long fileShortcutId, long folderId, long toFileEntryId,
1137 ServiceContext serviceContext)
1138 throws PortalException {
1139
1140 LocalRepository localRepository =
1141 repositoryProvider.getFileShortcutLocalRepository(fileShortcutId);
1142
1143 return localRepository.updateFileShortcut(
1144 userId, fileShortcutId, folderId, toFileEntryId, serviceContext);
1145 }
1146
1147
1154 @Override
1155 public void updateFileShortcuts(
1156 long oldToFileEntryId, long newToFileEntryId)
1157 throws PortalException {
1158
1159 LocalRepository localRepository =
1160 repositoryProvider.getFileEntryLocalRepository(newToFileEntryId);
1161
1162 localRepository.updateFileShortcuts(oldToFileEntryId, newToFileEntryId);
1163 }
1164
1165
1169 @Deprecated
1170 @Override
1171 public void updateFileShortcuts(
1172 long toRepositoryId, long oldToFileEntryId, long newToFileEntryId)
1173 throws PortalException {
1174
1175 updateFileShortcuts(oldToFileEntryId, newToFileEntryId);
1176 }
1177
1178
1199 @Override
1200 public Folder updateFolder(
1201 long folderId, long parentFolderId, String name, String description,
1202 ServiceContext serviceContext)
1203 throws PortalException {
1204
1205 LocalRepository localRepository =
1206 repositoryProvider.getFolderLocalRepository(folderId);
1207
1208 Folder folder = localRepository.updateFolder(
1209 folderId, parentFolderId, name, description, serviceContext);
1210
1211 if (folderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
1212 dlAppHelperLocalService.updateFolder(
1213 serviceContext.getUserId(), folder, serviceContext);
1214 }
1215
1216 return folder;
1217 }
1218
1219 protected FileEntry copyFileEntry(
1220 long userId, LocalRepository toLocalRepository, FileEntry fileEntry,
1221 long newFolderId, ServiceContext serviceContext)
1222 throws PortalException {
1223
1224 List<FileVersion> fileVersions = fileEntry.getFileVersions(
1225 WorkflowConstants.STATUS_ANY);
1226
1227 FileVersion latestFileVersion = fileVersions.get(
1228 fileVersions.size() - 1);
1229
1230 String sourceFileName = DLAppUtil.getSourceFileName(latestFileVersion);
1231
1232 FileEntry destinationFileEntry = toLocalRepository.addFileEntry(
1233 userId, newFolderId, sourceFileName,
1234 latestFileVersion.getMimeType(), latestFileVersion.getTitle(),
1235 latestFileVersion.getDescription(), StringPool.BLANK,
1236 latestFileVersion.getContentStream(false),
1237 latestFileVersion.getSize(), serviceContext);
1238
1239 for (int i = fileVersions.size() - 2; i >= 0; i--) {
1240 FileVersion fileVersion = fileVersions.get(i);
1241
1242 sourceFileName = DLAppUtil.getSourceFileName(fileVersion);
1243
1244 FileVersion previousFileVersion = fileVersions.get(i + 1);
1245
1246 try {
1247 destinationFileEntry = toLocalRepository.updateFileEntry(
1248 userId, destinationFileEntry.getFileEntryId(),
1249 sourceFileName, destinationFileEntry.getMimeType(),
1250 destinationFileEntry.getTitle(),
1251 destinationFileEntry.getDescription(), StringPool.BLANK,
1252 DLAppUtil.isMajorVersion(fileVersion, previousFileVersion),
1253 fileVersion.getContentStream(false), fileVersion.getSize(),
1254 serviceContext);
1255 }
1256 catch (PortalException pe) {
1257 toLocalRepository.deleteFileEntry(
1258 destinationFileEntry.getFileEntryId());
1259
1260 throw pe;
1261 }
1262 }
1263
1264 return destinationFileEntry;
1265 }
1266
1267 protected Folder copyFolder(
1268 long userId, long folderId, long parentFolderId,
1269 LocalRepository fromLocalRepository,
1270 LocalRepository toLocalRepository, ServiceContext serviceContext)
1271 throws PortalException {
1272
1273 Folder newFolder = null;
1274
1275 try {
1276 Folder folder = fromLocalRepository.getFolder(folderId);
1277
1278 newFolder = toLocalRepository.addFolder(
1279 userId, parentFolderId, folder.getName(),
1280 folder.getDescription(), serviceContext);
1281
1282 dlAppHelperLocalService.addFolder(
1283 userId, newFolder, serviceContext);
1284
1285 copyFolderDependencies(
1286 userId, folder, newFolder, fromLocalRepository,
1287 toLocalRepository, serviceContext);
1288
1289 return newFolder;
1290 }
1291 catch (PortalException pe) {
1292 if (newFolder != null) {
1293 toLocalRepository.deleteFolder(newFolder.getFolderId());
1294 }
1295
1296 throw pe;
1297 }
1298 }
1299
1300 protected void copyFolderDependencies(
1301 long userId, Folder sourceFolder, Folder destinationFolder,
1302 LocalRepository fromLocalRepository,
1303 LocalRepository toLocalRepository, ServiceContext serviceContext)
1304 throws PortalException {
1305
1306 List<RepositoryEntry> repositoryEntries =
1307 fromLocalRepository.getFoldersAndFileEntriesAndFileShortcuts(
1308 sourceFolder.getFolderId(), WorkflowConstants.STATUS_ANY, true,
1309 QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1310
1311 for (RepositoryEntry repositoryEntry : repositoryEntries) {
1312 if (repositoryEntry instanceof FileEntry) {
1313 FileEntry fileEntry = (FileEntry)repositoryEntry;
1314
1315 copyFileEntry(
1316 userId, toLocalRepository, fileEntry,
1317 destinationFolder.getFolderId(), serviceContext);
1318 }
1319 else if (repositoryEntry instanceof FileShortcut) {
1320 if (destinationFolder.isSupportsShortcuts()) {
1321 FileShortcut fileShortcut = (FileShortcut)repositoryEntry;
1322
1323 toLocalRepository.addFileShortcut(
1324 userId, destinationFolder.getFolderId(),
1325 fileShortcut.getToFileEntryId(), serviceContext);
1326 }
1327 }
1328 else if (repositoryEntry instanceof Folder) {
1329 Folder currentFolder = (Folder)repositoryEntry;
1330
1331 Folder newFolder = toLocalRepository.addFolder(
1332 userId, destinationFolder.getFolderId(),
1333 currentFolder.getName(), currentFolder.getDescription(),
1334 serviceContext);
1335
1336 dlAppHelperLocalService.addFolder(
1337 userId, newFolder, serviceContext);
1338
1339 copyFolderDependencies(
1340 userId, currentFolder, newFolder, fromLocalRepository,
1341 toLocalRepository, serviceContext);
1342 }
1343 }
1344 }
1345
1346 protected void deleteFileEntry(
1347 long oldFileEntryId, long newFileEntryId,
1348 LocalRepository fromLocalRepository,
1349 LocalRepository toLocalRepository)
1350 throws PortalException {
1351
1352 try {
1353 FileEntry fileEntry = fromLocalRepository.getFileEntry(
1354 oldFileEntryId);
1355
1356 fromLocalRepository.deleteFileEntry(oldFileEntryId);
1357
1358 dlAppHelperLocalService.deleteFileEntry(fileEntry);
1359 }
1360 catch (PortalException pe) {
1361 FileEntry fileEntry = toLocalRepository.getFileEntry(
1362 newFileEntryId);
1363
1364 toLocalRepository.deleteFileEntry(newFileEntryId);
1365
1366 dlAppHelperLocalService.deleteFileEntry(fileEntry);
1367
1368 throw pe;
1369 }
1370 }
1371
1372 protected void deleteRepository(LocalRepository localRepository)
1373 throws PortalException {
1374
1375 long repositoryId = localRepository.getRepositoryId();
1376
1377 dlAppHelperLocalService.deleteRepositoryFileEntries(repositoryId);
1378
1379 localRepository.deleteAll();
1380
1381 repositoryLocalService.deleteRepository(repositoryId);
1382 }
1383
1384 protected LocalRepository getFolderLocalRepository(
1385 long folderId, long groupId)
1386 throws PortalException {
1387
1388 if (folderId == DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
1389 return getLocalRepository(groupId);
1390 }
1391
1392 return repositoryProvider.getFolderLocalRepository(folderId);
1393 }
1394
1395 protected LocalRepository getLocalRepository(long repositoryId)
1396 throws PortalException {
1397
1398 try {
1399 return repositoryProvider.getLocalRepository(repositoryId);
1400 }
1401 catch (InvalidRepositoryIdException irie) {
1402 StringBundler sb = new StringBundler(3);
1403
1404 sb.append("No Group exists with the key {repositoryId=");
1405 sb.append(repositoryId);
1406 sb.append("}");
1407
1408 throw new NoSuchGroupException(sb.toString(), irie);
1409 }
1410 }
1411
1412 protected FileEntry moveFileEntry(
1413 long userId, long fileEntryId, long newFolderId,
1414 LocalRepository fromLocalRepository,
1415 LocalRepository toLocalRepository, ServiceContext serviceContext)
1416 throws PortalException {
1417
1418 FileEntry sourceFileEntry = fromLocalRepository.getFileEntry(
1419 fileEntryId);
1420
1421 FileEntry destinationFileEntry = copyFileEntry(
1422 userId, toLocalRepository, sourceFileEntry, newFolderId,
1423 serviceContext);
1424
1425 deleteFileEntry(
1426 fileEntryId, destinationFileEntry.getFileEntryId(),
1427 fromLocalRepository, toLocalRepository);
1428
1429 return destinationFileEntry;
1430 }
1431
1432 protected Folder moveFolder(
1433 long userId, long folderId, long parentFolderId,
1434 LocalRepository fromLocalRepository,
1435 LocalRepository toLocalRepository, ServiceContext serviceContext)
1436 throws PortalException {
1437
1438 Folder newFolder = copyFolder(
1439 userId, folderId, parentFolderId, fromLocalRepository,
1440 toLocalRepository, serviceContext);
1441
1442 fromLocalRepository.deleteFolder(folderId);
1443
1444 return newFolder;
1445 }
1446
1447 @BeanReference(type = RepositoryProvider.class)
1448 protected RepositoryProvider repositoryProvider;
1449
1450 private static final Log _log = LogFactoryUtil.getLog(
1451 DLAppLocalServiceImpl.class);
1452
1453 }