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