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