Changes done in ProteusDataSource.java (bean folder) created and changes done...

Changes done in ProteusDataSource.java (bean folder) created and changes done in UtilMethods.java during migration of employee leave validation and confirmation


git-svn-id: http://15.206.35.175/svn/proteus/business-java/trunk@106468 ce508802-f39f-4f6c-b175-0d175dae99d5

webitm-sys/ibase/webitm/bean/sys/ProteusDataSource.java

+/*
+
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<Root>
+	<Detail1>
+		<id>1</id>
+		<name>Pankaj</name>
+		<age>29</age>
+		<role>Java Developer</role>
+		<gender>Male</gender>
+	</Detail1>
+	<Detail1>
+		<id>2</id>
+		<name>Lisa</name>
+		<age>35</age>
+		<role>CSS Developer</role>
+		<gender>Female</gender>
+	</Detail1>
+</Root>
+
+*/
+
+
+
+
+package ibase.webitm.bean.sys;
+
+import ibase.utility.E12GenericUtility;
+import ibase.utility.UserInfoBean;
+import ibase.webitm.utility.GenericUtility;
+import ibase.webitm.utility.ITMException;
+import ibase.system.config.ConnDriver;
+import ibase.utility.CommonConstants;
+
+import java.text.SimpleDateFormat;
+import java.util.*;
+import java.io.File;
+import java.io.IOException;
+import java.io.StringWriter;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import javax.servlet.http.HttpSession;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerException;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+import org.xml.sax.SAXException;
+
+public class ProteusDataSource 
+{
+	E12GenericUtility genericUtility = new E12GenericUtility();
+	private String dataObjNmae = "";
+	private String dataSourceSQL = "";
+	private Connection transactionObject = null;
+	private	int rowCount = 0;
+	private int columnCount = 0;
+	private HashMap modifiedRowMap = new HashMap();
+	private HashMap columnsAttributeMap = new HashMap();
+	private Document editDom = null;
+	private	String objName = "";
+	private	int formNo = 0;
+	private	NodeList parentNodeList = null;
+	private	NodeList childNodeList = null;
+	private String formTagName = null;
+	private String[] columnList;
+
+	public ProteusDataSource( String objName, String domStr , int formNo) throws ITMException
+	{
+		Document localDom = null;
+		Node parentNode = null;
+		String childNodeName = "";
+		try
+		{
+			if (domStr.indexOf("<Root>") == -1)
+			{
+				domStr = "<Root>\r\n" + domStr + "</Root>";
+			}
+			localDom = genericUtility.parseString(domStr);
+			initiateProteusDataSource(objName, localDom, formNo);
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+
+	}
+
+	public ProteusDataSource( String objName, Document argDom , int formNo) throws ITMException
+	{
+		try
+		{
+			String domStr = genericUtility.serializeDom(argDom);
+			if (domStr.indexOf("<Root>") == -1)
+			{
+				domStr = "<Root>\r\n" + domStr + "</Root>";
+			}
+			argDom = genericUtility.parseString(domStr);
+			initiateProteusDataSource(objName, argDom, formNo);
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}		
+	}
+
+	private void initiateProteusDataSource( String objName, Document argDom , int formNo) throws ITMException
+	{
+		Node parentNode = null;
+		String childNodeName = "";
+		Node childNode = null;
+		try
+		{
+			this.objName = objName;
+			this.editDom = argDom;
+			this.formNo = formNo;
+			this.parentNodeList = this.editDom.getElementsByTagName("Detail" + formNo);
+			this.rowCount = this.parentNodeList.getLength();
+			parentNode = this.parentNodeList.item(0);
+			this.childNodeList = parentNode.getChildNodes();
+			int childNodeListLength = this.childNodeList.getLength();
+			this.columnCount = childNodeListLength;
+			this.formTagName = "Detail" + this.formNo;
+			System.out.println("serialize editDom ::"+genericUtility.serializeDom(this.editDom));
+			this.columnList = new String[childNodeListLength];
+			for(int ctr = 0; ctr < childNodeListLength; ctr++)
+			{
+				childNode = childNodeList.item(ctr);
+				if (childNode.getNodeType() != Node.ELEMENT_NODE) 
+				{
+					continue;
+				}
+				this.columnList[ctr] = childNodeList.item(ctr).getNodeName();
+				this.columnsAttributeMap.put((String)childNodeList.item(ctr).getNodeName().trim() + "_protect" , "X");
+			}
+		
+
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}		
+	}
+
+
+	public int setItem(int rowNum, String columnName ,  int columnValue) throws ITMException
+	{
+		Element element = null;
+		Node node = null;
+		int returnValue = 0;
+		try
+		{
+			element = (Element) this.parentNodeList.item(rowNum - 1);
+			node = element.getElementsByTagName(columnName).item(0).getFirstChild();
+			node.setNodeValue("" + columnValue);
+			ArrayList modifiedColNames = new ArrayList();
+			if (this.modifiedRowMap.get(rowNum) != null)
+			{
+				modifiedColNames = (ArrayList)this.modifiedRowMap.get(rowNum);
+			}
+			if (!modifiedColNames.contains(columnName))
+			{
+				modifiedColNames.add(columnName);
+				this.modifiedRowMap.put(rowNum , modifiedColNames);
+			}
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return returnValue;
+	}
+
+	public int setItem(int rowNum, String columnName ,  String columnValue) throws ITMException
+	{
+		Element element = null;
+		Node node = null;
+		int returnValue = 0;
+		try
+		{
+			element = (Element) this.parentNodeList.item(rowNum - 1);
+			node = element.getElementsByTagName(columnName).item(0).getFirstChild();
+			node.setNodeValue(columnValue);
+			ArrayList modifiedColNames = new ArrayList();
+			if (this.modifiedRowMap.get(rowNum) != null)
+			{
+				modifiedColNames = (ArrayList)this.modifiedRowMap.get(rowNum);
+			}
+			if (!modifiedColNames.contains(columnName))
+			{
+				modifiedColNames.add(columnName);
+				this.modifiedRowMap.put(rowNum , modifiedColNames);
+			}
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return returnValue;
+	}
+
+	public int setItem(int rowNum, String columnName ,  double columnValue) throws ITMException
+	{
+		Element element = null;
+		Node node = null;
+		int returnValue = 0;
+		try
+		{
+			element = (Element) this.parentNodeList.item(rowNum - 1);
+			node = element.getElementsByTagName(columnName).item(0).getFirstChild();
+			node.setNodeValue("" + columnValue);
+			ArrayList modifiedColNames = new ArrayList();
+			if (this.modifiedRowMap.get(rowNum) != null)
+			{
+				modifiedColNames = (ArrayList)this.modifiedRowMap.get(rowNum);
+			}
+			if (!modifiedColNames.contains(columnName))
+			{
+				modifiedColNames.add(columnName);
+				this.modifiedRowMap.put(rowNum , modifiedColNames);
+			}
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return returnValue;
+	}
+
+	public String getItemString(int rowNum, String columnName) throws ITMException
+	{
+		Node parentNode = null;
+		Node childNode = null;
+		NodeList childNodeList = null;
+		String columnValue = null;
+		String returnValue = null;
+		int childNodeListLength = 0;
+		try
+		{
+			parentNode =  this.parentNodeList.item(rowNum - 1);
+			childNodeList = parentNode.getChildNodes();
+			childNodeListLength = childNodeList.getLength();
+			for (int childRow = 0; childRow < childNodeListLength; childRow++)
+			{
+				childNode = childNodeList.item(childRow);
+				if( childNode.getNodeType() != Node.ELEMENT_NODE )
+				{
+					continue;
+				}
+				String childNodeName = childNode.getNodeName(); 
+				if (!childNodeName.equals(columnName))
+				{
+					continue;
+				}
+				if (childNode.getFirstChild() != null)
+				{
+					columnValue = childNode.getFirstChild().getNodeValue();
+				}
+				if (columnValue != null && !columnValue.equalsIgnoreCase("null") && !columnValue.equalsIgnoreCase("<null>") && columnValue.length() > 0)
+				{
+					returnValue = columnValue;
+				}
+			}
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return returnValue;
+	}
+
+/*
+	public String getItemString(int rowNum, String columnName) throws ITMException
+	{
+		Element element = null;
+		String columnValue = null;
+		String returnValue = null;
+		try
+		{
+			element = (Element) this.parentNodeList.item(rowNum - 1);
+			columnValue = element.getElementsByTagName(columnName).item(0).getFirstChild().getNodeValue();
+			if (columnValue != null && !columnValue.equalsIgnoreCase("null") && !columnValue.equalsIgnoreCase("<null>") && columnValue.length() > 0)
+			{
+				returnValue = columnValue;
+			}
+
+			
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return returnValue;
+	}
+*/
+
+	public Integer getItemNumber(int rowNum, String columnName) throws ITMException
+	{
+		String columnValue = null;
+		Integer returnValue = null;
+		try
+		{
+
+			columnValue = getItemString(rowNum , columnName);
+			if (columnValue != null && !columnValue.equalsIgnoreCase("null") && !columnValue.equalsIgnoreCase("<null>") && columnValue.length() > 0)
+			{
+				returnValue = Integer.parseInt(columnValue);
+			}
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return returnValue;
+	}
+
+
+	public Integer getItemNumber(int rowNum, String columnName, Integer i) throws ITMException
+	{
+		String columnValue = null;
+		Integer returnValue = null;
+		try
+		{
+			columnValue = getItemString(rowNum , columnName);
+			if (columnValue != null && !columnValue.equalsIgnoreCase("null") && !columnValue.equalsIgnoreCase("<null>") && columnValue.length() > 0)
+			{
+				int decPos = columnValue.indexOf(".");
+				if (decPos != -1)
+				{
+					if (decPos > 0)
+					{
+						columnValue = columnValue.substring(0 , decPos);
+					}
+					else
+					{
+						columnValue = "0";
+					}
+				}
+				returnValue = Integer.parseInt(columnValue);
+			}
+			
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return returnValue;
+	}
+
+
+	public Double getItemNumber(int rowNum, String columnName, Double d) throws ITMException
+	{
+		String columnValue = null;
+		Double returnValue = null;
+		try
+		{
+			columnValue = getItemString(rowNum , columnName);
+			if (columnValue != null && !columnValue.equalsIgnoreCase("null") && !columnValue.equalsIgnoreCase("<null>") && columnValue.length() > 0)
+			{
+				returnValue = Double.parseDouble(columnValue);
+			}
+			
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return returnValue;
+	}
+
+
+	public Double getItemDecimal(int rowNum, String columnName) throws ITMException
+	{
+		String columnValue = null;
+		Double returnValue = null;
+		try
+		{
+			columnValue = getItemString(rowNum , columnName);
+			if (columnValue != null && !columnValue.equalsIgnoreCase("null") && !columnValue.equalsIgnoreCase("<null>") && columnValue.length() > 0)
+			{
+				returnValue = Double.parseDouble(columnValue);
+			}
+			
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return returnValue;
+	}
+
+	public java.sql.Timestamp getItemDateTime(int rowNum, String columnName) throws ITMException
+	{
+		String columnValue = null;
+		java.sql.Timestamp returnValue = null;
+		try
+		{
+			columnValue = getItemString(rowNum , columnName);
+			if (columnValue != null && !columnValue.equalsIgnoreCase("null") && !columnValue.equalsIgnoreCase("<null>") && columnValue.length() > 0)
+			{
+				returnValue = java.sql.Timestamp.valueOf(genericUtility.getValidDateTimeString(columnValue, genericUtility.getApplDateFormat(), genericUtility.getDBDateFormat()));
+			}
+		}
+		catch (Exception e)
+		{
+			//throw new ITMException(e);
+			returnValue = null;
+		}
+		return returnValue;
+	}
+
+	public java.sql.Date getItemDate(int rowNum, String columnName) throws ITMException
+	{
+		String columnValue = null;
+		java.sql.Date returnValue = null;
+		try
+		{
+			columnValue = getItemString(rowNum , columnName);
+			if (columnValue != null && !columnValue.equalsIgnoreCase("null") && !columnValue.equalsIgnoreCase("<null>") && columnValue.length() > 0)
+			{
+				returnValue = java.sql.Date.valueOf(genericUtility.getValidDateString(columnValue, genericUtility.getApplDateFormat(), genericUtility.getDBDateFormat()));
+			}
+		}
+		catch (Exception e)
+		{
+			//throw new ITMException(e);
+			returnValue = null;
+		}
+		return returnValue;
+	}
+
+
+	public String getXmlString() throws ITMException
+	{
+		String output = null;
+		try 
+		{
+			output = genericUtility.serializeDom(this.editDom);
+		} 
+		catch (Exception e) 
+		{
+			System.out.println("HHHHH::: " + e);
+			e.printStackTrace();
+			throw new ITMException(e);
+		}
+        return output;
+    }
+
+	public String getXmlString(String s) throws ITMException
+	{
+		String output = null;
+		StringBuffer xmlString = new StringBuffer();
+
+		xmlString.append("<?xml version=\"1.0\"?>\r\n<Root>\r\n<Header>\r\n<editFlag>");
+		xmlString.append("A").append("</editFlag>\r\n</Header>\r\n");
+		try 
+		{
+
+
+			for (int i=0; i<this.rowCount; i++)
+			{
+				xmlString.append("<" + formTagName + ">\r\n");
+				for (int j=0; j < this.columnCount; j++)
+				{
+					String columnValue = getItemString(i+1 ,this.columnList[j]);
+					String columnProtect = (String)this.columnsAttributeMap.get(this.columnList[j] + "_protect");
+					if (columnProtect != null && columnProtect.length() > 0 && !columnProtect.equalsIgnoreCase("X"))
+					{
+						columnProtect = " protect='" + columnProtect + "'";
+					}
+					else
+					{
+						columnProtect = "";
+					}
+					xmlString.append("<" + this.columnList[j] + columnProtect + ">");
+					if (columnValue != null && !columnValue.equalsIgnoreCase("null") && !columnValue.equalsIgnoreCase("<null>") && columnValue.length() > 0)
+					{
+						xmlString.append("<![CDATA[" + columnValue + "]]>");
+					}
+					xmlString.append("</" +this.columnList[j] + ">\r\n");
+				}
+				xmlString.append("</" + formTagName + ">\r\n");
+			}			
+			xmlString.append("</Root>");
+			output = xmlString.toString();
+		} 
+		catch (Exception e) 
+		{
+			System.out.println("HHHHH::: " + e);
+			e.printStackTrace();
+			throw new ITMException(e);
+		}
+        return output;
+    }
+
+	public String getChangedXmlString() throws ITMException
+	{
+		String output = null;
+		int key = 0;
+		Integer ikey = 0;
+		int modifiedColumnCounts = 0;
+		StringBuffer xmlString = new StringBuffer();
+		ArrayList modifiedColumnList = new ArrayList();
+
+		xmlString.append("<?xml version=\"1.0\"?>\r\n<Root>\r\n<Header>\r\n<editFlag>");
+		xmlString.append("A").append("</editFlag>\r\n</Header>\r\n");
+		try 
+		{
+			Iterator keySetIterator = this.modifiedRowMap.keySet().iterator();
+			while(keySetIterator.hasNext())
+			{ 
+				key = (int)keySetIterator.next(); 
+				modifiedColumnList = (ArrayList)this.modifiedRowMap.get(key);
+				modifiedColumnCounts = modifiedColumnList.size();
+				if (modifiedColumnCounts > 0)
+				{
+					xmlString.append("<" + formTagName + ">\r\n");
+					String[] modifiedColumnNames ;
+					modifiedColumnNames = new String[modifiedColumnCounts];
+					for (int i = 0; i < modifiedColumnCounts; i++)
+					{
+						modifiedColumnNames[i] = modifiedColumnList.get(i).toString();
+						String columnValue = getItemString(key , modifiedColumnNames[i]);
+						String columnProtect = (String)this.columnsAttributeMap.get(modifiedColumnNames[i] + "_protect");
+						if (columnProtect != null && columnProtect.length() > 0 && !columnProtect.equalsIgnoreCase("X"))
+						{
+							columnProtect = " protect='" + columnProtect + "'";
+						}
+						else
+						{
+							columnProtect = "";
+						}
+						xmlString.append("<" + modifiedColumnNames[i] + columnProtect + ">");
+						if (columnValue != null && !columnValue.equalsIgnoreCase("null") && !columnValue.equalsIgnoreCase("<null>") && columnValue.length() > 0)
+						{
+							xmlString.append("<![CDATA[" + columnValue + "]]>");
+						}
+						xmlString.append("</" + modifiedColumnNames[i] + ">\r\n");
+					}
+				}
+				modifiedColumnList.clear();
+				modifiedColumnCounts = 0;
+				xmlString.append("</" + formTagName + ">\r\n");
+			}
+			xmlString.append("</Root>");
+			output = xmlString.toString();
+		} 
+		catch (Exception e) 
+		{
+			System.out.println("HHHHH::: " + e);
+			e.printStackTrace();
+			throw new ITMException(e);
+		}
+        return output;
+    }
+
+	public int getRowCount() throws ITMException
+	{
+		String output = null;
+		try 
+		{
+			this.parentNodeList = this.editDom.getElementsByTagName(formTagName);
+			this.rowCount = this.parentNodeList.getLength();
+		} 
+		catch (Exception e) 
+		{
+			throw new ITMException(e);
+		}
+        return this.rowCount;
+    }
+
+	public int insertRow(int rowPos) throws ITMException
+	{
+		NodeList rootNode = null;
+		Element element = null;
+		Element newElement = null;
+		ArrayList modifiedColNames = new ArrayList();
+		try 
+		{
+
+			rootNode = this.editDom.getElementsByTagName("Root");
+			element = (Element)rootNode.item(0);
+				System.out.println("\r\n Inside Insert Row 1");
+			newElement = this.editDom.createElement(this.formTagName);
+				System.out.println("\r\n Inside Insert Row 2");
+			newElement.appendChild(this.editDom.createTextNode(""));
+            element.appendChild(newElement);
+				System.out.println("\r\n Inside Insert Row 3");
+			this.parentNodeList = this.editDom.getElementsByTagName(formTagName);
+				System.out.println("\r\n Inside Insert Row 4");
+			this.rowCount = this.parentNodeList.getLength();
+				System.out.println("\r\n Inside Insert Row 5 --- " + this.rowCount);
+			element = (Element)this.parentNodeList.item(this.rowCount);
+				System.out.println("\r\n Inside Insert Row 6");
+				System.out.println("\r\n Inside Insert Row 6 -- " + this.columnCount);
+			for ( int ctr = 0;ctr < this.columnCount; ctr++)
+			{
+				newElement = this.editDom.createElement(this.columnList[ctr]);
+				System.out.println("\r\n Inside Insert Row 7");
+				newElement.appendChild(this.editDom.createTextNode(""));
+				System.out.println("\r\n Inside Insert Row 8");
+				element = (Element)this.parentNodeList.item(this.rowCount - 1);
+				System.out.println("\r\n Inside Insert Row 9");
+				element.appendChild(newElement);
+				System.out.println("\r\n Inside Insert Row 10");
+				modifiedColNames.add(this.columnList[ctr]);
+			}
+			this.modifiedRowMap.put(this.rowCount , modifiedColNames);
+		} 
+		catch (Exception e) 
+		{
+			e.printStackTrace();
+			throw new ITMException(e);
+		}
+        return rowCount;
+    }
+
+	public void modifyDsAttribute(String columnName , String columnAttributeName , String columnAttributeValue) throws ITMException
+	{
+		try
+		{
+			String columnAttribute = columnName.trim() + "_" + columnAttributeName.trim();
+			System.out.println("columnAttribute::: " + columnAttribute);
+			this.columnsAttributeMap.put(columnAttribute , columnAttributeValue);
+			for (int i=1; i <= this.rowCount; i++)
+			{
+				ArrayList modifiedColNames = new ArrayList();
+				if (this.modifiedRowMap.get(i) != null)
+				{
+					modifiedColNames = (ArrayList)this.modifiedRowMap.get(i);
+				}
+				if (!modifiedColNames.contains(columnName))
+				{
+					modifiedColNames.add(columnName);
+					this.modifiedRowMap.put(i , modifiedColNames);
+				}
+			}
+		}
+		catch (Exception e)
+		{
+			System.out.println("HHHHH::: " + e);
+			e.printStackTrace();
+			throw new ITMException(e);
+		}
+	}
+
+}

webitm-sys/ibase/webitm/ejb/sys/UtilMethods.java

@@ -5,6 +5,8 @@ import java.text.SimpleDateFormat;
 import java.text.DecimalFormat;
 import java.util.Calendar;
 import java.util.Date;
+import ibase.webitm.utility.ITMException;
+import org.w3c.dom.*;
 
 public class UtilMethods {
 	public UtilMethods(){
@@ -249,5 +251,1064 @@ public class UtilMethods {
     	return totHHMM;
     }
     
+	//***** Modified by Vishal on 23/06/2017.Start
+	public Date today()
+    {
+		Calendar rightNow = Calendar.getInstance();
+		rightNow.clear(Calendar.HOUR);
+		rightNow.clear(Calendar.MINUTE);
+		rightNow.clear(Calendar.SECOND);
+		rightNow.clear(Calendar.MILLISECOND);
+		Date today = rightNow.getTime();
+		return today;
+	}
+    public java.sql.Date todaySqlDate()
+    {
+		java.sql.Date today =  new java.sql.Date(System.currentTimeMillis());
+		return today;
+	}
+
+	public java.sql.Time now()
+	{
+		return new java.sql.Time(System.currentTimeMillis());
+	}
+
+	public java.sql.Date getSqlDate(java.sql.Timestamp ts1)  throws ITMException
+	{
+		java.sql.Date sd = null;
+		try
+		{
+			sd = new java.sql.Date(ts1.getTime());
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return sd;
+	}
+   
+	public java.sql.Date date(java.sql.Timestamp ts1)  throws ITMException
+	{
+		java.sql.Date sd = null;
+		try
+		{
+			sd = new java.sql.Date(ts1.getTime());
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return sd;
+	}
+   
+	public java.sql.Date getSqlDate(int year, int month, int day)  throws ITMException
+	{
+		Calendar rightNow = Calendar.getInstance();
+		java.sql.Date today = null;
+		try
+		{
+			rightNow.set(Calendar.DAY_OF_MONTH , day);
+			rightNow.set(Calendar.	MONTH , month - 1);
+			rightNow.set(Calendar.YEAR , year);
+			rightNow.clear(Calendar.HOUR);
+			rightNow.clear(Calendar.MINUTE);
+			rightNow.clear(Calendar.SECOND);
+			rightNow.clear(Calendar.MILLISECOND);
+			java.util.Date dt = rightNow.getTime();
+			today = new java.sql.Date(dt.getTime());
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return today;
+	}
+
+	public java.sql.Date date(int year, int month, int day)  throws ITMException
+	{
+		Calendar rightNow = Calendar.getInstance();
+		java.sql.Date today = null;
+		try
+		{
+			rightNow.set(Calendar.DAY_OF_MONTH , day);
+			rightNow.set(Calendar.	MONTH , month - 1);
+			rightNow.set(Calendar.YEAR , year);
+			rightNow.clear(Calendar.HOUR);
+			rightNow.clear(Calendar.MINUTE);
+			rightNow.clear(Calendar.SECOND);
+			rightNow.clear(Calendar.MILLISECOND);
+			java.util.Date dt = rightNow.getTime();
+			today = new java.sql.Date(dt.getTime());
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return today;
+	}
+
+
+	public int year(java.sql.Date sd)  throws ITMException
+	{
+		Calendar rightNow = Calendar.getInstance();
+		int year = 0;
+		try
+		{
+			rightNow.setTime(sd);
+			year = rightNow.get(Calendar.YEAR);
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return year;
+	}
+
+	public int year(java.util.Date sd)  throws ITMException
+	{
+		Calendar rightNow = Calendar.getInstance();
+		int year = 0;
+		try
+		{
+			rightNow.setTime(sd);
+			year = rightNow.get(Calendar.YEAR);
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return year;
+	}
+
+	public int year(java.sql.Timestamp st)  throws ITMException
+	{
+		Calendar rightNow = Calendar.getInstance();
+		int year = 0;
+		try
+		{
+			rightNow.setTime(st);
+			year = rightNow.get(Calendar.YEAR);
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return year;
+	}
+
+	public int month(java.sql.Date sd)  throws ITMException
+	{
+		Calendar rightNow = Calendar.getInstance();
+		int month = 0;
+		try
+		{
+			rightNow.setTime(sd);
+			month = rightNow.get(Calendar.MONTH) + 1;
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return month;
+	}
+
+	public int month(java.util.Date sd)  throws ITMException
+	{
+		Calendar rightNow = Calendar.getInstance();
+		int month = 0;
+		try
+		{
+			rightNow.setTime(sd);
+			month = rightNow.get(Calendar.MONTH) + 1;
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return month;
+	}
+
+	public int month(java.sql.Timestamp st)  throws ITMException
+	{
+		Calendar rightNow = Calendar.getInstance();
+		int month = 0;
+		try
+		{
+			rightNow.setTime(st);
+			month = rightNow.get(Calendar.MONTH) + 1;
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return month;
+	}
+
+	public int day(java.sql.Date sd)  throws ITMException
+	{
+		Calendar rightNow = Calendar.getInstance();
+		int day = 0;
+		try
+		{
+			rightNow.setTime(sd);
+			day = rightNow.get(Calendar.DAY_OF_MONTH);
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return day;
+	}
+
+	public int day(java.util.Date sd)  throws ITMException
+	{
+		Calendar rightNow = Calendar.getInstance();
+		int day = 0;
+		try
+		{
+			rightNow.setTime(sd);
+			day = rightNow.get(Calendar.DAY_OF_MONTH);
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return day;
+	}
+
+	public int day(java.sql.Timestamp st)  throws ITMException
+	{
+		Calendar rightNow = Calendar.getInstance();
+		int day = 0;
+		try
+		{
+			rightNow.setTime(st);
+			day = rightNow.get(Calendar.DAY_OF_MONTH);
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return day;
+	}
+
+	public java.util.Date getUtilDate(java.util.Date date)   throws ITMException
+	{
+		Calendar rightNow = Calendar.getInstance();
+		Date today = null;
+		try
+		{
+			rightNow.setTime(date);
+			rightNow.clear(Calendar.HOUR);
+			rightNow.clear(Calendar.MINUTE);
+			rightNow.clear(Calendar.SECOND);
+			rightNow.clear(Calendar.MILLISECOND);
+			today = rightNow.getTime();
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return today;
+	}
+
+	public java.util.Date date(java.util.Date date)   throws ITMException
+	{
+		Calendar rightNow = Calendar.getInstance();
+		Date today = null;
+		try
+		{
+			rightNow.setTime(date);
+			rightNow.clear(Calendar.HOUR);
+			rightNow.clear(Calendar.MINUTE);
+			rightNow.clear(Calendar.SECOND);
+			rightNow.clear(Calendar.MILLISECOND);
+			today = rightNow.getTime();
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return today;
+	}
+
+	public java.sql.Timestamp dateTime(java.util.Date ud) throws ITMException
+	{
+		Calendar rightNow = Calendar.getInstance();
+		Date today = null;
+		java.sql.Timestamp ts = null;
+		try
+		{
+			rightNow.setTime(ud);
+			rightNow.clear(Calendar.HOUR);
+			rightNow.clear(Calendar.MINUTE);
+			rightNow.clear(Calendar.SECOND);
+			rightNow.clear(Calendar.MILLISECOND);
+			today = rightNow.getTime();
+			ts = new java.sql.Timestamp(today.getTime());
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return ts;
+	}
+
+	public java.sql.Timestamp dateTime(java.sql.Date sd) throws ITMException
+	{
+		Calendar rightNow = Calendar.getInstance();
+		Date today = null;
+		java.sql.Timestamp ts = null;
+		try
+		{
+			rightNow.setTime(sd);
+			rightNow.clear(Calendar.HOUR);
+			rightNow.clear(Calendar.MINUTE);
+			rightNow.clear(Calendar.SECOND);
+			rightNow.clear(Calendar.MILLISECOND);
+			today = rightNow.getTime();
+			ts = new java.sql.Timestamp(today.getTime());
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return ts;
+	}
+
+
+	public java.sql.Timestamp dateTime(java.sql.Date sd, java.sql.Time sqlTime) throws ITMException
+	{
+		Calendar rightNow = Calendar.getInstance();
+		Date today = null;
+		String timeStr = "";
+		String timeStrArr[];
+		java.sql.Timestamp ts = null;
+		try
+		{
+			timeStr = sqlTime.toString();
+			timeStrArr = timeStr.split(":");
+			rightNow.setTime(sd);
+			rightNow.set(Calendar.HOUR , Integer.parseInt(timeStrArr[0]));
+			rightNow.set(Calendar.MINUTE,Integer.parseInt(timeStrArr[1]));
+			rightNow.clear(Calendar.SECOND);
+			rightNow.clear(Calendar.MILLISECOND);
+			today = rightNow.getTime();
+			ts = new java.sql.Timestamp(today.getTime());
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return ts;
+	}
+
+	public java.sql.Timestamp dateTime(java.util.Date ud, java.sql.Time sqlTime) throws ITMException
+	{
+		Calendar rightNow = Calendar.getInstance();
+		Date today = null;
+		String timeStr = "";
+		String timeStrArr[];
+		java.sql.Timestamp ts = null;
+		try
+		{
+			timeStr = sqlTime.toString();
+			timeStrArr = timeStr.split(":");
+			rightNow.setTime(ud);
+			rightNow.set(Calendar.HOUR , Integer.parseInt(timeStrArr[0]));
+			rightNow.set(Calendar.MINUTE,Integer.parseInt(timeStrArr[1]));
+			rightNow.clear(Calendar.SECOND);
+			rightNow.clear(Calendar.MILLISECOND);
+			today = rightNow.getTime();
+			ts = new java.sql.Timestamp(today.getTime());
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return ts;
+	}
+
+
+
+	public double mod(double value1 , double value2)
+	{
+		return value1 % value2;
+	}
+
+	public double mod(double value1 , Double value2) throws ITMException
+	{
+		double d1 = 0;
+		try
+		{
+			d1 = value1 % value2;
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return d1;
+     }
+
+	public double mod(double value1 , int value2)
+	{
+		return value1 % value2;
+	}
+
+	public double mod(double value1 , Integer value2) throws ITMException
+	{
+		double d1 = 0;
+ 		try
+		{
+			d1 = value1 % value2;
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return d1;
+	}
+
+	public double mod(int value1 , int value2)
+	{
+		return value1 % value2;
+	}
+
+	public double mod(int value1 , Integer value2) throws ITMException
+	{
+		double d1 = 0;
+		try
+		{
+			d1 = value1 % value2;
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return d1;
+	}
+
+	public double mod(int value1 , double value2)
+	{
+		return value1 % value2;
+	}
+
+
+	public double mod(int value1 , Double value2) throws ITMException
+	{
+		double d1 = 0;
+		try
+		{
+			d1 = value1 % value2;
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return d1;
+	}
+
+	public double mod(Integer value1 , Integer value2) throws ITMException
+	{
+		double d1 = 0;
+		try
+		{
+			d1 = value1 % value2;
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return d1;
+	}
+
+	public double mod(Integer value1 , int value2) throws ITMException
+	{
+		double d1 = 0;
+		try
+		{
+			d1 = value1 % value2;
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return d1;
+	}
+
+	public double mod(Integer value1 , double value2) throws ITMException
+	{
+		double d1 = 0;
+		try
+		{
+			d1 = value1 % value2;
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return d1;
+	}
+
+	public double mod(Integer value1 , Double value2) throws ITMException
+	{
+		double d1 = 0;
+		try
+		{
+			d1 = value1 % value2;
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return d1;
+	}
+
+	public double mod(Double value1 , Double value2) throws ITMException
+	{
+		double d1 = 0;
+		try
+		{
+			d1 = value1 % value2;
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return d1;
+	}
+
+	public double mod(Double value1 , double value2) throws ITMException
+	{
+		double d1 = 0;
+		try
+		{
+			d1 = value1 % value2;
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return d1;
+	}
+
+	public double mod(Double value1 , int value2) throws ITMException
+	{
+		double d1 = 0;
+		try
+		{
+			d1 = value1 % value2;
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return d1;
+	}
+
+	public double mod(Double value1 , Integer value2) throws ITMException
+	{
+		double d1 = 0;
+		try
+		{
+			d1 = value1 % value2;
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return d1;
+	}
+
+	/*
+	public String mid( String lsStr, int start, int liColWidth )  throws ITMException
+	{
+		String str1 = null;
+		try
+		{
+			str1 = lsStr.substring( start, liColWidth );
+			
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return str1;
+	}
+	*/
+	public String mid( String lsStr, int start, int liColWidth )  throws ITMException
+	{
+		String str1 = null;
+		try
+		{
+			if (start > 0)
+			{
+				start = start - 1;
+			}
+			if (liColWidth > 0)
+			{
+				liColWidth = start + liColWidth;
+			}
+			str1 = lsStr.substring( start, liColWidth );
+			
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return str1;
+	}
+
+	public String mid( String lsStr, int start )  throws ITMException
+	{
+		String str1 = null;
+		try
+		{
+			if (start > 0)
+			{
+				start = start - 1;
+			}
+			str1 = lsStr.substring( start );
+			
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return str1;
+	}
+
+	public String left( String src, int size ) throws ITMException
+	{
+		String str1 = null;
+		try
+		{
+			if( src.length() < size)
+			{
+				size = src.length();
+			}
+			str1 = src.substring( 0, size );
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return str1;
+	}
+
+	public String right( String src, int size ) throws ITMException
+	{
+		String str1 = null;
+		try
+		{
+			if( src.length() < size )
+			{
+				str1 = "";
+			}
+			else
+			{
+				str1 = src.substring( src.length() - size );
+			}
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return str1;
+	}
+
+	public int pos( String str, String searchChar ) throws ITMException
+	{
+		int i1 = 0;
+		try
+		{
+			i1 = str.indexOf( searchChar );
+			if (i1 == -1)
+			{
+				i1 = 0;
+			}
+			else
+			{
+				i1 = i1 + 1;
+			}
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return i1;
+	}
+
+	public int pos( String str, String searchChar, int position ) throws ITMException
+	{
+		int i1 = 0;
+		try
+		{
+			i1 = ( str.indexOf( searchChar, position ) == -1 ? 0 : str.indexOf( searchChar, position ) + 1 );
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return i1 ;
+	}
+
+	public String space( int noOfSpaces )
+	{
+		String blankStr = null;
+		blankStr = "";
+		for( int cnt = 0; cnt < noOfSpaces ; cnt++ )
+		{
+			blankStr = blankStr + " ";
+		}
+		return blankStr;
+	}
+
+	public int getRowCount( Document dom, int formNo ) throws ITMException
+	{
+		int rowCount = 0;
+		NodeList detailList = null;
+		String detail = null;
+		try
+		{
+			detail = "Detail" + formNo;
+			detailList = dom.getElementsByTagName( detail );
+			rowCount = detailList.getLength();
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return rowCount;
+	}
+
+	public boolean isnumber( String str )
+	{
+		int val;
+		try
+		{
+			val = Integer.parseInt( str );
+		}catch( NumberFormatException nex )
+		{
+			return false;
+		}catch( Exception ex )
+		{
+			return false;
+		}
+		return true;
+	}
+
+
+	public String leftTrim(String str)  throws ITMException
+	{
+		String returnStr = null;
+		try
+		{
+			if (str == null)
+			{
+				returnStr = null;
+			}
+			else if (str == null || str.trim().length() == 0)
+			{
+				returnStr = "";
+			}
+			else
+			{
+				StringBuilder sb = new StringBuilder(str);
+				while (Character.isWhitespace(sb.charAt(0)))
+				{
+					sb.deleteCharAt(0); 
+				}
+				returnStr = sb.toString();
+			}
+		}
+		catch (Exception e)
+		{
+			returnStr = null;
+		}
+		return returnStr;
+	}
+
+	public String rightTrim(String str)  throws ITMException
+	{
+		String returnStr = null;
+		try
+		{
+			if (str == null)
+			{
+				returnStr = null;
+			}
+			else if (str == null || str.trim().length() == 0)
+			{
+				returnStr = "";
+			}
+			else
+			{
+				StringBuilder sb = new StringBuilder(str);
+				while (Character.isWhitespace(sb.charAt(sb.length() - 1)))
+				{
+					sb.deleteCharAt(sb.length() - 1); 
+				}
+				returnStr = sb.toString();
+			}
+		}
+		catch (Exception e)
+		{
+			returnStr = null;
+		}
+		return returnStr;
+	}
+
+	public String convertToString(int ival) throws ITMException
+	{
+		String returnStr = null;
+		try
+		{
+			returnStr = String.valueOf(ival); 
+		}
+		catch (Exception e)
+		{
+			returnStr = null;
+		}
+		return returnStr;
+	}
+
+	public String convertToString(double dval) throws ITMException
+	{
+		String returnStr = null;
+		try
+		{
+			returnStr = String.valueOf(dval); 
+		}
+		catch (Exception e)
+		{
+			returnStr = null;
+		}
+		return returnStr;
+	}
+
+	public String convertToString(Integer ival) throws ITMException
+	{
+		String returnStr = null;
+		try
+		{
+			returnStr = ival.toString();
+		}
+		catch (Exception e)
+		{
+			returnStr = null;
+		}
+		return returnStr;
+	}
+
+
+	public int DaysAfter(Date d1, Date d2) throws ITMException
+	{
+		int noDays = 0;
+		try
+		{
+			noDays = (int)( (d2.getTime() - d1.getTime()) / (1000 * 60 * 60 * 24));
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		finally
+		{
+		}
+		return noDays;
+	}
+
+	public int DaysAfter(java.sql.Date d1, java.sql.Date d2) throws ITMException
+	{
+		int noDays = 0;
+		try
+		{
+			noDays = (int)( (d2.getTime() - d1.getTime()) / (1000 * 60 * 60 * 24));
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return noDays;
+	}
+
+	public double convertMinutesToHours(int min)  throws ITMException
+	{
+		double hrs = 0d, dReminder = 0d;
+		int i1 = 0, iSign = 1;
+		try
+		{
+			if (min != 0)
+			{
+				if (min < 0)
+				{
+					iSign = -1;
+					min = min * -1;
+				}
+				dReminder = mod(min , 60);
+				i1 = (min  - (int)dReminder) / 60;
+				hrs = i1 + (dReminder / 100.0);
+			}
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return (hrs * iSign);
+	}
+
+	public int convertTimeInMin(double dTime)  throws ITMException
+	{
+		double dReminder = 0d;
+		int min = 0, iSign = 1;
+		try
+		{
+			if (dTime != 0)
+			{
+				if (dTime < 0)
+				{
+					iSign = -1;
+					dTime = dTime * -1d;
+				}
+				dReminder = mod(dTime , 1d);
+				min = (int)(((dTime - dReminder) * 60) + (dReminder * 100));
+			}
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return (min * iSign);
+	}
+
+	public java.sql.Time stringToTime(String str) throws ITMException
+	{
+		java.sql.Time sTime = null;
+		try
+		{
+			String[] s = str.split(":");
+			if (s.length < 2)
+			{
+				str = str + ":00:00";
+			}
+			else if (s.length < 3)
+			{
+				str = str + ":00";
+			}
+			System.out.println("\r\nTime String :::"+ str + "\r\n");
+			return sTime.valueOf(str);
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+	}
+
+	
+	public int upperBound(String strArr[]) throws ITMException
+	{
+		int iLength = 0;
+		try
+		{
+			return strArr.length;
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+	}
+
+	public int upperBound(int intArr[]) throws ITMException
+	{
+		int iLength = 0;
+		try
+		{
+			return intArr.length;
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+	}
+
+	public int upperBound(java.sql.Timestamp tsArr[]) throws ITMException
+	{
+		int iLength = 0;
+		try
+		{
+			return tsArr.length;
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+	}
+
+	public int upperBound(java.sql.Date sdArr[]) throws ITMException
+	{
+		int iLength = 0;
+		try
+		{
+			return sdArr.length;
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+	}
+
+	
+
+	public int convertTimeInMin(java.sql.Time sqlTime)  throws ITMException
+	{
+		String timeStr = "";
+		String timeStrArr[];
+		int min = 0, iSign = 1;
+		try
+		{
+			timeStr = sqlTime.toString();
+			timeStrArr = timeStr.split(":");
+			min = (Integer.parseInt(timeStrArr[0]) * 60) + (Integer.parseInt(timeStrArr[1]));
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return (min * iSign);
+	}
+	public int abs(int intVal)  throws ITMException
+	{
+		try
+		{
+			if (intVal < 0)
+			{
+				intVal = intVal * -1;
+			}
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return intVal;
+	}
+	public double abs(double dblVal)  throws ITMException
+	{
+		try
+		{
+			if (dblVal < 0d)
+			{
+				dblVal = dblVal * -1;
+			}
+		}
+		catch (Exception e)
+		{
+			throw new ITMException(e);
+		}
+		return dblVal;
+	}
+
+	//***** Modified by Vishal on 23/06/2017.End
+
 
 }