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.GetterUtil;
031 import com.liferay.portal.kernel.util.MapUtil;
032 import com.liferay.portal.kernel.util.StringBundler;
033 import com.liferay.portal.kernel.util.StringPool;
034 import com.liferay.portal.kernel.util.StringUtil;
035 import com.liferay.portal.kernel.util.Validator;
036 import com.liferay.portal.kernel.workflow.WorkflowConstants;
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.repository.liferayrepository.model.LiferayFileEntry;
042 import com.liferay.portal.service.GroupLocalServiceUtil;
043 import com.liferay.portal.service.ServiceContext;
044 import com.liferay.portal.util.PortletKeys;
045 import com.liferay.portal.util.PropsValues;
046 import com.liferay.portlet.documentlibrary.DuplicateFileException;
047 import com.liferay.portlet.documentlibrary.NoSuchFileException;
048 import com.liferay.portlet.documentlibrary.model.DLFileEntry;
049 import com.liferay.portlet.documentlibrary.model.DLFileEntryMetadata;
050 import com.liferay.portlet.documentlibrary.model.DLFileEntryType;
051 import com.liferay.portlet.documentlibrary.model.DLFileRank;
052 import com.liferay.portlet.documentlibrary.model.DLFileShortcut;
053 import com.liferay.portlet.documentlibrary.model.DLFolder;
054 import com.liferay.portlet.documentlibrary.model.DLFolderConstants;
055 import com.liferay.portlet.documentlibrary.service.DLAppLocalServiceUtil;
056 import com.liferay.portlet.documentlibrary.service.DLFileEntryMetadataLocalServiceUtil;
057 import com.liferay.portlet.documentlibrary.service.DLFileEntryTypeLocalServiceUtil;
058 import com.liferay.portlet.documentlibrary.service.DLFileEntryTypeServiceUtil;
059 import com.liferay.portlet.documentlibrary.service.persistence.DLFileEntryTypeUtil;
060 import com.liferay.portlet.documentlibrary.service.persistence.DLFileRankUtil;
061 import com.liferay.portlet.documentlibrary.service.persistence.DLFileShortcutUtil;
062 import com.liferay.portlet.documentlibrary.util.DLUtil;
063 import com.liferay.portlet.dynamicdatamapping.lar.DDMPortletDataHandlerImpl;
064 import com.liferay.portlet.dynamicdatamapping.model.DDMStructure;
065 import com.liferay.portlet.dynamicdatamapping.service.persistence.DDMStructureUtil;
066 import com.liferay.portlet.dynamicdatamapping.storage.Fields;
067 import com.liferay.portlet.dynamicdatamapping.storage.StorageEngineUtil;
068 import com.liferay.util.PwdGenerator;
069
070 import java.io.IOException;
071 import java.io.InputStream;
072
073 import java.util.ArrayList;
074 import java.util.List;
075 import java.util.Map;
076 import java.util.regex.Pattern;
077
078 import javax.portlet.PortletPreferences;
079
080
084 public class DLPortletDataHandlerImpl extends BasePortletDataHandler {
085
086 public static void exportFileEntry(
087 PortletDataContext portletDataContext,
088 Element fileEntryTypesElement, Element foldersElement,
089 Element fileEntriesElement, Element fileRanksElement,
090 FileEntry fileEntry, boolean checkDateRange)
091 throws Exception {
092
093 if (checkDateRange &&
094 !portletDataContext.isWithinDateRange(
095 fileEntry.getModifiedDate())) {
096
097 return;
098 }
099
100 FileVersion fileVersion = fileEntry.getFileVersion();
101
102 if (fileVersion.getStatus() != WorkflowConstants.STATUS_APPROVED) {
103 return;
104 }
105
106 String path = getFileEntryPath(portletDataContext, fileEntry);
107
108 if (!portletDataContext.isPathNotProcessed(path)) {
109 return;
110 }
111
112 Element fileEntryElement = fileEntriesElement.addElement("file-entry");
113
114 if (foldersElement != null) {
115 exportParentFolder(
116 portletDataContext, fileEntryTypesElement, foldersElement,
117 fileEntry.getFolderId());
118 }
119
120 if (!portletDataContext.isPerformDirectBinaryImport()) {
121 String binPath = getFileEntryBinPath(portletDataContext, fileEntry);
122
123 fileEntryElement.addAttribute("bin-path", binPath);
124
125 InputStream is = null;
126
127 try {
128 is = FileEntryUtil.getContentStream(fileEntry);
129 }
130 catch (NoSuchFileException nsfe) {
131 }
132
133 if (is == null) {
134 if (_log.isWarnEnabled()) {
135 _log.warn(
136 "No file found for file entry " +
137 fileEntry.getFileEntryId());
138 }
139
140 fileEntryElement.detach();
141
142 return;
143 }
144
145 try {
146 portletDataContext.addZipEntry(binPath, is);
147 }
148 finally {
149 try {
150 is.close();
151 }
152 catch (IOException ioe) {
153 _log.error(ioe, ioe);
154 }
155 }
156 }
157
158 if (portletDataContext.getBooleanParameter(_NAMESPACE, "ranks")) {
159 List<DLFileRank> fileRanks = DLFileRankUtil.findByFileEntryId(
160 fileEntry.getFileEntryId());
161
162 for (DLFileRank fileRank : fileRanks) {
163 exportFileRank(
164 portletDataContext, fileRanksElement, fileRank);
165 }
166 }
167
168 exportMetaData(
169 portletDataContext, fileEntryTypesElement, fileEntryElement,
170 fileEntry);
171
172 portletDataContext.addClassedModel(
173 fileEntryElement, path, fileEntry, _NAMESPACE);
174 }
175
176 public static String getFileEntryPath(
177 PortletDataContext portletDataContext, FileEntry fileEntry) {
178
179 StringBundler sb = new StringBundler(6);
180
181 sb.append(
182 portletDataContext.getPortletPath(PortletKeys.DOCUMENT_LIBRARY));
183 sb.append("/file-entries/");
184 sb.append(fileEntry.getFileEntryId());
185 sb.append(StringPool.SLASH);
186 sb.append(fileEntry.getVersion());
187 sb.append(".xml");
188
189 return sb.toString();
190 }
191
192 public static void importFileEntry(
193 PortletDataContext portletDataContext, Element fileEntryElement)
194 throws Exception {
195
196 String path = fileEntryElement.attributeValue("path");
197
198 if (!portletDataContext.isPathNotProcessed(path)) {
199 return;
200 }
201
202 FileEntry fileEntry = (FileEntry)portletDataContext.getZipEntryAsObject(
203 path);
204
205 long userId = portletDataContext.getUserId(fileEntry.getUserUuid());
206
207 Map<Long, Long> folderPKs =
208 (Map<Long, Long>)portletDataContext.getNewPrimaryKeysMap(
209 DLFolder.class);
210
211 long folderId = MapUtil.getLong(
212 folderPKs, fileEntry.getFolderId(), fileEntry.getFolderId());
213
214 long[] assetCategoryIds = null;
215 String[] assetTagNames = null;
216
217 if (portletDataContext.getBooleanParameter(_NAMESPACE, "categories")) {
218 assetCategoryIds = portletDataContext.getAssetCategoryIds(
219 DLFileEntry.class, fileEntry.getFileEntryId());
220 }
221
222 if (portletDataContext.getBooleanParameter(_NAMESPACE, "tags")) {
223 assetTagNames = portletDataContext.getAssetTagNames(
224 DLFileEntry.class, fileEntry.getFileEntryId());
225 }
226
227 ServiceContext serviceContext = portletDataContext.createServiceContext(
228 fileEntryElement, fileEntry, _NAMESPACE);
229
230 serviceContext.setAttribute(
231 "sourceFileName", "A." + fileEntry.getExtension());
232 serviceContext.setUserId(userId);
233
234 String binPath = fileEntryElement.attributeValue("bin-path");
235
236 InputStream is = null;
237
238 if (Validator.isNull(binPath) &&
239 portletDataContext.isPerformDirectBinaryImport()) {
240
241 is = FileEntryUtil.getContentStream(fileEntry);
242 }
243 else {
244 is = portletDataContext.getZipEntryAsInputStream(binPath);
245 }
246
247 String folderUuid = StringPool.BLANK;
248
249 if ((folderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) &&
250 (folderId == fileEntry.getFolderId())) {
251
252 String folderPath = getImportFolderPath(
253 portletDataContext, folderId);
254
255 Folder folder = (Folder)portletDataContext.getZipEntryAsObject(
256 folderPath);
257
258 Document document = fileEntryElement.getDocument();
259
260 Element rootElement = document.getRootElement();
261
262 Element folderElement = (Element)rootElement.selectSingleNode(
263 "
264
265 importFolder(
266 portletDataContext, folderPath, folderElement, folder);
267
268 folderUuid = folder.getUuid();
269
270 folderId = MapUtil.getLong(
271 folderPKs, fileEntry.getFolderId(), fileEntry.getFolderId());
272 }
273
274 importMetaData(portletDataContext, fileEntryElement, serviceContext);
275
276 FileEntry importedFileEntry = null;
277
278 String titleWithExtension = fileEntry.getTitle();
279 String extension = fileEntry.getExtension();
280
281 if (!titleWithExtension.endsWith(StringPool.PERIOD + extension)) {
282 titleWithExtension += StringPool.PERIOD + extension;
283 }
284
285 if (portletDataContext.isDataStrategyMirror()) {
286 FileEntry existingFileEntry = FileEntryUtil.fetchByUUID_R(
287 fileEntry.getUuid(), portletDataContext.getScopeGroupId());
288
289 if (existingFileEntry == null) {
290 FileEntry existingTitleFileEntry = FileEntryUtil.fetchByR_F_T(
291 portletDataContext.getScopeGroupId(), folderId,
292 fileEntry.getTitle());
293
294 if (existingTitleFileEntry != null) {
295 if (portletDataContext.
296 isDataStrategyMirrorWithOverwritting()) {
297
298 DLAppLocalServiceUtil.deleteFileEntry(
299 existingTitleFileEntry.getFileEntryId());
300 }
301 else {
302 String originalTitle = fileEntry.getTitle();
303 String dotExtension = StringPool.PERIOD + extension;
304
305 if (originalTitle.endsWith(dotExtension)) {
306 int pos = originalTitle.lastIndexOf(dotExtension);
307
308 originalTitle = originalTitle.substring(0, pos);
309 }
310
311 for (int i = 1;; i++) {
312 titleWithExtension =
313 originalTitle + StringPool.SPACE + i +
314 dotExtension;
315
316 existingTitleFileEntry = FileEntryUtil.findByR_F_T(
317 portletDataContext.getScopeGroupId(), folderId,
318 titleWithExtension);
319
320 if (existingTitleFileEntry == null) {
321 break;
322 }
323 }
324 }
325 }
326
327 serviceContext.setUuid(fileEntry.getUuid());
328
329 importedFileEntry = DLAppLocalServiceUtil.addFileEntry(
330 userId, portletDataContext.getScopeGroupId(), folderId,
331 titleWithExtension, fileEntry.getMimeType(),
332 fileEntry.getTitle(), fileEntry.getDescription(), null, is,
333 fileEntry.getSize(), serviceContext);
334 }
335 else if (!isDuplicateFileEntry(
336 folderUuid, fileEntry, existingFileEntry)) {
337
338 importedFileEntry = DLAppLocalServiceUtil.updateFileEntry(
339 userId, existingFileEntry.getFileEntryId(),
340 fileEntry.getTitle(), fileEntry.getMimeType(),
341 fileEntry.getTitle(), fileEntry.getDescription(), null,
342 true, is, fileEntry.getSize(), serviceContext);
343 }
344 else {
345 FileVersion latestFileVersion =
346 existingFileEntry.getLatestFileVersion();
347
348 DLAppLocalServiceUtil.updateAsset(
349 userId, existingFileEntry, latestFileVersion,
350 assetCategoryIds, assetTagNames, null);
351
352 if (existingFileEntry instanceof LiferayFileEntry) {
353 LiferayFileEntry liferayFileEntry =
354 (LiferayFileEntry)existingFileEntry;
355
356 Indexer indexer = IndexerRegistryUtil.getIndexer(
357 DLFileEntry.class);
358
359 indexer.reindex(liferayFileEntry.getModel());
360 }
361
362 importedFileEntry = existingFileEntry;
363 }
364 }
365 else {
366 try {
367 importedFileEntry = DLAppLocalServiceUtil.addFileEntry(
368 userId, portletDataContext.getScopeGroupId(), folderId,
369 titleWithExtension, fileEntry.getMimeType(),
370 fileEntry.getTitle(), fileEntry.getDescription(), null, is,
371 fileEntry.getSize(), serviceContext);
372 }
373 catch (DuplicateFileException dfe) {
374 String title = fileEntry.getTitle();
375
376 String[] titleParts = title.split("\\.", 2);
377
378 title = titleParts[0] + PwdGenerator.getPassword();
379
380 if (titleParts.length > 1) {
381 title += StringPool.PERIOD + titleParts[1];
382 }
383
384 if (!title.endsWith(StringPool.PERIOD + extension)) {
385 title += StringPool.PERIOD + extension;
386 }
387
388 importedFileEntry = DLAppLocalServiceUtil.addFileEntry(
389 userId, portletDataContext.getScopeGroupId(), folderId,
390 title, fileEntry.getMimeType(), title,
391 fileEntry.getDescription(), null, is, fileEntry.getSize(),
392 serviceContext);
393 }
394 }
395
396 Map<String, String> fileEntryTitles =
397 (Map<String, String>)portletDataContext.getNewPrimaryKeysMap(
398 DLFileEntry.class.getName() + ".title");
399
400 fileEntryTitles.put(fileEntry.getTitle(), importedFileEntry.getTitle());
401
402 portletDataContext.importClassedModel(
403 fileEntry, importedFileEntry, _NAMESPACE);
404 }
405
406 public static void importFileRank(
407 PortletDataContext portletDataContext, Element fileRankElement)
408 throws Exception {
409
410 String path = fileRankElement.attributeValue("path");
411
412 if (!portletDataContext.isPathNotProcessed(path)) {
413 return;
414 }
415
416 DLFileRank fileRank =
417 (DLFileRank)portletDataContext.getZipEntryAsObject(path);
418
419 String fileEntryUuid = fileRankElement.attributeValue(
420 "file-entry-uuid");
421
422 importFileRank(portletDataContext, fileRank, fileEntryUuid);
423 }
424
425 public static void importFolder(
426 PortletDataContext portletDataContext, Element folderElement)
427 throws Exception {
428
429 String path = folderElement.attributeValue("path");
430
431 if (!portletDataContext.isPathNotProcessed(path)) {
432 return;
433 }
434
435 Folder folder = (Folder)portletDataContext.getZipEntryAsObject(path);
436
437 importFolder(portletDataContext, path, folderElement, folder);
438 }
439
440 @Override
441 public PortletDataHandlerControl[] getExportControls() {
442 return new PortletDataHandlerControl[] {
443 _foldersAndDocuments, _shortcuts, _ranks, _categories, _comments,
444 _ratings, _tags
445 };
446 }
447
448 @Override
449 public PortletDataHandlerControl[] getImportControls() {
450 return new PortletDataHandlerControl[] {
451 _foldersAndDocuments, _shortcuts, _ranks, _categories, _comments,
452 _ratings, _tags
453 };
454 }
455
456 @Override
457 public boolean isAlwaysExportable() {
458 return _ALWAYS_EXPORTABLE;
459 }
460
461 @Override
462 public boolean isPublishToLiveByDefault() {
463 return PropsValues.DL_PUBLISH_TO_LIVE_BY_DEFAULT;
464 }
465
466 protected static void exportFileEntryType(
467 PortletDataContext portletDataContext,
468 Element fileEntryTypesElement, DLFileEntryType dlFileEntryType)
469 throws Exception {
470
471 String path = getFileEntryTypePath(portletDataContext, dlFileEntryType);
472
473 if (!portletDataContext.isPathNotProcessed(path)) {
474 return;
475 }
476
477 Element fileEntryTypeElement = fileEntryTypesElement.addElement(
478 "file-entry-type");
479
480 List<DDMStructure> ddmStructures = dlFileEntryType.getDDMStructures();
481
482 String[] ddmStructureUuids = new String[ddmStructures.size()];
483
484 for (int i = 0; i < ddmStructures.size(); i++) {
485 DDMStructure ddmStructure = ddmStructures.get(i);
486
487 ddmStructureUuids[i] = ddmStructure.getUuid();
488
489 DDMPortletDataHandlerImpl.exportStructure(
490 portletDataContext, fileEntryTypeElement, ddmStructure);
491 }
492
493 fileEntryTypeElement.addAttribute(
494 "structureUuids", StringUtil.merge(ddmStructureUuids));
495
496 portletDataContext.addClassedModel(
497 fileEntryTypeElement, path, dlFileEntryType, _NAMESPACE);
498 }
499
500 protected static void exportFileRank(
501 PortletDataContext portletDataContext, Element fileRanksElement,
502 DLFileRank fileRank)
503 throws Exception {
504
505 String path = getFileRankPath(portletDataContext, fileRank);
506
507 if (!portletDataContext.isPathNotProcessed(path)) {
508 return;
509 }
510
511 Element fileRankElement = fileRanksElement.addElement("file-rank");
512
513 FileEntry fileEntry = FileEntryUtil.fetchByPrimaryKey(
514 fileRank.getFileEntryId());
515
516 String fileEntryUuid = fileEntry.getUuid();
517
518 fileRankElement.addAttribute("file-entry-uuid", fileEntryUuid);
519
520 portletDataContext.addClassedModel(
521 fileRankElement, path, fileRank, _NAMESPACE);
522 }
523
524 protected static void exportFileShortcut(
525 PortletDataContext portletDataContext,
526 Element fileEntryTypesElement, Element foldersElement,
527 Element fileShortcutsElement, DLFileShortcut fileShortcut)
528 throws Exception {
529
530 if (!portletDataContext.isWithinDateRange(
531 fileShortcut.getModifiedDate())) {
532
533 return;
534 }
535
536 exportParentFolder(
537 portletDataContext, fileEntryTypesElement, foldersElement,
538 fileShortcut.getFolderId());
539
540 String path = getFileShortcutPath(portletDataContext, fileShortcut);
541
542 if (portletDataContext.isPathNotProcessed(path)) {
543 Element fileShortcutElement = fileShortcutsElement.addElement(
544 "file-shortcut");
545
546 FileEntry fileEntry = FileEntryUtil.fetchByPrimaryKey(
547 fileShortcut.getToFileEntryId());
548
549 String fileEntryUuid = fileEntry.getUuid();
550
551 fileShortcutElement.addAttribute("file-entry-uuid", fileEntryUuid);
552
553 portletDataContext.addClassedModel(
554 fileShortcutElement, path, fileShortcut, _NAMESPACE);
555 }
556 }
557
558 protected static void exportFolder(
559 PortletDataContext portletDataContext,
560 Element fileEntryTypesElement, Element foldersElement,
561 Element fileEntriesElement, Element fileShortcutsElement,
562 Element fileRanksElement, Folder folder, boolean recurse)
563 throws Exception {
564
565 if (!portletDataContext.isWithinDateRange(folder.getModifiedDate())) {
566 return;
567 }
568
569 exportParentFolder(
570 portletDataContext, fileEntryTypesElement, foldersElement,
571 folder.getParentFolderId());
572
573 String path = getFolderPath(portletDataContext, folder);
574
575 if (!portletDataContext.isPathNotProcessed(path)) {
576 return;
577 }
578
579 Element folderElement = foldersElement.addElement("folder");
580
581 exportFolderFileEntryTypes(
582 portletDataContext, folder, fileEntryTypesElement, folderElement);
583
584 portletDataContext.addClassedModel(
585 folderElement, path, folder, _NAMESPACE);
586
587 if (recurse) {
588 List<Folder> folders = FolderUtil.findByR_P(
589 folder.getRepositoryId(), folder.getFolderId());
590
591 for (Folder curFolder : folders) {
592 exportFolder(
593 portletDataContext, fileEntryTypesElement, foldersElement,
594 fileEntriesElement, fileShortcutsElement, fileRanksElement,
595 curFolder, recurse);
596 }
597 }
598
599 List<FileEntry> fileEntries = FileEntryUtil.findByR_F(
600 folder.getRepositoryId(), folder.getFolderId());
601
602 for (FileEntry fileEntry : fileEntries) {
603 exportFileEntry(
604 portletDataContext, fileEntryTypesElement, foldersElement,
605 fileEntriesElement, fileRanksElement, fileEntry, true);
606 }
607
608 if (portletDataContext.getBooleanParameter(_NAMESPACE, "shortcuts")) {
609 List<DLFileShortcut> fileShortcuts = DLFileShortcutUtil.findByG_F(
610 folder.getRepositoryId(), folder.getFolderId());
611
612 for (DLFileShortcut fileShortcut : fileShortcuts) {
613 exportFileShortcut(
614 portletDataContext, fileEntryTypesElement, foldersElement,
615 fileShortcutsElement, fileShortcut);
616 }
617 }
618 }
619
620 protected static void exportFolderFileEntryTypes(
621 PortletDataContext portletDataContext, Folder folder,
622 Element fileEntryTypesElement, Element folderElement)
623 throws Exception {
624
625 List<DLFileEntryType> dlFileEntryTypes =
626 DLFileEntryTypeLocalServiceUtil.getFolderFileEntryTypes(
627 new long[] {portletDataContext.getScopeGroupId()},
628 folder.getFolderId(), false);
629
630 String[] fileEntryTypeUuids = new String[dlFileEntryTypes.size()];
631
632 long defaultFileEntryTypeId =
633 DLFileEntryTypeLocalServiceUtil.getDefaultFileEntryTypeId(
634 folder.getFolderId());
635
636 String defaultFileEntryTypeUuid = StringPool.BLANK;
637
638 for (int i = 0; i < dlFileEntryTypes.size(); i++) {
639 DLFileEntryType dlFileEntryType = dlFileEntryTypes.get(i);
640
641 if (!isFileEntryTypeExportable(
642 portletDataContext.getCompanyId(), dlFileEntryType)) {
643
644 continue;
645 }
646
647 fileEntryTypeUuids[i] = dlFileEntryType.getUuid();
648
649 if (defaultFileEntryTypeId ==
650 dlFileEntryType.getFileEntryTypeId()) {
651
652 defaultFileEntryTypeUuid = dlFileEntryType.getUuid();
653 }
654
655 exportFileEntryType(
656 portletDataContext, fileEntryTypesElement, dlFileEntryType);
657 }
658
659 folderElement.addAttribute(
660 "fileEntryTypeUuids", StringUtil.merge(fileEntryTypeUuids));
661 folderElement.addAttribute(
662 "defaultFileEntryTypeUuid", defaultFileEntryTypeUuid);
663 }
664
665 protected static void exportMetaData(
666 PortletDataContext portletDataContext,
667 Element fileEntryTypesElement, Element fileEntryElement,
668 FileEntry fileEntry)
669 throws Exception {
670
671 if (!(fileEntry instanceof LiferayFileEntry)) {
672 return;
673 }
674
675 LiferayFileEntry liferayFileEntry = (LiferayFileEntry)fileEntry;
676
677 DLFileEntry dlFileEntry = liferayFileEntry.getDLFileEntry();
678
679 long fileEntryTypeId = dlFileEntry.getFileEntryTypeId();
680
681 DLFileEntryType dlFileEntryType =
682 DLFileEntryTypeLocalServiceUtil.fetchFileEntryType(
683 fileEntryTypeId);
684
685 if (dlFileEntryType == null) {
686 return;
687 }
688
689 if (!isFileEntryTypeExportable(
690 portletDataContext.getCompanyId(), dlFileEntryType)) {
691
692 return;
693 }
694
695 exportFileEntryType(
696 portletDataContext, fileEntryTypesElement, dlFileEntryType);
697
698 fileEntryElement.addAttribute(
699 "fileEntryTypeUuid", dlFileEntryType.getUuid());
700
701 List<DDMStructure> ddmStructures = dlFileEntryType.getDDMStructures();
702
703 for (DDMStructure ddmStructure : ddmStructures) {
704 Element structureFields = fileEntryElement.addElement(
705 "structure-fields");
706
707 String path = getFileEntryFileEntryTypeStructureFieldsPath(
708 portletDataContext, fileEntry, dlFileEntryType.getUuid(),
709 ddmStructure.getStructureId());
710
711 structureFields.addAttribute("path", path);
712
713 structureFields.addAttribute(
714 "structureUuid", ddmStructure.getUuid());
715
716 FileVersion fileVersion = fileEntry.getFileVersion();
717
718 DLFileEntryMetadata dlFileEntryMetadata =
719 DLFileEntryMetadataLocalServiceUtil.getFileEntryMetadata(
720 ddmStructure.getStructureId(),
721 fileVersion.getFileVersionId());
722
723 Fields fields = StorageEngineUtil.getFields(
724 dlFileEntryMetadata.getDDMStorageId());
725
726 portletDataContext.addZipEntry(path, fields);
727 }
728 }
729
730 protected static void exportParentFolder(
731 PortletDataContext portletDataContext,
732 Element fileEntryTypesElement, Element foldersElement,
733 long folderId)
734 throws Exception {
735
736 if (folderId == DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
737 return;
738 }
739
740 Folder folder = FolderUtil.findByPrimaryKey(folderId);
741
742 exportParentFolder(
743 portletDataContext, fileEntryTypesElement, foldersElement,
744 folder.getParentFolderId());
745
746 String path = getFolderPath(portletDataContext, folder);
747
748 if (portletDataContext.isPathNotProcessed(path)) {
749 Element folderElement = foldersElement.addElement("folder");
750
751 exportFolderFileEntryTypes(
752 portletDataContext, folder, fileEntryTypesElement,
753 folderElement);
754
755 portletDataContext.addClassedModel(
756 folderElement, path, folder, _NAMESPACE);
757 }
758 }
759
760 protected static String getFileEntryBinPath(
761 PortletDataContext portletDataContext, FileEntry fileEntry) {
762
763 StringBundler sb = new StringBundler(5);
764
765 sb.append(
766 portletDataContext.getPortletPath(PortletKeys.DOCUMENT_LIBRARY));
767 sb.append("/bin/");
768 sb.append(fileEntry.getFileEntryId());
769 sb.append(StringPool.SLASH);
770 sb.append(fileEntry.getVersion());
771
772 return sb.toString();
773 }
774
775 protected static String getFileEntryFileEntryTypeStructureFieldsPath(
776 PortletDataContext portletDataContext, FileEntry fileEntry,
777 String fileEntryTypeUuid, long structureId) {
778
779 StringBundler sb = new StringBundler(4);
780
781 String fileEntryPath = getFileEntryPath(portletDataContext, fileEntry);
782
783 sb.append(StringUtil.replace(fileEntryPath, ".xml", StringPool.BLANK));
784 sb.append("/file-entry-type/");
785 sb.append(fileEntryTypeUuid);
786 sb.append("/structure-fields/");
787 sb.append(structureId);
788 sb.append(".xml");
789
790 return sb.toString();
791 }
792
793 protected static String getFileEntryTypeName(
794 String uuid, long companyId, long groupId, String name, int count)
795 throws Exception {
796
797 DLFileEntryType dlFileEntryType = DLFileEntryTypeUtil.fetchByG_N(
798 groupId, name);
799
800 if (dlFileEntryType == null) {
801 return name;
802 }
803
804 if (Validator.isNotNull(uuid) &&
805 uuid.equals(dlFileEntryType.getUuid())) {
806
807 return name;
808 }
809
810 if (Pattern.matches(".* \\(\\d+\\)", name)) {
811 int pos = name.lastIndexOf(" (");
812
813 name = name.substring(0, pos);
814 }
815
816 StringBundler sb = new StringBundler(5);
817
818 sb.append(name);
819 sb.append(StringPool.SPACE);
820 sb.append(StringPool.OPEN_PARENTHESIS);
821 sb.append(count);
822 sb.append(StringPool.CLOSE_PARENTHESIS);
823
824 name = sb.toString();
825
826 return getFileEntryTypeName(uuid, companyId, groupId, name, ++count);
827 }
828
829 protected static String getFileEntryTypePath(
830 PortletDataContext portletDataContext,
831 DLFileEntryType dlFileEntryType) {
832
833 StringBundler sb = new StringBundler(4);
834
835 sb.append(
836 portletDataContext.getPortletPath(PortletKeys.DOCUMENT_LIBRARY));
837 sb.append("/entry-types/");
838 sb.append(dlFileEntryType.getFileEntryTypeId());
839 sb.append(".xml");
840
841 return sb.toString();
842 }
843
844 protected static String getFileRankPath(
845 PortletDataContext portletDataContext, DLFileRank fileRank) {
846
847 StringBundler sb = new StringBundler(4);
848
849 sb.append(
850 portletDataContext.getPortletPath(PortletKeys.DOCUMENT_LIBRARY));
851 sb.append("/ranks/");
852 sb.append(fileRank.getFileRankId());
853 sb.append(".xml");
854
855 return sb.toString();
856 }
857
858 protected static String getFileShortcutPath(
859 PortletDataContext portletDataContext, DLFileShortcut fileShortcut) {
860
861 StringBundler sb = new StringBundler(4);
862
863 sb.append(
864 portletDataContext.getPortletPath(PortletKeys.DOCUMENT_LIBRARY));
865 sb.append("/shortcuts/");
866 sb.append(fileShortcut.getFileShortcutId());
867 sb.append(".xml");
868
869 return sb.toString();
870 }
871
872 protected static String getFolderName(
873 String uuid, long companyId, long groupId, long parentFolderId,
874 String name, int count)
875 throws Exception {
876
877 Folder folder = FolderUtil.fetchByR_P_N(groupId, parentFolderId, name);
878
879 if (folder == null) {
880 return name;
881 }
882
883 if (Validator.isNotNull(uuid) && uuid.equals(folder.getUuid())) {
884 return name;
885 }
886
887 if (Pattern.matches(".* \\(\\d+\\)", name)) {
888 int pos = name.lastIndexOf(" (");
889
890 name = name.substring(0, pos);
891 }
892
893 StringBundler sb = new StringBundler(5);
894
895 sb.append(name);
896 sb.append(StringPool.SPACE);
897 sb.append(StringPool.OPEN_PARENTHESIS);
898 sb.append(count);
899 sb.append(StringPool.CLOSE_PARENTHESIS);
900
901 name = sb.toString();
902
903 return getFolderName(
904 uuid, companyId, groupId, parentFolderId, name, ++count);
905 }
906
907 protected static String getFolderPath(
908 PortletDataContext portletDataContext, Folder folder) {
909
910 StringBundler sb = new StringBundler(4);
911
912 sb.append(
913 portletDataContext.getPortletPath(PortletKeys.DOCUMENT_LIBRARY));
914 sb.append("/folders/");
915 sb.append(folder.getFolderId());
916 sb.append(".xml");
917
918 return sb.toString();
919 }
920
921 protected static String getImportFolderPath(
922 PortletDataContext portletDataContext, long folderId) {
923
924 StringBundler sb = new StringBundler(4);
925
926 sb.append(
927 portletDataContext.getSourcePortletPath(
928 PortletKeys.DOCUMENT_LIBRARY));
929 sb.append("/folders/");
930 sb.append(folderId);
931 sb.append(".xml");
932
933 return sb.toString();
934 }
935
936 protected static void importFileEntryType(
937 PortletDataContext portletDataContext, Element fileEntryTypeElement)
938 throws Exception {
939
940 String path = fileEntryTypeElement.attributeValue("path");
941
942 if (!portletDataContext.isPathNotProcessed(path)) {
943 return;
944 }
945
946 DLFileEntryType dlFileEntryType =
947 (DLFileEntryType)portletDataContext.getZipEntryAsObject(path);
948
949 long userId = portletDataContext.getUserId(
950 dlFileEntryType.getUserUuid());
951
952 String name = getFileEntryTypeName(
953 dlFileEntryType.getUuid(), portletDataContext.getCompanyId(),
954 portletDataContext.getScopeGroupId(), dlFileEntryType.getName(), 2);
955
956 List<Element> structureElements = fileEntryTypeElement.elements(
957 "structure");
958
959 for (Element structureElement : structureElements) {
960 DDMPortletDataHandlerImpl.importStructure(
961 portletDataContext, structureElement);
962 }
963
964 String[] ddmStructureUuids = StringUtil.split(
965 fileEntryTypeElement.attributeValue("structureUuids"));
966
967 long[] ddmStrutureIds = new long[ddmStructureUuids.length];
968
969 for (int i = 0; i < ddmStructureUuids.length; i++) {
970 DDMStructure existingStructure = DDMStructureUtil.fetchByUUID_G(
971 ddmStructureUuids[i], portletDataContext.getScopeGroupId());
972
973 ddmStrutureIds[i] = existingStructure.getStructureId();
974 }
975
976 ServiceContext serviceContext = portletDataContext.createServiceContext(
977 path, dlFileEntryType, _NAMESPACE);
978
979 DLFileEntryType importedDLFileEntryType = null;
980
981 if (portletDataContext.isDataStrategyMirror()) {
982 DLFileEntryType existingDLFileEntryType =
983 DLFileEntryTypeUtil.fetchByUUID_G(
984 dlFileEntryType.getUuid(),
985 portletDataContext.getScopeGroupId());
986
987 if (existingDLFileEntryType == null) {
988 serviceContext.setUuid(dlFileEntryType.getUuid());
989
990 importedDLFileEntryType =
991 DLFileEntryTypeLocalServiceUtil.addFileEntryType(
992 userId, portletDataContext.getScopeGroupId(), name,
993 dlFileEntryType.getDescription(), ddmStrutureIds,
994 serviceContext);
995 }
996 else {
997 DLFileEntryTypeLocalServiceUtil.updateFileEntryType(
998 userId, existingDLFileEntryType.getFileEntryTypeId(),
999 name, dlFileEntryType.getDescription(), ddmStrutureIds,
1000 serviceContext);
1001
1002 importedDLFileEntryType = existingDLFileEntryType;
1003 }
1004 }
1005 else {
1006 importedDLFileEntryType =
1007 DLFileEntryTypeLocalServiceUtil.addFileEntryType(
1008 userId, portletDataContext.getScopeGroupId(), name,
1009 dlFileEntryType.getDescription(), ddmStrutureIds,
1010 serviceContext);
1011 }
1012
1013 portletDataContext.importClassedModel(
1014 dlFileEntryType, importedDLFileEntryType, _NAMESPACE);
1015 }
1016
1017 protected static void importFileRank(
1018 PortletDataContext portletDataContext, DLFileRank fileRank,
1019 String fileEntryUuid)
1020 throws Exception {
1021
1022 long userId = portletDataContext.getUserId(fileRank.getUserUuid());
1023
1024 long groupId = portletDataContext.getScopeGroupId();
1025
1026 FileEntry fileEntry = FileEntryUtil.fetchByUUID_R(
1027 fileEntryUuid, groupId);
1028
1029 if (fileEntry == null) {
1030 if (_log.isWarnEnabled()) {
1031 _log.warn(
1032 "Unable to retrieve file: " + fileEntryUuid +
1033 " to import file rank.");
1034 }
1035
1036 return;
1037 }
1038
1039 long fileEntryId = fileEntry.getFileEntryId();
1040
1041 ServiceContext serviceContext = new ServiceContext();
1042
1043 serviceContext.setCreateDate(fileRank.getCreateDate());
1044
1045 DLAppLocalServiceUtil.updateFileRank(
1046 portletDataContext.getScopeGroupId(),
1047 portletDataContext.getCompanyId(), userId, fileEntryId,
1048 serviceContext);
1049 }
1050
1051 protected static void importFileShortcut(
1052 PortletDataContext portletDataContext, Element fileShortcutElement)
1053 throws Exception {
1054
1055 String path = fileShortcutElement.attributeValue("path");
1056
1057 if (!portletDataContext.isPathNotProcessed(path)) {
1058 return;
1059 }
1060
1061 DLFileShortcut fileShortcut =
1062 (DLFileShortcut)portletDataContext.getZipEntryAsObject(path);
1063
1064 importFileShortcut(
1065 portletDataContext, fileShortcutElement, fileShortcut);
1066 }
1067
1068 protected static void importFileShortcut(
1069 PortletDataContext portletDataContext, Element fileShortcutElement,
1070 DLFileShortcut fileShortcut)
1071 throws Exception {
1072
1073 long userId = portletDataContext.getUserId(fileShortcut.getUserUuid());
1074
1075 Map<Long, Long> folderPKs =
1076 (Map<Long, Long>)portletDataContext.getNewPrimaryKeysMap(
1077 DLFolder.class);
1078
1079 long folderId = MapUtil.getLong(
1080 folderPKs, fileShortcut.getFolderId(), fileShortcut.getFolderId());
1081
1082 long groupId = portletDataContext.getScopeGroupId();
1083
1084 if (folderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
1085 Folder folder = FolderUtil.findByPrimaryKey(folderId);
1086
1087 groupId = folder.getRepositoryId();
1088 }
1089
1090 String fileEntryUuid = fileShortcutElement.attributeValue(
1091 "file-entry-uuid");
1092
1093 FileEntry fileEntry = FileEntryUtil.fetchByUUID_R(
1094 fileEntryUuid, groupId);
1095
1096 if (fileEntry == null) {
1097 if (_log.isWarnEnabled()) {
1098 _log.warn(
1099 "Unable to fetch file entry {uuid=" + fileEntryUuid +
1100 ",groupId=" + groupId + "}");
1101 }
1102
1103 return;
1104 }
1105
1106 long fileEntryId = fileEntry.getFileEntryId();
1107
1108 ServiceContext serviceContext = portletDataContext.createServiceContext(
1109 fileShortcutElement, fileShortcut, _NAMESPACE);
1110
1111 DLFileShortcut importedFileShortcut = null;
1112
1113 if (portletDataContext.isDataStrategyMirror()) {
1114 DLFileShortcut existingFileShortcut =
1115 DLFileShortcutUtil.fetchByUUID_G(
1116 fileShortcut.getUuid(),
1117 portletDataContext.getScopeGroupId());
1118
1119 if (existingFileShortcut == null) {
1120 serviceContext.setUuid(fileShortcut.getUuid());
1121
1122 importedFileShortcut = DLAppLocalServiceUtil.addFileShortcut(
1123 userId, groupId, folderId, fileEntryId, serviceContext);
1124 }
1125 else {
1126 importedFileShortcut = DLAppLocalServiceUtil.updateFileShortcut(
1127 userId, existingFileShortcut.getFileShortcutId(), folderId,
1128 fileEntryId, serviceContext);
1129 }
1130 }
1131 else {
1132 importedFileShortcut = DLAppLocalServiceUtil.addFileShortcut(
1133 userId, groupId, folderId, fileEntryId, serviceContext);
1134 }
1135
1136 portletDataContext.importClassedModel(
1137 fileShortcut, importedFileShortcut, _NAMESPACE);
1138 }
1139
1140 protected static void importFolder(
1141 PortletDataContext portletDataContext, String folderPath,
1142 Element folderElement, Folder folder)
1143 throws Exception {
1144
1145 long userId = portletDataContext.getUserId(folder.getUserUuid());
1146
1147 Map<Long, Long> folderPKs =
1148 (Map<Long, Long>)portletDataContext.getNewPrimaryKeysMap(
1149 DLFolder.class);
1150
1151 long parentFolderId = MapUtil.getLong(
1152 folderPKs, folder.getParentFolderId(), folder.getParentFolderId());
1153
1154 ServiceContext serviceContext = portletDataContext.createServiceContext(
1155 folderPath, folder, _NAMESPACE);
1156
1157 if ((parentFolderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) &&
1158 (parentFolderId == folder.getParentFolderId())) {
1159
1160 String path = getImportFolderPath(
1161 portletDataContext, parentFolderId);
1162
1163 Folder parentFolder =
1164 (Folder)portletDataContext.getZipEntryAsObject(path);
1165
1166 importFolder(portletDataContext, path, folderElement, parentFolder);
1167
1168 parentFolderId = MapUtil.getLong(
1169 folderPKs, folder.getParentFolderId(),
1170 folder.getParentFolderId());
1171 }
1172
1173 Folder importedFolder = null;
1174
1175 if (portletDataContext.isDataStrategyMirror()) {
1176 Folder existingFolder = FolderUtil.fetchByUUID_R(
1177 folder.getUuid(), portletDataContext.getScopeGroupId());
1178
1179 if (existingFolder == null) {
1180 String name = getFolderName(
1181 null, portletDataContext.getCompanyId(),
1182 portletDataContext.getScopeGroupId(), parentFolderId,
1183 folder.getName(), 2);
1184
1185 serviceContext.setUuid(folder.getUuid());
1186
1187 importedFolder = DLAppLocalServiceUtil.addFolder(
1188 userId, portletDataContext.getScopeGroupId(),
1189 parentFolderId, name, folder.getDescription(),
1190 serviceContext);
1191 }
1192 else {
1193 String name = getFolderName(
1194 folder.getUuid(), portletDataContext.getCompanyId(),
1195 portletDataContext.getScopeGroupId(), parentFolderId,
1196 folder.getName(), 2);
1197
1198 importedFolder = DLAppLocalServiceUtil.updateFolder(
1199 existingFolder.getFolderId(), parentFolderId, name,
1200 folder.getDescription(), serviceContext);
1201 }
1202 }
1203 else {
1204 String name = getFolderName(
1205 null, portletDataContext.getCompanyId(),
1206 portletDataContext.getScopeGroupId(), parentFolderId,
1207 folder.getName(), 2);
1208
1209 importedFolder = DLAppLocalServiceUtil.addFolder(
1210 userId, portletDataContext.getScopeGroupId(), parentFolderId,
1211 name, folder.getDescription(), serviceContext);
1212 }
1213
1214 importFolderFileEntryTypes(
1215 portletDataContext, folderElement, importedFolder, serviceContext);
1216
1217 portletDataContext.importClassedModel(
1218 folder, importedFolder, _NAMESPACE);
1219 }
1220
1221 protected static void importFolderFileEntryTypes(
1222 PortletDataContext portletDataContext, Element folderElement,
1223 Folder folder, ServiceContext serviceContext)
1224 throws Exception {
1225
1226 String[] fileEntryTypeUuids = StringUtil.split(
1227 folderElement.attributeValue("fileEntryTypeUuids"));
1228
1229 List<Long> fileEntryTypeIds = new ArrayList<Long>();
1230
1231 String defaultFileEntryTypeUuid = GetterUtil.getString(
1232 folderElement.attributeValue("defaultFileEntryTypeUuid"));
1233
1234 long defaultFileEntryTypeId = 0;
1235
1236 for (String fileEntryTypeUuid : fileEntryTypeUuids) {
1237 DLFileEntryType dlFileEntryType = DLFileEntryTypeUtil.fetchByUUID_G(
1238 fileEntryTypeUuid, portletDataContext.getScopeGroupId());
1239
1240 if (dlFileEntryType == null) {
1241 continue;
1242 }
1243
1244 fileEntryTypeIds.add(dlFileEntryType.getFileEntryTypeId());
1245
1246 if (defaultFileEntryTypeUuid.equals(dlFileEntryType.getUuid())) {
1247 defaultFileEntryTypeId = dlFileEntryType.getFileEntryTypeId();
1248 }
1249 }
1250
1251 DLFileEntryTypeLocalServiceUtil.updateFolderFileEntryTypes(
1252 (DLFolder)folder.getModel(), fileEntryTypeIds,
1253 defaultFileEntryTypeId, serviceContext);
1254 }
1255
1256 protected static void importMetaData(
1257 PortletDataContext portletDataContext, Element fileEntryElement,
1258 ServiceContext serviceContext)
1259 throws Exception {
1260
1261 String fileEntryTypeUuid = fileEntryElement.attributeValue(
1262 "fileEntryTypeUuid");
1263
1264 if (Validator.isNull(fileEntryTypeUuid)) {
1265 return;
1266 }
1267
1268 DLFileEntryType dlFileEntryType = DLFileEntryTypeUtil.fetchByUUID_G(
1269 fileEntryTypeUuid, portletDataContext.getScopeGroupId());
1270
1271 if (dlFileEntryType == null) {
1272 serviceContext.setAttribute("fileEntryTypeId", -1);
1273
1274 return;
1275 }
1276
1277 serviceContext.setAttribute(
1278 "fileEntryTypeId", dlFileEntryType.getFileEntryTypeId());
1279
1280 List<DDMStructure> ddmStructures = dlFileEntryType.getDDMStructures();
1281
1282 for (DDMStructure ddmStructure : ddmStructures) {
1283 Element structureFieldsElement =
1284 (Element)fileEntryElement.selectSingleNode(
1285 "
1286 ddmStructure.getUuid()).concat("']"));
1287
1288 if (structureFieldsElement == null) {
1289 continue;
1290 }
1291
1292 String path = structureFieldsElement.attributeValue("path");
1293
1294 Fields fields = (Fields)portletDataContext.getZipEntryAsObject(
1295 path);
1296
1297 serviceContext.setAttribute(
1298 Fields.class.getName() + ddmStructure.getStructureId(), fields);
1299 }
1300 }
1301
1302 protected static boolean isDuplicateFileEntry(
1303 String folderUuid, FileEntry fileEntry1, FileEntry fileEntry2) {
1304
1305 try {
1306 Folder folder2 = fileEntry2.getFolder();
1307
1308 if (folderUuid.equals(folder2.getUuid()) &&
1309 (fileEntry1.getSize() == fileEntry2.getSize()) &&
1310 (DLUtil.compareVersions(
1311 fileEntry1.getVersion(), fileEntry2.getVersion()) == 0) &&
1312 fileEntry1.getVersionUserUuid().equals(
1313 fileEntry2.getVersionUserUuid())) {
1314
1315 return true;
1316 }
1317 else {
1318 return false;
1319 }
1320 }
1321 catch (Exception e) {
1322 return false;
1323 }
1324 }
1325
1326 protected static boolean isFileEntryTypeExportable(
1327 long companyId, DLFileEntryType dlFileEntryType)
1328 throws PortalException, SystemException {
1329
1330 if (dlFileEntryType.getFileEntryTypeId() == 0) {
1331 return false;
1332 }
1333
1334 Group group = GroupLocalServiceUtil.getCompanyGroup(companyId);
1335
1336 if (dlFileEntryType.getGroupId() == group.getGroupId()) {
1337 return false;
1338 }
1339
1340 return true;
1341 }
1342
1343 @Override
1344 protected PortletPreferences doDeleteData(
1345 PortletDataContext portletDataContext, String portletId,
1346 PortletPreferences portletPreferences)
1347 throws Exception {
1348
1349 if (!portletDataContext.addPrimaryKey(
1350 DLPortletDataHandlerImpl.class, "deleteData")) {
1351
1352 DLAppLocalServiceUtil.deleteAll(
1353 portletDataContext.getScopeGroupId());
1354 }
1355
1356 return null;
1357 }
1358
1359 @Override
1360 protected String doExportData(
1361 PortletDataContext portletDataContext, String portletId,
1362 PortletPreferences portletPreferences)
1363 throws Exception {
1364
1365 portletDataContext.addPermissions(
1366 "com.liferay.portlet.documentlibrary",
1367 portletDataContext.getScopeGroupId());
1368
1369 Document document = SAXReaderUtil.createDocument();
1370
1371 Element rootElement = document.addElement("documentlibrary-data");
1372
1373 rootElement.addAttribute(
1374 "group-id", String.valueOf(portletDataContext.getScopeGroupId()));
1375
1376 long rootFolderId = GetterUtil.getLong(
1377 portletPreferences.getValue("rootFolderId", null));
1378
1379 if (rootFolderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
1380 rootElement.addAttribute(
1381 "root-folder-id", String.valueOf(rootFolderId));
1382 }
1383
1384 Element fileEntryTypesElement = rootElement.addElement(
1385 "file-entry-types");
1386 Element foldersElement = rootElement.addElement("folders");
1387 Element fileEntriesElement = rootElement.addElement("file-entries");
1388 Element fileShortcutsElement = rootElement.addElement("file-shortcuts");
1389 Element fileRanksElement = rootElement.addElement("file-ranks");
1390
1391 List<DLFileEntryType> dlFileEntryTypes =
1392 DLFileEntryTypeServiceUtil.getFileEntryTypes(
1393 new long[] {portletDataContext.getScopeGroupId()});
1394
1395 for (DLFileEntryType dlFileEntryType : dlFileEntryTypes) {
1396 if (!isFileEntryTypeExportable(
1397 portletDataContext.getCompanyId(), dlFileEntryType)) {
1398
1399 continue;
1400 }
1401
1402 exportFileEntryType(
1403 portletDataContext, fileEntryTypesElement, dlFileEntryType);
1404 }
1405
1406 List<Folder> folders = FolderUtil.findByRepositoryId(
1407 portletDataContext.getScopeGroupId());
1408
1409 for (Folder folder : folders) {
1410 exportFolder(
1411 portletDataContext, fileEntryTypesElement, foldersElement,
1412 fileEntriesElement, fileShortcutsElement, fileRanksElement,
1413 folder, false);
1414 }
1415
1416 List<FileEntry> fileEntries = FileEntryUtil.findByR_F(
1417 portletDataContext.getScopeGroupId(),
1418 DLFolderConstants.DEFAULT_PARENT_FOLDER_ID);
1419
1420 for (FileEntry fileEntry : fileEntries) {
1421 exportFileEntry(
1422 portletDataContext, fileEntryTypesElement, foldersElement,
1423 fileEntriesElement, fileRanksElement, fileEntry, true);
1424 }
1425
1426 if (portletDataContext.getBooleanParameter(_NAMESPACE, "shortcuts")) {
1427 List<DLFileShortcut> fileShortcuts = DLFileShortcutUtil.findByG_F(
1428 portletDataContext.getScopeGroupId(),
1429 DLFolderConstants.DEFAULT_PARENT_FOLDER_ID);
1430
1431 for (DLFileShortcut fileShortcut : fileShortcuts) {
1432 exportFileShortcut(
1433 portletDataContext, fileEntryTypesElement, foldersElement,
1434 fileShortcutsElement, fileShortcut);
1435 }
1436 }
1437
1438 return document.formattedString();
1439 }
1440
1441 @Override
1442 protected PortletPreferences doImportData(
1443 PortletDataContext portletDataContext, String portletId,
1444 PortletPreferences portletPreferences, String data)
1445 throws Exception {
1446
1447 portletDataContext.importPermissions(
1448 "com.liferay.portlet.documentlibrary",
1449 portletDataContext.getSourceGroupId(),
1450 portletDataContext.getScopeGroupId());
1451
1452 Document document = SAXReaderUtil.read(data);
1453
1454 Element rootElement = document.getRootElement();
1455
1456 Element fileEntryTypesElement = rootElement.element("file-entry-types");
1457
1458 List<Element> fileEntryTypeElements = fileEntryTypesElement.elements(
1459 "file-entry-type");
1460
1461 for (Element fileEntryTypeElement : fileEntryTypeElements) {
1462 importFileEntryType(portletDataContext, fileEntryTypeElement);
1463 }
1464
1465 Element foldersElement = rootElement.element("folders");
1466
1467 List<Element> folderElements = foldersElement.elements("folder");
1468
1469 for (Element folderElement : folderElements) {
1470 importFolder(portletDataContext, folderElement);
1471 }
1472
1473 Element fileEntriesElement = rootElement.element("file-entries");
1474
1475 List<Element> fileEntryElements = fileEntriesElement.elements(
1476 "file-entry");
1477
1478 for (Element fileEntryElement : fileEntryElements) {
1479 importFileEntry(portletDataContext, fileEntryElement);
1480 }
1481
1482 if (portletDataContext.getBooleanParameter(_NAMESPACE, "shortcuts")) {
1483 List<Element> fileShortcutElements = rootElement.element(
1484 "file-shortcuts").elements("file-shortcut");
1485
1486 for (Element fileShortcutElement : fileShortcutElements) {
1487 importFileShortcut(portletDataContext, fileShortcutElement);
1488 }
1489 }
1490
1491 if (portletDataContext.getBooleanParameter(_NAMESPACE, "ranks")) {
1492 Element fileRanksElement = rootElement.element("file-ranks");
1493
1494 List<Element> fileRankElements = fileRanksElement.elements(
1495 "file-rank");
1496
1497 for (Element fileRankElement : fileRankElements) {
1498 importFileRank(portletDataContext, fileRankElement);
1499 }
1500 }
1501
1502 long rootFolderId = GetterUtil.getLong(
1503 rootElement.attributeValue("root-folder-id"));
1504
1505 if (rootFolderId > 0) {
1506 Map<Long, Long> folderPKs =
1507 (Map<Long, Long>)portletDataContext.getNewPrimaryKeysMap(
1508 DLFolder.class);
1509
1510 rootFolderId = MapUtil.getLong(
1511 folderPKs, rootFolderId, rootFolderId);
1512
1513 portletPreferences.setValue(
1514 "rootFolderId", String.valueOf(rootFolderId));
1515 }
1516
1517 return portletPreferences;
1518 }
1519
1520 private static final boolean _ALWAYS_EXPORTABLE = true;
1521
1522 private static final String _NAMESPACE = "document_library";
1523
1524 private static Log _log = LogFactoryUtil.getLog(
1525 DLPortletDataHandlerImpl.class);
1526
1527 private static PortletDataHandlerBoolean _categories =
1528 new PortletDataHandlerBoolean(_NAMESPACE, "categories");
1529
1530 private static PortletDataHandlerBoolean _comments =
1531 new PortletDataHandlerBoolean(_NAMESPACE, "comments");
1532
1533 private static PortletDataHandlerBoolean _foldersAndDocuments =
1534 new PortletDataHandlerBoolean(
1535 _NAMESPACE, "folders-and-documents", true, true);
1536
1537 private static PortletDataHandlerBoolean _ranks =
1538 new PortletDataHandlerBoolean(_NAMESPACE, "ranks");
1539
1540 private static PortletDataHandlerBoolean _ratings =
1541 new PortletDataHandlerBoolean(_NAMESPACE, "ratings");
1542
1543 private static PortletDataHandlerBoolean _shortcuts=
1544 new PortletDataHandlerBoolean(_NAMESPACE, "shortcuts");
1545
1546 private static PortletDataHandlerBoolean _tags =
1547 new PortletDataHandlerBoolean(_NAMESPACE, "tags");
1548
1549 }