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