Example usage for org.apache.commons.configuration PropertiesConfiguration containsKey

List of usage examples for org.apache.commons.configuration PropertiesConfiguration containsKey

  1. HOME
  2. Java
  3. org.apache.commons
  4. org.apache.commons.configuration.*
  5. PropertiesConfiguration
  6. containsKey

Introduction

In this page you can find the example usage for org.apache.commons.configuration PropertiesConfiguration containsKey.

Prototype

public boolean containsKey(String key)

Source Link

Usage

From source file:org.xwiki.contrib.confluence.filter.internal.input.ConfluenceInputFilterStream.java

private void readAttachment(long pageId, PropertiesConfiguration attachmentProperties, Object filter,
        ConfluenceFilter proxyFilter) throws FilterException {
    String contentStatus = attachmentProperties.getString(ConfluenceXMLPackage.KEY_ATTACHMENT_CONTENTSTATUS,
            null);/*from   w  w w  . ja v a  2 s.  c om*/
    if (StringUtils.equals(contentStatus, "deleted")) {
        // The actual deleted attachment is not in the exported package so we can't really do anything with it
        return;
    }

    long attachmentId = attachmentProperties.getInt("id");

    String attachmentName = this.confluencePackage.getAttachmentName(attachmentProperties);

    long attachmentSize;
    String mediaType = null;
    if (attachmentProperties.containsKey(ConfluenceXMLPackage.KEY_ATTACHMENT_CONTENTPROPERTIES)) {
        PropertiesConfiguration attachmentContentProperties = getContentProperties(attachmentProperties,
                ConfluenceXMLPackage.KEY_ATTACHMENT_CONTENTPROPERTIES);

        attachmentSize = attachmentContentProperties
                .getLong(ConfluenceXMLPackage.KEY_ATTACHMENT_CONTENT_FILESIZE);
        if (attachmentProperties.containsKey(ConfluenceXMLPackage.KEY_ATTACHMENT_CONTENTTYPE)) {
            mediaType = attachmentContentProperties
                    .getString(ConfluenceXMLPackage.KEY_ATTACHMENT_CONTENT_MEDIA_TYPE);
        }
    } else {
        attachmentSize = attachmentProperties.getLong(ConfluenceXMLPackage.KEY_ATTACHMENT_CONTENT_SIZE);
        if (attachmentProperties.containsKey(ConfluenceXMLPackage.KEY_ATTACHMENT_CONTENTTYPE)) {
            mediaType = attachmentProperties.getString(ConfluenceXMLPackage.KEY_ATTACHMENT_CONTENTTYPE);
        }
    }

    Long version = this.confluencePackage.getAttachementVersion(attachmentProperties);

    long originalRevisionId = this.confluencePackage.getAttachmentOriginalVersionId(attachmentProperties,
            attachmentId);
    File contentFile;
    try {
        contentFile = this.confluencePackage.getAttachmentFile(pageId, originalRevisionId, version);
    } catch (FileNotFoundException e) {
        throw new FilterException(
                String.format("Failed to find file corresponding to version [%s] attachment [%s] in page [%s]",
                        version, attachmentName, pageId),
                e);
    }

    FilterEventParameters attachmentParameters = new FilterEventParameters();
    if (mediaType != null) {
        attachmentParameters.put(WikiAttachmentFilter.PARAMETER_CONTENT_TYPE, mediaType);
    }
    if (attachmentProperties.containsKey(ConfluenceXMLPackage.KEY_ATTACHMENT_CREATION_AUTHOR)) {
        attachmentParameters.put(WikiAttachmentFilter.PARAMETER_CREATION_AUTHOR,
                attachmentProperties.getString(ConfluenceXMLPackage.KEY_ATTACHMENT_CREATION_AUTHOR));
    }
    if (attachmentProperties.containsKey(ConfluenceXMLPackage.KEY_ATTACHMENT_CREATION_DATE)) {
        try {
            attachmentParameters.put(WikiAttachmentFilter.PARAMETER_CREATION_DATE, this.confluencePackage
                    .getDate(attachmentProperties, ConfluenceXMLPackage.KEY_ATTACHMENT_CREATION_DATE));
        } catch (ParseException e) {
            if (this.properties.isVerbose()) {
                this.logger.error("Failed to parse date", e);
            }
        }
    }

    attachmentParameters.put(WikiAttachmentFilter.PARAMETER_REVISION, String.valueOf(version));
    if (attachmentProperties.containsKey(ConfluenceXMLPackage.KEY_ATTACHMENT_REVISION_AUTHOR)) {
        attachmentParameters.put(WikiAttachmentFilter.PARAMETER_REVISION_AUTHOR,
                attachmentProperties.getString(ConfluenceXMLPackage.KEY_ATTACHMENT_REVISION_AUTHOR));
    }
    if (attachmentProperties.containsKey(ConfluenceXMLPackage.KEY_ATTACHMENT_REVISION_DATE)) {
        try {
            attachmentParameters.put(WikiAttachmentFilter.PARAMETER_REVISION_DATE, this.confluencePackage
                    .getDate(attachmentProperties, ConfluenceXMLPackage.KEY_ATTACHMENT_REVISION_DATE));
        } catch (ParseException e) {
            if (this.properties.isVerbose()) {
                this.logger.error("Failed to parse date", e);
            }
        }
    }
    if (attachmentProperties.containsKey(ConfluenceXMLPackage.KEY_ATTACHMENT_REVISION_COMMENT)) {
        attachmentParameters.put(WikiAttachmentFilter.PARAMETER_REVISION_COMMENT,
                attachmentProperties.getString(ConfluenceXMLPackage.KEY_ATTACHMENT_REVISION_COMMENT));
    }

    // WikiAttachment

    try {
        FileInputStream fis = new FileInputStream(contentFile);

        try {
            proxyFilter.onWikiAttachment(attachmentName, fis, attachmentSize, attachmentParameters);
        } finally {
            fis.close();
        }
    } catch (Exception e) {
        throw new FilterException("Failed to read attachment", e);
    }
}

From source file:org.xwiki.filter.confluence.xml.internal.ConfluenceXMLPackage.java

public EntityReference getReferenceFromId(PropertiesConfiguration currentProperties, String key)
        throws ConfigurationException {
    if (currentProperties.containsKey(key)) {
        int pageId = currentProperties.getInt(key);

        PropertiesConfiguration pageProperties = getPageProperties(pageId);

        int spaceId = pageProperties.getInt(KEY_PAGE_SPACE);
        int currentSpaceId = currentProperties.getInt(KEY_PAGE_SPACE);

        EntityReference spaceReference;
        if (spaceId != currentSpaceId) {
            spaceReference = new EntityReference(getSpaceName(currentSpaceId), EntityType.SPACE);
        } else {/*from   w  w w .j  a  v a 2  s. com*/
            spaceReference = null;
        }

        return new EntityReference(pageProperties.getString(KEY_PAGE_TITLE), EntityType.DOCUMENT,
                spaceReference);
    }

    return null;
}

From source file:org.xwiki.filter.confluence.xml.internal.ConfluenceXMLPackage.java

private void readAttachmentObject(XMLStreamReader xmlReader)
        throws XMLStreamException, FilterException, ConfigurationException, IOException {
    PropertiesConfiguration properties = newProperties();

    int attachmentId = readObjectProperties(xmlReader, properties);

    if (properties.containsKey(KEY_ATTACHMENT_CONTENT)) {
        int pageId = properties.getInt(KEY_ATTACHMENT_CONTENT);

        // Save attachment
        saveAttachmentProperties(properties, pageId, attachmentId);
    }//from   w ww  . j a  va 2s.  c  om
}

From source file:org.xwiki.filter.confluence.xml.internal.ConfluenceXMLPackage.java

private void readSpacePermissionObject(XMLStreamReader xmlReader)
        throws XMLStreamException, ConfigurationException, IOException, FilterException {
    PropertiesConfiguration properties = newProperties();

    int permissionId = readObjectProperties(xmlReader, properties);

    if (properties.containsKey("space")) {
        int spaceId = properties.getInt("space");

        // Save attachment
        saveSpacePermissionsProperties(properties, spaceId, permissionId);
    }/*from   w  w  w  .  j av a 2s .c  o  m*/
}

From source file:org.xwiki.filter.confluence.xml.internal.ConfluenceXMLPackage.java

private void readBodyContentObject(XMLStreamReader xmlReader)
        throws XMLStreamException, ConfigurationException, FilterException, IOException {
    PropertiesConfiguration properties = newProperties();
    properties.setDelimiterParsingDisabled(true);

    readObjectProperties(xmlReader, properties);

    if (properties.containsKey("content")) {
        int pageId = properties.getInt("content");

        savePageProperties(properties, pageId);
    }/* w  w  w .  jav a2s.  com*/
}

From source file:org.xwiki.filter.confluence.xml.internal.input.ConfluenceInputFilterStream.java

@Override
protected void read(Object filter, ConfluenceFilter proxyFilter) throws FilterException {
    // Prepare package
    try {/*from  w  w  w. j  a  v a 2  s. co m*/
        this.confluencePackage = new ConfluenceXMLPackage(this.properties.getSource());
    } catch (Exception e) {
        throw new FilterException("Failed to read package", e);
    }

    // Generate users events
    for (int userInt : this.confluencePackage.getUsers()) {
        PropertiesConfiguration userProperties;
        try {
            userProperties = this.confluencePackage.getUserProperties(userInt);
        } catch (ConfigurationException e) {
            throw new FilterException("Failed to get user properties", e);
        }

        String userId = userProperties.getString(ConfluenceXMLPackage.KEY_USER_NAME, String.valueOf(userInt));
        if (this.properties.isConvertToXWiki() && userId.equals("admin")) {
            userId = "Admin";
        }

        FilterEventParameters userParameters = new FilterEventParameters();

        userParameters.put(UserFilter.PARAMETER_FIRSTNAME,
                userProperties.getString(ConfluenceXMLPackage.KEY_USER_FIRSTNAME));
        userParameters.put(UserFilter.PARAMETER_LASTNAME,
                userProperties.getString(ConfluenceXMLPackage.KEY_USER_LASTNAME));
        userParameters.put(UserFilter.PARAMETER_EMAIL,
                userProperties.getString(ConfluenceXMLPackage.KEY_USER_EMAIL));
        userParameters.put(UserFilter.PARAMETER_ACTIVE,
                userProperties.getBoolean(ConfluenceXMLPackage.KEY_USER_ACTIVE));

        try {
            userParameters.put(UserFilter.PARAMETER_REVISION_DATE, this.confluencePackage
                    .getDate(userProperties, ConfluenceXMLPackage.KEY_USER_REVISION_DATE));
            userParameters.put(UserFilter.PARAMETER_CREATION_DATE, this.confluencePackage
                    .getDate(userProperties, ConfluenceXMLPackage.KEY_USER_CREATION_DATE));
        } catch (ParseException e) {
            if (this.properties.isVerbose()) {
                this.logger.error("Failed to parse date", e);
            }
        }

        // TODO: no idea how to import/convert the password, probably salted with the Confluence instance id

        // > User
        proxyFilter.beginUser(userId, userParameters);

        // < User
        proxyFilter.endUser(userId, userParameters);
    }

    // Generate users events
    for (int groupInt : this.confluencePackage.getGroups()) {
        PropertiesConfiguration groupProperties;
        try {
            groupProperties = this.confluencePackage.getGroupProperties(groupInt);
        } catch (ConfigurationException e) {
            throw new FilterException("Failed to get group properties", e);
        }

        String groupId = groupProperties.getString(ConfluenceXMLPackage.KEY_GROUP_NAME,
                String.valueOf(groupInt));
        if (this.properties.isConvertToXWiki()) {
            if (groupId.equals("confluence-administrators")) {
                groupId = "XWikiAdminGroup";
            } else if (groupId.equals("confluence-users")) {
                groupId = "XWikiAllGroup";
            }
        }

        FilterEventParameters groupParameters = new FilterEventParameters();

        try {
            groupParameters.put(GroupFilter.PARAMETER_REVISION_DATE, this.confluencePackage
                    .getDate(groupProperties, ConfluenceXMLPackage.KEY_GROUP_REVISION_DATE));
            groupParameters.put(GroupFilter.PARAMETER_CREATION_DATE, this.confluencePackage
                    .getDate(groupProperties, ConfluenceXMLPackage.KEY_GROUP_CREATION_DATE));
        } catch (ParseException e) {
            if (this.properties.isVerbose()) {
                this.logger.error("Failed to parse date", e);
            }
        }

        // > Group
        proxyFilter.beginGroup(groupId, groupParameters);

        // Members users
        if (groupProperties.containsKey(ConfluenceXMLPackage.KEY_GROUP_MEMBERUSERS)) {
            List<Integer> users = this.confluencePackage.getIntegertList(groupProperties,
                    ConfluenceXMLPackage.KEY_GROUP_MEMBERUSERS);
            for (Integer memberInt : users) {
                FilterEventParameters memberParameters = new FilterEventParameters();

                try {
                    String memberId = this.confluencePackage.getUserProperties(memberInt)
                            .getString(ConfluenceXMLPackage.KEY_USER_NAME, String.valueOf(memberInt));

                    if (this.properties.isConvertToXWiki() && memberId.equals("admin")) {
                        memberId = "Admin";
                    }

                    proxyFilter.onGroupMemberGroup(memberId, memberParameters);
                } catch (ConfigurationException e) {
                    this.logger.error("Failed to get user properties", e);
                }
            }
        }

        // Members groups
        if (groupProperties.containsKey(ConfluenceXMLPackage.KEY_GROUP_MEMBERGROUPS)) {
            List<Integer> groups = this.confluencePackage.getIntegertList(groupProperties,
                    ConfluenceXMLPackage.KEY_GROUP_MEMBERGROUPS);
            for (Integer memberInt : groups) {
                FilterEventParameters memberParameters = new FilterEventParameters();

                try {
                    String memberId = this.confluencePackage.getGroupProperties(memberInt)
                            .getString(ConfluenceXMLPackage.KEY_GROUP_NAME, String.valueOf(memberInt));

                    if (this.properties.isConvertToXWiki()) {
                        if (memberId.equals("confluence-administrators")) {
                            memberId = "XWikiAdminGroup";
                        } else if (memberId.equals("confluence-users")) {
                            memberId = "XWikiAllGroup";
                        }
                    }

                    proxyFilter.onGroupMemberGroup(memberId, memberParameters);
                } catch (ConfigurationException e) {
                    this.logger.error("Failed to get group properties", e);
                }
            }
        }

        // < Group
        proxyFilter.endGroup(groupId, groupParameters);
    }

    // Generate documents events
    for (Map.Entry<Integer, List<Integer>> entry : this.confluencePackage.getPages().entrySet()) {
        int spaceId = entry.getKey();

        PropertiesConfiguration spaceProperties;
        try {
            spaceProperties = this.confluencePackage.getSpaceProperties(spaceId);
        } catch (ConfigurationException e) {
            throw new FilterException("Failed to get space properties", e);
        }

        String spaceName = spaceProperties.getString(ConfluenceXMLPackage.KEY_SPACE_NAME);
        FilterEventParameters spaceParameters = new FilterEventParameters();

        // > WikiSpace
        proxyFilter.beginWikiSpace(spaceName, spaceParameters);

        // Main page
        if (spaceProperties.containsKey(ConfluenceXMLPackage.KEY_SPACE_DESCRIPTION)) {
            readPage(spaceProperties.getInt(ConfluenceXMLPackage.KEY_SPACE_DESCRIPTION), filter, proxyFilter);
        }

        // Other pages
        for (int pageId : entry.getValue()) {
            readPage(pageId, filter, proxyFilter);
        }

        // < WikiSpace
        proxyFilter.endWikiSpace(spaceName, spaceParameters);
    }

    // Cleanup

    try {
        this.confluencePackage.close();
    } catch (IOException e) {
        throw new FilterException("Failed to close package", e);
    }
}

From source file:org.xwiki.filter.confluence.xml.internal.input.ConfluenceInputFilterStream.java

private void readPage(int pageId, Object filter, ConfluenceFilter proxyFilter) throws FilterException {
    PropertiesConfiguration pageProperties = getPageProperties(pageId);

    String documentName;//from w  ww.  j av  a 2s  .  co m
    if (pageProperties.containsKey(ConfluenceXMLPackage.KEY_PAGE_HOMEPAGE)) {
        documentName = this.properties.getSpacePageName();
    } else {
        documentName = pageProperties.getString(ConfluenceXMLPackage.KEY_PAGE_TITLE);
    }

    FilterEventParameters documentParameters = new FilterEventParameters();
    if (this.properties.getDefaultLocale() != null) {
        documentParameters.put(WikiDocumentFilter.PARAMETER_LOCALE, this.properties.getDefaultLocale());
    }

    // > WikiDocument
    proxyFilter.beginWikiDocument(documentName, documentParameters);

    Locale locale = Locale.ROOT;

    FilterEventParameters documentLocaleParameters = new FilterEventParameters();
    if (pageProperties.containsKey(ConfluenceXMLPackage.KEY_PAGE_CREATION_AUTHOR)) {
        documentLocaleParameters.put(WikiDocumentFilter.PARAMETER_CREATION_AUTHOR,
                pageProperties.getString(ConfluenceXMLPackage.KEY_PAGE_CREATION_AUTHOR));
    }
    if (pageProperties.containsKey(ConfluenceXMLPackage.KEY_PAGE_CREATION_DATE)) {
        try {
            documentLocaleParameters.put(WikiDocumentFilter.PARAMETER_CREATION_DATE, this.confluencePackage
                    .getDate(pageProperties, ConfluenceXMLPackage.KEY_PAGE_CREATION_DATE));
        } catch (ParseException e) {
            if (this.properties.isVerbose()) {
                this.logger.error("Failed to parse date", e);
            }
        }
    }
    if (pageProperties.containsKey(ConfluenceXMLPackage.KEY_PAGE_REVISION)) {
        documentLocaleParameters.put(WikiDocumentFilter.PARAMETER_LASTREVISION,
                pageProperties.getString(ConfluenceXMLPackage.KEY_PAGE_REVISION));
    }

    // > WikiDocumentLocale
    proxyFilter.beginWikiDocumentLocale(locale, documentLocaleParameters);

    // Revisions
    if (pageProperties.containsKey(ConfluenceXMLPackage.KEY_PAGE_REVISIONS)) {
        List<Integer> revisions = this.confluencePackage.getIntegertList(pageProperties,
                ConfluenceXMLPackage.KEY_PAGE_REVISIONS);
        for (Integer revisionId : revisions) {
            readPageRevision(revisionId, filter, proxyFilter);
        }
    }

    // Current version
    readPageRevision(pageId, filter, proxyFilter);

    // < WikiDocumentLocale
    proxyFilter.endWikiDocumentLocale(locale, documentLocaleParameters);

    // < WikiDocument
    proxyFilter.endWikiDocument(documentName, documentParameters);
}

From source file:org.xwiki.filter.confluence.xml.internal.input.ConfluenceInputFilterStream.java

private void readPageRevision(int pageId, PropertiesConfiguration pageProperties, Object filter,
        ConfluenceFilter proxyFilter) throws FilterException {
    String revision = pageProperties.getString(ConfluenceXMLPackage.KEY_PAGE_REVISION);

    FilterEventParameters documentRevisionParameters = new FilterEventParameters();
    if (pageProperties.containsKey(ConfluenceXMLPackage.KEY_PAGE_PARENT)) {
        try {/* ww  w .  j a  va 2s.  c o  m*/
            documentRevisionParameters.put(WikiDocumentFilter.PARAMETER_PARENT, this.confluencePackage
                    .getReferenceFromId(pageProperties, ConfluenceXMLPackage.KEY_PAGE_PARENT));
        } catch (ConfigurationException e) {
            if (this.properties.isVerbose()) {
                this.logger.error("Failed to parse parent", e);
            }
        }
    }
    if (pageProperties.containsKey(ConfluenceXMLPackage.KEY_PAGE_REVISION_AUTHOR)) {
        documentRevisionParameters.put(WikiDocumentFilter.PARAMETER_REVISION_AUTHOR,
                pageProperties.getString(ConfluenceXMLPackage.KEY_PAGE_REVISION_AUTHOR));
    }
    if (pageProperties.containsKey(ConfluenceXMLPackage.KEY_PAGE_REVISION_DATE)) {
        try {
            documentRevisionParameters.put(WikiDocumentFilter.PARAMETER_REVISION_DATE, this.confluencePackage
                    .getDate(pageProperties, ConfluenceXMLPackage.KEY_PAGE_REVISION_DATE));
        } catch (ParseException e) {
            if (this.properties.isVerbose()) {
                this.logger.error("Failed to parse date", e);
            }
        }
    }
    if (pageProperties.containsKey(ConfluenceXMLPackage.KEY_PAGE_REVISION_COMMENT)) {
        documentRevisionParameters.put(WikiDocumentFilter.PARAMETER_REVISION_COMMENT,
                pageProperties.getString(ConfluenceXMLPackage.KEY_PAGE_REVISION_COMMENT));
    }
    documentRevisionParameters.put(WikiDocumentFilter.PARAMETER_TITLE,
            pageProperties.getString(ConfluenceXMLPackage.KEY_PAGE_TITLE));

    String bodyContent = null;
    Syntax bodySyntax = null;
    int bodyType = -1;

    if (pageProperties.containsKey(ConfluenceXMLPackage.KEY_PAGE_BODY)
            && pageProperties.containsKey(ConfluenceXMLPackage.KEY_PAGE_BODY_TYPE)) {
        bodyContent = pageProperties.getString(ConfluenceXMLPackage.KEY_PAGE_BODY);
        bodyType = pageProperties.getInt(ConfluenceXMLPackage.KEY_PAGE_BODY_TYPE);

        switch (bodyType) {
        case 0:
            bodySyntax = Syntax.CONFLUENCE_1_0;
            break;
        case 2:
            bodySyntax = Syntax.CONFLUENCEXHTML_1_0;
            break;
        default:
            if (this.properties.isVerbose()) {
                this.logger.error("Unknown body type [{}]", bodyType);
            }
            break;
        }
    }

    // If target filter does not support rendering events, pass the content as it is
    if (!(filter instanceof Listener) && bodyContent != null && bodySyntax != null) {
        documentRevisionParameters.put(WikiDocumentFilter.PARAMETER_CONTENT, bodyContent);
        documentRevisionParameters.put(WikiDocumentFilter.PARAMETER_SYNTAX, bodySyntax);
    }

    // > WikiDocumentRevision
    proxyFilter.beginWikiDocumentRevision(revision, documentRevisionParameters);

    // Content
    if (filter instanceof Listener && bodyContent != null && bodySyntax != null) {
        try {
            switch (bodyType) {
            case 0:
                this.confluenceWIKIParser.parse(new StringReader(bodyContent), proxyFilter);
                break;
            case 2:
                this.confluenceXHTMLParser.parse(new StringReader(bodyContent), proxyFilter);
                break;
            default:
                break;
            }
        } catch (org.xwiki.rendering.parser.ParseException e) {
            throw new FilterException(String.format("Failed parser content [%s]", bodyContent), e);
        }
    }

    // Attachments
    Map<String, PropertiesConfiguration> pageAttachments = new LinkedHashMap<String, PropertiesConfiguration>();
    for (int attachmentId : this.confluencePackage.getAttachments(pageId)) {
        PropertiesConfiguration attachmentProperties;
        try {
            attachmentProperties = this.confluencePackage.getAttachmentProperties(pageId, attachmentId);
        } catch (ConfigurationException e) {
            throw new FilterException("Failed to get attachment properties", e);
        }

        String attachmentName = attachmentProperties.getString(ConfluenceXMLPackage.KEY_ATTACHMENT_NAME);

        PropertiesConfiguration currentAttachmentProperties = pageAttachments.get(attachmentName);
        if (currentAttachmentProperties != null) {
            int version = attachmentProperties.getInt(ConfluenceXMLPackage.KEY_ATTACHMENT_REVISION);
            int currentVersion = currentAttachmentProperties
                    .getInt(ConfluenceXMLPackage.KEY_ATTACHMENT_REVISION);

            if (version > currentVersion) {
                pageAttachments.put(attachmentName, attachmentProperties);
            }
        } else {
            pageAttachments.put(attachmentName, attachmentProperties);
        }
    }

    for (PropertiesConfiguration attachmentProperties : pageAttachments.values()) {
        readAttachment(pageId, attachmentProperties, filter, proxyFilter);
    }

    // < WikiDocumentRevision
    proxyFilter.endWikiDocumentRevision(revision, documentRevisionParameters);
}

From source file:org.xwiki.filter.confluence.xml.internal.input.ConfluenceInputFilterStream.java

private void readAttachment(int pageId, PropertiesConfiguration attachmentProperties, Object filter,
        ConfluenceFilter proxyFilter) throws FilterException {
    int attachmentId = attachmentProperties.getInt("id");

    String attachmentName = attachmentProperties.getString(ConfluenceXMLPackage.KEY_ATTACHMENT_NAME);
    long attachmentSize = attachmentProperties.getLong(ConfluenceXMLPackage.KEY_ATTACHMENT_CONTENT_SIZE);

    int version = attachmentProperties.getInt(ConfluenceXMLPackage.KEY_ATTACHMENT_REVISION);
    int originalRevisionId = attachmentProperties.getInt(ConfluenceXMLPackage.KEY_ATTACHMENT_ORIGINAL_REVISION,
            attachmentId);//from  ww  w.ja v  a 2s. co  m
    File contentFile = this.confluencePackage.getAttachmentFile(pageId, originalRevisionId, version);

    FilterEventParameters attachmentParameters = new FilterEventParameters();
    if (attachmentProperties.containsKey(ConfluenceXMLPackage.KEY_ATTACHMENT_CONTENT_TYPE)) {
        attachmentParameters.put(WikiAttachmentFilter.PARAMETER_CONTENT_TYPE,
                attachmentProperties.getString(ConfluenceXMLPackage.KEY_ATTACHMENT_CONTENT_TYPE));
    }
    if (attachmentProperties.containsKey(ConfluenceXMLPackage.KEY_ATTACHMENT_CREATION_AUTHOR)) {
        attachmentParameters.put(WikiAttachmentFilter.PARAMETER_CREATION_AUTHOR,
                attachmentProperties.getString(ConfluenceXMLPackage.KEY_ATTACHMENT_CREATION_AUTHOR));
    }
    if (attachmentProperties.containsKey(ConfluenceXMLPackage.KEY_ATTACHMENT_CREATION_DATE)) {
        try {
            attachmentParameters.put(WikiAttachmentFilter.PARAMETER_CREATION_DATE, this.confluencePackage
                    .getDate(attachmentProperties, ConfluenceXMLPackage.KEY_ATTACHMENT_CREATION_DATE));
        } catch (ParseException e) {
            if (this.properties.isVerbose()) {
                this.logger.error("Failed to parse date", e);
            }
        }
    }

    attachmentParameters.put(WikiAttachmentFilter.PARAMETER_REVISION, String.valueOf(version));
    if (attachmentProperties.containsKey(ConfluenceXMLPackage.KEY_ATTACHMENT_REVISION_AUTHOR)) {
        attachmentParameters.put(WikiAttachmentFilter.PARAMETER_REVISION_AUTHOR,
                attachmentProperties.getString(ConfluenceXMLPackage.KEY_ATTACHMENT_REVISION_AUTHOR));
    }
    if (attachmentProperties.containsKey(ConfluenceXMLPackage.KEY_ATTACHMENT_REVISION_DATE)) {
        try {
            attachmentParameters.put(WikiAttachmentFilter.PARAMETER_REVISION_DATE, this.confluencePackage
                    .getDate(attachmentProperties, ConfluenceXMLPackage.KEY_ATTACHMENT_REVISION_DATE));
        } catch (ParseException e) {
            if (this.properties.isVerbose()) {
                this.logger.error("Failed to parse date", e);
            }
        }
    }
    if (attachmentProperties.containsKey(ConfluenceXMLPackage.KEY_ATTACHMENT_REVISION_COMMENT)) {
        attachmentParameters.put(WikiAttachmentFilter.PARAMETER_REVISION_COMMENT,
                attachmentProperties.getString(ConfluenceXMLPackage.KEY_ATTACHMENT_REVISION_COMMENT));
    }

    // WikiAttachment

    try {
        FileInputStream fis = new FileInputStream(contentFile);

        try {
            proxyFilter.onWikiAttachment(attachmentName, fis, attachmentSize, attachmentParameters);
        } finally {
            fis.close();
        }
    } catch (Exception e) {
        throw new FilterException("Failed to read attachment", e);
    }
}

From source file:org.xwiki.test.escaping.framework.SingleXWikiExecutor.java

/**
 * {@inheritDoc}/* w w  w .j  av  a 2  s  . co m*/
 * 
 * Starts the server on the first call, subsequent calls only increase the internal counter by one.
 */
@Override
public synchronized void start() throws Exception {
    if (counter == 0) {
        if (!VERIFY_RUNNING_XWIKI_AT_START.equals("true") || isXWikiStarted(getURL(), 15).timedOut) {
            // Disable extensions manager external repositories
            PropertiesConfiguration properties = loadXWikiPropertiesConfiguration();
            if (!properties.containsKey("extension.repositories")) {
                properties.setProperty("extension.repositories", "");
            }
            saveXWikiProperties(properties);
        }

        super.start();
    }
    counter++;
}