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