org.apache.axis2.saaj.AttachmentPartImpl Maven / Gradle / Ivy
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.axis2.saaj;
import org.apache.axiom.om.OMAbstractFactory;
import org.apache.axiom.om.OMText;
import org.apache.axiom.util.base64.Base64Utils;
import org.apache.axis2.saaj.util.SAAJDataSource;
import org.apache.axis2.transport.http.HTTPConstants;
import javax.activation.DataHandler;
import javax.xml.soap.AttachmentPart;
import javax.xml.soap.MimeHeader;
import javax.xml.soap.MimeHeaders;
import javax.xml.soap.SOAPException;
import javax.xml.transform.stream.StreamSource;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Iterator;
/**
*
*/
public class AttachmentPartImpl extends AttachmentPart {
private DataHandler dataHandler;
private MimeHeaders mimeHeaders = new MimeHeaders();
private String attachmentFile;
private OMText omText;
private boolean isAttachmentReferenced;
/**
* Check whether at least one of the headers of this object matches a provided header
*
* @param headers
* @return true if at least one header of this AttachmentPart matches a header in the
* provided headers parameter, false if none of the headers of this
* AttachmentPart matches at least one of the header in the provided
* headers parameter
*/
public boolean matches(MimeHeaders headers) {
for (Iterator i = headers.getAllHeaders(); i.hasNext();) {
MimeHeader hdr = (javax.xml.soap.MimeHeader)i.next();
String values[] = mimeHeaders.getHeader(hdr.getName());
boolean found = false;
if (values != null) {
for (int j = 0; j < values.length; j++) {
if (!hdr.getValue().equalsIgnoreCase(values[j])) {
continue;
}
found = true;
break;
}
}
if (!found) {
return false;
}
}
return true;
}
public boolean isAttachmentReferenced() {
return isAttachmentReferenced;
}
public void setAttachmentReferenced(boolean attachmentReferenced) {
isAttachmentReferenced = attachmentReferenced;
}
/**
* Returns the number of bytes in this AttachmentPart object.
*
* @return the size of this AttachmentPart object in bytes or -1 if the size cannot
* be determined
* @throws javax.xml.soap.SOAPException if the content of this attachment is corrupted of if
* there was an exception while trying to determine the
* size.
*/
public int getSize() throws SOAPException {
if (dataHandler == null) {
return 0;
}
ByteArrayOutputStream bout = new ByteArrayOutputStream();
try {
dataHandler.writeTo(bout);
} catch (Exception ex) {
throw new SOAPException(ex);
}
return bout.size();
}
/**
* Clears out the content of this AttachmentPart object. The MIME header portion
* is left untouched.
*/
public void clearContent() {
dataHandler = null;
omText = null;
}
/**
* Gets the content of this AttachmentPart object as a Java object. The type of the
* returned Java object depends on - the
DataContentHandler object that is
* used to interpret the bytes - the
Content-Type given in the header
*
*
* For the MIME content types "text/plain", "text/html" and "text/xml", the
* DataContentHandler object does the conversions to and from the Java types
* corresponding to the MIME types. For other MIME types,the DataContentHandler
* object can return an InputStream object that contains the content data as raw
* bytes.
*
* A JAXM-compliant implementation must, as a minimum, return a java.lang.String
* object corresponding to any content stream with a Content-Type value of
* text/plain, a javax.xml.transform.StreamSource object corresponding
* to a content stream with a Content-Type value of text/xml, a
* java.awt.Image object corresponding to a content stream with a
* Content-Type value of image/gif or image/jpeg. For
* those content types that an installed DataContentHandler object does not
* understand, the DataContentHandler object is required to return a
* java.io.InputStream object with the raw bytes.
*
* @return a Java object with the content of this AttachmentPart object
* @throws javax.xml.soap.SOAPException if there is no content set into this AttachmentPart
* object or if there was a data transformation error
*/
public Object getContent() throws SOAPException {
if (dataHandler == null) {
throw new SOAPException("No content is present in this AttachmentPart");
}
try {
String contentType = dataHandler.getContentType();
if (contentType.equals(HTTPConstants.MEDIA_TYPE_TEXT_XML) ||
contentType.equals(HTTPConstants.MEDIA_TYPE_APPLICATION_XML)) {
StreamSource streamSource = new StreamSource();
streamSource.setInputStream(dataHandler.getInputStream());
return streamSource;
} else if (contentType.equals("text/plain") ||
contentType.equals("text/html")) {
return (String)dataHandler.getContent();
} else {
try {
return dataHandler.getContent();
} catch (Exception e) {
//If the underlying DataContentHandler can't handle the object contents,
//we will return an inputstream of raw bytes representing the content data
return dataHandler.getDataSource().getInputStream();
}
}
} catch (IOException e) {
throw new SOAPException(e.getMessage());
}
}
/**
* Sets the content of this attachment part to that of the given Object and sets
* the value of the Content-Type header to the given type. The type of the
* Object should correspond to the value given for the Content-Type.
* This depends on the particular set of DataContentHandler objects in use.
*
* @param object the Java object that makes up the content for this attachment part
* @param contentType the MIME string that specifies the type of the content
* @throws IllegalArgumentException if the contentType does not match the type of the content
* object, or if there was no DataContentHandler
* object for this content object
* @see #getContent()
*/
public void setContent(Object object, String contentType) {
SAAJDataSource source;
setMimeHeader(HTTPConstants.HEADER_CONTENT_TYPE, contentType);
if (object instanceof String) {
try {
String s = (String)object;
java.io.ByteArrayInputStream bais = new java.io.ByteArrayInputStream(s.getBytes());
source = new SAAJDataSource(bais,
SAAJDataSource.MAX_MEMORY_DISK_CACHED,
contentType, true);
extractFilename(source);
this.dataHandler = new DataHandler(source);
} catch (java.io.IOException io) {
throw new java.lang.IllegalArgumentException("Illegal Argument");
}
} else if (object instanceof java.io.InputStream) {
try {
source = new SAAJDataSource((java.io.InputStream)object,
SAAJDataSource.MIN_MEMORY_DISK_CACHED,
contentType, true);
extractFilename(source);
this.dataHandler = new DataHandler(source);
} catch (java.io.IOException io) {
throw new java.lang.IllegalArgumentException("Illegal Argument");
}
} else if (object instanceof StreamSource) {
try {
source = new SAAJDataSource(((StreamSource)object).getInputStream(),
SAAJDataSource.MAX_MEMORY_DISK_CACHED,
contentType, true);
extractFilename(source);
this.dataHandler = new DataHandler(source);
} catch (java.io.IOException io) {
throw new java.lang.IllegalArgumentException("Illegal Argument");
}
} else if (object instanceof BufferedImage) {
try {
this.dataHandler = new DataHandler(object, contentType);
} catch (Exception e) {
throw new java.lang.IllegalArgumentException(e.getMessage());
}
} else if (object instanceof byte[]) {
try {
java.io.ByteArrayInputStream bais =
new java.io.ByteArrayInputStream((byte[])object);
source = new SAAJDataSource(bais,
SAAJDataSource.MAX_MEMORY_DISK_CACHED,
contentType, true);
extractFilename(source);
this.dataHandler = new DataHandler(source);
} catch (Exception e) {
throw new java.lang.IllegalArgumentException(e.getMessage());
}
} else {
throw new java.lang.IllegalArgumentException("Illegal Argument");
}
}
/**
* Gets the DataHandler object for this AttachmentPart object.
*
* @return the DataHandler object associated with this AttachmentPart
* object
* @throws javax.xml.soap.SOAPException if there is no data in this AttachmentPart
* object
*/
public DataHandler getDataHandler() throws SOAPException {
//if (getContent() == null) {
// throw new SOAPException("No Content present in the Attachment part");
//}
//commented to fix AXIS2-778
if (dataHandler == null) {
throw new SOAPException("No Content present in the Attachment part");
}
return dataHandler;
}
/**
* Sets the given DataHandler object as the data handler for this
* AttachmentPart object. Typically, on an incoming message, the data handler is
* automatically set. When a message is being created and populated with content, the
* setDataHandler method can be used to get data from various data sources into the
* message.
*
* @param datahandler DataHandler object to be set
* @throws IllegalArgumentException if there was a problem with the specified
* DataHandler object
*/
public void setDataHandler(DataHandler datahandler) {
if (datahandler != null) {
this.dataHandler = datahandler;
setMimeHeader(HTTPConstants.HEADER_CONTENT_TYPE, datahandler.getContentType());
omText = OMAbstractFactory.getMetaFactory(OMAbstractFactory.FEATURE_DOM).getOMFactory().createOMText(datahandler, true);
} else {
throw new IllegalArgumentException("Cannot set null DataHandler");
}
}
/**
* Removes all MIME headers that match the given name.
*
* @param header - the string name of the MIME header/s to be removed
*/
public void removeMimeHeader(String header) {
mimeHeaders.removeHeader(header);
}
/** Removes all the MIME header entries. */
public void removeAllMimeHeaders() {
mimeHeaders.removeAllHeaders();
}
/**
* Gets all the values of the header identified by the given String.
*
* @param name the name of the header; example: "Content-Type"
* @return a String array giving the value for the specified header
* @see #setMimeHeader(String, String) setMimeHeader(java.lang.String, java.lang.String)
*/
public String[] getMimeHeader(String name) {
return mimeHeaders.getHeader(name);
}
/**
* Changes the first header entry that matches the given name to the given value, adding a new
* header if no existing header matches. This method also removes all matching headers but the
* first.
*
* Note that RFC822 headers can only contain US-ASCII characters.
*
* @param name a String giving the name of the header for which to search
* @param value a String giving the value to be set for the header whose name
* matches the given name
* @throws IllegalArgumentException if there was a problem with the specified mime header name
* or value
*/
public void setMimeHeader(String name, String value) {
mimeHeaders.setHeader(name, value);
}
/**
* Adds a MIME header with the specified name and value to this AttachmentPart
* object.
*
* Note that RFC822 headers can contain only US-ASCII characters.
*
* @param name a String giving the name of the header to be added
* @param value a String giving the value of the header to be added
* @throws IllegalArgumentException if there was a problem with the specified mime header name
* or value
*/
public void addMimeHeader(String name, String value) {
mimeHeaders.addHeader(name, value);
}
/**
* Retrieves all the headers for this AttachmentPart object as an iterator over
* the MimeHeader objects.
*
* @return an Iterator object with all of the Mime headers for this
* AttachmentPart object
*/
public Iterator getAllMimeHeaders() {
return mimeHeaders.getAllHeaders();
}
/**
* Retrieves all MimeHeader objects that match a name in the given array.
*
* @param names a String array with the name(s) of the MIME headers to be returned
* @return all of the MIME headers that match one of the names in the given array as an
* Iterator object
*/
public Iterator getMatchingMimeHeaders(String names[]) {
return mimeHeaders.getMatchingHeaders(names);
}
/**
* Retrieves all MimeHeader objects whose name does not match a name in the given
* array.
*
* @param names a String array with the name(s) of the MIME headers not to be
* returned
* @return all of the MIME headers in this AttachmentPart object except those that
* match one of the names in the given array. The nonmatching MIME headers are returned
* as an Iterator object.
*/
public Iterator getNonMatchingMimeHeaders(String names[]) {
return mimeHeaders.getNonMatchingHeaders(names);
}
public InputStream getBase64Content() throws SOAPException {
byte[] rawData = getRawContentBytes();
ByteArrayOutputStream out = new ByteArrayOutputStream();
try {
Base64Utils.encode(rawData, 0, rawData.length, out);
return new ByteArrayInputStream(out.toByteArray());
} catch (IOException e) {
throw new SOAPException(e);
}
}
/**
* Gets the content of this AttachmentPart object as an InputStream as if a call had been made
* to getContent and no DataContentHandler had been registered for the content-type of this
* AttachmentPart.Note that reading from the returned InputStream would result in consuming the
* data in the stream. It is the responsibility of the caller to reset the InputStream
* appropriately before calling a Subsequent API. If a copy of the raw attachment content is
* required then the getRawContentBytes() API should be used instead.
*
* @return an InputStream from which the raw data contained by the AttachmentPart can be
* accessed.
* @throws SOAPException - if there is no content set into this AttachmentPart object or if
* there was a data transformation error.
* @since SAAJ 1.3
*/
public InputStream getRawContent() throws SOAPException {
try {
if (dataHandler == null) {
throw new SOAPException("No content set");
}
return dataHandler.getInputStream();
} catch (IOException e) {
throw new SOAPException(e);
}
}
/**
* Gets the content of this AttachmentPart object as a byte[] array as if a call had been made
* to getContent and no DataContentHandler had been registered for the content-type of this
* AttachmentPart.
*
* @return a byte[] array containing the raw data of the AttachmentPart.
* @throws SOAPException - if there is no content set into this AttachmentPart object or if
* there was a data transformation error.
* @since SAAJ 1.3
*/
public byte[] getRawContentBytes() throws SOAPException {
if (dataHandler == null) {
throw new SOAPException("Content is null");
}
ByteArrayOutputStream bout = new ByteArrayOutputStream();
try {
dataHandler.writeTo(bout);
} catch (Exception ex) {
throw new SOAPException(ex);
}
return bout.toByteArray();
}
/**
* Sets the content of this attachment part from the Base64 source InputStream and sets the
* value of the Content-Type header to the value contained in contentType, This method would
* first decode the base64 input and write the resulting raw bytes to the attachment. A
* subsequent call to getSize() may not be an exact measure of the content size.
*
* @param content - the base64 encoded data to add to the attachment part contentType - the
* value to set into the Content-Type header
* @throws SOAPException - if there is an error in setting the content java.lang.NullPointerException
* - if content is null
*/
public void setBase64Content(InputStream content, String contentType) throws SOAPException {
if (content == null) {
throw new SOAPException("Content is null");
}
OutputStream outputStream = new ByteArrayOutputStream();
byte[] buffer = new byte[1024];
int read;
try {
while ((read = content.read(buffer, 0, buffer.length)) > 0) {
outputStream.write(buffer, 0, read);
}
String contentString = outputStream.toString();
if (Base64Utils.isValidBase64Encoding(contentString)) {
setContent(Base64Utils.decode(contentString), contentType);
} else {
throw new SOAPException("Not a valid Base64 encoding");
}
} catch (IOException ex) {
throw new SOAPException(ex);
}
}
/**
* Sets the content of this attachment part to that contained by the InputStream content and
* sets the value of the Content-Type header to the value contained in contentType.A subsequent
* call to getSize() may not be an exact measure of the content size.
*
* @param content - the raw data to add to the attachment part contentType - the value to set
* into the Content-Type header
* @throws SOAPException - if there is an error in setting the content java.lang.NullPointerException
* - if content is null
*/
public void setRawContent(InputStream content, String contentType) throws SOAPException {
if (content == null) {
throw new SOAPException("content is null");
}
setContent(content, contentType);
}
/**
* Sets the content of this attachment part to that contained by the byte[] array content and
* sets the value of the Content-Type header to the value contained in contentType.
*
* @param content - the raw data to add to the attachment part contentType - the value to set
* into the Content-Type header offset - the offset in the byte array of the
* content len - the number of bytes that form the content
* @throws SOAPException - if an there is an error in setting the content or content is null
* @since SAAJ 1.3
*/
public void setRawContentBytes(byte[] content, int offset, int len, String contentType)
throws SOAPException {
//TODO - how to use offset & len?
if (content == null) {
throw new SOAPException("Content is null");
}
setContent(content, contentType);
}
/**
* Retrieve the OMText
*
* @return the OMText
* @throws SOAPException If omText is not available
*/
public OMText getOMText() throws SOAPException {
if (omText == null) {
throw new SOAPException("OMText set to null");
}
return omText;
}
/**
* Set the filename of this attachment part.
*
* @param path the new file path
*/
protected void setAttachmentFile(String path) {
attachmentFile = path;
}
/**
* Detach the attachment file from this class, so it is not cleaned up. This has the side-effect
* of making subsequent calls to getAttachmentFile() return null.
*/
public void detachAttachmentFile() {
attachmentFile = null;
}
/**
* Get the filename of this attachment.
*
* @return the filename or null for an uncached file
*/
public String getAttachmentFile() {
return attachmentFile;
}
private void extractFilename(SAAJDataSource source) {
if (source.getDiskCacheFile() != null) {
String path = source.getDiskCacheFile().getAbsolutePath();
setAttachmentFile(path);
}
}
}
© 2015 - 2024 Weber Informatics LLC | Privacy Policy