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