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