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