OpenConcerto

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

svn://code.openconcerto.org/openconcerto

Rev

Rev 151 | Rev 174 | 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.generationEcritures;
15
 
16
import org.openconcerto.erp.config.ComptaPropsConfiguration;
83 ilm 17
import org.openconcerto.erp.core.common.element.BanqueSQLElement;
151 ilm 18
import org.openconcerto.erp.core.common.element.NumerotationAutoSQLElement;
67 ilm 19
import org.openconcerto.erp.core.common.ui.TotalCalculator;
83 ilm 20
import org.openconcerto.erp.core.finance.accounting.element.ComptePCESQLElement;
21
import org.openconcerto.erp.core.finance.accounting.element.JournalSQLElement;
156 ilm 22
import org.openconcerto.erp.generationDoc.OOXMLCache;
83 ilm 23
import org.openconcerto.erp.generationEcritures.provider.AnalytiqueProvider;
24
import org.openconcerto.erp.generationEcritures.provider.AnalytiqueProviderManager;
73 ilm 25
import org.openconcerto.erp.preferences.DefaultNXProps;
80 ilm 26
import org.openconcerto.erp.preferences.GestionPieceCommercialePanel;
18 ilm 27
import org.openconcerto.sql.Configuration;
151 ilm 28
import org.openconcerto.sql.element.SQLElement;
29
import org.openconcerto.sql.model.SQLBackgroundTableCache;
156 ilm 30
import org.openconcerto.sql.model.SQLBackgroundTableCacheItem;
18 ilm 31
import org.openconcerto.sql.model.SQLBase;
32
import org.openconcerto.sql.model.SQLRow;
90 ilm 33
import org.openconcerto.sql.model.SQLRowAccessor;
151 ilm 34
import org.openconcerto.sql.model.SQLRowListRSH;
18 ilm 35
import org.openconcerto.sql.model.SQLRowValues;
156 ilm 36
import org.openconcerto.sql.model.SQLRowValuesCluster.StoreMode;
18 ilm 37
import org.openconcerto.sql.model.SQLSelect;
38
import org.openconcerto.sql.model.SQLTable;
151 ilm 39
import org.openconcerto.sql.model.Where;
18 ilm 40
import org.openconcerto.sql.users.UserManager;
41
import org.openconcerto.utils.ExceptionHandler;
42
 
61 ilm 43
import java.math.BigDecimal;
142 ilm 44
import java.math.RoundingMode;
18 ilm 45
import java.sql.SQLException;
156 ilm 46
import java.util.Arrays;
83 ilm 47
import java.util.Collection;
18 ilm 48
import java.util.Date;
49
import java.util.HashMap;
50
import java.util.List;
51
import java.util.Map;
52
 
80 ilm 53
import javax.swing.JOptionPane;
18 ilm 54
import javax.swing.SwingUtilities;
55
 
149 ilm 56
import com.ibm.icu.text.SimpleDateFormat;
57
 
18 ilm 58
/**
59
 * Generation des ecritures comptables, permet l'ajout d'ecriture, la creation des mouvements
60
 *
61
 * @author Administrateur
62
 *
63
 */
64
public class GenerationEcritures {
65
 
66
    protected static final SQLBase base = ((ComptaPropsConfiguration) Configuration.getInstance()).getSQLBaseSociete();
67 ilm 67
    protected static final SQLTable compteTable = base.getTable("COMPTE_PCE");
68
    protected static final SQLTable journalTable = base.getTable("JOURNAL");
69
    protected static final SQLTable ecritureTable = base.getTable("ECRITURE");
70
    protected static final SQLTable pieceTable = base.getTable("PIECE");
80 ilm 71
    protected static final SQLTable mouvementTable = base.getTable("MOUVEMENT");
18 ilm 72
 
73
    protected int idMvt;
74
    protected int idPiece;
75
 
76
    // Date d'ecriture
77
    protected Date date;
78
 
79
    // Libelle de l'ecriture
80
    protected String nom;
81
 
93 ilm 82
    private SQLRow rowAnalytiqueSource;
83
 
18 ilm 84
    // Map contenant les valeurs pour la SQLRowValues de la table Ecritures à ajouter
149 ilm 85
    protected final Map<String, Object> mEcritures = new HashMap<String, Object>();
18 ilm 86
 
149 ilm 87
    public void putValue(String field, Object value) {
88
        mEcritures.put(field, value);
89
    }
93 ilm 90
 
91
    public void setRowAnalytiqueSource(SQLRow rowAnalytiqueSource) {
92
        this.rowAnalytiqueSource = rowAnalytiqueSource;
93
    }
94
 
95
    public SQLRow getRowAnalytiqueSource() {
96
        return this.rowAnalytiqueSource;
97
    }
98
 
156 ilm 99
    private Date dDebEx = null;
100
    private Date dCloture = null;
101
 
18 ilm 102
    /**
103
     * Ajout d'une écriture et maj des totaux du compte associé
104
     *
105
     * @return Id de l'ecriture crée
106
     * @throws IllegalArgumentException
107
     */
83 ilm 108
    synchronized public SQLRow ajoutEcriture() throws IllegalArgumentException {
18 ilm 109
 
110
        long debit = ((Long) this.mEcritures.get("DEBIT")).longValue();
111
        long credit = ((Long) this.mEcritures.get("CREDIT")).longValue();
112
 
113
        // Report des valeurs pour accelerer les IListes
114
        Number n = (Number) this.mEcritures.get("ID_JOURNAL");
115
        if (n != null) {
156 ilm 116
            final SQLBackgroundTableCacheItem cacheForTableJrnl = SQLBackgroundTableCache.getInstance().getCacheForTable(journalTable);
117
            SQLRow rowJrnl = cacheForTableJrnl.getRowFromId(n.intValue());
83 ilm 118
            if (rowJrnl == null) {
119
                throw new IllegalArgumentException("Le journal qui a pour ID " + n + " a été archivé.");
120
            }
18 ilm 121
            this.mEcritures.put("JOURNAL_NOM", rowJrnl.getString("NOM"));
122
            this.mEcritures.put("JOURNAL_CODE", rowJrnl.getString("CODE"));
123
        }
124
 
125
        Number n2 = (Number) this.mEcritures.get("ID_COMPTE_PCE");
126
        if (n2 != null) {
156 ilm 127
            final SQLBackgroundTableCacheItem cacheForTableCpt = SQLBackgroundTableCache.getInstance().getCacheForTable(compteTable);
128
            SQLRow rowCpt = cacheForTableCpt.getRowFromId(n2.intValue());
129
            if (rowCpt == null) {
130
                rowCpt = compteTable.getRow(n2.intValue());
131
            }
18 ilm 132
            this.mEcritures.put("COMPTE_NUMERO", rowCpt.getString("NUMERO"));
133
            this.mEcritures.put("COMPTE_NOM", rowCpt.getString("NOM"));
134
        }
135
 
136
        if (debit != 0 && credit != 0) {
137
            // ExceptionHandler.handle("Le débit et le crédit ne peuvent pas être tous les 2
138
            // différents de 0. Debit : " + debit + " Credit : " + credit);
139
            throw new IllegalArgumentException("Le débit et le crédit ne peuvent pas être tous les 2 différents de 0. Debit : " + debit + " Credit : " + credit);
140
            // return -1;
141
        }
142
 
143
        if (debit < 0) {
144
            credit = -debit;
145
            debit = 0;
146
        }
147
        if (credit < 0) {
148
            debit = -credit;
149
            credit = 0;
150
        }
151
 
152
        this.mEcritures.put("DEBIT", Long.valueOf(debit));
153
        this.mEcritures.put("CREDIT", Long.valueOf(credit));
154
 
155
        // TODO checker que les ecritures sont entrees à une date correcte
156
        Date d = (Date) this.mEcritures.get("DATE");
157
 
156 ilm 158
        if (this.dDebEx == null) {
159
            SQLTable tableExercice = Configuration.getInstance().getBase().getTable("EXERCICE_COMMON");
160
            SQLRow rowSociete = ((ComptaPropsConfiguration) Configuration.getInstance()).getRowSociete();
161
            SQLRow rowExercice = tableExercice.getRow(rowSociete.getInt("ID_EXERCICE_COMMON"));
162
            this.dDebEx = (Date) rowExercice.getObject("DATE_DEB");
163
            this.dCloture = (Date) rowExercice.getObject("DATE_CLOTURE");
164
        }
18 ilm 165
 
166
        if (dCloture != null) {
167
            if (dCloture.after(d)) {
149 ilm 168
                final String error = "Impossible de générer l'écriture pour la date " + SimpleDateFormat.getDateInstance(SimpleDateFormat.FULL).format(d)
156 ilm 169
                        + ". Cette date est antérieure à la date de clôture (" + SimpleDateFormat.getDateInstance(SimpleDateFormat.FULL).format(dCloture) + ")";
149 ilm 170
                throw new IllegalArgumentException(error);
18 ilm 171
            }
172
        } else {
173
            if (dDebEx.after(d)) {
149 ilm 174
                final String error = "Impossible de générer l'écriture pour la date " + SimpleDateFormat.getDateInstance(SimpleDateFormat.FULL).format(d)
175
                        + ". Cette date est antérieure à la date de début d'exercice (" + SimpleDateFormat.getDateInstance(SimpleDateFormat.FULL).format(dDebEx) + ")";
176
                throw new IllegalArgumentException(error);
18 ilm 177
            }
178
        }
179
 
180
        final SQLRowValues valEcriture = new SQLRowValues(GenerationEcritures.ecritureTable, this.mEcritures);
181
        valEcriture.put("IDUSER_CREATE", UserManager.getInstance().getCurrentUser().getId());
182
 
183
        try {
156 ilm 184
            // ajout de l'ecriture
185
            // SQLRow ecritureRow = valEcriture.insert();
186
            SQLRow ecritureRow = valEcriture.getGraph().store(StoreMode.INSERT, false).getStoredRow(valEcriture);
93 ilm 187
 
156 ilm 188
            // TODO Analytique
189
            addAssocAnalytiqueFromProvider(ecritureRow, this.rowAnalytiqueSource);
190
            return ecritureRow;
191
 
18 ilm 192
        } catch (SQLException e) {
193
            System.err.println("Error insert row in " + GenerationEcritures.ecritureTable.getName() + " : " + e);
194
            final SQLException eFinal = e;
195
            SwingUtilities.invokeLater(new Runnable() {
196
                public void run() {
197
                    ExceptionHandler.handle("Erreur lors de la génération des écritures.", eFinal);
198
                }
199
            });
200
            e.printStackTrace();
201
        }
202
 
83 ilm 203
        return null;
18 ilm 204
    }
205
 
83 ilm 206
    private static SQLTable tableAssoc = null;
207
    private static SQLTable tablePoste = Configuration.getInstance().getDirectory().getElement("POSTE_ANALYTIQUE").getTable();
18 ilm 208
 
83 ilm 209
    public void addAssocAnalytique(SQLRow rowEcr, int idPoste) throws SQLException {
210
        if (tablePoste.getUndefinedID() == idPoste) {
211
            return;
212
        }
213
        if (tableAssoc == null) {
214
            tableAssoc = Configuration.getInstance().getDirectory().getElement("ASSOCIATION_ANALYTIQUE").getTable();
215
        }
216
        SQLRowValues rowVals = new SQLRowValues(tableAssoc);
217
        rowVals.put("ID_POSTE_ANALYTIQUE", idPoste);
218
        rowVals.put("POURCENT", 100.0);
219
        rowVals.put("ID_ECRITURE", rowEcr.getID());
220
        rowVals.put("MONTANT", rowEcr.getLong("DEBIT") - rowEcr.getLong("CREDIT"));
221
        rowVals.commit();
222
 
223
    }
224
 
225
    public void addAssocAnalytiqueFromProvider(SQLRow rowEcr, SQLRow rowSource) throws SQLException {
226
 
93 ilm 227
        String numeroCpt = rowEcr.getString("COMPTE_NUMERO");
228
        if (rowSource != null && !rowSource.getTable().getName().equalsIgnoreCase("SAISIE_KM") && (numeroCpt.startsWith("6") || numeroCpt.startsWith("7"))) {
229
            for (SQLRow axe : AnalytiqueCache.getCache().getAxes()) {
230
                // TODO Check if total = 100%
231
                int assoc = 0;
232
                Collection<AnalytiqueProvider> l = AnalytiqueProviderManager.getAll();
233
                for (AnalytiqueProvider analytiqueProvider : l) {
234
                    List<SQLRow> result = analytiqueProvider.addAssociation(axe, rowEcr, rowSource);
235
                    if (result != null) {
236
                        assoc += result.size();
237
                    }
238
                }
239
 
240
                if (assoc == 0) {
241
                    SQLRow poste = AnalytiqueCache.getCache().getDefaultPoste(axe.getID());
242
                    if (poste != null) {
243
                        if (tableAssoc == null) {
244
                            tableAssoc = Configuration.getInstance().getDirectory().getElement("ASSOCIATION_ANALYTIQUE").getTable();
245
                        }
246
                        SQLRowValues rowVals = new SQLRowValues(tableAssoc);
247
                        rowVals.put("ID_POSTE_ANALYTIQUE", poste.getID());
248
                        rowVals.put("POURCENT", 100.0);
249
                        rowVals.put("ID_ECRITURE", rowEcr.getID());
250
                        rowVals.put("MONTANT", rowEcr.getLong("DEBIT") - rowEcr.getLong("CREDIT"));
251
                        rowVals.put("GESTION_AUTO", Boolean.TRUE);
252
                        rowVals.commit();
253
                    }
254
                }
255
            }
83 ilm 256
        }
257
    }
258
 
18 ilm 259
    /**
260
     * Génération d'un groupe d'écritures respectant la partie double.
261
     *
262
     * @param l liste de SQLRowValues d'ecritures
263
     */
264
    public void genereEcritures(List<SQLRowValues> l) {
265
 
266
        if (l == null) {
267
            return;
268
        }
269
        try {
270
 
271
            // Test de validité des écritures
272
            for (SQLRowValues rowVals : l) {
273
                checkDateValide(rowVals);
274
                checkDebitCreditValide(rowVals);
275
            }
276
            if (isSoldeNul(l)) {
277
 
278
                for (SQLRowValues rowVals : l) {
279
 
280
                    rowVals.put("IDUSER_CREATE", UserManager.getInstance().getCurrentUser().getId());
281
 
282
                    // ajout de l'ecriture
283
                    rowVals.insert();
284
                }
285
            } else {
286
                throw new IllegalArgumentException("La partie double n'est pas respectée. Impossible de générer les écritures comptables.");
287
            }
288
        } catch (final Exception e) {
289
            e.printStackTrace();
290
            SwingUtilities.invokeLater(new Runnable() {
291
                public void run() {
292
                    // TODO Auto-generated method stub
293
                    ExceptionHandler.handle("", e);
294
                }
295
            });
296
        }
297
    }
298
 
299
    private void checkDateValide(SQLRowValues rowVals) throws Exception {
300
        Date d = (Date) rowVals.getObject("DATE");
301
 
302
        SQLTable tableExercice = Configuration.getInstance().getBase().getTable("EXERCICE_COMMON");
303
        SQLRow rowSociete = ((ComptaPropsConfiguration) Configuration.getInstance()).getRowSociete();
304
        SQLRow rowExercice = tableExercice.getRow(rowSociete.getInt("ID_EXERCICE_COMMON"));
305
        Date dDebEx = (Date) rowExercice.getObject("DATE_DEB");
306
 
307
        Date dCloture = (Date) rowExercice.getObject("DATE_CLOTURE");
308
 
309
        if (dCloture != null) {
310
            if (dCloture.after(d)) {
311
                System.err.println("Impossible de générer l'écriture pour la date " + d + ". Cette période est cloturée.");
312
                throw new Exception("Impossible de générer l'écriture pour la date " + d + ". Cette période est cloturée.");
313
                // return -1;
314
            }
315
        } else {
316
            if (dDebEx.after(d)) {
317
                System.err.println("Impossible de générer l'écriture pour la date " + d + ". Cette période est cloturée.");
318
                throw new Exception("Impossible de générer l'écriture pour la date " + d + ". Cette période est cloturée.");
319
            }
320
        }
321
    }
322
 
323
    private void checkDebitCreditValide(SQLRowValues rowVals) throws Exception {
324
        long debit = rowVals.getLong("DEBIT");
325
        long credit = rowVals.getLong("CREDIT");
326
 
327
        if (debit != 0 && credit != 0) {
328
            // ExceptionHandler.handle("Le débit et le crédit ne peuvent pas être tous les 2
329
            // différents de 0. Debit : " + debit + " Credit : " + credit);
330
            throw new Exception("Le débit et le crédit ne peuvent pas être tous les 2 différents de 0. Debit : " + debit + " Credit : " + credit);
331
            // return -1;
332
        }
333
 
334
        if (debit < 0) {
335
            credit = -debit;
336
            debit = 0;
337
        }
338
        if (credit < 0) {
339
            debit = -credit;
340
            credit = 0;
341
        }
342
 
343
        rowVals.put("DEBIT", Long.valueOf(debit));
344
        rowVals.put("CREDIT", Long.valueOf(credit));
345
    }
346
 
347
    private boolean isSoldeNul(List<SQLRowValues> l) {
348
 
349
        long debit = 0;
350
        long credit = 0;
351
        for (SQLRowValues rowVals : l) {
352
            debit += rowVals.getLong("DEBIT");
353
            credit += rowVals.getLong("CREDIT");
354
        }
355
        return (debit - credit == 0);
356
    }
357
 
358
    /**
359
     * Crée un mouvement et une nouvelle piecé associée
360
     *
361
     * @param source
362
     * @param idSource
363
     * @param idPere
364
     * @param nomPiece
365
     * @return id d'un nouveau mouvement
73 ilm 366
     * @throws SQLException
18 ilm 367
     */
73 ilm 368
    synchronized public int getNewMouvement(String source, int idSource, int idPere, SQLRowValues rowValsPiece) throws SQLException {
369
        SQLRow rowPiece = rowValsPiece.insert();
370
        return getNewMouvement(source, idSource, idPere, rowPiece.getID());
18 ilm 371
 
372
    }
373
 
73 ilm 374
    synchronized public int getNewMouvement(String source, int idSource, int idPere, String nomPiece) throws SQLException {
67 ilm 375
 
376
        SQLRowValues rowValsPiece = new SQLRowValues(pieceTable);
377
        rowValsPiece.put("NOM", nomPiece);
378
        return getNewMouvement(source, idSource, idPere, rowValsPiece);
379
    }
380
 
156 ilm 381
    protected TotalCalculator getValuesFromElement(SQLRow row, SQLTable foreign, BigDecimal portHT, SQLRow rowTVAPort, BigDecimal fraisDocHT, SQLRow rowTVAFraisDoc, SQLTable tableEchantillon) {
382
        return getValuesFromElement(false, false, "T_PV_HT", row, foreign, portHT, rowTVAPort, fraisDocHT, rowTVAFraisDoc, tableEchantillon, null);
80 ilm 383
    }
67 ilm 384
 
156 ilm 385
    protected TotalCalculator getValuesFromElement(boolean intra, boolean achat, String fieldTotalHT, SQLRow row, SQLTable foreign, BigDecimal portHT, SQLRow rowTVAPort, BigDecimal fraisDocHT,
386
            SQLRow rowTVAFraisDoc, SQLTable tableEchantillon, SQLRow defaultCompte) {
80 ilm 387
 
156 ilm 388
        final SQLRow tiers;
389
        if (achat) {
390
            tiers = row.getForeign("ID_FOURNISSEUR");
391
        } else {
392
            tiers = row.getForeign("ID_CLIENT");
393
        }
394
 
395
        SQLRowAccessor rowCatCompta = null;
396
        if (tiers.getObject("ID_CATEGORIE_COMPTABLE") != null && !tiers.isForeignEmpty("ID_CATEGORIE_COMPTABLE")) {
397
            rowCatCompta = tiers.getForeign("ID_CATEGORIE_COMPTABLE");
398
        }
399
        TotalCalculator calc = new TotalCalculator("T_PA_HT", fieldTotalHT, null, achat, defaultCompte, rowCatCompta);
142 ilm 400
        calc.setIntraComm(intra);
156 ilm 401
 
73 ilm 402
        String val = DefaultNXProps.getInstance().getStringProperty("ArticleService");
93 ilm 403
        Boolean bServiceActive = Boolean.valueOf(val);
404
 
73 ilm 405
        calc.setServiceActive(bServiceActive != null && bServiceActive);
156 ilm 406
 
407
        SQLBackgroundTableCacheItem cacheCompte = SQLBackgroundTableCache.getInstance().getCacheForTable(compteTable);
90 ilm 408
        if (row.getTable().contains("ID_COMPTE_PCE_SERVICE") && !row.isForeignEmpty("ID_COMPTE_PCE_SERVICE")) {
156 ilm 409
            SQLRowAccessor serviceCompte = cacheCompte.getRowFromId(row.getForeignID("ID_COMPTE_PCE_SERVICE"));
410
            if (serviceCompte != null && !serviceCompte.isUndefined()) {
90 ilm 411
                calc.setRowDefaultCptService(serviceCompte);
412
            }
413
        }
132 ilm 414
        if (row.getTable().contains("ID_COMPTE_PCE_VENTE") && !row.isForeignEmpty("ID_COMPTE_PCE_VENTE")) {
156 ilm 415
            SQLRowAccessor produitCompte = cacheCompte.getRowFromId(row.getForeignID("ID_COMPTE_PCE_VENTE"));
132 ilm 416
            if (!produitCompte.isUndefined()) {
417
                calc.setRowDefaultCptProduit(produitCompte);
418
            }
419
        }
67 ilm 420
        long remise = 0;
421
        BigDecimal totalAvtRemise = BigDecimal.ZERO;
156 ilm 422
        OOXMLCache cacheRefRows = new OOXMLCache();
423
        final List<? extends SQLRowAccessor> referentRows = cacheRefRows.getReferentRows(Arrays.asList(row), foreign);
67 ilm 424
        if (row.getTable().contains("REMISE_HT")) {
425
            remise = row.getLong("REMISE_HT");
426
            if (remise != 0) {
156 ilm 427
 
428
                // List<SQLRow> rows = row.getReferentRows(foreign);
429
                for (SQLRowAccessor sqlRow : referentRows) {
67 ilm 430
                    calc.addLine(sqlRow, sqlRow.getForeign("ID_ARTICLE"), 1, false);
431
                }
432
 
433
                if (tableEchantillon != null) {
434
                    List<SQLRow> rowsEch = row.getReferentRows(tableEchantillon);
435
                    for (SQLRow sqlRow : rowsEch) {
436
                        calc.addEchantillon((BigDecimal) sqlRow.getObject("T_PV_HT"), sqlRow.getForeign("ID_TAXE"));
437
                    }
438
                }
439
                calc.checkResult();
440
                totalAvtRemise = calc.getTotalHT();
441
            }
442
        }
443
 
444
        calc.initValues();
142 ilm 445
        long valRemiseHTReel = remise;
446
        if (row.getFields().contains("POURCENT_FACTURABLE") && row.getFields().contains("MONTANT_FACTURABLE")) {
447
            BigDecimal montantFact = row.getBigDecimal("MONTANT_FACTURABLE");
448
            BigDecimal percentFact = row.getBigDecimal("POURCENT_FACTURABLE");
67 ilm 449
 
142 ilm 450
            if (montantFact != null && montantFact.signum() > 0) {
451
                valRemiseHTReel = 0;
452
            } else if (percentFact != null && percentFact.signum() > 0) {
453
                valRemiseHTReel = percentFact.movePointLeft(2).multiply(new BigDecimal(remise)).setScale(0, RoundingMode.HALF_UP).longValue();
454
            }
455
 
456
        }
457
        calc.setRemise(valRemiseHTReel, totalAvtRemise);
458
 
156 ilm 459
        // List<SQLRow> rows = row.getReferentRows(foreign);
460
        for (int i = 0; i < referentRows.size(); i++) {
461
            SQLRowAccessor sqlRow = referentRows.get(i);
462
            calc.addLine(sqlRow, sqlRow.getForeign("ID_ARTICLE"), i, i == referentRows.size() - 1);
67 ilm 463
        }
464
 
465
        if (tableEchantillon != null) {
466
            List<SQLRow> rowsEch = row.getReferentRows(tableEchantillon);
467
            for (SQLRow sqlRow : rowsEch) {
468
                calc.addEchantillon((BigDecimal) sqlRow.getObject("T_PV_HT"), sqlRow.getForeign("ID_TAXE"));
469
            }
470
        }
471
        if (rowTVAPort != null && !rowTVAPort.isUndefined()) {
472
            SQLRowValues rowValsPort = new SQLRowValues(foreign);
149 ilm 473
            rowValsPort.put(achat ? "T_PA_HT" : "T_PV_HT", portHT);
67 ilm 474
            rowValsPort.put("QTE", 1);
73 ilm 475
            rowValsPort.put("ID_TAXE", rowTVAPort.getIDNumber());
94 ilm 476
 
477
            final SQLTable tablePrefCompte = Configuration.getInstance().getRoot().findTable("PREFS_COMPTE");
156 ilm 478
            final SQLRow rowPrefsCompte = SQLBackgroundTableCache.getInstance().getCacheForTable(tablePrefCompte).getRowFromId(2);
94 ilm 479
            SQLRow rowDefaultCptPort;
480
            if (rowTVAPort.getFloat("TAUX") > 0) {
156 ilm 481
                rowDefaultCptPort = cacheCompte.getRowFromId(rowPrefsCompte.getForeignID("ID_COMPTE_PCE_PORT_SOUMIS"));
94 ilm 482
                if (rowDefaultCptPort == null || rowDefaultCptPort.isUndefined()) {
483
                    try {
484
                        rowDefaultCptPort = ComptePCESQLElement.getRowComptePceDefault("PortVenteSoumisTVA");
485
                    } catch (Exception e) {
486
                        e.printStackTrace();
487
                    }
488
                }
489
            } else {
156 ilm 490
                rowDefaultCptPort = cacheCompte.getRowFromId(rowPrefsCompte.getForeignID("ID_COMPTE_PCE_PORT_NON_SOUMIS"));
94 ilm 491
                if (rowDefaultCptPort == null || rowDefaultCptPort.isUndefined()) {
492
                    try {
493
                        rowDefaultCptPort = ComptePCESQLElement.getRowComptePceDefault("PortVenteNonSoumisTVA");
494
                    } catch (Exception e) {
495
                        e.printStackTrace();
496
                    }
497
                }
498
            }
142 ilm 499
            final SQLRowValues rowValsArt = rowValsPort.putRowValues("ID_ARTICLE");
149 ilm 500
            rowValsArt.put(achat ? "ID_COMPTE_PCE_ACHAT" : "ID_COMPTE_PCE", rowDefaultCptPort.getID());
142 ilm 501
            rowValsArt.put("ID_TAXE_COMPLEMENTAIRE", null);
156 ilm 502
            rowValsArt.put("ID_FAMILLE_ARTICLE", null);
94 ilm 503
            calc.addLine(rowValsPort, rowValsPort.getForeign("ID_ARTICLE"), 1, false);
67 ilm 504
        }
156 ilm 505
 
506
        if (rowTVAFraisDoc != null && !rowTVAFraisDoc.isUndefined()) {
507
            // Frais documents
508
            SQLRowValues rowValsFraisDoc = new SQLRowValues(foreign);
509
            rowValsFraisDoc.put(achat ? "T_PA_HT" : "T_PV_HT", fraisDocHT);
510
            rowValsFraisDoc.put("QTE", 1);
511
            rowValsFraisDoc.put("ID_TAXE", rowTVAFraisDoc.getIDNumber());
512
            rowValsFraisDoc.put("SERVICE", Boolean.TRUE);
513
            rowValsFraisDoc.put("ID_FAMILLE_ARTICLE", null);
514
            calc.addLine(rowValsFraisDoc, null, 1, false);
515
        }
516
 
67 ilm 517
        calc.checkResult();
518
        return calc;
519
    }
520
 
18 ilm 521
    /**
522
     * Crée un nouveau mouvement associé à la piece d'id idPiece
523
     *
524
     * @param source
525
     * @param idSource
526
     * @param idPere
527
     * @param idPiece
528
     * @return id d'un nouveau mouvement
73 ilm 529
     * @throws SQLException
18 ilm 530
     */
73 ilm 531
    synchronized public int getNewMouvement(String source, int idSource, int idPere, int idPiece) throws SQLException {
18 ilm 532
 
533
        SQLTable mouvementTable = base.getTable("MOUVEMENT");
534
 
535
        // on calcule le nouveau numero de mouvement
73 ilm 536
        SQLSelect selNumMvt = new SQLSelect();
537
        selNumMvt.addSelect(mouvementTable.getField("NUMERO"), "MAX");
18 ilm 538
 
539
        String reqNumMvt = selNumMvt.asString();
73 ilm 540
        Object obNumMvt = base.getDataSource().executeScalar(reqNumMvt);
18 ilm 541
 
542
        int numMvt = 1;
73 ilm 543
        if (obNumMvt != null) {
544
            numMvt = Integer.parseInt(obNumMvt.toString());
18 ilm 545
        }
546
        numMvt++;
547
 
548
        // Creation du mouvement
549
        Map<String, Object> m = new HashMap<String, Object>();
550
        m.put("SOURCE", source);
551
        m.put("IDSOURCE", Integer.valueOf(idSource));
552
        m.put("ID_MOUVEMENT_PERE", Integer.valueOf(idPere));
553
        this.idPiece = idPiece;
554
        m.put("ID_PIECE", Integer.valueOf(idPiece));
555
        m.put("NUMERO", Integer.valueOf(numMvt));
556
 
557
        SQLRowValues val = new SQLRowValues(mouvementTable, m);
558
 
73 ilm 559
        if (val.getInvalid() == null) {
560
            SQLRow row = val.insert();
561
            this.idMvt = row.getID();
562
            this.mEcritures.put("ID_MOUVEMENT", Integer.valueOf(this.idMvt));
563
        } else {
564
            throw new IllegalStateException("Error in values for insert in table " + val.getTable().getName() + " : " + val.toString());
18 ilm 565
        }
566
 
567
        System.err.println("Numero de mouvement généré : " + numMvt);
568
 
569
        return this.idMvt;
570
    }
80 ilm 571
 
572
    protected void displayMvtNumber() {
573
        if (DefaultNXProps.getInstance().getBooleanValue(GestionPieceCommercialePanel.SHOW_MOUVEMENT_NUMBER, false)) {
574
            final int numero = mouvementTable.getRow(idMvt).getInt("NUMERO");
575
            SwingUtilities.invokeLater(new Runnable() {
576
                @Override
577
                public void run() {
578
                    JOptionPane.showMessageDialog(null, "N° de mouvement associé : " + numero);
579
                }
580
            });
581
        }
582
 
583
    }
584
 
83 ilm 585
    /**
586
     * Définit le journal en fonction de la banque sélectionnée
587
     *
588
     * @param sqlRow sqlRow contenant la foreignKey Banque
589
     */
590
    protected void fillJournalBanqueFromRow(SQLRow sqlRow) {
591
        this.mEcritures.put("ID_JOURNAL", JournalSQLElement.BANQUES);
592
        if (!sqlRow.isForeignEmpty("ID_" + BanqueSQLElement.TABLENAME)) {
593
            SQLRow rowBanque = sqlRow.getForeignRow("ID_" + BanqueSQLElement.TABLENAME);
594
            if (!rowBanque.isForeignEmpty("ID_JOURNAL")) {
595
                SQLRow rowJournal = rowBanque.getForeignRow("ID_JOURNAL");
596
                this.mEcritures.put("ID_JOURNAL", rowJournal.getID());
597
            }
598
        }
599
    }
600
 
601
    /**
602
     * Définit le compte en fonction de la banque sélectionnée
603
     *
604
     * @param sqlRow sqlRow contenant la foreignKey Banque
605
     * @throws Exception
606
     */
607
    protected void fillCompteBanqueFromRow(SQLRow sqlRow, String defaultProps, boolean achat) throws Exception {
142 ilm 608
        int idPce = -1;
609
        if (sqlRow.getTable().contains("ID_TYPE_REGLEMENT")) {
610
            idPce = sqlRow.getForeign("ID_TYPE_REGLEMENT").getInt("ID_COMPTE_PCE_" + (achat ? "FOURN" : "CLIENT"));
611
        } else {
612
            idPce = base.getTable("TYPE_REGLEMENT").getRow(2).getInt("ID_COMPTE_PCE_" + (achat ? "FOURN" : "CLIENT"));
613
        }
83 ilm 614
        if (idPce <= 1) {
615
            idPce = ComptePCESQLElement.getIdComptePceDefault(defaultProps);
616
        }
617
        if (!sqlRow.isForeignEmpty("ID_" + BanqueSQLElement.TABLENAME)) {
618
            SQLRow rowBanque = sqlRow.getForeignRow("ID_" + BanqueSQLElement.TABLENAME);
619
            if (!rowBanque.isForeignEmpty("ID_COMPTE_PCE")) {
620
                SQLRow rowCompteBanque = rowBanque.getForeignRow("ID_COMPTE_PCE");
621
                idPce = rowCompteBanque.getID();
622
            }
623
        }
624
 
625
        this.mEcritures.put("ID_COMPTE_PCE", idPce);
626
    }
151 ilm 627
 
628
    protected void lettrageAuto(List<Integer> pieceIDs, Date d) {
629
        final SQLTable tablePrefCompte = base.getTable("PREFS_COMPTE");
630
        final SQLRow rowPrefsCompte = SQLBackgroundTableCache.getInstance().getCacheForTable(tablePrefCompte).getRowFromId(2);
631
 
632
        if (rowPrefsCompte.getBoolean("AUTO_LETTRAGE")) {
633
            SQLSelect selEcr = new SQLSelect();
634
            SQLTable tableEcr = base.getTable("ECRITURE");
635
            selEcr.addSelect(tableEcr.getKey());
636
            selEcr.addSelect(tableEcr.getField("DEBIT"));
637
            selEcr.addSelect(tableEcr.getField("CREDIT"));
638
            selEcr.addSelect(tableEcr.getField("LETTRAGE"));
639
            SQLTable tableCpte = base.getTable("COMPTE_PCE");
640
            Where w2 = new Where(base.getTable("MOUVEMENT").getField("ID_PIECE"), pieceIDs);
641
            w2 = w2.and(new Where(tableEcr.getField("ID_MOUVEMENT"), "=", base.getTable("MOUVEMENT").getKey()));
642
            w2 = w2.and(new Where(tableEcr.getField("ID_COMPTE_PCE"), "=", tableCpte.getKey()));
643
            w2 = w2.and(new Where(tableCpte.getField("NUMERO"), "LIKE", "40%").or(new Where(tableCpte.getField("NUMERO"), "LIKE", "41%")));
644
            w2 = w2.and(new Where(tableEcr.getField("DATE_LETTRAGE"), "=", (Object) null));
645
            selEcr.setWhere(w2);
646
            long solde = -1;
647
            List<SQLRow> ecr = SQLRowListRSH.execute(selEcr);
648
            if (!ecr.isEmpty()) {
649
                solde = 0;
650
                for (SQLRow sqlRow2 : ecr) {
651
                    solde += sqlRow2.getLong("DEBIT");
652
                    solde -= sqlRow2.getLong("CREDIT");
653
                }
654
            }
655
            if (solde == 0) {
656
 
657
                String codeLettre = NumerotationAutoSQLElement.getNextCodeLettrage();
658
 
659
                for (SQLRow sqlRow2 : ecr) {
660
                    SQLRowValues rowValsEcr = sqlRow2.asRowValues();
661
                    // Lettrage
662
                    // On lettre ou relettre la ligne avec le code saisi
663
                    if (codeLettre.length() > 0) {
664
 
665
                        rowValsEcr.put("LETTRAGE", codeLettre);
666
                        rowValsEcr.put("DATE_LETTRAGE", d);
667
                        try {
668
                            rowValsEcr.update();
669
                        } catch (SQLException e1) {
670
 
671
                            e1.printStackTrace();
672
                        }
673
                    }
674
                    // Mise à jour du code de lettrage
675
                    SQLElement elt = Configuration.getInstance().getDirectory().getElement("NUMEROTATION_AUTO");
676
                    SQLRowValues rowVals = elt.getTable().getRow(2).createEmptyUpdateRow();
677
                    rowVals.put("CODE_LETTRAGE", codeLettre);
678
                    try {
679
                        rowVals.update();
680
                    } catch (SQLException ex) {
681
                        ex.printStackTrace();
682
                    }
683
 
684
                }
685
 
686
            }
687
        }
688
    }
156 ilm 689
 
18 ilm 690
}