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