/*
* The MIT License
* Copyright (c) 2012 Microsoft Corporation
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package microsoft.exchange.webservices.data.core;
import microsoft.exchange.webservices.data.core.enumeration.misc.XmlNamespace;
import microsoft.exchange.webservices.data.core.exception.service.local.ServiceXmlSerializationException;
import microsoft.exchange.webservices.data.misc.OutParam;
import microsoft.exchange.webservices.data.property.complex.ISearchStringProvider;
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.w3c.dom.CDATASection;
import org.w3c.dom.Comment;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.EntityReference;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.ProcessingInstruction;
import org.w3c.dom.Text;
import javax.xml.stream.XMLOutputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamWriter;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Date;
/**
* Stax based XML Writer implementation.
*/
public class EwsServiceXmlWriter implements IDisposable {
private static final Log LOG = LogFactory.getLog(EwsServiceXmlWriter.class);
/**
* The is disposed.
*/
private boolean isDisposed;
/**
* The service.
*/
private ExchangeServiceBase service;
/**
* The xml writer.
*/
private XMLStreamWriter xmlWriter;
/**
* The is time zone header emitted.
*/
private boolean isTimeZoneHeaderEmitted;
/**
* The Buffer size.
*/
private static final int BufferSize = 4096;
/**
* The requireWSSecurityUtilityNamespace *
*/
protected boolean requireWSSecurityUtilityNamespace;
/**
* Initializes a new instance.
*
* @param service the service
* @param stream the stream
* @throws XMLStreamException the XML stream exception
*/
public EwsServiceXmlWriter(ExchangeServiceBase service, OutputStream stream) throws XMLStreamException {
this.service = service;
XMLOutputFactory xmlof = XMLOutputFactory.newInstance();
xmlWriter = xmlof.createXMLStreamWriter(stream, "utf-8");
}
/**
* Try to convert object to a string.
*
* @param value The value.
* @param str the str
* @return True if object was converted, false otherwise. A null object will
* be "successfully" converted to a null string.
*/
protected boolean tryConvertObjectToString(Object value,
OutParam<String> str) {
boolean converted = true;
str.setParam(null);
if (value != null) {
if (value.getClass().isEnum()) {
str.setParam(EwsUtilities.serializeEnum(value));
} else if (value.getClass().equals(Boolean.class)) {
str.setParam(EwsUtilities.boolToXSBool((Boolean) value));
} else if (value instanceof Date) {
str
.setParam(this.service
.convertDateTimeToUniversalDateTimeString(
(Date) value));
} else if (value.getClass().isPrimitive()) {
str.setParam(value.toString());
} else if (value instanceof String) {
str.setParam(value.toString());
} else if (value instanceof ISearchStringProvider) {
ISearchStringProvider searchStringProvider =
(ISearchStringProvider) value;
str.setParam(searchStringProvider.getSearchString());
} else if (value instanceof Number) {
str.setParam(value.toString());
} else {
converted = false;
}
}
return converted;
}
/**
* Performs application-defined tasks associated with freeing, releasing, or
* resetting unmanaged resources.
*/
@Override
public void dispose() {
if (!this.isDisposed) {
try {
this.xmlWriter.close();
} catch (XMLStreamException e) {
LOG.error(e);
}
this.isDisposed = true;
}
}
/**
* Flushes this instance.
*
* @throws XMLStreamException the XML stream exception
*/
public void flush() throws XMLStreamException {
this.xmlWriter.flush();
}
/**
* Writes the start element.
*
* @param xmlNamespace the XML namespace
* @param localName the local name of the element
* @throws XMLStreamException the XML stream exception
*/
public void writeStartElement(XmlNamespace xmlNamespace, String localName)
throws XMLStreamException {
String strPrefix = EwsUtilities.getNamespacePrefix(xmlNamespace);
String strNameSpace = EwsUtilities.getNamespaceUri(xmlNamespace);
this.xmlWriter.writeStartElement(strPrefix, localName, strNameSpace);
}
/**
* Writes the end element.
*
* @throws XMLStreamException the XML stream exception
*/
public void writeEndElement() throws XMLStreamException {
this.xmlWriter.writeEndElement();
}
/**
* Writes the attribute value.
*
* @param localName the local name of the attribute
* @param value the value
* @throws ServiceXmlSerializationException the service xml serialization exception
*/
public void writeAttributeValue(String localName, Object value)
throws ServiceXmlSerializationException {
this.writeAttributeValue(localName,
false /* alwaysWriteEmptyString */, value);
}
/**
* Writes the attribute value. Optionally emits empty string values.
*
* @param localName the local name of the attribute.
* @param alwaysWriteEmptyString always emit the empty string as the value.
* @param value the value
* @throws ServiceXmlSerializationException the service xml serialization exception
*/
public void writeAttributeValue(String localName,
boolean alwaysWriteEmptyString,
Object value) throws ServiceXmlSerializationException {
OutParam<String> stringOut = new OutParam<String>();
String stringValue = null;
if (this.tryConvertObjectToString(value, stringOut)) {
stringValue = stringOut.getParam();
if ((null != stringValue) && (alwaysWriteEmptyString || (stringValue.length() != 0))) {
this.writeAttributeString(localName, stringValue);
}
} else {
throw new ServiceXmlSerializationException(String.format(
"Values of type '%s' can't be used for the '%s' attribute.", value.getClass()
.getName(), localName));
}
}
/**
* Writes the attribute value.
*
* @param namespacePrefix the namespace prefix
* @param localName the local name of the attribute
* @param value the value
* @throws ServiceXmlSerializationException the service xml serialization exception
*/
public void writeAttributeValue(String namespacePrefix, String localName,
Object value) throws ServiceXmlSerializationException {
OutParam<String> stringOut = new OutParam<String>();
String stringValue = null;
if (this.tryConvertObjectToString(value, stringOut)) {
stringValue = stringOut.getParam();
if (null != stringValue && !stringValue.isEmpty()) {
this.writeAttributeString(namespacePrefix, localName,
stringValue);
}
} else {
throw new ServiceXmlSerializationException(String.format(
"Values of type '%s' can't be used for the '%s' attribute.", value.getClass()
.getName(), localName));
}
}
/**
* Writes the attribute value.
*
* @param localName The local name of the attribute.
* @param stringValue The string value.
* @throws ServiceXmlSerializationException Thrown if string value isn't valid for XML
*/
protected void writeAttributeString(String localName, String stringValue)
throws ServiceXmlSerializationException {
try {
this.xmlWriter.writeAttribute(localName, stringValue);
} catch (XMLStreamException e) {
// Bug E14:65046: XmlTextWriter will throw ArgumentException
//if string includes invalid characters.
throw new ServiceXmlSerializationException(String.format(
"The invalid value '%s' was specified for the '%s' attribute.", stringValue, localName), e);
}
}
/**
* Writes the attribute value.
*
* @param namespacePrefix The namespace prefix.
* @param localName The local name of the attribute.
* @param stringValue The string value.
* @throws ServiceXmlSerializationException Thrown if string value isn't valid for XML.
*/
protected void writeAttributeString(String namespacePrefix,
String localName, String stringValue)
throws ServiceXmlSerializationException {
try {
this.xmlWriter.writeAttribute(namespacePrefix, "", localName,
stringValue);
} catch (XMLStreamException e) {
// Bug E14:65046: XmlTextWriter will throw ArgumentException
//if string includes invalid characters.
throw new ServiceXmlSerializationException(String.format(
"The invalid value '%s' was specified for the '%s' attribute.", stringValue, localName), e);
}
}
/**
* Writes string value.
*
* @param value The value.
* @param name Element name (used for error handling)
* @throws ServiceXmlSerializationException Thrown if string value isn't valid for XML.
*/
public void writeValue(String value, String name)
throws ServiceXmlSerializationException {
try {
this.xmlWriter.writeCharacters(value);
} catch (XMLStreamException e) {
// Bug E14:65046: XmlTextWriter will throw ArgumentException
//if string includes invalid characters.
throw new ServiceXmlSerializationException(String.format(
"The invalid value '%s' was specified for the '%s' element.", value, name), e);
}
}
/**
* Writes the element value.
*
* @param xmlNamespace the XML namespace
* @param localName the local name of the element
* @param displayName the name that should appear in the exception message when the value can not be serialized
* @param value the value
* @throws XMLStreamException the XML stream exception
* @throws ServiceXmlSerializationException the service xml serialization exception
*/
public void writeElementValue(XmlNamespace xmlNamespace, String localName, String displayName, Object value)
throws XMLStreamException, ServiceXmlSerializationException {
String stringValue = null;
OutParam<String> strOut = new OutParam<String>();
if (this.tryConvertObjectToString(value, strOut)) {
stringValue = strOut.getParam();
if (null != stringValue) {
// allow an empty string to create an empty element (like <Value
// />).
this.writeStartElement(xmlNamespace, localName);
this.writeValue(stringValue, displayName);
this.writeEndElement();
}
} else {
throw new ServiceXmlSerializationException(String.format(
"Values of type '%s' can't be used for the '%s' element.", value.getClass()
.getName(), localName));
}
}
public void writeNode(Node xmlNode) throws XMLStreamException {
if (xmlNode != null) {
writeNode(xmlNode, this.xmlWriter);
}
}
/**
* @param xmlNode XML node
* @param xmlStreamWriter XML stream writer
* @throws XMLStreamException the XML stream exception
*/
public static void writeNode(Node xmlNode, XMLStreamWriter xmlStreamWriter)
throws XMLStreamException {
if (xmlNode instanceof Element) {
addElement((Element) xmlNode, xmlStreamWriter);
} else if (xmlNode instanceof Text) {
xmlStreamWriter.writeCharacters(xmlNode.getNodeValue());
} else if (xmlNode instanceof CDATASection) {
xmlStreamWriter.writeCData(((CDATASection) xmlNode).getData());
} else if (xmlNode instanceof Comment) {
xmlStreamWriter.writeComment(((Comment) xmlNode).getData());
} else if (xmlNode instanceof EntityReference) {
xmlStreamWriter.writeEntityRef(xmlNode.getNodeValue());
} else if (xmlNode instanceof ProcessingInstruction) {
ProcessingInstruction procInst = (ProcessingInstruction) xmlNode;
xmlStreamWriter.writeProcessingInstruction(procInst.getTarget(),
procInst.getData());
} else if (xmlNode instanceof Document) {
writeToDocument((Document) xmlNode, xmlStreamWriter);
}
}
/**
* @param document XML document
* @param xmlStreamWriter XML stream writer
* @throws XMLStreamException the XML stream exception
*/
public static void writeToDocument(Document document,
XMLStreamWriter xmlStreamWriter) throws XMLStreamException {
xmlStreamWriter.writeStartDocument();
Element rootElement = document.getDocumentElement();
addElement(rootElement, xmlStreamWriter);
xmlStreamWriter.writeEndDocument();
}
/**
* @param element DOM element
* @param writer XML stream writer
* @throws XMLStreamException the XML stream exception
*/
public static void addElement(Element element, XMLStreamWriter writer)
throws XMLStreamException {
String nameSpace = element.getNamespaceURI();
String prefix = element.getPrefix();
String localName = element.getLocalName();
if (prefix == null) {
prefix = "";
}
if (localName == null) {
localName = element.getNodeName();
if (localName == null) {
throw new IllegalStateException(
"Element's local name cannot be null!");
}
}
String decUri = writer.getNamespaceContext().getNamespaceURI(prefix);
boolean declareNamespace = decUri == null || !decUri.equals(nameSpace);
if (nameSpace == null || nameSpace.length() == 0) {
writer.writeStartElement(localName);
} else {
writer.writeStartElement(prefix, localName, nameSpace);
}
NamedNodeMap attrs = element.getAttributes();
for (int i = 0; i < attrs.getLength(); i++) {
Node attr = attrs.item(i);
String name = attr.getNodeName();
String attrPrefix = "";
int prefixIndex = name.indexOf(':');
if (prefixIndex != -1) {
attrPrefix = name.substring(0, prefixIndex);
name = name.substring(prefixIndex + 1);
}
if ("xmlns".equals(attrPrefix)) {
writer.writeNamespace(name, attr.getNodeValue());
if (name.equals(prefix)
&& attr.getNodeValue().equals(nameSpace)) {
declareNamespace = false;
}
} else {
if ("xmlns".equals(name) && "".equals(attrPrefix)) {
writer.writeNamespace("", attr.getNodeValue());
if (attr.getNodeValue().equals(nameSpace)) {
declareNamespace = false;
}
} else {
writer.writeAttribute(attrPrefix, attr.getNamespaceURI(),
name, attr.getNodeValue());
}
}
}
if (declareNamespace) {
if (nameSpace == null) {
writer.writeNamespace(prefix, "");
} else {
writer.writeNamespace(prefix, nameSpace);
}
}
NodeList nodes = element.getChildNodes();
for (int i = 0; i < nodes.getLength(); i++) {
Node n = nodes.item(i);
writeNode(n, writer);
}
writer.writeEndElement();
}
/**
* Writes the element value.
*
* @param xmlNamespace the XML namespace
* @param localName the local name of the element
* @param value the value
* @throws XMLStreamException the XML stream exception
* @throws ServiceXmlSerializationException the service xml serialization exception
*/
public void writeElementValue(XmlNamespace xmlNamespace, String localName,
Object value) throws XMLStreamException,
ServiceXmlSerializationException {
this.writeElementValue(xmlNamespace, localName, localName, value);
}
/**
* Writes the base64-encoded element value.
*
* @param buffer the buffer
* @throws XMLStreamException the XML stream exception
*/
public void writeBase64ElementValue(byte[] buffer)
throws XMLStreamException {
String strValue = Base64.encodeBase64String(buffer);
this.xmlWriter.writeCharacters(strValue);//Base64.encode(buffer));
}
/**
* Writes the base64-encoded element value.
*
* @param stream the stream
* @throws IOException signals that an I/O exception has occurred
* @throws XMLStreamException the XML stream exception
*/
public void writeBase64ElementValue(InputStream stream) throws IOException,
XMLStreamException {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
byte[] buf = new byte[BufferSize];
try {
for (int readNum; (readNum = stream.read(buf)) != -1; ) {
bos.write(buf, 0, readNum);
}
} catch (IOException ex) {
LOG.error(ex);
} finally {
bos.close();
}
byte[] bytes = bos.toByteArray();
String strValue = Base64.encodeBase64String(bytes);
this.xmlWriter.writeCharacters(strValue);
}
/**
* Gets the internal XML writer.
*
* @return the internal writer
*/
public XMLStreamWriter getInternalWriter() {
return xmlWriter;
}
/**
* Gets the service.
*
* @return The service.
*/
public ExchangeServiceBase getService() {
return service;
}
/**
* Gets a value indicating whether the SOAP message need WSSecurity Utility namespace.
*/
public boolean isRequireWSSecurityUtilityNamespace() {
return requireWSSecurityUtilityNamespace;
}
/**
* Sets a value indicating whether the SOAP message need WSSecurity Utility namespace.
*/
public void setRequireWSSecurityUtilityNamespace(boolean requireWSSecurityUtilityNamespace) {
this.requireWSSecurityUtilityNamespace = requireWSSecurityUtilityNamespace;
}
/**
* Gets a value indicating whether the time zone SOAP header was emitted
* through this writer.
*
* @return true if the time zone SOAP header was emitted; otherwise false.
*/
public boolean isTimeZoneHeaderEmitted() {
return isTimeZoneHeaderEmitted;
}
/**
* Sets a value indicating whether the time zone SOAP header was emitted
* through this writer.
*
* @param isTimeZoneHeaderEmitted true if the time zone SOAP header was emitted; otherwise
* false.
*/
public void setTimeZoneHeaderEmitted(boolean isTimeZoneHeaderEmitted) {
this.isTimeZoneHeaderEmitted = isTimeZoneHeaderEmitted;
}
/**
* Write start document.
*
* @throws XMLStreamException the XML stream exception
*/
public void writeStartDocument() throws XMLStreamException {
this.xmlWriter.writeStartDocument("utf-8", "1.0");
}
}