WebSVN - OpenConcerto - Diff - Rev 182 and 185 - /trunk/OpenConcerto/src/org/openconcerto/erp/core/supplychain/stock/element/InventaireFromEtatStockImporter.java

 import org.openconcerto.erp.importer.DataImporter;
 import org.openconcerto.erp.preferences.GestionArticleGlobalPreferencePanel;
 import org.openconcerto.sql.Configuration;
 import org.openconcerto.sql.element.SQLElement;
 import org.openconcerto.sql.model.DBRoot;
+import org.openconcerto.sql.model.SQLBase;
+import org.openconcerto.sql.model.SQLInsert;
 import org.openconcerto.sql.model.SQLRow;
 import org.openconcerto.sql.model.SQLRowAccessor;
 import org.openconcerto.sql.model.SQLRowListRSH;
 import org.openconcerto.sql.model.SQLRowValues;
-import org.openconcerto.sql.model.SQLRowValuesCluster.StoreMode;
 import org.openconcerto.sql.model.SQLRowValuesListFetcher;
 import org.openconcerto.sql.model.SQLSelect;
 import org.openconcerto.sql.model.SQLTable;
+import org.openconcerto.sql.model.SQLUpdate;
+import org.openconcerto.sql.model.Where;
 import org.openconcerto.sql.preferences.SQLPreferences;
+import org.openconcerto.sql.request.UpdateBuilder;
 import org.openconcerto.sql.utils.SQLUtils;
-import org.openconcerto.utils.Tuple2;
+import org.openconcerto.utils.CollectionUtils;
 import org.openconcerto.utils.Tuple3;
+import org.openconcerto.utils.cc.ITransformer;
 import java.io.File;
 import java.io.IOException;
 import java.math.BigDecimal;
 import java.sql.SQLException;
 import java.util.Arrays;
 import java.util.Calendar;
 import java.util.Collection;
 import java.util.Date;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Set;
 import org.apache.commons.dbutils.ResultSetHandler;
 public class InventaireFromEtatStockImporter {
     private Map<String, SQLRowValues> kits = new HashMap<String, SQLRowValues>();
+    private Map<Integer, InventaireProductLine> kitsChildren = new HashMap<Integer, InventaireProductLine>();
     private List<String> codeKits = new ArrayList<String>();
-    private SQLRowAccessor depot;
     private static String FAMILLE = "Famille";
     private static String CODE = "Code";
     private static String NOM = "Nom";
     private static String TAILLE = "Taille";
+    private static String DEPOT = "Dépôt";
     private static String COULEUR = "Couleur";
     private static String QTE = "Qté réelle relevée";
     private static String QTE_OPENCONCERTO = "QTE OpenConcerto";
     private final Map<String, Integer> mapCouleur = new HashMap<String, Integer>();
     private final Map<String, Integer> mapTaille = new HashMap<String, Integer>();
     private final DBRoot root;
     private final SQLElement artElt;
-    public InventaireFromEtatStockImporter(SQLElement articleElt, SQLRowAccessor depot) {
+    public InventaireFromEtatStockImporter(SQLElement articleElt) {
-        this.depot = depot;
         this.root = articleElt.getTable().getDBRoot();
         this.artElt = articleElt;
+        {
             SQLSelect sel = new SQLSelect();
             sel.addSelect(articleElt.getTable().getTable("ARTICLE_DECLINAISON_COULEUR").getKey());
             sel.addSelect(articleElt.getTable().getTable("ARTICLE_DECLINAISON_COULEUR").getField("NOM"));
             List<SQLRow> l = SQLRowListRSH.execute(sel);
             for (SQLRow sqlRow : l) {
-                mapCouleur.put(sqlRow.getString("NOM").trim(), sqlRow.getID());
+                this.mapCouleur.put(sqlRow.getString("NOM").trim(), sqlRow.getID());
+            }
+        }
+        {
             SQLSelect sel = new SQLSelect();
             sel.addSelect(articleElt.getTable().getTable("ARTICLE_DECLINAISON_TAILLE").getField("NOM"));
             List<SQLRow> l = SQLRowListRSH.execute(sel);
             for (SQLRow sqlRow : l) {
-                mapTaille.put(sqlRow.getString("NOM").trim(), sqlRow.getID());
+                this.mapTaille.put(sqlRow.getString("NOM").trim(), sqlRow.getID());
+            }
+        }
+    }
     public void importArticles(File file, DBRoot root) throws IOException, SQLException {
         columnMapping.put(TAILLE, null);
         columnMapping.put(FAMILLE, null);
         columnMapping.put(COULEUR, null);
         columnMapping.put(QTE, null);
         columnMapping.put(QTE_OPENCONCERTO, null);
+        columnMapping.put(DEPOT, null);
+        {
             // Searching column index from column Header
             final DataImporter importer = new DataImporter(table);
             importer.setSkipFirstLine(false);
             ArrayTableModel m = importer.createModelFrom(file);
         String msg = "Colonnes importées : \n";
         final SQLPreferences prefs = SQLPreferences.getMemCached(table.getDBRoot());
         final boolean hasDeclinaison = prefs.getBoolean(GestionArticleGlobalPreferencePanel.ACTIVER_DECLINAISON, false);
         List<String> required;
         if (hasDeclinaison) {
             required = Arrays.asList(CODE, QTE, QTE_OPENCONCERTO, TAILLE, COULEUR);
         } else {
             required = Arrays.asList(CODE, QTE, QTE_OPENCONCERTO);
+        }
+        SQLSelect selDepot = new SQLSelect();
+        selDepot.addSelectStar(tableArtElt.getTable("DEPOT_STOCK"));
+        final List<SQLRow> listDepot = SQLRowListRSH.execute(selDepot);
+        final Map<String, SQLRow> mapDepot = new HashMap<>();
+        for (SQLRow sqlRow : listDepot) {
+            mapDepot.put(sqlRow.getString("NOM"), sqlRow);
+        }
         for (Entry<String, Integer> e : columnMapping.entrySet()) {
             if (e.getValue() != null) {
                 msg += e.getKey() + " : " + getColumnName(e.getValue()) + "\n";
             } else {
                 if (required.contains(e.getKey())) {
             };
             importer.setSkipFirstLine(true);
             ArrayTableModel m = importer.createModelFrom(file);
+            // Check depot
+            boolean multiDepotPrefs = prefs.getBoolean(GestionArticleGlobalPreferencePanel.STOCK_MULTI_DEPOT, false);
+            SQLRowAccessor defaultDepotRow = null;
+            boolean multiDepotFile = columnMapping.containsKey(DEPOT);
+            if (!multiDepotFile) {
+                if (multiDepotPrefs) {
+                    // TODO popup choix depot
+                } else {
+                    defaultDepotRow = table.getTable("DEPOT_STOCK").getRow(DepotStockSQLElement.DEFAULT_ID);
+                }
+            } else {
+                Set<String> errors = new HashSet<>();
+                for (int i = 1; i < m.getRowCount(); i++) {
+                    List<Object> o = m.getLineValuesAt(i);
+                    if (o.size() >= 5) {
+                        System.err.println(o);
+                        String code = o.get(columnMapping.get(CODE)).toString();
+                        if (code.trim().length() > 0) {
+                            final String depotName = o.get(columnMapping.get(DEPOT)).toString().trim();
+                            if (depotName.length() == 0) {
+                                errors.add("Le Depôt n'est pas renseigné, ligne " + i + ". Import annulé!");
+                            } else if (mapDepot.get(depotName) == null) {
+                                errors.add("Impossible de trouver le dépôt " + depotName + ", ligne " + i + ". Import annulé!");
+                            }
+                        }
+                    }
+                }
+                if (!errors.isEmpty()) {
+                    JOptionPane.showMessageDialog(null, errors);
+                    return;
+                }
+            }
             Calendar c = Calendar.getInstance();
             // c.set(Calendar.DAY_OF_MONTH, 1);
             // c.set(Calendar.MONTH, Calendar.JANUARY);
             // c.set(Calendar.HOUR_OF_DAY, 0);
             Date today = c.getTime();
             // TODO ne pas vider les stocks des kits, recalculer les stocks des kits
-            SQLRowValues rowVals = new SQLRowValues(table.getTable("ETAT_STOCK"));
-            rowVals.put("DATE", today);
-            rowVals.put("INVENTAIRE", Boolean.TRUE);
-            rowVals.put("ID_DEPOT_STOCK", this.depot.getID());
-            SQLRow rowEtat = rowVals.commit();
+            Map<Integer, Integer> mapDepotEtat = new HashMap<>();
+            List<SQLInsert> inserts = new ArrayList<>();
+            List<SQLUpdate> updates = new ArrayList<>();
             for (int i = 1; i < m.getRowCount(); i++) {
                 List<Object> o = m.getLineValuesAt(i);
                 if (o.size() >= 5) {
                     System.err.println(o);
                     String code = o.get(columnMapping.get(CODE)).toString();
                             taille = o.get(columnMapping.get(TAILLE)).toString();
+                        }
                         // SQLRowAccessor match = findArticle(code, couleur, taille);
-                        Tuple2<SQLRowValues, SQLRowValues> match = findArticle(code, couleur, taille);
+                        InventaireProductLine match = findArticle(code, couleur, taille);
                         if (match != null) {
-                            SQLRowAccessor stockValues = match.get1();
+                            SQLRowAccessor depotRow = defaultDepotRow;
+                            if (multiDepotFile) {
+                                final String depotName = o.get(columnMapping.get(DEPOT)).toString().trim();
+                                depotRow = mapDepot.get(depotName);
+                            }
+                            if (!mapDepotEtat.containsKey(depotRow.getID())) {
+                                mapDepotEtat.put(depotRow.getID(), createEtat(table.getTable("ETAT_STOCK"), depotRow.getID()).commit().getID());
+                            }
+                            int etatID = mapDepotEtat.get(depotRow.getID());
+                            SQLRowAccessor stockValues = match.getOrCreateStockRowValues(depotRow);
                             final SQLTable tableMvt = table.getTable("MOUVEMENT_STOCK");
-                            SQLRowValues rowValsMvtStockClotureFermeture = new SQLRowValues(tableMvt);
+                            SQLInsert insertMvtStockClotureFermeture = new SQLInsert();
-                            rowValsMvtStockClotureFermeture.put("QTE", -qtyOld);
+                            insertMvtStockClotureFermeture.add(tableMvt.getField("QTE"), -qtyOld);
-                            rowValsMvtStockClotureFermeture.put("NOM", "Clôture stock avant inventaire");
+                            insertMvtStockClotureFermeture.add(tableMvt.getField("NOM"), "Clôture stock avant inventaire");
-                            rowValsMvtStockClotureFermeture.put("ID_ARTICLE", match.get0().getID());
+                            insertMvtStockClotureFermeture.add(tableMvt.getField("ID_ARTICLE"), match.getRowValsArt().getID());
-                            rowValsMvtStockClotureFermeture.put("DATE", today);
+                            insertMvtStockClotureFermeture.add(tableMvt.getField("DATE"), today);
-                            rowValsMvtStockClotureFermeture.put("REEL", Boolean.TRUE);
+                            insertMvtStockClotureFermeture.add(tableMvt.getField("REEL"), Boolean.TRUE);
-                            rowValsMvtStockClotureFermeture.put("ID_STOCK", stockValues.getID());
+                            insertMvtStockClotureFermeture.add(tableMvt.getField("ID_STOCK"), stockValues.getID());
-                            BigDecimal prc = getPRC(match.get0(), Math.round(qtyOld), today);
+                            BigDecimal prc = getPRC(match.getRowValsArt(), Math.round(qtyOld), today);
                             if (prc == null) {
                                 prc = BigDecimal.ZERO;
+                            }
                             if (tableMvt.contains("PRICE")) {
-                                rowValsMvtStockClotureFermeture.put("PRICE", prc);
+                                insertMvtStockClotureFermeture.add(tableMvt.getField("PRICE"), prc);
+                            }
-                            rowValsMvtStockClotureFermeture.put("CLOTURE", Boolean.TRUE);
+                            insertMvtStockClotureFermeture.add(tableMvt.getField("CLOTURE"), Boolean.TRUE);
-                            rowValsMvtStockClotureFermeture.put("ID_ETAT_STOCK", rowEtat.getID());
+                            insertMvtStockClotureFermeture.add(tableMvt.getField("ID_ETAT_STOCK"), etatID);
-                            rowValsMvtStockClotureFermeture.getGraph().store(StoreMode.COMMIT, false);
+                            // insertMvtStockClotureFermeture.getGraph().store(StoreMode.COMMIT,
+                            // false);
+                            inserts.add(insertMvtStockClotureFermeture);
-                            SQLRowValues rowValsItem = new SQLRowValues(table.getTable("ETAT_STOCK_ELEMENT"));
+                            final SQLTable tableEtatElt = table.getTable("ETAT_STOCK_ELEMENT");
+                            SQLInsert insertItem = new SQLInsert();
-                            rowValsItem.put("ID_ETAT_STOCK", rowEtat.getID());
+                            insertItem.add(tableEtatElt.getField("ID_ETAT_STOCK"), etatID);
-                            rowValsItem.put("PA", prc);
+                            insertItem.add(tableEtatElt.getField("PA"), prc);
-                            rowValsItem.put("PV", BigDecimal.ZERO);
+                            insertItem.add(tableEtatElt.getField("PV"), BigDecimal.ZERO);
-                            rowValsItem.put("QTE", qtyOld);
+                            insertItem.add(tableEtatElt.getField("QTE"), qtyOld);
-                            rowValsItem.put("T_PA", prc.multiply(new BigDecimal(qtyOld)));
+                            insertItem.add(tableEtatElt.getField("T_PA"), prc.multiply(new BigDecimal(qtyOld)));
-                            rowValsItem.put("T_PV", BigDecimal.ZERO);
+                            insertItem.add(tableEtatElt.getField("T_PV"), BigDecimal.ZERO);
-                            rowValsItem.put("CODE", match.get0().getString("CODE"));
+                            insertItem.add(tableEtatElt.getField("CODE"), match.getRowValsArt().getString("CODE"));
-                            rowValsItem.put("NOM", match.get0().getString("NOM"));
+                            insertItem.add(tableEtatElt.getField("NOM"), match.getRowValsArt().getString("NOM"));
-                            rowValsItem.put("ID_ARTICLE", match.get0().getID());
+                            insertItem.add(tableEtatElt.getField("ID_ARTICLE"), match.getRowValsArt().getID());
-                            rowValsItem.getGraph().store(StoreMode.COMMIT, false);
+                            // insertItem.getGraph().store(StoreMode.COMMIT, false);
+                            inserts.add(insertItem);
-                            SQLRowValues rowValsMvtStockClotureOuverture = new SQLRowValues(tableMvt);
+                            SQLInsert insertMvtStockClotureOuverture = new SQLInsert();
-                            rowValsMvtStockClotureOuverture.put("QTE", qty);
+                            insertMvtStockClotureOuverture.add(tableMvt.getField("QTE"), qty);
-                            rowValsMvtStockClotureOuverture.put("NOM", "Mise en stock inventaire");
+                            insertMvtStockClotureOuverture.add(tableMvt.getField("NOM"), "Mise en stock inventaire");
-                            rowValsMvtStockClotureOuverture.put("ID_ETAT_STOCK", rowEtat.getID());
+                            insertMvtStockClotureOuverture.add(tableMvt.getField("ID_ETAT_STOCK"), etatID);
-                            rowValsMvtStockClotureOuverture.put("ID_ARTICLE", match.get0().getID());
+                            insertMvtStockClotureOuverture.add(tableMvt.getField("ID_ARTICLE"), match.getRowValsArt().getID());
-                            rowValsMvtStockClotureOuverture.put("DATE", today);
+                            insertMvtStockClotureOuverture.add(tableMvt.getField("DATE"), today);
-                            rowValsMvtStockClotureOuverture.put("REEL", Boolean.TRUE);
+                            insertMvtStockClotureOuverture.add(tableMvt.getField("REEL"), Boolean.TRUE);
-                            rowValsMvtStockClotureOuverture.put("ID_STOCK", stockValues.getID());
+                            insertMvtStockClotureOuverture.add(tableMvt.getField("ID_STOCK"), stockValues.getID());
-                            rowValsMvtStockClotureOuverture.put("OUVERTURE", Boolean.TRUE);
+                            insertMvtStockClotureOuverture.add(tableMvt.getField("OUVERTURE"), Boolean.TRUE);
                             if (tableMvt.contains("PRICE")) {
-                                rowValsMvtStockClotureOuverture.put("PRICE", getPRC(match.get0(), qty.intValue(), today));
+                                insertMvtStockClotureOuverture.add(tableMvt.getField("PRICE"), getPRC(match.getRowValsArt(), qty.intValue(), today));
+                            }
+                            inserts.add(insertMvtStockClotureOuverture);
-                            rowValsMvtStockClotureOuverture.getGraph().store(StoreMode.COMMIT, false);
+                            // insertMvtStockClotureOuverture.getGraph().store(StoreMode.COMMIT,
+                            // false);
                             // if (!match.isForeignEmpty("ID_STOCK")) {
                             // match.getForeign("ID_STOCK").createEmptyUpdateRow().put("QTE_REEL",
                             // qty).commit();
                             // } else {
-                            final SQLRowValues createEmptyUpdateRow = match.get1().createEmptyUpdateRow();
+                            // final SQLRowValues createEmptyUpdateRow =
+                            // stockValues.createEmptyUpdateRow();
-                            createEmptyUpdateRow.put("QTE_REEL", qty);
+                            // createEmptyUpdateRow.put("QTE_REEL", qty);
-                            createEmptyUpdateRow.getGraph().store(StoreMode.COMMIT, false);
+                            // createEmptyUpdateRow.getGraph().store(StoreMode.COMMIT, false);
+                            SQLUpdate up = new SQLUpdate(new Where(stockValues.getTable().getKey(), "=", stockValues.getID()));
+                            up.add(stockValues.getTable().getField("QTE_REEL"), qty);
+                            updates.add(up);
                             // }
                         } else {
-                            System.err.println("Aucun article correspondant au code " + code);
+                            System.err.println("\t Aucun article correspondant au code " + code);
+                        }
+                    }
+                }
+            }
+            if (!inserts.isEmpty()) {
+                SQLInsert.executeMultipleWithBatch(table.getDBSystemRoot(), inserts);
+            }
+            if (!updates.isEmpty()) {
+                SQLUpdate.executeMultipleWithBatch(table.getDBSystemRoot(), updates);
+                System.err.println(CollectionUtils.join(updates, ";\n"));
+            }
             /**
              * Mise à jour des kits
              */
+            final List<? extends SQLRowAccessor> rowsDepot;
+            if (multiDepotFile) {
+                rowsDepot = listDepot;
+            } else {
+                rowsDepot = Arrays.asList(defaultDepotRow);
+            }
             List<String> reqs = new ArrayList<String>();
+            // Recalcul des stocks pour chaque kit impacté
-            for (String code : codeKits) {
+            for (String code : this.codeKits) {
                 System.err.println(code);
-                SQLRowValues rowValsKit = kits.get(code);
+                SQLRowValues rowValsKit = this.kits.get(code);
+                // récupération des stocks initialisés pour ce kit
+                final Set<SQLRowValues> referentRowsStock = rowValsKit.getReferentRows(table.getTable("STOCK").getField("ID_ARTICLE"));
+                for (SQLRowAccessor d : referentRowsStock) {
-                StockItem item = new StockItem(rowValsKit, ProductComponent.findOrCreateStock(rowValsKit, depot));
+                    StockItem item = new StockItem(rowValsKit, d);
-                Collection<SQLRowValues> elts = rowValsKit.getReferentRows(tableArtElt.getField("ID_ARTICLE_PARENT"));
+                    Collection<SQLRowValues> elts = rowValsKit.getReferentRows(tableArtElt.getField("ID_ARTICLE_PARENT"));
+                    // Recalcul du stock pour le dépot
-                for (SQLRowValues sqlRowValues : elts) {
+                    for (SQLRowValues sqlRowValues : elts) {
+                        final InventaireProductLine inventaireProductLine = this.kitsChildren.get(sqlRowValues.getID());
-                    if (sqlRowValues.getForeign("ID_ARTICLE") != null) {
+                        if (inventaireProductLine != null && sqlRowValues.getForeign("ID_ARTICLE") != null) {
+                            final SQLRowValues stockArticle = inventaireProductLine.getStockRowValues(d.getForeign("ID_DEPOT_STOCK"));
-                        item.addItemComponent(
+                            if (stockArticle != null)
-                                new StockItemComponent(new StockItem(sqlRowValues.getForeign("ID_ARTICLE"), ProductComponent.findOrCreateStock(sqlRowValues.getForeign("ID_ARTICLE"), depot)),
+                                item.addItemComponent(new StockItemComponent(new StockItem(sqlRowValues.getForeign("ID_ARTICLE"), stockArticle), sqlRowValues.getBigDecimal("QTE_UNITAIRE"),
-                                        sqlRowValues.getBigDecimal("QTE_UNITAIRE"), sqlRowValues.getInt("QTE")));
+                                        sqlRowValues.getInt("QTE")));
+                        }
+                    }
-                item.updateQtyFromChildren();
+                    item.updateQtyFromChildren();
-                reqs.add(item.getUpdateRequest());
+                    reqs.add(item.getUpdateRequest());
+                }
+            }
+            if (!reqs.isEmpty()) {
-            List<? extends ResultSetHandler> handlers = new ArrayList<ResultSetHandler>(reqs.size());
+                List<? extends ResultSetHandler> handlers = new ArrayList<ResultSetHandler>(reqs.size());
-            for (String s : reqs) {
+                for (String s : reqs) {
-                handlers.add(null);
+                    handlers.add(null);
+                }
-            // FIXME FIRE TABLE CHANGED TO UPDATE ILISTE ??
+                // FIXME FIRE TABLE CHANGED TO UPDATE ILISTE ??
-            SQLUtils.executeMultiple(table.getDBSystemRoot(), reqs, handlers);
+                SQLUtils.executeMultiple(table.getDBSystemRoot(), reqs, handlers);
+            }
+            // Recalcul du stock théorique
+            final SQLTable tableStock = root.getTable("STOCK");
+            org.openconcerto.sql.request.UpdateBuilder req = new UpdateBuilder(tableStock);
+            req.set("QTE_TH", SQLBase.quoteIdentifier("QTE_REEL") + "-" + SQLBase.quoteIdentifier("QTE_LIV_ATTENTE") + "+" + SQLBase.quoteIdentifier("QTE_RECEPT_ATTENTE"));
+            table.getDBSystemRoot().getDataSource().execute(req.asString());
             /**
              * Mise à jour des prix mini
              */
             // for (SQLRowValues rowValsArt : rowValsArtNonSync) {
             // SQLRow rowVals = mapLastValidAchatRows.get(qte);
             // checkMinPrice(rowVals, mapLastValidRows.get(qte));
             // }
             // }
+        }
+    }
+    public static SQLInsert getCreateStock(SQLRowAccessor article, SQLRowAccessor depot) {
+        SQLTable stockTable = article.getTable().getTable("STOCK");
+        SQLRowValues putRowValuesStock = new SQLRowValues(stockTable);
+        putRowValuesStock.putNulls(stockTable.getTable().getFieldsName());
+        SQLRowValuesListFetcher fetch = SQLRowValuesListFetcher.create(putRowValuesStock);
+        Where w = new Where(putRowValuesStock.getTable().getField("ID_DEPOT_STOCK"), "=", depot.getID());
+        Where w2 = new Where(putRowValuesStock.getTable().getField("ID_ARTICLE"), "=", article.getID());
+        Collection<SQLRowValues> rowValsResult = fetch.fetch(w.and(w2));
+        if (rowValsResult.size() == 0) {
+            SQLInsert insert = new SQLInsert();
+            insert.add(stockTable.getField("ID_ARTICLE"), article.getID());
+            insert.add(stockTable.getField("ID_DEPOT_STOCK"), depot.getID());
+            insert.add(stockTable.getField("QTE_TH"), 0F);
+            insert.add(stockTable.getField("QTE_REEL"), 0F);
+            insert.add(stockTable.getField("QTE_RECEPT_ATTENTE"), 0F);
+            insert.add(stockTable.getField("QTE_LIV_ATTENTE"), 0F);
+            return insert;
+        }
+        return null;
+    }
+    private SQLRowValues createEtat(SQLTable tableEtat, int depotID) {
+        SQLRowValues rowVals = new SQLRowValues(tableEtat);
+        rowVals.put("DATE", new Date());
+        rowVals.put("INVENTAIRE", Boolean.TRUE);
+        rowVals.put("ID_DEPOT_STOCK", depotID);
+        return rowVals;
+    }
     private void checkMinPrice(SQLRow rowValsSuplierLastValid, SQLRow lastValidRow) {
         boolean update = false;
         final ProductHelper helper = new ProductHelper(rowValsSuplierLastValid.getTable().getDBRoot());
         ProductComponent comp = new ProductComponent(rowVals, new BigDecimal(qty), null, null);
         return comp.getPRC(d);
         // return result;
+    }
-    private final Map<String, Tuple2<SQLRowValues, SQLRowValues>> mapArticle = new HashMap<String, Tuple2<SQLRowValues, SQLRowValues>>();
+    private final Map<String, InventaireProductLine> mapDepotArticle = new HashMap();
-    private final Map<String, Tuple2<SQLRowValues, SQLRowValues>> mapArticleVirtuel = new HashMap<String, Tuple2<SQLRowValues, SQLRowValues>>();
+    private final Map<String, InventaireProductLine> mapDepotArticleVirtuel = new HashMap();
-    private final Map<Tuple3<String, String, String>, Tuple2<SQLRowValues, SQLRowValues>> mapDeclArticle = new HashMap<Tuple3<String, String, String>, Tuple2<SQLRowValues, SQLRowValues>>();
+    private final Map<Tuple3<String, String, String>, InventaireProductLine> mapDepotDeclArticle = new HashMap();
     private void fillArticles() throws SQLException {
         final SQLTable table = Configuration.getInstance().getRoot().findTable("ARTICLE");
         SQLRowValues graph = new SQLRowValues(table);
         graph.put("ID", null);
         graph.put("CODE", null);
         graph.put("NOM", null);
         graph.put("VIRTUEL", null);
         graph.putRowValues("ID_ARTICLE_DECLINAISON_COULEUR").putNulls("ID", "NOM");
         graph.putRowValues("ID_ARTICLE_DECLINAISON_TAILLE").putNulls("ID", "NOM");
         final SQLTable foreignTableStock = table.getForeignTable("ID_STOCK");
         SQLRowValues graphStock = new SQLRowValues(foreignTableStock);
-        graphStock.putNulls("ID_DEPOT_STOCK", "ID", "QTE_REEL", "QTE_TH", "QTE_LIV_ATTENTE", "QTE_RECEPT_ATTENTE");
+        graphStock.putNulls("ID", "QTE_REEL", "QTE_TH", "QTE_LIV_ATTENTE", "QTE_RECEPT_ATTENTE").putRowValues("ID_DEPOT_STOCK").putNulls("NOM");
         graphStock.put("ID_ARTICLE", graph);
         SQLRowValues graphStockArt = new SQLRowValues(foreignTableStock);
-        graphStockArt.putNulls("ID_DEPOT_STOCK", "ID", "QTE_REEL", "QTE_TH", "QTE_LIV_ATTENTE", "QTE_RECEPT_ATTENTE");
+        graphStockArt.putNulls("ID", "QTE_REEL", "QTE_TH", "QTE_LIV_ATTENTE", "QTE_RECEPT_ATTENTE").putRowValues("ID_DEPOT_STOCK").putNulls("NOM");
         graph.put("ID_STOCK", graphStockArt);
         final SQLTable tableArtElt = table.getTable("ARTICLE_ELEMENT");
         SQLRowValues artElt = new SQLRowValues(tableArtElt);
         artElt.put("ID", null);
         Calendar c = Calendar.getInstance();
         // c.set(Calendar.DAY_OF_MONTH, 1);
         c.add(Calendar.MONTH, -2);
         c.set(Calendar.DAY_OF_MONTH, 31);
-        Date dEndYear = c.getTime();
         for (SQLRowValues sqlRowValues : results) {
             final String code = sqlRowValues.getString("CODE");
-            Collection<SQLRowValues> stocks = sqlRowValues.getReferentRows(foreignTableStock);
-            SQLRowValues rowValsStock = null;
-            for (SQLRowValues sqlRowValues2 : stocks) {
-                if (sqlRowValues2.getForeignID("ID_DEPOT_STOCK") == depot.getID()) {
-                    rowValsStock = sqlRowValues2;
-                }
-            }
-            // if (rowValsStock == null) {
-            // rowValsStock = ProductComponent.findOrCreateStock(sqlRowValues, depot).asRowValues();
-            // }
             if (sqlRowValues.getBoolean("VIRTUEL")) {
-                mapArticleVirtuel.put(sqlRowValues.getString("CODE"), Tuple2.create(sqlRowValues, rowValsStock));
+                this.mapDepotArticleVirtuel.put(sqlRowValues.getString("CODE"), new InventaireProductLine(sqlRowValues));
+            }
             final SQLRowAccessor couleur = sqlRowValues.getObject("ID_ARTICLE_DECLINAISON_COULEUR") == null ? null : sqlRowValues.getNonEmptyForeign("ID_ARTICLE_DECLINAISON_COULEUR");
             final SQLRowAccessor taille = sqlRowValues.getObject("ID_ARTICLE_DECLINAISON_TAILLE") == null ? null : sqlRowValues.getNonEmptyForeign("ID_ARTICLE_DECLINAISON_TAILLE");
             if (couleur == null && taille == null) {
-                mapArticle.put(sqlRowValues.getString("CODE"), Tuple2.create(sqlRowValues, rowValsStock));
+                this.mapDepotArticle.put(sqlRowValues.getString("CODE"), new InventaireProductLine(sqlRowValues));
             } else if (couleur == null) {
-                mapDeclArticle.put(Tuple3.create(sqlRowValues.getString("CODE"), null, taille.getString("NOM")), Tuple2.create(sqlRowValues, rowValsStock));
+                this.mapDepotDeclArticle.put(Tuple3.create(sqlRowValues.getString("CODE"), null, taille.getString("NOM")), new InventaireProductLine(sqlRowValues));
             } else if (taille == null) {
-                mapDeclArticle.put(Tuple3.create(sqlRowValues.getString("CODE"), couleur.getString("NOM"), null), Tuple2.create(sqlRowValues, rowValsStock));
+                this.mapDepotDeclArticle.put(Tuple3.create(sqlRowValues.getString("CODE"), couleur.getString("NOM"), null), new InventaireProductLine(sqlRowValues));
             } else {
-                mapDeclArticle.put(Tuple3.create(sqlRowValues.getString("CODE"), couleur.getString("NOM"), taille.getString("NOM")), Tuple2.create(sqlRowValues, rowValsStock));
+                this.mapDepotDeclArticle.put(Tuple3.create(sqlRowValues.getString("CODE"), couleur.getString("NOM"), taille.getString("NOM")), new InventaireProductLine(sqlRowValues));
+            }
             final Set<SQLRowValues> referentRows = sqlRowValues.getReferentRows(tableArtElt.getField("ID_ARTICLE_PARENT"));
             if (referentRows.size() == 0) {
                 // if (!sqlRowValues.isForeignEmpty("ID_STOCK")) {
                 // }
             } else {
                 boolean contains = false;
                 for (SQLRowValues sqlRowValues2 : referentRows) {
                     if (sqlRowValues2.getForeign("ID_ARTICLE") != null && !sqlRowValues2.isForeignEmpty("ID_ARTICLE") && sqlRowValues2.getForeign("ID_ARTICLE").getString("CODE") != null) {
-                        if (codeKits.contains(sqlRowValues2.getForeign("ID_ARTICLE").getString("CODE"))) {
+                        if (this.codeKits.contains(sqlRowValues2.getForeign("ID_ARTICLE").getString("CODE"))) {
                             contains = true;
                             break;
+                        }
+                    }
+                }
                 if (!contains) {
-                    codeKits.add(0, code);
+                    this.codeKits.add(0, code);
                 } else {
-                    codeKits.add(code);
+                    this.codeKits.add(code);
+                }
-                kits.put(code, sqlRowValues);
+                this.kits.put(code, sqlRowValues);
                 // if (sqlRowValues.isForeignEmpty("ID_STOCK")) {
                 // sqlRowValues.putRowValues("ID_STOCK").commit();
                 // }
+            }
+        }
+        fillKitChildren();
+    }
+    private void fillKitChildren() {
+        final SQLTable table = Configuration.getInstance().getRoot().findTable("ARTICLE");
+        SQLRowValues graph = new SQLRowValues(table);
+        graph.put("ID", null);
+        graph.put("CODE", null);
+        graph.put("NOM", null);
+        graph.put("VIRTUEL", null);
+        graph.putRowValues("ID_ARTICLE_DECLINAISON_COULEUR").putNulls("ID", "NOM");
+        graph.putRowValues("ID_ARTICLE_DECLINAISON_TAILLE").putNulls("ID", "NOM");
+        final SQLTable foreignTableStock = table.getForeignTable("ID_STOCK");
+        SQLRowValues graphStock = new SQLRowValues(foreignTableStock);
+        graphStock.putNulls("ID", "QTE_REEL", "QTE_TH", "QTE_LIV_ATTENTE", "QTE_RECEPT_ATTENTE").putRowValues("ID_DEPOT_STOCK").putNulls("NOM");
+        graphStock.put("ID_ARTICLE", graph);
+        final SQLTable tableArtElt = table.getTable("ARTICLE_ELEMENT");
+        SQLRowValues artElt = new SQLRowValues(tableArtElt);
+        artElt.put("ID", null);
+        artElt.put("QTE", null);
+        artElt.put("QTE_UNITAIRE", null);
+        artElt.put("ID_ARTICLE", graph);
+        SQLRowValuesListFetcher fetcher = SQLRowValuesListFetcher.create(artElt);
+        fetcher.appendSelTransf(new ITransformer<SQLSelect, SQLSelect>() {
+            @Override
+            public SQLSelect transformChecked(SQLSelect input) {
+                input.setWhere(Where.inValues(tableArtElt.getField("ID_ARTICLE_PARENT"), SQLRow.getIDs(InventaireFromEtatStockImporter.this.kits.values())));
+                return input;
+            }
+        });
+        List<SQLRowValues> results = fetcher.fetch();
+        for (SQLRowValues sqlRowValues : results) {
+            final SQLRowAccessor foreign = sqlRowValues.getNonEmptyForeign("ID_ARTICLE");
+            if (foreign != null) {
+                this.kitsChildren.put(foreign.getID(), new InventaireProductLine(foreign.asRowValues()));
+            }
+        }
+    }
-    private Tuple2<SQLRowValues, SQLRowValues> findArticle(String code, String couleur, String taille) throws SQLException {
+    private InventaireProductLine findArticle(String code, String couleur, String taille) throws SQLException {
-        if (!mapCouleur.containsKey(couleur)) {
+        if (!this.mapCouleur.containsKey(couleur)) {
-            SQLRowValues rowVals = new SQLRowValues(root.getTable("ARTICLE_DECLINAISON_COULEUR"));
+            SQLRowValues rowVals = new SQLRowValues(this.root.getTable("ARTICLE_DECLINAISON_COULEUR"));
             rowVals.put("NOM", couleur);
-            mapCouleur.put(couleur, rowVals.commit().getID());
+            this.mapCouleur.put(couleur, rowVals.commit().getID());
+        }
-        if (!mapTaille.containsKey(taille)) {
+        if (!this.mapTaille.containsKey(taille)) {
-            SQLRowValues rowVals = new SQLRowValues(root.getTable("ARTICLE_DECLINAISON_TAILLE"));
+            SQLRowValues rowVals = new SQLRowValues(this.root.getTable("ARTICLE_DECLINAISON_TAILLE"));
             rowVals.put("NOM", taille);
-            mapTaille.put(taille, rowVals.commit().getID());
+            this.mapTaille.put(taille, rowVals.commit().getID());
+        }
-        Tuple2<SQLRowValues, SQLRowValues> t;
+        InventaireProductLine t;
         if ((couleur == null || couleur.trim().length() == 0) && (taille == null || taille.trim().length() == 0)) {
-            t = mapArticle.get(code);
+            t = this.mapDepotArticle.get(code);
-            if (t.get1() == null) {
-                t = Tuple2.create(t.get0(), ProductComponent.findOrCreateStock(t.get0(), depot).asRowValues());
-                mapArticle.put(code, t);
-            }
         } else if (couleur == null || couleur.trim().length() == 0) {
-            t = mapDeclArticle.get(Tuple3.create(code, null, taille.trim()));
+            t = this.mapDepotDeclArticle.get(Tuple3.create(code, null, taille.trim()));
+            if (t == null) {
+                t = this.mapDepotDeclArticle.get(Tuple3.create(code, "", taille.trim()));
+            }
             if (t == null) {
-                SQLRowValues artRow = cloneFromArticle(mapArticleVirtuel.get(code).get0(), null, mapTaille.get(taille.trim())).asRowValues();
+                System.err.println("\tCREATE ARTICLE " + code + " taille : " + taille);
-                final SQLRowValues stockRow = ProductComponent.findOrCreateStock(artRow, depot).asRowValues();
+                SQLRowValues rARtVirt = this.mapDepotArticleVirtuel.get(code).getRowValsArt();
-                t = Tuple2.create(artRow, stockRow);
-                mapDeclArticle.put(Tuple3.create(code, null, taille.trim()), t);
+                SQLRowValues artRow = cloneFromArticle(rARtVirt, null, this.mapTaille.get(taille.trim())).asRowValues();
-            } else if (t.get1() == null) {
+                t = new InventaireProductLine(artRow);
-                t = Tuple2.create(t.get0(), ProductComponent.findOrCreateStock(t.get0(), depot).asRowValues());
-                mapDeclArticle.put(Tuple3.create(code, null, taille.trim()), t);
+                this.mapDepotDeclArticle.put(Tuple3.create(code, null, taille.trim()), t);
+            }
         } else if (taille == null || taille.trim().length() == 0) {
-            t = mapDeclArticle.get(Tuple3.create(code, couleur.trim(), null));
+            t = this.mapDepotDeclArticle.get(Tuple3.create(code, couleur.trim(), null));
+            if (t == null) {
+                t = this.mapDepotDeclArticle.get(Tuple3.create(code, couleur.trim(), ""));
+            }
             if (t == null) {
-                SQLRowValues artRow = cloneFromArticle(mapArticleVirtuel.get(code).get0(), mapCouleur.get(couleur.trim()), null).asRowValues();
+                System.err.println("\tCREATE ARTICLE " + code + " couleur : " + couleur);
-                final SQLRowValues stockRow = ProductComponent.findOrCreateStock(artRow, depot).asRowValues();
+                SQLRowValues rARtVirt = this.mapDepotArticleVirtuel.get(code).getRowValsArt();
-                t = Tuple2.create(artRow, stockRow);
-                mapDeclArticle.put(Tuple3.create(code, couleur.trim(), null), t);
+                SQLRowValues artRow = cloneFromArticle(rARtVirt, this.mapCouleur.get(couleur.trim()), null).asRowValues();
-            } else if (t.get1() == null) {
+                t = new InventaireProductLine(artRow);
-                t = Tuple2.create(t.get0(), ProductComponent.findOrCreateStock(t.get0(), depot).asRowValues());
-                mapDeclArticle.put(Tuple3.create(code, couleur.trim(), null), t);
+                this.mapDepotDeclArticle.put(Tuple3.create(code, couleur.trim(), null), t);
+            }
         } else {
-            t = mapDeclArticle.get(Tuple3.create(code, couleur.trim(), taille.trim()));
+            t = this.mapDepotDeclArticle.get(Tuple3.create(code, couleur.trim(), taille.trim()));
             if (t == null) {
-                if (mapArticle.get(code) != null) {
+                if (this.mapDepotArticleVirtuel.get(code) != null) {
-                    SQLRowValues artRow = cloneFromArticle(mapArticleVirtuel.get(code).get0(), mapCouleur.get(couleur.trim()), mapTaille.get(taille.trim())).asRowValues();
+                    System.err.println("\tCREATE ARTICLE " + code + " taille : " + taille + " couleur : " + couleur);
-                    final SQLRowValues stockRow = ProductComponent.findOrCreateStock(artRow, depot).asRowValues();
+                    SQLRowValues rARtVirt = this.mapDepotArticleVirtuel.get(code).getRowValsArt();
+                    SQLRowValues artRow = cloneFromArticle(rARtVirt, this.mapCouleur.get(couleur.trim()), this.mapTaille.get(taille.trim())).asRowValues();
-                    t = Tuple2.create(artRow, stockRow);
+                    t = new InventaireProductLine(artRow);
-                    mapDeclArticle.put(Tuple3.create(code, couleur.trim(), taille.trim()), t);
+                    this.mapDepotDeclArticle.put(Tuple3.create(code, couleur.trim(), taille.trim()), t);
                 }
-            } else if (t.get1() == null) {
-                t = Tuple2.create(t.get0(), ProductComponent.findOrCreateStock(t.get0(), depot).asRowValues());
-                mapDeclArticle.put(Tuple3.create(code, couleur.trim(), taille.trim()), t);
+            }
+        }
         return t;
+    }
     public SQLRow cloneFromArticle(SQLRowAccessor rArt, Integer idCouleur, Integer idTaille) throws SQLException {
         if (rArt == null) {
             return null;
+        }
-        SQLRowValues copy = artElt.createCopy(rArt.getID());
+        SQLRowValues copy = this.artElt.createCopy(rArt.getID());
         copy.put("VIRTUEL", Boolean.FALSE);
         copy.put("ID_ARTICLE_VIRTUEL_PERE", rArt.getID());
         if (idCouleur != null) {
             copy.put("ID_ARTICLE_DECLINAISON_COULEUR", idCouleur);
+        }
+            }
+        }
         return columnName;
+    }
+    class InventaireProductLine {
+        private final SQLRowValues rowValsArt;
+        private final Map<String, SQLRowValues> stockMap = new HashMap<>();
+        public InventaireProductLine(SQLRowValues rowValsArt) {
+            this.rowValsArt = rowValsArt;
+            Collection<SQLRowValues> stocks = this.rowValsArt.getReferentRows(this.rowValsArt.getTable().getTable("STOCK"));
+            for (SQLRowValues rowValsStock : stocks) {
+                this.stockMap.put(rowValsStock.getForeign("ID_DEPOT_STOCK").getString("NOM"), rowValsStock);
+            }
+        }
+        public SQLRowValues getOrCreateStockRowValues(SQLRowAccessor depot) {
+            final String depotName = depot.getString("NOM");
+            if (!this.stockMap.containsKey(depotName)) {
+                this.stockMap.put(depotName, ProductComponent.findOrCreateStock(this.rowValsArt, depot).asRowValues());
+            }
+            return this.stockMap.get(depotName);
+        }
+        public SQLRowValues getStockRowValues(SQLRowAccessor depot) {
+            final String depotName = depot.getString("NOM");
+            if (!this.stockMap.containsKey(depotName)) {
+                return null;
+            }
+            return this.stockMap.get(depotName);
+        }
+        public SQLRowValues getRowValsArt() {
+            return this.rowValsArt;
+        }
+    }
+}

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

svn://code.openconcerto.org/openconcerto

(root)/trunk/OpenConcerto/src/org/openconcerto/erp/core/supplychain/stock/element/InventaireFromEtatStockImporter.java - Rev 182 → 185