/* | |
* 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.jaxws.marshaller.impl.alt; | |
import org.apache.axiom.om.util.UUIDGenerator; | |
import org.apache.axis2.jaxws.ExceptionFactory; | |
import org.apache.axis2.jaxws.description.AttachmentDescription; | |
import org.apache.axis2.jaxws.i18n.Messages; | |
import org.apache.axis2.jaxws.utility.ConvertUtils; | |
import org.apache.axis2.transport.http.HTTPConstants; | |
import org.apache.commons.logging.Log; | |
import org.apache.commons.logging.LogFactory; | |
import javax.activation.DataHandler; | |
import javax.imageio.IIOImage; | |
import javax.imageio.ImageWriter; | |
import javax.imageio.stream.ImageOutputStream; | |
import javax.mail.internet.InternetHeaders; | |
import javax.mail.internet.MimeBodyPart; | |
import javax.mail.internet.MimePartDataSource; | |
import javax.xml.transform.Source; | |
import java.awt.*; | |
import java.awt.image.BufferedImage; | |
import java.io.ByteArrayOutputStream; | |
import java.io.IOException; | |
import java.util.Iterator; | |
/** | |
* The Attachment object has a similar function as the | |
* org.apache.axis2.jaxws.marshaller.impl.alt.Element object. | |
* The Element object is used to | |
* 1) Get the "element rendered" object that is marshalled/unmarshalled from the wire | |
* 2) Get the "type rendered" object that is used as the parameter value in the signature. | |
* | |
* The Attachment object has a similar role. | |
* The DataHandler object is used for marshalling/unmarshalling. | |
* And the getValue method is used to get the signature representation. | |
* | |
* | |
*/ | |
class Attachment { | |
private static final Log log = LogFactory.getLog(Attachment.class); | |
DataHandler dh = null; | |
String cid = null; | |
AttachmentDescription aDesc = null; | |
Object sigValue = null; | |
Class sigClass = null; | |
String partName = null; | |
/** | |
* Constructor used to set Attachment from wire unmarshalling | |
* @param dh | |
* @param cid | |
*/ | |
public Attachment(DataHandler dh, String cid) { | |
if (log.isDebugEnabled()) { | |
System.out.println("Construct with dh=" + dh.getContentType() + " cid=" + cid); | |
} | |
this.dh = dh; | |
this.cid = cid; | |
} | |
/** | |
* Constructor used to create Attachment from signature data | |
* @param sigValue | |
* @param sigClass | |
*/ | |
public Attachment(Object sigValue, Class sigClass, AttachmentDescription aDesc, String partName) { | |
this.sigValue = sigValue; | |
this.sigClass = sigClass; | |
this.aDesc = aDesc; | |
this.partName = partName; | |
} | |
/** | |
* @return DataHandler | |
*/ | |
public DataHandler getDataHandler() { | |
if (dh == null) { | |
//if null DH was specified explicitly, return it, don't create something else. | |
if (sigValue == null) { | |
// Create a contentID and null DataHandler | |
getContentID(); // Force setting of content id | |
dh = (DataHandler) null; | |
} else { | |
// Normal case: create a DataHandler from the sigValue object | |
dh = createDataHandler(sigValue, sigClass, aDesc.getMimeTypes(), getContentID()); | |
} | |
} | |
return dh; | |
} | |
/** | |
* @return ContentID | |
*/ | |
public String getContentID() { | |
if (cid == null) { | |
cid = UUIDGenerator.getUUID(); | |
// Per spec, use the partName in the content-id | |
// http://www.ws-i.org/Profiles/AttachmentsProfile-1.0.html#Value-space_of_Content-Id_Header | |
if (partName != null) { | |
cid = partName + "=" + cid; | |
} | |
} | |
return cid; | |
} | |
private static DataHandler createDataHandler(Object value, Class cls, String[] mimeTypes, | |
String cid) { | |
if (log.isDebugEnabled()) { | |
System.out.println("Construct data handler for " + cls + " cid=" + cid); | |
} | |
DataHandler dh = null; | |
if (cls.isAssignableFrom(DataHandler.class)) { | |
dh = (DataHandler) value; | |
if(dh == null) | |
{ | |
return dh; //return if DataHandler is null | |
} | |
try { | |
Object content = dh.getContent(); | |
// If the content is a Source, convert to a String due to | |
// problems with the DataContentHandler | |
if (content instanceof Source) { | |
if (log.isDebugEnabled()) { | |
System.out.println("Converting DataHandler Source content to " | |
+ "DataHandlerString content"); | |
} | |
byte[] bytes = (byte[]) ConvertUtils.convert(content, byte[].class); | |
String newContent = new String(bytes); | |
return new DataHandler(newContent, mimeTypes[0]); | |
} | |
} catch (Exception e) { | |
throw ExceptionFactory.makeWebServiceException(e); | |
} | |
} else { | |
try { | |
byte[] bytes = createBytes(value, cls, mimeTypes); | |
// Create MIME Body Part | |
InternetHeaders ih = new InternetHeaders(); | |
ih.setHeader(HTTPConstants.HEADER_CONTENT_TYPE, mimeTypes[0]); | |
MimeBodyPart mbp = new MimeBodyPart(ih, bytes); | |
//Create a data source for the MIME Body Part | |
MimePartDataSource ds = new MimePartDataSource(mbp); | |
dh = new DataHandler(ds); | |
mbp.setHeader(HTTPConstants.HEADER_CONTENT_ID, cid); | |
} catch (Exception e) { | |
throw ExceptionFactory.makeWebServiceException(e); | |
} | |
} | |
return dh; | |
} | |
private static byte[] createBytes(Object value, Class cls, String[] mimeTypes) { | |
if (cls.isAssignableFrom(byte[].class)) { | |
return (byte[]) value; | |
} else if (cls.isAssignableFrom(String.class)) { | |
return ((String) value).getBytes(); | |
} else if (cls.isAssignableFrom(Image.class)) { | |
return createBytesFromImage((Image) value, mimeTypes[0]); | |
} else if (ConvertUtils.isConvertable(value, byte[].class)) { | |
return (byte[]) ConvertUtils.convert(value, byte[].class); | |
} else { | |
throw ExceptionFactory.makeWebServiceException(Messages.getMessage("convertProblem", | |
cls.getName(), | |
"byte[]")); | |
} | |
} | |
private static byte[] createBytesFromImage(Image image, String mimeType) { | |
try { | |
ImageWriter imageWriter = null; | |
BufferedImage bufferedImage = (BufferedImage) image; | |
ByteArrayOutputStream baos = new ByteArrayOutputStream(); | |
Iterator iterator = javax.imageio.ImageIO.getImageWritersByMIMEType(mimeType); | |
if (iterator.hasNext()) { | |
imageWriter = (ImageWriter) iterator.next(); | |
} | |
ImageOutputStream ios = javax.imageio.ImageIO.createImageOutputStream(baos); | |
imageWriter.setOutput(ios); | |
imageWriter.write(new IIOImage(bufferedImage, null, null)); | |
ios.flush(); | |
imageWriter.dispose(); | |
return baos.toByteArray(); | |
} catch (IOException e) { | |
throw ExceptionFactory.makeWebServiceException(e); | |
} | |
} | |
} |