Java tutorial
package com.cloudhopper.sxmp; /* * #%L * ch-sxmp * %% * Copyright (C) 2012 - 2013 Cloudhopper by Twitter * %% * Licensed 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. * #L% */ import com.cloudhopper.commons.util.HexUtil; import com.cloudhopper.sxmp.util.MobileAddressUtil; import com.cloudhopper.commons.util.StringUtil; import java.io.IOException; import java.io.InputStream; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.Map; import javax.xml.XMLConstants; import javax.xml.parsers.ParserConfigurationException; import javax.xml.parsers.SAXParser; import javax.xml.parsers.SAXParserFactory; import org.apache.commons.lang.StringEscapeUtils; import org.apache.commons.lang.StringUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.joda.time.DateTime; import org.joda.time.DateTimeZone; import org.joda.time.format.DateTimeFormat; import org.joda.time.format.DateTimeFormatter; import org.joda.time.format.ISODateTimeFormat; import org.json.JSONObject; import org.json.JSONException; import org.xml.sax.*; import org.xml.sax.ext.Locator2; import org.xml.sax.helpers.DefaultHandler; /** * * @author joelauer */ public class SxmpParser { private static final Logger logger = LoggerFactory.getLogger(SxmpParser.class); static protected DateTimeFormatter dateTimeFormat = ISODateTimeFormat.dateTime().withZone(DateTimeZone.UTC); public static final String VERSION_1_0 = "1.0"; public static final String VERSION_1_1 = "1.1"; public static final String VERSION_1_2 = "1.2"; protected final String version; // for backwards compatibility public SxmpParser() { this.version = VERSION_1_0; } public SxmpParser(final String version) { this.version = version; } /** public Node parse(InputSource source) throws IOException, SAXException { // _dtd=null; Handler handler = new Handler(); XMLReader reader = _parser.getXMLReader(); reader.setContentHandler(handler); reader.setErrorHandler(handler); reader.setEntityResolver(handler); if (logger.isDebugEnabled()) logger.debug("parsing: sid=" + source.getSystemId() + ",pid=" + source.getPublicId()); _parser.parse(source, handler); if (handler.error != null) throw handler.error; Node root = (Node)handler.root; handler.reset(); return root; } public synchronized Node parse(String xml) throws IOException, SAXException { ByteArrayInputStream is = new ByteArrayInputStream(xml.getBytes()); return parse(is); } public synchronized Node parse(File file) throws IOException, SAXException { return parse(new InputSource(file.toURI().toURL().toString())); } public synchronized Node parse(InputStream in) throws IOException, SAXException { //_dtd=null; Handler handler = new Handler(); XMLReader reader = _parser.getXMLReader(); reader.setContentHandler(handler); reader.setErrorHandler(handler); reader.setEntityResolver(handler); _parser.parse(new InputSource(in), handler); if (handler.error != null) throw handler.error; Node root = (Node)handler.root; handler.reset(); return root; } */ public Operation parse(InputStream in) throws SxmpParsingException, IOException, SAXException, ParserConfigurationException { // create a new SAX parser SAXParserFactory factory = SAXParserFactory.newInstance(); //factory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true); SAXParser parser = factory.newSAXParser(); //_parser.getXMLReader().setFeature("http://xml.org/sax/features/validation", validating); parser.getXMLReader().setFeature("http://xml.org/sax/features/namespaces", true); parser.getXMLReader().setFeature("http://xml.org/sax/features/namespace-prefixes", true); parser.getXMLReader().setFeature("http://javax.xml.XMLConstants/feature/secure-processing", true); //_dtd=null; Handler handler = new Handler(); XMLReader reader = parser.getXMLReader(); reader.setContentHandler(handler); reader.setErrorHandler(handler); reader.setEntityResolver(handler); // try parsing (may throw an SxmpParsingException in the handler) try { parser.parse(new InputSource(in), handler); } catch (com.sun.org.apache.xerces.internal.impl.io.MalformedByteSequenceException e) { throw new SxmpParsingException(SxmpErrorCode.INVALID_XML, "XML encoding mismatch", null); } // check if there was an error if (handler.error != null) { throw handler.error; } // check to see if an operation was actually parsed if (handler.getOperation() == null) { throw new SxmpParsingException(SxmpErrorCode.MISSING_REQUIRED_ELEMENT, "The operation type [" + handler.operationType.getValue() + "] requires a request element", new PartialOperation(handler.operationType)); } // if we got here, an operation was parsed -- now we need to validate it // to make sure that it has all required elements try { handler.getOperation().validate(); } catch (SxmpErrorException e) { throw new SxmpParsingException(e.getErrorCode(), e.getErrorMessage(), handler.getOperation()); } return handler.getOperation(); } private class Handler extends DefaultHandler { SAXParseException error; private int depth; Attributes currentAttrs; StringBuilder charBuffer; Operation.Type operationType; Account account; Application application; Operation operation; // we'll use this hashmap for duplicate element checks HashSet<String> elements; private String encoding = "unknown"; private Locator2 locator; /* * Per http://xerces.apache.org/xerces2-j/javadocs/api/org/xml/sax/ContentHandler.html#setDocumentLocator%28org.xml.sax.Locator%29 * Note that the locator will return correct information only during the * invocation SAX event callbacks after startDocument returns and before * endDocument is called. The application should not attempt to use it * at any other time. */ @Override public void setDocumentLocator(Locator locator) { if (locator instanceof Locator2) { this.locator = (Locator2) locator; } } // utility class to hold error code and message private class ErrorCodeMessage { public int code; public String message; } Handler() { depth = -1; charBuffer = new StringBuilder(200); this.elements = new HashSet<String>(); } /** * Gets the value from a required attribute. This method will provide * the following error checking. If the attribute is missing, it will * throw a MISSING_ATTRIBUTE exception. If the attribute was included, * but the value was empty, it will throw an EMPTY_VALUE exception. * Otherwise, it will return the value. * @param attr The attributes to check * @param name The attribute name to find * @return The value * @throws SxmpErrorException See method overview */ public String getOptionalAttributeValue(String tag, Attributes attrs, String name) throws SxmpParsingException { // // make sure the attribute exists // int size = attrs.getLength(); String value = null; for (int i = 0; i < size; i++) { if (attrs.getQName(i).equals(name)) { // is this the second time we found this attribute? if (value != null) { throw new SxmpParsingException(SxmpErrorCode.MULTIPLE_ATTRIBUTES_NOT_SUPPORTED, "Multiple [" + name + "] attributes within the [" + tag + "] element are not supported", (this.operation != null ? this.operation : new PartialOperation(this.operationType))); } value = attrs.getValue(i); // is there some sort of value for it? if (StringUtil.isEmpty(value)) { throw new SxmpParsingException(SxmpErrorCode.EMPTY_VALUE, "The [" + name + "] attribute was empty in the [" + tag + "] element", (this.operation != null ? this.operation : new PartialOperation(this.operationType))); } } } if (value != null) { return value; } else { return null; } } /** * Gets the value from a required attribute. This method will provide * the following error checking. If the attribute is missing, it will * throw a MISSING_ATTRIBUTE exception. If the attribute was included, * but the value was empty, it will throw an EMPTY_VALUE exception. * Otherwise, it will return the value. * @param attr The attributes to check * @param name The attribute name to find * @return The value * @throws SxmpErrorException See method overview */ public String getRequiredAttributeValue(String tag, Attributes attrs, String name) throws SxmpParsingException { // // same process as an optional element // String value = getOptionalAttributeValue(tag, attrs, name); if (value != null) { return value; } else { throw new SxmpParsingException(SxmpErrorCode.MISSING_REQUIRED_ATTRIBUTE, "The attribute [" + name + "] is required with the [" + tag + "] element", (this.operation != null ? this.operation : new PartialOperation(this.operationType))); } } public void parseRequestElement(String tag, Request request, Attributes attrs) throws SxmpParsingException { // should only occur once if (elements.contains(tag)) { // we already had the same operation before, so we'll include that in the error throw new SxmpParsingException(SxmpErrorCode.MULTIPLE_ELEMENTS_NOT_SUPPORTED, "Multiple [" + tag + "] elements are not supported", this.operation); } // add the element tag to something we visited elements.add(tag); // an account must ALWAYS come before a request if (this.account == null) { throw new SxmpParsingException(SxmpErrorCode.MISSING_REQUIRED_ELEMENT, "The [account] element is required before a [" + tag + "] element", new PartialOperation(this.operationType)); } // check if the request type matches the operation type if (request.getType() != this.operationType) { throw new SxmpParsingException( SxmpErrorCode.OPTYPE_MISMATCH, "The operation type [" + operationType.getValue() + "] does not match the [" + tag + "] element", new PartialOperation(this.operationType)); } // save the account in this request request.setAccount(this.account); request.setApplication(this.application); // save the request as our operation this.operation = request; // all requests have an optional referenceId attribute String referenceId = getOptionalAttributeValue("submitRequest", attrs, "referenceId"); if (!StringUtil.isEmpty(referenceId)) { try { request.setReferenceId(referenceId); } catch (SxmpErrorException e) { throw new SxmpParsingException(SxmpErrorCode.INVALID_REFERENCE_ID, e.getErrorMessage(), this.operation); } } } public void parseResponseElement(String tag, Response response) throws SxmpParsingException { // should only occur once if (elements.contains(tag)) { // we already had the same operation before, so we'll include that in the error throw new SxmpParsingException(SxmpErrorCode.MULTIPLE_ELEMENTS_NOT_SUPPORTED, "Multiple [" + tag + "] elements are not supported", this.operation); } // add the element tag to something we visited elements.add(tag); // check if the request type matches the operation type if (response.getType() != this.operationType) { throw new SxmpParsingException( SxmpErrorCode.OPTYPE_MISMATCH, "The operation type [" + operationType.getValue() + "] does not match the [" + tag + "] element", new PartialOperation(this.operationType)); } // save the request as our operation this.operation = response; } public String parseCharacterData(String tag, boolean required) throws SxmpParsingException { // should only occur once if (elements.contains(tag)) { throw new SxmpParsingException(SxmpErrorCode.MULTIPLE_ELEMENTS_NOT_SUPPORTED, "Multiple [" + tag + "] elements are not supported", this.operation); } // add the element tag to something we visisted elements.add(tag); // should be able to convert character data to an integer String text = charBuffer.toString(); if (required && StringUtil.isEmpty(text)) { throw new SxmpParsingException(SxmpErrorCode.EMPTY_VALUE, "The element [" + tag + "] must contain a value", this.operation); } return text; } public Integer parseIntegerValue(String name, String value) throws SxmpParsingException { // convert to an integer try { return Integer.valueOf(value); } catch (NumberFormatException e) { throw new SxmpParsingException(SxmpErrorCode.UNABLE_TO_CONVERT_VALUE, "Unable to convert [" + value + "] to an integer for [" + name + "]", this.operation); } } public Boolean parseBooleanValue(String name, String value) throws SxmpParsingException { // convert to a boolean if (value == null) { throw new SxmpParsingException(SxmpErrorCode.UNABLE_TO_CONVERT_VALUE, "Unable to convert [null] to a boolean for [" + name + "]", this.operation); } if (value.equalsIgnoreCase("true")) { return Boolean.TRUE; } else if (value.equalsIgnoreCase("false")) { return Boolean.FALSE; } else { throw new SxmpParsingException(SxmpErrorCode.UNABLE_TO_CONVERT_VALUE, "Unable to convert [" + value + "] to a boolean for [" + name + "]", this.operation); } } public ErrorCodeMessage parseErrorElement(String tag, Attributes attrs) throws SxmpParsingException { // should only occur once at this level if (elements.contains(tag)) { throw new SxmpParsingException(SxmpErrorCode.MULTIPLE_ELEMENTS_NOT_SUPPORTED, "Multiple [" + tag + "] elements are not supported", this.operation); } // add the element tag to something we visisted elements.add(tag); ErrorCodeMessage ecm = new ErrorCodeMessage(); String errorCodeString = this.getRequiredAttributeValue("error", currentAttrs, "code"); ecm.message = this.getRequiredAttributeValue("error", currentAttrs, "message"); ecm.code = this.parseIntegerValue("code", errorCodeString); return ecm; } public Operation getOperation() { return this.operation; } @Override public void processingInstruction(String target, String value) { //logger.debug("processing instr!"); } @Override public void startElement(String uri, String localName, String qName, Attributes attrs) throws SAXException { // // get the tag stripped of any namespace // String tag = (StringUtil.isEmpty(uri)) ? qName : localName; // debug //logger.debug("startElement: tag=" + tag); // logger.trace("startElement: uri=" + uri + ", localName=" + localName + ", qName=" + qName); // always increment our depth depth++; // // Depth: zero // Element(s): operation // if (depth == 0) { // make sure our encoding is valid if (this.locator != null) { this.encoding = this.locator.getEncoding(); } if (version.equals(VERSION_1_1)) { if (!this.encoding.toLowerCase().equals("utf-8")) { throw new SxmpParsingException(SxmpErrorCode.UNSUPPORTED_TEXT_ENCODING, "Invalid encoding: " + encoding, null); } } if (!tag.equals("operation")) { throw new SxmpParsingException(SxmpErrorCode.INVALID_XML, "Root element must be an [operation]", null); } // must contain an attribute with the type String opType = getRequiredAttributeValue("operation", attrs, "type"); // parse it via the enum this.operationType = Operation.Type.parse(opType); if (this.operationType == null) { throw new SxmpParsingException(SxmpErrorCode.UNSUPPORTED_OPERATION, "Unsupported operation type [" + opType + "]", null); } // // Depth: 1 // Element(s): account, submitRequest // } else if (depth == 1) { if (tag.equals("account")) { // should only occur once if (elements.contains(tag)) { throw new SxmpParsingException(SxmpErrorCode.MULTIPLE_ELEMENTS_NOT_SUPPORTED, "Multiple [account] elements are not supported", new PartialOperation(this.operationType)); } elements.add(tag); // should have two attributes, username and password String username = getRequiredAttributeValue("account", attrs, "username"); String password = getRequiredAttributeValue("account", attrs, "password"); this.account = new Account(username, password); } else if (tag.equals("application")) { // should only occur once if (elements.contains(tag)) { throw new SxmpParsingException(SxmpErrorCode.MULTIPLE_ELEMENTS_NOT_SUPPORTED, "Multiple [application] elements are not supported", new PartialOperation(this.operationType)); } } else if (tag.equals("error")) { // this is a top level error -- indicates this should be // the only element to return ErrorCodeMessage ecm = parseErrorElement(tag, currentAttrs); ErrorResponse errorResponse = new ErrorResponse(this.operationType, ecm.code, ecm.message); this.operation = errorResponse; } else if (tag.equals("submitRequest")) { parseRequestElement(tag, new SubmitRequest(version), attrs); } else if (tag.equals("deliverRequest")) { parseRequestElement(tag, new DeliverRequest(), attrs); } else if (tag.equals("deliveryReportRequest")) { parseRequestElement(tag, new DeliveryReportRequest(), attrs); } else if (tag.equals("submitResponse")) { parseResponseElement(tag, new SubmitResponse()); } else if (tag.equals("deliverResponse")) { parseResponseElement(tag, new DeliverResponse()); } else if (tag.equals("deliveryReportResponse")) { parseResponseElement(tag, new DeliveryReportResponse()); } else { throw new SxmpParsingException(SxmpErrorCode.UNSUPPORTED_ELEMENT, "Unsupported [" + tag + "] element found at depth [" + depth + "]", new PartialOperation(this.operationType)); } // // Depth: 2 // Element(s): operatorId, etc. // } else if (depth == 2) { // do nothing here, always process in endElement callback } else { // NOTE: no other depths are supported in SXMP throw new SxmpParsingException(SxmpErrorCode.UNSUPPORTED_ELEMENT, "Unsupported [" + tag + "] element found at depth [" + depth + "]", this.operation); } // starting element means reset our character buffer charBuffer.setLength(0); // save reference to attributes for processing in endElement currentAttrs = attrs; } @Override public void endElement(String uri, String localName, String qName) throws SAXException { // // get the tag stripped of any namespace // String tag = (StringUtil.isEmpty(uri)) ? qName : localName; // logger.trace("endElement: uri=" + uri + ", localName=" + localName + ", qName=" + qName); if (depth == 1) { if (tag.equals("application")) { // parse the character data, check for duplicates String applicationNameText = parseCharacterData(tag, true); this.application = new Application(applicationNameText); } } else if (depth == 2) { if (tag.equals("operatorId")) { // parse the character data, check for duplicates String operatorIdText = parseCharacterData(tag, true); // convert to an integer Integer operatorId = parseIntegerValue(tag, operatorIdText); try { if (operation instanceof MessageRequest) { ((MessageRequest) operation).setOperatorId(operatorId); } else { throw new SxmpParsingException(SxmpErrorCode.UNSUPPORTED_ELEMENT, "The [operatorId] element is not supported for this operation type", this.operation); } } catch (SxmpErrorException e) { throw new SxmpParsingException(e.getErrorCode(), e.getErrorMessage(), this.operation); } } else if (tag.equals("priority")) { // parse the character data, check for duplicates String priorityText = parseCharacterData(tag, true); // convert to an integer Integer priorityFlag = parseIntegerValue(tag, priorityText); try { if (operation instanceof MessageRequest) { ((MessageRequest) operation).setPriority(Priority.fromPriorityFlag(priorityFlag)); } else { throw new SxmpParsingException(SxmpErrorCode.UNSUPPORTED_ELEMENT, "The [priority] element is not supported for this operation type", this.operation); } } catch (IllegalArgumentException e) { throw new SxmpParsingException(SxmpErrorCode.INVALID_VALUE, e.getMessage(), this.operation); } } else if (tag.equals("error")) { // parse the error element ErrorCodeMessage ecm = parseErrorElement(tag, currentAttrs); if (operation instanceof Response) { ((Response) operation).setErrorCode(ecm.code); ((Response) operation).setErrorMessage(ecm.message); } else { throw new SxmpParsingException(SxmpErrorCode.UNSUPPORTED_ELEMENT, "The [" + tag + "] element is not supported for this operation type", this.operation); } } else if (tag.equals("ticketId")) { // parse the character data, check for duplicates String ticketId = parseCharacterData(tag, true); // we basically support a ticket element on anything (request or response) operation.setTicketId(ticketId); } else if (tag.equals("status")) { // should only occur once if (elements.contains(tag)) { throw new SxmpParsingException(SxmpErrorCode.MULTIPLE_ELEMENTS_NOT_SUPPORTED, "Multiple [status] elements are not supported", this.operation); } // add the element tag to something we visisted elements.add(tag); String statusCodeString = this.getRequiredAttributeValue("status", currentAttrs, "code"); String statusMessage = this.getRequiredAttributeValue("status", currentAttrs, "message"); Integer statusCode = this.parseIntegerValue("code", statusCodeString); DeliveryStatus status = new DeliveryStatus(statusCode, statusMessage); if (operation instanceof DeliveryReportRequest) { ((DeliveryReportRequest) operation).setStatus(status); } else { throw new SxmpParsingException(SxmpErrorCode.UNSUPPORTED_ELEMENT, "The status element is not supported for this operation type", this.operation); } } else if (tag.equals("messageError")) { // should only occur once if (elements.contains(tag)) { throw new SxmpParsingException(SxmpErrorCode.MULTIPLE_ELEMENTS_NOT_SUPPORTED, "Multiple [messageError] elements are not supported", this.operation); } // add the element tag to something we visisted elements.add(tag); String messageErrorCodeString = this.getRequiredAttributeValue("messageError", currentAttrs, "code"); Integer messageErrorCode = this.parseIntegerValue("code", messageErrorCodeString); if (operation instanceof DeliveryReportRequest) { ((DeliveryReportRequest) operation).setMessageErrorCode(messageErrorCode); } else { throw new SxmpParsingException(SxmpErrorCode.UNSUPPORTED_ELEMENT, "The messageError element is not supported for this operation type", this.operation); } } else if (tag.equals("createDate")) { // should only occur once if (elements.contains(tag)) { throw new SxmpParsingException(SxmpErrorCode.MULTIPLE_ELEMENTS_NOT_SUPPORTED, "Multiple [createDate] elements are not supported", this.operation); } String createDateText = parseCharacterData(tag, true); DateTime createDate = null; try { createDate = dateTimeFormat.parseDateTime(createDateText); } catch (Exception e) { throw new SxmpParsingException(SxmpErrorCode.INVALID_VALUE, "Unable to convert createDate [" + createDateText + "] into a DateTime", this.operation); } if (operation instanceof DeliveryReportRequest) { ((DeliveryReportRequest) operation).setCreateDate(createDate); } else { throw new SxmpParsingException(SxmpErrorCode.UNSUPPORTED_ELEMENT, "The createDate element is not supported for this operation type", this.operation); } } else if (tag.equals("finalDate")) { // should only occur once if (elements.contains(tag)) { throw new SxmpParsingException(SxmpErrorCode.MULTIPLE_ELEMENTS_NOT_SUPPORTED, "Multiple [finalDate] elements are not supported", this.operation); } String finalDateText = parseCharacterData(tag, true); DateTime finalDate = null; try { finalDate = dateTimeFormat.parseDateTime(finalDateText); } catch (Exception e) { throw new SxmpParsingException(SxmpErrorCode.INVALID_VALUE, "Unable to convert finalDate [" + finalDateText + "] into a DateTime", this.operation); } if (operation instanceof DeliveryReportRequest) { ((DeliveryReportRequest) operation).setFinalDate(finalDate); } else { throw new SxmpParsingException(SxmpErrorCode.UNSUPPORTED_ELEMENT, "The finalDate element is not supported for this operation type", this.operation); } } else if (tag.equals("deliveryReport")) { // parse the character data, check for duplicates String deliveryReportText = parseCharacterData(tag, true); Boolean deliveryReport = parseBooleanValue(tag, deliveryReportText); if (operation instanceof SubmitRequest) { ((SubmitRequest) operation).setDeliveryReport(deliveryReport); } else { throw new SxmpParsingException(SxmpErrorCode.UNSUPPORTED_ELEMENT, "The [deliveryReport] element is not supported for this operation type", this.operation); } } else if (tag.equals("sourceAddress")) { // parse the character data, check for duplicates String addrString = parseCharacterData(tag, true); // a type attribute is required String addrTypeString = getRequiredAttributeValue(tag, currentAttrs, "type"); try { // parse and create address MobileAddress srcAddr = MobileAddressUtil.parseAddress(addrTypeString, addrString); if (operation instanceof MessageRequest) { ((MessageRequest) operation).setSourceAddress(srcAddr); } else { throw new SxmpParsingException(SxmpErrorCode.UNSUPPORTED_ELEMENT, "The [sourceAddress] element is not supported for this operation type", this.operation); } } catch (SxmpErrorException e) { throw new SxmpParsingException(e.getErrorCode(), e.getErrorMessage(), this.operation); } } else if (tag.equals("destinationAddress")) { // parse the character data, check for duplicates String addrString = parseCharacterData(tag, true); // a type attribute is required String addrTypeString = getRequiredAttributeValue(tag, currentAttrs, "type"); try { // dest address is XML-escaped for push if (MobileAddressUtil.parseType(addrTypeString) == MobileAddress.Type.PUSH_DESTINATION) { // TODO: CHANGE TO STRINGUTIL.UNESCAPE MAKE FCN addrString = StringEscapeUtils.unescapeXml(addrString); } // parse and create address MobileAddress destAddr = MobileAddressUtil.parseAddress(addrTypeString, addrString); if (operation instanceof MessageRequest) { ((MessageRequest) operation).setDestinationAddress(destAddr); } else { throw new SxmpParsingException(SxmpErrorCode.UNSUPPORTED_ELEMENT, "The [destinationAddress] element is not supported for this operation type", this.operation); } } catch (SxmpErrorException e) { throw new SxmpParsingException(e.getErrorCode(), e.getErrorMessage(), this.operation); } } else if (tag.equals("text")) { // parse the character data, check for duplicates // NOTE: the text element can contain no chars (empty message) String encodedText = parseCharacterData(tag, false); // an encoding MUST be included String encoding = getRequiredAttributeValue(tag, currentAttrs, "encoding"); TextEncoding te = TextEncoding.valueOfCharset(encoding); // if no encoding was found, then this is not supported if (te == null) { throw new SxmpParsingException(SxmpErrorCode.UNSUPPORTED_TEXT_ENCODING, "Unsupported text encoding [" + encoding + "] found", this.operation); } // try to convert hex encoding String text = null; try { if (logger.isTraceEnabled()) { logger.trace("textBeforeDecoding: [" + encodedText + "]"); } byte[] bytes = HexUtil.toByteArray(encodedText); // convert these bytes into a string using the provided charset text = new String(bytes, te.getCharset()); if (logger.isTraceEnabled()) { logger.debug("textAfterDecoding: [" + text + "]"); } } catch (Exception e) { throw new SxmpParsingException(SxmpErrorCode.TEXT_HEX_DECODING_FAILED, "Unable to decode hex data into text", this.operation); } if (operation instanceof MessageRequest) { ((MessageRequest) operation).setText(text, te); } else { throw new SxmpParsingException(SxmpErrorCode.UNSUPPORTED_ELEMENT, "The [text] element is not supported for this operation type", this.operation); } } else if (tag.equals("optionalParams") && version.equals(VERSION_1_1)) { String encodedText = parseCharacterData(tag, false); // optionalParams are XML-escaped encodedText = StringEscapeUtils.unescapeXml(encodedText); if (!StringUtils.isBlank(encodedText)) { //logger.debug("*** Encoded text: '"+encodedText+"'"); try { JSONObject jsonObj = new JSONObject(encodedText); OptionalParamMap optionalParams = new OptionalParamMap(OptionalParamMap.HASH_MAP); Iterator<String> nameItr = jsonObj.keys(); while (nameItr.hasNext()) { String name = nameItr.next(); Object o = jsonObj.get(name); optionalParams.put(name, o); } ((MessageRequest) operation).setOptionalParams(optionalParams); } catch (JSONException e) { logger.warn("", e); throw new SxmpParsingException(SxmpErrorCode.UNABLE_TO_CONVERT_VALUE, "Unable to decode json data", this.operation); } catch (IllegalArgumentException e) { throw new SxmpParsingException(SxmpErrorCode.INVALID_VALUE, "Invalid optional parameters", this.operation); } } } else { throw new SxmpParsingException(SxmpErrorCode.UNSUPPORTED_ELEMENT, "Unsupported [" + tag + "] element found at depth [" + depth + "]", this.operation); } } // always decrement our depth depth--; } @Override public void ignorableWhitespace(char buf[], int offset, int len) throws SAXException { // do nothing logger.debug("ignorable whitespace included!"); } @Override public void characters(char buf[], int offset, int len) throws SAXException { if (buf == null || buf.length <= 0) { // do nothing return; } // convert to string String text = new String(buf, offset, len); // now, only set a text value if its not empty if (text != null && !text.isEmpty()) { charBuffer.append(text); } } @Override public void warning(SAXParseException ex) { logger.warn("", ex); logger.warn("WARNING @ " + getLocationString(ex) + " : " + ex.toString()); } @Override public void error(SAXParseException ex) throws SAXException { // Save error and continue to report other errors if (error == null) error = ex; //logger.debug(ex); logger.error("ERROR @ " + getLocationString(ex) + " : " + ex.toString()); } @Override public void fatalError(SAXParseException ex) throws SAXException { error = ex; //logger.debug(ex); logger.error("FATAL @ " + getLocationString(ex) + " : " + ex.toString()); throw ex; } private String getLocationString(SAXParseException ex) { return ex.getSystemId() + " line:" + ex.getLineNumber() + " col:" + ex.getColumnNumber(); } @Override public InputSource resolveEntity(String pid, String sid) { //logger.debug("resolveEntity(" + pid + ", " + sid + ")"); /** if (logger.isDebugEnabled()) logger.debug("resolveEntity(" + pid + ", " + sid + ")"); if (sid!=null && sid.endsWith(".dtd")) _dtd=sid; URL entity = null; if (pid != null) entity = (URL) _redirectMap.get(pid); if (entity == null) entity = (URL) _redirectMap.get(sid); if (entity == null) { String dtd = sid; if (dtd.lastIndexOf('/') >= 0) dtd = dtd.substring(dtd.lastIndexOf('/') + 1); if (logger.isDebugEnabled()) logger.debug("Can't exact match entity in redirect map, trying " + dtd); entity = (URL) _redirectMap.get(dtd); } if (entity != null) { try { InputStream in = entity.openStream(); if (logger.isDebugEnabled()) logger.debug("Redirected entity " + sid + " --> " + entity); InputSource is = new InputSource(in); is.setSystemId(sid); return is; } catch (IOException e) { logger.warn(e); } } */ return null; } } }