www.pudn.com > code_source_compiere_erp_crm_logiciel_java.zip > AcctSchema.java
/******************************************************************************
* 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