AcctSchema


1   /******************************************************************************
2    * The contents of this file are subject to the   Compiere License  Version 1.1
3    * ("License"); You may not use this file except in compliance with the License
4    * You may obtain a copy of the License at http://www.compiere.org/license.html
5    * Software distributed under the License is distributed on an  "AS IS"  basis,
6    * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
7    * the specific language governing rights and limitations under the License.
8    * The Original Code is                  Compiere  ERP & CRM  Business Solution
9    * The Initial Developer of the Original Code is Jorg Janke  and ComPiere, Inc.
10   * Portions created by Jorg Janke are Copyright (C) 1999-2001 Jorg Janke, parts
11   * created by ComPiere are Copyright (C) ComPiere, Inc.;   All Rights Reserved.
12   * Contributor(s): ______________________________________.
13   *****************************************************************************/
14  package org.compiere.model;
15  
16  import java.sql.*;
17  import java.util.*;
18  
19  import org.compiere.util.*;
20  import java.io.*;
21  
22  /**
23   *  Accounting Schema Object
24   *
25   *  @author     Jorg Janke
26   *  @version    $Id: AcctSchema.java,v 1.12 2003/07/22 05:40:41 jjanke Exp $
27   */
28  public final class AcctSchema implements Serializable
29  {
30      /**
31       *  Constructor
32       *  @param C_AcctSchema_ID acct schema
33       */
34      public AcctSchema (int C_AcctSchema_ID)
35      {
36          Log.trace(Log.l1_User, "AcctSchema - " + C_AcctSchema_ID);
37          load (C_AcctSchema_ID);
38      }   //  DocumentType
39  
40      /** ID                  */
41      private int         m_C_AcctSchema_ID = 0;
42  
43      /** database field      */
44      private String        m_Name = null;
45      /** database field      */
46      private String        m_GAAP = null;
47      /** database field      */
48      private boolean     m_IsAccrual = false;
49      /** HasAlias            */
50      private boolean     m_HasAlias = true;
51      /** database field      */
52      private String        m_CostingMethod = null;
53      /** database field      */
54      private int         m_C_Currency_ID = 0;
55      private int         m_AD_Client_ID = 0;
56      private boolean     m_IsTradeDiscountPosted = false;
57      private boolean     m_IsDiscountCorrectsTax = false;
58  
59  
60      /** database field      */
61      private String        m_CurrencyRateType = "S";       //  Spot default
62  
63      /** database field      */
64      private boolean     m_UseSuspenseBalancing = false;
65      /** database field      */
66      private Account     m_SuspenseBalancing_Acct = null;
67      /** database field      */
68      private boolean     m_UseSuspenseError = false;
69      /** database field      */
70      private Account     m_SuspenseError_Acct = null;
71      /** database field      */
72      private boolean     m_UseCurrencyBalancing = false;
73      /** database field      */
74      private Account     m_CurrencyBalancing_Acct = null;
75      /** database field      */
76      private Account     m_DueTo_Acct = null;
77      /** database field      */
78      private Account     m_DueFrom_Acct = null;
79      //
80  
81      /** Segment Lists       */
82      ArrayList   m_elementList = null;
83  
84      //  Costing Methods
85      public static final String    COSTING_AVERAGE = "A";
86      public static final String    COSTING_STANDARD = "S";
87  //  public static final String  COSTING_FIFO = "F";
88  //  public static final String  COSTING_LIFO = "L";
89      public static final String    COSTING_LASTPO = "P";
90  
91      //  GAAPs
92      public static final String    GAAP_US = "US";
93      public static final String    GAAP_INTERNATIONAL = "UN";
94      public static final String    GAAP_GERMAN = "DE";
95  
96      /*************************************************************************/
97  
98      /**  Cache                              **/
99      private static CCache  s_schema = new CCache("acctSchema", 3);      //  3 clients
100 
101     /**
102      *  Factory: Get AccountSchema List
103      *  @param AD_Client_ID client
104      *  @return ArrayList of AcctSchema of Client
105      */
106     public static synchronized ArrayList getAcctSchemaList (int AD_Client_ID)
107     {
108         //  Check Cache
109         Integer   key = new Integer  (AD_Client_ID);
110         if (s_schema.containsKey(key))
111             return (ArrayList)s_schema.get(key);
112 
113         //  Create New
114         ArrayList list = new ArrayList();
115         String   sql = "SELECT C_AcctSchema1_ID,"
116                 + "Acct2_Active,C_AcctSchema2_ID,"
117                 + "Acct3_Active,C_AcctSchema3_ID "
118             + "FROM AD_ClientInfo WHERE AD_Client_ID=?";
119         try
120         {
121             PreparedStatement pstmt = DB.prepareStatement(sql);
122             pstmt.setInt(1, AD_Client_ID);
123             ResultSet rs = pstmt.executeQuery();
124             if (rs.next())
125             {
126                 int as = rs.getInt(1);
127                 list.add(new AcctSchema(as));
128                 //
129                 if (rs.getString(2).equals("Y"))
130                 {
131                     as = rs.getInt(3);
132                     if (as != 0)
133                         list.add(new AcctSchema(as));
134                 }
135                 if (rs.getString(4).equals("Y"))
136                 {
137                     as = rs.getInt(5);
138                     if (as != 0)
139                         list.add(new AcctSchema(as));
140                 }
141             }
142             rs.close();
143             pstmt.close();
144         }
145         catch (SQLException e)
146         {
147             Log.error ("AcctSchema.getAcctSchemaList", e);
148         }
149         //  Save
150         s_schema.put(key, list);
151         return list;
152     }   //  getAcctSchemaList
153 
154     /**
155      *  AcctSchema Element Array
156      *  @param AD_Client_ID client
157      *  @return AcctSchema Array of Client
158      */
159     public static AcctSchema[] getAcctSchemaArray(int AD_Client_ID)
160     {
161         ArrayList list = getAcctSchemaList (AD_Client_ID);
162         AcctSchema[] retValue = new AcctSchema [list.size()];
163         list.toArray(retValue);
164         return retValue;
165     }   //  getAcctSchemaArray
166 
167     /*************************************************************************/
168 
169     /**
170      *  Get Details & accounts
171      *  @param newC_AcctSchema_ID acct schema
172      */
173     public void load (int newC_AcctSchema_ID)
174     {
175         Log.trace(Log.l3_Util, "AcctSchema.load - " + newC_AcctSchema_ID);
176         //
177         m_C_AcctSchema_ID = newC_AcctSchema_ID;
178         String   sql = "SELECT Name,GAAP,IsAccrual,CostingMethod,C_Currency_ID,HasAlias, "
179             + "IsTradeDiscountPosted,IsDiscountCorrectsTax, AD_Client_ID "
180             + "FROM C_AcctSchema WHERE C_AcctSchema_ID=?";
181         try
182         {
183             PreparedStatement pstmt = DB.prepareStatement(sql);
184             pstmt.setInt(1, m_C_AcctSchema_ID);
185             ResultSet rs = pstmt.executeQuery();
186             if (rs.next())
187             {
188                 m_Name = rs.getString(1);
189                 m_GAAP = rs.getString(2);
190                 m_IsAccrual = rs.getString(3).equals("Y");
191                 m_CostingMethod = rs.getString(4);
192                 m_C_Currency_ID = rs.getInt(5);
193                 m_HasAlias = rs.getString(6).equals("Y");
194                 m_IsTradeDiscountPosted = rs.getString(7).equals("Y");
195                 m_IsDiscountCorrectsTax = rs.getString(8).equals("Y");
196                 m_AD_Client_ID = rs.getInt(9);
197             }
198             rs.close();
199             pstmt.close();
200             //  _GL
201             sql = "SELECT UseSuspenseBalancing,SuspenseBalancing_Acct, "    //  1..2
202                 + "UseSuspenseError,SuspenseError_Acct, "                   //  3..4
203                 + "UseCurrencyBalancing,CurrencyBalancing_Acct, "           //  5..6
204                 + "RetainedEarning_Acct,IncomeSummary_Acct, "               //  7..8
205                 + "InterCompanyDueTo_Acct,InterCompanyDueFrom_Acct "        //  9..10
206                 + "FROM C_AcctSchema_GL "
207                 + "WHERE C_AcctSchema_ID=?";
208             pstmt = DB.prepareStatement(sql);
209             pstmt.setInt(1, m_C_AcctSchema_ID);
210             rs = pstmt.executeQuery();
211             if (rs.next())
212             {
213                 //  Suspense Balance
214                 m_UseSuspenseBalancing = rs.getString(1).equals("Y");
215                 int ID = rs.getInt(2);
216                 if (m_UseSuspenseBalancing && ID != 0)
217                     m_SuspenseBalancing_Acct = Account.getAccount(ID);
218                 else
219                     m_UseSuspenseBalancing = false;
220                 Log.trace(Log.l4_Data, "SuspenseBalancing=" + m_UseSuspenseBalancing + " " + m_SuspenseBalancing_Acct);
221                 //  Suspense Error
222                 m_UseSuspenseError = rs.getString(3).equals("Y");
223                 ID = rs.getInt(4);
224                 if (m_UseSuspenseError && ID != 0)
225                     m_SuspenseError_Acct = Account.getAccount(ID);
226                 else
227                     m_UseSuspenseError = false;
228                 Log.trace(Log.l4_Data, "SuspenseError=" + m_UseSuspenseError + " " + m_SuspenseError_Acct);
229                 //  Currency Balancing
230                 m_UseCurrencyBalancing = rs.getString(5).equals("Y");
231                 ID = rs.getInt(6);
232                 if (m_UseCurrencyBalancing && ID != 0)
233                     m_CurrencyBalancing_Acct = Account.getAccount(ID);
234                 else
235                     m_UseCurrencyBalancing = false;
236                 Log.trace(Log.l4_Data, "CurrencyBalancing=" + m_UseCurrencyBalancing + " " + m_CurrencyBalancing_Acct);
237                 //  -retained
238                 //  InterCompany
239                 ID = rs.getInt(9);
240                 if (ID != 0)
241                     m_DueTo_Acct = Account.getAccount(ID);
242                 ID = rs.getInt(10);
243                 if (ID != 0)
244                     m_DueFrom_Acct = Account.getAccount(ID);
245             }
246             rs.close();
247             pstmt.close();
248 
249             //  _Default
250 
251             //  Segments
252             m_elementList = AcctSchemaElement.getAcctSchemaElementList(m_C_AcctSchema_ID);
253         }
254         catch (SQLException e)
255         {
256             Log.error ("AcctSchema.load SQL=" + sql, e);
257             m_C_AcctSchema_ID = 0;
258         }
259     }   //  load
260 
261 
262     /*************************************************************************/
263 
264     /**
265      *  Get Acct_Schema
266      *  @return C_AcctSchema_ID
267      */
268     public int getC_AcctSchema_ID()
269     {
270         return m_C_AcctSchema_ID;
271     }   //  getC_AcctSchema_ID
272 
273     /**
274      *  AcctSchema Element List
275      *  @return ArrayList of AcctSchemaElement
276      */
277     public ArrayList getAcctSchemaElementList()
278     {
279         return m_elementList;
280     }   //  getAcctSchemaElementList
281 
282     /**
283      *  Get AcctSchema Element
284      *  @param segmentType segment type - AcctSchemaElement.SEGMENT_
285      *  @return AcctSchemaElement
286      */
287     public AcctSchemaElement getAcctSchemaElement (String   segmentType)
288     {
289         int size = m_elementList.size();
290         for (int i = 0; i < size; i++)
291         {
292             AcctSchemaElement ase = (AcctSchemaElement)m_elementList.get(i);
293             if (ase.getSegmentType().equals(segmentType))
294                 return ase;
295         }
296         return null;
297     }   //  getAcctSchemaElement
298 
299     /**
300      *  Has AcctSchema Element
301      *  @param segmentType segment type - AcctSchemaElement.SEGMENT_
302      *  @return true if schema has segment type
303      */
304     public boolean isAcctSchemaElement (String   segmentType)
305     {
306         return getAcctSchemaElement(segmentType) != null;
307     }   //  isAcctSchemaElement
308 
309 
310 
311     /**
312      *  String representation
313      *  @return String rep
314      */
315     public String   toString()
316     {
317         StringBuffer   sb = new StringBuffer  ("AcctSchema[");
318         sb.append(m_C_AcctSchema_ID);
319         sb.append("-").append(m_Name);
320         sb.append("]");
321         return sb.toString();
322     }   //  toString
323 
324     /**
325      *  Get Name
326      *  @return name
327      */
328     public String   getName()
329     {
330         return m_Name;
331     }   //  getName
332 
333     /**
334      *  Get GAAP
335      *  @return GAAP
336      */
337     public String   getGAAP()
338     {
339         return m_GAAP;
340     }   //  getGAAP
341 
342     /**
343      *  Get Costing Type
344      *  @return Costing Method
345      */
346     public String   getCostingMethod()
347     {
348         return m_CostingMethod;
349     }   //  getCostingMethod
350 
351     /**
352      *  Is Accrual
353      *  @return true if accrual
354      */
355     public boolean isAccrual()
356     {
357         return m_IsAccrual;
358     }   //  isAccrual
359 
360     /**
361      *  HasAlias
362      *  @return true if has alias
363      */
364     public boolean hasAlias()
365     {
366         return m_HasAlias;
367     }   //  hasAlias
368 
369     /**
370      *  Is Trade Discount posted
371      *  @return true if trade discount is posted
372      */
373     public boolean isTradeDiscountPosted()
374     {
375         return m_IsTradeDiscountPosted;
376     }
377 
378     /**
379      *  Do we need to cirrect tax for payment discount?
380      *  @return true if tax is corrected
381      */
382     public boolean isDiscountCorrectTax()
383     {
384         return m_IsDiscountCorrectsTax;
385     }
386 
387     /**
388      *  Get AD_Client_ID
389      *  @return AD_Client_ID
390      */
391     public int getAD_Client_ID()
392     {
393         return m_AD_Client_ID;
394     }   //  getC_Currency_ID
395 
396     /**
397      *  Get C_Currency_ID
398      *  @return C_Currency_ID
399      */
400     public int getC_Currency_ID()
401     {
402         return m_C_Currency_ID;
403     }   //  getC_Currency_ID
404 
405     /**
406      *  Get Currency Rate Type
407      *  @return Currency Rate Type
408      */
409     public String   getCurrencyRateType()
410     {
411         return m_CurrencyRateType;
412     }   //  getCurrencyRateType
413 
414     /**
415      *  Use Suspense Balancing
416      *  @return true if suspense balancing
417      */
418     public boolean isSuspenseBalancing()
419     {
420         return m_UseSuspenseBalancing;
421     }   //  useSuspenseBalancing
422 
423     /**
424      *  Get Suspense Balancing Account
425      *  @return suspense balancing account
426      */
427     public Account getSuspenseBalancing_Acct()
428     {
429         return m_SuspenseBalancing_Acct;
430     }   //  getSuspenseBalancing_Acct
431 
432     /**
433      *  Use Suspense Error
434      *  @return true if suspense error
435      */
436     public boolean isSuspenseError()
437     {
438         return m_UseSuspenseError;
439     }   //  useSuspenseError
440 
441     /**
442      *  Get Suspense Error Account
443      *  @return suspense error account
444      */
445     public Account getSuspenseError_Acct()
446     {
447         return m_SuspenseError_Acct;
448     }   //  getSuspenseError_Acct
449 
450     /**
451      *  Use Currency Balancing
452      *  @return true if currency balancing
453      */
454     public boolean isCurrencyBalancing()
455     {
456         return m_UseCurrencyBalancing;
457     }   //  useCurrencyBalancing
458 
459     /**
460      *  Get Currency Balancing Account
461      *  @return currency balancing account
462      */
463     public Account getCurrencyBalancing_Acct()
464     {
465         return m_CurrencyBalancing_Acct;
466     }   //  getCurrencyBalancing_Acct
467 
468     /**
469      *  Get Due To Account for Segment
470      *  @param segment element based on AcctSchemaElement.SEGMENT_*
471      *  @return Account
472      */
473     public Account getDueTo_Acct(String   segment)
474     {
475         return m_DueTo_Acct;
476     }   //  getDueTo_Acct
477 
478     /**
479      *  Get Due From Account for Segment
480      *  @param segment element based on AcctSchemaElement.SEGMENT_*
481      *  @return Account
482      */
483     public Account getDueFrom_Acct(String   segment)
484     {
485         return m_DueFrom_Acct;
486     }   //  getDueFrom_Acct
487 
488     private void writeObject(ObjectOutputStream oos) throws IOException
489     {
490         oos.defaultWriteObject();
491     }
492     private void readObject(ObjectInputStream ois) throws ClassNotFoundException  , IOException
493     {
494         ois.defaultReadObject();
495     }
496 
497 }   //  AccountingSchema
498
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags