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

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

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

Introduction

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

Prototype

public boolean isDefaultRepository();

Source Link

Usage

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

License:Open Source License

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

    Element fileEntryElement = portletDataContext.getExportDataElement(fileEntry);

    String fileEntryPath = ExportImportPathUtil.getModelPath(fileEntry);

    if (!fileEntry.isDefaultRepository()) {
        Repository repository = _repositoryLocalService.getRepository(fileEntry.getRepositoryId());

        StagedModelDataHandlerUtil.exportReferenceStagedModel(portletDataContext, fileEntry, repository,
                PortletDataContext.REFERENCE_TYPE_STRONG);

        portletDataContext.addClassedModel(fileEntryElement, fileEntryPath, fileEntry);

        long portletRepositoryClassNameId = _portal.getClassNameId(PortletRepository.class.getName());

        if (repository.getClassNameId() != portletRepositoryClassNameId) {
            return;
        }//from  w  w w. ja  va  2  s.co m
    }

    if (fileEntry.getFolderId() != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {

        StagedModelDataHandlerUtil.exportReferenceStagedModel(portletDataContext, fileEntry,
                fileEntry.getFolder(), PortletDataContext.REFERENCE_TYPE_PARENT);
    }

    LiferayFileEntry liferayFileEntry = (LiferayFileEntry) fileEntry;

    liferayFileEntry.setCachedFileVersion(fileEntry.getFileVersion());

    if (!portletDataContext.isPerformDirectBinaryImport()) {
        InputStream is = null;

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

        if (is == null) {
            fileEntryElement.detach();

            return;
        }

        try {
            String binPath = ExportImportPathUtil.getModelPath(fileEntry, fileEntry.getVersion());

            portletDataContext.addZipEntry(binPath, is);

            fileEntryElement.addAttribute("bin-path", binPath);
        } finally {
            try {
                is.close();
            } catch (IOException ioe) {
                _log.error(ioe, ioe);
            }
        }
    }

    for (DLPluggableContentDataHandler dlPluggableContentDataHandler : _serviceTrackerList) {

        dlPluggableContentDataHandler.exportContent(portletDataContext, fileEntryElement, fileEntry);
    }

    exportMetaData(portletDataContext, fileEntryElement, fileEntry);

    portletDataContext.addClassedModel(fileEntryElement, fileEntryPath, liferayFileEntry, DLFileEntry.class);
}

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;/*from  ww w.j  av  a2 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.portlet.documentlibrary.lar.DLPortletDataHandlerImpl.java

License:Open Source License

public static void exportFileEntry(PortletDataContext portletDataContext, Element fileEntryTypesElement,
        Element foldersElement, Element fileEntriesElement, Element fileRanksElement,
        Element repositoriesElement, Element repositoryEntriesElement, FileEntry fileEntry,
        boolean checkDateRange) throws Exception {

    if (checkDateRange && !portletDataContext.isWithinDateRange(fileEntry.getModifiedDate())) {

        return;/*from www.  ja va 2  s  .c  o  m*/
    }

    if (!fileEntry.isDefaultRepository()) {
        Repository repository = RepositoryUtil.findByPrimaryKey(fileEntry.getRepositoryId());

        exportRepository(portletDataContext, repositoriesElement, repositoryEntriesElement, repository);

        return;
    }

    FileVersion fileVersion = fileEntry.getFileVersion();

    if (fileVersion.getStatus() != WorkflowConstants.STATUS_APPROVED) {
        return;
    }

    String path = getFileEntryPath(portletDataContext, fileEntry);

    if (!portletDataContext.isPathNotProcessed(path)) {
        return;
    }

    Element fileEntryElement = fileEntriesElement.addElement("file-entry");

    if (foldersElement != null) {
        exportParentFolder(portletDataContext, fileEntryTypesElement, foldersElement, repositoriesElement,
                repositoryEntriesElement, fileEntry.getFolderId());
    }

    if (!portletDataContext.isPerformDirectBinaryImport()) {
        InputStream is = null;

        try {
            is = FileEntryUtil.getContentStream(fileEntry);
        } catch (NoSuchFileException nsfe) {
        }

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

            fileEntryElement.detach();

            return;
        }

        try {
            String binPath = getFileEntryBinPath(portletDataContext, fileEntry);

            portletDataContext.addZipEntry(binPath, is);

            fileEntryElement.addAttribute("bin-path", binPath);
        } finally {
            try {
                is.close();
            } catch (IOException ioe) {
                _log.error(ioe, ioe);
            }
        }
    }

    if (portletDataContext.getBooleanParameter(_NAMESPACE, "ranks")) {
        List<DLFileRank> fileRanks = DLFileRankUtil.findByFileEntryId(fileEntry.getFileEntryId());

        for (DLFileRank fileRank : fileRanks) {
            exportFileRank(portletDataContext, fileRanksElement, fileRank);
        }
    }

    if (portletDataContext.getBooleanParameter(_NAMESPACE, "previews-and-thumbnails")) {

        DLProcessorRegistryUtil.exportGeneratedFiles(portletDataContext, fileEntry, fileEntryElement);
    }

    exportMetaData(portletDataContext, fileEntryTypesElement, fileEntryElement, fileEntry);

    portletDataContext.addClassedModel(fileEntryElement, path, fileEntry, _NAMESPACE);
}

From source file:com.liferay.portlet.journal.lar.JournalPortletDataHandlerImpl.java

License:Open Source License

protected static String exportDLFileEntries(PortletDataContext portletDataContext,
        Element dlFileEntryTypesElement, Element dlFoldersElement, Element dlFileEntriesElement,
        Element dlFileRanksElement, Element dlRepositoriesElement, Element dlRepositoryEntriesElement,
        Element entityElement, String content, boolean checkDateRange) throws Exception {

    Group group = GroupLocalServiceUtil.getGroup(portletDataContext.getGroupId());

    if (group.isStagingGroup()) {
        group = group.getLiveGroup();/*from   w  w  w. j a v a2 s.  com*/
    }

    if (group.isStaged() && !group.isStagedRemotely() && !group.isStagedPortlet(PortletKeys.DOCUMENT_LIBRARY)) {

        return content;
    }

    StringBuilder sb = new StringBuilder(content);

    int beginPos = content.length();
    int currentLocation = -1;

    while (true) {
        currentLocation = content.lastIndexOf("/c/document_library/get_file?", beginPos);

        if (currentLocation == -1) {
            currentLocation = content.lastIndexOf("/documents/", beginPos);
        }

        if (currentLocation == -1) {
            return sb.toString();
        }

        beginPos = currentLocation;

        int endPos1 = content.indexOf(CharPool.APOSTROPHE, beginPos);
        int endPos2 = content.indexOf(CharPool.CLOSE_BRACKET, beginPos);
        int endPos3 = content.indexOf(CharPool.CLOSE_CURLY_BRACE, beginPos);
        int endPos4 = content.indexOf(CharPool.CLOSE_PARENTHESIS, beginPos);
        int endPos5 = content.indexOf(CharPool.LESS_THAN, beginPos);
        int endPos6 = content.indexOf(CharPool.QUESTION, beginPos);
        int endPos7 = content.indexOf(CharPool.QUOTE, beginPos);
        int endPos8 = content.indexOf(CharPool.SPACE, beginPos);

        int endPos = endPos1;

        if ((endPos == -1) || ((endPos2 != -1) && (endPos2 < endPos))) {
            endPos = endPos2;
        }

        if ((endPos == -1) || ((endPos3 != -1) && (endPos3 < endPos))) {
            endPos = endPos3;
        }

        if ((endPos == -1) || ((endPos4 != -1) && (endPos4 < endPos))) {
            endPos = endPos4;
        }

        if ((endPos == -1) || ((endPos5 != -1) && (endPos5 < endPos))) {
            endPos = endPos5;
        }

        if ((endPos == -1) || ((endPos6 != -1) && (endPos6 < endPos))) {
            endPos = endPos6;
        }

        if ((endPos == -1) || ((endPos7 != -1) && (endPos7 < endPos))) {
            endPos = endPos7;
        }

        if ((endPos == -1) || ((endPos8 != -1) && (endPos8 < endPos))) {
            endPos = endPos8;
        }

        if ((beginPos == -1) || (endPos == -1)) {
            break;
        }

        try {
            String oldParameters = content.substring(beginPos, endPos);

            while (oldParameters.contains(StringPool.AMPERSAND_ENCODED)) {
                oldParameters = oldParameters.replace(StringPool.AMPERSAND_ENCODED, StringPool.AMPERSAND);
            }

            Map<String, String[]> map = new HashMap<String, String[]>();

            if (oldParameters.startsWith("/documents/")) {
                String[] pathArray = oldParameters.split(StringPool.SLASH);

                map.put("groupId", new String[] { pathArray[2] });

                if (pathArray.length == 4) {
                    map.put("uuid", new String[] { pathArray[3] });
                } else if (pathArray.length == 5) {
                    map.put("folderId", new String[] { pathArray[3] });

                    String name = HttpUtil.decodeURL(pathArray[4]);

                    int pos = name.indexOf(StringPool.QUESTION);

                    if (pos != -1) {
                        name = name.substring(0, pos);
                    }

                    map.put("name", new String[] { name });
                } else if (pathArray.length > 5) {
                    String uuid = pathArray[5];

                    int pos = uuid.indexOf(StringPool.QUESTION);

                    if (pos != -1) {
                        uuid = uuid.substring(0, pos);
                    }

                    map.put("uuid", new String[] { uuid });
                }
            } else {
                oldParameters = oldParameters.substring(oldParameters.indexOf(CharPool.QUESTION) + 1);

                map = HttpUtil.parameterMapFromString(oldParameters);
            }

            FileEntry fileEntry = null;

            String uuid = MapUtil.getString(map, "uuid");

            if (Validator.isNotNull(uuid)) {
                String groupIdString = MapUtil.getString(map, "groupId");

                long groupId = GetterUtil.getLong(groupIdString);

                if (groupIdString.equals("@group_id@")) {
                    groupId = portletDataContext.getScopeGroupId();
                }

                fileEntry = DLAppLocalServiceUtil.getFileEntryByUuidAndGroupId(uuid, groupId);
            } else {
                String folderIdString = MapUtil.getString(map, "folderId");

                if (Validator.isNotNull(folderIdString)) {
                    long folderId = GetterUtil.getLong(folderIdString);
                    String name = MapUtil.getString(map, "name");

                    String groupIdString = MapUtil.getString(map, "groupId");

                    long groupId = GetterUtil.getLong(groupIdString);

                    if (groupIdString.equals("@group_id@")) {
                        groupId = portletDataContext.getScopeGroupId();
                    }

                    fileEntry = DLAppLocalServiceUtil.getFileEntry(groupId, folderId, name);
                }
            }

            if (fileEntry == null) {
                beginPos--;

                continue;
            }

            DLPortletDataHandlerImpl.exportFileEntry(portletDataContext, dlFileEntryTypesElement,
                    dlFoldersElement, dlFileEntriesElement, dlFileRanksElement, dlRepositoriesElement,
                    dlRepositoryEntriesElement, fileEntry, checkDateRange);

            Element dlReferenceElement = entityElement.addElement("dl-reference");

            dlReferenceElement.addAttribute("default-repository",
                    String.valueOf(fileEntry.isDefaultRepository()));

            String path = null;

            if (fileEntry.isDefaultRepository()) {
                path = DLPortletDataHandlerImpl.getFileEntryPath(portletDataContext, fileEntry);

            } else {
                path = DLPortletDataHandlerImpl.getRepositoryEntryPath(portletDataContext,
                        fileEntry.getFileEntryId());
            }

            dlReferenceElement.addAttribute("path", path);

            String dlReference = "[$dl-reference=" + path + "$]";

            sb.replace(beginPos, endPos, dlReference);
        } catch (Exception e) {
            if (_log.isDebugEnabled()) {
                _log.debug(e, e);
            } else if (_log.isWarnEnabled()) {
                _log.warn(e.getMessage());
            }
        }

        beginPos--;
    }

    return sb.toString();
}