001    /**
002     * Copyright (c) 2000-present 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.dao.orm.QueryUtil;
018    import com.liferay.portal.kernel.exception.PortalException;
019    import com.liferay.portal.kernel.lar.BaseStagedModelDataHandler;
020    import com.liferay.portal.kernel.lar.ExportImportPathUtil;
021    import com.liferay.portal.kernel.lar.PortletDataContext;
022    import com.liferay.portal.kernel.lar.PortletDataException;
023    import com.liferay.portal.kernel.lar.StagedModelDataHandlerUtil;
024    import com.liferay.portal.kernel.lar.StagedModelModifiedDateComparator;
025    import com.liferay.portal.kernel.log.Log;
026    import com.liferay.portal.kernel.log.LogFactoryUtil;
027    import com.liferay.portal.kernel.repository.model.FileEntry;
028    import com.liferay.portal.kernel.repository.model.FileVersion;
029    import com.liferay.portal.kernel.repository.model.Folder;
030    import com.liferay.portal.kernel.search.Indexer;
031    import com.liferay.portal.kernel.search.IndexerRegistryUtil;
032    import com.liferay.portal.kernel.trash.TrashHandler;
033    import com.liferay.portal.kernel.trash.TrashHandlerRegistryUtil;
034    import com.liferay.portal.kernel.util.ArrayUtil;
035    import com.liferay.portal.kernel.util.FileUtil;
036    import com.liferay.portal.kernel.util.ListUtil;
037    import com.liferay.portal.kernel.util.MapUtil;
038    import com.liferay.portal.kernel.util.StringPool;
039    import com.liferay.portal.kernel.util.StringUtil;
040    import com.liferay.portal.kernel.util.Validator;
041    import com.liferay.portal.kernel.xml.Element;
042    import com.liferay.portal.model.Repository;
043    import com.liferay.portal.repository.liferayrepository.LiferayRepository;
044    import com.liferay.portal.repository.liferayrepository.model.LiferayFileEntry;
045    import com.liferay.portal.service.RepositoryLocalServiceUtil;
046    import com.liferay.portal.service.ServiceContext;
047    import com.liferay.portal.util.PortalUtil;
048    import com.liferay.portlet.documentlibrary.DuplicateFileException;
049    import com.liferay.portlet.documentlibrary.NoSuchFileException;
050    import com.liferay.portlet.documentlibrary.model.DLFileEntry;
051    import com.liferay.portlet.documentlibrary.model.DLFileEntryMetadata;
052    import com.liferay.portlet.documentlibrary.model.DLFileEntryType;
053    import com.liferay.portlet.documentlibrary.model.DLFileVersion;
054    import com.liferay.portlet.documentlibrary.model.DLFolderConstants;
055    import com.liferay.portlet.documentlibrary.service.DLAppLocalServiceUtil;
056    import com.liferay.portlet.documentlibrary.service.DLAppServiceUtil;
057    import com.liferay.portlet.documentlibrary.service.DLFileEntryLocalServiceUtil;
058    import com.liferay.portlet.documentlibrary.service.DLFileEntryMetadataLocalServiceUtil;
059    import com.liferay.portlet.documentlibrary.service.DLFileEntryTypeLocalServiceUtil;
060    import com.liferay.portlet.documentlibrary.service.DLFileVersionLocalServiceUtil;
061    import com.liferay.portlet.documentlibrary.util.DLProcessorRegistryUtil;
062    import com.liferay.portlet.documentlibrary.util.DLProcessorThreadLocal;
063    import com.liferay.portlet.documentlibrary.util.DLUtil;
064    import com.liferay.portlet.dynamicdatamapping.model.DDMStructure;
065    import com.liferay.portlet.dynamicdatamapping.storage.Fields;
066    import com.liferay.portlet.dynamicdatamapping.storage.StorageEngineUtil;
067    
068    import java.io.IOException;
069    import java.io.InputStream;
070    
071    import java.util.List;
072    import java.util.Map;
073    
074    /**
075     * @author Mate Thurzo
076     */
077    public class FileEntryStagedModelDataHandler
078            extends BaseStagedModelDataHandler<FileEntry> {
079    
080            public static final String[] CLASS_NAMES = {
081                    DLFileEntry.class.getName(), FileEntry.class.getName(),
082                    LiferayFileEntry.class.getName()
083            };
084    
085            @Override
086            public void deleteStagedModel(
087                            String uuid, long groupId, String className, String extraData)
088                    throws PortalException {
089    
090                    FileEntry fileEntry = fetchStagedModelByUuidAndGroupId(uuid, groupId);
091    
092                    if (fileEntry != null) {
093                            DLAppLocalServiceUtil.deleteFileEntry(fileEntry.getFileEntryId());
094                    }
095            }
096    
097            @Override
098            public FileEntry fetchStagedModelByUuidAndCompanyId(
099                    String uuid, long companyId) {
100    
101                    List<DLFileEntry> fileEntries =
102                            DLFileEntryLocalServiceUtil.getDLFileEntriesByUuidAndCompanyId(
103                                    uuid, companyId, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
104                                    new StagedModelModifiedDateComparator<DLFileEntry>());
105    
106                    if (ListUtil.isEmpty(fileEntries)) {
107                            return null;
108                    }
109    
110                    return new LiferayFileEntry(fileEntries.get(0));
111            }
112    
113            @Override
114            public FileEntry fetchStagedModelByUuidAndGroupId(
115                    String uuid, long groupId) {
116    
117                    try {
118                            return DLAppLocalServiceUtil.getFileEntryByUuidAndGroupId(
119                                    uuid, groupId);
120                    }
121                    catch (PortalException pe) {
122                            return null;
123                    }
124            }
125    
126            @Override
127            public String[] getClassNames() {
128                    return CLASS_NAMES;
129            }
130    
131            @Override
132            public String getDisplayName(FileEntry fileEntry) {
133                    return fileEntry.getTitle();
134            }
135    
136            @Override
137            public void importStagedModel(
138                            PortletDataContext portletDataContext, FileEntry fileEntry)
139                    throws PortletDataException {
140    
141                    boolean dlProcessorEnabled = DLProcessorThreadLocal.isEnabled();
142    
143                    try {
144                            DLProcessorThreadLocal.setEnabled(false);
145    
146                            super.importStagedModel(portletDataContext, fileEntry);
147                    }
148                    finally {
149                            DLProcessorThreadLocal.setEnabled(dlProcessorEnabled);
150                    }
151            }
152    
153            @Override
154            protected void doExportStagedModel(
155                            PortletDataContext portletDataContext, FileEntry fileEntry)
156                    throws Exception {
157    
158                    Element fileEntryElement = portletDataContext.getExportDataElement(
159                            fileEntry);
160    
161                    String fileEntryPath = ExportImportPathUtil.getModelPath(fileEntry);
162    
163                    if (!fileEntry.isDefaultRepository()) {
164                            Repository repository = RepositoryLocalServiceUtil.getRepository(
165                                    fileEntry.getRepositoryId());
166    
167                            StagedModelDataHandlerUtil.exportReferenceStagedModel(
168                                    portletDataContext, fileEntry, repository,
169                                    PortletDataContext.REFERENCE_TYPE_STRONG);
170    
171                            portletDataContext.addClassedModel(
172                                    fileEntryElement, fileEntryPath, fileEntry);
173    
174                            long liferayRepositoryClassNameId = PortalUtil.getClassNameId(
175                                    LiferayRepository.class.getName());
176    
177                            if (repository.getClassNameId() != liferayRepositoryClassNameId) {
178                                    return;
179                            }
180                    }
181    
182                    if (fileEntry.getFolderId() !=
183                                    DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
184    
185                            StagedModelDataHandlerUtil.exportReferenceStagedModel(
186                                    portletDataContext, fileEntry, fileEntry.getFolder(),
187                                    PortletDataContext.REFERENCE_TYPE_PARENT);
188                    }
189    
190                    LiferayFileEntry liferayFileEntry = (LiferayFileEntry)fileEntry;
191    
192                    liferayFileEntry.setCachedFileVersion(fileEntry.getFileVersion());
193    
194                    if (!portletDataContext.isPerformDirectBinaryImport()) {
195                            InputStream is = null;
196    
197                            try {
198                                    is = FileEntryUtil.getContentStream(fileEntry);
199                            }
200                            catch (NoSuchFileException nsfe) {
201                            }
202    
203                            if (is == null) {
204                                    if (_log.isWarnEnabled()) {
205                                            _log.warn(
206                                                    "No file found for file entry " +
207                                                            fileEntry.getFileEntryId());
208                                    }
209    
210                                    fileEntryElement.detach();
211    
212                                    return;
213                            }
214    
215                            try {
216                                    String binPath = ExportImportPathUtil.getModelPath(
217                                            fileEntry, fileEntry.getVersion());
218    
219                                    portletDataContext.addZipEntry(binPath, is);
220    
221                                    fileEntryElement.addAttribute("bin-path", binPath);
222                            }
223                            finally {
224                                    try {
225                                            is.close();
226                                    }
227                                    catch (IOException ioe) {
228                                            _log.error(ioe, ioe);
229                                    }
230                            }
231                    }
232    
233                    if (portletDataContext.getBooleanParameter(
234                                    DLPortletDataHandler.NAMESPACE, "previews-and-thumbnails")) {
235    
236                            DLProcessorRegistryUtil.exportGeneratedFiles(
237                                    portletDataContext, fileEntry, fileEntryElement);
238                    }
239    
240                    exportMetaData(portletDataContext, fileEntryElement, fileEntry);
241    
242                    portletDataContext.addClassedModel(
243                            fileEntryElement, fileEntryPath, liferayFileEntry,
244                            DLFileEntry.class);
245            }
246    
247            @Override
248            protected void doImportMissingReference(
249                            PortletDataContext portletDataContext, String uuid, long groupId,
250                            long fileEntryId)
251                    throws Exception {
252    
253                    FileEntry existingFileEntry = fetchMissingReference(uuid, groupId);
254    
255                    Map<Long, Long> dlFileEntryIds =
256                            (Map<Long, Long>)portletDataContext.getNewPrimaryKeysMap(
257                                    DLFileEntry.class);
258    
259                    dlFileEntryIds.put(fileEntryId, existingFileEntry.getFileEntryId());
260    
261                    Map<Long, Long> fileEntryIds =
262                            (Map<Long, Long>)portletDataContext.getNewPrimaryKeysMap(
263                                    FileEntry.class);
264    
265                    fileEntryIds.put(fileEntryId, existingFileEntry.getFileEntryId());
266            }
267    
268            @Override
269            protected void doImportStagedModel(
270                            PortletDataContext portletDataContext, FileEntry fileEntry)
271                    throws Exception {
272    
273                    long userId = portletDataContext.getUserId(fileEntry.getUserUuid());
274    
275                    if (!fileEntry.isDefaultRepository()) {
276    
277                            // References has been automatically imported, nothing to do here
278    
279                            return;
280                    }
281    
282                    Map<Long, Long> folderIds =
283                            (Map<Long, Long>)portletDataContext.getNewPrimaryKeysMap(
284                                    Folder.class);
285    
286                    long folderId = MapUtil.getLong(
287                            folderIds, fileEntry.getFolderId(), fileEntry.getFolderId());
288    
289                    long[] assetCategoryIds = portletDataContext.getAssetCategoryIds(
290                            DLFileEntry.class, fileEntry.getFileEntryId());
291                    String[] assetTagNames = portletDataContext.getAssetTagNames(
292                            DLFileEntry.class, fileEntry.getFileEntryId());
293    
294                    ServiceContext serviceContext = portletDataContext.createServiceContext(
295                            fileEntry, DLFileEntry.class);
296    
297                    serviceContext.setAttribute(
298                            "sourceFileName", "A." + fileEntry.getExtension());
299                    serviceContext.setUserId(userId);
300    
301                    Element fileEntryElement = portletDataContext.getImportDataElement(
302                            fileEntry);
303    
304                    String binPath = fileEntryElement.attributeValue("bin-path");
305    
306                    InputStream is = null;
307    
308                    if (Validator.isNull(binPath) &&
309                            portletDataContext.isPerformDirectBinaryImport()) {
310    
311                            try {
312                                    is = FileEntryUtil.getContentStream(fileEntry);
313                            }
314                            catch (NoSuchFileException nsfe) {
315                            }
316                    }
317                    else {
318                            is = portletDataContext.getZipEntryAsInputStream(binPath);
319                    }
320    
321                    if (is == null) {
322                            if (_log.isWarnEnabled()) {
323                                    _log.warn(
324                                            "No file found for file entry " +
325                                                    fileEntry.getFileEntryId());
326                            }
327    
328                            return;
329                    }
330    
331                    importMetaData(
332                            portletDataContext, fileEntryElement, fileEntry, serviceContext);
333    
334                    FileEntry importedFileEntry = null;
335    
336                    String titleWithExtension = DLUtil.getTitleWithExtension(fileEntry);
337                    String extension = fileEntry.getExtension();
338    
339                    String periodAndExtension = StringPool.PERIOD.concat(extension);
340    
341                    if (portletDataContext.isDataStrategyMirror()) {
342                            FileEntry existingFileEntry = fetchStagedModelByUuidAndGroupId(
343                                    fileEntry.getUuid(), portletDataContext.getScopeGroupId());
344    
345                            FileVersion fileVersion = fileEntry.getFileVersion();
346    
347                            if (existingFileEntry == null) {
348                                    String fileEntryTitle = fileEntry.getTitle();
349    
350                                    FileEntry existingTitleFileEntry = FileEntryUtil.fetchByR_F_T(
351                                            portletDataContext.getScopeGroupId(), folderId,
352                                            fileEntryTitle);
353    
354                                    if (existingTitleFileEntry != null) {
355                                            if ((fileEntry.getGroupId() ==
356                                                            portletDataContext.getSourceGroupId()) &&
357                                                    portletDataContext.
358                                                            isDataStrategyMirrorWithOverwriting()) {
359    
360                                                    DLAppLocalServiceUtil.deleteFileEntry(
361                                                            existingTitleFileEntry.getFileEntryId());
362                                            }
363                                            else {
364                                                    boolean titleHasExtension = false;
365    
366                                                    if (fileEntryTitle.endsWith(periodAndExtension)) {
367                                                            fileEntryTitle = FileUtil.stripExtension(
368                                                                    fileEntryTitle);
369    
370                                                            titleHasExtension = true;
371                                                    }
372    
373                                                    for (int i = 1;; i++) {
374                                                            fileEntryTitle += StringPool.SPACE + i;
375    
376                                                            titleWithExtension =
377                                                                    fileEntryTitle + periodAndExtension;
378    
379                                                            existingTitleFileEntry = FileEntryUtil.fetchByR_F_T(
380                                                                    portletDataContext.getScopeGroupId(), folderId,
381                                                                    titleWithExtension);
382    
383                                                            if (existingTitleFileEntry == null) {
384                                                                    if (titleHasExtension) {
385                                                                            fileEntryTitle += periodAndExtension;
386                                                                    }
387    
388                                                                    break;
389                                                            }
390                                                    }
391                                            }
392                                    }
393    
394                                    serviceContext.setAttribute(
395                                            "fileVersionUuid", fileVersion.getUuid());
396                                    serviceContext.setUuid(fileEntry.getUuid());
397    
398                                    importedFileEntry = DLAppLocalServiceUtil.addFileEntry(
399                                            userId, portletDataContext.getScopeGroupId(), folderId,
400                                            titleWithExtension, fileEntry.getMimeType(), fileEntryTitle,
401                                            fileEntry.getDescription(), null, is, fileEntry.getSize(),
402                                            serviceContext);
403    
404                                    if (fileEntry.isInTrash()) {
405                                            importedFileEntry = DLAppServiceUtil.moveFileEntryToTrash(
406                                                    importedFileEntry.getFileEntryId());
407                                    }
408                            }
409                            else {
410                                    FileVersion latestExistingFileVersion =
411                                            existingFileEntry.getLatestFileVersion(true);
412    
413                                    boolean indexEnabled = serviceContext.isIndexingEnabled();
414    
415                                    try {
416                                            serviceContext.setIndexingEnabled(false);
417    
418                                            if (!fileVersion.getUuid().equals(
419                                                            latestExistingFileVersion.getUuid())) {
420    
421                                                    DLFileVersion alreadyExistingFileVersion =
422                                                            DLFileVersionLocalServiceUtil.
423                                                                    getFileVersionByUuidAndGroupId(
424                                                                            fileVersion.getUuid(),
425                                                                            existingFileEntry.getGroupId());
426    
427                                                    if (alreadyExistingFileVersion != null) {
428                                                            serviceContext.setAttribute(
429                                                                    "existingDLFileVersionId",
430                                                                    alreadyExistingFileVersion.getFileVersionId());
431                                                    }
432    
433                                                    serviceContext.setUuid(fileVersion.getUuid());
434    
435                                                    importedFileEntry =
436                                                            DLAppLocalServiceUtil.updateFileEntry(
437                                                                    userId, existingFileEntry.getFileEntryId(),
438                                                                    titleWithExtension, fileEntry.getMimeType(),
439                                                                    fileEntry.getTitle(),
440                                                                    fileEntry.getDescription(), null, false, is,
441                                                                    fileEntry.getSize(), serviceContext);
442                                            }
443                                            else {
444                                                    DLAppLocalServiceUtil.updateAsset(
445                                                            userId, existingFileEntry,
446                                                            latestExistingFileVersion, assetCategoryIds,
447                                                            assetTagNames, null);
448    
449                                                    importedFileEntry = existingFileEntry;
450                                            }
451    
452                                            if (importedFileEntry.getFolderId() != folderId) {
453                                                    importedFileEntry = DLAppLocalServiceUtil.moveFileEntry(
454                                                            userId, importedFileEntry.getFileEntryId(),
455                                                            folderId, serviceContext);
456                                            }
457    
458                                            if (importedFileEntry instanceof LiferayFileEntry) {
459                                                    LiferayFileEntry liferayFileEntry =
460                                                            (LiferayFileEntry)importedFileEntry;
461    
462                                                    Indexer indexer = IndexerRegistryUtil.getIndexer(
463                                                            DLFileEntry.class);
464    
465                                                    indexer.reindex(liferayFileEntry.getModel());
466                                            }
467                                    }
468                                    finally {
469                                            serviceContext.setIndexingEnabled(indexEnabled);
470                                    }
471                            }
472                    }
473                    else {
474                            try {
475                                    importedFileEntry = DLAppLocalServiceUtil.addFileEntry(
476                                            userId, portletDataContext.getScopeGroupId(), folderId,
477                                            titleWithExtension, fileEntry.getMimeType(),
478                                            fileEntry.getTitle(), fileEntry.getDescription(), null, is,
479                                            fileEntry.getSize(), serviceContext);
480                            }
481                            catch (DuplicateFileException dfe) {
482                                    String title = fileEntry.getTitle();
483    
484                                    String[] titleParts = title.split("\\.", 2);
485    
486                                    title = titleParts[0] + StringUtil.randomString();
487    
488                                    if (titleParts.length > 1) {
489                                            title += StringPool.PERIOD + titleParts[1];
490                                    }
491    
492                                    if (!title.endsWith(periodAndExtension)) {
493                                            title += periodAndExtension;
494                                    }
495    
496                                    importedFileEntry = DLAppLocalServiceUtil.addFileEntry(
497                                            userId, portletDataContext.getScopeGroupId(), folderId,
498                                            title, fileEntry.getMimeType(), title,
499                                            fileEntry.getDescription(), null, is, fileEntry.getSize(),
500                                            serviceContext);
501                            }
502                    }
503    
504                    if (portletDataContext.getBooleanParameter(
505                                    DLPortletDataHandler.NAMESPACE, "previews-and-thumbnails")) {
506    
507                            DLProcessorRegistryUtil.importGeneratedFiles(
508                                    portletDataContext, fileEntry, importedFileEntry,
509                                    fileEntryElement);
510                    }
511    
512                    portletDataContext.importClassedModel(
513                            fileEntry, importedFileEntry, DLFileEntry.class);
514    
515                    Map<Long, Long> fileEntryIds =
516                            (Map<Long, Long>)portletDataContext.getNewPrimaryKeysMap(
517                                    FileEntry.class);
518    
519                    fileEntryIds.put(
520                            fileEntry.getFileEntryId(), importedFileEntry.getFileEntryId());
521            }
522    
523            @Override
524            protected void doRestoreStagedModel(
525                            PortletDataContext portletDataContext, FileEntry fileEntry)
526                    throws Exception {
527    
528                    long userId = portletDataContext.getUserId(fileEntry.getUserUuid());
529    
530                    FileEntry existingFileEntry = fetchStagedModelByUuidAndGroupId(
531                            fileEntry.getUuid(), portletDataContext.getScopeGroupId());
532    
533                    if ((existingFileEntry == null) || !existingFileEntry.isInTrash()) {
534                            return;
535                    }
536    
537                    TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
538                            DLFileEntry.class.getName());
539    
540                    if (trashHandler.isRestorable(existingFileEntry.getFileEntryId())) {
541                            trashHandler.restoreTrashEntry(
542                                    userId, existingFileEntry.getFileEntryId());
543                    }
544            }
545    
546            protected void exportMetaData(
547                            PortletDataContext portletDataContext, Element fileEntryElement,
548                            FileEntry fileEntry)
549                    throws Exception {
550    
551                    LiferayFileEntry liferayFileEntry = (LiferayFileEntry)fileEntry;
552    
553                    DLFileEntry dlFileEntry = liferayFileEntry.getDLFileEntry();
554    
555                    long fileEntryTypeId = dlFileEntry.getFileEntryTypeId();
556    
557                    DLFileEntryType dlFileEntryType =
558                            DLFileEntryTypeLocalServiceUtil.fetchFileEntryType(fileEntryTypeId);
559    
560                    if ((dlFileEntryType == null) || !dlFileEntryType.isExportable()) {
561                            return;
562                    }
563    
564                    StagedModelDataHandlerUtil.exportReferenceStagedModel(
565                            portletDataContext, fileEntry, dlFileEntryType,
566                            PortletDataContext.REFERENCE_TYPE_STRONG);
567    
568                    List<DDMStructure> ddmStructures = dlFileEntryType.getDDMStructures();
569    
570                    for (DDMStructure ddmStructure : ddmStructures) {
571                            FileVersion fileVersion = fileEntry.getFileVersion();
572    
573                            DLFileEntryMetadata dlFileEntryMetadata =
574                                    DLFileEntryMetadataLocalServiceUtil.fetchFileEntryMetadata(
575                                            ddmStructure.getStructureId(),
576                                            fileVersion.getFileVersionId());
577    
578                            if (dlFileEntryMetadata == null) {
579                                    continue;
580                            }
581    
582                            Element structureFields = fileEntryElement.addElement(
583                                    "structure-fields");
584    
585                            String path = ExportImportPathUtil.getModelPath(
586                                    ddmStructure,
587                                    String.valueOf(dlFileEntryMetadata.getDDMStorageId()));
588    
589                            structureFields.addAttribute("path", path);
590    
591                            structureFields.addAttribute(
592                                    "structureUuid", ddmStructure.getUuid());
593    
594                            Fields fields = StorageEngineUtil.getFields(
595                                    dlFileEntryMetadata.getDDMStorageId());
596    
597                            portletDataContext.addZipEntry(path, fields);
598                    }
599            }
600    
601            protected void importMetaData(
602                            PortletDataContext portletDataContext, Element fileEntryElement,
603                            FileEntry fileEntry, ServiceContext serviceContext)
604                    throws Exception {
605    
606                    LiferayFileEntry liferayFileEntry = (LiferayFileEntry)fileEntry;
607    
608                    DLFileEntry dlFileEntry = liferayFileEntry.getDLFileEntry();
609    
610                    Map<Long, Long> dlFileEntryTypeIds =
611                            (Map<Long, Long>)portletDataContext.getNewPrimaryKeysMap(
612                                    DLFileEntryType.class);
613    
614                    long dlFileEntryTypeId = MapUtil.getLong(
615                            dlFileEntryTypeIds, dlFileEntry.getFileEntryTypeId(),
616                            dlFileEntry.getFileEntryTypeId());
617    
618                    DLFileEntryType existingDLFileEntryType =
619                            DLFileEntryTypeLocalServiceUtil.fetchDLFileEntryType(
620                                    dlFileEntryTypeId);
621    
622                    if (existingDLFileEntryType == null) {
623                            serviceContext.setAttribute("fileEntryTypeId", -1);
624    
625                            return;
626                    }
627    
628                    serviceContext.setAttribute(
629                            "fileEntryTypeId", existingDLFileEntryType.getFileEntryTypeId());
630    
631                    List<DDMStructure> ddmStructures =
632                            existingDLFileEntryType.getDDMStructures();
633    
634                    for (DDMStructure ddmStructure : ddmStructures) {
635                            Element structureFieldsElement =
636                                    (Element)fileEntryElement.selectSingleNode(
637                                            "structure-fields[@structureUuid='".concat(
638                                                    ddmStructure.getUuid()).concat("']"));
639    
640                            if (structureFieldsElement == null) {
641                                    continue;
642                            }
643    
644                            String path = structureFieldsElement.attributeValue("path");
645    
646                            Fields fields = (Fields)portletDataContext.getZipEntryAsObject(
647                                    path);
648    
649                            serviceContext.setAttribute(
650                                    Fields.class.getName() + ddmStructure.getStructureId(), fields);
651                    }
652            }
653    
654            @Override
655            protected void validateExport(
656                            PortletDataContext portletDataContext, FileEntry fileEntry)
657                    throws PortletDataException {
658    
659                    if ((fileEntry.getGroupId() != portletDataContext.getGroupId()) &&
660                            (fileEntry.getGroupId() != portletDataContext.getScopeGroupId())) {
661    
662                            PortletDataException pde = new PortletDataException(
663                                    PortletDataException.INVALID_GROUP);
664    
665                            pde.setStagedModel(fileEntry);
666    
667                            throw pde;
668                    }
669    
670                    try {
671                            FileVersion fileVersion = fileEntry.getFileVersion();
672    
673                            if (!ArrayUtil.contains(
674                                            getExportableStatuses(), fileVersion.getStatus())) {
675    
676                                    throw new PortletDataException(
677                                            PortletDataException.STATUS_UNAVAILABLE);
678                            }
679                    }
680                    catch (PortletDataException pde) {
681                            throw pde;
682                    }
683                    catch (Exception e) {
684                            if (_log.isDebugEnabled()) {
685                                    _log.debug(e, e);
686                            }
687                            else if (_log.isWarnEnabled()) {
688                                    _log.warn(
689                                            "Unable to check workflow status for file entry " +
690                                                    fileEntry.getFileEntryId());
691                            }
692                    }
693    
694                    TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
695                            DLFileEntry.class.getName());
696    
697                    if (trashHandler != null) {
698                            try {
699                                    if (trashHandler.isInTrash(fileEntry.getFileEntryId()) ||
700                                            trashHandler.isInTrashContainer(
701                                                    fileEntry.getFileEntryId())) {
702    
703                                            throw new PortletDataException(
704                                                    PortletDataException.STATUS_IN_TRASH);
705                                    }
706                            }
707                            catch (PortletDataException pde) {
708                                    throw pde;
709                            }
710                            catch (Exception e) {
711                                    if (_log.isDebugEnabled()) {
712                                            _log.debug(e, e);
713                                    }
714                                    else if (_log.isWarnEnabled()) {
715                                            _log.warn(
716                                                    "Unable to check trash status for file entry " +
717                                                            fileEntry.getFileEntryId());
718                                    }
719                            }
720                    }
721            }
722    
723            private static Log _log = LogFactoryUtil.getLog(
724                    FileEntryStagedModelDataHandler.class);
725    
726    }