/*
* 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) {
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;
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);
}
}
}