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