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