• Home
• de.mhus.ports
• ports-javaxt
• 1.3.6
• source code
• Parameter.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

javaxt.webservices.Parameter Maven / Gradle / Ivy

package javaxt.webservices;

import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;

import javaxt.utils.Value;
import javaxt.xml.DOM;

//******************************************************************************
//**  Parameter Class
//******************************************************************************
/**
 * Used to represent a parameter associated with a web method.
 *
 ******************************************************************************/

public class Parameter {

	private String name;
	private String type;
	private Object value;
	private int minOccurs = 0;
	private int maxOccurs = 1;
	protected boolean IsNillable;
	protected boolean IsAttribute;

	private Parameter[] children = null;
	private Option[] options = null;
	private Node parentNode;

	// **************************************************************************
	// ** Constructor
	// **************************************************************************
	/**
	 * Instantiates this class using a "Parameter" node from an SSD.
	 */
	protected Parameter(Node ParameterNode) throws InstantiationException {

		if (!ParameterNode.getNodeName().equalsIgnoreCase("parameter")) {
			throw new InstantiationException(DOM.getText(ParameterNode));
		}

		this.parentNode = ParameterNode.getParentNode();

		NamedNodeMap attr = ParameterNode.getAttributes();
		name = DOM.getAttributeValue(attr, "name");
		type = DOM.getAttributeValue(attr, "type");
		IsAttribute = bool(DOM.getAttributeValue(attr, "isattribute"));
		IsNillable = bool(DOM.getAttributeValue(attr, "isnillable"));

		if (name.length() == 0) {
			throw new InstantiationException(DOM.getText(ParameterNode));
		}

		// Get min occurances
		try {
			minOccurs = cint(DOM.getAttributeValue(attr, "minOccurs").trim());
			if (minOccurs < 0)
				minOccurs = 0;
		} catch (Exception e) {
		}

		// Get max occurances
		String maxOccurs = DOM.getAttributeValue(attr, "maxOccurs").trim();
		if (maxOccurs.equalsIgnoreCase("unbounded")) {
			this.maxOccurs = 32767;
		} else if (maxOccurs.equals("")) {
			this.maxOccurs = 1;
		} else {
			try {
				this.maxOccurs = cint(maxOccurs);
				if (this.maxOccurs < 0)
					this.maxOccurs = 0;
			} catch (Exception e) {
			}
		}

		// Get children
		java.util.ArrayList params = new java.util.ArrayList();
		for (Node node : DOM.getNodes(ParameterNode.getChildNodes())) {

			if (node.getNodeName().equalsIgnoreCase("parameter")) {
				try {
					params.add(new Parameter(node));
				} catch (InstantiationException e) {
					e.printStackTrace();
				}
			}

			// params.add(new Parameter(node));
		}
		if (!params.isEmpty()) {
			children = params.toArray(new Parameter[params.size()]);
		}

		// Get list of possible values (i.e. options)
		java.util.ArrayList options = new java.util.ArrayList();
		for (Node node : DOM.getNodes(ParameterNode.getChildNodes())) {
			if (node.getNodeName().equalsIgnoreCase("options")) {
				for (Node optionNode : DOM.getNodes(node.getChildNodes())) {
					String value = DOM.getAttributeValue(optionNode.getAttributes(), "value");
					String name = value;
					options.add(new Option(name, value));
				}
			}
		}
		if (!options.isEmpty()) {
			this.options = options.toArray(new Option[options.size()]);
		}

	}

	// **************************************************************************
	// ** getName
	// **************************************************************************
	/**
	 * Returns the parameter name.
	 */
	public String getName() {
		return name;
	}

	// **************************************************************************
	// ** getType
	// **************************************************************************
	/**
	 * Returns the parameter type (e.g. string, int, boolean, base64Binary,
	 * dateTime, etc).
	 */
	public String getType() {
		return type;
	}

	// **************************************************************************
	// ** getValue
	// **************************************************************************
	/**
	 * Returns the value set for this parameter. Note that the value returned
	 * from this method may vary from what was passed to setValue. Refer to the
	 * setValue method for more information.
	 */
	public Object getValue() {
		return value;
	}

	// **************************************************************************
	// ** setValue
	// **************************************************************************
	/**
	 * Used to set the value for this parameter. If there is a type mismatch
	 * between the value and the parameter data type, this method will attempt
	 * to convert the value to the correct datatype. For example, if a byte[]
	 * array is given for a base64Binary parameter, the array is converted to a
	 * base64 encoded string.
	 * 

	 * This method is intended for parameters with simple types. For complex
	 * types, use the getChildren() method and set values for the composite
	 * parameters individually. Alternatively, you can pass a properly formed
	 * xml fragment (string) which will be used, without modification, in the
	 * SOAP/XML request.
	 * 
	 * @param val
	 *            Accepts either an array or a single instance of byte, string,
	 *            boolean, double, float, int, short, long, decimal,
	 *            java.util.Date, javaxt.utils.Date, java.io.File, and
	 *            javaxt.io.File.
	 */
	public void setValue(Object val) {

		if (val == null) {
			value = null;
			return;
		}

		if (isComplex()) {
			if (val instanceof String) {
				String str = (String) val;
				if (str.trim().startsWith("<")) {
					value = str;
				}
			}
		} else {

			if (val.getClass().isArray()) {

				if (getMaxOccurs() > 1) {

					// Copy all the objects in the array. Covert types as
					// needed.
					Object[] a = (Object[]) val;
					Object[] b = new Object[a.length];
					for (int i = 0; i < a.length; i++) {
						b[i] = getValue(a[i]);
					}
					value = b;
				} else {

					if (val instanceof byte[]) {
						value = getValue(val);
					} else {
						// throw new Exception("This parameter does not support
						// arrays.");
					}

				}
			} else {
				value = getValue(val);
			}
		}
	}

	private Object getValue(Object val) {
		if (type.equalsIgnoreCase("base64Binary")) {
			if (val instanceof byte[]) {
				return val;
			} else if (val instanceof String) {
				return javaxt.utils.Base64.decode((String) val);
			} else if (val instanceof java.io.File) {
				return new javaxt.io.File((java.io.File) val).getBytes().toByteArray();
			} else if (val instanceof javaxt.io.File) {
				return ((javaxt.io.File) val).getBytes().toByteArray();
			}
		} else if (type.equalsIgnoreCase("boolean")) {
			return new Value(val).toBoolean();
		} else if (type.equalsIgnoreCase("byte")) {

		} else if (type.equalsIgnoreCase("double")) {
			return new Value(val).toDouble();
		} else if (type.equalsIgnoreCase("dateTime")) {
			if (val instanceof java.util.Date) {
				return val;
			} else if (val instanceof javaxt.utils.Date) {
				return ((javaxt.utils.Date) val).getDate();
			} else if (val instanceof String) {
				try {
					return new javaxt.utils.Date((String) val).getDate();
				} catch (Exception e) {
				}
			}
		} else if (type.equalsIgnoreCase("decimal")) {
			return new Value(val).toBigDecimal();
		} else if (type.equalsIgnoreCase("float")) {
			return new Value(val).toFloat();
		} else if (type.equalsIgnoreCase("int")) {
			return new Value(val).toInteger();
		} else if (type.equalsIgnoreCase("long")) {
			return new Value(val).toLong();
		} else if (type.equalsIgnoreCase("short")) {
			return new Value(val).toShort();
		} else if (type.equalsIgnoreCase("string")) {
			return new Value(val).toString();
		}

		return null;
	}

	// **************************************************************************
	// ** toXML
	// **************************************************************************
	/**
	 * Returns the parameter name and value as an XML fragment suitable for a
	 * SOAP request.
	 */
	protected String toXML(String attributes, String ns) {

		if (ns != null)
			ns = ns.trim();
		else
			ns = "";

		String name = this.name;
		if (ns.length() > 0)
			name = ns + ":" + name;

		StringBuffer xml = new StringBuffer();

		if (value != null && value.getClass().isArray()) {

			if (value instanceof byte[]) {
				xml.append("<" + name + attributes + ">");
				xml.append(javaxt.utils.Base64.encodeBytes((byte[]) value));
				xml.append("");
			} else if (value instanceof Object[]) {
				boolean escapeXML = type.equalsIgnoreCase("string");
				for (Object obj : (Object[]) value) {
					String val = obj + "";
					if (escapeXML)
						val = javaxt.xml.DOM.escapeXml(val);

					xml.append("<" + name + attributes + ">");
					xml.append(val);
					xml.append("");
				}

				/*
				 * String arr = " " +
				 * "MINDSTRM " +
				 * "MSFT " +
				 * "SUN " + "";
				 */

			}
		} else {
			xml.append("<" + name + attributes + ">");

			if (value != null) {
				if (value instanceof String) {
					if (!isComplex()) {
						// xml.append("");
						xml.append(javaxt.xml.DOM.escapeXml((String) value));
					} else { // xml fragment?
						xml.append((String) value);
					}
				} else if (value instanceof java.util.Date) {
					java.util.Date date = (java.util.Date) value;

					// 2003-11-24T00:00:00.0000000-05:00
					java.text.SimpleDateFormat formatter = new java.text.SimpleDateFormat(
					        "yyyy-MM-dd HH:mm:ss.SSSSSSSZ");

					String d = formatter.format(date).replace(" ", "T");

					String d1 = d.substring(0, d.length() - 2);
					String d2 = d.substring(d.length() - 2);
					xml.append(d1 + ":" + d2);
				} else {
					xml.append(value);
				}
			}
			xml.append("");
		}

		return xml.toString();
	}

	public int getMaxOccurs() {
		return maxOccurs;
	}

	public int getMinOccurs() {
		return minOccurs;
	}

	public boolean isRequired() {
		if (getMinOccurs() == 0)
			return false;
		else
			return true;
	}

	public boolean isComplex() {

		if (this.getChildren() != null) {
			if (this.getChildren().length > 0)
				return true;
		}

		if (options != null) {
			return false;
		}

		return false;
	}

	public Parameter[] getChildren() {
		return children;
	}

	protected Node getParentNode() {
		return parentNode;
	}

	public Option[] getOptions() {
		return options;
	}

	@Override
	public String toString() {
		if (isComplex()) {
			return name;
		} else {
			return name + "=" + value;
		}
	}

	// public void reset(){
	// reset(this);
	// }
	//
	// private void reset(Parameter param){
	// param.Value = null;
	// if (Children!=null){
	// for (Parameter p : Children){
	// reset(p);
	// }
	// }
	// }

	private int cint(String str) {
		return javaxt.utils.string.cint(str);
	}

	private boolean bool(String str) {
		if (str.equalsIgnoreCase("true"))
			return true;
		else
			return false;
	}
}