parameterproviderimpl.java

The ability to create groups of reports, and grant users access to reports by group. The ability to

/*
 * Copyright (C) 2002 Erik Swenson - [e-mail]
 * 
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 2 of the License, or (at your option)
 * any later version.
 * 
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 * 
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
 * Place - Suite 330, Boston, MA 02111-1307, USA.
 *  
 */

package org.efs.openreports.providers.impl;

import java.math.BigDecimal;
import java.sql.*;
import java.util.*;

import com.opensymphony.xwork.ActionContext;
import com.opensymphony.xwork.interceptor.component.ComponentManager;

import org.apache.log4j.Logger;
import org.efs.openreports.objects.*;
import org.efs.openreports.providers.*;
import org.efs.openreports.providers.persistence.ParameterPersistenceProvider;
import org.efs.openreports.util.*;

import net.sf.jasperreports.engine.design.JRDesignQuery;
import net.sf.jasperreports.engine.util.JRQueryExecuter;

public class ParameterProviderImpl
	implements ParameterProvider, DataSourceProviderAware, DateProviderAware
{
	protected static Logger log =
		Logger.getLogger(ParameterProviderImpl.class.getName());	

	private ParameterPersistenceProvider paramPersistenceProvider;

	private DataSourceProvider dataSourceProvider;
	private DateProvider dateProvider;

	public ParameterProviderImpl() throws ProviderException
	{
		ComponentManager container =
			(ComponentManager) ActionContext.getContext().get(
				"com.opensymphony.xwork.interceptor.component.ComponentManager");

		container.initializeObject(this);

		paramPersistenceProvider = new ParameterPersistenceProvider();

		log.info("Created");
	}	

	public ReportParameterValue[] getParamValues(
		ReportParameter reportParameter,
		Map parameters)
		throws ProviderException
	{
		if (reportParameter.getType().equals(ReportParameter.QUERY_PARAM))
		{
			return getParamValuesFromDataSource(reportParameter, parameters);
		}
		else if (reportParameter.getType().equals(ReportParameter.LIST_PARAM))
		{
			return parseListValues(reportParameter);
		}

		throw new ProviderException(
			reportParameter.getName()
				+ ": param-type "
				+ reportParameter.getType()
				+ " not supported!");
	}

	protected ReportParameterValue[] parseListValues(ReportParameter reportParameter)
		throws ProviderException
	{
		StringTokenizer st =
			new StringTokenizer(reportParameter.getData(), "|");

		ReportParameterValue[] values =
			new ReportParameterValue[st.countTokens()];

		int index = 0;
		while (st.hasMoreTokens())
		{
			try
			{
				if (reportParameter.getClassName().equals("java.lang.Integer"))
				{
					values[index] =
						new ReportParameterValue(
							Integer.valueOf(st.nextToken()));
				}
				else if (
					reportParameter.getClassName().equals("java.lang.Double"))
				{
					values[index] =
						new ReportParameterValue(
							Double.valueOf(st.nextToken()));
				}
				else if (
					reportParameter.getClassName().equals("java.lang.Long"))
				{
					values[index] =
						new ReportParameterValue(Long.valueOf(st.nextToken()));
				}
				else if (
					reportParameter.getClassName().equals(
						"java.math.BigDecimal"))
				{
					values[index] =
						new ReportParameterValue(
							new BigDecimal(st.nextToken()));
				}
				else
				{
					values[index] = new ReportParameterValue(st.nextToken());
				}
			}
			catch (Exception e)
			{
				throw new ProviderException(
					reportParameter.getData()
						+ " contains invalid "
						+ reportParameter.getClassName());
			}

			index++;
		}

		return values;
	}

	protected ReportParameterValue[] getParamValuesFromDataSource(
		ReportParameter param,
		Map parameters)
		throws ProviderException
	{
		Connection conn = null;
		PreparedStatement pStmt = null;
		ResultSet rs = null;

		try
		{
			ReportDataSource dataSource = param.getDataSource();
			conn = dataSourceProvider.getConnection(dataSource.getId());			

			if (parameters == null || parameters.isEmpty())
			{
				pStmt = conn.prepareStatement(param.getData());				
			}
			else
			{
				// Use JasperReports Query logic to parse parameters in chart
				// queries

				JRDesignQuery query = new JRDesignQuery();
				query.setText(param.getData());

				// convert parameters to JRDesignParameters so they can be
				// parsed
				Map jrParameters = ORUtil.buildJRDesignParameters(parameters);

				pStmt =
					JRQueryExecuter.getStatement(
						query,
						jrParameters,
						parameters,
						conn);
			}
			
			rs = pStmt.executeQuery();

			ResultSetMetaData rsMetaData = rs.getMetaData();

			boolean multipleColumns = false;
			if (rsMetaData.getColumnCount() > 1)
				multipleColumns = true;

			Vector v = new Vector();

			while (rs.next())
			{
				ReportParameterValue value = new ReportParameterValue();

				if (param.getClassName().equals("java.lang.String"))
				{
					value.setId(rs.getString(1));
				}
				else if (param.getClassName().equals("java.lang.Double"))
				{
					value.setId(new Double(rs.getDouble(1)));
				}
				else if (param.getClassName().equals("java.lang.Integer"))
				{
					value.setId(new Integer(rs.getInt(1)));
				}
				else if (param.getClassName().equals("java.lang.Long"))
				{
					value.setId(new Long(rs.getLong(1)));
				}
				else if (param.getClassName().equals("java.math.BigDecimal"))
				{
					value.setId(rs.getBigDecimal(1));
				}
				else if (param.getClassName().equals("java.util.Date"))
				{
					value.setId(rs.getDate(1));
				}
				else if (param.getClassName().equals("java.sql.Date"))
				{
					value.setId(rs.getDate(1));
				}
				else if (param.getClassName().equals("java.sql.Timestamp"))
				{
					value.setId(rs.getTimestamp(1));
				}

				if (multipleColumns)
				{
					value.setDescription(rs.getString(2));
				}

				v.add(value);
			}

			rs.close();

			ReportParameterValue[] values = new ReportParameterValue[v.size()];
			v.copyInto(values);

			return values;
		}
		catch (Exception e)
		{
			throw new ProviderException(
				"Error retreiving param values from database: "
					+ e.getMessage());
		}
		finally
		{
			try
			{
				if (pStmt != null)
					pStmt.close();
				if (conn != null)
					conn.close();
			}
			catch (Exception c)
			{
				log.error("Error closing");
			}
		}
	}

	protected void validateParameter(ReportParameter parameter, String value)
		throws ProviderException
	{
		try
		{
			if (parameter.getClassName().equals("java.lang.Double"))
			{
				Double d = new Double(value);
			}
			else if (parameter.getClassName().equals("java.lang.Integer"))
			{
				Integer integer = new Integer(value);
			}
			else if (parameter.getClassName().equals("java.lang.Long"))
			{
				Long l = new Long(value);
			}
			else if (parameter.getClassName().equals("java.math.BigDecimal"))
			{
				BigDecimal bd = new BigDecimal(value);
			}
			else if (
				parameter.getClassName().equals("java.util.Date")
					|| parameter.getClassName().equals("java.sql.Date")
					|| parameter.getClassName().equals("java.sql.Timestamp"))
			{
				try
				{
					dateProvider.parseDate(value);
				}
				catch (Exception e)
				{
					throw new ProviderException(e.getMessage());
				}
			}
		}
		catch (Exception e)
		{
			throw new ProviderException(
				parameter.getDescription() + " Invalid: " + e.getMessage());
		}
	}

	protected Object parseParameter(ReportParameter parameter, String value)
		throws ProviderException
	{
		try
		{
			if (parameter.getClassName().equals("java.lang.String"))
			{
				return value;
			}
			else if (parameter.getClassName().equals("java.lang.Double"))
			{
				return new Double(value);