/*
* 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.ISelfValidate;
import microsoft.exchange.webservices.data.attribute.EwsEnum;
import microsoft.exchange.webservices.data.attribute.RequiredServerVersion;
import microsoft.exchange.webservices.data.core.request.HttpWebRequest;
import microsoft.exchange.webservices.data.core.service.ICreateServiceObjectWithAttachmentParam;
import microsoft.exchange.webservices.data.core.service.ICreateServiceObjectWithServiceParam;
import microsoft.exchange.webservices.data.core.service.ServiceObject;
import microsoft.exchange.webservices.data.core.service.ServiceObjectInfo;
import microsoft.exchange.webservices.data.core.service.item.Item;
import microsoft.exchange.webservices.data.core.enumeration.notification.EventType;
import microsoft.exchange.webservices.data.core.enumeration.misc.ExchangeVersion;
import microsoft.exchange.webservices.data.core.enumeration.service.FileAsMapping;
import microsoft.exchange.webservices.data.core.enumeration.search.ItemTraversal;
import microsoft.exchange.webservices.data.core.enumeration.property.MailboxType;
import microsoft.exchange.webservices.data.core.enumeration.service.MeetingRequestsDeliveryScope;
import microsoft.exchange.webservices.data.core.enumeration.property.RuleProperty;
import microsoft.exchange.webservices.data.core.enumeration.property.WellKnownFolderName;
import microsoft.exchange.webservices.data.core.enumeration.misc.XmlNamespace;
import microsoft.exchange.webservices.data.core.exception.misc.ArgumentException;
import microsoft.exchange.webservices.data.core.exception.misc.ArgumentNullException;
import microsoft.exchange.webservices.data.core.exception.http.EWSHttpException;
import microsoft.exchange.webservices.data.core.exception.misc.FormatException;
import microsoft.exchange.webservices.data.core.exception.service.local.ServiceLocalException;
import microsoft.exchange.webservices.data.core.exception.service.local.ServiceValidationException;
import microsoft.exchange.webservices.data.core.exception.service.local.ServiceVersionException;
import microsoft.exchange.webservices.data.misc.TimeSpan;
import microsoft.exchange.webservices.data.property.complex.ItemAttachment;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.joda.time.Period;
import org.joda.time.format.ISOPeriodFormat;
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.lang.reflect.Field;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.net.URISyntaxException;
import java.text.DateFormat;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.TimeZone;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* EWS utilities.
*/
public final class EwsUtilities {
private static final Log LOG = LogFactory.getLog(EwsUtilities.class);
/**
* The Constant XSFalse.
*/
public static final String XSFalse = "false";
/**
* The Constant XSTrue.
*/
public static final String XSTrue = "true";
/**
* The Constant EwsTypesNamespacePrefix.
*/
public static final String EwsTypesNamespacePrefix = "t";
/**
* The Constant EwsMessagesNamespacePrefix.
*/
public static final String EwsMessagesNamespacePrefix = "m";
/**
* The Constant EwsErrorsNamespacePrefix.
*/
public static final String EwsErrorsNamespacePrefix = "e";
/**
* The Constant EwsSoapNamespacePrefix.
*/
public static final String EwsSoapNamespacePrefix = "soap";
/**
* The Constant EwsXmlSchemaInstanceNamespacePrefix.
*/
public static final String EwsXmlSchemaInstanceNamespacePrefix = "xsi";
/**
* The Constant PassportSoapFaultNamespacePrefix.
*/
public static final String PassportSoapFaultNamespacePrefix = "psf";
/**
* The Constant WSTrustFebruary2005NamespacePrefix.
*/
public static final String WSTrustFebruary2005NamespacePrefix = "wst";
/**
* The Constant WSAddressingNamespacePrefix.
*/
public static final String WSAddressingNamespacePrefix = "wsa";
/**
* The Constant AutodiscoverSoapNamespacePrefix.
*/
public static final String AutodiscoverSoapNamespacePrefix = "a";
/**
* The Constant WSSecurityUtilityNamespacePrefix.
*/
public static final String WSSecurityUtilityNamespacePrefix = "wsu";
/**
* The Constant WSSecuritySecExtNamespacePrefix.
*/
public static final String WSSecuritySecExtNamespacePrefix = "wsse";
/**
* The Constant EwsTypesNamespace.
*/
public static final String EwsTypesNamespace =
"http://schemas.microsoft.com/exchange/services/2006/types";
/**
* The Constant EwsMessagesNamespace.
*/
public static final String EwsMessagesNamespace =
"http://schemas.microsoft.com/exchange/services/2006/messages";
/**
* The Constant EwsErrorsNamespace.
*/
public static final String EwsErrorsNamespace =
"http://schemas.microsoft.com/exchange/services/2006/errors";
/**
* The Constant EwsSoapNamespace.
*/
public static final String EwsSoapNamespace =
"http://schemas.xmlsoap.org/soap/envelope/";
/**
* The Constant EwsSoap12Namespace.
*/
public static final String EwsSoap12Namespace =
"http://www.w3.org/2003/05/soap-envelope";
/**
* The Constant EwsXmlSchemaInstanceNamespace.
*/
public static final String EwsXmlSchemaInstanceNamespace =
"http://www.w3.org/2001/XMLSchema-instance";
/**
* The Constant PassportSoapFaultNamespace.
*/
public static final String PassportSoapFaultNamespace =
"http://schemas.microsoft.com/Passport/SoapServices/SOAPFault";
/**
* The Constant WSTrustFebruary2005Namespace.
*/
public static final String WSTrustFebruary2005Namespace =
"http://schemas.xmlsoap.org/ws/2005/02/trust";
/**
* The Constant WSAddressingNamespace.
*/
public static final String WSAddressingNamespace =
"http://www.w3.org/2005/08/addressing";
// "http://schemas.xmlsoap.org/ws/2004/08/addressing";
/**
* The Constant AutodiscoverSoapNamespace.
*/
public static final String AutodiscoverSoapNamespace =
"http://schemas.microsoft.com/exchange/2010/Autodiscover";
public static final String WSSecurityUtilityNamespace =
"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd";
public static final String WSSecuritySecExtNamespace =
"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd";
/**
* The service object info.
*/
private static final LazyMember<ServiceObjectInfo> SERVICE_OBJECT_INFO =
new LazyMember<ServiceObjectInfo>(
new ILazyMember<ServiceObjectInfo>() {
public ServiceObjectInfo createInstance() {
return new ServiceObjectInfo();
}
}
);
private static final String XML_SCHEMA_DATE_FORMAT = "yyyy-MM-dd'Z'";
private static final String XML_SCHEMA_DATE_TIME_FORMAT = "yyyy-MM-dd'T'HH:mm:ss'Z'";
private static final Pattern PATTERN_TIME_SPAN = Pattern.compile("-P");
private static final Pattern PATTERN_YEAR = Pattern.compile("(\\d+)Y");
private static final Pattern PATTERN_MONTH = Pattern.compile("(\\d+)M");
private static final Pattern PATTERN_DAY = Pattern.compile("(\\d+)D");
private static final Pattern PATTERN_HOUR = Pattern.compile("(\\d+)H");
private static final Pattern PATTERN_MINUTES = Pattern.compile("(\\d+)M");
private static final Pattern PATTERN_SECONDS = Pattern.compile("(\\d+)\\."); // Need to escape dot, otherwise it matches any char
private static final Pattern PATTERN_MILLISECONDS = Pattern.compile("(\\d+)S");
private EwsUtilities() {
throw new UnsupportedOperationException();
}
/**
* Gets the builds the version.
*
* @return the builds the version
*/
public static String getBuildVersion() {
return "0.0.0.0";
}
/**
* The enum version dictionaries.
*/
private static final LazyMember<Map<Class<?>, Map<String, ExchangeVersion>>>
ENUM_VERSION_DICTIONARIES =
new LazyMember<Map<Class<?>, Map<String, ExchangeVersion>>>(
new ILazyMember<Map<Class<?>, Map<String, ExchangeVersion>>>() {
@Override
public Map<Class<?>, Map<String, ExchangeVersion>>
createInstance() {
Map<Class<?>, Map<String, ExchangeVersion>> enumDicts =
new HashMap<Class<?>, Map<String,
ExchangeVersion>>();
enumDicts.put(WellKnownFolderName.class,
buildEnumDict(WellKnownFolderName.class));
enumDicts.put(ItemTraversal.class,
buildEnumDict(ItemTraversal.class));
enumDicts.put(FileAsMapping.class,
buildEnumDict(FileAsMapping.class));
enumDicts.put(EventType.class,
buildEnumDict(EventType.class));
enumDicts.put(MeetingRequestsDeliveryScope.class,
buildEnumDict(MeetingRequestsDeliveryScope.
class));
return enumDicts;
}
});
/**
* Dictionary of enum type to schema-name-to-enum-value maps.
*/
private static final LazyMember<Map<Class<?>, Map<String, String>>>
SCHEMA_TO_ENUM_DICTIONARIES =
new LazyMember<Map<Class<?>, Map<String, String>>>(
new ILazyMember<Map<Class<?>, Map<String, String>>>() {
@Override
public Map<Class<?>, Map<String, String>> createInstance() {
Map<Class<?>, Map<String, String>> enumDicts =
new HashMap<Class<?>, Map<String, String>>();
enumDicts.put(EventType.class,
buildSchemaToEnumDict(EventType.class));
enumDicts.put(MailboxType.class,
buildSchemaToEnumDict(MailboxType.class));
enumDicts.put(FileAsMapping.class,
buildSchemaToEnumDict(FileAsMapping.class));
enumDicts.put(RuleProperty.class,
buildSchemaToEnumDict(RuleProperty.class));
return enumDicts;
}
});
/**
* Dictionary of enum type to enum-value-to-schema-name maps.
*/
public static final LazyMember<Map<Class<?>, Map<String, String>>>
ENUM_TO_SCHEMA_DICTIONARIES =
new LazyMember<Map<Class<?>, Map<String, String>>>(
new ILazyMember<Map<Class<?>, Map<String, String>>>() {
@Override
public Map<Class<?>, Map<String, String>> createInstance() {
Map<Class<?>, Map<String, String>> enumDicts =
new HashMap<Class<?>, Map<String, String>>();
enumDicts.put(EventType.class,
buildEnumToSchemaDict(EventType.class));
enumDicts.put(MailboxType.class,
buildEnumToSchemaDict(MailboxType.class));
enumDicts.put(FileAsMapping.class,
buildEnumToSchemaDict(FileAsMapping.class));
enumDicts.put(RuleProperty.class,
buildEnumToSchemaDict(RuleProperty.class));
return enumDicts;
}
});
/**
* Regular expression for legal domain names.
*/
public static final String DomainRegex = "^[-a-zA-Z0-9_.]+$";
/**
* Asserts that the specified condition if true.
*
* @param condition Assertion.
* @param caller The caller.
* @param message The message to use if assertion fails.
*/
public static void ewsAssert(
final boolean condition, final String caller, final String message
) {
if (!condition) {
throw new RuntimeException(String.format("[%s] %s", caller, message));
}
}
/**
* Gets the namespace prefix from an XmlNamespace enum value.
*
* @param xmlNamespace The XML namespace
* @return Namespace prefix string.
*/
public static String getNamespacePrefix(XmlNamespace xmlNamespace) {
return xmlNamespace.getNameSpacePrefix();
}
/**
* Gets the namespace URI from an XmlNamespace enum value.
*
* @param xmlNamespace The XML namespace.
* @return Uri as string
*/
public static String getNamespaceUri(XmlNamespace xmlNamespace) {
return xmlNamespace.getNameSpaceUri();
}
/**
* Gets the namespace from uri.
*
* @param namespaceUri the namespace uri
* @return the namespace from uri
*/
public static XmlNamespace getNamespaceFromUri(String namespaceUri) {
if (EwsErrorsNamespace.equals(namespaceUri)) {
return XmlNamespace.Errors;
} else if (EwsTypesNamespace.equals(namespaceUri)) {
return XmlNamespace.Types;
} else if (EwsMessagesNamespace.equals(namespaceUri)) {
return XmlNamespace.Messages;
} else if (EwsSoapNamespace.equals(namespaceUri)) {
return XmlNamespace.Soap;
} else if (EwsSoap12Namespace.equals(namespaceUri)) {
return XmlNamespace.Soap12;
} else if (EwsXmlSchemaInstanceNamespace.equals(namespaceUri)) {
return XmlNamespace.XmlSchemaInstance;
} else if (PassportSoapFaultNamespace.equals(namespaceUri)) {
return XmlNamespace.PassportSoapFault;
} else if (WSTrustFebruary2005Namespace.equals(namespaceUri)) {
return XmlNamespace.WSTrustFebruary2005;
} else if (WSAddressingNamespace.equals(namespaceUri)) {
return XmlNamespace.WSAddressing;
} else {
return XmlNamespace.NotSpecified;
}
}
/**
* Creates the ews object from xml element name.
*
* @param <TServiceObject> the generic type
* @param itemClass the item class
* @param service the service
* @param xmlElementName the xml element name
* @return the t service object
* @throws Exception the exception
*/
@SuppressWarnings("unchecked")
public static <TServiceObject extends ServiceObject>
TServiceObject createEwsObjectFromXmlElementName(
Class<?> itemClass, ExchangeService service, String xmlElementName)
throws Exception {
final ServiceObjectInfo member = EwsUtilities.SERVICE_OBJECT_INFO.getMember();
final Map<String, Class<?>> map = member.getXmlElementNameToServiceObjectClassMap();
final Class<?> ic = map.get(xmlElementName);
if (ic != null) {
final Map<Class<?>, ICreateServiceObjectWithServiceParam>
serviceParam = member.getServiceObjectConstructorsWithServiceParam();
final ICreateServiceObjectWithServiceParam creationDelegate =
serviceParam.get(ic);
if (creationDelegate != null) {
return (TServiceObject) creationDelegate
.createServiceObjectWithServiceParam(service);
} else {
throw new IllegalArgumentException("No appropriate constructor could be found for this item class.");
}
}
return (TServiceObject) itemClass.newInstance();
}
/**
* Creates the item from item class.
*
* @param itemAttachment the item attachment
* @param itemClass the item class
* @param isNew the is new
* @return the item
* @throws Exception the exception
*/
public static Item createItemFromItemClass(
ItemAttachment itemAttachment, Class<?> itemClass, boolean isNew)
throws Exception {
final ServiceObjectInfo member = EwsUtilities.SERVICE_OBJECT_INFO.getMember();
final Map<Class<?>, ICreateServiceObjectWithAttachmentParam>
dataMap = member.getServiceObjectConstructorsWithAttachmentParam();
final ICreateServiceObjectWithAttachmentParam creationDelegate =
dataMap.get(itemClass);
if (creationDelegate != null) {
return (Item) creationDelegate
.createServiceObjectWithAttachmentParam(itemAttachment, isNew);
}
throw new IllegalArgumentException("No appropriate constructor could be found for this item class.");
}
/**
* Creates the item from xml element name.
*
* @param itemAttachment the item attachment
* @param xmlElementName the xml element name
* @return the item
* @throws Exception the exception
*/
public static Item createItemFromXmlElementName(
ItemAttachment itemAttachment, String xmlElementName)
throws Exception {
final ServiceObjectInfo member = EwsUtilities.SERVICE_OBJECT_INFO.getMember();
final Map<String, Class<?>> map =
member.getXmlElementNameToServiceObjectClassMap();
final Class<?> itemClass = map.get(xmlElementName);
if (itemClass != null) {
return createItemFromItemClass(itemAttachment, itemClass, false);
}
return null;
}
public static Class<?> getItemTypeFromXmlElementName(String xmlElementName) {
final ServiceObjectInfo member = EwsUtilities.SERVICE_OBJECT_INFO.getMember();
final Map<String, Class<?>> map = member.getXmlElementNameToServiceObjectClassMap();
return map.get(xmlElementName);
}
/**
* Finds the first item of type TItem (not a descendant type) in the
* specified collection.
*
* @param <TItem> TItem is the type of the item to find.
* @param cls the cls
* @param items the item
* @return A TItem instance or null if no instance of TItem could be found.
*/
@SuppressWarnings("unchecked")
public static <TItem extends Item> TItem findFirstItemOfType(
Class<TItem> cls, Iterable<Item> items
) {
for (Item item : items) {
// We're looking for an exact class match here.
final Class<? extends Item> itemClass = item.getClass();
if (itemClass.equals(cls)) {
return (TItem) item;
}
}
return null;
}
/**
* Write trace start element.
*
* @param writer the writer to write the start element to
* @param traceTag the trace tag
* @param includeVersion if true, include build version attribute
* @throws XMLStreamException the XML stream exception
*/
private static void writeTraceStartElement(
XMLStreamWriter writer,
String traceTag,
boolean includeVersion) throws XMLStreamException {
writer.writeStartElement("Trace");
writer.writeAttribute("Tag", traceTag);
writer.writeAttribute("Tid", Thread.currentThread().getId() + "");
Date d = new Date();
DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss'Z'");
df.setTimeZone(TimeZone.getTimeZone("UTC"));
String formattedString = df.format(d);
writer.writeAttribute("Time", formattedString);
if (includeVersion) {
writer.writeAttribute("Version", EwsUtilities.getBuildVersion());
}
}
/**
* .
*
* @param entryKind the entry kind
* @param logEntry the log entry
* @return the string
* @throws XMLStreamException the XML stream exception
* @throws IOException signals that an I/O exception has occurred.
*/
public static String formatLogMessage(String entryKind, String logEntry)
throws XMLStreamException, IOException {
String lineSeparator = System.getProperty("line.separator");
ByteArrayOutputStream outStream = new ByteArrayOutputStream();
XMLOutputFactory factory = XMLOutputFactory.newInstance();
XMLStreamWriter writer = factory.createXMLStreamWriter(outStream);
EwsUtilities.writeTraceStartElement(writer, entryKind, false);
writer.writeCharacters(lineSeparator);
writer.writeCharacters(logEntry);
writer.writeCharacters(lineSeparator);
writer.writeEndElement();
writer.writeCharacters(lineSeparator);
writer.flush();
writer.close();
outStream.flush();
String formattedLogMessage = outStream.toString();
formattedLogMessage = formattedLogMessage.replaceAll("'", "'");
formattedLogMessage = formattedLogMessage.replaceAll(""", "\"");
formattedLogMessage = formattedLogMessage.replaceAll(">", ">");
formattedLogMessage = formattedLogMessage.replaceAll("<", "<");
formattedLogMessage = formattedLogMessage.replaceAll("&", "&");
outStream.close();
return formattedLogMessage;
}
/**
* Format http response headers.
*
* @param response the response
* @return the string
* @throws EWSHttpException the EWS http exception
*/
public static String formatHttpResponseHeaders(HttpWebRequest response)
throws EWSHttpException {
final int code = response.getResponseCode();
final String contentType = response.getResponseContentType();
final Map<String, String> headers = response.getResponseHeaders();
return code + " " + contentType + "\n"
+ EwsUtilities.formatHttpHeaders(headers) + "\n";
}
/**
* Format request HTTP headers.
*
* @param request The HTTP request.
*/
public static String formatHttpRequestHeaders(HttpWebRequest request)
throws URISyntaxException, EWSHttpException {
final String method = request.getRequestMethod().toUpperCase();
final String path = request.getUrl().toURI().getPath();
final Map<String, String> property = request.getRequestProperty();
final String headers = EwsUtilities.formatHttpHeaders(property);
return String.format("%s %s HTTP/%s\n", method, path, "1.1") + headers + "\n";
}
/**
* Formats HTTP headers.
*
* @param headers The headers.
* @return Headers as a string
*/
private static String formatHttpHeaders(Map<String, String> headers) {
StringBuilder sb = new StringBuilder();
for (Map.Entry<String, String> header : headers.entrySet()) {
sb.append(String.format("%s : %s\n", header.getKey(), header.getValue()));
}
return sb.toString();
}
/**
* Format XML content in a MemoryStream for message.
*
* @param traceTypeStr Kind of the entry.
* @param stream The memory stream.
* @return XML log entry as a string.
*/
public static String formatLogMessageWithXmlContent(String traceTypeStr,
ByteArrayOutputStream stream) {
try {
return formatLogMessage(traceTypeStr, stream.toString());
} catch (Exception e) {
return stream.toString();
}
}
/**
* Convert bool to XML Schema bool.
*
* @param value Bool value.
* @return String representing bool value in XML Schema.
*/
public static String boolToXSBool(Boolean value) {
return value ? EwsUtilities.XSTrue : EwsUtilities.XSFalse;
}
/**
* Parses an enum value list.
*
* @param <T> the generic type
* @param c the c
* @param list the list
* @param value the value
* @param separators the separators
*/
public static <T extends Enum<?>> void parseEnumValueList(Class<T> c,
List<T> list, String value, char... separators) {
EwsUtilities.ewsAssert(c.isEnum(), "EwsUtilities.ParseEnumValueList", "T is not an enum type.");
StringBuilder regexp = new StringBuilder();
regexp.append("[");
for (char s : separators) {
regexp.append("[");
regexp.append(Pattern.quote(s + ""));
regexp.append("]");
}
regexp.append("]");
String[] enumValues = value.split(regexp.toString());
for (String enumValue : enumValues) {
for (T o : c.getEnumConstants()) {
if (o.toString().equals(enumValue)) {
list.add(o);
}
}
}
}
/**
* Converts an enum to a string, using the mapping dictionaries if
* appropriate.
*
* @param value The enum value to be serialized
* @return String representation of enum to be used in the protocol
*/
public static String serializeEnum(Object value) {
String strValue = value.toString();
final Map<Class<?>, Map<String, String>> member =
ENUM_TO_SCHEMA_DICTIONARIES.getMember();
final Map<String, String> enumToStringDict = member.get(value.getClass());
if (enumToStringDict != null) {
final Enum<?> e = (Enum<?>) value;
final String enumStr = enumToStringDict.get(e.name());
if (enumStr != null) {
strValue = enumStr;
}
}
return strValue;
}
/**
* Parses the.
*
* @param <T> the generic type
* @param cls the cls
* @param value the value
* @return the t
* @throws java.text.ParseException the parse exception
*/
@SuppressWarnings("unchecked")
public static <T> T parse(Class<T> cls, String value) throws ParseException {
if (cls.isEnum()) {
final Map<Class<?>, Map<String, String>> member = SCHEMA_TO_ENUM_DICTIONARIES.getMember();
String val = value;
final Map<String, String> stringToEnumDict = member.get(cls);
if (stringToEnumDict != null) {
final String strEnumName = stringToEnumDict.get(value);
if (strEnumName != null) {
val = strEnumName;
}
}
for (T o : cls.getEnumConstants()) {
if (o.toString().equals(val)) {
return o;
}
}
return null;
}else if (Number.class.isAssignableFrom(cls)){
if (Double.class.isAssignableFrom(cls)){
return (T) ((Double) Double.parseDouble(value));
}else if (Integer.class.isAssignableFrom(cls)) {
return (T) ((Integer) Integer.parseInt(value));
}else if (Long.class.isAssignableFrom(cls)){
return (T) ((Long) Long.parseLong(value));
}else if (Float.class.isAssignableFrom(cls)){
return (T) ((Float) Float.parseFloat(value));
}else if (Byte.class.isAssignableFrom(cls)){
return (T) ((Byte) Byte.parseByte(value));
}else if (Short.class.isAssignableFrom(cls)){
return (T) ((Short) Short.parseShort(value));
}else if (BigInteger.class.isAssignableFrom(cls)){
return (T) (new BigInteger(value));
}else if (BigDecimal.class.isAssignableFrom(cls)){
return (T) (new BigDecimal(value));
}
} else if (Date.class.isAssignableFrom(cls)) {
DateFormat df = createDateFormat(XML_SCHEMA_DATE_TIME_FORMAT);
return (T) df.parse(value);
} else if (Boolean.class.isAssignableFrom(cls)) {
return (T) ((Boolean) Boolean.parseBoolean(value));
} else if (String.class.isAssignableFrom(cls)) {
return (T) value;
}
return null;
}
/**
* Builds the schema to enum mapping dictionary.
*
* @param <E> Type of the enum.
* @param c Class
* @return The mapping from enum to schema name
*/
private static <E extends Enum<E>> Map<String, String>
buildSchemaToEnumDict(Class<E> c) {
Map<String, String> dict = new HashMap<String, String>();
Field[] fields = c.getDeclaredFields();
for (Field f : fields) {
if (f.isEnumConstant() && f.isAnnotationPresent(EwsEnum.class)) {
EwsEnum ewsEnum = f.getAnnotation(EwsEnum.class);
String fieldName = f.getName();
String schemaName = ewsEnum.schemaName();
if (!schemaName.isEmpty()) {
dict.put(schemaName, fieldName);
}
}
}
return dict;
}
/**
* Validate param collection.
*
* @param eventTypes the event types
* @param paramName the param name
* @throws Exception the exception
*/
public static void validateParamCollection(EventType[] eventTypes,
String paramName) throws Exception {
validateParam(eventTypes, paramName);
int count = 0;
for (EventType event : eventTypes) {
try {
validateParam(event, String.format("collection[%d] , ", count));
} catch (Exception e) {
throw new IllegalArgumentException(String.format(
"The element at position %d is invalid", count), e);
}
count++;
}
if (count == 0) {
throw new IllegalArgumentException(
String.format("The collection \"%s\" is empty.", paramName)
);
}
}
/**
* Convert DateTime to XML Schema date.
*
* @param date the date
* @return String representation of DateTime.
*/
public static String dateTimeToXSDate(Date date) {
return formatDate(date, XML_SCHEMA_DATE_FORMAT);
}
/**
* Dates the DateTime into an XML schema date time.
*
* @param date the date
* @return String representation of DateTime.
*/
public static String dateTimeToXSDateTime(Date date) {
return formatDate(date, XML_SCHEMA_DATE_TIME_FORMAT);
}
/**
* Takes a System.TimeSpan structure and converts it into an xs:duration
* string as defined by the W3 Consortiums Recommendation
* "XML Schema Part 2: Datatypes Second Edition",
* http://www.w3.org/TR/xmlschema-2/#duration
*
* @param timeOffset structure to convert
* @return xs:duration formatted string
*/
public static String getTimeSpanToXSDuration(TimeSpan timeOffset) {
// Optional '-' offset
String offsetStr = (timeOffset.getTotalSeconds() < 0) ? "-" : "";
long days = Math.abs(timeOffset.getDays());
long hours = Math.abs(timeOffset.getHours());
long minutes = Math.abs(timeOffset.getMinutes());
long seconds = Math.abs(timeOffset.getSeconds());
long milliseconds = Math.abs(timeOffset.getMilliseconds());
// The TimeSpan structure does not have a Year or Month
// property, therefore we wouldn't be able to return an xs:duration
// string from a TimeSpan that included the nY or nM components.
return offsetStr + "P" + days + "DT" + hours + "H" + minutes + "M"
+ seconds + "." + milliseconds + "S";
}
/**
* Takes an xs:duration string as defined by the W3 Consortiums
* Recommendation "XML Schema Part 2: Datatypes Second Edition",
* http://www.w3.org/TR/xmlschema-2/#duration, and converts it into a
* System.TimeSpan structure This method uses the following approximations:
* 1 year = 365 days 1 month = 30 days Additionally, it only allows for four
* decimal points of seconds precision.
*
* @param xsDuration xs:duration string to convert
* @return System.TimeSpan structure
*/
public static TimeSpan getXSDurationToTimeSpan(String xsDuration) {
// TODO: Need to check whether this should be the equivalent or not
Matcher m = PATTERN_TIME_SPAN.matcher(xsDuration);
boolean negative = false;
if (m.find()) {
negative = true;
}
// Removing leading '-'
if (negative) {
xsDuration = xsDuration.replace("-P", "P");
}
Period period = Period.parse(xsDuration, ISOPeriodFormat.standard());
long retval = period.toStandardDuration().getMillis();
if (negative) {
retval = -retval;
}
return new TimeSpan(retval);
}
/**
* Time span to xs time.
*
* @param timeSpan the time span
* @return the string
*/
public static String timeSpanToXSTime(TimeSpan timeSpan) {
DecimalFormat myFormatter = new DecimalFormat("00");
return String.format("%s:%s:%s", myFormatter.format(timeSpan.getHours()), myFormatter.format(timeSpan
.getMinutes()), myFormatter.format(timeSpan.getSeconds()));
}
/**
* Gets the domain name from an email address.
*
* @param emailAddress The email address.
* @return Domain name.
* @throws FormatException the format exception
*/
public static String domainFromEmailAddress(String emailAddress)
throws FormatException {
String[] emailAddressParts = emailAddress.split("@");
if (emailAddressParts.length != 2
|| (emailAddressParts[1] == null || emailAddressParts[1]
.isEmpty())) {
throw new FormatException("The e-mail address is formed incorrectly.");
}
return emailAddressParts[1];
}
public static int getDim(Object array) {
int dim = 0;
Class<?> c = array.getClass();
while (c.isArray()) {
c = c.getComponentType();
dim++;
}
return (dim);
}
/**
* Validates parameter (and allows null value).
*
* @param param The param.
* @param paramName Name of the param.
* @throws Exception the exception
*/
public static void validateParamAllowNull(Object param, String paramName)
throws Exception {
if (param instanceof ISelfValidate) {
ISelfValidate selfValidate = (ISelfValidate) param;
try {
selfValidate.validate();
} catch (ServiceValidationException e) {
throw new Exception(String.format("%s %s", "Validation failed.", paramName), e);
}
}
if (param instanceof ServiceObject) {
ServiceObject ewsObject = (ServiceObject) param;
if (ewsObject.isNew()) {
throw new Exception(String.format("%s %s", "This service object doesn't have an ID.", paramName));
}
}
}
/**
* Validates parameter (null value not allowed).
*
* @param param The param.
* @param paramName Name of the param.
* @throws Exception the exception
*/
public static void validateParam(Object param, String paramName) throws Exception {
boolean isValid;
if (param instanceof String) {
String strParam = (String) param;
isValid = !strParam.isEmpty();
} else {
isValid = param != null;
}
if (!isValid) {
throw new Exception(String.format("Argument %s not valid",
paramName));
}
validateParamAllowNull(param, paramName);
}
/**
* Validates parameter collection.
*
* @param <T> the generic type
* @param collection The collection.
* @param paramName Name of the param.
* @throws Exception the exception
*/
public static <T> void validateParamCollection(Iterator<T> collection, String paramName) throws Exception {
validateParam(collection, paramName);
int count = 0;
while (collection.hasNext()) {
T obj = collection.next();
try {
validateParam(obj, String.format("collection[%d],", count));
} catch (Exception e) {
throw new IllegalArgumentException(String.format(
"The element at position %d is invalid", count), e);
}
count++;
}
if (count == 0) {
throw new IllegalArgumentException(
String.format("The collection \"%s\" is empty.", paramName)
);
}
}
/**
* Validates string parameter to be non-empty string (null value allowed).
*
* @param param The string parameter.
* @param paramName Name of the parameter.
* @throws ArgumentException
* @throws ServiceLocalException
*/
public static void validateNonBlankStringParamAllowNull(String param,
String paramName) throws ArgumentException, ServiceLocalException {
if (param != null) {
// Non-empty string has at least one character
//which is *not* a whitespace character
if (param.length() == countMatchingChars(param,
new IPredicate<Character>() {
@Override
public boolean predicate(Character obj) {
return Character.isWhitespace(obj);
}
})) {
throw new ArgumentException("The string argument contains only white space characters.", paramName);
}
}
}
/**
* Validates string parameter to be
* non-empty string (null value not allowed).
*
* @param param The string parameter.
* @param paramName Name of the parameter.
* @throws ArgumentNullException
* @throws ArgumentException
* @throws ServiceLocalException
*/
public static void validateNonBlankStringParam(String param,
String paramName) throws ArgumentNullException, ArgumentException, ServiceLocalException {
if (param == null) {
throw new ArgumentNullException(paramName);
}
validateNonBlankStringParamAllowNull(param, paramName);
}
/**
* Validate enum version value.
*
* @param enumValue the enum value
* @param requestVersion the request version
* @throws ServiceVersionException the service version exception
*/
public static void validateEnumVersionValue(Enum<?> enumValue,
ExchangeVersion requestVersion) throws ServiceVersionException {
final Map<Class<?>, Map<String, ExchangeVersion>> member =
ENUM_VERSION_DICTIONARIES.getMember();
final Map<String, ExchangeVersion> enumVersionDict =
member.get(enumValue.getClass());
final ExchangeVersion enumVersion = enumVersionDict.get(enumValue.toString());
if (enumVersion != null) {
final int i = requestVersion.compareTo(enumVersion);
if (i < 0) {
throw new ServiceVersionException(
String.format(
"Enumeration value %s in enumeration type %s is only valid for Exchange version %s or later.",
enumValue.toString(),
enumValue.getClass().getName(),
enumVersion
)
);
}
}
}
/**
* Validates service object version against the request version.
*
* @param serviceObject The service object.
* @param requestVersion The request version.
* @throws ServiceVersionException Raised if this service object type requires a later version
* of Exchange.
*/
public static void validateServiceObjectVersion(
ServiceObject serviceObject, ExchangeVersion requestVersion)
throws ServiceVersionException {
ExchangeVersion minimumRequiredServerVersion = serviceObject
.getMinimumRequiredServerVersion();
if (requestVersion.ordinal() < minimumRequiredServerVersion.ordinal()) {
String msg = String.format(
"The object type %s is only valid for Exchange Server version %s or later versions.",
serviceObject.getClass().getName(), minimumRequiredServerVersion.toString());
throw new ServiceVersionException(msg);
}
}
/**
* Validates property version against the request version.
*
* @param service The Exchange service.
* @param minimumServerVersion The minimum server version
* @param propertyName The property name
* @throws ServiceVersionException The service version exception
*/
public static void validatePropertyVersion(
ExchangeService service,
ExchangeVersion minimumServerVersion,
String propertyName) throws ServiceVersionException {
if (service.getRequestedServerVersion().ordinal() <
minimumServerVersion.ordinal()) {
throw new ServiceVersionException(
String.format("The property %s is valid only for Exchange %s or later versions.",
propertyName,
minimumServerVersion));
}
}
/**
* Validate method version.
*
* @param service the service
* @param minimumServerVersion the minimum server version
* @param methodName the method name
* @throws ServiceVersionException the service version exception
*/
public static void validateMethodVersion(ExchangeService service,
ExchangeVersion minimumServerVersion, String methodName)
throws ServiceVersionException {
if (service.getRequestedServerVersion().ordinal() <
minimumServerVersion.ordinal())
{
throw new ServiceVersionException(String.format(
"Method %s is only valid for Exchange Server version %s or later.", methodName,
minimumServerVersion));
}
}
/**
* Validates class version against the request version.
*
* @param service the service
* @param minimumServerVersion The minimum server version that supports the method.
* @param className Name of the class.
* @throws ServiceVersionException
*/
public static void validateClassVersion(
ExchangeService service,
ExchangeVersion minimumServerVersion,
String className) throws ServiceVersionException {
if (service.getRequestedServerVersion().ordinal() <
minimumServerVersion.ordinal()) {
throw new ServiceVersionException(
String.format("Class %s is only valid for Exchange version %s or later.",
className,
minimumServerVersion));
}
}
/**
* Validates domain name (null value allowed)
*
* @param domainName Domain name.
* @param paramName Parameter name.
* @throws ArgumentException
*/
public static void validateDomainNameAllowNull(String domainName, String paramName) throws
ArgumentException {
if (domainName != null) {
Pattern domainNamePattern = Pattern.compile(DomainRegex);
Matcher domainNameMatcher = domainNamePattern.matcher(domainName);
if (!domainNameMatcher.find()) {
throw new ArgumentException(String.format("'%s' is not a valid domain name.", domainName), paramName);
}
}
}
/**
* Builds the enum dict.
*
* @param <E> the element type
* @param c the c
* @return the map
*/
private static <E extends Enum<E>> Map<String, ExchangeVersion>
buildEnumDict(Class<E> c) {
Map<String, ExchangeVersion> dict =
new HashMap<String, ExchangeVersion>();
Field[] fields = c.getDeclaredFields();
for (Field f : fields) {
if (f.isEnumConstant()
&& f.isAnnotationPresent(RequiredServerVersion.class)) {
RequiredServerVersion ewsEnum = f
.getAnnotation(RequiredServerVersion.class);
String fieldName = f.getName();
ExchangeVersion exchangeVersion = ewsEnum.version();
dict.put(fieldName, exchangeVersion);
}
}
return dict;
}
/**
* Builds the enum to schema mapping dictionary.
*
* @param c class type
* @return The mapping from enum to schema name
*/
private static Map<String, String> buildEnumToSchemaDict(Class<?> c) {
Map<String, String> dict = new HashMap<String, String>();
Field[] fields = c.getFields();
for (Field f : fields) {
if (f.isEnumConstant() && f.isAnnotationPresent(EwsEnum.class)) {
EwsEnum ewsEnum = f.getAnnotation(EwsEnum.class);
String fieldName = f.getName();
String schemaName = ewsEnum.schemaName();
if (!schemaName.isEmpty()) {
dict.put(fieldName, schemaName);
}
}
}
return dict;
}
/**
* Gets the enumerated object count.
*
* @param <T> the generic type
* @param objects The objects.
* @return Count of objects in iterator.
*/
public static <T> int getEnumeratedObjectCount(Iterator<T> objects) {
int count = 0;
while (objects != null && objects.hasNext()) {
objects.next();
count++;
}
return count;
}
/**
* Gets the enumerated object at.
*
* @param <T> the generic type
* @param objects the objects
* @param index the index
* @return the enumerated object at
*/
public static <T> Object getEnumeratedObjectAt(Iterable<T> objects, int index) {
int count = 0;
for (Object obj : objects) {
if (count == index) {
return obj;
}
count++;
}
throw new IndexOutOfBoundsException("The IEnumerable doesn't contain that many objects.");
}
/**
* Count characters in string that match a condition.
*
* @param str The string.
* @param charPredicate Predicate to evaluate for each character in the string.
* @return Count of characters that match condition expressed by predicate.
* @throws ServiceLocalException
*/
public static int countMatchingChars(
String str, IPredicate<Character> charPredicate
) throws ServiceLocalException {
int count = 0;
for (int i = 0; i < str.length(); i++) {
if (charPredicate.predicate(str.charAt(i))) {
count++;
}
}
return count;
}
/**
* Determines whether every element in the collection
* matches the conditions defined by the specified predicate.
*
* @param <T> Entry type.
* @param collection The collection.
* @param predicate Predicate that defines the conditions to check against the elements.
* @return True if every element in the collection matches
* the conditions defined by the specified predicate; otherwise, false.
* @throws ServiceLocalException
*/
public static <T> boolean trueForAll(Iterable<T> collection,
IPredicate<T> predicate) throws ServiceLocalException {
for (T entry : collection) {
if (!predicate.predicate(entry)) {
return false;
}
}
return true;
}
/**
* Call an action for each member of a collection.
*
* @param <T> Collection element type.
* @param collection The collection.
* @param action The action to apply.
*/
public static <T> void forEach(Iterable<T> collection, IAction<T> action) {
for (T entry : collection) {
action.action(entry);
}
}
private static String formatDate(Date date, String format) {
final DateFormat utcFormatter = createDateFormat(format);
return utcFormatter.format(date);
}
private static DateFormat createDateFormat(String format) {
final DateFormat utcFormatter = new SimpleDateFormat(format);
utcFormatter.setTimeZone(TimeZone.getTimeZone("UTC"));
return utcFormatter;
}
}