OpenConcerto

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

svn://code.openconcerto.org/openconcerto

Rev

Rev 156 | Rev 177 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
18 ilm 1 
/*
2 
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
3 
 *
4 
 * Copyright 2011 OpenConcerto, by ILM Informatique. All rights reserved.
5 
 *
6 
 * The contents of this file are subject to the terms of the GNU General Public License Version 3
7 
 * only ("GPL"). You may not use this file except in compliance with the License. You can obtain a
8 
 * copy of the License at http://www.gnu.org/licenses/gpl-3.0.html See the License for the specific
9 
 * language governing permissions and limitations under the License.
10 
 *
11 
 * When distributing the software, include this License Header Notice in each file.
12 
 */
13 
 
14 
 package org.openconcerto.erp.core.common.ui;
15 
 
16 
import org.openconcerto.erp.config.ComptaPropsConfiguration;
93 ilm 17 
import org.openconcerto.erp.core.finance.accounting.model.CurrencyConverter;
18 ilm 18 
import org.openconcerto.erp.core.finance.tax.model.TaxeCache;
142 ilm 19 
import org.openconcerto.erp.core.sales.pos.io.BarcodeReader;
20 
import org.openconcerto.erp.core.sales.pos.ui.BarcodeListener;
18 ilm 21 
import org.openconcerto.erp.core.sales.product.element.ReferenceArticleSQLElement;
94 ilm 22 
import org.openconcerto.erp.core.sales.product.model.ProductComponent;
132 ilm 23 
import org.openconcerto.erp.core.sales.product.model.ProductHelper;
24 
import org.openconcerto.erp.core.sales.product.model.ProductHelper.TypePrice;
18 ilm 25 
import org.openconcerto.erp.core.sales.product.ui.ArticleRowValuesRenderer;
94 ilm 26 
import org.openconcerto.erp.core.sales.product.ui.CurrencyWithSymbolRenderer;
19 ilm 27 
import org.openconcerto.erp.core.sales.product.ui.QteMultipleRowValuesRenderer;
61 ilm 28 
import org.openconcerto.erp.core.sales.product.ui.QteUnitRowValuesRenderer;
174 ilm 29 
import org.openconcerto.erp.core.supplychain.stock.element.StockSQLElement;
94 ilm 30 
import org.openconcerto.erp.importer.ArrayTableModel;
31 
import org.openconcerto.erp.importer.DataImporter;
18 ilm 32 
import org.openconcerto.erp.preferences.DefaultNXProps;
61 ilm 33 
import org.openconcerto.erp.preferences.GestionArticleGlobalPreferencePanel;
18 ilm 34 
import org.openconcerto.sql.Configuration;
35 
import org.openconcerto.sql.element.SQLElement;
94 ilm 36 
import org.openconcerto.sql.model.FieldPath;
19 ilm 37 
import org.openconcerto.sql.model.SQLField;
38 
import org.openconcerto.sql.model.SQLRow;
39 
import org.openconcerto.sql.model.SQLRowAccessor;
94 ilm 40 
import org.openconcerto.sql.model.SQLRowListRSH;
18 ilm 41 
import org.openconcerto.sql.model.SQLRowValues;
94 ilm 42 
import org.openconcerto.sql.model.SQLSelect;
18 ilm 43 
import org.openconcerto.sql.model.SQLTable;
80 ilm 44 
import org.openconcerto.sql.model.UndefinedRowValuesCache;
18 ilm 45 
import org.openconcerto.sql.model.Where;
94 ilm 46 
import org.openconcerto.sql.model.graph.Path;
61 ilm 47 
import org.openconcerto.sql.preferences.SQLPreferences;
83 ilm 48 
import org.openconcerto.sql.sqlobject.ITextArticleWithCompletionCellEditor;
61 ilm 49 
import org.openconcerto.sql.sqlobject.ITextWithCompletion;
94 ilm 50 
import org.openconcerto.sql.users.rights.UserRights;
142 ilm 51 
import org.openconcerto.sql.users.rights.UserRightsManager;
174 ilm 52 
import org.openconcerto.sql.view.EditFrame;
53 
import org.openconcerto.sql.view.EditPanel.EditMode;
18 ilm 54 
import org.openconcerto.sql.view.list.AutoCompletionManager;
55 
import org.openconcerto.sql.view.list.CellDynamicModifier;
56 
import org.openconcerto.sql.view.list.RowValuesTable;
57 
import org.openconcerto.sql.view.list.RowValuesTableModel;
58 
import org.openconcerto.sql.view.list.SQLTableElement;
93 ilm 59 
import org.openconcerto.sql.view.list.SQLTextComboTableCellEditor;
65 ilm 60 
import org.openconcerto.sql.view.list.ValidStateChecker;
93 ilm 61 
import org.openconcerto.utils.CompareUtils;
90 ilm 62 
import org.openconcerto.utils.DecimalUtils;
94 ilm 63 
import org.openconcerto.utils.StringUtils;
64 
import org.openconcerto.utils.Tuple3;
132 ilm 65 
import org.openconcerto.utils.cc.ITransformer;
93 ilm 66 
import org.openconcerto.utils.i18n.TranslationManager;
18 ilm 67 
 
80 ilm 68 
import java.awt.Component;
94 ilm 69 
import java.awt.datatransfer.DataFlavor;
70 
import java.awt.datatransfer.Transferable;
71 
import java.awt.datatransfer.UnsupportedFlavorException;
72 
import java.awt.dnd.DnDConstants;
73 
import java.awt.dnd.DropTarget;
74 
import java.awt.dnd.DropTargetDropEvent;
93 ilm 75 
import java.awt.event.ActionEvent;
174 ilm 76 
import java.awt.event.ActionListener;
142 ilm 77 
import java.awt.event.HierarchyEvent;
78 
import java.awt.event.HierarchyListener;
79 
import java.awt.event.KeyEvent;
93 ilm 80 
import java.awt.event.MouseAdapter;
81 
import java.awt.event.MouseEvent;
94 ilm 82 
import java.io.File;
83 
import java.io.IOException;
19 ilm 84 
import java.math.BigDecimal;
67 ilm 85 
import java.math.RoundingMode;
18 ilm 86 
import java.util.ArrayList;
19 ilm 87 
import java.util.Collection;
93 ilm 88 
import java.util.Date;
28 ilm 89 
import java.util.HashMap;
18 ilm 90 
import java.util.List;
28 ilm 91 
import java.util.Map;
142 ilm 92 
import java.util.Set;
18 ilm 93 
import java.util.Vector;
94 
 
93 ilm 95 
import javax.swing.AbstractAction;
18 ilm 96 
import javax.swing.JButton;
142 ilm 97 
import javax.swing.JFrame;
80 ilm 98 
import javax.swing.JLabel;
174 ilm 99 
import javax.swing.JMenu;
100 
import javax.swing.JMenuItem;
19 ilm 101 
import javax.swing.JOptionPane;
93 ilm 102 
import javax.swing.JPopupMenu;
80 ilm 103 
import javax.swing.JTable;
104 
import javax.swing.SwingUtilities;
18 ilm 105 
import javax.swing.ToolTipManager;
93 ilm 106 
import javax.swing.event.TableModelEvent;
107 
import javax.swing.event.TableModelListener;
80 ilm 108 
import javax.swing.table.DefaultTableCellRenderer;
18 ilm 109 
import javax.swing.table.TableCellRenderer;
110 
 
111 
public abstract class AbstractVenteArticleItemTable extends AbstractArticleItemTable {
112 
 
21 ilm 113 
    public static final String ARTICLE_SHOW_DEVISE = "ArticleShowDevise";
28 ilm 114 
    public static final String ARTICLE_SERVICE = "ArticleService";
19 ilm 115 
 
94 ilm 116 
    public static final String EDIT_PRIX_VENTE_CODE = "CORPS_EDITER_PRIX_VENTE";
117 
    public static final String SHOW_PRIX_ACHAT_CODE = "CORPS_VOIR_PRIX_ACHAT";
156 ilm 118 
    public static final String SHOW_PRIX_VENTE_CODE = "CORPS_VOIR_PRIX_VENTE";
94 ilm 119 
    public static final String LOCK_PRIX_MIN_VENTE_CODE = "CORPS_VERROU_PRIX_MIN_VENTE";
120 
 
18 ilm 121 
    public AbstractVenteArticleItemTable() {
122 
        super();
123 
    }
124 
 
125 
    public AbstractVenteArticleItemTable(List<JButton> buttons) {
126 
        super(buttons);
127 
    }
128 
 
132 ilm 129 
    protected boolean isCellNiveauEditable(SQLRowValues vals, int rowIndex, int columnIndex) {
93 ilm 130 
        RowValuesTableModel model = getModel();
83 ilm 131 
        int niveau = vals.getInt("NIVEAU");
132 ilm 132 
        return rowIndex + 1 == model.getRowCount() || niveau >= model.getRowValuesAt(rowIndex + 1).getInt("NIVEAU");
83 ilm 133 
    }
134 
 
80 ilm 135 
    SQLTableElement tableElementFacturable;
94 ilm 136 
    protected SQLTableElement tableElementRemise;
80 ilm 137 
 
83 ilm 138 
    public enum TypeCalcul {
139 
        CALCUL_FACTURABLE("MONTANT_FACTURABLE", "POURCENT_FACTURABLE"), CALCUL_REMISE("MONTANT_REMISE", "POURCENT_REMISE");
140 
 
141 
        String fieldMontant, fieldPourcent;
142 
 
143 
        TypeCalcul(String fieldMontant, String fieldPourcent) {
144 
            this.fieldMontant = fieldMontant;
145 
            this.fieldPourcent = fieldPourcent;
146 
        }
147 
 
148 
        public String getFieldMontant() {
149 
            return fieldMontant;
150 
        }
151 
 
152 
        public String getFieldPourcent() {
153 
            return fieldPourcent;
154 
        }
155 
    };
156 
 
157 
    public void calculPourcentage(final Acompte a, final TypeCalcul type) {
80 ilm 158 
        Runnable r = new Runnable() {
159 
 
160 
            @Override
161 
            public void run() {
162 
                SwingUtilities.invokeLater(new Runnable() {
163 
 
164 
                    @Override
165 
                    public void run() {
83 ilm 166 
                        SQLTableElement tableElement = (type == TypeCalcul.CALCUL_FACTURABLE ? tableElementFacturable : tableElementRemise);
93 ilm 167 
                        RowValuesTableModel model = getModel();
80 ilm 168 
                        if (a == null) {
169 
                            for (int i = 0; i < model.getRowCount(); i++) {
83 ilm 170 
                                model.putValue(null, i, type.getFieldMontant());
171 
                                model.putValue(null, i, type.getFieldPourcent());
172 
                                tableElement.fireModification(model.getRowValuesAt(i));
80 ilm 173 
                            }
174 
                        } else if (a.getPercent() != null) {
175 
                            for (int i = 0; i < model.getRowCount(); i++) {
83 ilm 176 
                                model.putValue(a.getPercent(), i, type.getFieldPourcent());
177 
                                model.putValue(null, i, type.getFieldMontant());
178 
                                tableElement.fireModification(model.getRowValuesAt(i));
80 ilm 179 
                            }
180 
                        } else {
181 
                            // FIXME repartition du montant sur chaque ligne
182 
                            BigDecimal totalHT = BigDecimal.ZERO;
83 ilm 183 
                            for (SQLRowValues rowVals : getRowValuesAtLevel(1)) {
80 ilm 184 
                                int qte = rowVals.getInt("QTE");
185 
                                BigDecimal qteU = rowVals.getBigDecimal("QTE_UNITAIRE");
186 
                                BigDecimal pU = rowVals.getBigDecimal("PV_HT");
187 
 
90 ilm 188 
                                BigDecimal totalLine = pU.multiply(qteU, DecimalUtils.HIGH_PRECISION).multiply(new BigDecimal(qte), DecimalUtils.HIGH_PRECISION).setScale(2, RoundingMode.HALF_UP);
80 ilm 189 
 
83 ilm 190 
                                // BigDecimal lremise = (type == TypeCalcul.CALCUL_FACTURABLE ?
191 
                                // rowVals.getBigDecimal("POURCENT_REMISE") : BigDecimal.ZERO);
192 
                                //
193 
                                // if (lremise.compareTo(BigDecimal.ZERO) > 0 &&
194 
                                // lremise.compareTo(BigDecimal.valueOf(100)) < 100) {
195 
                                // totalLine =
196 
                                // totalLine.multiply(BigDecimal.valueOf(100).subtract(lremise),
90 ilm 197 
                                // DecimalUtils.HIGH_PRECISION).movePointLeft(2);
83 ilm 198 
                                // }
199 
                                if (type == TypeCalcul.CALCUL_FACTURABLE) {
200 
                                    if (rowVals.getTable().getFieldsName().contains("MONTANT_REMISE")) {
201 
                                        final BigDecimal acomptePercent = rowVals.getBigDecimal("POURCENT_REMISE");
202 
                                        final BigDecimal acompteMontant = rowVals.getBigDecimal("MONTANT_REMISE");
203 
                                        Remise remise = new Remise(acomptePercent, acompteMontant);
204 
                                        totalLine = remise.getResultFrom(totalLine);
205 
                                    }
80 ilm 206 
                                }
207 
                                totalHT = totalHT.add(totalLine);
208 
                            }
209 
 
142 ilm 210 
                            // BigDecimal percent = (totalHT.signum() != 0 ?
211 
                            // a.getMontant().divide(totalHT, DecimalUtils.HIGH_PRECISION) :
212 
                            // BigDecimal.ZERO);
213 
 
80 ilm 214 
                            for (int i = 0; i < model.getRowCount(); i++) {
83 ilm 215 
                                // Restrict to level 1
216 
                                if (model.getRowValuesAt(i).getInt("NIVEAU") != 1) {
217 
                                    continue;
218 
                                }
219 
                                model.putValue(null, i, type.getFieldPourcent());
80 ilm 220 
                                SQLRowValues rowVals = model.getRowValuesAt(i);
221 
                                int qte = rowVals.getInt("QTE");
222 
                                BigDecimal qteU = rowVals.getBigDecimal("QTE_UNITAIRE");
223 
                                BigDecimal pU = rowVals.getBigDecimal("PV_HT");
224 
 
90 ilm 225 
                                BigDecimal totalLine = pU.multiply(qteU, DecimalUtils.HIGH_PRECISION).multiply(new BigDecimal(qte), DecimalUtils.HIGH_PRECISION).setScale(2, RoundingMode.HALF_UP);
80 ilm 226 
 
83 ilm 227 
                                // BigDecimal lremise = (type == TypeCalcul.CALCUL_FACTURABLE ?
228 
                                // rowVals.getBigDecimal("POURCENT_REMISE") : BigDecimal.ZERO);
229 
                                //
230 
                                // if (lremise.compareTo(BigDecimal.ZERO) > 0 &&
231 
                                // lremise.compareTo(BigDecimal.valueOf(100)) < 100) {
232 
                                // totalLine =
233 
                                // totalLine.multiply(BigDecimal.valueOf(100).subtract(lremise),
90 ilm 234 
                                // DecimalUtils.HIGH_PRECISION).movePointLeft(2);
83 ilm 235 
                                // }
236 
                                if (rowVals.getTable().getFieldsName().contains("MONTANT_REMISE")) {
237 
                                    final BigDecimal acomptePercent = rowVals.getBigDecimal("POURCENT_REMISE");
238 
                                    final BigDecimal acompteMontant = rowVals.getBigDecimal("MONTANT_REMISE");
239 
                                    Remise remise = new Remise(acomptePercent, acompteMontant);
240 
                                    totalLine = remise.getResultFrom(totalLine);
80 ilm 241 
                                }
242 
 
90 ilm 243 
                                BigDecimal percent = (totalHT.signum() != 0 ? totalLine.divide(totalHT, DecimalUtils.HIGH_PRECISION) : BigDecimal.ZERO);
80 ilm 244 
 
90 ilm 245 
                                model.putValue(a.getMontant().multiply(percent, DecimalUtils.HIGH_PRECISION).setScale(6, RoundingMode.HALF_UP), i, type.getFieldMontant());
83 ilm 246 
                                tableElement.fireModification(model.getRowValuesAt(i));
80 ilm 247 
                            }
248 
                        }
249 
                        model.fireTableDataChanged();
250 
                    }
251 
                });
252 
            }
253 
        };
93 ilm 254 
        getModel().submit(r);
80 ilm 255 
 
256 
    }
257 
 
28 ilm 258 
    private static Map<String, Boolean> visibilityMap = new HashMap<String, Boolean>();
259 
 
260 
    public static Map<String, Boolean> getVisibilityMap() {
261 
        return visibilityMap;
262 
    }
263 
 
19 ilm 264 
    private SQLTable tableArticleTarif = Configuration.getInstance().getBase().getTable("ARTICLE_TARIF");
61 ilm 265 
    private SQLTable tableArticle = Configuration.getInstance().getBase().getTable("ARTICLE");
19 ilm 266 
 
18 ilm 267 
    protected void init() {
268 
 
67 ilm 269 
        SQLPreferences prefs = SQLPreferences.getMemCached(getSQLElement().getTable().getDBRoot());
61 ilm 270 
        final boolean selectArticle = prefs.getBoolean(GestionArticleGlobalPreferencePanel.USE_CREATED_ARTICLE, false);
93 ilm 271 
        final boolean filterFamilleArticle = prefs.getBoolean(GestionArticleGlobalPreferencePanel.FILTER_BY_FAMILY, false);
61 ilm 272 
        final boolean createAuto = prefs.getBoolean(GestionArticleGlobalPreferencePanel.CREATE_ARTICLE_AUTO, true);
142 ilm 273 
        final boolean showEco = prefs.getBoolean(AbstractVenteArticleItemTable.SHOW_ECO_CONTRIBUTION_COLUMNS, false);
156 ilm 274 
        final boolean showDevise = prefs.getBoolean(AbstractVenteArticleItemTable.ARTICLE_SHOW_DEVISE, false);
61 ilm 275 
 
142 ilm 276 
        final UserRights rights = UserRightsManager.getCurrentUserRights();
94 ilm 277 
        final boolean editVTPrice = rights.haveRight(EDIT_PRIX_VENTE_CODE);
278 
        final boolean showHAPrice = rights.haveRight(SHOW_PRIX_ACHAT_CODE);
279 
        final boolean lockVTMinPrice = rights.haveRight(LOCK_PRIX_MIN_VENTE_CODE);
280 
 
18 ilm 281 
        final SQLElement e = getSQLElement();
282 
 
283 
        final List<SQLTableElement> list = new Vector<SQLTableElement>();
83 ilm 284 
        final SQLTableElement eNiveau = new SQLTableElement(e.getTable().getField("NIVEAU")) {
285 
            @Override
286 
            public void setValueFrom(SQLRowValues row, Object value) {
287 
                super.setValueFrom(row, value);
288 
            }
289 
        };
290 
        eNiveau.setRenderer(new NiveauTableCellRender());
291 
        eNiveau.setEditor(new NiveauTableCellEditor());
292 
        list.add(eNiveau);
293 
 
18 ilm 294 
        list.add(new SQLTableElement(e.getTable().getField("ID_STYLE")));
28 ilm 295 
 
174 ilm 296 
        if (e.getTable().contains("ID_COMPTE_PCE")) {
297 
            list.add(new SQLTableElement(e.getTable().getField("ID_COMPTE_PCE")));
298 
        }
299 
 
93 ilm 300 
        final SQLTableElement tableFamille = new SQLTableElement(e.getTable().getField("ID_FAMILLE_ARTICLE"));
301 
        list.add(tableFamille);
302 
 
61 ilm 303 
        // Article
156 ilm 304 
        SQLTableElement tableElementDepot = new SQLTableElement(e.getTable().getField("ID_DEPOT_STOCK"), true, true, true);
305 
        list.add(tableElementDepot);
306 
 
307 
        // Article
67 ilm 308 
        SQLTableElement tableElementArticle = new SQLTableElement(e.getTable().getField("ID_ARTICLE"), true, true, true);
61 ilm 309 
        list.add(tableElementArticle);
28 ilm 310 
 
142 ilm 311 
        if (e.getTable().getFieldsName().contains("ID_ECO_CONTRIBUTION")) {
312 
            this.tableElementEcoID = new SQLTableElement(e.getTable().getField("ID_ECO_CONTRIBUTION"));
313 
            list.add(this.tableElementEcoID);
314 
        }
315 
 
28 ilm 316 
        // Code article
94 ilm 317 
        final SQLTableElement tableElementCode = new SQLTableElement(e.getTable().getField("CODE"), String.class,
318 
                new ITextArticleWithCompletionCellEditor(e.getTable().getTable("ARTICLE"), e.getTable().getTable("ARTICLE_FOURNISSEUR")));
18 ilm 319 
        list.add(tableElementCode);
83 ilm 320 
 
18 ilm 321 
        // Désignation de l'article
322 
        final SQLTableElement tableElementNom = new SQLTableElement(e.getTable().getField("NOM"));
323 
        list.add(tableElementNom);
324 
 
41 ilm 325 
        if (e.getTable().getFieldsName().contains("COLORIS")) {
326 
            final SQLTableElement tableElementColoris = new SQLTableElement(e.getTable().getField("COLORIS"));
327 
            list.add(tableElementColoris);
328 
        }
329 
 
21 ilm 330 
        if (e.getTable().getFieldsName().contains("DESCRIPTIF")) {
331 
            final SQLTableElement tableElementDesc = new SQLTableElement(e.getTable().getField("DESCRIPTIF"));
332 
            list.add(tableElementDesc);
333 
        }
334 
 
149 ilm 335 
        if (e.getTable().getFieldsName().contains("DELAI")) {
336 
            final SQLTableElement tableElementDelai = new SQLTableElement(e.getTable().getField("DELAI"));
337 
            list.add(tableElementDelai);
338 
        }
339 
 
156 ilm 340 
        if (showDevise) {
19 ilm 341 
            // Code Douanier
342 
            final SQLTableElement tableElementCodeDouane = new SQLTableElement(e.getTable().getField("CODE_DOUANIER"));
343 
            list.add(tableElementCodeDouane);
344 
            final SQLTableElement tableElementPays = new SQLTableElement(e.getTable().getField("ID_PAYS"));
345 
            list.add(tableElementPays);
346 
        }
347 
 
18 ilm 348 
        // Valeur des métriques
349 
        final SQLTableElement tableElement_ValeurMetrique2 = new SQLTableElement(e.getTable().getField("VALEUR_METRIQUE_2"), Float.class) {
350 
            @Override
132 ilm 351 
            public boolean isCellEditable(SQLRowValues vals, int rowIndex, int columnIndex) {
18 ilm 352 
                Number modeNumber = (Number) vals.getObject("ID_MODE_VENTE_ARTICLE");
353 
                // int mode = vals.getInt("ID_MODE_VENTE_ARTICLE");
94 ilm 354 
                if (modeNumber != null && (modeNumber.intValue() == ReferenceArticleSQLElement.A_LA_PIECE || modeNumber.intValue() == ReferenceArticleSQLElement.AU_POID_METRECARRE
355 
                        || modeNumber.intValue() == ReferenceArticleSQLElement.AU_METRE_LONGUEUR)) {
18 ilm 356 
                    return false;
357 
                } else {
132 ilm 358 
                    return super.isCellEditable(vals, rowIndex, columnIndex);
18 ilm 359 
                }
360 
            }
361 
 
362 
            @Override
363 
            public TableCellRenderer getTableCellRenderer() {
364 
 
365 
                return new ArticleRowValuesRenderer(null);
366 
            }
367 
        };
368 
        list.add(tableElement_ValeurMetrique2);
369 
        final SQLTableElement tableElement_ValeurMetrique3 = new SQLTableElement(e.getTable().getField("VALEUR_METRIQUE_3"), Float.class) {
370 
            @Override
132 ilm 371 
            public boolean isCellEditable(SQLRowValues vals, int rowIndex, int columnIndex) {
18 ilm 372 
 
373 
                Number modeNumber = (Number) vals.getObject("ID_MODE_VENTE_ARTICLE");
374 
                if (modeNumber != null && (!(modeNumber.intValue() == ReferenceArticleSQLElement.AU_POID_METRECARRE))) {
375 
                    return false;
376 
                } else {
132 ilm 377 
                    return super.isCellEditable(vals, rowIndex, columnIndex);
18 ilm 378 
                }
379 
            }
380 
 
381 
            @Override
382 
            public TableCellRenderer getTableCellRenderer() {
383 
 
384 
                return new ArticleRowValuesRenderer(null);
385 
            }
386 
        };
387 
        list.add(tableElement_ValeurMetrique3);
388 
        final SQLTableElement tableElement_ValeurMetrique1 = new SQLTableElement(e.getTable().getField("VALEUR_METRIQUE_1"), Float.class) {
389 
            @Override
132 ilm 390 
            public boolean isCellEditable(SQLRowValues vals, int rowIndex, int columnIndex) {
18 ilm 391 
 
392 
                Number modeNumber = (Number) vals.getObject("ID_MODE_VENTE_ARTICLE");
94 ilm 393 
                if (modeNumber != null && (modeNumber.intValue() == ReferenceArticleSQLElement.A_LA_PIECE || modeNumber.intValue() == ReferenceArticleSQLElement.AU_POID_METRECARRE
394 
                        || modeNumber.intValue() == ReferenceArticleSQLElement.AU_METRE_LARGEUR)) {
18 ilm 395 
                    return false;
396 
                } else {
132 ilm 397 
                    return super.isCellEditable(vals, rowIndex, columnIndex);
18 ilm 398 
                }
399 
            }
400 
 
401 
            @Override
402 
            public TableCellRenderer getTableCellRenderer() {
403 
 
404 
                return new ArticleRowValuesRenderer(null);
405 
            }
406 
        };
407 
        list.add(tableElement_ValeurMetrique1);
408 
 
41 ilm 409 
        // Prébilan
61 ilm 410 
 
41 ilm 411 
        if (e.getTable().getFieldsName().contains("PREBILAN")) {
90 ilm 412 
            prebilan = new SQLTableElement(e.getTable().getField("PREBILAN"), BigDecimal.class) {
413 
                protected Object getDefaultNullValue() {
414 
                    return BigDecimal.ZERO;
415 
                }
416 
 
417 
                @Override
132 ilm 418 
                public boolean isCellEditable(SQLRowValues vals, int rowIndex, int columnIndex) {
419 
                    return isCellNiveauEditable(vals, rowIndex, columnIndex);
90 ilm 420 
                }
421 
 
422 
            };
423 
            prebilan.setRenderer(new DeviseTableCellRenderer());
41 ilm 424 
            list.add(prebilan);
425 
        }
426 
 
18 ilm 427 
        // Prix d'achat HT de la métrique 1
73 ilm 428 
        final SQLTableElement tableElement_PrixMetrique1_AchatHT = new SQLTableElement(e.getTable().getField("PRIX_METRIQUE_HA_1"), BigDecimal.class) {
429 
            protected Object getDefaultNullValue() {
430 
                return BigDecimal.ZERO;
431 
            }
83 ilm 432 
 
433 
            @Override
132 ilm 434 
            public boolean isCellEditable(SQLRowValues vals, int rowIndex, int columnIndex) {
435 
                return isCellNiveauEditable(vals, rowIndex, columnIndex);
83 ilm 436 
            }
437 
 
73 ilm 438 
        };
94 ilm 439 
        tableElement_PrixMetrique1_AchatHT.setRenderer(new CurrencyWithSymbolRenderer());
18 ilm 440 
        list.add(tableElement_PrixMetrique1_AchatHT);
441 
 
19 ilm 442 
        SQLTableElement eltDevise = null;
443 
        SQLTableElement eltUnitDevise = null;
156 ilm 444 
        if (showDevise) {
19 ilm 445 
            // Devise
446 
            eltDevise = new SQLTableElement(e.getTable().getField("ID_DEVISE"));
447 
            list.add(eltDevise);
448 
 
449 
            // Prix vente devise
83 ilm 450 
            eltUnitDevise = new SQLTableElement(e.getTable().getField("PV_U_DEVISE"), BigDecimal.class) {
451 
                @Override
132 ilm 452 
                public boolean isCellEditable(SQLRowValues vals, int rowIndex, int columnIndex) {
453 
                    return editVTPrice && isCellNiveauEditable(vals, rowIndex, columnIndex);
83 ilm 454 
                }
132 ilm 455 
 
456 
                protected Object getDefaultNullValue() {
457 
                    return BigDecimal.ZERO;
458 
                }
459 
 
83 ilm 460 
            };
94 ilm 461 
            Path p = new Path(getSQLElement().getTable()).addForeignField("ID_DEVISE");
462 
            eltUnitDevise.setRenderer(new CurrencyWithSymbolRenderer(new FieldPath(p, "CODE")));
19 ilm 463 
            list.add(eltUnitDevise);
464 
        }
18 ilm 465 
        // Prix de vente HT de la métrique 1
73 ilm 466 
 
67 ilm 467 
        SQLField field = e.getTable().getField("PRIX_METRIQUE_VT_1");
73 ilm 468 
        final DeviseNumericHTConvertorCellEditor editorPVHT = new DeviseNumericHTConvertorCellEditor(field);
18 ilm 469 
 
83 ilm 470 
        final SQLTableElement tableElement_PrixMetrique1_VenteHT = new SQLTableElement(field, BigDecimal.class, editorPVHT) {
471 
            @Override
132 ilm 472 
            public boolean isCellEditable(SQLRowValues vals, int rowIndex, int columnIndex) {
473 
                return editVTPrice && isCellNiveauEditable(vals, rowIndex, columnIndex);
83 ilm 474 
            }
475 
        };
94 ilm 476 
        tableElement_PrixMetrique1_VenteHT.setRenderer(new CurrencyWithSymbolRenderer());
18 ilm 477 
        list.add(tableElement_PrixMetrique1_VenteHT);
19 ilm 478 
 
142 ilm 479 
        if (e.getTable().getFieldsName().contains("ECO_CONTRIBUTION")) {
480 
            this.tableElementEco = new SQLTableElement(e.getTable().getField("ECO_CONTRIBUTION"));
481 
            list.add(this.tableElementEco);
482 
        }
483 
 
18 ilm 484 
        // // Prix d'achat HT de la métrique 1
61 ilm 485 
 
486 
        SQLTableElement qteU = new SQLTableElement(e.getTable().getField("QTE_UNITAIRE"), BigDecimal.class) {
487 
            @Override
132 ilm 488 
            public boolean isCellEditable(SQLRowValues vals, int rowIndex, int columnIndex) {
61 ilm 489 
 
490 
                SQLRowAccessor row = vals.getForeign("ID_UNITE_VENTE");
491 
                if (row != null && !row.isUndefined() && row.getBoolean("A_LA_PIECE")) {
492 
                    return false;
493 
                } else {
132 ilm 494 
                    return super.isCellEditable(vals, rowIndex, columnIndex);
61 ilm 495 
                }
496 
            }
497 
 
498 
            @Override
499 
            public TableCellRenderer getTableCellRenderer() {
500 
                return new QteUnitRowValuesRenderer();
501 
            }
67 ilm 502 
 
503 
            protected Object getDefaultNullValue() {
504 
                return BigDecimal.ZERO;
505 
            }
61 ilm 506 
        };
507 
        list.add(qteU);
508 
 
509 
        SQLTableElement uniteVente = new SQLTableElement(e.getTable().getField("ID_UNITE_VENTE"));
510 
        list.add(uniteVente);
511 
 
18 ilm 512 
        // Quantité
21 ilm 513 
        this.qte = new SQLTableElement(e.getTable().getField("QTE"), Integer.class, new QteCellEditor()) {
19 ilm 514 
            protected Object getDefaultNullValue() {
515 
                return Integer.valueOf(0);
516 
            }
517 
 
518 
            public TableCellRenderer getTableCellRenderer() {
519 
                if (getSQLElement().getTable().getFieldsName().contains("QTE_ACHAT")) {
520 
                    return new QteMultipleRowValuesRenderer();
521 
                } else {
522 
                    return super.getTableCellRenderer();
523 
                }
524 
            }
525 
        };
18 ilm 526 
        this.qte.setPreferredSize(20);
527 
        list.add(this.qte);
528 
 
132 ilm 529 
        if (e.getTable().contains("RETOUR_STOCK")) {
530 
            list.add(new SQLTableElement(e.getTable().getField("RETOUR_STOCK")));
531 
        }
532 
 
18 ilm 533 
        // Mode de vente
534 
        final SQLTableElement tableElement_ModeVente = new SQLTableElement(e.getTable().getField("ID_MODE_VENTE_ARTICLE"));
535 
        list.add(tableElement_ModeVente);
536 
 
537 
        // // Prix d'achat unitaire HT
73 ilm 538 
 
539 
        final SQLField prixAchatHTField = e.getTable().getField("PA_HT");
540 
        final DeviseNumericCellEditor editorPAchatHT = new DeviseNumericCellEditor(prixAchatHTField);
541 
        this.ha = new SQLTableElement(e.getTable().getField("PA_HT"), BigDecimal.class, editorPAchatHT) {
542 
            protected Object getDefaultNullValue() {
543 
                return BigDecimal.ZERO;
544 
            }
83 ilm 545 
 
546 
            @Override
132 ilm 547 
            public boolean isCellEditable(SQLRowValues vals, int rowIndex, int columnIndex) {
548 
                return isCellNiveauEditable(vals, rowIndex, columnIndex);
83 ilm 549 
            }
73 ilm 550 
        };
83 ilm 551 
        this.ha = new SQLTableElement(prixAchatHTField, BigDecimal.class, editorPAchatHT) {
552 
            @Override
132 ilm 553 
            public boolean isCellEditable(SQLRowValues vals, int rowIndex, int columnIndex) {
554 
                return isCellNiveauEditable(vals, rowIndex, columnIndex);
83 ilm 555 
            }
556 
        };
94 ilm 557 
        this.ha.setRenderer(new CurrencyWithSymbolRenderer());
73 ilm 558 
 
18 ilm 559 
        list.add(this.ha);
560 
 
561 
        // Prix de vente unitaire HT
73 ilm 562 
        final SQLField prixVenteHTField = e.getTable().getField("PV_HT");
563 
        final DeviseNumericCellEditor editorPVenteHT = new DeviseNumericCellEditor(prixAchatHTField);
83 ilm 564 
        final SQLTableElement tableElement_PrixVente_HT = new SQLTableElement(prixVenteHTField, BigDecimal.class, editorPVenteHT) {
565 
            @Override
132 ilm 566 
            public boolean isCellEditable(SQLRowValues vals, int rowIndex, int columnIndex) {
567 
                return editVTPrice && isCellNiveauEditable(vals, rowIndex, columnIndex);
83 ilm 568 
            }
569 
        };
94 ilm 570 
        tableElement_PrixVente_HT.setRenderer(new CurrencyWithSymbolRenderer());
18 ilm 571 
        list.add(tableElement_PrixVente_HT);
572 
 
573 
        // TVA
61 ilm 574 
        this.tableElementTVA = new SQLTableElement(e.getTable().getField("ID_TAXE"));
575 
        this.tableElementTVA.setPreferredSize(20);
576 
        list.add(this.tableElementTVA);
18 ilm 577 
        // Poids piece
80 ilm 578 
        SQLTableElement tableElementPoids = new SQLTableElement(e.getTable().getField("POIDS"), Float.class) {
579 
            protected Object getDefaultNullValue() {
580 
                return 0F;
581 
            }
582 
 
583 
            @Override
584 
            public TableCellRenderer getTableCellRenderer() {
585 
                return new QteUnitRowValuesRenderer();
586 
            }
587 
 
588 
        };
18 ilm 589 
        tableElementPoids.setPreferredSize(20);
590 
        list.add(tableElementPoids);
591 
 
592 
        // Poids total
80 ilm 593 
        this.tableElementPoidsTotal = new SQLTableElement(e.getTable().getField("T_POIDS"), Float.class) {
594 
            @Override
595 
            public TableCellRenderer getTableCellRenderer() {
596 
                return new QteUnitRowValuesRenderer();
597 
            }
598 
        };
599 
        this.tableElementPoidsTotal.setEditable(false);
18 ilm 600 
        list.add(this.tableElementPoidsTotal);
601 
 
80 ilm 602 
        // Packaging
603 
        if (prefs.getBoolean(GestionArticleGlobalPreferencePanel.ITEM_PACKAGING, false)) {
604 
 
605 
            SQLTableElement poidsColis = new SQLTableElement(e.getTable().getField("POIDS_COLIS_NET"), BigDecimal.class) {
606 
                @Override
607 
                public TableCellRenderer getTableCellRenderer() {
608 
                    return new QteUnitRowValuesRenderer();
609 
                }
610 
 
611 
            };
612 
            list.add(poidsColis);
613 
 
614 
            SQLTableElement nbColis = new SQLTableElement(e.getTable().getField("NB_COLIS"), Integer.class);
615 
            list.add(nbColis);
616 
 
617 
            final SQLTableElement totalPoidsColis = new SQLTableElement(e.getTable().getField("T_POIDS_COLIS_NET"), BigDecimal.class) {
618 
                @Override
619 
                public TableCellRenderer getTableCellRenderer() {
620 
                    return new QteUnitRowValuesRenderer();
621 
                }
622 
 
623 
            };
624 
            list.add(totalPoidsColis);
625 
 
626 
            poidsColis.addModificationListener(totalPoidsColis);
627 
            nbColis.addModificationListener(totalPoidsColis);
628 
            totalPoidsColis.setModifier(new CellDynamicModifier() {
93 ilm 629 
                public Object computeValueFrom(final SQLRowValues row, SQLTableElement source) {
80 ilm 630 
                    final Object o2 = row.getObject("POIDS_COLIS_NET");
631 
                    final Object o3 = row.getObject("NB_COLIS");
632 
                    if (o2 != null && o3 != null) {
633 
                        BigDecimal poids = (BigDecimal) o2;
634 
                        int nb = (Integer) o3;
90 ilm 635 
                        return poids.multiply(new BigDecimal(nb), DecimalUtils.HIGH_PRECISION).setScale(totalPoidsColis.getDecimalDigits(), RoundingMode.HALF_UP);
80 ilm 636 
                    } else {
637 
                        return row.getObject("T_POIDS_COLIS_NET");
638 
                    }
639 
                }
640 
            });
641 
 
642 
        }
643 
 
18 ilm 644 
        // Service
19 ilm 645 
        if (DefaultNXProps.getInstance().getBooleanValue(ARTICLE_SERVICE, false)) {
18 ilm 646 
            this.service = new SQLTableElement(e.getTable().getField("SERVICE"), Boolean.class);
647 
            list.add(this.service);
648 
        }
649 
 
83 ilm 650 
        this.totalHT = new SQLTableElement(e.getTable().getField("T_PV_HT"), BigDecimal.class) {
651 
            @Override
132 ilm 652 
            public boolean isCellEditable(SQLRowValues vals, int rowIndex, int columnIndex) {
653 
                return isCellNiveauEditable(vals, rowIndex, columnIndex);
83 ilm 654 
            }
655 
        };
174 ilm 656 
        CurrencyWithSymbolRenderer totalRenderer = new CurrencyWithSymbolRenderer();
657 
        totalRenderer.setHideZeroValue(true);
658 
        this.totalHT.setRenderer(totalRenderer);
61 ilm 659 
        this.totalHT.setEditable(false);
80 ilm 660 
        if (e.getTable().getFieldsName().contains("MONTANT_FACTURABLE")) {
661 
            // SQLTableElement tableElementAcompte = new
662 
            // SQLTableElement(e.getTable().getField("POURCENT_ACOMPTE"));
663 
            // list.add(tableElementAcompte);
664 
 
665 
            this.tableElementFacturable = new SQLTableElement(e.getTable().getField("POURCENT_FACTURABLE"), Acompte.class, new AcompteCellEditor("POURCENT_FACTURABLE", "MONTANT_FACTURABLE")) {
666 
                @Override
667 
                public void setValueFrom(SQLRowValues row, Object value) {
668 
 
669 
                    if (value != null) {
670 
                        Acompte a = (Acompte) value;
671 
                        row.put("MONTANT_FACTURABLE", a.getMontant());
672 
                        row.put("POURCENT_FACTURABLE", a.getPercent());
673 
                    } else {
674 
                        row.put("MONTANT_FACTURABLE", null);
675 
                        row.put("POURCENT_FACTURABLE", BigDecimal.ONE.movePointRight(2));
676 
                    }
677 
                    fireModification(row);
678 
                }
679 
            };
680 
            tableElementFacturable.setRenderer(new DefaultTableCellRenderer() {
681 
                @Override
682 
                public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
683 
                    SQLRowValues rowVals = ((RowValuesTable) table).getRowValuesTableModel().getRowValuesAt(row);
684 
                    JLabel label = (JLabel) super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
685 
                    BigDecimal percent = rowVals.getBigDecimal("POURCENT_FACTURABLE");
686 
                    BigDecimal amount = rowVals.getBigDecimal("MONTANT_FACTURABLE");
687 
                    Acompte a = new Acompte(percent, amount);
132 ilm 688 
                    label.setText(a.toPlainString(true));
80 ilm 689 
                    return label;
690 
                }
691 
            });
692 
            tableElementFacturable.addModificationListener(this.totalHT);
693 
            list.add(tableElementFacturable);
28 ilm 694 
        }
73 ilm 695 
 
83 ilm 696 
        final SQLField fieldRemise = e.getTable().getField("POURCENT_REMISE");
697 
 
698 
        if (e.getTable().getFieldsName().contains("MONTANT_REMISE")) {
699 
            tableElementRemise = new SQLTableElement(e.getTable().getField("POURCENT_REMISE"), Acompte.class, new AcompteCellEditor("POURCENT_REMISE", "MONTANT_REMISE")) {
700 
                @Override
701 
                public void setValueFrom(SQLRowValues row, Object value) {
702 
 
703 
                    if (value != null) {
704 
                        Acompte a = (Acompte) value;
705 
                        row.put("MONTANT_REMISE", a.getMontant());
706 
                        row.put("POURCENT_REMISE", a.getPercent());
707 
                    } else {
708 
                        row.put("MONTANT_REMISE", null);
709 
                        row.put("POURCENT_REMISE", BigDecimal.ZERO);
710 
                    }
711 
                    fireModification(row);
712 
                }
713 
            };
714 
            tableElementRemise.setRenderer(new DefaultTableCellRenderer() {
715 
                @Override
716 
                public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
717 
                    SQLRowValues rowVals = ((RowValuesTable) table).getRowValuesTableModel().getRowValuesAt(row);
718 
                    JLabel label = (JLabel) super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
719 
                    BigDecimal percent = rowVals.getBigDecimal("POURCENT_REMISE");
720 
                    BigDecimal amount = rowVals.getBigDecimal("MONTANT_REMISE");
721 
                    Remise a = new Remise(percent, amount);
132 ilm 722 
                    label.setText(a.toPlainString(true));
83 ilm 723 
                    return label;
724 
                }
725 
            });
726 
        } else {
727 
            tableElementRemise = new SQLTableElement(fieldRemise) {
728 
                protected Object getDefaultNullValue() {
729 
                    return BigDecimal.ZERO;
730 
                }
731 
            };
732 
        }
19 ilm 733 
        list.add(tableElementRemise);
28 ilm 734 
        SQLTableElement tableElementRG = null;
735 
        if (e.getTable().getFieldsName().contains("POURCENT_RG")) {
736 
            tableElementRG = new SQLTableElement(e.getTable().getField("POURCENT_RG"));
737 
            list.add(tableElementRG);
738 
        }
739 
 
18 ilm 740 
        // Total HT
67 ilm 741 
        this.totalHA = new SQLTableElement(e.getTable().getField("T_PA_HT"), BigDecimal.class);
174 ilm 742 
        this.totalHA.setRenderer(totalRenderer);
67 ilm 743 
        this.totalHA.setEditable(false);
744 
        list.add(this.totalHA);
18 ilm 745 
 
156 ilm 746 
        if (showDevise) {
19 ilm 747 
            // Total HT
83 ilm 748 
            this.tableElementTotalDevise = new SQLTableElement(e.getTable().getField("PV_T_DEVISE"), BigDecimal.class) {
749 
                @Override
132 ilm 750 
                public boolean isCellEditable(SQLRowValues vals, int rowIndex, int columnIndex) {
751 
                    return isCellNiveauEditable(vals, rowIndex, columnIndex);
83 ilm 752 
                }
753 
            };
94 ilm 754 
            Path p = new Path(getSQLElement().getTable()).addForeignField("ID_DEVISE");
174 ilm 755 
            CurrencyWithSymbolRenderer currencyRenderer = new CurrencyWithSymbolRenderer(new FieldPath(p, "CODE"));
756 
            currencyRenderer.setHideZeroValue(true);
757 
            this.tableElementTotalDevise.setRenderer(currencyRenderer);
758 
            list.add(this.tableElementTotalDevise);
19 ilm 759 
        }
21 ilm 760 
 
761 
        // Marge HT
762 
        if (e.getTable().getFieldsName().contains("MARGE_HT")) {
763 
 
90 ilm 764 
            final SQLTableElement marge = new SQLTableElement(e.getTable().getField("MARGE_HT"), BigDecimal.class) {
765 
                protected Object getDefaultNullValue() {
766 
                    return BigDecimal.ZERO;
767 
                }
768 
 
769 
                @Override
132 ilm 770 
                public boolean isCellEditable(SQLRowValues vals, int rowIndex, int columnIndex) {
771 
                    return isCellNiveauEditable(vals, rowIndex, columnIndex);
90 ilm 772 
                }
773 
 
774 
            };
174 ilm 775 
            marge.setRenderer(totalRenderer);
21 ilm 776 
            marge.setEditable(false);
777 
            list.add(marge);
778 
            this.totalHT.addModificationListener(marge);
67 ilm 779 
            this.totalHA.addModificationListener(marge);
21 ilm 780 
            marge.setModifier(new CellDynamicModifier() {
781 
                @Override
93 ilm 782 
                public Object computeValueFrom(SQLRowValues row, SQLTableElement source) {
21 ilm 783 
 
67 ilm 784 
                    BigDecimal vt = (BigDecimal) row.getObject("T_PV_HT");
21 ilm 785 
 
67 ilm 786 
                    BigDecimal ha = (BigDecimal) row.getObject("T_PA_HT");
21 ilm 787 
 
80 ilm 788 
                    final BigDecimal acomptePercent = row.getBigDecimal("POURCENT_FACTURABLE");
789 
                    final BigDecimal acompteMontant = row.getBigDecimal("MONTANT_FACTURABLE");
790 
                    Acompte acompte = new Acompte(acomptePercent, acompteMontant);
791 
                    ha = acompte.getResultFrom(ha);
792 
                    vt = acompte.getResultFrom(vt);
28 ilm 793 
 
67 ilm 794 
                    return vt.subtract(ha).setScale(marge.getDecimalDigits(), RoundingMode.HALF_UP);
21 ilm 795 
                }
796 
 
797 
            });
798 
 
799 
        }
800 
 
61 ilm 801 
        if (e.getTable().getFieldsName().contains("MARGE_PREBILAN_HT")) {
802 
 
90 ilm 803 
            final SQLTableElement marge = new SQLTableElement(e.getTable().getField("MARGE_PREBILAN_HT"), BigDecimal.class) {
804 
                protected Object getDefaultNullValue() {
805 
                    return BigDecimal.ZERO;
806 
                }
807 
            };
808 
            marge.setRenderer(new DeviseTableCellRenderer());
61 ilm 809 
            marge.setEditable(false);
810 
            list.add(marge);
811 
            this.totalHT.addModificationListener(marge);
812 
            prebilan.addModificationListener(marge);
813 
            marge.setModifier(new CellDynamicModifier() {
814 
                @Override
93 ilm 815 
                public Object computeValueFrom(SQLRowValues row, SQLTableElement source) {
61 ilm 816 
 
67 ilm 817 
                    BigDecimal vt = (BigDecimal) row.getObject("T_PV_HT");
61 ilm 818 
 
67 ilm 819 
                    BigDecimal ha = row.getObject("PREBILAN") == null ? BigDecimal.ZERO : (BigDecimal) row.getObject("PREBILAN");
61 ilm 820 
 
80 ilm 821 
                    final BigDecimal acomptePercent = row.getBigDecimal("POURCENT_FACTURABLE");
822 
                    final BigDecimal acompteMontant = row.getBigDecimal("MONTANT_FACTURABLE");
823 
                    Acompte acompte = new Acompte(acomptePercent, acompteMontant);
824 
                    ha = acompte.getResultFrom(ha);
825 
                    vt = acompte.getResultFrom(vt);
67 ilm 826 
                    return vt.subtract(ha).setScale(marge.getDecimalDigits(), RoundingMode.HALF_UP);
61 ilm 827 
                }
828 
 
829 
            });
830 
 
831 
        }
832 
 
142 ilm 833 
        if (e.getTable().getFieldsName().contains("T_ECO_CONTRIBUTION")) {
834 
            this.tableElementEcoTotal = new SQLTableElement(e.getTable().getField("T_ECO_CONTRIBUTION"));
835 
            list.add(this.tableElementEcoTotal);
836 
        }
837 
 
18 ilm 838 
        // Total HT
73 ilm 839 
 
67 ilm 840 
        this.totalHT.setEditable(false);
18 ilm 841 
        list.add(this.totalHT);
842 
        // Total TTC
65 ilm 843 
        // FIXME add a modifier -> T_TTC modify P_VT_METRIQUE_1 + fix CellDynamicModifier not fire
844 
        // if value not changed
83 ilm 845 
        this.tableElementTotalTTC = new SQLTableElement(e.getTable().getField("T_PV_TTC"), BigDecimal.class) {
846 
            @Override
132 ilm 847 
            public boolean isCellEditable(SQLRowValues vals, int rowIndex, int columnIndex) {
848 
                return isCellNiveauEditable(vals, rowIndex, columnIndex);
83 ilm 849 
            }
850 
        };
174 ilm 851 
        this.tableElementTotalTTC.setRenderer(totalRenderer);
67 ilm 852 
        this.tableElementTotalTTC.setEditable(false);
18 ilm 853 
        list.add(this.tableElementTotalTTC);
854 
 
94 ilm 855 
        this.defaultRowVals = new SQLRowValues(UndefinedRowValuesCache.getInstance().getDefaultRowValues(e.getTable()));
856 
        defaultRowVals.put("ID_TAXE", TaxeCache.getCache().getFirstTaxe().getID());
857 
        defaultRowVals.put("CODE", "");
858 
        defaultRowVals.put("NOM", "");
156 ilm 859 
        final RowValuesTableModel model = new RowValuesTableModel(e, list, e.getTable().getField("ID_TAXE"), false, defaultRowVals) {
860 
            @Override
861 
            public void commitData() {
862 
                int size = getRowCount();
863 
                for (int i = 0; i < size; i++) {
864 
                    SQLRowValues rowVals = getRowValuesAt(i);
865 
                    if (rowVals.getObject("PV_U_DEVISE") == null) {
866 
                        rowVals.put("PV_U_DEVISE", rowVals.getObject("PRIX_METRIQUE_VT_1"));
867 
                        final BigDecimal globalQty = rowVals.getBigDecimal("QTE_UNITAIRE").multiply(new BigDecimal(rowVals.getInt("QTE")));
868 
                        rowVals.put("PV_T_DEVISE", rowVals.getBigDecimal("PRIX_METRIQUE_VT_1").multiply(globalQty));
869 
                    }
870 
                }
871 
                super.commitData();
872 
            }
873 
        };
93 ilm 874 
        setModel(model);
18 ilm 875 
 
93 ilm 876 
        this.table = new RowValuesTable(model, getConfigurationFile());
18 ilm 877 
        ToolTipManager.sharedInstance().unregisterComponent(this.table);
878 
        ToolTipManager.sharedInstance().unregisterComponent(this.table.getTableHeader());
879 
 
174 ilm 880 
        this.table.getTableHeader().addMouseListener(new MouseAdapter() {
881 
            @Override
882 
            public void mousePressed(MouseEvent e) {
883 
                if (e.isPopupTrigger()) {
884 
                    displayPopupMenu(e);
885 
                }
886 
            }
887 
 
888 
            @Override
889 
            public void mouseReleased(MouseEvent e) {
890 
                if (e.isPopupTrigger()) {
891 
                    displayPopupMenu(e);
892 
                }
893 
            }
894 
 
895 
            private void displayPopupMenu(MouseEvent e) {
896 
                JPopupMenu menu = new JPopupMenu();
897 
 
898 
                TaxeCache cache = TaxeCache.getCache();
899 
                Set<SQLRowAccessor> taxes = cache.getAllTaxe();
900 
                JMenu subMenuTVA = new JMenu("Appliquer une TVA spécifique sur toutes les lignes");
901 
                menu.add(subMenuTVA);
902 
                for (SQLRowAccessor taxe : taxes) {
903 
 
904 
                    subMenuTVA.add(new JMenuItem(new AbstractAction(taxe.getFloat("TAUX") + "%") {
905 
 
906 
                        @Override
907 
                        public void actionPerformed(ActionEvent e) {
908 
                            for (int i = 0; i < AbstractVenteArticleItemTable.this.table.getRowCount(); i++) {
909 
                                AbstractVenteArticleItemTable.this.table.getRowValuesTableModel().putValue(taxe.getID(), i, "ID_TAXE");
910 
                            }
911 
                        }
912 
                    }));
913 
                }
914 
                menu.show(e.getComponent(), e.getX(), e.getY());
915 
            }
916 
        });
917 
 
93 ilm 918 
        if (filterFamilleArticle) {
919 
            ((SQLTextComboTableCellEditor) tableElementArticle.getTableCellEditor(this.table)).setDynamicWhere(e.getTable().getTable("ARTICLE").getField("ID_FAMILLE_ARTICLE"));
920 
        }
921 
 
18 ilm 922 
        // Autocompletion
93 ilm 923 
        final SQLTable sqlTableArticle = ((ComptaPropsConfiguration) Configuration.getInstance()).getRootSociete().getTable("ARTICLE");
28 ilm 924 
        List<String> completionField = new ArrayList<String>();
142 ilm 925 
        if (e.getTable().getFieldsName().contains("ID_ECO_CONTRIBUTION")) {
926 
            completionField.add("ID_ECO_CONTRIBUTION");
927 
        }
156 ilm 928 
        if (showDevise) {
28 ilm 929 
            completionField.add("CODE_DOUANIER");
930 
            completionField.add("ID_PAYS");
19 ilm 931 
        }
156 ilm 932 
        completionField.add("POURCENT_REMISE");
61 ilm 933 
        completionField.add("ID_UNITE_VENTE");
156 ilm 934 
        completionField.add("QTE_UNITAIRE");
28 ilm 935 
        completionField.add("PA_HT");
936 
        completionField.add("PV_HT");
937 
        completionField.add("ID_TAXE");
938 
        completionField.add("POIDS");
939 
        completionField.add("PRIX_METRIQUE_HA_1");
940 
        completionField.add("PRIX_METRIQUE_HA_2");
941 
        completionField.add("PRIX_METRIQUE_HA_3");
942 
        completionField.add("VALEUR_METRIQUE_1");
943 
        completionField.add("VALEUR_METRIQUE_2");
944 
        completionField.add("VALEUR_METRIQUE_3");
945 
        completionField.add("ID_MODE_VENTE_ARTICLE");
946 
        completionField.add("PRIX_METRIQUE_VT_1");
947 
        completionField.add("PRIX_METRIQUE_VT_2");
948 
        completionField.add("PRIX_METRIQUE_VT_3");
949 
        completionField.add("SERVICE");
93 ilm 950 
        completionField.add("ID_FAMILLE_ARTICLE");
21 ilm 951 
        if (getSQLElement().getTable().getFieldsName().contains("DESCRIPTIF")) {
28 ilm 952 
            completionField.add("DESCRIPTIF");
21 ilm 953 
        }
156 ilm 954 
        if (showDevise) {
28 ilm 955 
            completionField.add("ID_DEVISE");
956 
            completionField.add("PV_U_DEVISE");
19 ilm 957 
        }
958 
        if (getSQLElement().getTable().getFieldsName().contains("QTE_ACHAT") && sqlTableArticle.getTable().getFieldsName().contains("QTE_ACHAT")) {
28 ilm 959 
            completionField.add("QTE_ACHAT");
19 ilm 960 
        }
18 ilm 961 
 
28 ilm 962 
        final AutoCompletionManager m = new AutoCompletionManager(tableElementCode, sqlTableArticle.getField("CODE"), this.table, this.table.getRowValuesTableModel()) {
93 ilm 963 
 
28 ilm 964 
            @Override
93 ilm 965 
            protected Object getValueFrom(SQLRow row, String field, SQLRowAccessor rowDest) {
966 
                Object res = tarifCompletion(row, field, rowDest, true);
28 ilm 967 
                if (res == null) {
174 ilm 968 
                    res = super.getValueFrom(row, field, rowDest);
28 ilm 969 
                }
174 ilm 970 
                if (field.equals("POURCENT_REMISE")) {
971 
                    return getRemiseClient(row);
972 
                }
973 
                return res;
28 ilm 974 
            }
142 ilm 975 
 
28 ilm 976 
        };
977 
        m.fill("NOM", "NOM");
61 ilm 978 
        m.fill("ID", "ID_ARTICLE");
28 ilm 979 
        for (String string : completionField) {
980 
            m.fill(string, string);
981 
        }
982 
 
132 ilm 983 
        ITransformer<SQLSelect, SQLSelect> selTrans = new ITransformer<SQLSelect, SQLSelect>() {
984 
            @Override
985 
            public SQLSelect transformChecked(SQLSelect input) {
986 
 
149 ilm 987 
                // FIXME utiliser le stock sélectionné sur la ligne et non le stock par défaut de
988 
                // l'article
132 ilm 989 
                final SQLTable tableStock = sqlTableArticle.getTable("STOCK");
990 
                input.andWhere(new Where(tableStock.getKey(), "=", sqlTableArticle.getField("ID_STOCK")));
991 
                input.setExcludeUndefined(false, tableStock);
156 ilm 992 
                Where w = new Where(sqlTableArticle.getField("OBSOLETE"), "=", Boolean.FALSE)
993 
                        .or(new Where(input.getAlias(tableStock.getKey()), "!=", tableStock.getUndefinedID()).and(new Where(input.getAlias(tableStock.getField("QTE_REEL")), ">", 0)));
132 ilm 994 
 
995 
                if (input.getWhere() != null) {
996 
                    input.setWhere(input.getWhere().and(w));
997 
                } else {
998 
                    input.setWhere(w);
999 
                }
1000 
                input.asString();
1001 
                return input;
1002 
            }
1003 
        };
1004 
 
1005 
        m.setSelectTransformer(selTrans);
1006 
 
94 ilm 1007 
        this.table.setDropTarget(new DropTarget() {
1008 
            @Override
1009 
            public synchronized void drop(DropTargetDropEvent dtde) {
1010 
                dropInTable(dtde, m);
1011 
                // super.drop(dtde);
1012 
            }
1013 
        });
1014 
 
132 ilm 1015 
        if (prefs.getBoolean(GestionArticleGlobalPreferencePanel.CAN_EXPAND_NOMENCLATURE_VT, true)) {
93 ilm 1016 
 
132 ilm 1017 
            table.addMouseListener(new MouseAdapter() {
93 ilm 1018 
 
132 ilm 1019 
                @Override
1020 
                public void mousePressed(MouseEvent e) {
1021 
 
1022 
                    handlePopup(e);
93 ilm 1023 
                }
1024 
 
132 ilm 1025 
                @Override
1026 
                public void mouseReleased(MouseEvent e) {
1027 
 
1028 
                    handlePopup(e);
1029 
                }
1030 
 
1031 
                public void handlePopup(MouseEvent e) {
1032 
                    final int rowindex = table.getSelectedRow();
1033 
                    if (rowindex < 0)
1034 
                        return;
1035 
                    if (e.isPopupTrigger() && e.getComponent() instanceof JTable) {
1036 
                        JPopupMenu popup = new JPopupMenu();
1037 
                        popup.add(new AbstractAction(TranslationManager.getInstance().getTranslationForItem("product.bom.expand")) {
1038 
 
1039 
                            @Override
1040 
                            public void actionPerformed(ActionEvent arg0) {
1041 
                                expandNomenclature(rowindex, m, EXPAND_TYPE.EXPAND);
1042 
                            }
1043 
                        });
1044 
                        popup.add(new AbstractAction(TranslationManager.getInstance().getTranslationForItem("product.bom.expose")) {
1045 
 
1046 
                            @Override
1047 
                            public void actionPerformed(ActionEvent arg0) {
1048 
                                expandNomenclature(rowindex, m, EXPAND_TYPE.VIEW_ONLY);
1049 
                            }
1050 
                        });
142 ilm 1051 
 
1052 
                        for (AbstractAction action : getAdditionnalMouseAction(rowindex)) {
1053 
                            popup.add(action);
1054 
                        }
1055 
 
132 ilm 1056 
                        popup.show(e.getComponent(), e.getX(), e.getY());
1057 
                    }
1058 
                }
1059 
            });
1060 
        }
19 ilm 1061 
        final AutoCompletionManager m2 = new AutoCompletionManager(tableElementNom, sqlTableArticle.getField("NOM"), this.table, this.table.getRowValuesTableModel()) {
1062 
            @Override
93 ilm 1063 
            protected Object getValueFrom(SQLRow row, String field, SQLRowAccessor rowDest) {
1064 
                Object res = tarifCompletion(row, field, rowDest, true);
19 ilm 1065 
                if (res == null) {
174 ilm 1066 
                    res = super.getValueFrom(row, field, rowDest);
19 ilm 1067 
                }
174 ilm 1068 
                if (field.equals("POURCENT_REMISE")) {
1069 
                    return getRemiseClient(row);
1070 
                }
1071 
                return res;
19 ilm 1072 
            }
1073 
 
1074 
        };
18 ilm 1075 
        m2.fill("CODE", "CODE");
61 ilm 1076 
        m2.fill("ID", "ID_ARTICLE");
28 ilm 1077 
        for (String string : completionField) {
1078 
            m2.fill(string, string);
19 ilm 1079 
        }
1080 
 
132 ilm 1081 
        m2.setSelectTransformer(selTrans);
18 ilm 1082 
 
61 ilm 1083 
        final AutoCompletionManager m3 = new AutoCompletionManager(tableElementArticle, sqlTableArticle.getField("NOM"), this.table, this.table.getRowValuesTableModel(),
65 ilm 1084 
                ITextWithCompletion.MODE_CONTAINS, true, true, new ValidStateChecker()) {
61 ilm 1085 
            @Override
93 ilm 1086 
            protected Object getValueFrom(SQLRow row, String field, SQLRowAccessor rowDest) {
1087 
                Object res = tarifCompletion(row, field, rowDest, true);
61 ilm 1088 
                if (res == null) {
174 ilm 1089 
                    res = super.getValueFrom(row, field, rowDest);
61 ilm 1090 
                }
174 ilm 1091 
                if (field.equals("POURCENT_REMISE")) {
1092 
                    return getRemiseClient(row);
1093 
                }
1094 
                return res;
61 ilm 1095 
            }
28 ilm 1096 
 
61 ilm 1097 
        };
1098 
        m3.fill("CODE", "CODE");
1099 
        m3.fill("NOM", "NOM");
1100 
        for (String string : completionField) {
1101 
            m3.fill(string, string);
1102 
        }
28 ilm 1103 
 
132 ilm 1104 
        m3.setSelectTransformer(selTrans);
61 ilm 1105 
 
67 ilm 1106 
        // Deselection de l'article si le code est modifié
93 ilm 1107 
        tableFamille.addModificationListener(tableElementArticle);
61 ilm 1108 
        tableElementCode.addModificationListener(tableElementArticle);
1109 
        tableElementArticle.setModifier(new CellDynamicModifier() {
1110 
            @Override
93 ilm 1111 
            public Object computeValueFrom(SQLRowValues row, SQLTableElement source) {
83 ilm 1112 
                try {
93 ilm 1113 
                    if (filterFamilleArticle) {
1114 
                        if (row.isForeignEmpty("ID_FAMILLE_ARTICLE")) {
132 ilm 1115 
                            m.setWhere(null);
1116 
                            m2.setWhere(null);
93 ilm 1117 
                        } else {
132 ilm 1118 
                            m.setWhere(new Where(sqlTableArticle.getField("ID_FAMILLE_ARTICLE"), "=", row.getForeignID("ID_FAMILLE_ARTICLE")));
1119 
                            m2.setWhere(new Where(sqlTableArticle.getField("ID_FAMILLE_ARTICLE"), "=", row.getForeignID("ID_FAMILLE_ARTICLE")));
93 ilm 1120 
                        }
1121 
                    }
83 ilm 1122 
                    SQLRowAccessor foreign = row.getForeign("ID_ARTICLE");
1123 
                    if (foreign != null && !foreign.isUndefined() && foreign.getObject("CODE") != null && foreign.getString("CODE").equals(row.getString("CODE"))) {
1124 
                        return foreign.getID();
1125 
                    } else {
1126 
                        return tableArticle.getUndefinedID();
1127 
                    }
1128 
                } catch (Exception e) {
61 ilm 1129 
                    return tableArticle.getUndefinedID();
1130 
                }
1131 
            }
1132 
        });
1133 
 
142 ilm 1134 
        // ECO Contribution
1135 
        if (this.tableElementEco != null && this.tableElementEcoTotal != null && this.tableElementEcoID != null) {
1136 
            this.qte.addModificationListener(this.tableElementEcoTotal);
1137 
            this.tableElementEco.addModificationListener(this.tableElementEcoTotal);
1138 
            this.tableElementEcoTotal.setModifier(new CellDynamicModifier() {
1139 
                public Object computeValueFrom(final SQLRowValues row, SQLTableElement source) {
1140 
 
1141 
                    int qte = Integer.parseInt(row.getObject("QTE").toString());
1142 
                    BigDecimal f = (row.getObject("ECO_CONTRIBUTION") == null) ? BigDecimal.ZERO : (BigDecimal) row.getObject("ECO_CONTRIBUTION");
1143 
                    return f.multiply(new BigDecimal(qte));
1144 
                }
1145 
 
1146 
            });
1147 
            this.tableElementEcoID.addModificationListener(this.tableElementEco);
1148 
            this.tableElementEco.setModifier(new CellDynamicModifier() {
1149 
                public Object computeValueFrom(final SQLRowValues row, SQLTableElement source) {
1150 
 
1151 
                    if (source != null && source.equals(tableElementEcoID)) {
1152 
                        return row.getForeign("ID_ECO_CONTRIBUTION").getBigDecimal("TAUX");
1153 
                    } else {
1154 
                        return row.getObject("ECO_CONTRIBUTION");
1155 
                    }
1156 
                }
1157 
            });
1158 
        }
1159 
 
18 ilm 1160 
        // Calcul automatique du total HT
93 ilm 1161 
        this.qte.addModificationListener(tableElement_PrixMetrique1_VenteHT);
18 ilm 1162 
        this.qte.addModificationListener(this.totalHT);
67 ilm 1163 
        this.qte.addModificationListener(this.totalHA);
61 ilm 1164 
        qteU.addModificationListener(this.totalHT);
67 ilm 1165 
        qteU.addModificationListener(this.totalHA);
28 ilm 1166 
        if (tableElementRG != null) {
1167 
            tableElementRG.addModificationListener(this.totalHT);
1168 
        }
19 ilm 1169 
        tableElementRemise.addModificationListener(this.totalHT);
28 ilm 1170 
 
18 ilm 1171 
        tableElement_PrixVente_HT.addModificationListener(this.totalHT);
19 ilm 1172 
        // tableElement_PrixVente_HT.addModificationListener(tableElement_PrixMetrique1_VenteHT);
67 ilm 1173 
        this.ha.addModificationListener(this.totalHA);
18 ilm 1174 
 
1175 
        this.totalHT.setModifier(new CellDynamicModifier() {
93 ilm 1176 
            public Object computeValueFrom(final SQLRowValues row, SQLTableElement source) {
19 ilm 1177 
 
83 ilm 1178 
                BigDecimal lremise = BigDecimal.ZERO;
28 ilm 1179 
 
1180 
                if (row.getTable().getFieldsName().contains("POURCENT_RG")) {
1181 
                    final Object o3 = row.getObject("POURCENT_RG");
93 ilm 1182 
                    if (o3 != null) {
1183 
                        lremise = lremise.add(((BigDecimal) o3));
1184 
                    }
28 ilm 1185 
                }
1186 
 
19 ilm 1187 
                int qte = (row.getObject("QTE") == null) ? 0 : Integer.parseInt(row.getObject("QTE").toString());
61 ilm 1188 
                BigDecimal b = (row.getObject("QTE_UNITAIRE") == null) ? BigDecimal.ONE : (BigDecimal) row.getObject("QTE_UNITAIRE");
67 ilm 1189 
                BigDecimal f = (BigDecimal) row.getObject("PV_HT");
90 ilm 1190 
                BigDecimal r = b.multiply(f.multiply(BigDecimal.valueOf(qte), DecimalUtils.HIGH_PRECISION), DecimalUtils.HIGH_PRECISION);
67 ilm 1191 
                if (lremise.compareTo(BigDecimal.ZERO) > 0 && lremise.compareTo(BigDecimal.valueOf(100)) < 100) {
90 ilm 1192 
                    r = r.multiply(BigDecimal.valueOf(100).subtract(lremise), DecimalUtils.HIGH_PRECISION).movePointLeft(2);
19 ilm 1193 
                }
83 ilm 1194 
 
1195 
                if (row.getTable().getFieldsName().contains("MONTANT_REMISE")) {
1196 
                    final BigDecimal acomptePercent = row.getBigDecimal("POURCENT_REMISE");
1197 
                    final BigDecimal acompteMontant = row.getBigDecimal("MONTANT_REMISE");
1198 
                    Remise remise = new Remise(acomptePercent, acompteMontant);
1199 
                    r = remise.getResultFrom(r);
1200 
                }
1201 
 
80 ilm 1202 
                if (row.getTable().getFieldsName().contains("POURCENT_FACTURABLE")) {
1203 
                    final BigDecimal acomptePercent = row.getBigDecimal("POURCENT_FACTURABLE");
1204 
                    final BigDecimal acompteMontant = row.getBigDecimal("MONTANT_FACTURABLE");
1205 
                    Acompte acompte = new Acompte(acomptePercent, acompteMontant);
1206 
                    r = acompte.getResultFrom(r);
1207 
                }
1208 
 
67 ilm 1209 
                return r.setScale(totalHT.getDecimalDigits(), BigDecimal.ROUND_HALF_UP);
18 ilm 1210 
            }
1211 
        });
67 ilm 1212 
        this.totalHA.setModifier(new CellDynamicModifier() {
18 ilm 1213 
            @Override
93 ilm 1214 
            public Object computeValueFrom(SQLRowValues row, SQLTableElement source) {
18 ilm 1215 
                int qte = Integer.parseInt(row.getObject("QTE").toString());
61 ilm 1216 
                BigDecimal b = (row.getObject("QTE_UNITAIRE") == null) ? BigDecimal.ONE : (BigDecimal) row.getObject("QTE_UNITAIRE");
67 ilm 1217 
                BigDecimal f = (BigDecimal) row.getObject("PA_HT");
142 ilm 1218 
                BigDecimal rHA = b.multiply(new BigDecimal(qte), DecimalUtils.HIGH_PRECISION).multiply(f, DecimalUtils.HIGH_PRECISION).setScale(6, BigDecimal.ROUND_HALF_UP);
1219 
                if (row.getTable().getFieldsName().contains("POURCENT_FACTURABLE")) {
1220 
                    final BigDecimal acomptePercent = row.getBigDecimal("POURCENT_FACTURABLE");
1221 
                    final BigDecimal acompteMontant = row.getBigDecimal("MONTANT_FACTURABLE");
1222 
                    if (acomptePercent != null || acompteMontant != null) {
1223 
                        if (acomptePercent != null) {
1224 
                            rHA = rHA.multiply(acomptePercent.movePointLeft(2), DecimalUtils.HIGH_PRECISION);
1225 
                        } else {
1226 
                            // Calcul du T_HT vente origin
1227 
                            BigDecimal lremise = BigDecimal.ZERO;
1228 
 
1229 
                            if (row.getTable().getFieldsName().contains("POURCENT_RG")) {
1230 
                                final Object o3 = row.getObject("POURCENT_RG");
1231 
                                if (o3 != null) {
1232 
                                    lremise = lremise.add(((BigDecimal) o3));
1233 
                                }
1234 
                            }
1235 
 
1236 
                            BigDecimal fVT = (BigDecimal) row.getObject("PV_HT");
1237 
                            BigDecimal r = b.multiply(fVT.multiply(BigDecimal.valueOf(qte), DecimalUtils.HIGH_PRECISION), DecimalUtils.HIGH_PRECISION);
1238 
                            if (lremise.compareTo(BigDecimal.ZERO) > 0 && lremise.compareTo(BigDecimal.valueOf(100)) < 100) {
1239 
                                r = r.multiply(BigDecimal.valueOf(100).subtract(lremise), DecimalUtils.HIGH_PRECISION).movePointLeft(2);
1240 
                            }
1241 
 
1242 
                            if (row.getTable().getFieldsName().contains("MONTANT_REMISE")) {
1243 
                                final BigDecimal acomptePercentR = row.getBigDecimal("POURCENT_REMISE");
1244 
                                final BigDecimal acompteMontantR = row.getBigDecimal("MONTANT_REMISE");
1245 
                                Remise remise = new Remise(acomptePercentR, acompteMontantR);
1246 
                                r = remise.getResultFrom(r);
1247 
                            }
1248 
                            if (r.signum() != 0) {
1249 
                                rHA = rHA.multiply(acompteMontant.divide(r, DecimalUtils.HIGH_PRECISION), DecimalUtils.HIGH_PRECISION);
1250 
                            }
1251 
                        }
1252 
                    }
1253 
 
1254 
                }
1255 
                return rHA.setScale(totalHA.getDecimalDigits(), BigDecimal.ROUND_HALF_UP);
18 ilm 1256 
            }
83 ilm 1257 
 
1258 
            @Override
1259 
            public void setValueFrom(SQLRowValues row, Object value) {
1260 
                super.setValueFrom(row, value);
1261 
            }
18 ilm 1262 
        });
1263 
 
156 ilm 1264 
        if (showDevise) {
19 ilm 1265 
            this.qte.addModificationListener(tableElementTotalDevise);
61 ilm 1266 
            qteU.addModificationListener(tableElementTotalDevise);
80 ilm 1267 
            if (eltUnitDevise != null) {
1268 
                eltUnitDevise.addModificationListener(tableElementTotalDevise);
1269 
            }
21 ilm 1270 
            tableElementRemise.addModificationListener(this.tableElementTotalDevise);
19 ilm 1271 
            tableElementTotalDevise.setModifier(new CellDynamicModifier() {
1272 
                @Override
93 ilm 1273 
                public Object computeValueFrom(SQLRowValues row, SQLTableElement source) {
1274 
                    int qte = row.getInt("QTE");
1275 
                    BigDecimal prixDeVenteUnitaireDevise = (row.getObject("PV_U_DEVISE") == null) ? BigDecimal.ZERO : (BigDecimal) row.getObject("PV_U_DEVISE");
1276 
                    BigDecimal qUnitaire = (row.getObject("QTE_UNITAIRE") == null) ? BigDecimal.ONE : (BigDecimal) row.getObject("QTE_UNITAIRE");
1277 
                    // r = prixUnitaire x qUnitaire x qte
1278 
                    BigDecimal prixVente = qUnitaire.multiply(prixDeVenteUnitaireDevise.multiply(BigDecimal.valueOf(qte), DecimalUtils.HIGH_PRECISION), DecimalUtils.HIGH_PRECISION);
67 ilm 1279 
 
83 ilm 1280 
                    if (row.getTable().getFieldsName().contains("MONTANT_REMISE")) {
1281 
                        final BigDecimal acomptePercent = row.getBigDecimal("POURCENT_REMISE");
1282 
                        final BigDecimal acompteMontant = row.getBigDecimal("MONTANT_REMISE");
1283 
                        Remise remise = new Remise(acomptePercent, acompteMontant);
93 ilm 1284 
                        prixVente = remise.getResultFrom(prixVente);
21 ilm 1285 
                    }
83 ilm 1286 
 
1287 
                    // if (lremise.compareTo(BigDecimal.ZERO) > 0 &&
1288 
                    // lremise.compareTo(BigDecimal.valueOf(100)) < 100) {
1289 
                    // r = r.multiply(BigDecimal.valueOf(100).subtract(lremise),
90 ilm 1290 
                    // DecimalUtils.HIGH_PRECISION).movePointLeft(2);
83 ilm 1291 
                    // }
93 ilm 1292 
                    return prixVente.setScale(tableElementTotalDevise.getDecimalDigits(), BigDecimal.ROUND_HALF_UP);
19 ilm 1293 
                }
1294 
            });
1295 
        }
18 ilm 1296 
        // Calcul automatique du total TTC
73 ilm 1297 
 
18 ilm 1298 
        this.totalHT.addModificationListener(this.tableElementTotalTTC);
61 ilm 1299 
        this.tableElementTVA.addModificationListener(this.tableElementTotalTTC);
18 ilm 1300 
        this.tableElementTotalTTC.setModifier(new CellDynamicModifier() {
1301 
            @Override
93 ilm 1302 
            public Object computeValueFrom(SQLRowValues row, SQLTableElement source) {
21 ilm 1303 
 
73 ilm 1304 
                BigDecimal ht = (BigDecimal) row.getObject("T_PV_HT");
93 ilm 1305 
                int idTaux = row.getForeignID("ID_TAXE");
18 ilm 1306 
 
1307 
                Float resultTaux = TaxeCache.getCache().getTauxFromId(idTaux);
1308 
 
1309 
                if (resultTaux == null) {
80 ilm 1310 
                    SQLRow rowTax = TaxeCache.getCache().getFirstTaxe();
1311 
                    row.put("ID_TAXE", rowTax.getID());
1312 
                    resultTaux = rowTax.getFloat("TAUX");
18 ilm 1313 
                }
1314 
 
1315 
                float taux = (resultTaux == null) ? 0.0F : resultTaux.floatValue();
73 ilm 1316 
                editorPVHT.setTaxe(taux);
94 ilm 1317 
                editorPVHT.setMin(null);
1318 
                if (!row.isForeignEmpty("ID_ARTICLE") && getSQLElement().getTable().getDBRoot().contains("ARTICLE_PRIX_MIN_VENTE") && !lockVTMinPrice) {
1319 
                    List<SQLRow> minPrices = row.getForeign("ID_ARTICLE").asRow().getReferentRows(row.getTable().getTable("ARTICLE_PRIX_MIN_VENTE"));
1320 
                    if (minPrices.size() > 0) {
1321 
                        editorPVHT.setMin(minPrices.get(0).getBigDecimal("PRIX"));
1322 
                    }
1323 
                }
73 ilm 1324 
 
90 ilm 1325 
                BigDecimal r = ht.multiply(BigDecimal.valueOf(taux).movePointLeft(2).add(BigDecimal.ONE), DecimalUtils.HIGH_PRECISION);
73 ilm 1326 
                final BigDecimal resultTTC = r.setScale(tableElementTotalTTC.getDecimalDigits(), BigDecimal.ROUND_HALF_UP);
83 ilm 1327 
 
73 ilm 1328 
                return resultTTC;
18 ilm 1329 
            }
1330 
 
83 ilm 1331 
            @Override
1332 
            public void setValueFrom(SQLRowValues row, Object value) {
1333 
                super.setValueFrom(row, value);
1334 
            }
1335 
 
18 ilm 1336 
        });
21 ilm 1337 
 
18 ilm 1338 
        // Calcul automatique du poids unitaire
1339 
        tableElement_ValeurMetrique1.addModificationListener(tableElementPoids);
1340 
        tableElement_ValeurMetrique2.addModificationListener(tableElementPoids);
1341 
        tableElement_ValeurMetrique3.addModificationListener(tableElementPoids);
1342 
        tableElementPoids.setModifier(new CellDynamicModifier() {
93 ilm 1343 
            public Object computeValueFrom(SQLRowValues row, SQLTableElement source) {
18 ilm 1344 
                return new Float(ReferenceArticleSQLElement.getPoidsFromDetails(row));
1345 
            }
1346 
 
1347 
        });
1348 
        // Calcul automatique du poids total
1349 
        tableElementPoids.addModificationListener(this.tableElementPoidsTotal);
61 ilm 1350 
        qteU.addModificationListener(tableElementPoidsTotal);
18 ilm 1351 
        this.qte.addModificationListener(this.tableElementPoidsTotal);
1352 
        this.tableElementPoidsTotal.setModifier(new CellDynamicModifier() {
93 ilm 1353 
            public Object computeValueFrom(SQLRowValues row, SQLTableElement source) {
18 ilm 1354 
                Number f = (Number) row.getObject("POIDS");
80 ilm 1355 
                if (f == null) {
1356 
                    f = 0;
1357 
                }
18 ilm 1358 
                int qte = Integer.parseInt(row.getObject("QTE").toString());
61 ilm 1359 
                BigDecimal b = (row.getObject("QTE_UNITAIRE") == null) ? BigDecimal.ONE : (BigDecimal) row.getObject("QTE_UNITAIRE");
1360 
                // FIXME convertir en float autrement pour éviter une valeur non valeur transposable
1361 
                // avec floatValue ou passer POIDS en bigDecimal
1362 
                return b.multiply(new BigDecimal(f.floatValue() * qte)).floatValue();
18 ilm 1363 
            }
1364 
 
1365 
        });
61 ilm 1366 
        uniteVente.addModificationListener(qteU);
1367 
        qteU.setModifier(new CellDynamicModifier() {
93 ilm 1368 
            public Object computeValueFrom(SQLRowValues row, SQLTableElement source) {
61 ilm 1369 
                SQLRowAccessor rowUnite = row.getForeign("ID_UNITE_VENTE");
1370 
                if (rowUnite != null && !rowUnite.isUndefined() && rowUnite.getBoolean("A_LA_PIECE")) {
1371 
                    return BigDecimal.ONE;
1372 
                } else {
1373 
                    return row.getObject("QTE_UNITAIRE");
1374 
                }
1375 
            }
1376 
 
1377 
        });
93 ilm 1378 
 
1379 
        tableElement_PrixMetrique1_VenteHT.setModifier(new CellDynamicModifier() {
1380 
            public Object computeValueFrom(SQLRowValues row, SQLTableElement source) {
1381 
                if (source != null && source.getField().getName().equals("PRIX_METRIQUE_VT_1")) {
1382 
                    return row.getObject("PRIX_METRIQUE_VT_1");
1383 
                } else {
1384 
                    if (source != null && source.getField().getName().equals("PV_U_DEVISE")) {
1385 
                        if (!row.isForeignEmpty("ID_DEVISE")) {
1386 
                            String devCode = row.getForeign("ID_DEVISE").getString("CODE");
1387 
                            BigDecimal prixDeVenteUnitaireDevise = (row.getObject("PV_U_DEVISE") == null) ? BigDecimal.ZERO : (BigDecimal) row.getObject("PV_U_DEVISE");
1388 
 
1389 
                            CurrencyConverter c = new CurrencyConverter();
1390 
                            BigDecimal result = c.convert(prixDeVenteUnitaireDevise, devCode, c.getCompanyCurrencyCode(), getDateDevise(), isUsedBiasedDevise());
1391 
                            if (result == null) {
1392 
                                result = prixDeVenteUnitaireDevise;
1393 
                            }
1394 
                            return result.setScale(row.getTable().getField("PRIX_METRIQUE_VT_1").getType().getDecimalDigits(), RoundingMode.HALF_UP);
1395 
                        } else {
1396 
                            return row.getObject("PRIX_METRIQUE_VT_1");
1397 
                        }
1398 
                    }
1399 
                    return tarifCompletion(row.getForeign("ID_ARTICLE"), "PRIX_METRIQUE_VT_1", row);
1400 
                }
1401 
            }
1402 
 
1403 
        });
1404 
 
156 ilm 1405 
        if (showDevise) {
80 ilm 1406 
            if (eltUnitDevise != null) {
1407 
                eltUnitDevise.addModificationListener(tableElement_PrixMetrique1_VenteHT);
1408 
            }
83 ilm 1409 
 
93 ilm 1410 
            if (eltUnitDevise != null) {
1411 
                tableElement_PrixMetrique1_VenteHT.addModificationListener(eltUnitDevise);
132 ilm 1412 
                eltDevise.addModificationListener(eltUnitDevise);
93 ilm 1413 
                eltUnitDevise.setModifier(new CellDynamicModifier() {
1414 
                    public Object computeValueFrom(SQLRowValues row, SQLTableElement source) {
1415 
                        if (source != null && source.getField().getName().equals("PV_U_DEVISE")) {
1416 
                            BigDecimal prixDeVenteUnitaireDevise = (row.getObject("PV_U_DEVISE") == null) ? BigDecimal.ZERO : (BigDecimal) row.getObject("PV_U_DEVISE");
1417 
                            return prixDeVenteUnitaireDevise;
1418 
                        } else {
1419 
                            if (!row.isForeignEmpty("ID_DEVISE")) {
1420 
                                String devCode = row.getForeign("ID_DEVISE").getString("CODE");
1421 
                                BigDecimal bigDecimal = (BigDecimal) row.getObject("PRIX_METRIQUE_VT_1");
1422 
 
1423 
                                CurrencyConverter c = new CurrencyConverter();
1424 
                                BigDecimal result = c.convert(bigDecimal, c.getCompanyCurrencyCode(), devCode, getDateDevise(), isUsedBiasedDevise());
1425 
                                if (result == null) {
1426 
                                    result = bigDecimal;
1427 
                                }
1428 
                                return result.setScale(row.getTable().getField("PRIX_METRIQUE_VT_1").getType().getDecimalDigits(), RoundingMode.HALF_UP);
1429 
                            } else if (source != null && source.getField().getName().equalsIgnoreCase("PRIX_METRIQUE_VT_1")) {
1430 
                                return row.getObject("PRIX_METRIQUE_VT_1");
1431 
                            }
1432 
                            BigDecimal prixDeVenteUnitaireDevise = (row.getObject("PV_U_DEVISE") == null) ? BigDecimal.ZERO : (BigDecimal) row.getObject("PV_U_DEVISE");
1433 
                            return prixDeVenteUnitaireDevise;
1434 
                        }
19 ilm 1435 
                    }
1436 
 
93 ilm 1437 
                });
1438 
            }
19 ilm 1439 
        }
1440 
 
18 ilm 1441 
        // Calcul automatique du prix de vente unitaire HT
1442 
        tableElement_ValeurMetrique1.addModificationListener(tableElement_PrixVente_HT);
1443 
        tableElement_ValeurMetrique2.addModificationListener(tableElement_PrixVente_HT);
1444 
        tableElement_ValeurMetrique3.addModificationListener(tableElement_PrixVente_HT);
1445 
        tableElement_PrixMetrique1_VenteHT.addModificationListener(tableElement_PrixVente_HT);
1446 
        tableElement_PrixVente_HT.setModifier(new CellDynamicModifier() {
93 ilm 1447 
            public Object computeValueFrom(SQLRowValues row, SQLTableElement source) {
1448 
                if (row.isForeignEmpty("ID_MODE_VENTE_ARTICLE") || row.getInt("ID_MODE_VENTE_ARTICLE") == ReferenceArticleSQLElement.A_LA_PIECE) {
67 ilm 1449 
                    return row.getObject("PRIX_METRIQUE_VT_1");
18 ilm 1450 
                } else {
1451 
 
67 ilm 1452 
                    final BigDecimal prixVTFromDetails = ReferenceArticleSQLElement.getPrixVTFromDetails(row);
1453 
                    return prixVTFromDetails.setScale(tableElement_PrixVente_HT.getDecimalDigits(), RoundingMode.HALF_UP);
18 ilm 1454 
                }
1455 
            }
1456 
        });
1457 
 
1458 
        // Calcul automatique du prix d'achat unitaire HT
1459 
        tableElement_ValeurMetrique1.addModificationListener(this.ha);
1460 
        tableElement_ValeurMetrique2.addModificationListener(this.ha);
1461 
        tableElement_ValeurMetrique3.addModificationListener(this.ha);
1462 
        tableElement_PrixMetrique1_AchatHT.addModificationListener(this.ha);
1463 
        this.ha.setModifier(new CellDynamicModifier() {
93 ilm 1464 
            public Object computeValueFrom(SQLRowValues row, SQLTableElement source) {
1465 
                if (row.isForeignEmpty("ID_MODE_VENTE_ARTICLE") || row.getInt("ID_MODE_VENTE_ARTICLE") == ReferenceArticleSQLElement.A_LA_PIECE) {
67 ilm 1466 
                    return row.getObject("PRIX_METRIQUE_HA_1");
18 ilm 1467 
                } else {
1468 
 
67 ilm 1469 
                    final BigDecimal prixHAFromDetails = ReferenceArticleSQLElement.getPrixHAFromDetails(row);
1470 
                    return prixHAFromDetails.setScale(ha.getDecimalDigits(), RoundingMode.HALF_UP);
18 ilm 1471 
                }
1472 
            }
1473 
 
1474 
        });
1475 
 
1476 
        this.table.readState();
1477 
 
93 ilm 1478 
        setColumnVisible(model.getColumnForField("T_PA_HT"), true);
18 ilm 1479 
 
80 ilm 1480 
        // Packaging
1481 
        if (prefs.getBoolean(GestionArticleGlobalPreferencePanel.ITEM_PACKAGING, false)) {
93 ilm 1482 
            setColumnVisible(model.getColumnForField("T_POIDS_COLIS_NET"), false);
80 ilm 1483 
        }
1484 
 
18 ilm 1485 
        // Mode Gestion article avancé
21 ilm 1486 
        final boolean modeAvance = DefaultNXProps.getInstance().getBooleanValue("ArticleModeVenteAvance", false);
93 ilm 1487 
        setColumnVisible(model.getColumnForField("VALEUR_METRIQUE_1"), modeAvance);
1488 
        setColumnVisible(model.getColumnForField("VALEUR_METRIQUE_2"), modeAvance);
1489 
        setColumnVisible(model.getColumnForField("VALEUR_METRIQUE_3"), modeAvance);
1490 
        setColumnVisible(model.getColumnForField("PV_HT"), modeAvance);
1491 
        setColumnVisible(model.getColumnForField("PA_HT"), modeAvance);
1492 
        setColumnVisible(model.getColumnForField("ID_MODE_VENTE_ARTICLE"), modeAvance);
18 ilm 1493 
 
142 ilm 1494 
        if (this.tableElementEco != null && this.tableElementEcoTotal != null && this.tableElementEcoID != null) {
1495 
            setColumnVisible(model.getColumnForField("ID_ECO_CONTRIBUTION"), showEco);
1496 
            setColumnVisible(model.getColumnForField("ECO_CONTRIBUTION"), showEco);
1497 
            setColumnVisible(model.getColumnForField("T_ECO_CONTRIBUTION"), showEco);
1498 
        }
1499 
 
61 ilm 1500 
        // Gestion des unités de vente
1501 
        final boolean gestionUV = prefs.getBoolean(GestionArticleGlobalPreferencePanel.UNITE_VENTE, true);
93 ilm 1502 
        setColumnVisible(model.getColumnForField("QTE_UNITAIRE"), gestionUV);
1503 
        setColumnVisible(model.getColumnForField("ID_UNITE_VENTE"), gestionUV);
61 ilm 1504 
 
93 ilm 1505 
        setColumnVisible(model.getColumnForField("ID_ARTICLE"), selectArticle);
1506 
        setColumnVisible(model.getColumnForField("CODE"), !selectArticle || (selectArticle && createAuto));
1507 
        setColumnVisible(model.getColumnForField("NOM"), !selectArticle || (selectArticle && createAuto));
61 ilm 1508 
 
18 ilm 1509 
        // Voir le poids
21 ilm 1510 
        final boolean showPoids = DefaultNXProps.getInstance().getBooleanValue("ArticleShowPoids", false);
93 ilm 1511 
        setColumnVisible(model.getColumnForField("POIDS"), showPoids);
1512 
        setColumnVisible(model.getColumnForField("T_POIDS"), showPoids);
18 ilm 1513 
 
1514 
        // Voir le style
93 ilm 1515 
        setColumnVisible(model.getColumnForField("ID_STYLE"), DefaultNXProps.getInstance().getBooleanValue("ArticleShowStyle", true));
1516 
        setColumnVisible(model.getColumnForField("POURCENT_FACTURABLE"), false);
18 ilm 1517 
 
93 ilm 1518 
        setColumnVisible(getModel().getColumnForField("ID_FAMILLE_ARTICLE"), filterFamilleArticle);
28 ilm 1519 
 
94 ilm 1520 
        setColumnVisible(model.getColumnForField("PRIX_METRIQUE_HA_1"), showHAPrice);
156 ilm 1521 
        setColumnVisible(model.getColumnForField("MARGE_HT"), showHAPrice);
94 ilm 1522 
        setColumnVisible(model.getColumnForField("T_PA_HT"), showHAPrice);
93 ilm 1523 
 
94 ilm 1524 
 
156 ilm 1525 
        setColumnVisible(model.getColumnForField("ID_DEPOT_STOCK"), prefs.getBoolean(GestionArticleGlobalPreferencePanel.STOCK_MULTI_DEPOT, false));
1526 
 
28 ilm 1527 
        for (String string : visibilityMap.keySet()) {
93 ilm 1528 
            setColumnVisible(model.getColumnForField(string), visibilityMap.get(string));
28 ilm 1529 
        }
1530 
 
41 ilm 1531 
        Map<String, Boolean> mapCustom = getCustomVisibilityMap();
1532 
        if (mapCustom != null) {
1533 
            for (String string : mapCustom.keySet()) {
93 ilm 1534 
                setColumnVisible(model.getColumnForField(string), mapCustom.get(string));
41 ilm 1535 
            }
1536 
        }
1537 
 
142 ilm 1538 
        // Barcode reader
1539 
        final BarcodeReader barcodeReader = ComptaPropsConfiguration.getInstanceCompta().getBarcodeReader();
1540 
        if (barcodeReader != null) {
1541 
 
1542 
            final BarcodeListener l = new BarcodeListener() {
1543 
 
1544 
                @Override
1545 
                public void keyReceived(KeyEvent ee) {
1546 
                    // TODO Auto-generated method stub
1547 
                }
1548 
 
1549 
                @Override
1550 
                public void barcodeRead(String code) {
1551 
                    if (((JFrame) SwingUtilities.getRoot(getRowValuesTable())).isActive()) {
1552 
                        final SQLSelect selArticle = new SQLSelect();
1553 
                        final SQLTable tableArticle = getSQLElement().getForeignElement("ID_ARTICLE").getTable();
1554 
                        selArticle.addSelectStar(tableArticle);
1555 
                        Where w = new Where(tableArticle.getField("OBSOLETE"), "=", Boolean.FALSE);
1556 
                        w = w.and(new Where(tableArticle.getField("CODE_BARRE"), "=", code));
1557 
                        selArticle.setWhere(w);
1558 
                        List<SQLRow> l2 = SQLRowListRSH.execute(selArticle);
1559 
                        if (l2.size() > 0) {
1560 
                            System.err.println("ARTICLE " + l2.get(0).getString("NOM"));
1561 
                            Tuple3<Double, String, String> art = Tuple3.create(1.0D, l2.get(0).getString("CODE"), l2.get(0).getString("NOM"));
1562 
                            List<Tuple3<Double, String, String>> l = new ArrayList<Tuple3<Double, String, String>>();
1563 
                            l.add(art);
1564 
                            insertFromDrop(l, m);
1565 
                        } else {
1566 
                            System.err.println("ARTICLE NOT FOUND !");
1567 
                        }
1568 
                    }
1569 
 
1570 
                }
1571 
            };
1572 
            getRowValuesTable().addHierarchyListener(new HierarchyListener() {
1573 
                public void hierarchyChanged(HierarchyEvent e) {
1574 
                    if ((e.getChangeFlags() & HierarchyEvent.DISPLAYABILITY_CHANGED) != 0)
1575 
                        if (getRowValuesTable().isDisplayable()) {
1576 
                            barcodeReader.addBarcodeListener(l);
1577 
                        } else {
1578 
                            barcodeReader.removeBarcodeListener(l);
1579 
                        }
1580 
                }
1581 
            });
1582 
 
1583 
        }
1584 
 
18 ilm 1585 
        // On réécrit la configuration au cas ou les preferences aurait changé (ajout ou suppression
1586 
        // du mode de vente specifique)
1587 
        this.table.writeState();
174 ilm 1588 
 
1589 
        if (this.table.getRowValuesTableModel().getColumnForField("ID_DEPOT_STOCK") >= 0 && this.table.getRowValuesTableModel().getColumnForField("ID_ARTICLE") >= 0) {
1590 
            if (this.buttons == null) {
1591 
                this.buttons = new ArrayList<>();
1592 
            }
1593 
 
1594 
            JButton buttonStock = new JButton("Consulter le stock");
1595 
            buttonStock.addActionListener(new ActionListener() {
1596 
                public void actionPerformed(ActionEvent event) {
1597 
                    SQLRowValues rowValsSel = table.getSelectedRowValues();
1598 
                    if (rowValsSel != null) {
1599 
                        SQLRowAccessor foreignArt = rowValsSel.getForeign("ID_ARTICLE");
1600 
                        if (foreignArt != null && !foreignArt.isUndefined()) {
1601 
                            SQLRowAccessor rowValsStock = StockSQLElement.getStock(rowValsSel);
1602 
                            if (rowValsStock != null && !rowValsStock.isUndefined()) {
1603 
                                EditFrame frame = new EditFrame(table.getRowValuesTableModel().getSQLElement().getDirectory().getElement("STOCK"), EditMode.READONLY);
1604 
                                frame.selectionId(rowValsStock.getID());
1605 
                                frame.setVisible(true);
1606 
                            }
1607 
                        }
1608 
                    }
1609 
 
1610 
                }
1611 
            });
1612 
 
1613 
            this.buttons.add(buttonStock);
1614 
 
1615 
        }
1616 
 
18 ilm 1617 
    }
1618 
 
174 ilm 1619 
    Collection<? extends SQLRowAccessor> cacheRemise = null;
1620 
 
1621 
    protected BigDecimal getTarifRemiseClient(SQLRowAccessor article, BigDecimal pv) {
1622 
        if (cacheRemise != null) {
1623 
            if (getRowClient() != null && !getRowClient().isUndefined() && article != null && !article.isUndefined()) {
1624 
                for (SQLRowAccessor sqlRowAccessor : cacheRemise) {
1625 
                    if (!sqlRowAccessor.isForeignEmpty("ID_ARTICLE") && sqlRowAccessor.getForeignID("ID_ARTICLE") == article.getID()) {
1626 
                        BigDecimal remise = sqlRowAccessor.getBigDecimal("POURCENT_REMISE");
1627 
                        if (remise != null) {
1628 
                            return pv.multiply(BigDecimal.ONE.subtract(remise.movePointLeft(2)), DecimalUtils.HIGH_PRECISION).setScale(pv.scale(), RoundingMode.HALF_UP);
1629 
                        }
1630 
                    }
1631 
                }
1632 
            }
1633 
        }
1634 
        return pv;
1635 
    }
1636 
 
1637 
    protected Acompte getRemiseClient(SQLRowAccessor article) {
1638 
        Acompte remise = new Acompte(BigDecimal.ZERO, BigDecimal.ZERO);
1639 
        if (this.cacheRemise != null) {
1640 
            if (getRowClient() != null && !getRowClient().isUndefined() && article != null && !article.isUndefined()) {
1641 
                for (SQLRowAccessor sqlRowAccessor : this.cacheRemise) {
1642 
                    if (!sqlRowAccessor.isForeignEmpty("ID_ARTICLE") && sqlRowAccessor.getForeignID("ID_ARTICLE") == article.getID()) {
1643 
                        BigDecimal r = sqlRowAccessor.getBigDecimal("POURCENT_REMISE");
1644 
                        if (remise != null) {
1645 
                            remise = new Acompte(r, null);
1646 
                        }
1647 
                    }
1648 
                }
1649 
            }
1650 
        }
1651 
        return remise;
1652 
    }
1653 
 
93 ilm 1654 
    @Override
1655 
    protected void refreshDeviseAmount() {
1656 
        int count = getRowValuesTable().getRowCount();
1657 
        final int columnForField = getRowValuesTable().getRowValuesTableModel().getColumnForField("PV_U_DEVISE");
1658 
        if (columnForField >= 0) {
1659 
            SQLTableElement eltDevise = getRowValuesTable().getRowValuesTableModel().getSQLTableElementAt(columnForField);
1660 
            for (int i = 0; i < count; i++) {
1661 
                SQLRowValues rowVals = getRowValuesTable().getRowValuesTableModel().getRowValuesAt(i);
1662 
                // getRowValuesTable().getRowValuesTableModel().putValue(rowVals.getObject("PV_U_DEVISE"),
1663 
                // i, "PV_U_DEVISE", true);
1664 
                BigDecimal prixDeVenteUnitaireDevise = (rowVals.getObject("PV_U_DEVISE") == null) ? BigDecimal.ZERO : (BigDecimal) rowVals.getObject("PV_U_DEVISE");
1665 
                eltDevise.setValueFrom(rowVals, prixDeVenteUnitaireDevise);
1666 
                getRowValuesTable().getRowValuesTableModel().fireTableChanged(new TableModelEvent(getRowValuesTable().getRowValuesTableModel(), i, i, columnForField));
1667 
            }
1668 
        }
1669 
    }
1670 
 
41 ilm 1671 
    protected Map<String, Boolean> getCustomVisibilityMap() {
1672 
        return null;
1673 
    }
1674 
 
93 ilm 1675 
    protected Object tarifCompletion(SQLRowAccessor row, String field, SQLRowAccessor rowDest) {
1676 
        return tarifCompletion(row, field, rowDest, false);
1677 
    }
19 ilm 1678 
 
93 ilm 1679 
    protected Object tarifCompletion(SQLRowAccessor row, String field, SQLRowAccessor rowDest, boolean fromCompletion) {
1680 
 
156 ilm 1681 
        if (row != null && !row.isUndefined() && (field.equalsIgnoreCase("PRIX_METRIQUE_HA_1") || field.equalsIgnoreCase("PA_HT"))) {
132 ilm 1682 
 
156 ilm 1683 
            if (getSQLElement().getTable().getDBRoot().contains("ARTICLE_PRIX_REVIENT")) {
1684 
                final BigDecimal prc;
1685 
                if (row.getBoolean("AUTO_PRIX_REVIENT_NOMENCLATURE")) {
1686 
                    ProductHelper helper = new ProductHelper(row.getTable().getDBRoot());
1687 
                    prc = helper.getBomPriceForQuantity(1, row.getReferentRows(row.getTable().getTable("ARTICLE_ELEMENT").getField("ID_ARTICLE_PARENT")), TypePrice.ARTICLE_PRIX_REVIENT);
1688 
                } else {
1689 
                    ProductComponent productComp = new ProductComponent(row, BigDecimal.ONE, null, null);
1690 
                    prc = productComp.getPRC(new Date());
1691 
                }
1692 
                if (prc == null) {
1693 
                    return BigDecimal.ZERO;
1694 
                }
1695 
                return prc;
1696 
            } else if (getSQLElement().getTable().getDBRoot().contains("COUT_REVIENT") && row.getObject("ID_COUT_REVIENT") != null && !row.isForeignEmpty("ID_COUT_REVIENT")) {
1697 
                BigDecimal ha = row.getBigDecimal(field);
1698 
                BigDecimal percent = row.getForeign("ID_COUT_REVIENT").getBigDecimal("POURCENT");
1699 
                return ha.multiply(percent.movePointLeft(2).add(BigDecimal.ONE)).setScale(ha.precision(), RoundingMode.HALF_UP);
132 ilm 1700 
            }
94 ilm 1701 
        }
1702 
 
73 ilm 1703 
        if (getTarif() != null && !getTarif().isUndefined()) {
28 ilm 1704 
            Collection<? extends SQLRowAccessor> rows = row.getReferentRows(tableArticleTarif);
19 ilm 1705 
 
93 ilm 1706 
            // Récupération du tarif associé à la quantité
1707 
            int quantite = 0;
1708 
            BigDecimal b = rowDest.getBigDecimal("QTE_UNITAIRE");
1709 
            int q = rowDest.getInt("QTE");
1710 
            BigDecimal qteTotal = b.multiply(new BigDecimal(q), DecimalUtils.HIGH_PRECISION);
28 ilm 1711 
            SQLRowAccessor rowTarif = null;
93 ilm 1712 
 
1713 
            for (SQLRowAccessor sqlRowAccessor : rows) {
1714 
 
1715 
                if (!sqlRowAccessor.getTable().contains("OBSOLETE") || !sqlRowAccessor.getBoolean("OBSOLETE")) {
1716 
                    // FIXME BigDecimal??
1717 
                    // BigDecimal bigDecimal = sqlRowAccessor.getBigDecimal("QTE");
1718 
                    int qteTarif = sqlRowAccessor.getInt("QTE");
1719 
                    if (sqlRowAccessor.getForeignID("ID_TARIF") == getTarif().getID() && CompareUtils.compare(qteTarif, qteTotal) <= 0 && CompareUtils.compare(qteTarif, quantite) > 0) {
1720 
                        quantite = qteTarif;
1721 
                        rowTarif = sqlRowAccessor;
1722 
                        // else {
1723 
                        // result = null;
1724 
                        // remise = sqlRowAccessor.getBigDecimal("POURCENT_REMISE");
1725 
                        // }
1726 
                    }
19 ilm 1727 
                }
1728 
            }
1729 
 
1730 
            if (rowTarif == null) {
93 ilm 1731 
                if (!getTarif().isForeignEmpty("ID_DEVISE")) {
19 ilm 1732 
                    if ((field.equalsIgnoreCase("ID_DEVISE"))) {
1733 
                        return getTarif().getObject("ID_DEVISE");
1734 
                    } else if ((field.equalsIgnoreCase("PV_U_DEVISE"))) {
1735 
 
132 ilm 1736 
                        return getQtyTarifPvM1(rowDest, fromCompletion);
93 ilm 1737 
                    }
1738 
                }
1739 
                if ((field.equalsIgnoreCase("ID_TAXE"))) {
83 ilm 1740 
 
93 ilm 1741 
                    if (!getTarif().isForeignEmpty("ID_TAXE")) {
1742 
                        return getTarif().getForeignID("ID_TAXE");
19 ilm 1743 
                    }
1744 
                }
1745 
 
93 ilm 1746 
            } else {
1747 
                if (field.equalsIgnoreCase("PRIX_METRIQUE_VT_1")) {
1748 
                    if (rowTarif.isForeignEmpty("ID_DEVISE"))
1749 
                        return rowTarif.getObject(field);
1750 
                    else {
19 ilm 1751 
 
93 ilm 1752 
                        String devCode = getTarif().getForeign("ID_DEVISE").getString("CODE");
1753 
                        CurrencyConverter c = new CurrencyConverter();
1754 
                        BigDecimal result = c.convert(rowTarif.getBigDecimal(field), devCode, c.getCompanyCurrencyCode(), new Date(), true);
1755 
                        return result.setScale(row.getTable().getField(field).getType().getDecimalDigits(), RoundingMode.HALF_UP);
1756 
                    }
19 ilm 1757 
 
93 ilm 1758 
                } else if ((field.equalsIgnoreCase("ID_DEVISE"))) {
19 ilm 1759 
 
93 ilm 1760 
                    return rowTarif.getObject("ID_DEVISE");
1761 
                }
19 ilm 1762 
 
93 ilm 1763 
                else if ((field.equalsIgnoreCase("PV_U_DEVISE"))) {
19 ilm 1764 
 
93 ilm 1765 
                    return rowTarif.getObject("PRIX_METRIQUE_VT_1");
19 ilm 1766 
 
93 ilm 1767 
                } else if ((field.equalsIgnoreCase("ID_TAXE"))) {
1768 
 
1769 
                    if (!rowTarif.isForeignEmpty("ID_TAXE")) {
1770 
                        return rowTarif.getObject("ID_TAXE");
1771 
 
1772 
                    }
94 ilm 1773 
                } else if ((field.equalsIgnoreCase("POURCENT_REMISE"))) {
1774 
                    Acompte remise = new Acompte(rowTarif.getBigDecimal("POURCENT_REMISE"), BigDecimal.ZERO);
1775 
                    return remise;
19 ilm 1776 
                }
1777 
            }
1778 
        }
93 ilm 1779 
 
156 ilm 1780 
        if (field.equalsIgnoreCase("ID_TAXE_VENTE") && this.rowCatComptable != null) {
1781 
            return this.rowCatComptable.getForeignID("ID_TAXE_VENTE");
1782 
        }
1783 
 
94 ilm 1784 
        if ((field.equalsIgnoreCase("POURCENT_REMISE"))) {
1785 
            return new Acompte(BigDecimal.ZERO, BigDecimal.ZERO);
1786 
        }
1787 
 
93 ilm 1788 
        if ((field.equalsIgnoreCase("PRIX_METRIQUE_VT_1"))) {
1789 
            return getQtyTarifPvM1(rowDest, fromCompletion);
1790 
        } else {
1791 
            return null;
1792 
        }
19 ilm 1793 
    }
1794 
 
1795 
    @Override
174 ilm 1796 
    public void setClient(SQLRowAccessor rowClient, boolean ask) {
1797 
        if (rowClient == null || getRowClient() == null || rowClient.getID() != getRowClient().getID()) {
1798 
            super.setClient(rowClient, ask);
1799 
            if (getRowClient() != null && !getRowClient().isUndefined()) {
1800 
                this.cacheRemise = getRowClient().getReferentRows(getSQLElement().getTable().getTable("TARIF_ARTICLE_CLIENT"));
1801 
                if (ask && getRowValuesTable().getRowCount() > 0
1802 
                        && JOptionPane.showConfirmDialog(null, "Appliquer les remises associées au client sur les lignes déjà présentes?") == JOptionPane.YES_OPTION) {
1803 
                    int nbRows = this.table.getRowCount();
1804 
                    for (int i = 0; i < nbRows; i++) {
1805 
                        SQLRowValues rowVals = getRowValuesTable().getRowValuesTableModel().getRowValuesAt(i);
1806 
 
1807 
                        if (!rowVals.isForeignEmpty("ID_ARTICLE")) {
1808 
                            SQLRowAccessor rowValsArt = rowVals.getForeign("ID_ARTICLE");
1809 
                            final Object taxeValue = tarifCompletion(rowValsArt, "ID_TAXE", rowVals);
1810 
                            if (taxeValue != null) {
1811 
                                getRowValuesTable().getRowValuesTableModel().putValue(taxeValue, i, "ID_TAXE");
1812 
                            }
1813 
 
1814 
                            final Object deviseValue = tarifCompletion(rowValsArt, "ID_DEVISE", rowVals);
1815 
                            if (deviseValue != null) {
1816 
                                getRowValuesTable().getRowValuesTableModel().putValue(deviseValue, i, "ID_DEVISE");
1817 
                            }
1818 
                            getRowValuesTable().getRowValuesTableModel().putValue(tarifCompletion(rowValsArt, "PV_U_DEVISE", rowVals), i, "PV_U_DEVISE");
1819 
                            getRowValuesTable().getRowValuesTableModel().putValue(tarifCompletion(rowValsArt, "PRIX_METRIQUE_VT_1", rowVals), i, "PRIX_METRIQUE_VT_1");
1820 
                        }
1821 
                    }
1822 
                }
1823 
            } else {
1824 
                this.cacheRemise = null;
1825 
            }
1826 
        }
1827 
    }
1828 
 
1829 
    @Override
19 ilm 1830 
    public void setTarif(SQLRowAccessor rowValuesTarif, boolean ask) {
1831 
        if (rowValuesTarif == null || getTarif() == null || rowValuesTarif.getID() != getTarif().getID()) {
1832 
            super.setTarif(rowValuesTarif, ask);
94 ilm 1833 
            if (ask && getRowValuesTable().getRowCount() > 0
1834 
                    && JOptionPane.showConfirmDialog(null, "Appliquer les tarifs associés au client sur les lignes déjà présentes?") == JOptionPane.YES_OPTION) {
19 ilm 1835 
                int nbRows = this.table.getRowCount();
1836 
                for (int i = 0; i < nbRows; i++) {
1837 
                    SQLRowValues rowVals = getRowValuesTable().getRowValuesTableModel().getRowValuesAt(i);
1838 
 
93 ilm 1839 
                    if (!rowVals.isForeignEmpty("ID_ARTICLE")) {
1840 
                        SQLRowAccessor rowValsArt = rowVals.getForeign("ID_ARTICLE");
1841 
                        final Object taxeValue = tarifCompletion(rowValsArt, "ID_TAXE", rowVals);
1842 
                        if (taxeValue != null) {
1843 
                            getRowValuesTable().getRowValuesTableModel().putValue(taxeValue, i, "ID_TAXE");
19 ilm 1844 
                        }
93 ilm 1845 
 
1846 
                        final Object deviseValue = tarifCompletion(rowValsArt, "ID_DEVISE", rowVals);
1847 
                        if (deviseValue != null) {
1848 
                            getRowValuesTable().getRowValuesTableModel().putValue(deviseValue, i, "ID_DEVISE");
1849 
                        }
1850 
                        getRowValuesTable().getRowValuesTableModel().putValue(tarifCompletion(rowValsArt, "PV_U_DEVISE", rowVals), i, "PV_U_DEVISE");
1851 
                        getRowValuesTable().getRowValuesTableModel().putValue(tarifCompletion(rowValsArt, "PRIX_METRIQUE_VT_1", rowVals), i, "PRIX_METRIQUE_VT_1");
19 ilm 1852 
                    }
93 ilm 1853 
                }
1854 
            }
1855 
        }
1856 
    }
28 ilm 1857 
 
93 ilm 1858 
    protected Object getQtyTarifPvM1(SQLRowAccessor row, boolean fromCompletion) {
73 ilm 1859 
 
93 ilm 1860 
        // Test si un tarif spécial est associé à l'article
1861 
        // Object o = tarifCompletion(row.getForeign("ID_ARTICLE"), "PRIX_METRIQUE_VT_1", row,
1862 
        // false);
1863 
        // if (o != null) {
1864 
        // return o;
1865 
        // }
1866 
 
1867 
        SQLRowAccessor rowA = row.getForeign("ID_ARTICLE");
132 ilm 1868 
        if (rowA != null && !rowA.isUndefined() && rowA.getTable().contains("AUTO_PRIX_MIN_VENTE_NOMENCLATURE") && rowA.getBoolean("AUTO_PRIX_MIN_VENTE_NOMENCLATURE")) {
1869 
            BigDecimal b = row.getBigDecimal("QTE_UNITAIRE");
1870 
            int q = row.getInt("QTE");
1871 
            BigDecimal qteTotal = b.multiply(new BigDecimal(q), DecimalUtils.HIGH_PRECISION);
1872 
            ProductHelper helper = new ProductHelper(rowA.getTable().getDBRoot());
1873 
 
1874 
            return helper.getBomPriceForQuantity(qteTotal.setScale(0, RoundingMode.HALF_UP).intValue(), rowA.getReferentRows(rowA.getTable().getTable("ARTICLE_ELEMENT").getField("ID_ARTICLE_PARENT")),
1875 
                    TypePrice.ARTICLE_PRIX_PUBLIC);
1876 
        }
93 ilm 1877 
        BigDecimal result = null;
1878 
        // BigDecimal remise = null;
1879 
        if (rowA != null && !rowA.isUndefined() && rowA.getTable().getDBRoot().contains("ARTICLE_PRIX_PUBLIC")) {
1880 
            Collection<? extends SQLRowAccessor> col = rowA.getReferentRows(rowA.getTable().getTable("ARTICLE_PRIX_PUBLIC"));
1881 
            int quantite = 0;
1882 
            BigDecimal b = row.getBigDecimal("QTE_UNITAIRE");
1883 
            int q = row.getInt("QTE");
1884 
            BigDecimal qteTotal = b.multiply(new BigDecimal(q), DecimalUtils.HIGH_PRECISION);
1885 
 
1886 
            for (SQLRowAccessor sqlRowAccessor : col) {
1887 
 
1888 
                // FIXME BigDecimal??
1889 
                // BigDecimal bigDecimal = sqlRowAccessor.getBigDecimal("QTE");
1890 
                int qtePublic = sqlRowAccessor.getInt("QTE");
1891 
                if (CompareUtils.compare(qtePublic, qteTotal) <= 0 && CompareUtils.compare(qtePublic, quantite) > 0) {
1892 
                    quantite = qtePublic;
1893 
                    if (sqlRowAccessor.getBigDecimal("PRIX") != null) {
1894 
                        result = sqlRowAccessor.getBigDecimal("PRIX");
1895 
                        // remise = null;
19 ilm 1896 
                    }
93 ilm 1897 
                    // else {
1898 
                    // result = null;
1899 
                    // remise = sqlRowAccessor.getBigDecimal("POURCENT_REMISE");
1900 
                    // }
1901 
                }
1902 
            }
1903 
        }
94 ilm 1904 
        if (result == null && rowA != null && !rowA.isUndefined() && rowA.getTable().getDBRoot().contains("ARTICLE_PRIX_MIN_VENTE")) {
93 ilm 1905 
            Collection<? extends SQLRowAccessor> col = rowA.getReferentRows(rowA.getTable().getTable("ARTICLE_PRIX_MIN_VENTE"));
1906 
            int quantite = 0;
1907 
            BigDecimal b = row.getBigDecimal("QTE_UNITAIRE");
1908 
            int q = row.getInt("QTE");
1909 
            BigDecimal qteTotal = b.multiply(new BigDecimal(q), DecimalUtils.HIGH_PRECISION);
19 ilm 1910 
 
93 ilm 1911 
            for (SQLRowAccessor sqlRowAccessor : col) {
1912 
 
1913 
                int qteMinVente = sqlRowAccessor.getInt("QTE");
1914 
                if (CompareUtils.compare(qteMinVente, qteTotal) <= 0 && CompareUtils.compare(qteMinVente, quantite) > 0) {
1915 
                    quantite = qteMinVente;
1916 
                    if (sqlRowAccessor.getBigDecimal("PRIX") != null) {
1917 
                        result = sqlRowAccessor.getBigDecimal("PRIX");
19 ilm 1918 
                    }
1919 
                }
1920 
            }
18 ilm 1921 
        }
94 ilm 1922 
 
1923 
        BigDecimal remise = null;
1924 
 
1925 
        if (rowA != null && !rowA.isUndefined() && rowA.getTable().getDBRoot().contains("TARIF_QUANTITE")) {
1926 
            Collection<? extends SQLRowAccessor> col = rowA.getReferentRows(rowA.getTable().getTable("TARIF_QUANTITE"));
1927 
            BigDecimal quantite = BigDecimal.ZERO;
1928 
            BigDecimal b = row.getBigDecimal("QTE_UNITAIRE");
1929 
            int q = row.getInt("QTE");
1930 
            BigDecimal qteTotal = b.multiply(new BigDecimal(q), DecimalUtils.HIGH_PRECISION);
1931 
 
1932 
            for (SQLRowAccessor sqlRowAccessor : col) {
1933 
 
1934 
                BigDecimal bigDecimal = sqlRowAccessor.getBigDecimal("QUANTITE");
1935 
                if (CompareUtils.compare(bigDecimal, qteTotal) <= 0 && CompareUtils.compare(bigDecimal, quantite) > 0) {
1936 
                    quantite = bigDecimal;
1937 
                    if (sqlRowAccessor.getBigDecimal("PRIX_METRIQUE_VT_1") != null) {
1938 
                        result = sqlRowAccessor.getBigDecimal("PRIX_METRIQUE_VT_1");
1939 
                        remise = null;
1940 
                    } else {
1941 
                        result = null;
1942 
                        remise = sqlRowAccessor.getBigDecimal("POURCENT_REMISE");
1943 
                    }
1944 
                }
1945 
            }
1946 
            if (!col.isEmpty() && result == null && remise == null) {
1947 
                result = rowA.getBigDecimal("PRIX_METRIQUE_VT_1");
1948 
            }
1949 
        }
1950 
        int index = getRowValuesTable().getRowValuesTableModel().row2index(row);
1951 
        if (result == null && remise == null) {
93 ilm 1952 
            // getRowValuesTable().getRowValuesTableModel().putValue(BigDecimal.ZERO, index,
1953 
            // "POURCENT_REMISE");
1954 
            return (fromCompletion ? null : row.getObject("PRIX_METRIQUE_VT_1"));
1955 
        } else {
1956 
            if (result != null) {
1957 
                // getRowValuesTable().getRowValuesTableModel().putValue(BigDecimal.ZERO, index,
1958 
                // "POURCENT_REMISE");
1959 
                return result;
1960 
            } else {
94 ilm 1961 
                getRowValuesTable().getRowValuesTableModel().putValue(remise, index, "POURCENT_REMISE");
93 ilm 1962 
                return row.getBigDecimal("PRIX_METRIQUE_VT_1");
1963 
            }
1964 
        }
1965 
 
18 ilm 1966 
    }
93 ilm 1967 
 
1968 
    @Override
1969 
    protected void setModel(RowValuesTableModel model) {
1970 
        super.setModel(model);
1971 
        model.addTableModelListener(new TableModelListener() {
1972 
 
1973 
            @Override
1974 
            public void tableChanged(TableModelEvent e) {
1975 
 
1976 
                calculTarifNomenclature();
1977 
 
1978 
            }
1979 
        });
1980 
    }
94 ilm 1981 
 
1982 
    private void dropInTable(DropTargetDropEvent dtde, final AutoCompletionManager autoM) {
1983 
        dtde.acceptDrop(DnDConstants.ACTION_COPY_OR_MOVE);
1984 
        Transferable t = dtde.getTransferable();
1985 
        try {
1986 
 
1987 
            List<Tuple3<Double, String, String>> articles = new ArrayList<Tuple3<Double, String, String>>();
1988 
            if (t.isDataFlavorSupported(DataFlavor.javaFileListFlavor)) {
1989 
                List<File> fileList = (List<File>) t.getTransferData(DataFlavor.javaFileListFlavor);
1990 
                final DataImporter importer = new DataImporter(getSQLElement().getTable());
1991 
                final File file = fileList.get(0);
1992 
                if (file.getName().endsWith(".ods") || file.getName().endsWith(".xls")) {
1993 
                    ArrayTableModel m = importer.createModelFrom(file);
1994 
                    for (int i = 0; i < m.getRowCount(); i++) {
1995 
                        List<Object> l = m.getLineValuesAt(i);
1996 
                        if (l.size() > 1) {
1997 
                            if (l.get(0) == null || l.get(0).toString().length() == 0) {
1998 
                                break;
1999 
                            }
2000 
                            Double qte = ((Number) l.get(1)).doubleValue();
2001 
                            String code = "";
2002 
                            if (l.get(0) instanceof Number) {
2003 
                                code = String.valueOf(((Number) l.get(0)).intValue());
2004 
                            } else {
2005 
                                code = l.get(0).toString();
2006 
                            }
2007 
                            String nom = "";
2008 
                            if (l.size() > 2) {
2009 
                                nom = (String) l.get(2);
2010 
                            }
2011 
                            if (qte > 0) {
2012 
                                articles.add(Tuple3.create(qte, code, nom));
2013 
                            }
2014 
                        }
2015 
                    }
2016 
                } else {
2017 
                    JOptionPane.showMessageDialog(null, "Les formats de fichiers pris en charge sont ods et xls!");
2018 
                }
2019 
            } else if (t.isDataFlavorSupported(DataFlavor.stringFlavor)) {
2020 
                final String transferData = (String) t.getTransferData(DataFlavor.stringFlavor);
2021 
                List<String> l = StringUtils.fastSplitTrimmed(transferData, '\n');
2022 
                for (String string : l) {
2023 
                    List<String> line = StringUtils.fastSplitTrimmed(string, '\t');
2024 
                    if (line.size() >= 2) {
2025 
                        Double qte = Double.valueOf(line.get(1));
2026 
                        String code = (line.get(0) == null ? "" : line.get(0).toString());
2027 
                        String nom = "";
2028 
                        if (line.size() > 2) {
2029 
                            nom = (String) line.get(2);
2030 
                        }
2031 
                        if (qte > 0) {
2032 
                            articles.add(Tuple3.create(qte, code, nom));
2033 
                        }
2034 
                    } else {
2035 
                        break;
2036 
                    }
2037 
                }
2038 
            }
2039 
            if (articles.size() > 0) {
2040 
                insertFromDrop(articles, autoM);
2041 
                for (Tuple3<Double, String, String> tuple3 : articles) {
2042 
                    System.err.println("ADD LINE " + tuple3);
2043 
                }
2044 
            }
2045 
        } catch (UnsupportedFlavorException e) {
2046 
            // TODO Auto-generated catch block
2047 
            e.printStackTrace();
2048 
        } catch (IOException e) {
2049 
            // TODO Auto-generated catch block
2050 
            e.printStackTrace();
2051 
        }
2052 
 
2053 
        // dtde.acceptDrop(DnDConstants.ACTION_COPY_OR_MOVE);
2054 
        // Transferable t = dtde.getTransferable();
2055 
        // List fileList = (List)t.getTransferData(DataFlavor.javaFileListFlavor);
2056 
        // File f = (File)fileList.get(0);
2057 
        // table.setValueAt(f.getAbsolutePath(), row, column);
2058 
        // table.setValueAt(f.length(), row, column+1);
2059 
    }
2060 
 
142 ilm 2061 
    protected void insertFromDrop(List<Tuple3<Double, String, String>> articles, AutoCompletionManager m) {
94 ilm 2062 
 
2063 
        List<String> code = new ArrayList<String>(articles.size());
2064 
        for (int i = articles.size() - 1; i >= 0; i--) {
2065 
 
2066 
            Tuple3<Double, String, String> tuple = articles.get(i);
2067 
            code.add(tuple.get1());
2068 
        }
2069 
        SQLSelect sel = new SQLSelect();
2070 
        final SQLTable articleTable = getSQLElement().getTable().getForeignTable("ID_ARTICLE");
2071 
        sel.addSelectStar(articleTable);
2072 
        sel.setWhere(new Where(articleTable.getField("CODE"), code));
2073 
        List<SQLRow> matchCode = SQLRowListRSH.execute(sel);
2074 
        Map<String, SQLRow> mapCode = new HashMap<String, SQLRow>();
2075 
        for (SQLRow sqlRow : matchCode) {
2076 
            mapCode.put(sqlRow.getString("CODE"), sqlRow);
2077 
        }
2078 
 
142 ilm 2079 
        int rowCount = getRowValuesTable().getRowValuesTableModel().getRowCount();
2080 
        Map<Integer, Integer> mapRows = new HashMap<Integer, Integer>();
2081 
        for (int i = 0; i < rowCount; i++) {
2082 
            SQLRowValues rowVals = getRowValuesTable().getRowValuesTableModel().getRowValuesAt(i);
2083 
            if (rowVals.getObject("ID_ARTICLE") != null && !rowVals.isForeignEmpty("ID_ARTICLE")) {
2084 
                mapRows.put(rowVals.getForeignID("ID_ARTICLE"), i);
2085 
            }
2086 
        }
2087 
 
2088 
        Set<String> fieldsFrom = m.getFieldsFrom();
2089 
        fieldsFrom.remove("POURCENT_REMISE");
94 ilm 2090 
        for (int i = articles.size() - 1; i >= 0; i--) {
2091 
 
2092 
            Tuple3<Double, String, String> tuple = articles.get(i);
2093 
 
2094 
            SQLRow article = mapCode.get(tuple.get1());
142 ilm 2095 
            String fieldQte = "QTE";
94 ilm 2096 
 
142 ilm 2097 
            if (article != null && mapRows.containsKey(article.getID())) {
2098 
                Integer index = mapRows.get(article.getID());
2099 
                SQLRowValues rowVals = getRowValuesTable().getRowValuesTableModel().getRowValuesAt(index);
2100 
                if (rowVals.getTable().getName().equals("BON_DE_LIVRAISON_ELEMENT")) {
2101 
                    fieldQte = "QTE_LIVREE";
2102 
                }
2103 
                getRowValuesTable().getRowValuesTableModel().putValue(rowVals.getInt(fieldQte) + 1, index, fieldQte);
94 ilm 2104 
            } else {
142 ilm 2105 
                final SQLRowValues row2Insert = new SQLRowValues(getRowValuesTable().getRowValuesTableModel().getDefaultRowValues());
94 ilm 2106 
 
142 ilm 2107 
                // Completion depuis l'article trouvé
2108 
                if (article != null) {
2109 
                    m.fillRowValues(article, fieldsFrom, row2Insert);
2110 
                    // Fill prix total
2111 
                    row2Insert.put("ID_ARTICLE", article.getID());
2112 
                    row2Insert.put("CODE", article.getObject("CODE"));
2113 
                    row2Insert.put("NOM", article.getObject("NOM"));
2114 
                } else {
2115 
                    row2Insert.put("CODE", tuple.get1());
2116 
                    row2Insert.put("NOM", tuple.get2());
2117 
                }
94 ilm 2118 
 
142 ilm 2119 
                row2Insert.put(fieldQte, Math.round(tuple.get0().floatValue()));
2120 
                if (row2Insert.getTable().getName().equals("BON_DE_LIVRAISON_ELEMENT")) {
2121 
                    row2Insert.put("QTE_LIVREE", Math.round(tuple.get0().floatValue()));
2122 
                }
2123 
                row2Insert.put("POURCENT_REMISE", BigDecimal.ZERO);
2124 
                row2Insert.put("MONTANT_REMISE", BigDecimal.ZERO);
94 ilm 2125 
 
142 ilm 2126 
                row2Insert.put("PV_HT", row2Insert.getObject("PRIX_METRIQUE_VT_1"));
2127 
                //
2128 
                final BigDecimal resultTotalHT = row2Insert.getBigDecimal("PV_HT").multiply(new BigDecimal(row2Insert.getInt(fieldQte)));
2129 
                row2Insert.put("T_PV_HT", resultTotalHT);
94 ilm 2130 
 
142 ilm 2131 
                Float resultTaux = TaxeCache.getCache().getTauxFromId(row2Insert.getForeignID("ID_TAXE"));
94 ilm 2132 
 
142 ilm 2133 
                if (resultTaux == null) {
2134 
                    SQLRow rowTax = TaxeCache.getCache().getFirstTaxe();
2135 
                    resultTaux = rowTax.getFloat("TAUX");
2136 
                }
94 ilm 2137 
 
142 ilm 2138 
                float taux = (resultTaux == null) ? 0.0F : resultTaux.floatValue();
94 ilm 2139 
 
142 ilm 2140 
                BigDecimal r = resultTotalHT.multiply(BigDecimal.valueOf(taux).movePointLeft(2).add(BigDecimal.ONE), DecimalUtils.HIGH_PRECISION);
94 ilm 2141 
 
142 ilm 2142 
                row2Insert.put("T_PV_TTC", r);
2143 
                // row2Insert.put("ID_STYLE", allStyleByName.get("Composant"));
2144 
                getRowValuesTable().getRowValuesTableModel().addRowAt(0, row2Insert);
2145 
            }
94 ilm 2146 
        }
2147 
    }
18 ilm 2148 
}