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