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