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