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