mtable.java

Java写的ERP系统

							{
								rs.updateTimestamp(col+1, (Timestamp)rowData[col]);	//	***
								type = "Date";
							}
							else
								rs.updateString(col+1, rowData[col].toString());	//	***
						}
						//
						is = INFO + columnName + "= " + m_rowData[col]
							+ " -> " + rowData[col] + " - " + type;
						Log.trace(Log.l5_DData, is);
					}
					//	Original != DB
					else
					{
						error = true;
						is = ERROR + field.getColumnName() + "= " + m_rowData[col]
							+ " != DB: " + rowDataDB[col] + " -> " + rowData[col];
						Log.trace(Log.l5_DData, is);
					}
				}

				//	MultiKey Inserting - retrieval sql
				if (m_inserting && field.isParent())
				{
					if (multiRowWHERE.length() != 0)
						multiRowWHERE.append(" AND ");
					multiRowWHERE.append(columnName).append("=").append(rowData[col]);
					if (rowData[col] == null)
						Log.error("MTable.dataSave - inserting MultiKey Parent " + columnName + " is NULL");
				}
			}	//	for every column

			if (error)
			{
				rs.cancelRowUpdates();
				rs.close();
				pstmt.close();
				fireDataStatusEEvent("SaveErrorDataChanged", "");
				dataRefresh(m_rowChanged);
				return SAVE_ERROR;
			}

			/**
			 *	Save to Database
			 */
			if (m_inserting)
			{
				Log.trace(Log.l5_DData, "inserting ...");
				rs.insertRow();
			}
			else
			{
				Log.trace(Log.l5_DData, "updating ...");
				rs.updateRow();
			}

			Log.trace(Log.l5_DData, "committing ...");
			DB.commit(true);
			//	data may be updated by trigger after update
			if (m_inserting)
			{
				//	for rows with multiple keys, there is no single keyColumn=value
				if (refreshSQL.indexOf("=") == -1)
				{
					refreshSQL.append(multiRowWHERE);
					Log.trace(Log.l5_DData, "reading ... " + multiRowWHERE.toString());
				}
				else
					Log.trace(Log.l5_DData, "reading ...");
				//	need to re-read row to get ROWID, Key, DocumentNo
				rs.close();
				rs = pstmt.executeQuery(refreshSQL.toString());
				if (rs.next())
				{
					rowDataDB = readData(rs);
					//	update buffer
					m_buffer.set(sort.index, rowDataDB);
					fireTableRowsUpdated(m_rowChanged, m_rowChanged);
				}
				else
					Log.error("MTable.dataSave - inserted row not found");
			}
			else
			{
				Log.trace(Log.l5_DData, "refreshing ...");
				rs.refreshRow();
				rowDataDB = readData(rs);
				//	update buffer
				m_buffer.set(sort.index, rowDataDB);
				fireTableRowsUpdated(m_rowChanged, m_rowChanged);
			}
			//
			rs.close();
			pstmt.close();
		}
		catch (SQLException e)
		{
			String msg = "SaveError";
			if (e.getErrorCode() == 1)		//	Unique Constraint
			{
				Log.error ("MTable.dataSave - Key Not Unique", e);
				msg = "SaveErrorNotUnique";
			}
			else
				Log.error ("MTable.dataSave\nSQL= " + SQL, e);
			fireDataStatusEEvent(msg, e.getLocalizedMessage());
			return SAVE_ERROR;
		}

		//	everything ok
		m_rowData = null;
		m_changed = false;
		m_rowChanged = -1;
		m_newRow = -1;
		m_inserting = false;
		fireDataStatusIEvent("Saved");
		//
		Log.trace(Log.l4_Data, "MTable.dataSave - fini");
		return SAVE_OK;
	}	//	dataSave

	/**
	 *	Get Mandatory empty columns
	 *  @param rowData row data
	 *  @return String with missing column headers/labels
	 */
	private String getMandatory(Object[] rowData)
	{
		//  see also => ProcessParameter.saveParameter
		StringBuffer sb = new StringBuffer();

		//	Check all columns
		int size = m_fields.size();
		for (int i = 0; i < size; i++)
		{
			MField field = (MField)m_fields.get(i);
			if (field.isMandatory(true))        //  check context
			{
				if (rowData[i] == null || rowData[i].toString().length() == 0)
				{
					field.setInserting (true);  //  set editable otherwise deadlock
					field.setError(true);
					if (sb.length() > 0)
						sb.append(", ");
					sb.append(field.getHeader());
				}
				else
					field.setError(false);
			}
		}

		if (sb.length() == 0)
			return "";
		return sb.toString();
	}	//	getMandatory

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

	/**
	 *	New Record after current Row
	 *  @param currentRow row
	 *  @param copyCurrent copy
	 *  @return true if success -
	 *  Error info (Access*, AccessCannotInsert) is saved in the log
	 */
	public boolean dataNew (int currentRow, boolean copyCurrent)
	{
		Log.trace(Log.l4_Data, "MTable.dataNew - Current=" + currentRow + ", Copy=" + copyCurrent);
		//  see if we need to save
		dataSave(-2, false);

		//  Read only
		if (m_readOnly)
		{
			fireDataStatusEEvent("AccessCannotInsert", "");
			return false;
		}
		/** @todo No TableLevel */
		//  || !Access.canViewInsert(m_ctx, m_WindowNo, tableLevel, true, true))
		//  fireDataStatusEvent(Log.retrieveError());

		m_inserting = true;
		//	Create default data
		int size = m_fields.size();
		m_rowData = new Object[size];	//	"original" data
		Object[] rowData = new Object[size];
		//	fill data
		if (copyCurrent)
		{
			MSort sort = (MSort) m_sort.get(currentRow);
			Object[] origData = (Object[])m_buffer.get(sort.index);
			for (int i = 0; i < size; i++)
				rowData[i] = origData[i];
		}
		else	//	new
		{
			for (int i = 0; i < size; i++)
			{
				MField field = (MField)m_fields.get(i);
				rowData[i] = field.getDefault();
				field.setValue(rowData[i], m_inserting);
			}
		}
		m_changed = true;
		m_rowChanged = -1;  //  only changed in setValueAt
		m_newRow = currentRow + 1;
		//  if there is no record, the current row could be 0 (and not -1)
		if (m_buffer.size() < m_newRow)
			m_newRow = m_buffer.size();

		//	add Data at end of buffer
		MSort sort = new MSort(m_buffer.size(), null);	//	index
		m_buffer.add(rowData);
		//	add Sort pointer
		m_sort.add(m_newRow, sort);
		m_rowCount++;

		//	inform
		fireTableRowsInserted(m_newRow, m_newRow);
		fireDataStatusIEvent(copyCurrent ? "UpdateCopied" : "Inserted");
		Log.trace(Log.l4_Data, "MTable.dataNew - Current=" + currentRow + ", New=" + m_newRow + " - complete");
		return true;
	}	//	dataNew


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

	/**
	 *	Delete Data
	 *  @param row row
	 *  @return true if success -
	 *  Error info (Access*, AccessNotDeleteable, DeleteErrorDependent,
	 *  DeleteError) is saved in the log
	 */
	public boolean dataDelete (int row)
	{
		Log.trace(Log.l4_Data, "MTable.dataDelete - " + row);
		if (row < 0)
			return false;
		Object rowID = getRowID(row);
		if (rowID == null)
			return false;

		//  Tab R/O
		if (m_readOnly)
		{
			fireDataStatusEEvent("AccessCannotDelete", "");
			return false;
		}

		//	Is this record deletable?
		if (!m_deleteable
			|| (m_processedColumnIndex > 0				//	processed
				&& "Y".equals(getValueAt(row, m_processedColumnIndex))	//	= Y
				&& !m_tableName.startsWith("I_") ))		//	ignore Import tables
		{
			fireDataStatusEEvent("AccessNotDeleteable", "");
			return false;
		}
		/** @todo check Access */
		//  fireDataStatusEvent(Log.retrieveError());


		//
		StringBuffer SQL = new StringBuffer("DELETE ");
		SQL.append(m_tableName).append(" WHERE ROWID=?");
		int no = 0;
		try
		{
			PreparedStatement pstmt = DB.prepareStatement(SQL.toString());
			DB.getDatabase().setRowID(pstmt, 1, rowID);
			no = pstmt.executeUpdate();
			pstmt.close();
		}
		catch (SQLException e)
		{
			Log.error ("MTable.dataDelete", e);
			String msg = "DeleteError";
			if (e.getErrorCode() == 2292)	//	Child Record Found
				msg = "DeleteErrorDependent";
			fireDataStatusEEvent(msg, e.getLocalizedMessage());
			return false;
		}
		//	Check Result
		if (no != 1)
		{
			Log.error("MTable.dataDelete - Number of deleted rows = " + no);
			return false;
		}

		//	Get Sort
		MSort sort = (MSort)m_sort.get(row);
		int bufferRow = sort.index;

		//	Delete row in Buffer and shifts all below up
		m_buffer.remove(bufferRow);
		m_rowCount--;

		//	Delete row in Sort
		m_sort.remove(row);
		//	Correct pointer in Sort
		for (int i = 0; i < m_sort.size(); i++)
		{
			MSort ptr = (MSort)m_sort.get(i);
			if (ptr.index > bufferRow)
				ptr.index--;	//	move up
		}

		//	inform
		m_changed = false;
		m_rowChanged = -1;
		fireTableRowsDeleted(row, row);
		fireDataStatusIEvent("Deleted");
		Log.trace(Log.l4_Data, "MTable.dataDelete - " + row + " complete");
		return true;
	}	//	dataDelete

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

	/**
	 *	Ignore changes
	 */
	public void dataIgnore()
	{
		Log.trace(Log.l4_Data, "MTable.dataIgnore", "Inserting=" + m_inserting);
		if (!m_inserting && !m_changed && m_rowChanged < 0)
		{
			Log.trace(Log.l5_DData, "MTable.dataIgnore - Nothing to ignore");
			return;
		}

		//	Inserting - delete new row
		if (m_inserting)
		{
			//	Get Sort
			MSort sort = (MSort)m_sort.get(m_newRow);
			int bufferRow = sort.index;
			//	Delete row in Buffer and shifts all below up
			m_buffer.remove(bufferRow);
			m_rowCount--;
			//	Delete row in Sort
			m_sort.remove(m_newRow);	//	pintint to the last column, so no adjustment
			//
			m_changed = false;
			m_rowData = null;
			m_rowChanged = -1;
			m_inserting = false;
			//	inform
			fireTableRowsDeleted(m_newRow, m_newRow);
		}
		else
		{
			//	update buffer
			if (m_rowData != null)
			{
				MSort sort = (MSort)m_sort.get(m_rowChanged);
				m_buffer.set(sort.index, m_rowData);
			}
			m_changed = false;
			m_rowData = null;
			m_rowChanged = -1;
			m_inserting = false;
			//	inform
		//	fireTableRowsUpdated(m_rowChanged, m_rowChanged); >> messes up display?? (clearSelection)
		}
		m_newRow = -1;
		fireDataStatusIEvent("Ignored");
	}	//	dataIgnore


	/**
	 *	Refresh Row - ignore changes
	 *  @param row row
	 */
	public void dataRefresh (int row)
	{
		Log.trace(Log.l4_Data, "MTable.dataRefresh " + row);

		if (row < 0)
			return;
		Object rowID = getRowID(row);
		if (rowID == null)
			return;

		//  ignore
		dataIgnore();

		//	Create SQL
		String SQL = m_SQL_Select + " WHERE ROWID=?";
		MSort sort = (MSort)m_sort.get(row);
		Object[] rowDataDB = null;
		try
		{
			PreparedStatement pstmt = DB.prepareStatement(SQL);
			DB.getDatabase().setRowID(pstmt, 1, rowID);
			ResultSet rs = pstmt.executeQuery();
			//	only one row
			if (rs.next())
				rowDataDB = readData(rs);
			rs.close();
			pstmt.close();
		}
		catch (SQLException e)
		{
			Log.error ("MTable.dataRefresh\nSQL=" + SQL, e);
			fireTableRowsUpdated(row, row);
			fireDataStatusEEvent("RefreshError", "");
			return;
		}

		//	update buffer
		m_buffer.set(sort.index, rowDataDB);
		//	info
		m_rowData = null;
		m_changed = false;
		m_rowChanged = -1;
		m_inserting = false;
		fireTableRowsUpdated(row, row);
		fireDataStatusIEvent("Refreshed");
	}	//	dataRefresh


	/**
	 *	Refresh all Rows - ignore changes
	 */
	public void dataRefreshAll()
	{
		Log.trace(Log.l4_Data, "MTable.dataRefreshAll");
		dataIgnore();
		close(false);
		open();
		//	Info
		m_rowData = null;
		m_changed = false;
		m_rowChanged = -1;
		m_inserting = false;
		fireTableDataChanged();
		fireDataStatusIEvent("Refreshed");
	}	//	dataRefreshAll


	/**
	 *	Requery with new whereClause
	 *  @param whereClause sql where clause
	 *  @param onlyCurrentRows only current rows
	 *  @param onlyCurrentDays how many days back
	 *  @return true if success
	 */
	public boolean dataRequery (String whereClause, boolean onlyCurrentRows, int onlyCurrentDays)
	{
		Log.trace(Log.l4_Data, "MTable.dataRequery - " + whereClause + "; OnlyCurrent=" + onlyCurrentRows);
		close(false);
		m_onlyCurrentDays = onlyCurrentDays;
		setWhereClause(whereClause, onlyCurrentRows, m_onlyCurrentDays);
		open();
		//  Info
		m_rowData = null;
		m_changed = false;
		m_rowChanged = -1;
		m_inserting = false;
		fireTableDataChanged();
		fireDataStatusIEvent("Refreshed");
		return true;
	}	//	dataRequery


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

	/**
	 *	Is Cell Editable
	 *
	 *  @param  row the row index being queried
	 *  @param  col the column index being queried
	 *  @return true, if editable
	 */
	public boolean isCellEditable (int row, int col)
	{
	//	Log.trace(Log.l6_Database, "MTable.isCellEditable");