Example usage for com.liferay.portal.kernel.repository.model FileEntry getExtension

List of usage examples for com.liferay.portal.kernel.repository.model FileEntry getExtension

  1. HOME
  2. Java
  3. com.liferay.portal
  4. com.liferay.portal.kernel.repository.model.*
  5. FileEntry
  6. getExtension

Introduction

In this page you can find the example usage for com.liferay.portal.kernel.repository.model FileEntry getExtension.

Prototype

public String getExtension();

Source Link

Usage

From source file:au.com.permeance.liferay.portlet.documentlibrary.service.impl.DLFolderExportZipHelper.java

License:Open Source License

/**
 * Returns a ZIP entry name for the file entry.
 * /*from   w ww  . j av  a  2s.c om*/
 * @param fileEntry file entry
 * @param folderPath file path
 * @param zipWriter ZIP writer
 * 
 * @return ZIP entry name
 * 
 * @throws SystemException
 * @throws PortalException
 */
public static String buildZipEntryName(FileEntry fileEntry, String folderPath, ZipWriter zipWriter)
        throws SystemException, PortalException {

    // Use file entry title as file name
    String fileEntryBaseName = fileEntry.getTitle();

    // normalize base name by stripping extension and replacing non-alphanum chars with underscore
    fileEntryBaseName = FilenameUtils.getBaseName(fileEntryBaseName);
    fileEntryBaseName = fileEntryBaseName.replaceAll("\\W+", "_");

    // build zip entry name
    String zipEntryName = folderPath + fileEntryBaseName + FilenameUtils.EXTENSION_SEPARATOR_STR
            + fileEntry.getExtension();

    if (zipWriter.hasAllocatedPath(zipEntryName)) {
        String oldZipEntryName = zipEntryName;
        int counter = 1;
        while (true) {
            zipEntryName = folderPath + fileEntryBaseName + StringPool.OPEN_BRACKET + counter
                    + StringPool.CLOSE_BRACKET + FilenameUtils.EXTENSION_SEPARATOR_STR
                    + fileEntry.getExtension();
            if (!zipWriter.hasAllocatedPath(zipEntryName)) {
                break;
            }
            counter++;
        }

        if (s_log.isDebugEnabled()) {
            s_log.debug(oldZipEntryName + " already exists in ZIP file, renaming to " + zipEntryName);
        }
    }

    return zipEntryName;
}

From source file:com.liferay.blogs.service.impl.BlogsEntryLocalServiceImpl.java

License:Open Source License

protected void validate(long smallImageFileEntryId) throws PortalException {
    String[] imageExtensions = PrefsPropsUtil.getStringArray(PropsKeys.BLOGS_IMAGE_EXTENSIONS,
            StringPool.COMMA);//www.  ja  va2  s . co m

    if (smallImageFileEntryId != 0) {
        FileEntry fileEntry = PortletFileRepositoryUtil.getPortletFileEntry(smallImageFileEntryId);

        boolean validSmallImageExtension = false;

        for (String imageExtension : imageExtensions) {
            if (StringPool.STAR.equals(imageExtension)
                    || imageExtension.equals(StringPool.PERIOD + fileEntry.getExtension())) {

                validSmallImageExtension = true;

                break;
            }
        }

        if (!validSmallImageExtension) {
            throw new EntrySmallImageNameException(
                    "Invalid small image for file entry " + smallImageFileEntryId);
        }
    }
}

From source file:com.liferay.document.library.internal.exportimport.data.handler.FileEntryStagedModelDataHandler.java

License:Open Source License

@Override
protected void doImportStagedModel(PortletDataContext portletDataContext, FileEntry fileEntry)
        throws Exception {

    long userId = portletDataContext.getUserId(fileEntry.getUserUuid());

    if (!fileEntry.isDefaultRepository()) {

        // References has been automatically imported, nothing to do here

        return;//w  w w  . j a  va2  s. c  om
    }

    Map<Long, Long> folderIds = (Map<Long, Long>) portletDataContext.getNewPrimaryKeysMap(Folder.class);

    long folderId = MapUtil.getLong(folderIds, fileEntry.getFolderId(), fileEntry.getFolderId());

    long[] assetCategoryIds = portletDataContext.getAssetCategoryIds(DLFileEntry.class,
            fileEntry.getFileEntryId());
    String[] assetTagNames = portletDataContext.getAssetTagNames(DLFileEntry.class, fileEntry.getFileEntryId());

    ServiceContext serviceContext = portletDataContext.createServiceContext(fileEntry, DLFileEntry.class);

    serviceContext.setAttribute("sourceFileName", "A." + fileEntry.getExtension());
    serviceContext.setUserId(userId);

    Element fileEntryElement = portletDataContext.getImportDataElement(fileEntry);

    String binPath = fileEntryElement.attributeValue("bin-path");

    InputStream is = null;

    try {
        if (Validator.isNull(binPath) && portletDataContext.isPerformDirectBinaryImport()) {

            try {
                is = FileEntryUtil.getContentStream(fileEntry);
            } catch (Exception e) {
                if (_log.isWarnEnabled()) {
                    _log.warn("Unable to retrieve content for file entry " + fileEntry.getFileEntryId(), e);
                }

                return;
            }
        } else {
            is = portletDataContext.getZipEntryAsInputStream(binPath);
        }

        if (is == null) {
            if (_log.isWarnEnabled()) {
                _log.warn("No file found for file entry " + fileEntry.getFileEntryId());
            }

            return;
        }

        importMetaData(portletDataContext, fileEntryElement, fileEntry, serviceContext);

        FileEntry importedFileEntry = null;

        if (portletDataContext.isDataStrategyMirror()) {
            FileEntry existingFileEntry = fetchStagedModelByUuidAndGroupId(fileEntry.getUuid(),
                    portletDataContext.getScopeGroupId());

            FileVersion fileVersion = fileEntry.getFileVersion();

            if (existingFileEntry == null) {
                if (portletDataContext.isDataStrategyMirrorWithOverwriting()) {

                    FileEntry existingTitleFileEntry = FileEntryUtil
                            .fetchByR_F_T(portletDataContext.getScopeGroupId(), folderId, fileEntry.getTitle());

                    if (existingTitleFileEntry == null) {
                        existingTitleFileEntry = FileEntryUtil.fetchByR_F_FN(
                                portletDataContext.getScopeGroupId(), folderId, fileEntry.getFileName());
                    }

                    if (existingTitleFileEntry != null) {
                        _dlAppLocalService.deleteFileEntry(existingTitleFileEntry.getFileEntryId());
                    }
                }

                serviceContext.setAttribute("fileVersionUuid", fileVersion.getUuid());
                serviceContext.setUuid(fileEntry.getUuid());

                String fileEntryTitle = _dlFileEntryLocalService.getUniqueTitle(
                        portletDataContext.getScopeGroupId(), folderId, 0, fileEntry.getTitle(),
                        fileEntry.getExtension());

                importedFileEntry = _dlAppLocalService.addFileEntry(userId,
                        portletDataContext.getScopeGroupId(), folderId, fileEntry.getFileName(),
                        fileEntry.getMimeType(), fileEntryTitle, fileEntry.getDescription(), null, is,
                        fileEntry.getSize(), serviceContext);

                if (fileEntry.isInTrash()) {
                    importedFileEntry = _dlTrashService
                            .moveFileEntryToTrash(importedFileEntry.getFileEntryId());
                }
            } else {
                FileVersion latestExistingFileVersion = existingFileEntry.getLatestFileVersion(true);

                boolean indexEnabled = serviceContext.isIndexingEnabled();

                boolean deleteFileEntry = false;
                boolean updateFileEntry = false;

                if (!Objects.equals(fileVersion.getUuid(), latestExistingFileVersion.getUuid())) {

                    deleteFileEntry = true;
                    updateFileEntry = true;
                } else {
                    InputStream existingFileVersionInputStream = null;

                    try {
                        existingFileVersionInputStream = latestExistingFileVersion.getContentStream(false);
                    } catch (Exception e) {
                        if (_log.isDebugEnabled()) {
                            _log.debug(e, e);
                        }
                    } finally {
                        if (existingFileVersionInputStream != null) {
                            existingFileVersionInputStream.close();
                        }
                    }

                    if (existingFileVersionInputStream == null) {
                        updateFileEntry = true;
                    }
                }

                try {
                    serviceContext.setIndexingEnabled(false);

                    if (updateFileEntry) {
                        DLFileVersion alreadyExistingFileVersion = _dlFileVersionLocalService
                                .getFileVersionByUuidAndGroupId(fileVersion.getUuid(),
                                        existingFileEntry.getGroupId());

                        if (alreadyExistingFileVersion != null) {
                            serviceContext.setAttribute("existingDLFileVersionId",
                                    alreadyExistingFileVersion.getFileVersionId());
                        }

                        serviceContext.setUuid(fileVersion.getUuid());

                        String fileEntryTitle = _dlFileEntryLocalService.getUniqueTitle(
                                portletDataContext.getScopeGroupId(), existingFileEntry.getFolderId(),
                                existingFileEntry.getFileEntryId(), fileEntry.getTitle(),
                                fileEntry.getExtension());

                        importedFileEntry = _dlAppLocalService.updateFileEntry(userId,
                                existingFileEntry.getFileEntryId(), fileEntry.getFileName(),
                                fileEntry.getMimeType(), fileEntryTitle, fileEntry.getDescription(), null,
                                false, is, fileEntry.getSize(), serviceContext);
                    } else {
                        _dlAppLocalService.updateAsset(userId, existingFileEntry, latestExistingFileVersion,
                                assetCategoryIds, assetTagNames, null);

                        importedFileEntry = existingFileEntry;
                    }

                    if (importedFileEntry.getFolderId() != folderId) {
                        importedFileEntry = _dlAppLocalService.moveFileEntry(userId,
                                importedFileEntry.getFileEntryId(), folderId, serviceContext);
                    }

                    if (importedFileEntry instanceof LiferayFileEntry) {
                        LiferayFileEntry liferayFileEntry = (LiferayFileEntry) importedFileEntry;

                        Indexer<DLFileEntry> indexer = IndexerRegistryUtil
                                .nullSafeGetIndexer(DLFileEntry.class);

                        indexer.reindex((DLFileEntry) liferayFileEntry.getModel());
                    }

                    if (deleteFileEntry && ExportImportThreadLocal.isStagingInProcess()) {

                        _dlAppService.deleteFileVersion(latestExistingFileVersion.getFileEntryId(),
                                latestExistingFileVersion.getVersion());
                    }
                } finally {
                    serviceContext.setIndexingEnabled(indexEnabled);
                }
            }
        } else {
            String fileEntryTitle = _dlFileEntryLocalService.getUniqueTitle(
                    portletDataContext.getScopeGroupId(), folderId, 0, fileEntry.getTitle(),
                    fileEntry.getExtension());

            importedFileEntry = _dlAppLocalService.addFileEntry(userId, portletDataContext.getScopeGroupId(),
                    folderId, fileEntry.getFileName(), fileEntry.getMimeType(), fileEntryTitle,
                    fileEntry.getDescription(), null, is, fileEntry.getSize(), serviceContext);
        }

        for (DLPluggableContentDataHandler dlPluggableContentDataHandler : _serviceTrackerList) {

            dlPluggableContentDataHandler.importContent(portletDataContext, fileEntryElement, fileEntry,
                    importedFileEntry);
        }

        portletDataContext.importClassedModel(fileEntry, importedFileEntry, DLFileEntry.class);

        Map<Long, Long> fileEntryIds = (Map<Long, Long>) portletDataContext
                .getNewPrimaryKeysMap(FileEntry.class);

        fileEntryIds.put(fileEntry.getFileEntryId(), importedFileEntry.getFileEntryId());
    } finally {
        try {
            is.close();
        } catch (IOException ioe) {
            _log.error(ioe, ioe);
        }
    }
}

From source file:com.liferay.document.library.internal.exportimport.data.handler.test.FileEntryStagedModelDataHandlerTest.java

License:Open Source License

@Test
public void testExportImportFileExtension() throws Exception {
    String fileName = "PDF_Test.pdf";

    ServiceContext serviceContext = ServiceContextTestUtil.getServiceContext(stagingGroup.getGroupId(),
            TestPropsValues.getUserId());

    FileEntry fileEntry = DLAppLocalServiceUtil.addFileEntry(TestPropsValues.getUserId(),
            stagingGroup.getGroupId(), DLFolderConstants.DEFAULT_PARENT_FOLDER_ID, fileName,
            ContentTypes.APPLICATION_PDF, FileUtil.getBytes(getClass(), "dependencies/" + fileName),
            serviceContext);//from  ww w .j av a2 s  .c o m

    exportImportStagedModel(fileEntry);

    FileEntry importedFileEntry = DLAppLocalServiceUtil.getFileEntryByUuidAndGroupId(fileEntry.getUuid(),
            liveGroup.getGroupId());

    Assert.assertEquals("pdf", importedFileEntry.getExtension());

    String title = RandomTestUtil.randomString() + ".awesome";

    DLAppServiceUtil.updateFileEntry(fileEntry.getFileEntryId(), StringPool.BLANK, ContentTypes.TEXT_PLAIN,
            title, StringPool.BLANK, StringPool.BLANK, false, (byte[]) null, serviceContext);

    exportImportStagedModel(fileEntry);

    importedFileEntry = DLAppLocalServiceUtil.getFileEntryByUuidAndGroupId(fileEntry.getUuid(),
            liveGroup.getGroupId());

    Assert.assertEquals("pdf", importedFileEntry.getExtension());
}

From source file:com.liferay.document.library.internal.exportimport.data.handler.test.FileEntryStagedModelDataHandlerTest.java

License:Open Source License

@Override
protected void validateImportedStagedModel(StagedModel stagedModel, StagedModel importedStagedModel)
        throws Exception {

    Assert.assertTrue(//from w  w w .j av  a 2s  .  co m
            String.valueOf(stagedModel.getCreateDate()) + StringPool.SPACE
                    + importedStagedModel.getCreateDate(),
            DateUtil.equals(stagedModel.getCreateDate(), importedStagedModel.getCreateDate()));

    Assert.assertEquals(stagedModel.getUuid(), importedStagedModel.getUuid());

    FileEntry fileEntry = (FileEntry) stagedModel;
    FileEntry importedFileEntry = (FileEntry) importedStagedModel;

    Assert.assertEquals(fileEntry.getFileName(), importedFileEntry.getFileName());
    Assert.assertEquals(fileEntry.getExtension(), importedFileEntry.getExtension());
    Assert.assertEquals(fileEntry.getMimeType(), importedFileEntry.getMimeType());
    Assert.assertEquals(fileEntry.getTitle(), importedFileEntry.getTitle());
    Assert.assertEquals(fileEntry.getDescription(), importedFileEntry.getDescription());
    Assert.assertEquals(fileEntry.getSize(), importedFileEntry.getSize());

    FileVersion latestFileVersion = fileEntry.getLatestFileVersion();
    FileVersion importedLatestFileVersion = importedFileEntry.getLatestFileVersion();

    Assert.assertEquals(latestFileVersion.getUuid(), importedLatestFileVersion.getUuid());
    Assert.assertEquals(latestFileVersion.getFileName(), importedLatestFileVersion.getFileName());
    Assert.assertEquals(latestFileVersion.getExtension(), importedLatestFileVersion.getExtension());
    Assert.assertEquals(latestFileVersion.getMimeType(), importedLatestFileVersion.getMimeType());
    Assert.assertEquals(latestFileVersion.getTitle(), importedLatestFileVersion.getTitle());
    Assert.assertEquals(latestFileVersion.getDescription(), importedLatestFileVersion.getDescription());
    Assert.assertEquals(latestFileVersion.getSize(), importedLatestFileVersion.getSize());
    Assert.assertEquals(latestFileVersion.getStatus(), importedLatestFileVersion.getStatus());
}

From source file:com.liferay.document.library.service.test.DLFileEntryExtensionTest.java

License:Open Source License

protected void testAddFileEntryBasic(String sourceFileName, String title, String extension,
        String titleWithExtension) throws Exception {

    FileEntry fileEntry = addFileEntry(sourceFileName, title);

    Assert.assertEquals("Invalid file extension", extension, fileEntry.getExtension());

    Assert.assertEquals(titleWithExtension, DLUtil.getTitleWithExtension(fileEntry));

    DLAppLocalServiceUtil.deleteFileEntry(fileEntry.getFileEntryId());
}

From source file:com.liferay.document.library.service.test.DLFileVersionUpdateTest.java

License:Open Source License

protected void testVersionUpdate(String addFileName, byte[] addBytes, String addMimeType, String updateFileName,
        byte[] updateBytes, String updateMimeType) throws PortalException {

    String description = StringPool.BLANK;
    String changeLog = StringPool.BLANK;

    ServiceContext serviceContext = ServiceContextTestUtil.getServiceContext(group.getGroupId());

    FileEntry fileEntry = DLAppServiceUtil.addFileEntry(group.getGroupId(), parentFolder.getFolderId(),
            addFileName, addMimeType, addFileName, description, changeLog, addBytes, serviceContext);

    fileEntry = DLAppServiceUtil.updateFileEntry(fileEntry.getFileEntryId(), updateFileName, updateMimeType,
            updateFileName, description, changeLog, false, updateBytes, serviceContext);

    FileVersion fileVersion = fileEntry.getFileVersion();

    Assert.assertEquals(DLFileEntryConstants.VERSION_DEFAULT, fileVersion.getVersion());
    Assert.assertEquals(updateMimeType, fileVersion.getMimeType());
    Assert.assertEquals(updateBytes.length, fileVersion.getSize());
    Assert.assertEquals(fileVersion.getExtension(), fileEntry.getExtension());
    Assert.assertEquals(fileVersion.getMimeType(), fileEntry.getMimeType());
    Assert.assertEquals(fileVersion.getSize(), fileEntry.getSize());
}

From source file:com.liferay.journal.web.util.JournalRSSUtil.java

License:Open Source License

protected Object[] getImageProperties(String url) {
    String type = null;//from w ww .  java2 s. c o  m
    long size = 0;

    Image image = getImage(url);

    if (image != null) {
        type = image.getType();
        size = image.getSize();
    } else {
        FileEntry fileEntry = getFileEntry(url);

        Set<String> imageMimeTypes = ImageProcessorUtil.getImageMimeTypes();

        if ((fileEntry != null) && imageMimeTypes.contains(fileEntry.getMimeType())) {

            type = fileEntry.getExtension();
            size = fileEntry.getSize();
        }
    }

    if (Validator.isNotNull(type)) {
        return new Object[] { type, size };
    }

    return null;
}

From source file:com.liferay.opensocial.shindig.service.LiferayMediaItemService.java

License:Open Source License

protected RestfulCollection<MediaItem> doGetMediaItems(Set<UserId> userIds, GroupId groupId, String appId,
        Set<String> fields, CollectionOptions collectionOptions, SecurityToken securityToken) throws Exception {

    List<MediaItem> mediaItems = new ArrayList<MediaItem>();

    for (UserId userId : userIds) {
        long userIdLong = GetterUtil.getLong(userId.getUserId(securityToken));

        User user = UserLocalServiceUtil.getUserById(userIdLong);

        if (!ShindigUtil.isValidUser(user)) {
            continue;
        }/* w  w  w  . jav  a  2 s .c o m*/

        List<FileEntry> fileEntries = new ArrayList<FileEntry>();

        GroupId.Type groupIdType = groupId.getType();

        if (groupIdType.equals(GroupId.Type.all) || groupIdType.equals(GroupId.Type.friends)
                || groupIdType.equals(GroupId.Type.groupId)) {

            List<User> socialUsers = UserLocalServiceUtil.getSocialUsers(user.getUserId(),
                    SocialRelationConstants.TYPE_BI_FRIEND, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);

            for (User socialUser : socialUsers) {
                Group group = socialUser.getGroup();

                List<FileEntry> friendFileEntries = DLAppServiceUtil.getGroupFileEntries(group.getGroupId(),
                        socialUser.getUserId(), collectionOptions.getFirst(), collectionOptions.getMax());

                fileEntries.addAll(friendFileEntries);
            }
        } else if (groupIdType.equals(GroupId.Type.self)) {
            Group group = user.getGroup();

            fileEntries = DLAppServiceUtil.getGroupFileEntries(group.getGroupId(), user.getUserId(),
                    collectionOptions.getFirst(), collectionOptions.getMax());
        }

        for (FileEntry fileEntry : fileEntries) {
            MediaItem.Type mediaItemType = toMediaItemType(StringPool.PERIOD.concat(fileEntry.getExtension()));

            if (mediaItemType == null) {
                continue;
            }

            MediaItem mediaItem = toMediaItem(fileEntry, fields, securityToken);

            mediaItems.add(mediaItem);
        }
    }

    return new RestfulCollection<MediaItem>(mediaItems, collectionOptions.getFirst(), mediaItems.size(),
            collectionOptions.getMax());
}

From source file:com.liferay.opensocial.shindig.service.LiferayMediaItemService.java

License:Open Source License

protected RestfulCollection<MediaItem> doGetMediaItems(UserId userId, String appId, String albumId,
        Set<String> fields, CollectionOptions collectionOptions, SecurityToken securityToken) throws Exception {

    long userIdLong = GetterUtil.getLong(userId.getUserId(securityToken));

    User user = UserLocalServiceUtil.getUserById(userIdLong);

    List<MediaItem> mediaItems = new ArrayList<MediaItem>();

    if (!ShindigUtil.isValidUser(user)) {
        return new RestfulCollection<MediaItem>(mediaItems, collectionOptions.getFirst(), mediaItems.size(),
                collectionOptions.getMax());
    }/*from w ww . j  a v a2  s  . co  m*/

    Group group = user.getGroup();

    long groupIdLong = group.getGroupId();

    long albumIdLong = GetterUtil.getLong(albumId);

    List<FileEntry> fileEntries = DLAppServiceUtil.getFileEntries(groupIdLong, albumIdLong);

    for (FileEntry fileEntry : fileEntries) {
        MediaItem.Type mediaItemType = toMediaItemType(StringPool.PERIOD.concat(fileEntry.getExtension()));

        if (mediaItemType == null) {
            continue;
        }

        MediaItem mediaItem = toMediaItem(fileEntry, fields, securityToken);

        mediaItems.add(mediaItem);
    }

    return new RestfulCollection<MediaItem>(mediaItems, collectionOptions.getFirst(), mediaItems.size(),
            collectionOptions.getMax());
}