WebSVN - OpenConcerto - Diff - Rev 149 and 156 - /trunk/OpenConcerto/src/org/openconcerto/erp/core/common/ui/TotalCalculator.java

 import org.openconcerto.erp.core.finance.accounting.element.ComptePCESQLElement;
 import org.openconcerto.erp.core.finance.tax.model.TaxeCache;
 import org.openconcerto.erp.preferences.GestionCommercialeGlobalPreferencePanel;
 import org.openconcerto.sql.Configuration;
+import org.openconcerto.sql.model.SQLBackgroundTableCache;
+import org.openconcerto.sql.model.SQLBackgroundTableCacheItem;
 import org.openconcerto.sql.model.SQLRow;
 import org.openconcerto.sql.model.SQLRowAccessor;
 import org.openconcerto.sql.model.SQLRowValues;
 import org.openconcerto.sql.model.SQLRowValuesListFetcher;
 import org.openconcerto.sql.model.SQLTable;
 import org.openconcerto.utils.DecimalUtils;
 import org.openconcerto.utils.Tuple2;
 import java.math.BigDecimal;
 import java.math.RoundingMode;
+import java.util.Collection;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
     private static String FIELD_POIDS = "T_POIDS";
     private final String fieldHT, fieldHA, fieldDevise;
     private boolean imputEcart = true;
     private SQLRowAccessor rowDefaultCptProduit, rowDefaultCptService, rowDefaultCptTVACollecte, rowDefaultCptTVADeductible, rowDefaultCptAchat;
+    private final SQLRowAccessor rowCatComptable;
     private SQLRowAccessor rowDefaultCptProduitStandard;
     private double totalPoids;
     private BigDecimal totalDevise, totalDeviseSel;
     private Boolean bServiceActive;
     private BigDecimal totalHTAvantRemise;
     private boolean intraComm = false;
-    public TotalCalculator(String fieldHA, String fieldHT, String fieldDeviseTotal) {
+    public TotalCalculator(String fieldHA, String fieldHT, String fieldDeviseTotal, SQLRowAccessor rowCatComptable) {
-        this(fieldHA, fieldHT, fieldDeviseTotal, false, null);
+        this(fieldHA, fieldHT, fieldDeviseTotal, false, null, rowCatComptable);
+    }
     public void setRowDefaultCptService(SQLRowAccessor rowDefaultCptService) {
         this.rowDefaultCptService = rowDefaultCptService;
+    }
     public void setIntraComm(boolean intraComm) {
         this.intraComm = intraComm;
+    }
-    public TotalCalculator(String fieldHA, String fieldHT, String fieldDeviseTotal, boolean achat, SQLRowAccessor defaultCompte) {
+    public TotalCalculator(String fieldHA, String fieldHT, String fieldDeviseTotal, boolean achat, SQLRowAccessor defaultCompte, SQLRowAccessor rowCatComptable) {
         this.achat = achat;
         initValues();
         this.fieldDevise = fieldDeviseTotal;
         this.fieldHA = fieldHA;
         this.fieldHT = fieldHT;
         final SQLTable tablePrefCompte = Configuration.getInstance().getRoot().findTable("PREFS_COMPTE");
+        final SQLBackgroundTableCacheItem cacheForTablePref = SQLBackgroundTableCache.getInstance().getCacheForTable(tablePrefCompte);
+        final SQLBackgroundTableCacheItem cacheForTableCompte = SQLBackgroundTableCache.getInstance().getCacheForTable(tablePrefCompte.getTable("COMPTE_PCE"));
-        final SQLRow rowPrefsCompte = tablePrefCompte.getRow(2);
+        final SQLRow rowPrefsCompte = cacheForTablePref.getRowFromId(2);
         SQLPreferences prefs = SQLPreferences.getMemCached(tablePrefCompte.getDBRoot());
         this.imputEcart = prefs.getBoolean(GestionCommercialeGlobalPreferencePanel.IMPUT_ECART, true);
         // FIXME faire un fetcher pour ne pas faire 5 requetes (1 par getForeign)
         // Comptes par défaut
-        this.rowDefaultCptService = rowPrefsCompte.getForeign("ID_COMPTE_PCE_VENTE_SERVICE");
+        this.rowDefaultCptService = cacheForTableCompte.getRowFromId(rowPrefsCompte.getForeignID("ID_COMPTE_PCE_VENTE_SERVICE"));
         if (this.rowDefaultCptService == null || this.rowDefaultCptService.isUndefined()) {
             try {
                 this.rowDefaultCptService = ComptePCESQLElement.getRowComptePceDefault("VentesServices");
             } catch (Exception e) {
                 e.printStackTrace();
+            }
+        }
+        this.rowCatComptable = rowCatComptable;
         if (defaultCompte == null || defaultCompte.isUndefined()) {
+            if (rowCatComptable != null && !rowCatComptable.isUndefined() && !rowCatComptable.isForeignEmpty("ID_COMPTE_PCE_VENTE")) {
+                this.rowDefaultCptProduit = cacheForTableCompte.getRowFromId(rowCatComptable.getForeignID("ID_COMPTE_PCE_VENTE"));
+            } else {
-            this.rowDefaultCptProduit = rowPrefsCompte.getForeign("ID_COMPTE_PCE_VENTE_PRODUIT");
+                this.rowDefaultCptProduit = cacheForTableCompte.getRowFromId(rowPrefsCompte.getForeignID("ID_COMPTE_PCE_VENTE_PRODUIT"));
-            if (this.rowDefaultCptProduit == null || this.rowDefaultCptProduit.isUndefined()) {
+                if (this.rowDefaultCptProduit == null || this.rowDefaultCptProduit.isUndefined()) {
-                try {
+                    try {
-                    this.rowDefaultCptProduit = ComptePCESQLElement.getRowComptePceDefault("VentesProduits");
+                        this.rowDefaultCptProduit = ComptePCESQLElement.getRowComptePceDefault("VentesProduits");
-                } catch (Exception e) {
+                    } catch (Exception e) {
-                    e.printStackTrace();
+                        e.printStackTrace();
+                    }
+                }
+            }
         } else {
             this.rowDefaultCptProduit = defaultCompte;
+        }
         this.rowDefaultCptProduitStandard = this.rowDefaultCptProduit;
-        this.rowDefaultCptTVACollecte = rowPrefsCompte.getForeign("ID_COMPTE_PCE_TVA_VENTE");
+        this.rowDefaultCptTVACollecte = cacheForTableCompte.getRowFromId(rowPrefsCompte.getForeignID("ID_COMPTE_PCE_TVA_VENTE"));
         if (this.rowDefaultCptTVACollecte == null || this.rowDefaultCptTVACollecte.isUndefined()) {
             try {
                 this.rowDefaultCptTVACollecte = ComptePCESQLElement.getRowComptePceDefault("TVACollectee");
             } catch (Exception e) {
                 e.printStackTrace();
+            }
+        }
-        this.rowDefaultCptTVADeductible = rowPrefsCompte.getForeign("ID_COMPTE_PCE_TVA_ACHAT");
+        this.rowDefaultCptTVADeductible = cacheForTableCompte.getRowFromId(rowPrefsCompte.getForeignID("ID_COMPTE_PCE_TVA_ACHAT"));
         if (this.rowDefaultCptTVADeductible == null || this.rowDefaultCptTVADeductible.isUndefined()) {
             try {
                 this.rowDefaultCptTVADeductible = ComptePCESQLElement.getRowComptePceDefault("TVADeductible");
             } catch (Exception e) {
                 e.printStackTrace();
+            }
+        }
         if (defaultCompte == null || defaultCompte.isUndefined()) {
+            if (rowCatComptable != null && !rowCatComptable.isUndefined() && !rowCatComptable.isForeignEmpty("ID_COMPTE_PCE_ACHAT")) {
+                this.rowDefaultCptProduit = cacheForTableCompte.getRowFromId(rowCatComptable.getForeignID("ID_COMPTE_PCE_ACHAT"));
+            } else {
-            this.rowDefaultCptAchat = rowPrefsCompte.getForeign("ID_COMPTE_PCE_ACHAT");
+                this.rowDefaultCptAchat = cacheForTableCompte.getRowFromId(rowPrefsCompte.getForeignID("ID_COMPTE_PCE_ACHAT"));
-            if (this.rowDefaultCptAchat == null || this.rowDefaultCptAchat.isUndefined()) {
+                if (this.rowDefaultCptAchat == null || this.rowDefaultCptAchat.isUndefined()) {
-                try {
+                    try {
-                    this.rowDefaultCptAchat = ComptePCESQLElement.getRowComptePceDefault("Achats");
+                        this.rowDefaultCptAchat = ComptePCESQLElement.getRowComptePceDefault("Achats");
-                } catch (Exception e) {
+                    } catch (Exception e) {
-                    e.printStackTrace();
+                        e.printStackTrace();
+                    }
+                }
+            }
         } else {
             this.rowDefaultCptAchat = defaultCompte;
+        }
+    }
     private void addHT(BigDecimal ht, BigDecimal htSansFacturable, SQLRowAccessor tva, SQLRowAccessor cptArticle, boolean selection) {
         BigDecimal ttc;
         BigDecimal totalTVA;
+        final SQLBackgroundTableCacheItem cacheForTableCompte = SQLBackgroundTableCache.getInstance().getCacheForTable(cptArticle.getTable());
         if (tva == null || tva.isUndefined()) {
             ttc = ht;
             totalTVA = BigDecimal.ZERO;
         } else {
         if (tva != null && !tva.isUndefined()) {
             SQLRowAccessor rowCptTva;
             if (this.intraComm) {
                 // Intra comm TTC=HT et solde de TVA
-                rowCptTva = tva.getForeign("ID_COMPTE_PCE_DED_INTRA");
+                rowCptTva = cacheForTableCompte.getRowFromId(tva.getForeignID("ID_COMPTE_PCE_DED_INTRA"));
                 if (rowCptTva == null || rowCptTva.isUndefined()) {
                     rowCptTva = this.rowDefaultCptTVADeductible;
+                }
-                SQLRowAccessor rowCptTvaIntra = tva.getForeign("ID_COMPTE_PCE_COLLECTE_INTRA");
+                SQLRowAccessor rowCptTvaIntra = cacheForTableCompte.getRowFromId(tva.getForeignID("ID_COMPTE_PCE_COLLECTE_INTRA"));
                 if (rowCptTvaIntra == null || rowCptTvaIntra.isUndefined()) {
                     rowCptTvaIntra = this.rowDefaultCptTVADeductible;
+                }
                 if (mapHtTVAIntra.get(rowCptTvaIntra) == null) {
                     mapHtTVAIntra.put(rowCptTvaIntra, totalTVA);
+                } else {
+                    BigDecimal l = mapHtTVAIntra.get(rowCptTvaIntra);
+                    mapHtTVAIntra.put(rowCptTvaIntra, l.add(totalTVA));
+                }
-                ht = ttc;
+                ttc = ht;
             } else if (this.achat) {
-                rowCptTva = tva.getForeign("ID_COMPTE_PCE_DED");
+                rowCptTva = cacheForTableCompte.getRowFromId(tva.getForeignID("ID_COMPTE_PCE_DED"));
                 if (rowCptTva == null || rowCptTva.isUndefined()) {
                     rowCptTva = this.rowDefaultCptTVADeductible;
+                }
             } else {
-                rowCptTva = tva.getForeign("ID_COMPTE_PCE_COLLECTE");
+                rowCptTva = cacheForTableCompte.getRowFromId(tva.getForeignID("ID_COMPTE_PCE_COLLECTE"));
                 if (rowCptTva == null || rowCptTva.isUndefined()) {
                     rowCptTva = this.rowDefaultCptTVACollecte;
+                }
+            }
             if (mapHtTVA.get(rowCptTva) == null) {
         // TODO : generaliser le cache
         if (mapTVA == null || lastTVAfetchedTime + 30 * 1000 < System.currentTimeMillis()) {
             fetchTVA();
+        }
-        final SQLRowAccessor foreignTVA = rowAccessorLine.getForeign("ID_TAXE");
         Integer idTVA = null;
+        if (rowAccessorLine.getObject("ID_TAXE") != null && !rowAccessorLine.isForeignEmpty("ID_TAXE")) {
+            idTVA = rowAccessorLine.getForeignID("ID_TAXE");
+        } else {
+            final SQLRowAccessor foreignTVA = rowAccessorLine.getForeign("ID_TAXE");
-        if (foreignTVA != null) {
+            if (foreignTVA != null) {
-            idTVA = foreignTVA.getID();
+                idTVA = foreignTVA.getID();
+            }
+        }
         SQLRowAccessor tva = mapTVA.get(idTVA);
         SQLRowAccessor cpt = (achat ? this.rowDefaultCptAchat : this.rowDefaultCptProduit);
+        final SQLBackgroundTableCacheItem cacheForTableCompte = SQLBackgroundTableCache.getInstance().getCacheForTable(cpt.getTable());
         if (!achat) {
             // Total Service
             if (bServiceActive != null && bServiceActive && service != null && service.booleanValue()) {
                 totalService = totalService.add(totalLineHT);
                 cpt = this.rowDefaultCptService;
                 if (tva != null && !tva.isForeignEmpty("ID_COMPTE_PCE_VENTE_SERVICE")) {
-                    cpt = tva.getForeign("ID_COMPTE_PCE_VENTE_SERVICE");
+                    cpt = cacheForTableCompte.getRowFromId(tva.getForeignID("ID_COMPTE_PCE_VENTE_SERVICE"));
+                }
             } else {
                 // Compte defini par défaut dans la TVA
                 if (tva != null && !tva.isForeignEmpty("ID_COMPTE_PCE_VENTE")) {
-                    cpt = tva.getForeign("ID_COMPTE_PCE_VENTE");
+                    cpt = cacheForTableCompte.getRowFromId(tva.getForeignID("ID_COMPTE_PCE_VENTE"));
+                }
+            }
+        }
         if (article != null && !article.isUndefined()) {
+            SQLRowAccessor cptCatComptable = null;
+            // TODO Optimiser les requetes
+            if (rowCatComptable != null && !rowCatComptable.isUndefined()) {
+                String suffix = (this.achat ? "_ACHAT" : "_VENTE");
+                Collection<? extends SQLRowAccessor> rows = article.getReferentRows(compteTable.getTable("ARTICLE_CATEGORIE_COMPTABLE"));
+                for (SQLRowAccessor sqlRowAccessor : rows) {
+                    if (sqlRowAccessor.getForeignID("ID_CATEGORIE_COMPTABLE") == this.rowCatComptable.getID()) {
+                        cptCatComptable = cacheForTableCompte.getRowFromId(rowCatComptable.getForeignID("ID_COMPTE_PCE" + suffix));
+                    }
+                }
+            }
+            if (cptCatComptable == null) {
-            String suffix = (this.achat ? "_ACHAT" : "");
+                String suffix = (this.achat ? "_ACHAT" : "");
-            SQLRowAccessor compteArticle = article.getForeign("ID_COMPTE_PCE" + suffix);
+                SQLRowAccessor compteArticle = cacheForTableCompte.getRowFromId(article.getForeignID("ID_COMPTE_PCE" + suffix));
-            if (compteArticle != null && !compteArticle.isUndefined()) {
+                if (compteArticle != null && !compteArticle.isUndefined()) {
-                cpt = compteArticle;
+                    cpt = compteArticle;
-            } else {
+                } else {
-                SQLRowAccessor familleArticle = article.getForeign("ID_FAMILLE_ARTICLE");
+                    SQLRowAccessor familleArticle = article.getForeign("ID_FAMILLE_ARTICLE");
-                Set<SQLRowAccessor> unique = new HashSet<SQLRowAccessor>();
+                    Set<SQLRowAccessor> unique = new HashSet<SQLRowAccessor>();
-                while (familleArticle != null && !familleArticle.isUndefined() && !unique.contains(familleArticle)) {
+                    while (familleArticle != null && !familleArticle.isUndefined() && !unique.contains(familleArticle)) {
-                    unique.add(familleArticle);
+                        unique.add(familleArticle);
+                        if (familleArticle.getObject("ID_COMPTE_PCE" + suffix) != null && !familleArticle.isForeignEmpty("ID_COMPTE_PCE" + suffix)) {
-                    SQLRowAccessor compteFamilleArticle = familleArticle.getForeign("ID_COMPTE_PCE" + suffix);
+                            SQLRowAccessor compteFamilleArticle = cacheForTableCompte.getRowFromId(familleArticle.getForeignID("ID_COMPTE_PCE" + suffix));
-                    if (compteFamilleArticle != null && !compteFamilleArticle.isUndefined()) {
+                            if (compteFamilleArticle != null && !compteFamilleArticle.isUndefined()) {
-                        cpt = compteFamilleArticle;
+                                cpt = compteFamilleArticle;
-                        break;
+                                break;
+                            }
+                        }
-                    familleArticle = familleArticle.getForeign("ID_FAMILLE_ARTICLE_PERE");
+                        familleArticle = familleArticle.getForeign("ID_FAMILLE_ARTICLE_PERE");
+                    }
+                }
+            } else {
+                cpt = cptCatComptable;
+            }
             if (!achat) {
                 SQLRowAccessor taxeCompl = (article.getFields().contains("ID_TAXE_COMPLEMENTAIRE") && article.getObject("ID_TAXE_COMPLEMENTAIRE") != null
                         && !article.isForeignEmpty("ID_TAXE_COMPLEMENTAIRE") ? article.getForeign("ID_TAXE_COMPLEMENTAIRE") : null);
                 if (taxeCompl != null && !taxeCompl.isUndefined()) {

Dépôt officiel du code source de l'ERP OpenConcerto

svn://code.openconcerto.org/openconcerto

(root)/trunk/OpenConcerto/src/org/openconcerto/erp/core/common/ui/TotalCalculator.java - Rev 149 → 156