import  java.io.*;
 import  javax.servlet.*;
 import  javax.servlet.http.*;
 import  ua.od.intes.*;
 import  java.lang.reflect.*;
/**
 * Main servlet class. Gets request from client, loades proper class, responsible for 
 * that request and returns answer in json format. 
 * @author Krot Vyacheslav
 *
 */
 public   class  CBackEnd  extends  HttpServlet 
{
	 public   void  doGet(HttpServletRequest request,
					  HttpServletResponse response)
					   throws  ServletException, IOException
	{	
		// always return data in json format
		response.setContentType("text/html");
		PrintWriter out = response.getWriter();
		// check whitch action user requests. Action is proveded by dojo frontend
		String strAction = request.getParameter("action");
		String strParams = request.getParameter("params");
		 if (strAction ==  null )
		{
			// no action specified. return error.
			out.write(CUtils.jsonError("No action specified in request"));
			out.close();
			 return ;
		}

		// load proper class and invoke single method returning required data in json format
		// all data to function is passed as single json string 
		 try 
		{
			// load class
			 Class  requestHandler =  Class .forName("ua.od.intes." + strAction);
			// parameters list for method to invoke
			 Class  [] paramTypes = {String. class };  
			Method handlerMethod = requestHandler.getMethod("getData", paramTypes);
			// create new instance of class
			Object handlerInstance = requestHandler.newInstance();
				
			// fill params
			Object[] parameters = { strParams };
			// invoke method
			Object retobj = handlerMethod.invoke(handlerInstance, parameters);
			out.write(retobj.toString());
		}
		 catch (ClassNotFoundException ex)
		{
			out.write(CUtils.jsonError("Internal error: Class for required action not found"));
		}
		 catch (Exception ex)
		{
			out.write(CUtils.jsonError("Internal error:" + ex.getCause().getMessage()));
			ex.printStackTrace();
		}
		 finally 
		{
			out.close();
		}
	}	
}

 package  ua.od.intes;

 import  java.sql.*;
 import  javax.sql.DataSource;
 import  javax.naming.*;
 import  java.io.File;
 import  java.util.*;
 import  javax.xml.parsers.DocumentBuilder;
 import  javax.xml.parsers.DocumentBuilderFactory;
 import  org.w3c.dom.Document;
 import  org.w3c.dom.Element;
 import  org.w3c.dom.Node;
 import  org.w3c.dom.NodeList;

/**
 *	Establishes connection to database and provides connection descriptor. 
 *	Supports connection pooling. 
 *	@author		Krot Vyacheslav
 *  @version	0.1
 */ 
 public   class  CDBConn 
{
	// connection descriptor
	 private  Connection dbConn;

	// file with connection parameters
	 private  String configFileName = "webapps\\test_3\\config\\config.xml";
	
	/**
	 * Openes new connection to database
	 * @param withConnectionPooling Determines wheather to use or not connection pooling
	 * @throws Exception If an error occures it's description is returned in Exception
	 */
	 public   void  connect( boolean  withConnectionPooling)
				 throws  Exception
	{
		 try 
		{
			// load proper class for mysql jdbc driver at runtime
			 Class .forName("org.gjt.mm.mysql.Driver");			
			 try 
			{			
				 if (withConnectionPooling == true)
				{
					// connection pooling
					 try  
					{	
						// Create a JNDI Initial context to be able to lookup  the DataSource
						InitialContext ctx =  new  InitialContext();
						// Lookup the DataSource
						DataSource ds = (DataSource)ctx.lookup("java:comp/env/jdbc/conversion");
						dbConn = ds.getConnection();
					}
					 catch  (NamingException ex)
					{
						 throw   new  Exception(
						        "Cannot retrieve java:comp/env/jdbc/conversion", ex);
					}
				}
				 else 
				{
					HashMap connParams = readConfig(configFileName);
					dbConn = DriverManager.getConnection(
							"jdbc:mysql://" + connParams.get("hostname") + "/" + connParams.get("db_name") + "?" + 
							"user=" + connParams.get("username") + "&password=" + connParams.get("passwd"));					
				}
			}
			 catch  (SQLException ex)
			{
				 throw   new  
			      Exception("Error connecting to database", ex);
			}
		}
		 catch (ClassNotFoundException ex)
		{
			 throw   new  
		      Exception("Error conneting to database: JDBC driver not found", ex);			
		}	
	}
	

	/**
	 * Closes openned connection to database
	 * @throws Exception
	 */
	 public   void  disconnect()
	   			 throws  Exception	
	{
		 if (dbConn ==  null )
		{
			 throw   new  
		      Exception("Failed to close connection: connection not openned");			
		}
		 try 
		{				
			dbConn.close();
			dbConn =  null ;
		}
		 catch  (SQLException ex)
		{
			 throw   new  
		      Exception("Failed to close connection", ex);
		}		
	}
	
	/**
	 * Returns connection descriptor for openned connection
	 * @return Connection descriptor
	 * @throws Exception
	 */
	 public  Connection getConn()
					   throws  Exception
	{
		 if (dbConn ==  null )
			 throw   new  Exception("Failed to return connection: connection not openned");
		 else 
			 return  dbConn;
	}
	
	/**
	 * Reades parameters of connection from specified XML file. Format of file is strongly defined
	 * @param filename
	 * @return HashMap with corresponding parameters
	 * @throws ServletException
	 */
	 public  HashMap readConfig(String filename)
				 throws  Exception
	{
		// returned results
		HashMap<String,String> map =  new  HashMap();
		 try  
		{
			// open file with XML config
			File file =  new  File(filename);
			DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
			DocumentBuilder db = dbf.newDocumentBuilder();
			Document doc = db.parse(file);
			doc.getDocumentElement().normalize();
			NodeList nodeLst = doc.getElementsByTagName("db_config");
			 if (nodeLst.getLength() !=  1 )
			{
				 throw   new  Exception("Failed to loading config file: invalid format",  new  java.lang.Throwable());
			}			
			// read data from node
			Node cNode = nodeLst.item( 0 );
			 if  (cNode.getNodeType() == Node.ELEMENT_NODE) 
			{
				Element fstElmnt = (Element) cNode;
				NodeList lstNmElmntLst = fstElmnt.getElementsByTagName("username");
				Element lstNmElmnt = (Element) lstNmElmntLst.item( 0 );
				NodeList lstNm = lstNmElmnt.getChildNodes();
				map.put("username", ((Node) lstNm.item( 0 )).getNodeValue());
				
				lstNmElmntLst = fstElmnt.getElementsByTagName("passwd");
				lstNmElmnt = (Element) lstNmElmntLst.item( 0 );
				lstNm = lstNmElmnt.getChildNodes();
				map.put("passwd", ((Node) lstNm.item( 0 )).getNodeValue());
				
				lstNmElmntLst = fstElmnt.getElementsByTagName("hostname");
				lstNmElmnt = (Element) lstNmElmntLst.item( 0 );
				lstNm = lstNmElmnt.getChildNodes();
				map.put("hostname", ((Node) lstNm.item( 0 )).getNodeValue());

				lstNmElmntLst = fstElmnt.getElementsByTagName("db_name");
				lstNmElmnt = (Element) lstNmElmntLst.item( 0 );
				lstNm = lstNmElmnt.getChildNodes();
				map.put("db_name", ((Node) lstNm.item( 0 )).getNodeValue());
			}
			 else 
			{
				 throw   new  Exception("Failed to load configuration file: invalid format");
			}
			
		} 
		 catch  (Exception ex) 
		{
			 throw   new  Exception("Failed to load configuration file", ex);
		}	
		
		 return  map;
	}	
}

 package  ua.od.intes;

 import  java.sql.*;

 import  org.json.*;

/**
 * Gets list of types from database
 * @author Krot Vyacheslav
 *
 */
 public   class  GetTypes 
{
	 public  String getData(String strParams)
				   throws  Exception
	{
		// local variables requiered to get data from database
		Connection dbConn =  null ;
		PreparedStatement stmt =  null ;
		ResultSet results =  null ;
	
		// open new connection
		CDBConn conn =  new  CDBConn();
		conn.connect(true);
		dbConn = conn.getConn();
		
		// json object for returning data	
		org.json.JSONArray pData =  new  org.json.JSONArray();	
		 try 
		{
			stmt = dbConn.prepareStatement("SELECT id, name FROM types");

			// execute query and put results in json object
			results = stmt.executeQuery();
			ResultSetMetaData metaData = results.getMetaData();
			 while (results.next())
			{		
				JSONArray pSubData =  new  JSONArray();
				// put all returned fields into array
				 for ( int  i =  0 ; i < metaData.getColumnCount(); i++)
				{					
					pSubData.put(results.getString(i+ 1 ));
				}
				pData.put(pSubData);					
			}
		}
		 catch (SQLException ex)
		{
			 throw   new  
				Exception("Error reading data from database", ex);
		}
		 finally 
		{
			// close connection and statement
			 try 
			{
				results.close();
				results =  null ;
				stmt.close();
				stmt =  null ;
			}
			 catch (Exception ex)
			{  
				// nothing could be done about it
			}
			conn.disconnect();
		}
		 return  pData.toString();
	}
}