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