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