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