acctschema.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 java.sql.*;
import java.util.*;

import org.compiere.util.*;
import java.io.*;

/**
 *  Accounting Schema Object
 *
 *  @author 	Jorg Janke
 *  @version 	$Id: AcctSchema.java,v 1.10 2003/03/17 20:30:53 jjanke Exp $
 */
public final class AcctSchema implements Serializable
{
	/**
	 *	Constructor
	 *  @param C_AcctSchema_ID
	 */
	public AcctSchema (int C_AcctSchema_ID)
	{
		Log.trace(Log.l1_User, "AcctSchema - " + C_AcctSchema_ID);
		load (C_AcctSchema_ID);
	}	//	DocumentType

	/** ID                  */
	private int 		m_C_AcctSchema_ID = 0;

	/** database field      */
	private String		m_Name = null;
	/** database field      */
	private String		m_GAAP = null;
	/** database field      */
	private boolean		m_IsAccrual = false;
	/** HasAlias            */
	private boolean     m_HasAlias = true;
	/** database field      */
	private String		m_CostingMethod = null;
	/** database field      */
	private int			m_C_Currency_ID = 0;
	private int			m_AD_Client_ID = 0;
	private boolean     m_IsTradeDiscountPosted = false;
	private boolean     m_IsDiscountCorrectsTax = false;


	/** database field      */
	private String		m_CurrencyRateType = "S";		//	Spot default

	/** database field      */
	private boolean		m_UseSuspenseBalancing = false;
	/** database field      */
	private Account		m_SuspenseBalancing_Acct = null;
	/** database field      */
	private boolean		m_UseSuspenseError = false;
	/** database field      */
	private Account		m_SuspenseError_Acct = null;
	/** database field      */
	private boolean		m_UseCurrencyBalancing = false;
	/** database field      */
	private Account		m_CurrencyBalancing_Acct = null;
	/** database field      */
	private Account		m_DueTo_Acct = null;
	/** database field      */
	private Account		m_DueFrom_Acct = null;
	//

	/** Segment Lists       */
	ArrayList   m_elementList = null;

	//  Costing Methods
	public static final String  COSTING_AVERAGE = "A";
	public static final String  COSTING_STANDARD = "S";
//	public static final String  COSTING_FIFO = "F";
//	public static final String  COSTING_LIFO = "L";
	public static final String  COSTING_LASTPO = "P";

	//  GAAPs
	public static final String  GAAP_US = "US";
	public static final String  GAAP_INTERNATIONAL = "UN";
	public static final String  GAAP_GERMAN = "DE";

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

	//  Cache
	private static HashMap  s_schema = new HashMap(3);      //  3 clients

	/**
	 *  Factory: Get AccountSchema List
	 *  @param AD_Client_ID
	 *  @return ArrayList of AcctSchema of Client
	 */
	public static synchronized ArrayList getAcctSchemaList (int AD_Client_ID)
	{
		//  Check Cache
		Integer key = new Integer(AD_Client_ID);
		if (s_schema.containsKey(key))
			return (ArrayList)s_schema.get(key);

		//  Create New
		ArrayList list = new ArrayList();
		String sql = "SELECT C_AcctSchema1_ID,"
				+ "Acct2_Active,C_AcctSchema2_ID,"
				+ "Acct3_Active,C_AcctSchema3_ID "
			+ "FROM AD_ClientInfo WHERE AD_Client_ID=?";
		try
		{
			PreparedStatement pstmt = DB.prepareStatement(sql);
			pstmt.setInt(1, AD_Client_ID);
			ResultSet rs = pstmt.executeQuery();
			if (rs.next())
			{
				int as = rs.getInt(1);
				list.add(new AcctSchema(as));
				//
				if (rs.getString(2).equals("Y"))
				{
					as = rs.getInt(3);
					if (as != 0)
						list.add(new AcctSchema(as));
				}
				if (rs.getString(4).equals("Y"))
				{
					as = rs.getInt(5);
					if (as != 0)
						list.add(new AcctSchema(as));
				}
			}
			rs.close();
			pstmt.close();
		}
		catch (SQLException e)
		{
			Log.error ("AcctSchema.getAcctSchemaList", e);
		}
		//  Save
		s_schema.put(key, list);
		return list;
	}   //  getAcctSchemaList

	/**
	 *  AcctSchema Element Array
	 *  @param AD_Client_ID
	 *  @return AcctSchema Array of Client
	 */
	public static AcctSchema[] getAcctSchemaArray(int AD_Client_ID)
	{
		ArrayList list = getAcctSchemaList (AD_Client_ID);
		AcctSchema[] retValue = new AcctSchema [list.size()];
		list.toArray(retValue);
		return retValue;
	}   //  getAcctSchemaArray

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

	/**
	 *	Get Details & accounts
	 *  @param newC_AcctSchema_ID
	 */
	public void load (int newC_AcctSchema_ID)
	{
		Log.trace(Log.l3_Util, "AcctSchema.load - " + newC_AcctSchema_ID);
		//
		m_C_AcctSchema_ID = newC_AcctSchema_ID;
		String sql = "SELECT Name,GAAP,IsAccrual,CostingMethod,C_Currency_ID,HasAlias, "
			+ "IsTradeDiscountPosted,IsDiscountCorrectsTax, AD_Client_ID "
			+ "FROM C_AcctSchema WHERE C_AcctSchema_ID=?";
		try
		{
			PreparedStatement pstmt = DB.prepareStatement(sql);
			pstmt.setInt(1, m_C_AcctSchema_ID);
			ResultSet rs = pstmt.executeQuery();
			if (rs.next())
			{
				m_Name = rs.getString(1);
				m_GAAP = rs.getString(2);
				m_IsAccrual = rs.getString(3).equals("Y");
				m_CostingMethod = rs.getString(4);
				m_C_Currency_ID = rs.getInt(5);
				m_HasAlias = rs.getString(6).equals("Y");
				m_IsTradeDiscountPosted = rs.getString(7).equals("Y");
				m_IsDiscountCorrectsTax = rs.getString(8).equals("Y");
				m_AD_Client_ID = rs.getInt(9);
			}
			rs.close();
			pstmt.close();
			//	_GL
			sql = "SELECT UseSuspenseBalancing,SuspenseBalancing_Acct, "    //  1..2
				+ "UseSuspenseError,SuspenseError_Acct, "                   //  3..4
				+ "UseCurrencyBalancing,CurrencyBalancing_Acct, "           //  5..6
				+ "RetainedEarning_Acct,IncomeSummary_Acct, "               //  7..8
				+ "InterCompanyDueTo_Acct,InterCompanyDueFrom_Acct "        //  9..10
				+ "FROM C_AcctSchema_GL "
				+ "WHERE C_AcctSchema_ID=?";
			pstmt = DB.prepareStatement(sql);
			pstmt.setInt(1, m_C_AcctSchema_ID);
			rs = pstmt.executeQuery();
			if (rs.next())
			{
				//  Suspense Balance
				m_UseSuspenseBalancing = rs.getString(1).equals("Y");
				int ID = rs.getInt(2);
				if (m_UseSuspenseBalancing && ID != 0)
					m_SuspenseBalancing_Acct = Account.getAccount(ID);
				else
					m_UseSuspenseBalancing = false;
				Log.trace(Log.l4_Data, "SuspenseBalancing=" + m_UseSuspenseBalancing + " " + m_SuspenseBalancing_Acct);
				//  Suspense Error
				m_UseSuspenseError = rs.getString(3).equals("Y");
				ID = rs.getInt(4);
				if (m_UseSuspenseError && ID != 0)
					m_SuspenseError_Acct = Account.getAccount(ID);
				else
					m_UseSuspenseError = false;
				Log.trace(Log.l4_Data, "SuspenseError=" + m_UseSuspenseError + " " + m_SuspenseError_Acct);
				//  Currency Balancing
				m_UseCurrencyBalancing = rs.getString(5).equals("Y");
				ID = rs.getInt(6);
				if (m_UseCurrencyBalancing && ID != 0)
					m_CurrencyBalancing_Acct = Account.getAccount(ID);
				else
					m_UseCurrencyBalancing = false;
				Log.trace(Log.l4_Data, "CurrencyBalancing=" + m_UseCurrencyBalancing + " " + m_CurrencyBalancing_Acct);
				//  -retained
				//  InterCompany
				ID = rs.getInt(9);
				if (ID != 0)
					m_DueTo_Acct = Account.getAccount(ID);
				ID = rs.getInt(10);
				if (ID != 0)
					m_DueFrom_Acct = Account.getAccount(ID);
			}
			rs.close();
			pstmt.close();

			//  _Default

			//	Segments
			m_elementList = AcctSchemaElement.getAcctSchemaElementList(m_C_AcctSchema_ID);
		}
		catch (SQLException e)
		{
			Log.error ("AcctSchema.load SQL=" + sql, e);
			m_C_AcctSchema_ID = 0;
		}
	}	//	load


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

	/**
	 *  Get Acct_Schema
	 *  @return C_AcctSchema_ID
	 */
	public int getC_AcctSchema_ID()
	{
		return m_C_AcctSchema_ID;
	}   //  getC_AcctSchema_ID

	/**
	 *  AcctSchema Element List
	 *  @return ArrayList of AcctSchemaElement
	 */
	public ArrayList getAcctSchemaElementList()
	{
		return m_elementList;
	}   //  getAcctSchemaElementList

	/**
	 *  Get AcctSchema Element
	 *  @param segmentType
	 *  @return AcctSchemaElement
	 */
	public AcctSchemaElement getAcctSchemaElement (String segmentType)
	{
		int size = m_elementList.size();
		for (int i = 0; i < size; i++)
		{
			AcctSchemaElement ase = (AcctSchemaElement)m_elementList.get(i);
			if (ase.getSegmentType().equals(segmentType))
				return ase;
		}
		return null;
	}   //  getAcctSchemaElement

	/**
	 *	String representation
	 *  @return String rep
	 */
	public String toString()
	{
		StringBuffer sb = new StringBuffer("AcctSchema[");
		sb.append(m_C_AcctSchema_ID);
		sb.append("-").append(m_Name);
		sb.append("]");
		return sb.toString();
	}	//	toString

	/**
	 *  Get Name
	 *  @return name
	 */
	public String getName()
	{
		return m_Name;
	}   //  getName

	/**
	 *	Get GAAP
	 *  @return GAAP
	 */
	public String getGAAP()
	{
		return m_GAAP;
	}	//	getGAAP

	/**
	 *	Get Costing Type
	 *  @return Costing Method
	 */
	public String getCostingMethod()
	{
		return m_CostingMethod;
	}	//	getCostingMethod

	/**
	 *	Is Accrual
	 *  @return true if accrual
	 */
	public boolean isAccrual()
	{
		return m_IsAccrual;
	}	//	isAccrual

	/**
	 *  HasAlias
	 *  @return true if has alias
	 */
	public boolean hasAlias()
	{
		return m_HasAlias;
	}   //  hasAlias

	/**
	 *  Is Trade Discount posted
	 *  @return true if trade discount is posted
	 */
	public boolean isTradeDiscountPosted()
	{
		return m_IsTradeDiscountPosted;
	}

	/**
	 *  Do we need to cirrect tax for payment discount?
	 *  @return true if tax is corrected
	 */
	public boolean isDiscountCorrectTax()
	{
		return m_IsDiscountCorrectsTax;
	}

	/**
	 *	Get AD_Client_ID
	 *  @return AD_Client_ID
	 */
	public int getAD_Client_ID()
	{
		return m_AD_Client_ID;
	}	//	getC_Currency_ID

	/**
	 *	Get C_Currency_ID
	 *  @return C_Currency_ID
	 */
	public int getC_Currency_ID()
	{
		return m_C_Currency_ID;
	}	//	getC_Currency_ID

	/**
	 *	Get Currency Rate Type
	 *  @return Currency Rate Type
	 */
	public String getCurrencyRateType()
	{
		return m_CurrencyRateType;
	}	//	getCurrencyRateType

	/**
	 *	Use Suspense Balancing
	 *  @return true if suspense balancing
	 */
	public boolean isSuspenseBalancing()
	{
		return m_UseSuspenseBalancing;
	}	//	useSuspenseBalancing

	/**
	 *	Get Suspense Balancing Account
	 *  @return suspense balancing account
	 */
	public Account getSuspenseBalancing_Acct()
	{
		return m_SuspenseBalancing_Acct;
	}	//	getSuspenseBalancing_Acct

	/**
	 *	Use Suspense Error
	 *  @return true if suspense error
	 */
	public boolean isSuspenseError()
	{
		return m_UseSuspenseError;
	}	//	useSuspenseError

	/**
	 *	Get Suspense Error Account
	 *  @return suspense error account
	 */
	public Account getSuspenseError_Acct()
	{
		return m_SuspenseError_Acct;
	}	//	getSuspenseError_Acct

	/**
	 *	Use Currency Balancing
	 *  @return true if currency balancing
	 */
	public boolean isCurrencyBalancing()
	{
		return m_UseCurrencyBalancing;
	}	//	useCurrencyBalancing

	/**
	 *	Get Currency Balancing Account
	 *  @return currency balancing account
	 */
	public Account getCurrencyBalancing_Acct()
	{
		return m_CurrencyBalancing_Acct;
	}	//	getCurrencyBalancing_Acct

	/**
	 *	Get Due To Account for Segment
	 *  @param segment element based on AcctSchemaElement.SEGMENT_*
	 *  @return Account
	 */
	public Account getDueTo_Acct(String segment)
	{
		return m_DueTo_Acct;
	}	//	getDueTo_Acct

	/**
	 *	Get Due From Account for Segment
	 *  @param segment element based on AcctSchemaElement.SEGMENT_*
	 *  @return Account
	 */
	public Account getDueFrom_Acct(String segment)
	{
		return m_DueFrom_Acct;
	}	//	getDueFrom_Acct

	private void writeObject(ObjectOutputStream oos) throws IOException
	{
		oos.defaultWriteObject();
	}
	private void readObject(ObjectInputStream ois) throws ClassNotFoundException, IOException
	{
		ois.defaultReadObject();
	}

}	//	AccountingSchema