mtable.java

Java写的ERP系统

/******************************************************************************
 * The contents of this file are subject to the   Compiere License  Version 1.1
 * ("License"); You may not use this file except in compliance with the License
 * You may obtain a copy of the License at http://www.compiere.org/license.html
 * Software distributed under the License is distributed on an  "AS IS"  basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
 * the specific language governing rights and limitations under the License.
 * The Original Code is                  Compiere  ERP & CRM  Business Solution
 * The Initial Developer of the Original Code is Jorg Janke  and ComPiere, Inc.
 * Portions created by Jorg Janke are Copyright (C) 1999-2001 Jorg Janke, parts
 * created by ComPiere are Copyright (C) ComPiere, Inc.;   All Rights Reserved.
 * Contributor(s): ______________________________________.
 *****************************************************************************/
package org.compiere.model;

import javax.swing.table.*;
import javax.swing.event.*;

import java.sql.*;
import java.util.*;
import java.math.*;
import java.beans.*;
import java.io.Serializable;

import org.compiere.util.*;

/**
 *	Grid Table Model for JDBC access including buffering.
 *  <pre>
 *		The following data types are handeled
 *			Integer		for all IDs
 *			BigDecimal	for all Numbers
 *			Timestamp	for all Dates
 *			String		for all others
 *  The data is read via r/o resultset and cached in m_buffer. Writes/updates
 *  are via dynamically constructed SQL INSERT/UPDATE statements. The record
 *  is re-read via the resultset to get results of triggers.
 *
 *  </pre>
 *  The model maintains and fires the requires TableModelEvent changes,
 *  the DataChanged events (loading, changed, etc.)
 *  as well as Vetoable Change event "RowChange"
 *  (for row changes initiated by moving the row in the table grid).
 *
 * 	@author 	Jorg Janke
 * 	@version 	$Id: MTable.java,v 1.36 2003/05/04 06:40:55 jjanke Exp $
 */
public final class MTable
	implements TableModel, Serializable
{
	/**
	 *	JDBC Based Buffered Table
	 *
	 *  @param ctx Properties
	 *  @param TableName table name
	 *  @param WindowNo window no
	 *  @param TabNo tab no
	 *  @param withAccessControl    if true adds AD_Client/Org restrictuins
	 */
	public MTable(Properties ctx, String TableName, int WindowNo, int TabNo,
		boolean withAccessControl)
	{
		super();
		Log.trace(Log.l4_Data, "MTable - " + TableName);
		m_ctx = ctx;
		setTableName(TableName);
		m_WindowNo = WindowNo;
		m_TabNo = TabNo;
		m_withAccessControl = withAccessControl;
	}	//	MTable

	private Properties          m_ctx;
	private String 		        m_tableName = "";
	private int				    m_WindowNo;
	private int				    m_TabNo;
	private boolean			    m_withAccessControl;
	private boolean			    m_readOnly = true;
	private boolean			    m_deleteable = true;

	/**	Rowcount                    */
	private int				    m_rowCount = 0;
	/**	Has Data changed?           */
	private boolean			    m_changed = false;
	/** Index of changed row via SetValueAt */
	private int				    m_rowChanged = -1;
	/** Insert mode active          */
	private boolean			    m_inserting = false;
	/** Inserted Row number         */
	private int                 m_newRow = -1;
	/**	Is the Resultset open?      */
	private boolean			    m_open = false;


	//	The buffer for all data
	private volatile ArrayList	m_buffer = new ArrayList(100);
	private volatile ArrayList	m_sort = new ArrayList(100);
	/** Original row data               */
	private Object[]			m_rowData = null;
	/** Original data [row,col,data]    */
	private Object[]            m_oldValue = null;
	//
	private Loader		        m_loader = null;

	/**	Columns                 		*/
	private ArrayList	        m_fields = new ArrayList(30);
	private ArrayList 	        m_parameterSELECT = new ArrayList(5);
	private ArrayList 	        m_parameterWHERE = new ArrayList(5);

	/** Complete SQL statement          */
	private String 		        m_SQL;
	/** SQL Statement for Row Count     */
	private String 		        m_SQL_Count;
	/** The SELECT clause with FROM     */
	private String 		        m_SQL_Select;
	/** The static where clause         */
	private String 		        m_whereClause = "";
	/** Show only Processed='N' and last 24h records    */
	private boolean		        m_onlyCurrentRows = false;
	/** Show only Not processed and x days				*/
	private int					m_onlyCurrentDays = 1;
	/** Static ORDER BY clause          */
	private String		        m_orderClause = "";

	/** Index of Key Column                 */
	private int			        m_keyColumnIndex = -1;
	/** Index of ID                         */
	private int                 m_IDColumnIndex = -1;
	/** Index of Color determinating column */
	private int			        m_colorColumnIndex = -1;
	/** Index of RowID column               */
	private int                 m_rowIdColumnIndex = -1;
	/** Index of Processed Column           */
	private int                 m_processedColumnIndex = -1;
	/** Index of Active column              */
	private int                 m_activeColumnIndex = -1;

	/** List of DataStatus Listeners    */
	private Vector 		        m_dataStatusListeners;
	/** List of TableModel Listeners    */
	private EventListenerList   m_tableModelListeners = new EventListenerList();
	/** Vetoable Change Bean support    */
	private VetoableChangeSupport   m_vetoableChangeSupport = new VetoableChangeSupport(this);
	/** Property of Vetoable Bean support "RowChange" */
	public static final String  PROPERTY = "MTable-RowSave";

	/**
	 *	Set Table Name
	 *  @param newTableName table name
	 */
	public void setTableName(String newTableName)
	{
		if (m_open)
		{
			Log.error("MTable.setTableName - Table already open - ignored");
			return;
		}
		if (newTableName == null || newTableName.length() == 0)
			return;
		m_tableName = newTableName;
	}	//	setTableName

	/**
	 *	Get Table Name
	 *  @return table name
	 */
	public String getTableName()
	{
		return m_tableName;
	}	//	getTableName

	/**
	 *	Set Where Clause (w/o the WHERE and w/o History).
	 *  @param newWhereClause sql where clause
	 *  @param onlyCurrentRows only current rows
	 *  @param onlyCurrentDays how many days back for current
	 *	@return true if where clase set
	 */
	public boolean setWhereClause(String newWhereClause, boolean onlyCurrentRows, int onlyCurrentDays)
	{
		if (m_open)
		{
			Log.error("MTable.setWhereClause - Table already open - ignored");
			return false;
		}
		//
		m_whereClause = newWhereClause;
		m_onlyCurrentRows = onlyCurrentRows;
		m_onlyCurrentDays = onlyCurrentDays;
		if (m_whereClause == null)
			m_whereClause = "";
		return true;
	}	//	setWhereClause

	/**
	 *	Get Where Clause (w/o the WHERE and w/o History)
	 *  @return where clause
	 */
	public String getWhereClause()
	{
		return m_whereClause;
	}	//	getWhereClause

	/**
	 *	Is History displayed
	 *  @return true if history displayed
	 */
	public boolean isOnlyCurrentRowsDisplayed()
	{
		return !m_onlyCurrentRows;
	}	//	isHistoryDisplayed

	/**
	 *	Set Order Clause (w/o the ORDER BY)
	 *  @param newOrderClause sql order by clause
	 */
	public void setOrderClause(String newOrderClause)
	{
		m_orderClause = newOrderClause;
		if (m_orderClause == null)
			m_orderClause = "";
	}	//	setOrderClause

	/**
	 *	Get Order Clause (w/o the ORDER BY)
	 *  @return order by clause
	 */
	public String getOrderClause()
	{
		return m_orderClause;
	}	//	getOrderClause

	/**
	 *	Assemble & store
	 *	m_SQL and m_countSQL
	 *  @return m_SQL
	 */
	private String createSQL ()
	{
		Log.trace(Log.l4_Data, "MTable.getSQL");
		//
		if (m_fields.size() == 0 || m_tableName == null || m_tableName.equals(""))
			return "";

		//	Create SELECT Part
		StringBuffer select = new StringBuffer("SELECT ");
		for (int i = 0; i < m_fields.size(); i++)
		{
			if (i > 0)
				select.append(",");
			MField field = (MField)m_fields.get(i);
			select.append(field.getColumnName());
		}
		//
		select.append(" FROM ").append(m_tableName);
		m_SQL_Select = select.toString();
		m_SQL_Count = "SELECT COUNT(*) FROM " + m_tableName;
		//

		StringBuffer where = new StringBuffer("");
		//	WHERE
		if (m_whereClause.length() > 0)
		{
			where.append(" WHERE ");
			if (m_whereClause.indexOf("@") == -1)
				where.append(m_whereClause);
			else    //  replace variables
				where.append(Env.parseContext(m_ctx, m_WindowNo, m_whereClause, false));
		}
		if (m_onlyCurrentRows)
		{
			if (where.toString().indexOf(" WHERE ") == -1)
				where.append(" WHERE ");
			else
				where.append(" AND ");
			//	Show only unprocessed or the one updated within x days
			where.append("(Processed='N' OR Updated>SysDate-").append(m_onlyCurrentDays).append(")");
		}

		//	RO/RW Access
		m_SQL = m_SQL_Select + where.toString();
		m_SQL_Count += where.toString();
		if (m_withAccessControl)
		{
			if (m_readOnly)
			{
				m_SQL = Access.addROAccessSQL(m_ctx, m_SQL, m_tableName, true);
				m_SQL_Count = Access.addROAccessSQL(m_ctx, m_SQL_Count, m_tableName, true);
			}
			else
			{
				m_SQL = Access.addRWAccessSQL(m_ctx, m_SQL, m_tableName, true);
				m_SQL_Count = Access.addRWAccessSQL(m_ctx, m_SQL_Count, m_tableName, true);
			}
		}

		//	ORDER BY
		if (!m_orderClause.equals(""))
			m_SQL += " ORDER BY " + m_orderClause;
		//
		Env.setContext(m_ctx, m_WindowNo, m_TabNo, "SQL", m_SQL);
		return m_SQL;
	}	//	getSQL

	/**
	 *	Add Field to Table
	 *  @param field field
	 */
	public void addField (MField field)
	{
		Log.trace(Log.l4_Data, "MTable.addField (" + m_tableName + ") - " + field.getColumnName());
		if (m_open)
		{
			Log.error("MTable.addField - Table already open - ignored: " + field.getColumnName());
			return;
		}
		//  Set Index for RowID column
		if (field.getDisplayType() == DisplayType.RowID)
			m_rowIdColumnIndex = m_fields.size();
		//  Set Index for Key column
		if (field.isKey())
			m_keyColumnIndex = m_fields.size();
		else if (field.getColumnName().equals("IsActive"))
			m_activeColumnIndex = m_fields.size();
		else if (field.getColumnName().equals("Processed"))
			m_processedColumnIndex = m_fields.size();
		else if (field.getDisplayType() == DisplayType.RowID)
			m_IDColumnIndex = m_fields.size();
		//
		m_fields.add(field);
	}	//	addColumn

	/**
	 *  Returns database column name
	 *
	 *  @param index  the column being queried
	 *  @return column name
	 */
	public String getColumnName (int index)
	{
		if (index < 0 || index > m_fields.size())
		{
			Log.error("MTable.getColumnName - invalid index=" + index);
			return "";
		}
		//
		MField field = (MField)m_fields.get(index);
		return field.getColumnName();
	}   //  getColumnName

	/**
	 * Returns a column given its name.
	 *
	 * @param columnName string containing name of column to be located
	 * @return the column index with <code>columnName</code>, or -1 if not found
	 */
	public int findColumn (String columnName)
	{
		for (int i = 0; i < m_fields.size(); i++)
		{
			MField field = (MField)m_fields.get(i);
			if (columnName.equals(field.getColumnName()))
				return i;
		}
		return -1;
	}   //  findColumn

	/**
	 *  Returns Class of database column/field
	 *
	 *  @param index  the column being queried
	 *  @return the class
	 */
	public Class getColumnClass (int index)
	{
		if (index < 0 || index >= m_fields.size())
		{
			Log.error("MTable.getColumnClass - invalid index=" + index);
			return null;
		}
		MField field = (MField)m_fields.get(index);
		return DisplayType.getClass(field.getDisplayType(), false);
	}   //  getColumnClass

	/**
	 *	Set Select Clause Parameter.
	 *	Assumes that you set parameters starting from index zero
	 *  @param index index
	 *  @param parameter parameter
	 */
	public void setParameterSELECT (int index, Object parameter)
	{
		if (index >= m_parameterSELECT.size())
			m_parameterSELECT.add(parameter);
		else
			m_parameterSELECT.set(index, parameter);
	}	//	setParameterSELECT

	/**
	 *	Set Where Clause Parameter.
	 *	Assumes that you set parameters starting from index zero
	 *  @param index index
	 *  @param parameter parameter
	 */
	public void setParameterWHERE (int index, Object parameter)
	{
		if (index >= m_parameterWHERE.size())
			m_parameterWHERE.add(parameter);
		else
			m_parameterWHERE.set(index, parameter);
	}	//	setParameterWHERE


	/**
	 *	Get Column at index
	 *  @param index index
	 *  @return MField
	 */
	protected MField getField (int index)
	{
		if (index < 0 || index >= m_fields.size())
			return null;
		return (MField)m_fields.get(index);
	}	//	getColumn

	/**
	 *	Return Columns with Indentifier (ColumnName)
	 *  @param identifier column name
	 *  @return MField
	 */
	protected MField getField (String identifier)
	{
		if (identifier == null || identifier.length() == 0)
			return null;
		int cols = m_fields.size();
		for (int i = 0; i < cols; i++)
		{
			MField field = (MField)m_fields.get(i);
			if (identifier.equalsIgnoreCase(field.getColumnName()))
				return field;
		}
	//	Log.error ("MTable.getField - not found: '" + identifier + "'");
		return null;
	}	//	getField


	/*************************************************************************/

	/**
	 *	Open Database.
	 *  if already opened, data is refreshed
	 *
	 *	@return true if success
	 */
	public boolean open ()
	{
		Log.trace(Log.l4_Data, "MTable.open");
		if (m_open)
		{
			Log.trace(Log.l5_DData, "already open");
			dataRefreshAll();
			return true;
		}

		//	create m_SQL and m_countSQL
		createSQL();
		if (m_SQL.equals(""))
		{
			Log.error("MTable.open - No SQL");
			return false;
		}

		//	Start Loading
		m_loader = new Loader();
		m_rowCount = m_loader.open();
		m_buffer = new ArrayList(m_rowCount+10);
		m_sort = new ArrayList(m_rowCount+10);
		if (m_rowCount > 0)
			m_loader.start();
		else