Author: sumedha
Date: Tue Jan 1 22:16:35 2008
New Revision: 11722
Log:
Fixes to namespace,timestamp jiras(675,676,677)
Added:
trunk/commons/data-services/src/main/java/org/wso2/ws/dataservice/beans/Param.java
trunk/commons/data-services/src/main/java/org/wso2/ws/dataservice/beans/Query.java
Modified:
trunk/commons/data-services/src/main/java/org/wso2/ws/dataservice/CallQuery.java
trunk/commons/data-services/src/main/java/org/wso2/ws/dataservice/DBDeployer.java
trunk/commons/data-services/src/main/java/org/wso2/ws/dataservice/DBUtils.java
trunk/commons/data-services/src/main/java/org/wso2/ws/dataservice/DataServiceDocLitWrappedSchemaGenerator.java
trunk/commons/data-services/src/main/java/org/wso2/ws/dataservice/QueryElement.java
Modified:
trunk/commons/data-services/src/main/java/org/wso2/ws/dataservice/CallQuery.java
==============================================================================
---
trunk/commons/data-services/src/main/java/org/wso2/ws/dataservice/CallQuery.java
(original)
+++
trunk/commons/data-services/src/main/java/org/wso2/ws/dataservice/CallQuery.java
Tue Jan 1 22:16:35 2008
@@ -15,13 +15,17 @@
*/
package org.wso2.ws.dataservice;
-import org.apache.axiom.om.OMElement;
-
-import javax.xml.namespace.QName;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
+import javax.xml.namespace.QName;
+
+import org.apache.axiom.om.OMElement;
+import org.apache.axis2.description.AxisService;
+import org.apache.axis2.description.java2wsdl.Java2WSDLConstants;
+import org.wso2.ws.dataservice.beans.Param;
+
public class CallQuery {
private ArrayList inputParms;
@@ -30,6 +34,9 @@
private String elementName;
private String rawName;
private ArrayList queryRefList;
+ private String defaultNamespace;
+ private String columnDefault;
+ private String nsPrefix;
public CallQuery() {
@@ -42,16 +49,16 @@
return inputParms;
}
- public void addInputParms(QueryElement element) {
- inputParms.add(element);
+ public void addInputParms(Param param) {
+ inputParms.add(param);
}
public ArrayList getOutputParms() {
return outputParms;
}
- public void addOutputParms(QueryElement element) {
- outputParms.add(element);
+ public void addOutputParms(Param param) {
+ outputParms.add(param);
}
@@ -84,24 +91,69 @@
public ArrayList getQueryRefList() {
return queryRefList;
}
+
+
+
+ public String getDefaultNamespace() {
+ return defaultNamespace;
+ }
+
+ public void setDefaultNamespace(String defaultNamespace) {
+ this.defaultNamespace = defaultNamespace;
+ }
+
+ public String getColumnDefault() {
+ return columnDefault;
+ }
+
+ public void setColumnDefault(String columnDefault) {
+ this.columnDefault = columnDefault;
+ }
+
+ public String getNsPrefix() {
+ return nsPrefix;
+ }
+
+ public void setNsPrefix(String nsPrefix) {
+ this.nsPrefix = nsPrefix;
+ }
- public void populateCallQuery(OMElement queryElement) {
+ public void populateCallQuery(OMElement queryElement,AxisService
axisService) {
Iterator inputsIterator = queryElement.getChildrenWithName(new
QName("param"));
while (inputsIterator.hasNext()) {
OMElement input = (OMElement) inputsIterator.next();
String name = input.getAttributeValue(new QName("name"));
String sqlType = input.getAttributeValue(new QName("sqlType"));
- String type = DBDeployer.getJavaTypeFromSQLType(sqlType);
- QueryElement inputElement = new QueryElement();
- inputElement.setClassType(type);
+ String dataType = DBDeployer.getJavaTypeFromSQLType(sqlType);
+ String paramType = input.getAttributeValue(new QName("type"));
+ String ordinal = input.getAttributeValue(new QName("ordinal"));
+ //QueryElement inputElement = new QueryElement();
+ Param param = new Param();
+ param.setSqlType(dataType);
+ //set Parameter type
+ if(paramType != null){
+ param.setType(paramType);
+ }else{
+ param.setType("IN");
+ }
+
+ //if ordinal is set, set it
+ if(ordinal != null){
+ param.setOrdinal(Integer.valueOf(ordinal).intValue());
+ }
+
+ //inputElement.setClassType(type);
+
+ //TODO : complete
//String withParamName = getExternalParameterName(queryElement,
paramsPerCallQueryMap, name);
//if(withParamName != null){
// inputElement.setName(withParamName);
//}else{
- inputElement.setName(name);
+ //inputElement.setName(name);
+ param.setName(name);
//}
- addInputParms(inputElement);
+ addInputParms(param);
}
OMElement sqlQuery = queryElement.getFirstChildWithName(new
QName("sql"));
if (sqlQuery != null) {
@@ -110,17 +162,37 @@
OMElement resultElement = queryElement.getFirstChildWithName(new
QName("result"));
if (resultElement != null) {
- elementName = resultElement.getAttributeValue(new
QName("element"));
+ elementName = resultElement.getAttributeValue(new
QName("element"));
rawName = resultElement.getAttributeValue(new QName("rowName"));
+ defaultNamespace = resultElement.getAttributeValue(new
QName("defaultNamespace"));
+ //if not mentioned, set the default one
+ if(defaultNamespace == null){
+ defaultNamespace = axisService.getTargetNamespace();
+ nsPrefix = axisService.getTargetNamespacePrefix();
+ }else{
+ //namespace prefix must be set
+ int index = rawName.indexOf(":");
+ if(index > -1){
+ nsPrefix = rawName.substring(1, index);
+ rawName = rawName.substring(index+1);
+ }else{
+ //TODO : throw exception
+ nsPrefix = Java2WSDLConstants.AXIS2_NAMESPACE_PREFIX;
+ }
+ }
+ columnDefault = resultElement.getAttributeValue(new
QName("columnDefault"));
+
+
+
//processing elements
Iterator elements = resultElement.getChildrenWithName(new
QName("element"));
while (elements.hasNext()) {
OMElement element = (OMElement) elements.next();
- QueryElement resultQueryElement = new QueryElement();
- resultQueryElement.setClassType("java.lang.String");
- resultQueryElement.setColumnName(element.getAttributeValue(new
QName("column")));
- resultQueryElement.setName(element.getAttributeValue(new
QName("name")));
- addOutputParms(resultQueryElement);
+ Param param = new Param();
+ param.setSqlType("java.lang.String");
+ param.setColumnName(element.getAttributeValue(new
QName("column")));
+ param.setName(element.getAttributeValue(new QName("name")));
+ addOutputParms(param);
}
Iterator queryElements = resultElement.getChildrenWithName(new
QName("call-query"));
while (queryElements.hasNext()) {
Modified:
trunk/commons/data-services/src/main/java/org/wso2/ws/dataservice/DBDeployer.java
==============================================================================
---
trunk/commons/data-services/src/main/java/org/wso2/ws/dataservice/DBDeployer.java
(original)
+++
trunk/commons/data-services/src/main/java/org/wso2/ws/dataservice/DBDeployer.java
Tue Jan 1 22:16:35 2008
@@ -190,6 +190,7 @@
throws AxisFault {
AxisService axisService;
OMElement configElement;
+ String baseURI = null;
DBMessageReceiver dbMessageReceiver = getDbMessageReceiver();
HashMap callQueryMap = new HashMap();
FileInputStream fis = null;
@@ -199,6 +200,7 @@
configElement = (new StAXOMBuilder(fis)).getDocumentElement();
configElement.build();
String serviceName = configElement.getAttributeValue(new
QName("name")).toString();
+ baseURI = configElement.getAttributeValue(new QName("baseURI"));
axisService = new AxisService(serviceName);
OMElement connection = configElement.getFirstChildWithName(new
QName("config"));
@@ -286,12 +288,16 @@
queryMap.put(queryId, queryElement);
CallQuery callQuery = new CallQuery();
//callQuery.populateCallQuery(queryElement,paramsPerCallQueryMap);
- callQuery.populateCallQuery(queryElement);
+ callQuery.populateCallQuery(queryElement,axisService);
callQueryMap.put(queryId,callQuery);
}
axisService.addParameter(new
Parameter(DBConstants.DB_QUERY_ELEMENTS, queryMap));
-
- axisService.setTargetNamespace(DBConstants.WSO2_NAMESPACE);
+ if(baseURI == null){
+ axisService.setTargetNamespace(DBConstants.WSO2_NAMESPACE);
+ }else{
+ axisService.setTargetNamespace(baseURI);
+ }
+
axisService.setElementFormDefault(false);
//set the datasource type as a Axis parameter
@@ -310,6 +316,10 @@
while (ops.hasNext()) {
OMElement operation = (OMElement) ops.next();
String opName = operation.getAttributeValue(new QName("name"));
+ int index = opName.indexOf(":");
+ if(index > -1){
+ opName = opName.substring(index+1);
+ }
//is it always InOutAxisOperation ??
AxisOperation axisOperation = new InOutAxisOperation(new
QName(opName));
// axisOperation.
@@ -326,7 +336,7 @@
OMElement query = (OMElement) queryMap.get(hrefVal);
CallQuery callQueryElement = new CallQuery();
//callQueryElement.populateCallQuery(query,paramsPerCallQueryMap);
- callQueryElement.populateCallQuery(query);
+ callQueryElement.populateCallQuery(query,axisService);
//creating a parameter to hold query object
Parameter callQueryParameter = new Parameter();
@@ -349,11 +359,18 @@
DataServiceDocLitWrappedSchemaGenerator schemaGenerator =
new
DataServiceDocLitWrappedSchemaGenerator(axisService,callQueryMap);
schemaGenerator.setElementFormDefault(Java2WSDLConstants.FORM_DEFAULT_UNQUALIFIED);
+
//schemaGenerator.setElementFormDefault(Java2WSDLConstants.FORM_DEFAULT_QUALIFIED);
NamespaceMap map = new NamespaceMap();
- map.put(Java2WSDLConstants.AXIS2_NAMESPACE_PREFIX,
- DBConstants.WSO2_NAMESPACE);
+ if(baseURI == null){
+ map.put(Java2WSDLConstants.AXIS2_NAMESPACE_PREFIX,
+ DBConstants.WSO2_NAMESPACE);
+ }else{
+ map.put(Java2WSDLConstants.AXIS2_NAMESPACE_PREFIX,
+ baseURI);
+ }
map.put(Java2WSDLConstants.DEFAULT_SCHEMA_NAMESPACE_PREFIX,
Java2WSDLConstants.URI_2001_SCHEMA_XSD);
+ //map.put("ns1", "http://oldcustomers.ws.wso2.org";);
axisService.setNameSpacesMap(map);
axisService.setElementFormDefault(false);
schemaGenerator.generateSchema();
Modified:
trunk/commons/data-services/src/main/java/org/wso2/ws/dataservice/DBUtils.java
==============================================================================
---
trunk/commons/data-services/src/main/java/org/wso2/ws/dataservice/DBUtils.java
(original)
+++
trunk/commons/data-services/src/main/java/org/wso2/ws/dataservice/DBUtils.java
Tue Jan 1 22:16:35 2008
@@ -27,6 +27,7 @@
import java.io.StringWriter;
import java.net.MalformedURLException;
import java.net.URL;
+import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.Date;
import java.sql.DriverManager;
@@ -69,6 +70,8 @@
import org.wso2.ws.dataservice.beans.CSVQuery;
import org.wso2.ws.dataservice.beans.Config;
import org.wso2.ws.dataservice.beans.ExcelQuery;
+import org.wso2.ws.dataservice.beans.Param;
+import org.wso2.ws.dataservice.beans.Query;
import org.wso2.ws.dataservice.beans.Result;
import au.com.bytecode.opencsv.CSVReader;
@@ -126,15 +129,28 @@
// in the spec.
// Right now order in which it appears in taken.
HashMap paramOrder = new HashMap();
+
+ //parameter type(IN/OUT/INOUT) for stored procedures
+ //For SQL queries, default is IN
+ HashMap paramType = new HashMap();
Iterator iParams = queryElement.getChildrenWithName(new
QName("param"));
int position = 0;
- while (iParams.hasNext()) {
+ while (iParams.hasNext()) {
OMElement param = (OMElement) iParams.next();
- String paramName = param.getAttributeValue(new
QName("name"));
- String sqlType = param.getAttributeValue(new
QName("sqlType"));
- params.put(paramName, sqlType);
- paramOrder.put(new Integer(position + 1),
paramName);
- position++;
+ String inOutType = param.getAttributeValue(new
QName("type"));
+ //OUT params are used for stored procedures only
+ //if(!("OUT".equals(inOutType))){
+ String paramName =
param.getAttributeValue(new QName("name"));
+ String sqlType =
param.getAttributeValue(new QName("sqlType"));
+ //default is IN type
+ if(inOutType == null){
+ inOutType = "IN";
+ }
+ params.put(paramName, sqlType);
+ paramOrder.put(new Integer(position +
1), paramName);
+ paramType.put(paramName, inOutType);
+ position++;
+ //}
}
String query = queryElement.getFirstChildWithName(new
QName("sql")).getText();
@@ -145,20 +161,24 @@
if (firstPartOfSQL.equalsIgnoreCase("SELECT")) {
resultElement =
- getSelectResult(queryElement, inputs,
params, paramOrder, axisService, false);
+ getSelectResult(queryElement, inputs,
params, paramOrder,paramType, axisService, false);
} else if (firstPartOfSQL.equalsIgnoreCase("INSERT")
||
firstPartOfSQL.equalsIgnoreCase("UPDATE")
||
firstPartOfSQL.equalsIgnoreCase("DELETE")
||
firstPartOfSQL.equalsIgnoreCase("CREATE")) {
- resultElement = getSelectResult(queryElement,
inputs, params, paramOrder, axisService, true);
+ resultElement = getSelectResult(queryElement,
inputs, params, paramOrder,paramType, axisService, true);
}else {
//This can be a stored procedure call
+ //resultElement =
+ // getSelectResult(queryElement, inputs,
params, paramOrder,paramType, axisService, false);
resultElement =
- getSelectResult(queryElement, inputs,
params, paramOrder, axisService, false);
+ getStoredProcedureResult(queryElement,
inputs, params, paramOrder,paramType, axisService);
+
}
} catch (Exception e) {
+ log.error("Error occured", e);
return
generateErrorResponse(axisService.getTargetNamespace(), (AxisFault)e);
}
return resultElement;
@@ -231,8 +251,242 @@
}
return null;
}
+
+ private static OMElement getStoredProcedureResult(OMElement
queryElement,HashMap inputValues,
+ HashMap params, HashMap paramOrder,HashMap paramType,
AxisService axisService)
+ throws AxisFault{
+ OMElement resultElement = null;
+ Connection conn = null;
+ boolean noResultSet = false;
+ String elementValue;
+ String sqlQuery = queryElement.getFirstChildWithName(new
QName("sql")).getText();
+ try {
+ Parameter dbConnectionParam =
axisService.getParameter(DBConstants.DB_CONNECTION);
+ if(dbConnectionParam == null){
+ throw new AxisFault("Database connection not
found in Axis Configuration");
+ }
+ conn = (Connection)dbConnectionParam.getValue();
+ conn = checkDBConnectionStatus(axisService, conn);
+ conn.setAutoCommit(false);
+ CallableStatement cs =
(CallableStatement)getProcessedPreparedStatement
+ (inputValues, params, paramOrder,paramType, conn,
sqlQuery,"STORED-PROCEDURE");
+
+ ResultSet rs = null;
+ try{
+ rs = cs.executeQuery();
+ }catch(SQLException e){
+
if(e.getMessage().indexOf("java.sql.CallableStatement.executeQuery() " +
+ "was called but no result set
was returned. " +
+ "Use
java.sql.CallableStatement.executeUpdate() for non-queries.") > -1){
+ noResultSet = true;
+ cs.executeUpdate();
+ }else{
+ log.error("Error occured getting stored
procedure result", e);
+ }
+ }
+
+
+ //check for out parameters
+
+ OMElement result =
queryElement.getFirstChildWithName(new QName("result"));
+ Query query = new
Query(queryElement.getChildrenWithName(new QName("param")));
+ Result resultObj = new Result(result);
+
+ String columnDefalut = result.getAttributeValue(new
QName("columnDefault"));
+
+ OMFactory fac = OMAbstractFactory.getOMFactory();
+ OMNamespace omNs =
fac.createOMNamespace(axisService.getTargetNamespace(), "data");
+ //OMNamespace omNs = fac.createOMNamespace("", "data");
+ resultElement =
fac.createOMElement(resultObj.getResultWrapper(), omNs);
+
+
+ //check if wrapper element should be qualified
+ if ( !axisService.isElementFormDefault()) {
+ omNs =fac.createOMNamespace("",
"data");
+ }
+
+ //put result elements into an array
+ Iterator tmpElements = result.getChildElements();
+ ArrayList tmpElementsArrayList = new ArrayList();
+ while(tmpElements.hasNext()){
+ OMElement element = (OMElement) tmpElements.next();
+ tmpElementsArrayList.add(element);
+ }
+
+ if(! noResultSet && rs != null){
+
+ while (rs.next()) {
+ HashMap elementValues = new HashMap();
+ int columnCount =
rs.getMetaData().getColumnCount();
+
+ OMElement row =
fac.createOMElement(resultObj.getRowName(), omNs);
+ if (resultObj.getRowName() == null) {
+ row = resultElement;
+ }
+ for (int i = 1; i <= columnCount; i++) {
+ String columnName =
rs.getMetaData().getColumnLabel(i);
+ String columnValue =
rs.getString(columnName);
+ elementValues.put(columnName,
columnValue);
+ }
+
+ boolean useAsParamToNextQuery = false;
+ for(int a=0;a <
resultObj.getDisplayColumnNames().length;a++){
+ //OMElement element =
(OMElement) elements.next();
+ if
(resultObj.getElementLocalNames()[a].equals("element")) {
+ //String displayTagName
= element.getAttributeValue(new QName("name"));
+ String displayTagName =
resultObj.getDisplayColumnNames()[a];
+ //String
resultSetFieldName = element.getAttributeValue(new QName("column"));
+ String resultSetFieldName =
resultObj.getResultSetColumnNames()[a];
+
+ // This means,the
parameter is not part of the
+ // resultset. i.e. it
is being passed from user's
+ // parameters.
+
+ //TODO **********
+
+
+
+ if
(useAsParamToNextQuery) {
+ elementValue =
(String) params.get(resultSetFieldName);
+
elementValues.put(resultSetFieldName, elementValue);
+ } else {
+ elementValue =
(String) elementValues.get(resultSetFieldName);
+ }
+
+ elementValue =
setOutparameterValue(cs, query,
+
resultSetFieldName);
+
+
+ if (columnDefalut ==
null || columnDefalut.equals("element")) {
+ OMElement
rowElement = fac.createOMElement(displayTagName, omNs);
+
rowElement.addChild(fac.createOMText(rowElement, elementValue));
+
row.addChild(rowElement);
+ } else if
(columnDefalut.equals("attribute")) {
+
row.addAttribute(displayTagName, elementValue, omNs);
+ }
+ } else if
(resultObj.getElementLocalNames()[a].equals("call-query")) {
+ //OMElement element = (OMElement)
elements.next();
+ OMElement element =
(OMElement)tmpElementsArrayList.get(a);
+ OMElement rowElement =
getRDBMSResult(element, axisService, elementValues);
+
row.addChild(rowElement);
+ }
+ }
+ if (resultObj.getRowName() != null) {
+ resultElement.addChild(row);
+ }
+ }
+ }else{
+ //No resultset, only out parameters are there.
+ OMElement row = null;
+ if(resultObj.getRowName() != null){
+ //row name is OPTIONAL
+ row =
fac.createOMElement(resultObj.getRowName(), omNs);
+ }
+
+ //if (resultObj.getRowName() == null) {
+ // row = resultElement;
+ //}
+
+ for(int a=0;a <
resultObj.getDisplayColumnNames().length;a++){
+ if
(resultObj.getElementLocalNames()[a].equals("element")) {
+ String displayTagName =
resultObj.getDisplayColumnNames()[a];
+ String resultSetFieldName =
resultObj.getResultSetColumnNames()[a];
+ elementValue =
setOutparameterValue(cs, query, resultSetFieldName);
+
+ if (columnDefalut ==
null || columnDefalut.equals("element")) {
+ OMElement
rowElement = fac.createOMElement(displayTagName, omNs);
+
rowElement.addChild(fac.createOMText(rowElement, elementValue));
+ if(row != null){
+
row.addChild(rowElement);
+ }else{
+
resultElement.addChild(rowElement);
+ }
+
+ } else if
(columnDefalut.equals("attribute")) {
+ if(row != null){
+
row.addAttribute(displayTagName, elementValue, omNs);
+ }else{
+
resultElement.addAttribute(displayTagName, elementValue, omNs);
+ }
+ }
+ }
+ }
+ if(row != null){
+ resultElement.addChild(row);
+ }
+ }
+
+ } catch (SQLException e) {
+ log.error("Exception occurred while trying to execute the
SQL statement : "+sqlQuery, e);
+ throw new AxisFault("Exception occurred while trying to
execute the SQL statement : "+sqlQuery, e);
+ }
+
+
+ finally {
+ try {
+ if (conn != null) {
+ conn.commit();
+ conn.close();
+ }
+ } catch (SQLException e) {
+ log.error(e.getMessage());
+ throw new AxisFault(
+ "Exception occurred while
trying to commit.", e);
+ }
+ }
+ return resultElement;
+ }
+
+ private static String setOutparameterValue(CallableStatement cs,
+ Query query, String resultSetFieldName)
+ throws SQLException,AxisFault {
+ // This could be an out parameter
+ //Procedure returns both result & out parameters
+ String elementValue = "";
+ Param param = query.getParam(resultSetFieldName);
+ if (param != null) {
+ if ("OUT".equals(param.getType())) {
+ if (param.getSqlType().equals(
+ DBConstants.DataTypes.STRING)) {
+ elementValue =
cs.getString(param.getOrdinal());
+ } else if (param.getSqlType().equals(
+ DBConstants.DataTypes.DOUBLE)) {
+ elementValue = String.valueOf(cs
+
.getDouble(param.getOrdinal()));
+ } else if (param.getSqlType().equals(
+ DBConstants.DataTypes.BIGINT ))
{
+ elementValue = String.valueOf(cs
+
.getLong(param.getOrdinal()));
+ } else if (param.getSqlType().equals(
+ DBConstants.DataTypes.INTEGER))
{
+ elementValue = String.valueOf(cs
+
.getInt(param.getOrdinal()));
+ } else if (param.getSqlType().equals(
+ DBConstants.DataTypes.TIME)) {
+ elementValue = String.valueOf(cs
+
.getTime(param.getOrdinal()));
+ } else if (param.getSqlType().equals(
+ DBConstants.DataTypes.DATE)) {
+ elementValue = String.valueOf(cs
+
.getDate(param.getOrdinal()));
+ } else if (param.getSqlType().equals(
+
DBConstants.DataTypes.TIMESTAMP)) {
+ elementValue = String.valueOf(cs
+
.getTimestamp(param.getOrdinal()));
+ } else{
+ log.error("Unsupported data type :
"+param.getSqlType());
+ throw new AxisFault("Unsupported data
type : "+param.getSqlType());
+ }
+
+ }
+ }
+ return elementValue;
+ }
+
+
+
private static OMElement getSelectResult(OMElement queryElement,
HashMap inputValues,
- HashMap params, HashMap paramOrder, AxisService
axisService, boolean isDML)
+ HashMap params, HashMap paramOrder,HashMap paramType,
AxisService axisService, boolean isDML)
throws AxisFault {
OMElement resultElement = null;
Connection conn = null;
@@ -249,7 +503,7 @@
conn.setAutoCommit(false);
PreparedStatement preparedStatement =
- getProcessedPreparedStatement(inputValues,
params, paramOrder, conn, sqlQuery);
+ getProcessedPreparedStatement(inputValues,
params, paramOrder,paramType, conn, sqlQuery,"SQL");
int responseCode = -1;
ResultSet rs = null;
@@ -282,7 +536,9 @@
OMFactory fac = OMAbstractFactory.getOMFactory();
OMNamespace omNs =
fac.createOMNamespace(axisService.getTargetNamespace(), "data");
+ //OMNamespace omNs = fac.createOMNamespace("", "data");
resultElement =
fac.createOMElement(resultObj.getResultWrapper(), omNs);
+
if (isDML) {
resultElement
@@ -879,8 +1135,7 @@
||
config.getPropertyValue(DBConstants.MAX_POOL_SIZE) != null){
//user has set connection pool size(s). Get
connection from pooling manager
DBCPConnectionManager dbcpConnectionManager =
new DBCPConnectionManager(config);
- conn =
dbcpConnectionManager.getDatasource().getConnection();
-
+ conn =
dbcpConnectionManager.getDatasource().getConnection();
}else{
conn = DriverManager.getConnection((String)
config.getPropertyValue(DBConstants.PROTOCOL), props);
}
@@ -904,37 +1159,45 @@
}
public static PreparedStatement getProcessedPreparedStatement(HashMap
inputs, HashMap params,
- HashMap paramOrder, Connection conn, String
sqlStatement) throws AxisFault {
+ HashMap paramOrder,HashMap paramTypes, Connection conn,
String sqlStatement,String callee) throws AxisFault {
String paramName = null;
String sqlType = null;
String value = null;
-
- try{
-
- PreparedStatement sqlQuery =
conn.prepareStatement(sqlStatement);
+ String paramType = null;
+
log.debug("Processing prepared statement for SQL " +
sqlStatement);
Set paramNames = params.keySet();
- Object pramNameArray[] = paramNames.toArray();
-
- //SQL expects parameters, but not params set in config file
- if(sqlStatement.indexOf("?") > -1 && pramNameArray.length == 0){
- throw new AxisFault("SQL : "+sqlStatement+" expects one
or more parameters. " +
- "But none is mentioned in the
configuration file.");
- }
+ Object pramNameArray[] = paramNames.toArray();
+
+ try{
+ PreparedStatement sqlQuery = null;
+ if("SQL".equals(callee)){
+ sqlQuery = conn.prepareStatement(sqlStatement);
+ //SQL expects parameters, but not params set in config
file
+ if(sqlStatement.indexOf("?") > -1 &&
pramNameArray.length == 0){
+ throw new AxisFault("SQL : "+sqlStatement+"
expects one or more parameters. " +
+ "But none is mentioned in the
configuration file.");
+ }
+ }else if("STORED-PROCEDURE".equals(callee)){
+ sqlQuery = conn.prepareCall(sqlStatement);
+ }
for (int i = 0; i < pramNameArray.length; i++) {
paramName = (String) paramOrder.get(new Integer(i + 1));
sqlType = (String) params.get(paramName);
+ paramType = (String)paramTypes.get(paramName);
value = (String) inputs.get(paramName);
log.debug("Param name : "+paramName
+" SQL Type : "+sqlType
+" Value : "+value);
- if(value == null || value.trim().length() == 0){
- log.error("Empty value found for parameter : "+paramName);
- throw new AxisFault("Empty value found for parameter :
"+paramName);
- }
+ if("IN".equals(paramType)){
+ if(value == null || value.trim().length() == 0){
+ log.error("Empty value found for parameter :
"+paramName);
+ throw new AxisFault("Empty value found for
parameter : "+paramName);
+ }
+ }
//work-a-round for setting NULL
if("NULL".equalsIgnoreCase(value)){
value = null;
@@ -943,30 +1206,85 @@
if (sqlType == null) {
// Defaults to string
- sqlQuery.setString(i + 1, value);
- } else if
(DBConstants.DataTypes.INTEGER.equals(sqlType)) {
- sqlQuery.setInt(i + 1, Integer.parseInt(value));
- } else if
(DBConstants.DataTypes.STRING.equals(sqlType)) {
- sqlQuery.setString(i + 1, value);
- } else if
(DBConstants.DataTypes.DOUBLE.equals(sqlType)) {
- sqlQuery.setDouble(i + 1,
Double.parseDouble(value));
+ if("IN".equals(paramType)){
+ sqlQuery.setString(i + 1, value);
+ }else{
+
((CallableStatement)sqlQuery).registerOutParameter(i+1, java.sql.Types.VARCHAR);
+ }
+ } else if
(DBConstants.DataTypes.INTEGER.equals(sqlType)) {
+ if("IN".equals(paramType)){
+ if("SQL".equals(callee)){
+ sqlQuery.setInt(i + 1,
Integer.parseInt(value));
+ }else{
+
((CallableStatement)sqlQuery).setInt(i + 1, Integer.parseInt(value));
+ }
+ }else{
+
((CallableStatement)sqlQuery).registerOutParameter(i+1, java.sql.Types.INTEGER);
+ }
+ } else if
(DBConstants.DataTypes.STRING.equals(sqlType)) {
+ if("IN".equals(paramType)){
+ if("SQL".equals(callee)){
+ sqlQuery.setString(i + 1,
value);
+ }else{
+
((CallableStatement)sqlQuery).setString(i + 1, value);
+ }
+ }else{
+
((CallableStatement)sqlQuery).registerOutParameter(i+1, java.sql.Types.VARCHAR);
+ }
+ } else if
(DBConstants.DataTypes.DOUBLE.equals(sqlType)) {
+ if("IN".equals(paramType)){
+ if("SQL".equals(callee)){
+ sqlQuery.setDouble(i + 1,
Double.parseDouble(value));
+ }else{
+
((CallableStatement)sqlQuery).setDouble(i + 1, Double.parseDouble(value));
+ }
+ }else{
+
((CallableStatement)sqlQuery).registerOutParameter(i+1, java.sql.Types.DOUBLE);
+ }
}else if(DBConstants.DataTypes.DATE.equals(sqlType)){
- try{
- sqlQuery.setDate(i+1, Date.valueOf(value));
+ try{
+ if("IN".equals(paramType)){
+ //Only yyyy-MM-dd part is needed
+ String modifiedValue =
value.substring(0, 10);
+ if("SQL".equals(callee)){
+ sqlQuery.setDate(i+1,
Date.valueOf(modifiedValue));
+ }else{
+
((CallableStatement)sqlQuery).setDate(i+1, Date.valueOf(modifiedValue));
+ }
+ }else{
+
((CallableStatement)sqlQuery).registerOutParameter(i+1, java.sql.Types.DATE);
+ }
}catch(IllegalArgumentException e){
- log.error("Incorrect date format for parameter :
"+paramName, e);
+ log.error("Incorrect date format("+value+") for
parameter : "+paramName, e);
throw new AxisFault("Incorrect date format for
parameter : "
+paramName+".Date should be in yyyy-mm-dd
format.", e);
}
}else
if(DBConstants.DataTypes.TIMESTAMP.equals(sqlType)){
- Timestamp timestamp =
getTimestamp(value,paramName);
- sqlQuery.setTimestamp(i+1,timestamp);
+ if("IN".equals(paramType)){
+ Timestamp timestamp =
getTimestamp(value,paramName);
+ if("SQL".equals(callee)){
+
sqlQuery.setTimestamp(i+1,timestamp);
+ }else{
+
((CallableStatement)sqlQuery).setTimestamp(i+1,timestamp);
+ }
+ }else{
+
((CallableStatement)sqlQuery).registerOutParameter(i+1,
java.sql.Types.TIMESTAMP);
+ }
}else if(DBConstants.DataTypes.TIME.equals(sqlType)){
- Time time = getTime(value,paramName);
- sqlQuery.setTime(i+1,time);
+ if("IN".equals(paramType)){
+ Time time = getTime(value,paramName);
+ if("SQL".equals(callee)){
+ sqlQuery.setTime(i+1,time);
+ }else{
+
((CallableStatement)sqlQuery).setTime(i+1,time);
+ }
+ }else{
+
((CallableStatement)sqlQuery).registerOutParameter(i+1, java.sql.Types.TIME);
+ }
+ }else{
+ log.error("Unsupported data type : "+sqlType+"
as input parameter.");
+ throw new AxisFault("Found Unsupported data
type : "+sqlType+" as input parameter.");
}
-
-
}
return sqlQuery;
}
@@ -987,21 +1305,56 @@
*/
private static Timestamp getTimestamp(String value,String paramName)
throws AxisFault{
- java.sql.Timestamp timestamp;
+ java.sql.Timestamp timestamp = null;
+ SimpleDateFormat sdf;
try{
- SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd
hh:mm:ss.SSSSSS");
+ sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss.SSSSSS");
java.util.Date date = sdf.parse(value);
timestamp = new java.sql.Timestamp(date.getTime());
}catch(ParseException e){
try{
- SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd
hh:mm:ss");
+ sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
java.util.Date date = sdf.parse(value);
timestamp = new java.sql.Timestamp(date.getTime());
}catch(ParseException e1){
- log.error("Incorrect Timestamp format for parameter :
"+paramName
- +".Timestamp should be either in format
yyyy-MM-dd hh:mm:ss.SSSSSS or yyyy-MM-dd hh:mm:ss", e);
- throw new AxisFault("Incorrect Timestamp format for parameter
: "+paramName
- +".Timestamp should be either in format
yyyy-MM-dd hh:mm:ss.SSSSSS or yyyy-MM-dd hh:mm:ss", e);
+ sdf = new SimpleDateFormat("yyyy-MM-dd'T'hh:mm:ss.sss'Z'");
+ try {
+ java.util.Date date = sdf.parse(value);
+ timestamp = new java.sql.Timestamp(date.getTime());
+ } catch (ParseException e2) {
+ try {
+ sdf = new
SimpleDateFormat("yyyy-MM-dd'T'hh:mm:ss.sss'+'hh:mm");
+ java.util.Date date = sdf.parse(value);
+ timestamp = new
java.sql.Timestamp(date.getTime());
+ } catch (ParseException e3) {
+ try{
+ sdf = new
SimpleDateFormat("yyyy-MM-dd'T'hh:mm:ss.sss'-'hh:mm");
+ java.util.Date date = sdf.parse(value);
+ timestamp = new
java.sql.Timestamp(date.getTime());
+ } catch (ParseException e4) {
+ try{
+ sdf = new
SimpleDateFormat("yyyy-MM-dd");
+ java.util.Date date =
sdf.parse(value);
+ timestamp = new
java.sql.Timestamp(date.getTime());
+ } catch (ParseException
e5) {
+ log.error("Incorrect Timestamp
format for parameter : "+paramName
+ +".Timestamp
should be in one of following formats " +
+
"yyyy-MM-dd'T'hh:mm:ss.sss'+'hh:mm, " +
+
"yyyy-MM-dd'T'hh:mm:ss.sss'-'hh:mm, " +
+
"yyyy-MM-dd'T'hh:mm:ss.sss'Z', " +
+
"yyyy-MM-dd hh:mm:ss.SSSSSS or " +
+
"yyyy-MM-dd hh:mm:ss", e5);
+ throw new
AxisFault("Incorrect Timestamp format for parameter : "+paramName
+ +".Timestamp
should be in one of following formats " +
+
"yyyy-MM-dd'T'hh:mm:ss.sss'+'hh:mm, " +
+
"yyyy-MM-dd'T'hh:mm:ss.sss'-'hh:mm, " +
+
"yyyy-MM-dd'T'hh:mm:ss.sss'Z', " +
+
"yyyy-MM-dd hh:mm:ss.SSSSSS or " +
+
"yyyy-MM-dd hh:mm:ss", e5);
+ }
+ }
+ }
+ }
}
}
return timestamp;
@@ -1016,7 +1369,7 @@
private static Time getTime(String value, String paramName)
throws AxisFault {
java.sql.Time time;
- try {
+ try {
SimpleDateFormat sdf = new SimpleDateFormat("hh:mm:ss");
java.util.Date date = sdf.parse(value);
time = new java.sql.Time(date.getTime());
@@ -1027,7 +1380,5 @@
+
".Time should be in the format hh:mm:ss",e);
}
return time;
- }
-
-
+ }
}
Modified:
trunk/commons/data-services/src/main/java/org/wso2/ws/dataservice/DataServiceDocLitWrappedSchemaGenerator.java
==============================================================================
---
trunk/commons/data-services/src/main/java/org/wso2/ws/dataservice/DataServiceDocLitWrappedSchemaGenerator.java
(original)
+++
trunk/commons/data-services/src/main/java/org/wso2/ws/dataservice/DataServiceDocLitWrappedSchemaGenerator.java
Tue Jan 1 22:16:35 2008
@@ -1,5 +1,6 @@
package org.wso2.ws.dataservice;
+import org.apache.axis2.AxisFault;
import org.apache.axis2.description.AxisMessage;
import org.apache.axis2.description.AxisOperation;
import org.apache.axis2.description.AxisService;
@@ -9,6 +10,7 @@
import org.apache.axis2.wsdl.WSDLConstants;
import org.apache.ws.commons.schema.*;
import org.apache.ws.commons.schema.utils.NamespaceMap;
+import org.wso2.ws.dataservice.beans.Param;
import javax.xml.namespace.QName;
import java.util.ArrayList;
@@ -73,6 +75,11 @@
generateSchemaforOperation(axisOperation);
}
axisService.addSchema(schemaMap.values());
+// try {
+// axisService.printSchema(System.out);
+// } catch (AxisFault e) {
+// e.printStackTrace();
+// }
}
/**
@@ -103,7 +110,7 @@
private void generateSchemaForOutput(CallQuery callQuery , boolean
addComplexType) {
XmlSchemaComplexType methodSchemaType =
- createSchemaTypeForMethodPart(callQuery.getElementName() ,
addComplexType);
+ createSchemaTypeForMethodPart(callQuery.getElementName(),
callQuery , addComplexType);
XmlSchemaSequence sequence = new XmlSchemaSequence();
methodSchemaType.setParticle(sequence);
QName rawQName = generateSchemaForRaw(callQuery);
@@ -114,14 +121,21 @@
elt1.setMinOccurs(0);
elt1.setNillable(true);
elt1.setMaxOccurs(Long.MAX_VALUE);
+ //elt1.setQName(rawQName);
}
private QName generateSchemaForRaw(CallQuery callQuery) {
- XmlSchema xmlSchema = getXmlSchema(schemaTargetNameSpace);
- QName elementName =
- new QName(this.schemaTargetNameSpace, callQuery.getRawName(),
- this.schema_namespace_prefix);
+ //XmlSchema xmlSchema = getXmlSchema(schemaTargetNameSpace);
+ XmlSchema xmlSchema = getXmlSchema(callQuery.getDefaultNamespace());
+
+// QName elementName =
+// new QName(this.schemaTargetNameSpace, callQuery.getRawName(),
+// this.schema_namespace_prefix);
+
+ QName elementName = new QName(callQuery.getDefaultNamespace(),
callQuery.getRawName(),
+ callQuery.getNsPrefix());
+
XmlSchemaComplexType methodSchemaType =
getComplexTypeForElement(xmlSchema, elementName);
if (methodSchemaType == null) {
methodSchemaType = new XmlSchemaComplexType(xmlSchema);
@@ -129,13 +143,14 @@
xmlSchema.getItems().add(methodSchemaType);
xmlSchema.getElements().add(elementName, methodSchemaType);
}
- typeTable.addComplexSchema(callQuery.getRawName(), elementName);
+ typeTable.addComplexSchema(callQuery.getRawName(),
elementName);
+
XmlSchemaSequence sequence = new XmlSchemaSequence();
methodSchemaType.setParticle(sequence);
ArrayList outParams = callQuery.getOutputParms();
for (int i = 0; i < outParams.size(); i++) {
- QueryElement queryElement = (QueryElement) outParams.get(i);
- generateSchemaForQueryElement(queryElement, sequence);
+ Param param = (Param)outParams.get(i);
+ generateSchemaForQueryElement(param, sequence);
}
ArrayList hrefs = callQuery.getQueryRefList();
if (hrefs != null) {
@@ -144,12 +159,14 @@
QName refQname = typeTable.getQNamefortheType(ref);
if (refQname == null) {
CallQuery query = (CallQuery) queryRefMap.get(ref);
+ //if (query == null) {
if (query != null) {
refQname = generateTypeforRef(query);
}
if (refQname != null) {
XmlSchemaElement elt1 = new XmlSchemaElement();
- elt1.setName(query.getElementName());
+ //elt1.setName(query.getElementName());
+ elt1.setQName(refQname);
elt1.setSchemaTypeName(refQname);
sequence.getItems().add(elt1);
elt1.setMinOccurs(0);
@@ -169,13 +186,13 @@
return null;
}
- private void generateSchemaForQueryElement(QueryElement queryElement,
XmlSchemaSequence sequence) {
- QName schemaTypeName =
typeTable.getSimpleSchemaTypeName(queryElement.getClassType());
+ private void generateSchemaForQueryElement(Param param, XmlSchemaSequence
sequence) {
+ QName schemaTypeName =
typeTable.getSimpleSchemaTypeName(param.getSqlType());
if (schemaTypeName == null) {
//something has gone wrong.
} else {
XmlSchemaElement elt1 = new XmlSchemaElement();
- elt1.setName(queryElement.getName());
+ elt1.setName(param.getName());
elt1.setSchemaTypeName(schemaTypeName);
sequence.getItems().add(elt1);
elt1.setMinOccurs(0);
@@ -186,22 +203,24 @@
private void generateSchemaForInput(String operationName, CallQuery
callQuery, AxisMessage inMessage) {
XmlSchemaSequence sequence = new XmlSchemaSequence();
- XmlSchemaComplexType methodSchemaType =
createSchemaTypeForMethodPart(operationName , false);
+ XmlSchemaComplexType methodSchemaType =
createSchemaTypeForMethodPart(operationName,callQuery , false);
methodSchemaType.setParticle(sequence);
ArrayList inputParams = callQuery.getInputParms();
for (int i = 0; i < inputParams.size(); i++) {
- QueryElement queryElement = (QueryElement) inputParams.get(i);
- generateSchemaForQueryElement(queryElement, sequence);
+ Param param = (Param) inputParams.get(i);
+ if("IN".equals(param.getType())){
+ generateSchemaForQueryElement(param, sequence);
+ }
}
inMessage.setElementQName(typeTable.getQNamefortheType(operationName));
}
- private XmlSchemaComplexType createSchemaTypeForMethodPart(String
operationName ,
+ private XmlSchemaComplexType createSchemaTypeForMethodPart(String
operationName,CallQuery callQuery ,
boolean
addComplextype) {
- XmlSchema xmlSchema = getXmlSchema(schemaTargetNameSpace);
+ XmlSchema xmlSchema = getXmlSchema(callQuery.getDefaultNamespace());
QName elementName =
- new QName(this.schemaTargetNameSpace, operationName,
this.schema_namespace_prefix);
+ new QName(callQuery.getDefaultNamespace(), operationName,
callQuery.getNsPrefix());
XmlSchemaComplexType complexType = getComplexTypeForElement(xmlSchema,
elementName);
if (complexType == null) {
@@ -220,10 +239,9 @@
}
xmlSchema.getItems().add(globalElement);
xmlSchema.getElements().add(elementName, globalElement);
-// xmlSchema.getElements().add(elementName, globalElement);
}
- typeTable.addComplexSchema(operationName, elementName);
-
+ typeTable.addComplexSchema(operationName, elementName);
+
return complexType;
}
@@ -244,6 +262,10 @@
xmlSchema = new XmlSchema(targetNamespace, xmlSchemaCollection);
xmlSchema.setAttributeFormDefault(getAttrFormDefaultSetting());
xmlSchema.setElementFormDefault(getElementFormDefaultSetting());
+ //xmlSchema.setAttributeFormDefault(new
XmlSchemaForm(XmlSchemaForm.QUALIFIED));
+ //xmlSchema.setElementFormDefault(new
XmlSchemaForm(XmlSchemaForm.QUALIFIED));
+
+
targetNamespacePrefixMap.put(targetNamespace,
targetNamespacePrefix);
@@ -302,6 +324,11 @@
if (object instanceof XmlSchemaElement && ((XmlSchemaElement)
object).getQName().equals(name)) {
return (XmlSchemaComplexType) ((XmlSchemaElement)
object).getSchemaType();
}
+ else if (object instanceof XmlSchemaComplexType &&
((XmlSchemaComplexType) object).getQName().equals(name)) {
+ //return (XmlSchemaComplexType) ((XmlSchemaElement)
object).getSchemaType();
+ return (XmlSchemaComplexType) object;
+ }
+
}
return null;
}
Modified:
trunk/commons/data-services/src/main/java/org/wso2/ws/dataservice/QueryElement.java
==============================================================================
---
trunk/commons/data-services/src/main/java/org/wso2/ws/dataservice/QueryElement.java
(original)
+++
trunk/commons/data-services/src/main/java/org/wso2/ws/dataservice/QueryElement.java
Tue Jan 1 22:16:35 2008
@@ -17,31 +17,31 @@
public class QueryElement {
- private String name;
- private String classType ;
- private String columnName;
-
- public String getName() {
- return name;
- }
-
- public void setName(String name) {
- this.name = name;
- }
-
- public String getClassType() {
- return classType;
- }
-
- public void setClassType(String classType) {
- this.classType = classType;
- }
-
- public String getColumnName() {
- return columnName;
- }
-
- public void setColumnName(String columnName) {
- this.columnName = columnName;
- }
+// private String name;
+// private String classType ;
+// private String columnName;
+//
+// public String getName() {
+// return name;
+// }
+//
+// public void setName(String name) {
+// this.name = name;
+// }
+//
+// public String getClassType() {
+// return classType;
+// }
+//
+// public void setClassType(String classType) {
+// this.classType = classType;
+// }
+//
+// public String getColumnName() {
+// return columnName;
+// }
+//
+// public void setColumnName(String columnName) {
+// this.columnName = columnName;
+// }
}
Added:
trunk/commons/data-services/src/main/java/org/wso2/ws/dataservice/beans/Param.java
==============================================================================
--- (empty file)
+++
trunk/commons/data-services/src/main/java/org/wso2/ws/dataservice/beans/Param.java
Tue Jan 1 22:16:35 2008
@@ -0,0 +1,63 @@
+package org.wso2.ws.dataservice.beans;
+
+/**
+ *
+ * Object for query/param element
+ *
+ */
+
+public class Param {
+ String name;
+ String sqlType;
+ String type;
+ int ordinal;
+
+ String columnName;
+
+ public String getName() {
+ return name;
+ }
+ public void setName(String name) {
+ this.name = name;
+ }
+ public String getSqlType() {
+ return sqlType;
+ }
+ public void setSqlType(String sqlType) {
+ this.sqlType = sqlType;
+ }
+ public String getType() {
+ return type;
+ }
+ public void setType(String type) {
+ this.type = type;
+ }
+
+ public int getOrdinal() {
+ return ordinal;
+ }
+ public void setOrdinal(int ordinal) {
+ this.ordinal = ordinal;
+ }
+
+ public String getColumnName() {
+ return columnName;
+ }
+ public void setColumnName(String columnName) {
+ this.columnName = columnName;
+ }
+ public Param(String name,String sqlType,String type,String ordinal){
+ this.name = name;
+ this.sqlType = sqlType;
+ this.type = type;
+ this.ordinal = Integer.valueOf(ordinal).intValue();;
+ }
+ public Param(String name,String sqlType,String type){
+ this.name = name;
+ this.sqlType = sqlType;
+ this.type = type;
+ }
+ public Param(){
+ }
+
+}
\ No newline at end of file
Added:
trunk/commons/data-services/src/main/java/org/wso2/ws/dataservice/beans/Query.java
==============================================================================
--- (empty file)
+++
trunk/commons/data-services/src/main/java/org/wso2/ws/dataservice/beans/Query.java
Tue Jan 1 22:16:35 2008
@@ -0,0 +1,58 @@
+package org.wso2.ws.dataservice.beans;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+
+import javax.xml.namespace.QName;
+import org.apache.axiom.om.OMElement;
+
+public class Query {
+ String id;
+ Param[] params;
+
+ public String getId() {
+ return id;
+ }
+ public void setId(String id) {
+ this.id = id;
+ }
+ public Param[] getParams() {
+ return params;
+ }
+ public void setParams(Param[] params) {
+ this.params = params;
+ }
+
+ public Param getParam(String name){
+ for (int a = 0; a < this.params.length; a++) {
+ if(params[a].getName().equals(name)){
+ return params[a];
+ }
+ }
+ return null;
+ }
+
+ public Query(Iterator paramItr){
+ Param param;
+ ArrayList paramList = new ArrayList();
+ while (paramItr.hasNext()) {
+ OMElement paramElement = (OMElement) paramItr.next();
+ param = new Param(paramElement.getAttributeValue(new
QName("name")),
+
paramElement.getAttributeValue(new QName("sqlType")),
+
paramElement.getAttributeValue(new QName("type")),
+
paramElement.getAttributeValue(new QName("ordinal")));
+ paramList.add(param);
+ }
+ try{
+ Param[] params = new Param[paramList.size()];
+ paramList.toArray(params);
+ //Param[] params = (Param[])paramList.toArray();
+ setParams(params);
+ }catch(Exception e){
+ e.printStackTrace();
+ }
+
+ }
+
+
+}
_______________________________________________
Commons-dev mailing list
[email protected]
http://wso2.org/cgi-bin/mailman/listinfo/commons-dev
