001
014
015 package com.liferay.portlet.documentlibrary.lar;
016
017 import com.liferay.portal.kernel.exception.PortalException;
018 import com.liferay.portal.kernel.exception.SystemException;
019 import com.liferay.portal.kernel.lar.BasePortletDataHandler;
020 import com.liferay.portal.kernel.lar.PortletDataContext;
021 import com.liferay.portal.kernel.lar.PortletDataHandlerBoolean;
022 import com.liferay.portal.kernel.lar.PortletDataHandlerControl;
023 import com.liferay.portal.kernel.log.Log;
024 import com.liferay.portal.kernel.log.LogFactoryUtil;
025 import com.liferay.portal.kernel.repository.model.FileEntry;
026 import com.liferay.portal.kernel.repository.model.FileVersion;
027 import com.liferay.portal.kernel.repository.model.Folder;
028 import com.liferay.portal.kernel.search.Indexer;
029 import com.liferay.portal.kernel.search.IndexerRegistryUtil;
030 import com.liferay.portal.kernel.util.ArrayUtil;
031 import com.liferay.portal.kernel.util.FileUtil;
032 import com.liferay.portal.kernel.util.GetterUtil;
033 import com.liferay.portal.kernel.util.MapUtil;
034 import com.liferay.portal.kernel.util.StringBundler;
035 import com.liferay.portal.kernel.util.StringPool;
036 import com.liferay.portal.kernel.util.StringUtil;
037 import com.liferay.portal.kernel.util.Validator;
038 import com.liferay.portal.kernel.xml.Document;
039 import com.liferay.portal.kernel.xml.Element;
040 import com.liferay.portal.kernel.xml.SAXReaderUtil;
041 import com.liferay.portal.model.Group;
042 import com.liferay.portal.model.Repository;
043 import com.liferay.portal.model.RepositoryEntry;
044 import com.liferay.portal.repository.liferayrepository.LiferayRepository;
045 import com.liferay.portal.repository.liferayrepository.model.LiferayFileEntry;
046 import com.liferay.portal.service.GroupLocalServiceUtil;
047 import com.liferay.portal.service.RepositoryEntryLocalServiceUtil;
048 import com.liferay.portal.service.RepositoryLocalServiceUtil;
049 import com.liferay.portal.service.ServiceContext;
050 import com.liferay.portal.service.persistence.RepositoryEntryUtil;
051 import com.liferay.portal.service.persistence.RepositoryUtil;
052 import com.liferay.portal.util.PortalUtil;
053 import com.liferay.portal.util.PortletKeys;
054 import com.liferay.portal.util.PropsValues;
055 import com.liferay.portlet.documentlibrary.DuplicateFileException;
056 import com.liferay.portlet.documentlibrary.NoSuchFileException;
057 import com.liferay.portlet.documentlibrary.model.DLFileEntry;
058 import com.liferay.portlet.documentlibrary.model.DLFileEntryMetadata;
059 import com.liferay.portlet.documentlibrary.model.DLFileEntryType;
060 import com.liferay.portlet.documentlibrary.model.DLFileRank;
061 import com.liferay.portlet.documentlibrary.model.DLFileShortcut;
062 import com.liferay.portlet.documentlibrary.model.DLFileVersion;
063 import com.liferay.portlet.documentlibrary.model.DLFolder;
064 import com.liferay.portlet.documentlibrary.model.DLFolderConstants;
065 import com.liferay.portlet.documentlibrary.service.DLAppLocalServiceUtil;
066 import com.liferay.portlet.documentlibrary.service.DLAppServiceUtil;
067 import com.liferay.portlet.documentlibrary.service.DLFileEntryMetadataLocalServiceUtil;
068 import com.liferay.portlet.documentlibrary.service.DLFileEntryTypeLocalServiceUtil;
069 import com.liferay.portlet.documentlibrary.service.DLFileEntryTypeServiceUtil;
070 import com.liferay.portlet.documentlibrary.service.DLFileVersionLocalServiceUtil;
071 import com.liferay.portlet.documentlibrary.service.persistence.DLFileEntryTypeUtil;
072 import com.liferay.portlet.documentlibrary.service.persistence.DLFileRankUtil;
073 import com.liferay.portlet.documentlibrary.service.persistence.DLFileShortcutUtil;
074 import com.liferay.portlet.documentlibrary.util.DLProcessorRegistryUtil;
075 import com.liferay.portlet.documentlibrary.util.DLProcessorThreadLocal;
076 import com.liferay.portlet.documentlibrary.util.DLUtil;
077 import com.liferay.portlet.dynamicdatamapping.lar.DDMPortletDataHandlerImpl;
078 import com.liferay.portlet.dynamicdatamapping.model.DDMStructure;
079 import com.liferay.portlet.dynamicdatamapping.service.DDMStructureLocalServiceUtil;
080 import com.liferay.portlet.dynamicdatamapping.storage.Fields;
081 import com.liferay.portlet.dynamicdatamapping.storage.StorageEngineUtil;
082 import com.liferay.util.PwdGenerator;
083
084 import java.io.IOException;
085 import java.io.InputStream;
086
087 import java.util.ArrayList;
088 import java.util.Collection;
089 import java.util.List;
090 import java.util.Map;
091
092 import javax.portlet.PortletPreferences;
093
094
099 public class DLPortletDataHandlerImpl extends BasePortletDataHandler {
100
101 public static void exportFileEntry(
102 PortletDataContext portletDataContext,
103 Element fileEntryTypesElement, Element foldersElement,
104 Element fileEntriesElement, Element fileRanksElement,
105 Element repositoriesElement, Element repositoryEntriesElement,
106 FileEntry fileEntry, boolean checkDateRange)
107 throws Exception {
108
109 if (checkDateRange &&
110 !portletDataContext.isWithinDateRange(
111 fileEntry.getModifiedDate())) {
112
113 return;
114 }
115
116 if (!fileEntry.isDefaultRepository()) {
117 Repository repository = RepositoryUtil.findByPrimaryKey(
118 fileEntry.getRepositoryId());
119
120 exportRepository(
121 portletDataContext, repositoriesElement,
122 repositoryEntriesElement, repository);
123
124 return;
125 }
126
127 FileVersion fileVersion = fileEntry.getFileVersion();
128
129 if (!fileVersion.isApproved() && !fileVersion.isInTrash()) {
130 return;
131 }
132
133 String path = getFileEntryPath(portletDataContext, fileEntry);
134
135 if (!portletDataContext.isPathNotProcessed(path)) {
136 return;
137 }
138
139 Element fileEntryElement = fileEntriesElement.addElement("file-entry");
140
141 if (foldersElement != null) {
142 exportParentFolder(
143 portletDataContext, fileEntryTypesElement, foldersElement,
144 repositoriesElement, repositoryEntriesElement,
145 fileEntry.getFolderId());
146 }
147
148 if (!portletDataContext.isPerformDirectBinaryImport()) {
149 InputStream is = null;
150
151 try {
152 is = FileEntryUtil.getContentStream(fileEntry);
153 }
154 catch (NoSuchFileException nsfe) {
155 }
156
157 if (is == null) {
158 if (_log.isWarnEnabled()) {
159 _log.warn(
160 "No file found for file entry " +
161 fileEntry.getFileEntryId());
162 }
163
164 fileEntryElement.detach();
165
166 return;
167 }
168
169 try {
170 String binPath = getFileEntryBinPath(
171 portletDataContext, fileEntry);
172
173 portletDataContext.addZipEntry(binPath, is);
174
175 fileEntryElement.addAttribute("bin-path", binPath);
176 }
177 finally {
178 try {
179 is.close();
180 }
181 catch (IOException ioe) {
182 _log.error(ioe, ioe);
183 }
184 }
185 }
186
187 if (portletDataContext.getBooleanParameter(_NAMESPACE, "ranks")) {
188 List<DLFileRank> fileRanks = DLFileRankUtil.findByFileEntryId(
189 fileEntry.getFileEntryId());
190
191 for (DLFileRank fileRank : fileRanks) {
192 exportFileRank(portletDataContext, fileRanksElement, fileRank);
193 }
194 }
195
196 if (portletDataContext.getBooleanParameter(
197 _NAMESPACE, "previews-and-thumbnails")) {
198
199 DLProcessorRegistryUtil.exportGeneratedFiles(
200 portletDataContext, fileEntry, fileEntryElement);
201 }
202
203 exportMetaData(
204 portletDataContext, fileEntryTypesElement, fileEntryElement,
205 fileEntry);
206
207 portletDataContext.addClassedModel(
208 fileEntryElement, path, fileEntry, _NAMESPACE);
209 }
210
211 public static String getFileEntryPath(
212 PortletDataContext portletDataContext, FileEntry fileEntry) {
213
214 StringBundler sb = new StringBundler(6);
215
216 sb.append(
217 portletDataContext.getPortletPath(PortletKeys.DOCUMENT_LIBRARY));
218 sb.append("/file-entries/");
219 sb.append(fileEntry.getFileEntryId());
220 sb.append(StringPool.SLASH);
221 sb.append(fileEntry.getVersion());
222 sb.append(".xml");
223
224 return sb.toString();
225 }
226
227 public static PortletDataHandlerControl[] getMetadataControls() {
228 return _metadataControls;
229 }
230
231 public static String getRepositoryEntryPath(
232 PortletDataContext portletDataContext, long repositoryEntryId) {
233
234 StringBundler sb = new StringBundler(4);
235
236 sb.append(
237 portletDataContext.getPortletPath(PortletKeys.DOCUMENT_LIBRARY));
238 sb.append("/repository-entries/");
239 sb.append(repositoryEntryId);
240 sb.append(".xml");
241
242 return sb.toString();
243 }
244
245 public static void importFileEntry(
246 PortletDataContext portletDataContext, Element fileEntryElement)
247 throws Exception {
248
249 String path = fileEntryElement.attributeValue("path");
250
251 if (!portletDataContext.isPathNotProcessed(path)) {
252 return;
253 }
254
255 boolean dlProcessorEnabled = DLProcessorThreadLocal.isEnabled();
256
257 try {
258 DLProcessorThreadLocal.setEnabled(false);
259
260 importFileEntry(portletDataContext, fileEntryElement, path);
261 }
262 finally {
263 DLProcessorThreadLocal.setEnabled(dlProcessorEnabled);
264 }
265 }
266
267 public static void importFileEntry(
268 PortletDataContext portletDataContext, Element fileEntryElement,
269 String path)
270 throws Exception {
271
272 FileEntry fileEntry = (FileEntry)portletDataContext.getZipEntryAsObject(
273 path);
274
275 long userId = portletDataContext.getUserId(fileEntry.getUserUuid());
276
277 Map<Long, Long> folderIds =
278 (Map<Long, Long>)portletDataContext.getNewPrimaryKeysMap(
279 DLFolder.class);
280
281 long folderId = MapUtil.getLong(
282 folderIds, fileEntry.getFolderId(), fileEntry.getFolderId());
283
284 long[] assetCategoryIds = null;
285 String[] assetTagNames = null;
286
287 if (portletDataContext.getBooleanParameter(_NAMESPACE, "categories")) {
288 assetCategoryIds = portletDataContext.getAssetCategoryIds(
289 DLFileEntry.class, fileEntry.getFileEntryId());
290 }
291
292 if (portletDataContext.getBooleanParameter(_NAMESPACE, "tags")) {
293 assetTagNames = portletDataContext.getAssetTagNames(
294 DLFileEntry.class, fileEntry.getFileEntryId());
295 }
296
297 ServiceContext serviceContext = portletDataContext.createServiceContext(
298 fileEntryElement, fileEntry, _NAMESPACE);
299
300 serviceContext.setAttribute(
301 "sourceFileName", "A." + fileEntry.getExtension());
302 serviceContext.setUserId(userId);
303
304 String binPath = fileEntryElement.attributeValue("bin-path");
305
306 InputStream is = null;
307
308 if (Validator.isNull(binPath) &&
309 portletDataContext.isPerformDirectBinaryImport()) {
310
311 try {
312 is = FileEntryUtil.getContentStream(fileEntry);
313 }
314 catch (NoSuchFileException nsfe) {
315 }
316 }
317 else {
318 is = portletDataContext.getZipEntryAsInputStream(binPath);
319 }
320
321 if (is == null) {
322 if (_log.isWarnEnabled()) {
323 _log.warn(
324 "No file found for file entry " +
325 fileEntry.getFileEntryId());
326 }
327
328 return;
329 }
330
331 if ((folderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) &&
332 (folderId == fileEntry.getFolderId())) {
333
334 String folderPath = getImportFolderPath(
335 portletDataContext, folderId);
336
337 Folder folder = (Folder)portletDataContext.getZipEntryAsObject(
338 folderPath);
339
340 Document document = fileEntryElement.getDocument();
341
342 Element rootElement = document.getRootElement();
343
344 Element folderElement = (Element)rootElement.selectSingleNode(
345 "
346
347 importFolder(portletDataContext, folderPath, folderElement, folder);
348
349 folderId = MapUtil.getLong(
350 folderIds, fileEntry.getFolderId(), fileEntry.getFolderId());
351 }
352
353 importMetaData(portletDataContext, fileEntryElement, serviceContext);
354
355 FileEntry importedFileEntry = null;
356
357 String titleWithExtension = DLUtil.getTitleWithExtension(fileEntry);
358 String extension = fileEntry.getExtension();
359
360 String dotExtension = StringPool.PERIOD + extension;
361
362 if (portletDataContext.isDataStrategyMirror()) {
363 FileEntry existingFileEntry = FileEntryUtil.fetchByUUID_R(
364 fileEntry.getUuid(), portletDataContext.getScopeGroupId());
365
366 FileVersion fileVersion = fileEntry.getFileVersion();
367
368 if (existingFileEntry == null) {
369 String fileEntryTitle = fileEntry.getTitle();
370
371 FileEntry existingTitleFileEntry = FileEntryUtil.fetchByR_F_T(
372 portletDataContext.getScopeGroupId(), folderId,
373 fileEntryTitle);
374
375 if (existingTitleFileEntry != null) {
376 if ((fileEntry.getGroupId() ==
377 portletDataContext.getSourceGroupId()) &&
378 portletDataContext.
379 isDataStrategyMirrorWithOverwriting()) {
380
381 DLAppLocalServiceUtil.deleteFileEntry(
382 existingTitleFileEntry.getFileEntryId());
383 }
384 else {
385 boolean titleHasExtension = false;
386
387 if (fileEntryTitle.endsWith(dotExtension)) {
388 fileEntryTitle = FileUtil.stripExtension(
389 fileEntryTitle);
390
391 titleHasExtension = true;
392 }
393
394 for (int i = 1;; i++) {
395 fileEntryTitle += StringPool.SPACE + i;
396
397 titleWithExtension = fileEntryTitle + dotExtension;
398
399 existingTitleFileEntry = FileEntryUtil.fetchByR_F_T(
400 portletDataContext.getScopeGroupId(), folderId,
401 titleWithExtension);
402
403 if (existingTitleFileEntry == null) {
404 if (titleHasExtension) {
405 fileEntryTitle += dotExtension;
406 }
407
408 break;
409 }
410 }
411 }
412 }
413
414 serviceContext.setAttribute(
415 "fileVersionUuid", fileVersion.getUuid());
416 serviceContext.setUuid(fileEntry.getUuid());
417
418 importedFileEntry = DLAppLocalServiceUtil.addFileEntry(
419 userId, portletDataContext.getScopeGroupId(), folderId,
420 titleWithExtension, fileEntry.getMimeType(), fileEntryTitle,
421 fileEntry.getDescription(), null, is, fileEntry.getSize(),
422 serviceContext);
423
424 if (fileVersion.isInTrash()) {
425 importedFileEntry = DLAppServiceUtil.moveFileEntryToTrash(
426 importedFileEntry.getFileEntryId());
427 }
428 }
429 else {
430 FileVersion latestExistingFileVersion =
431 existingFileEntry.getLatestFileVersion();
432
433 boolean indexEnabled = serviceContext.isIndexingEnabled();
434
435 try {
436 serviceContext.setIndexingEnabled(false);
437
438 if (!fileVersion.getUuid().equals(
439 latestExistingFileVersion.getUuid())) {
440
441 DLFileVersion alreadyExistingFileVersion =
442 DLFileVersionLocalServiceUtil.
443 getFileVersionByUuidAndGroupId(
444 fileVersion.getUuid(),
445 existingFileEntry.getGroupId());
446
447 if (alreadyExistingFileVersion != null) {
448 serviceContext.setAttribute(
449 "existingDLFileVersionId",
450 alreadyExistingFileVersion.getFileVersionId());
451 }
452
453 serviceContext.setUuid(fileVersion.getUuid());
454
455 importedFileEntry =
456 DLAppLocalServiceUtil.updateFileEntry(
457 userId, existingFileEntry.getFileEntryId(),
458 fileEntry.getTitle(), fileEntry.getMimeType(),
459 fileEntry.getTitle(),
460 fileEntry.getDescription(), null, false, is,
461 fileEntry.getSize(), serviceContext);
462 }
463 else {
464 DLAppLocalServiceUtil.updateAsset(
465 userId, existingFileEntry,
466 latestExistingFileVersion, assetCategoryIds,
467 assetTagNames, null);
468
469 importedFileEntry = existingFileEntry;
470 }
471
472 if (importedFileEntry.getFolderId() != folderId) {
473 importedFileEntry = DLAppLocalServiceUtil.moveFileEntry(
474 userId, importedFileEntry.getFileEntryId(),
475 folderId, serviceContext);
476 }
477
478 if (importedFileEntry instanceof LiferayFileEntry) {
479 LiferayFileEntry liferayFileEntry =
480 (LiferayFileEntry)importedFileEntry;
481
482 Indexer indexer = IndexerRegistryUtil.getIndexer(
483 DLFileEntry.class);
484
485 indexer.reindex(liferayFileEntry.getModel());
486 }
487 }
488 finally {
489 serviceContext.setIndexingEnabled(indexEnabled);
490 }
491 }
492 }
493 else {
494 try {
495 importedFileEntry = DLAppLocalServiceUtil.addFileEntry(
496 userId, portletDataContext.getScopeGroupId(), folderId,
497 titleWithExtension, fileEntry.getMimeType(),
498 fileEntry.getTitle(), fileEntry.getDescription(), null, is,
499 fileEntry.getSize(), serviceContext);
500 }
501 catch (DuplicateFileException dfe) {
502 String title = fileEntry.getTitle();
503
504 String[] titleParts = title.split("\\.", 2);
505
506 title = titleParts[0] + PwdGenerator.getPassword();
507
508 if (titleParts.length > 1) {
509 title += StringPool.PERIOD + titleParts[1];
510 }
511
512 if (!title.endsWith(dotExtension)) {
513 title += dotExtension;
514 }
515
516 importedFileEntry = DLAppLocalServiceUtil.addFileEntry(
517 userId, portletDataContext.getScopeGroupId(), folderId,
518 title, fileEntry.getMimeType(), title,
519 fileEntry.getDescription(), null, is, fileEntry.getSize(),
520 serviceContext);
521 }
522 }
523
524 if (portletDataContext.getBooleanParameter(
525 _NAMESPACE, "previews-and-thumbnails")) {
526
527 DLProcessorRegistryUtil.importGeneratedFiles(
528 portletDataContext, fileEntry, importedFileEntry,
529 fileEntryElement);
530 }
531
532 Map<String, String> fileEntryTitles =
533 (Map<String, String>)portletDataContext.getNewPrimaryKeysMap(
534 DLFileEntry.class.getName() + ".title");
535
536 fileEntryTitles.put(fileEntry.getTitle(), importedFileEntry.getTitle());
537
538 portletDataContext.importClassedModel(
539 fileEntry, importedFileEntry, _NAMESPACE);
540 }
541
542 public static void importFileRank(
543 PortletDataContext portletDataContext, Element fileRankElement)
544 throws Exception {
545
546 String path = fileRankElement.attributeValue("path");
547
548 if (!portletDataContext.isPathNotProcessed(path)) {
549 return;
550 }
551
552 DLFileRank fileRank =
553 (DLFileRank)portletDataContext.getZipEntryAsObject(path);
554
555 String fileEntryUuid = fileRankElement.attributeValue(
556 "file-entry-uuid");
557
558 importFileRank(portletDataContext, fileRank, fileEntryUuid);
559 }
560
561 public static void importFolder(
562 PortletDataContext portletDataContext, Element folderElement)
563 throws Exception {
564
565 String path = folderElement.attributeValue("path");
566
567 if (!portletDataContext.isPathNotProcessed(path)) {
568 return;
569 }
570
571 Folder folder = (Folder)portletDataContext.getZipEntryAsObject(path);
572
573 importFolder(portletDataContext, path, folderElement, folder);
574 }
575
576 public static void importRepository(
577 PortletDataContext portletDataContext, Element repositoryElement)
578 throws Exception {
579
580 String path = repositoryElement.attributeValue("path");
581
582 if (!portletDataContext.isPathNotProcessed(path)) {
583 return;
584 }
585
586 Repository repository =
587 (Repository)portletDataContext.getZipEntryAsObject(
588 repositoryElement, path);
589
590 long userId = portletDataContext.getUserId(repository.getUserUuid());
591
592 ServiceContext serviceContext = portletDataContext.createServiceContext(
593 repositoryElement, repository, _NAMESPACE);
594
595 long importedRepositoryId = 0;
596
597 try {
598 if (portletDataContext.isDataStrategyMirror()) {
599 Repository existingRepository = RepositoryUtil.fetchByUUID_G(
600 repository.getUuid(), portletDataContext.getScopeGroupId());
601
602 if (existingRepository == null) {
603 existingRepository =
604 RepositoryLocalServiceUtil.fetchRepository(
605 portletDataContext.getScopeGroupId(),
606 repository.getName());
607 }
608
609 long classNameId = 0;
610
611 if (existingRepository != null) {
612 classNameId = existingRepository.getClassNameId();
613 }
614
615 if ((existingRepository == null) ||
616 (classNameId !=
617 PortalUtil.getClassNameId(LiferayRepository.class))) {
618
619 serviceContext.setUuid(repository.getUuid());
620
621 importedRepositoryId =
622 RepositoryLocalServiceUtil.addRepository(
623 userId, portletDataContext.getScopeGroupId(),
624 repository.getClassNameId(),
625 DLFolderConstants.DEFAULT_PARENT_FOLDER_ID,
626 repository.getName(), repository.getDescription(),
627 repository.getPortletId(),
628 repository.getTypeSettingsProperties(), false,
629 serviceContext);
630 }
631 else {
632 RepositoryLocalServiceUtil.updateRepository(
633 existingRepository.getRepositoryId(),
634 repository.getName(), repository.getDescription());
635
636 importedRepositoryId = existingRepository.getRepositoryId();
637 }
638 }
639 else {
640 importedRepositoryId = RepositoryLocalServiceUtil.addRepository(
641 userId, portletDataContext.getScopeGroupId(),
642 repository.getClassNameId(),
643 DLFolderConstants.DEFAULT_PARENT_FOLDER_ID,
644 repository.getName(), repository.getDescription(),
645 repository.getPortletId(),
646 repository.getTypeSettingsProperties(), false,
647 serviceContext);
648 }
649 }
650 catch (Exception e) {
651 if (_log.isWarnEnabled()) {
652 _log.warn(
653 "Unable to connect to repository {name=" +
654 repository.getName() + ", typeSettings=" +
655 repository.getTypeSettingsProperties() + "}",
656 e);
657 }
658 }
659
660 Repository importedRepository =
661 RepositoryLocalServiceUtil.getRepository(importedRepositoryId);
662
663 portletDataContext.importClassedModel(
664 repository, importedRepository, _NAMESPACE);
665 }
666
667 public static void importRepositoryEntry(
668 PortletDataContext portletDataContext,
669 Element repositoryEntryElement)
670 throws Exception {
671
672 String path = repositoryEntryElement.attributeValue("path");
673
674 if (!portletDataContext.isPathNotProcessed(path)) {
675 return;
676 }
677
678 RepositoryEntry repositoryEntry =
679 (RepositoryEntry)portletDataContext.getZipEntryAsObject(path);
680
681 Map<Long, Long> repositoryIds =
682 (Map<Long, Long>)portletDataContext.getNewPrimaryKeysMap(
683 Repository.class);
684
685 long repositoryId = MapUtil.getLong(
686 repositoryIds, repositoryEntry.getRepositoryId(),
687 repositoryEntry.getRepositoryId());
688
689 ServiceContext serviceContext = portletDataContext.createServiceContext(
690 repositoryEntryElement, repositoryEntry, _NAMESPACE);
691
692 RepositoryEntry importedRepositoryEntry = null;
693
694 if (portletDataContext.isDataStrategyMirror()) {
695 RepositoryEntry existingRepositoryEntry =
696 RepositoryEntryUtil.fetchByUUID_G(
697 repositoryEntry.getUuid(),
698 portletDataContext.getScopeGroupId());
699
700 if (existingRepositoryEntry == null) {
701 serviceContext.setUuid(repositoryEntry.getUuid());
702
703 importedRepositoryEntry =
704 RepositoryEntryLocalServiceUtil.addRepositoryEntry(
705 portletDataContext.getScopeGroupId(), repositoryId,
706 repositoryEntry.getMappedId(), serviceContext);
707 }
708 else {
709 importedRepositoryEntry =
710 RepositoryEntryLocalServiceUtil.updateRepositoryEntry(
711 existingRepositoryEntry.getRepositoryEntryId(),
712 repositoryEntry.getMappedId());
713 }
714 }
715 else {
716 importedRepositoryEntry =
717 RepositoryEntryLocalServiceUtil.addRepositoryEntry(
718 portletDataContext.getScopeGroupId(), repositoryId,
719 repositoryEntry.getMappedId(), serviceContext);
720 }
721
722 Map<Long, Long> repositoryEntryIds =
723 (Map<Long, Long>)portletDataContext.getNewPrimaryKeysMap(
724 RepositoryEntry.class);
725
726 repositoryEntryIds.put(
727 repositoryEntry.getRepositoryEntryId(),
728 importedRepositoryEntry.getRepositoryEntryId());
729
730 portletDataContext.importClassedModel(
731 repositoryEntry, importedRepositoryEntry, _NAMESPACE);
732 }
733
734 @Override
735 public String[] getDataPortletPreferences() {
736 return new String[] {"rootFolderId"};
737 }
738
739 @Override
740 public PortletDataHandlerControl[] getExportControls() {
741 return new PortletDataHandlerControl[] {
742 _foldersAndDocuments, _shortcuts, _previewsAndThumbnails, _ranks
743 };
744 }
745
746 @Override
747 public PortletDataHandlerControl[] getExportMetadataControls() {
748 return new PortletDataHandlerControl[] {
749 new PortletDataHandlerBoolean(
750 _NAMESPACE, "folders-and-documents", true, _metadataControls)
751 };
752 }
753
754 @Override
755 public PortletDataHandlerControl[] getImportControls() {
756 return new PortletDataHandlerControl[] {
757 _foldersAndDocuments, _shortcuts, _previewsAndThumbnails, _ranks
758 };
759 }
760
761 @Override
762 public PortletDataHandlerControl[] getImportMetadataControls() {
763 return new PortletDataHandlerControl[] {
764 new PortletDataHandlerBoolean(
765 _NAMESPACE, "folders-and-documents", true, _metadataControls)
766 };
767 }
768
769 @Override
770 public boolean isAlwaysExportable() {
771 return _ALWAYS_EXPORTABLE;
772 }
773
774 @Override
775 public boolean isDataLocalized() {
776 return _DATA_LOCALIZED;
777 }
778
779 @Override
780 public boolean isPublishToLiveByDefault() {
781 return PropsValues.DL_PUBLISH_TO_LIVE_BY_DEFAULT;
782 }
783
784 protected static void exportFileEntryType(
785 PortletDataContext portletDataContext,
786 Element fileEntryTypesElement, DLFileEntryType dlFileEntryType)
787 throws Exception {
788
789 String path = getFileEntryTypePath(portletDataContext, dlFileEntryType);
790
791 if (!portletDataContext.isPathNotProcessed(path)) {
792 return;
793 }
794
795 Element fileEntryTypeElement = fileEntryTypesElement.addElement(
796 "file-entry-type");
797
798 List<DDMStructure> ddmStructures = dlFileEntryType.getDDMStructures();
799
800 String[] ddmStructureUuids = new String[ddmStructures.size()];
801
802 for (int i = 0; i < ddmStructures.size(); i++) {
803 DDMStructure ddmStructure = ddmStructures.get(i);
804
805 ddmStructureUuids[i] = ddmStructure.getUuid();
806
807 DDMPortletDataHandlerImpl.exportStructure(
808 portletDataContext, fileEntryTypeElement, ddmStructure);
809 }
810
811 fileEntryTypeElement.addAttribute(
812 "structureUuids", StringUtil.merge(ddmStructureUuids));
813
814 portletDataContext.addClassedModel(
815 fileEntryTypeElement, path, dlFileEntryType, _NAMESPACE);
816 }
817
818 protected static void exportFileRank(
819 PortletDataContext portletDataContext, Element fileRanksElement,
820 DLFileRank fileRank)
821 throws Exception {
822
823 String path = getFileRankPath(portletDataContext, fileRank);
824
825 if (!portletDataContext.isPathNotProcessed(path)) {
826 return;
827 }
828
829 Element fileRankElement = fileRanksElement.addElement("file-rank");
830
831 FileEntry fileEntry = FileEntryUtil.fetchByPrimaryKey(
832 fileRank.getFileEntryId());
833
834 String fileEntryUuid = fileEntry.getUuid();
835
836 fileRankElement.addAttribute("file-entry-uuid", fileEntryUuid);
837
838 portletDataContext.addClassedModel(
839 fileRankElement, path, fileRank, _NAMESPACE);
840 }
841
842 protected static void exportFileShortcut(
843 PortletDataContext portletDataContext,
844 Element fileEntryTypesElement, Element foldersElement,
845 Element fileShortcutsElement, Element repositoriesElement,
846 Element repositoryEntriesElement, DLFileShortcut fileShortcut)
847 throws Exception {
848
849 if (!portletDataContext.isWithinDateRange(
850 fileShortcut.getModifiedDate())) {
851
852 return;
853 }
854
855 exportParentFolder(
856 portletDataContext, fileEntryTypesElement, foldersElement,
857 repositoriesElement, repositoryEntriesElement,
858 fileShortcut.getFolderId());
859
860 String path = getFileShortcutPath(portletDataContext, fileShortcut);
861
862 if (portletDataContext.isPathNotProcessed(path)) {
863 Element fileShortcutElement = fileShortcutsElement.addElement(
864 "file-shortcut");
865
866 FileEntry fileEntry = DLAppLocalServiceUtil.getFileEntry(
867 fileShortcut.getToFileEntryId());
868
869 String fileEntryUuid = fileEntry.getUuid();
870
871 fileShortcutElement.addAttribute("file-entry-uuid", fileEntryUuid);
872
873 portletDataContext.addClassedModel(
874 fileShortcutElement, path, fileShortcut, _NAMESPACE);
875 }
876 }
877
878 protected static void exportFolder(
879 PortletDataContext portletDataContext,
880 Element fileEntryTypesElement, Element foldersElement,
881 Element fileEntriesElement, Element fileShortcutsElement,
882 Element fileRanksElement, Element repositoriesElement,
883 Element repositoryEntriesElement, Folder folder, boolean recurse)
884 throws Exception {
885
886 if (!portletDataContext.isWithinDateRange(folder.getModifiedDate())) {
887 return;
888 }
889
890 if (folder.isMountPoint()) {
891 Repository repository = RepositoryUtil.findByPrimaryKey(
892 folder.getRepositoryId());
893
894 exportRepository(
895 portletDataContext, repositoriesElement,
896 repositoryEntriesElement, repository);
897
898 return;
899 }
900 else if (!folder.isDefaultRepository()) {
901
902
903
904
905 return;
906 }
907
908 exportParentFolder(
909 portletDataContext, fileEntryTypesElement, foldersElement,
910 repositoriesElement, repositoryEntriesElement,
911 folder.getParentFolderId());
912
913 String path = getFolderPath(portletDataContext, folder);
914
915 if (!portletDataContext.isPathNotProcessed(path)) {
916 return;
917 }
918
919 Element folderElement = foldersElement.addElement("folder");
920
921 exportFolderFileEntryTypes(
922 portletDataContext, folder, fileEntryTypesElement, folderElement);
923
924 portletDataContext.addClassedModel(
925 folderElement, path, folder, _NAMESPACE);
926
927 if (recurse) {
928 List<Folder> folders = FolderUtil.findByR_P(
929 folder.getRepositoryId(), folder.getFolderId());
930
931 for (Folder curFolder : folders) {
932 exportFolder(
933 portletDataContext, fileEntryTypesElement, foldersElement,
934 fileEntriesElement, fileShortcutsElement, fileRanksElement,
935 repositoriesElement, repositoryEntriesElement, curFolder,
936 recurse);
937 }
938 }
939
940 List<FileEntry> fileEntries = FileEntryUtil.findByR_F(
941 folder.getRepositoryId(), folder.getFolderId());
942
943 for (FileEntry fileEntry : fileEntries) {
944 exportFileEntry(
945 portletDataContext, fileEntryTypesElement, foldersElement,
946 fileEntriesElement, fileRanksElement, repositoriesElement,
947 repositoryEntriesElement, fileEntry, true);
948 }
949
950 if (portletDataContext.getBooleanParameter(_NAMESPACE, "shortcuts")) {
951 List<DLFileShortcut> fileShortcuts = DLFileShortcutUtil.findByG_F_A(
952 folder.getRepositoryId(), folder.getFolderId(), true);
953
954 for (DLFileShortcut fileShortcut : fileShortcuts) {
955 exportFileShortcut(
956 portletDataContext, fileEntryTypesElement, foldersElement,
957 fileShortcutsElement, repositoriesElement,
958 repositoryEntriesElement, fileShortcut);
959 }
960 }
961 }
962
963 protected static void exportFolderFileEntryTypes(
964 PortletDataContext portletDataContext, Folder folder,
965 Element fileEntryTypesElement, Element folderElement)
966 throws Exception {
967
968 List<DLFileEntryType> dlFileEntryTypes =
969 DLFileEntryTypeLocalServiceUtil.getFolderFileEntryTypes(
970 new long[] {portletDataContext.getScopeGroupId()},
971 folder.getFolderId(), false);
972
973 String[] fileEntryTypeUuids = new String[dlFileEntryTypes.size()];
974
975 long defaultFileEntryTypeId =
976 DLFileEntryTypeLocalServiceUtil.getDefaultFileEntryTypeId(
977 folder.getFolderId());
978
979 String defaultFileEntryTypeUuid = StringPool.BLANK;
980
981 for (int i = 0; i < dlFileEntryTypes.size(); i++) {
982 DLFileEntryType dlFileEntryType = dlFileEntryTypes.get(i);
983
984 if (!isFileEntryTypeExportable(dlFileEntryType)) {
985 continue;
986 }
987
988 fileEntryTypeUuids[i] = dlFileEntryType.getUuid();
989
990 if (defaultFileEntryTypeId ==
991 dlFileEntryType.getFileEntryTypeId()) {
992
993 defaultFileEntryTypeUuid = dlFileEntryType.getUuid();
994 }
995
996 exportFileEntryType(
997 portletDataContext, fileEntryTypesElement, dlFileEntryType);
998 }
999
1000 folderElement.addAttribute(
1001 "fileEntryTypeUuids", StringUtil.merge(fileEntryTypeUuids));
1002 folderElement.addAttribute(
1003 "defaultFileEntryTypeUuid", defaultFileEntryTypeUuid);
1004 }
1005
1006 protected static void exportMetaData(
1007 PortletDataContext portletDataContext,
1008 Element fileEntryTypesElement, Element fileEntryElement,
1009 FileEntry fileEntry)
1010 throws Exception {
1011
1012 if (!(fileEntry instanceof LiferayFileEntry)) {
1013 return;
1014 }
1015
1016 LiferayFileEntry liferayFileEntry = (LiferayFileEntry)fileEntry;
1017
1018 DLFileEntry dlFileEntry = liferayFileEntry.getDLFileEntry();
1019
1020 long fileEntryTypeId = dlFileEntry.getFileEntryTypeId();
1021
1022 DLFileEntryType dlFileEntryType =
1023 DLFileEntryTypeLocalServiceUtil.fetchFileEntryType(fileEntryTypeId);
1024
1025 if (dlFileEntryType == null) {
1026 return;
1027 }
1028
1029 fileEntryElement.addAttribute(
1030 "fileEntryTypeUuid", dlFileEntryType.getUuid());
1031
1032 if (!isFileEntryTypeExportable(dlFileEntryType)) {
1033 return;
1034 }
1035
1036 exportFileEntryType(
1037 portletDataContext, fileEntryTypesElement, dlFileEntryType);
1038
1039 List<DDMStructure> ddmStructures = dlFileEntryType.getDDMStructures();
1040
1041 for (DDMStructure ddmStructure : ddmStructures) {
1042 Element structureFields = fileEntryElement.addElement(
1043 "structure-fields");
1044
1045 String path = getFileEntryFileEntryTypeStructureFieldsPath(
1046 portletDataContext, fileEntry, dlFileEntryType.getUuid(),
1047 ddmStructure.getStructureId());
1048
1049 structureFields.addAttribute("path", path);
1050
1051 structureFields.addAttribute(
1052 "structureUuid", ddmStructure.getUuid());
1053
1054 FileVersion fileVersion = fileEntry.getFileVersion();
1055
1056 DLFileEntryMetadata dlFileEntryMetadata =
1057 DLFileEntryMetadataLocalServiceUtil.getFileEntryMetadata(
1058 ddmStructure.getStructureId(),
1059 fileVersion.getFileVersionId());
1060
1061 Fields fields = StorageEngineUtil.getFields(
1062 dlFileEntryMetadata.getDDMStorageId());
1063
1064 portletDataContext.addZipEntry(path, fields);
1065 }
1066 }
1067
1068 protected static void exportParentFolder(
1069 PortletDataContext portletDataContext,
1070 Element fileEntryTypesElement, Element foldersElement,
1071 Element repositoriesElement, Element repositoryEntriesElement,
1072 long folderId)
1073 throws Exception {
1074
1075 if (folderId == DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
1076 return;
1077 }
1078
1079 Folder folder = DLAppLocalServiceUtil.getFolder(folderId);
1080
1081 if (folder.isMountPoint()) {
1082 Repository repository = RepositoryUtil.findByPrimaryKey(
1083 folder.getRepositoryId());
1084
1085 exportRepository(
1086 portletDataContext, repositoriesElement,
1087 repositoryEntriesElement, repository);
1088
1089 return;
1090 }
1091 else if (!folder.isDefaultRepository()) {
1092
1093
1094
1095
1096 return;
1097 }
1098
1099 exportParentFolder(
1100 portletDataContext, fileEntryTypesElement, foldersElement,
1101 repositoriesElement, repositoryEntriesElement,
1102 folder.getParentFolderId());
1103
1104 String path = getFolderPath(portletDataContext, folder);
1105
1106 if (portletDataContext.isPathNotProcessed(path)) {
1107 Element folderElement = foldersElement.addElement("folder");
1108
1109 exportFolderFileEntryTypes(
1110 portletDataContext, folder, fileEntryTypesElement,
1111 folderElement);
1112
1113 portletDataContext.addClassedModel(
1114 folderElement, path, folder, _NAMESPACE);
1115 }
1116 }
1117
1118 protected static void exportRepository(
1119 PortletDataContext portletDataContext, Element repositoriesElement,
1120 Element repositoryEntriesElement, Repository repository)
1121 throws Exception {
1122
1123 if (!portletDataContext.isWithinDateRange(
1124 repository.getModifiedDate())) {
1125
1126 return;
1127 }
1128
1129 String path = getRepositoryPath(portletDataContext, repository);
1130
1131 if (!portletDataContext.isPathNotProcessed(path)) {
1132 return;
1133 }
1134
1135 Element repositoryElement = repositoriesElement.addElement(
1136 "repository");
1137
1138 portletDataContext.addClassedModel(
1139 repositoryElement, path, repository, _NAMESPACE);
1140
1141 List<RepositoryEntry> repositoryEntries =
1142 RepositoryEntryUtil.findByRepositoryId(
1143 repository.getRepositoryId());
1144
1145 for (RepositoryEntry repositoryEntry : repositoryEntries) {
1146 exportRepositoryEntry(
1147 portletDataContext, repositoryEntriesElement, repositoryEntry);
1148 }
1149 }
1150
1151 protected static void exportRepositoryEntry(
1152 PortletDataContext portletDataContext,
1153 Element repositoryEntriesElement, RepositoryEntry repositoryEntry)
1154 throws Exception {
1155
1156 String path = getRepositoryEntryPath(
1157 portletDataContext, repositoryEntry);
1158
1159 if (!portletDataContext.isPathNotProcessed(path)) {
1160 return;
1161 }
1162
1163 Element repositoryEntryElement = repositoryEntriesElement.addElement(
1164 "repository-entry");
1165
1166 portletDataContext.addClassedModel(
1167 repositoryEntryElement, path, repositoryEntry, _NAMESPACE);
1168 }
1169
1170 protected static String getFileEntryBinPath(
1171 PortletDataContext portletDataContext, FileEntry fileEntry) {
1172
1173 StringBundler sb = new StringBundler(5);
1174
1175 sb.append(
1176 portletDataContext.getPortletPath(PortletKeys.DOCUMENT_LIBRARY));
1177 sb.append("/bin/");
1178 sb.append(fileEntry.getFileEntryId());
1179 sb.append(StringPool.SLASH);
1180 sb.append(fileEntry.getVersion());
1181
1182 return sb.toString();
1183 }
1184
1185 protected static String getFileEntryFileEntryTypeStructureFieldsPath(
1186 PortletDataContext portletDataContext, FileEntry fileEntry,
1187 String fileEntryTypeUuid, long structureId) {
1188
1189 StringBundler sb = new StringBundler(4);
1190
1191 String fileEntryPath = getFileEntryPath(portletDataContext, fileEntry);
1192
1193 sb.append(StringUtil.replace(fileEntryPath, ".xml", StringPool.BLANK));
1194 sb.append("/file-entry-type/");
1195 sb.append(fileEntryTypeUuid);
1196 sb.append("/structure-fields/");
1197 sb.append(structureId);
1198 sb.append(".xml");
1199
1200 return sb.toString();
1201 }
1202
1203
1209 protected static String getFileEntryTypeName(
1210 String uuid, long groupId, String name, int count)
1211 throws Exception {
1212
1213 DLFileEntryType dlFileEntryType = DLFileEntryTypeUtil.fetchByG_N(
1214 groupId, name);
1215
1216 if (dlFileEntryType == null) {
1217 return name;
1218 }
1219
1220 if (Validator.isNotNull(uuid) &&
1221 uuid.equals(dlFileEntryType.getUuid())) {
1222
1223 return name;
1224 }
1225
1226 name = StringUtil.appendParentheticalSuffix(name, count);
1227
1228 return getFileEntryTypeName(uuid, groupId, name, ++count);
1229 }
1230
1231 protected static String getFileEntryTypePath(
1232 PortletDataContext portletDataContext,
1233 DLFileEntryType dlFileEntryType) {
1234
1235 StringBundler sb = new StringBundler(4);
1236
1237 sb.append(
1238 portletDataContext.getPortletPath(PortletKeys.DOCUMENT_LIBRARY));
1239 sb.append("/entry-types/");
1240 sb.append(dlFileEntryType.getFileEntryTypeId());
1241 sb.append(".xml");
1242
1243 return sb.toString();
1244 }
1245
1246 protected static String getFileRankPath(
1247 PortletDataContext portletDataContext, DLFileRank fileRank) {
1248
1249 StringBundler sb = new StringBundler(4);
1250
1251 sb.append(
1252 portletDataContext.getPortletPath(PortletKeys.DOCUMENT_LIBRARY));
1253 sb.append("/ranks/");
1254 sb.append(fileRank.getFileRankId());
1255 sb.append(".xml");
1256
1257 return sb.toString();
1258 }
1259
1260 protected static String getFileShortcutPath(
1261 PortletDataContext portletDataContext, DLFileShortcut fileShortcut) {
1262
1263 StringBundler sb = new StringBundler(4);
1264
1265 sb.append(
1266 portletDataContext.getPortletPath(PortletKeys.DOCUMENT_LIBRARY));
1267 sb.append("/shortcuts/");
1268 sb.append(fileShortcut.getFileShortcutId());
1269 sb.append(".xml");
1270
1271 return sb.toString();
1272 }
1273
1274
1280 protected static String getFolderName(
1281 String uuid, long groupId, long parentFolderId, String name,
1282 int count)
1283 throws Exception {
1284
1285 Folder folder = FolderUtil.fetchByR_P_N(groupId, parentFolderId, name);
1286
1287 if (folder == null) {
1288 return name;
1289 }
1290
1291 if (Validator.isNotNull(uuid) && uuid.equals(folder.getUuid())) {
1292 return name;
1293 }
1294
1295 name = StringUtil.appendParentheticalSuffix(name, count);
1296
1297 return getFolderName(uuid, groupId, parentFolderId, name, ++count);
1298 }
1299
1300 protected static String getFolderPath(
1301 PortletDataContext portletDataContext, Folder folder) {
1302
1303 StringBundler sb = new StringBundler(4);
1304
1305 sb.append(
1306 portletDataContext.getPortletPath(PortletKeys.DOCUMENT_LIBRARY));
1307 sb.append("/folders/");
1308 sb.append(folder.getFolderId());
1309 sb.append(".xml");
1310
1311 return sb.toString();
1312 }
1313
1314 protected static String getImportFolderPath(
1315 PortletDataContext portletDataContext, long folderId) {
1316
1317 StringBundler sb = new StringBundler(4);
1318
1319 sb.append(
1320 portletDataContext.getSourcePortletPath(
1321 PortletKeys.DOCUMENT_LIBRARY));
1322 sb.append("/folders/");
1323 sb.append(folderId);
1324 sb.append(".xml");
1325
1326 return sb.toString();
1327 }
1328
1329 protected static String getRepositoryEntryPath(
1330 PortletDataContext portletDataContext,
1331 RepositoryEntry repositoryEntry) {
1332
1333 StringBundler sb = new StringBundler(4);
1334
1335 sb.append(
1336 portletDataContext.getPortletPath(PortletKeys.DOCUMENT_LIBRARY));
1337 sb.append("/repository-entries/");
1338 sb.append(repositoryEntry.getRepositoryEntryId());
1339 sb.append(".xml");
1340
1341 return sb.toString();
1342 }
1343
1344 protected static String getRepositoryPath(
1345 PortletDataContext portletDataContext, Repository repository) {
1346
1347 StringBundler sb = new StringBundler(4);
1348
1349 sb.append(
1350 portletDataContext.getPortletPath(PortletKeys.DOCUMENT_LIBRARY));
1351 sb.append("/repositories/");
1352 sb.append(repository.getRepositoryId());
1353 sb.append(".xml");
1354
1355 return sb.toString();
1356 }
1357
1358 protected static void importFileEntryType(
1359 PortletDataContext portletDataContext, Element fileEntryTypeElement)
1360 throws Exception {
1361
1362 String path = fileEntryTypeElement.attributeValue("path");
1363
1364 if (!portletDataContext.isPathNotProcessed(path)) {
1365 return;
1366 }
1367
1368 DLFileEntryType dlFileEntryType =
1369 (DLFileEntryType)portletDataContext.getZipEntryAsObject(path);
1370
1371 long userId = portletDataContext.getUserId(
1372 dlFileEntryType.getUserUuid());
1373
1374 String name = getFileEntryTypeName(
1375 dlFileEntryType.getUuid(), portletDataContext.getScopeGroupId(),
1376 dlFileEntryType.getName(), 2);
1377
1378 List<Element> structureElements = fileEntryTypeElement.elements(
1379 "structure");
1380
1381 for (Element structureElement : structureElements) {
1382 DDMPortletDataHandlerImpl.importStructure(
1383 portletDataContext, structureElement);
1384 }
1385
1386 Map<Long, Long> ddmStructureIdsMap =
1387 (Map<Long, Long>)portletDataContext.getNewPrimaryKeysMap(
1388 DDMStructure.class);
1389
1390 Collection<Long> ddmStructureIdsCollection =
1391 ddmStructureIdsMap.values();
1392
1393 long[] ddmStructureIds = ArrayUtil.toArray(
1394 ddmStructureIdsCollection.toArray(
1395 new Long[ddmStructureIdsMap.size()]));
1396
1397 ServiceContext serviceContext = portletDataContext.createServiceContext(
1398 path, dlFileEntryType, _NAMESPACE);
1399
1400 DLFileEntryType importedDLFileEntryType = null;
1401
1402 if (portletDataContext.isDataStrategyMirror()) {
1403 DLFileEntryType existingDLFileEntryType =
1404 DLFileEntryTypeUtil.fetchByUUID_G(
1405 dlFileEntryType.getUuid(),
1406 portletDataContext.getScopeGroupId());
1407
1408 if (existingDLFileEntryType == null) {
1409 Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
1410 portletDataContext.getCompanyId());
1411
1412 existingDLFileEntryType = DLFileEntryTypeUtil.fetchByUUID_G(
1413 dlFileEntryType.getUuid(), companyGroup.getGroupId());
1414 }
1415
1416 if (existingDLFileEntryType == null) {
1417 serviceContext.setUuid(dlFileEntryType.getUuid());
1418
1419 importedDLFileEntryType =
1420 DLFileEntryTypeLocalServiceUtil.addFileEntryType(
1421 userId, portletDataContext.getScopeGroupId(), name,
1422 dlFileEntryType.getDescription(), ddmStructureIds,
1423 serviceContext);
1424 }
1425 else {
1426 if (!isFileEntryTypeGlobal(
1427 portletDataContext.getCompanyId(),
1428 existingDLFileEntryType)) {
1429
1430 DLFileEntryTypeLocalServiceUtil.updateFileEntryType(
1431 userId, existingDLFileEntryType.getFileEntryTypeId(),
1432 name, dlFileEntryType.getDescription(), ddmStructureIds,
1433 serviceContext);
1434 }
1435
1436 importedDLFileEntryType = existingDLFileEntryType;
1437 }
1438 }
1439 else {
1440 importedDLFileEntryType =
1441 DLFileEntryTypeLocalServiceUtil.addFileEntryType(
1442 userId, portletDataContext.getScopeGroupId(), name,
1443 dlFileEntryType.getDescription(), ddmStructureIds,
1444 serviceContext);
1445 }
1446
1447 if (!isFileEntryTypeGlobal(
1448 portletDataContext.getCompanyId(), importedDLFileEntryType)) {
1449
1450 portletDataContext.importClassedModel(
1451 dlFileEntryType, importedDLFileEntryType, _NAMESPACE);
1452
1453 String importedDLFileEntryDDMStructureKey =
1454 DLUtil.getDDMStructureKey(importedDLFileEntryType);
1455
1456 List<DDMStructure> ddmStructures =
1457 importedDLFileEntryType.getDDMStructures();
1458
1459 for (DDMStructure ddmStructure : ddmStructures) {
1460 String ddmStructureKey = ddmStructure.getStructureKey();
1461
1462 if (!DLUtil.isAutoGeneratedDLFileEntryTypeDDMStructureKey(
1463 ddmStructureKey)) {
1464
1465 continue;
1466 }
1467
1468 if (ddmStructureKey.equals(
1469 importedDLFileEntryDDMStructureKey)) {
1470 continue;
1471 }
1472
1473 ddmStructure.setStructureKey(
1474 importedDLFileEntryDDMStructureKey);
1475
1476 DDMStructureLocalServiceUtil.updateDDMStructure(ddmStructure);
1477 }
1478 }
1479 }
1480
1481 protected static void importFileRank(
1482 PortletDataContext portletDataContext, DLFileRank fileRank,
1483 String fileEntryUuid)
1484 throws Exception {
1485
1486 long userId = portletDataContext.getUserId(fileRank.getUserUuid());
1487
1488 long groupId = portletDataContext.getScopeGroupId();
1489
1490 FileEntry fileEntry = FileEntryUtil.fetchByUUID_R(
1491 fileEntryUuid, groupId);
1492
1493 if (fileEntry == null) {
1494 if (_log.isWarnEnabled()) {
1495 _log.warn(
1496 "Unable to retrieve file " + fileEntryUuid +
1497 " to import file rank");
1498 }
1499
1500 return;
1501 }
1502
1503 long fileEntryId = fileEntry.getFileEntryId();
1504
1505 ServiceContext serviceContext = new ServiceContext();
1506
1507 serviceContext.setCreateDate(fileRank.getCreateDate());
1508
1509 DLAppLocalServiceUtil.updateFileRank(
1510 portletDataContext.getScopeGroupId(),
1511 portletDataContext.getCompanyId(), userId, fileEntryId,
1512 serviceContext);
1513 }
1514
1515 protected static void importFileShortcut(
1516 PortletDataContext portletDataContext, Element fileShortcutElement)
1517 throws Exception {
1518
1519 String path = fileShortcutElement.attributeValue("path");
1520
1521 if (!portletDataContext.isPathNotProcessed(path)) {
1522 return;
1523 }
1524
1525 DLFileShortcut fileShortcut =
1526 (DLFileShortcut)portletDataContext.getZipEntryAsObject(path);
1527
1528 importFileShortcut(
1529 portletDataContext, fileShortcutElement, fileShortcut);
1530 }
1531
1532 protected static void importFileShortcut(
1533 PortletDataContext portletDataContext, Element fileShortcutElement,
1534 DLFileShortcut fileShortcut)
1535 throws Exception {
1536
1537 long userId = portletDataContext.getUserId(fileShortcut.getUserUuid());
1538
1539 Map<Long, Long> folderIds =
1540 (Map<Long, Long>)portletDataContext.getNewPrimaryKeysMap(
1541 DLFolder.class);
1542
1543 long folderId = MapUtil.getLong(
1544 folderIds, fileShortcut.getFolderId(), fileShortcut.getFolderId());
1545
1546 long groupId = portletDataContext.getScopeGroupId();
1547
1548 if (folderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
1549 Folder folder = FolderUtil.findByPrimaryKey(folderId);
1550
1551 groupId = folder.getRepositoryId();
1552 }
1553
1554 String fileEntryUuid = fileShortcutElement.attributeValue(
1555 "file-entry-uuid");
1556
1557 FileEntry fileEntry = FileEntryUtil.fetchByUUID_R(
1558 fileEntryUuid, groupId);
1559
1560 if (fileEntry == null) {
1561 if (_log.isWarnEnabled()) {
1562 _log.warn(
1563 "Unable to fetch file entry {uuid=" + fileEntryUuid +
1564 ", groupId=" + groupId + "}");
1565 }
1566
1567 return;
1568 }
1569
1570 long fileEntryId = fileEntry.getFileEntryId();
1571
1572 ServiceContext serviceContext = portletDataContext.createServiceContext(
1573 fileShortcutElement, fileShortcut, _NAMESPACE);
1574
1575 DLFileShortcut importedFileShortcut = null;
1576
1577 if (portletDataContext.isDataStrategyMirror()) {
1578 DLFileShortcut existingFileShortcut =
1579 DLFileShortcutUtil.fetchByUUID_G(
1580 fileShortcut.getUuid(),
1581 portletDataContext.getScopeGroupId());
1582
1583 if (existingFileShortcut == null) {
1584 serviceContext.setUuid(fileShortcut.getUuid());
1585
1586 importedFileShortcut = DLAppLocalServiceUtil.addFileShortcut(
1587 userId, groupId, folderId, fileEntryId, serviceContext);
1588 }
1589 else {
1590 importedFileShortcut = DLAppLocalServiceUtil.updateFileShortcut(
1591 userId, existingFileShortcut.getFileShortcutId(), folderId,
1592 fileEntryId, serviceContext);
1593 }
1594 }
1595 else {
1596 importedFileShortcut = DLAppLocalServiceUtil.addFileShortcut(
1597 userId, groupId, folderId, fileEntryId, serviceContext);
1598 }
1599
1600 portletDataContext.importClassedModel(
1601 fileShortcut, importedFileShortcut, _NAMESPACE);
1602 }
1603
1604 protected static void importFolder(
1605 PortletDataContext portletDataContext, String folderPath,
1606 Element folderElement, Folder folder)
1607 throws Exception {
1608
1609 long userId = portletDataContext.getUserId(folder.getUserUuid());
1610
1611 Map<Long, Long> folderIds =
1612 (Map<Long, Long>)portletDataContext.getNewPrimaryKeysMap(
1613 DLFolder.class);
1614
1615 long parentFolderId = MapUtil.getLong(
1616 folderIds, folder.getParentFolderId(), folder.getParentFolderId());
1617
1618 ServiceContext serviceContext = portletDataContext.createServiceContext(
1619 folderPath, folder, _NAMESPACE);
1620
1621 if ((parentFolderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) &&
1622 (parentFolderId == folder.getParentFolderId())) {
1623
1624 String path = getImportFolderPath(
1625 portletDataContext, parentFolderId);
1626
1627 Folder parentFolder =
1628 (Folder)portletDataContext.getZipEntryAsObject(path);
1629
1630 importFolder(portletDataContext, path, folderElement, parentFolder);
1631
1632 parentFolderId = MapUtil.getLong(
1633 folderIds, folder.getParentFolderId(),
1634 folder.getParentFolderId());
1635 }
1636
1637 Folder importedFolder = null;
1638
1639 if (portletDataContext.isDataStrategyMirror()) {
1640 Folder existingFolder = FolderUtil.fetchByUUID_R(
1641 folder.getUuid(), portletDataContext.getScopeGroupId());
1642
1643 if (existingFolder == null) {
1644 String name = getFolderName(
1645 null, portletDataContext.getScopeGroupId(), parentFolderId,
1646 folder.getName(), 2);
1647
1648 serviceContext.setUuid(folder.getUuid());
1649
1650 importedFolder = DLAppLocalServiceUtil.addFolder(
1651 userId, portletDataContext.getScopeGroupId(),
1652 parentFolderId, name, folder.getDescription(),
1653 serviceContext);
1654 }
1655 else {
1656 String name = getFolderName(
1657 folder.getUuid(), portletDataContext.getScopeGroupId(),
1658 parentFolderId, folder.getName(), 2);
1659
1660 importedFolder = DLAppLocalServiceUtil.updateFolder(
1661 existingFolder.getFolderId(), parentFolderId, name,
1662 folder.getDescription(), serviceContext);
1663 }
1664 }
1665 else {
1666 String name = getFolderName(
1667 null, portletDataContext.getScopeGroupId(), parentFolderId,
1668 folder.getName(), 2);
1669
1670 importedFolder = DLAppLocalServiceUtil.addFolder(
1671 userId, portletDataContext.getScopeGroupId(), parentFolderId,
1672 name, folder.getDescription(), serviceContext);
1673 }
1674
1675 folderIds.put(folder.getFolderId(), importedFolder.getFolderId());
1676
1677 importFolderFileEntryTypes(
1678 portletDataContext, folderElement, importedFolder, serviceContext);
1679
1680 portletDataContext.importClassedModel(
1681 folder, importedFolder, _NAMESPACE);
1682 }
1683
1684 protected static void importFolderFileEntryTypes(
1685 PortletDataContext portletDataContext, Element folderElement,
1686 Folder folder, ServiceContext serviceContext)
1687 throws Exception {
1688
1689 String[] fileEntryTypeUuids = StringUtil.split(
1690 folderElement.attributeValue("fileEntryTypeUuids"));
1691
1692 List<Long> fileEntryTypeIds = new ArrayList<Long>();
1693
1694 String defaultFileEntryTypeUuid = GetterUtil.getString(
1695 folderElement.attributeValue("defaultFileEntryTypeUuid"));
1696
1697 long defaultFileEntryTypeId = 0;
1698
1699 for (String fileEntryTypeUuid : fileEntryTypeUuids) {
1700 DLFileEntryType dlFileEntryType = DLFileEntryTypeUtil.fetchByUUID_G(
1701 fileEntryTypeUuid, portletDataContext.getScopeGroupId());
1702
1703 if (dlFileEntryType == null) {
1704 continue;
1705 }
1706
1707 fileEntryTypeIds.add(dlFileEntryType.getFileEntryTypeId());
1708
1709 if (defaultFileEntryTypeUuid.equals(dlFileEntryType.getUuid())) {
1710 defaultFileEntryTypeId = dlFileEntryType.getFileEntryTypeId();
1711 }
1712 }
1713
1714 DLFileEntryTypeLocalServiceUtil.updateFolderFileEntryTypes(
1715 (DLFolder)folder.getModel(), fileEntryTypeIds,
1716 defaultFileEntryTypeId, serviceContext);
1717 }
1718
1719 protected static void importMetaData(
1720 PortletDataContext portletDataContext, Element fileEntryElement,
1721 ServiceContext serviceContext)
1722 throws Exception {
1723
1724 String fileEntryTypeUuid = fileEntryElement.attributeValue(
1725 "fileEntryTypeUuid");
1726
1727 if (Validator.isNull(fileEntryTypeUuid)) {
1728 return;
1729 }
1730
1731 DLFileEntryType dlFileEntryType = DLFileEntryTypeUtil.fetchByUUID_G(
1732 fileEntryTypeUuid, portletDataContext.getScopeGroupId());
1733
1734 if (dlFileEntryType == null) {
1735 Group group = GroupLocalServiceUtil.getCompanyGroup(
1736 portletDataContext.getCompanyId());
1737
1738 dlFileEntryType = DLFileEntryTypeUtil.fetchByUUID_G(
1739 fileEntryTypeUuid, group.getGroupId());
1740
1741 if (dlFileEntryType == null) {
1742 serviceContext.setAttribute("fileEntryTypeId", -1);
1743
1744 return;
1745 }
1746 }
1747
1748 serviceContext.setAttribute(
1749 "fileEntryTypeId", dlFileEntryType.getFileEntryTypeId());
1750
1751 List<DDMStructure> ddmStructures = dlFileEntryType.getDDMStructures();
1752
1753 for (DDMStructure ddmStructure : ddmStructures) {
1754 Element structureFieldsElement =
1755 (Element)fileEntryElement.selectSingleNode(
1756 "structure-fields[@structureUuid='".concat(
1757 ddmStructure.getUuid()).concat("']"));
1758
1759 if (structureFieldsElement == null) {
1760 continue;
1761 }
1762
1763 String path = structureFieldsElement.attributeValue("path");
1764
1765 Fields fields = (Fields)portletDataContext.getZipEntryAsObject(
1766 path);
1767
1768 serviceContext.setAttribute(
1769 Fields.class.getName() + ddmStructure.getStructureId(), fields);
1770 }
1771 }
1772
1773 protected static boolean isFileEntryTypeExportable(
1774 DLFileEntryType dlFileEntryType) {
1775
1776 if (dlFileEntryType.getFileEntryTypeId() == 0) {
1777 return false;
1778 }
1779
1780 return true;
1781 }
1782
1783 protected static boolean isFileEntryTypeGlobal(
1784 long companyId, DLFileEntryType dlFileEntryType)
1785 throws PortalException, SystemException {
1786
1787 Group group = GroupLocalServiceUtil.getCompanyGroup(companyId);
1788
1789 if (dlFileEntryType.getGroupId() == group.getGroupId()) {
1790 return true;
1791 }
1792
1793 return false;
1794 }
1795
1796 @Override
1797 protected PortletPreferences doDeleteData(
1798 PortletDataContext portletDataContext, String portletId,
1799 PortletPreferences portletPreferences)
1800 throws Exception {
1801
1802 if (!portletDataContext.addPrimaryKey(
1803 DLPortletDataHandlerImpl.class, "deleteData")) {
1804
1805 DLAppLocalServiceUtil.deleteAll(
1806 portletDataContext.getScopeGroupId());
1807 }
1808
1809 return null;
1810 }
1811
1812 @Override
1813 protected String doExportData(
1814 PortletDataContext portletDataContext, String portletId,
1815 PortletPreferences portletPreferences)
1816 throws Exception {
1817
1818 portletDataContext.addPermissions(
1819 "com.liferay.portlet.documentlibrary",
1820 portletDataContext.getScopeGroupId());
1821
1822 Document document = SAXReaderUtil.createDocument();
1823
1824 Element rootElement = document.addElement("documentlibrary-data");
1825
1826 rootElement.addAttribute(
1827 "group-id", String.valueOf(portletDataContext.getScopeGroupId()));
1828
1829 long rootFolderId = GetterUtil.getLong(
1830 portletPreferences.getValue("rootFolderId", null));
1831
1832 if (rootFolderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
1833 rootElement.addAttribute(
1834 "root-folder-id", String.valueOf(rootFolderId));
1835 }
1836
1837 Element fileEntryTypesElement = rootElement.addElement(
1838 "file-entry-types");
1839 Element foldersElement = rootElement.addElement("folders");
1840 Element fileEntriesElement = rootElement.addElement("file-entries");
1841 Element fileShortcutsElement = rootElement.addElement("file-shortcuts");
1842 Element fileRanksElement = rootElement.addElement("file-ranks");
1843 Element repositoriesElement = rootElement.addElement("repositories");
1844 Element repositoryEntriesElement = rootElement.addElement(
1845 "repository-entries");
1846
1847 Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
1848 portletDataContext.getCompanyId());
1849
1850 List<DLFileEntryType> dlFileEntryTypes =
1851 DLFileEntryTypeServiceUtil.getFileEntryTypes(
1852 new long[] {
1853 portletDataContext.getScopeGroupId(),
1854 companyGroup.getGroupId()
1855 });
1856
1857 for (DLFileEntryType dlFileEntryType : dlFileEntryTypes) {
1858 if (!isFileEntryTypeExportable(dlFileEntryType)) {
1859 continue;
1860 }
1861
1862 exportFileEntryType(
1863 portletDataContext, fileEntryTypesElement, dlFileEntryType);
1864 }
1865
1866 List<Folder> folders = FolderUtil.findByRepositoryId(
1867 portletDataContext.getScopeGroupId());
1868
1869 for (Folder folder : folders) {
1870 exportFolder(
1871 portletDataContext, fileEntryTypesElement, foldersElement,
1872 fileEntriesElement, fileShortcutsElement, fileRanksElement,
1873 repositoriesElement, repositoryEntriesElement, folder, false);
1874 }
1875
1876 List<FileEntry> fileEntries = FileEntryUtil.findByR_F(
1877 portletDataContext.getScopeGroupId(),
1878 DLFolderConstants.DEFAULT_PARENT_FOLDER_ID);
1879
1880 for (FileEntry fileEntry : fileEntries) {
1881 exportFileEntry(
1882 portletDataContext, fileEntryTypesElement, foldersElement,
1883 fileEntriesElement, fileRanksElement, repositoriesElement,
1884 repositoryEntriesElement, fileEntry, true);
1885 }
1886
1887 if (portletDataContext.getBooleanParameter(_NAMESPACE, "shortcuts")) {
1888 List<DLFileShortcut> fileShortcuts = DLFileShortcutUtil.findByG_F_A(
1889 portletDataContext.getScopeGroupId(),
1890 DLFolderConstants.DEFAULT_PARENT_FOLDER_ID, true);
1891
1892 for (DLFileShortcut fileShortcut : fileShortcuts) {
1893 exportFileShortcut(
1894 portletDataContext, fileEntryTypesElement, foldersElement,
1895 fileShortcutsElement, repositoriesElement,
1896 repositoryEntriesElement, fileShortcut);
1897 }
1898 }
1899
1900 return document.formattedString();
1901 }
1902
1903 @Override
1904 protected PortletPreferences doImportData(
1905 PortletDataContext portletDataContext, String portletId,
1906 PortletPreferences portletPreferences, String data)
1907 throws Exception {
1908
1909 portletDataContext.importPermissions(
1910 "com.liferay.portlet.documentlibrary",
1911 portletDataContext.getSourceGroupId(),
1912 portletDataContext.getScopeGroupId());
1913
1914 Document document = SAXReaderUtil.read(data);
1915
1916 Element rootElement = document.getRootElement();
1917
1918 Element repositoriesElement = rootElement.element("repositories");
1919
1920 if (repositoriesElement != null) {
1921 List<Element> repositoryElements = repositoriesElement.elements(
1922 "repository");
1923
1924 for (Element repositoryElement : repositoryElements) {
1925 importRepository(portletDataContext, repositoryElement);
1926 }
1927 }
1928
1929 Element repositoryEntriesElement = rootElement.element(
1930 "repository-entries");
1931
1932 List<Element> repositoryEntryElements =
1933 repositoryEntriesElement.elements("repository-entry");
1934
1935 for (Element repositoryEntryElement : repositoryEntryElements) {
1936 importRepositoryEntry(portletDataContext, repositoryEntryElement);
1937 }
1938
1939 Element fileEntryTypesElement = rootElement.element("file-entry-types");
1940
1941 List<Element> fileEntryTypeElements = fileEntryTypesElement.elements(
1942 "file-entry-type");
1943
1944 for (Element fileEntryTypeElement : fileEntryTypeElements) {
1945 importFileEntryType(portletDataContext, fileEntryTypeElement);
1946 }
1947
1948 Element foldersElement = rootElement.element("folders");
1949
1950 List<Element> folderElements = foldersElement.elements("folder");
1951
1952 for (Element folderElement : folderElements) {
1953 importFolder(portletDataContext, folderElement);
1954 }
1955
1956 Element fileEntriesElement = rootElement.element("file-entries");
1957
1958 List<Element> fileEntryElements = fileEntriesElement.elements(
1959 "file-entry");
1960
1961 for (Element fileEntryElement : fileEntryElements) {
1962 importFileEntry(portletDataContext, fileEntryElement);
1963 }
1964
1965 if (portletDataContext.getBooleanParameter(_NAMESPACE, "shortcuts")) {
1966 List<Element> fileShortcutElements = rootElement.element(
1967 "file-shortcuts").elements("file-shortcut");
1968
1969 for (Element fileShortcutElement : fileShortcutElements) {
1970 importFileShortcut(portletDataContext, fileShortcutElement);
1971 }
1972 }
1973
1974 if (portletDataContext.getBooleanParameter(_NAMESPACE, "ranks")) {
1975 Element fileRanksElement = rootElement.element("file-ranks");
1976
1977 List<Element> fileRankElements = fileRanksElement.elements(
1978 "file-rank");
1979
1980 for (Element fileRankElement : fileRankElements) {
1981 importFileRank(portletDataContext, fileRankElement);
1982 }
1983 }
1984
1985 long rootFolderId = GetterUtil.getLong(
1986 rootElement.attributeValue("root-folder-id"));
1987
1988 if (rootFolderId > 0) {
1989 Map<Long, Long> folderIds =
1990 (Map<Long, Long>)portletDataContext.getNewPrimaryKeysMap(
1991 DLFolder.class);
1992
1993 rootFolderId = MapUtil.getLong(
1994 folderIds, rootFolderId, rootFolderId);
1995
1996 portletPreferences.setValue(
1997 "rootFolderId", String.valueOf(rootFolderId));
1998 }
1999
2000 return portletPreferences;
2001 }
2002
2003 private static final boolean _ALWAYS_EXPORTABLE = true;
2004
2005 private static final boolean _DATA_LOCALIZED = true;
2006
2007 private static final String _NAMESPACE = "document_library";
2008
2009 private static Log _log = LogFactoryUtil.getLog(
2010 DLPortletDataHandlerImpl.class);
2011
2012 private static PortletDataHandlerBoolean _foldersAndDocuments =
2013 new PortletDataHandlerBoolean(
2014 _NAMESPACE, "folders-and-documents", true, true);
2015
2016 private static PortletDataHandlerControl[] _metadataControls =
2017 new PortletDataHandlerControl[] {
2018 new PortletDataHandlerBoolean(_NAMESPACE, "categories"),
2019 new PortletDataHandlerBoolean(_NAMESPACE, "comments"),
2020 new PortletDataHandlerBoolean(_NAMESPACE, "ratings"),
2021 new PortletDataHandlerBoolean(_NAMESPACE, "tags")
2022 };
2023
2024 private static PortletDataHandlerBoolean _previewsAndThumbnails =
2025 new PortletDataHandlerBoolean(_NAMESPACE, "previews-and-thumbnails");
2026
2027 private static PortletDataHandlerBoolean _ranks =
2028 new PortletDataHandlerBoolean(_NAMESPACE, "ranks");
2029
2030 private static PortletDataHandlerBoolean _shortcuts=
2031 new PortletDataHandlerBoolean(_NAMESPACE, "shortcuts");
2032
2033 }