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