OpenConcerto

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

svn://code.openconcerto.org/openconcerto

Rev

Rev 80 | Rev 93 | 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.finance.accounting.element;
15
 
16
import org.openconcerto.erp.config.ComptaPropsConfiguration;
17
import org.openconcerto.erp.core.common.element.ComptaSQLConfElement;
18
import org.openconcerto.erp.core.common.ui.DeviseField;
19
import org.openconcerto.erp.core.common.ui.PanelFrame;
19 ilm 20
import org.openconcerto.erp.core.finance.accounting.ui.LettrageRenderer;
21
import org.openconcerto.erp.core.finance.accounting.ui.ListEcritureRenderer;
22
import org.openconcerto.erp.core.finance.accounting.ui.PointageRenderer;
18 ilm 23
import org.openconcerto.erp.core.finance.accounting.ui.SuppressionEcrituresPanel;
24
import org.openconcerto.sql.Configuration;
25
import org.openconcerto.sql.element.BaseSQLComponent;
26
import org.openconcerto.sql.element.SQLComponent;
27
import org.openconcerto.sql.element.SQLElement;
28
import org.openconcerto.sql.model.SQLBase;
29
import org.openconcerto.sql.model.SQLRow;
30
import org.openconcerto.sql.model.SQLRowAccessor;
31
import org.openconcerto.sql.model.SQLRowValues;
32
import org.openconcerto.sql.model.SQLSelect;
33
import org.openconcerto.sql.model.SQLTable;
34
import org.openconcerto.sql.model.Where;
35
import org.openconcerto.sql.request.ListSQLRequest;
83 ilm 36
import org.openconcerto.sql.request.UpdateBuilder;
18 ilm 37
import org.openconcerto.sql.sqlobject.ElementComboBox;
38
import org.openconcerto.sql.users.UserManager;
39
import org.openconcerto.sql.utils.SQLUtils;
40
import org.openconcerto.sql.utils.SQLUtils.SQLFactory;
41
import org.openconcerto.sql.view.EditFrame;
19 ilm 42
import org.openconcerto.sql.view.list.SQLTableModelColumn;
43
import org.openconcerto.sql.view.list.SQLTableModelSourceOnline;
18 ilm 44
import org.openconcerto.ui.DefaultGridBagConstraints;
45
import org.openconcerto.ui.JDate;
46
import org.openconcerto.utils.ExceptionHandler;
47
 
48
import java.awt.GridBagConstraints;
49
import java.awt.GridBagLayout;
50
import java.awt.event.KeyAdapter;
51
import java.awt.event.KeyEvent;
52
import java.sql.SQLException;
53
import java.util.ArrayList;
80 ilm 54
import java.util.Collection;
18 ilm 55
import java.util.Date;
56
import java.util.List;
57
 
58
import javax.swing.JFrame;
59
import javax.swing.JLabel;
60
import javax.swing.JOptionPane;
61
import javax.swing.JTextField;
62
import javax.swing.SwingUtilities;
63
 
64
import org.apache.commons.dbutils.handlers.ArrayListHandler;
65
 
66
public class EcritureSQLElement extends ComptaSQLConfElement {
67
 
68
    public EcritureSQLElement() {
69
        super("ECRITURE", "une écriture", "écritures");
70
    }
71
 
72
    // Impossible de modifier si validée
73
    // FIXME impossible de saisir une écriture avant la date de debut d'exercice --> de saisir de
74
    // document de gest comm
75
 
76
    public List<String> getListFields() {
77
        final List<String> l = new ArrayList<String>();
78
 
79
        l.add("ID");
21 ilm 80
        l.add("VALIDE");
18 ilm 81
        l.add("ID_MOUVEMENT");
82
        // l.add("ID_COMPTE_PCE");
83
        l.add("COMPTE_NUMERO");
84
        l.add("COMPTE_NOM");
85
        // l.add("ID_JOURNAL");
86
        l.add("JOURNAL_NOM");
87
        l.add("NOM");
88
        l.add("DATE");
89
 
90
        l.add("DEBIT");
91
        l.add("CREDIT");
92
 
93
        return l;
94
    }
95
 
96
    protected List<String> getComboFields() {
97
        final List<String> l = new ArrayList<String>();
98
        l.add("NOM");
99
        l.add("DATE");
100
        l.add("DEBIT");
101
        l.add("CREDIT");
102
        l.add("ID_JOURNAL");
103
        l.add("ID_MOUVEMENT");
104
        return l;
105
    }
106
 
107
    @Override
19 ilm 108
    public synchronized ListSQLRequest createListRequest() {
109
        return createListRequest(this.getListFields());
110
    }
111
 
112
    public ListSQLRequest createListRequest(List<String> fields) {
113
        return new ListSQLRequest(this.getTable(), fields) {
18 ilm 114
            @Override
115
            protected void customizeToFetch(SQLRowValues graphToFetch) {
116
                super.customizeToFetch(graphToFetch);
117
                graphToFetch.put("VALIDE", null);
118
            }
119
        };
120
    }
121
 
19 ilm 122
    @Override
123
    protected void _initTableSource(SQLTableModelSourceOnline res) {
124
        super._initTableSource(res);
125
        for (SQLTableModelColumn col : res.getColumns()) {
126
            col.setRenderer(ListEcritureRenderer.UTILS.getRenderer(col.getRenderer()));
127
        }
128
    }
129
 
130
    public final SQLTableModelSourceOnline createPointageTableSource() {
131
        final List<String> listEcriture = new ArrayList<String>();
132
        listEcriture.add("POINTEE");
133
        listEcriture.add("DATE_POINTEE");
134
        listEcriture.add("ID_MOUVEMENT");
135
        listEcriture.add("NOM");
136
        listEcriture.add("DATE");
137
        listEcriture.add("DEBIT");
138
        listEcriture.add("CREDIT");
139
        final SQLTableModelSourceOnline res = this.initTableSource(new SQLTableModelSourceOnline(this.createListRequest(listEcriture)));
140
        for (SQLTableModelColumn column : res.getColumns()) {
141
            column.setRenderer(PointageRenderer.UTILS.getRenderer(column.getRenderer()));
142
        }
143
        return res;
144
    }
145
 
146
    public final SQLTableModelSourceOnline createLettrageTableSource() {
147
        final List<String> listEcriture = new ArrayList<String>();
148
        listEcriture.add("LETTRAGE");
149
        listEcriture.add("ID_COMPTE_PCE");
150
        listEcriture.add("ID_MOUVEMENT");
151
        listEcriture.add("NOM");
152
        listEcriture.add("DATE_LETTRAGE");
153
        listEcriture.add("DATE");
154
        listEcriture.add("DEBIT");
155
        listEcriture.add("CREDIT");
156
        final SQLTableModelSourceOnline res = this.initTableSource(new SQLTableModelSourceOnline(this.createListRequest(listEcriture)));
157
        for (SQLTableModelColumn column : res.getColumns()) {
158
            column.setRenderer(LettrageRenderer.UTILS.getRenderer(column.getRenderer()));
159
        }
160
        return res;
161
    }
162
 
18 ilm 163
    /*
164
     * (non-Javadoc)
165
     *
166
     * @see org.openconcerto.devis.SQLElement#getComponent()
167
     */
168
    public SQLComponent createComponent() {
169
        return new BaseSQLComponent(this) {
170
 
171
            private JTextField nom;
172
            private DeviseField debit;
173
            private DeviseField credit;
174
            private JDate date;
175
            private ElementComboBox journal;
176
 
177
            public void addViews() {
178
                this.setLayout(new GridBagLayout());
179
                final GridBagConstraints c = new DefaultGridBagConstraints();
180
 
181
                this.nom = new JTextField();
182
                this.debit = new DeviseField();
183
                this.credit = new DeviseField();
184
                this.date = new JDate();
185
                this.journal = new ElementComboBox();
186
                // Mouvement
187
                /*
188
                 * JLabel labelMouvement = new JLabel("Mouvement"); this.add(labelMouvement, c);
189
                 *
190
                 * c.gridx ++; c.weightx = 1; this.add(idMouvement, c);
191
                 */
192
 
193
                // Journal
194
                JLabel labelJournal = new JLabel("Journal");
195
                c.gridx = 0;
196
                this.add(labelJournal, c);
197
 
198
                c.gridx++;
199
                c.weightx = 1;
200
                this.add(this.journal, c);
201
 
202
                // Date
203
                JLabel labelDate = new JLabel("Date");
204
                c.gridx++;
205
                this.add(labelDate, c);
206
 
207
                c.gridx++;
208
                c.weightx = 1;
209
                this.add(this.date, c);
210
 
211
                // libellé
212
                JLabel labelNom = new JLabel("Libellé");
213
                c.gridy++;
214
                c.gridx = 0;
215
                this.add(labelNom, c);
216
 
217
                c.gridx++;
218
                c.weightx = 1;
219
                c.gridwidth = GridBagConstraints.REMAINDER;
220
                this.add(this.nom, c);
221
 
222
                // debit
223
                c.gridwidth = 1;
224
                JLabel labelDebit = new JLabel("Debit");
225
                c.gridy++;
226
                c.gridx = 0;
227
                this.add(labelDebit, c);
228
 
229
                c.gridx++;
230
                c.weightx = 1;
231
                this.add(this.debit, c);
232
                this.debit.addKeyListener(new KeyAdapter() {
233
                    public void keyReleased(KeyEvent e) {
234
                        if ((credit.getText().trim().length() != 0) && (debit.getText().trim().length() != 0)) {
235
                            credit.setText("");
236
                        }
237
                    }
238
                });
239
 
240
                // Credit
241
                JLabel labelCredit = new JLabel("Credit");
242
                c.gridx++;
243
                this.add(labelCredit, c);
244
 
245
                c.gridx++;
246
                c.weightx = 1;
247
                this.add(this.credit, c);
248
 
249
                this.credit.addKeyListener(new KeyAdapter() {
250
                    public void keyReleased(KeyEvent e) {
251
                        if ((debit.getText().trim().length() != 0) && (credit.getText().trim().length() != 0)) {
252
                            debit.setText("");
253
                        }
254
                    }
255
                });
256
 
257
                this.addSQLObject(this.nom, "NOM");
258
                this.addSQLObject(this.debit, "DEBIT");
259
                this.addSQLObject(this.credit, "CREDIT");
260
                this.addRequiredSQLObject(this.date, "DATE");
261
                this.addRequiredSQLObject(this.journal, "ID_JOURNAL");
262
            }
263
 
264
            @Override
265
            public void select(SQLRowAccessor r) {
266
                super.select(r);
267
 
268
                if (r != null && r.getBoolean("VALIDE")) {
269
                    this.nom.setEnabled(false);
270
                    this.debit.setEnabled(false);
271
                    this.credit.setEnabled(false);
272
                    this.date.setEnabled(false);
273
                    this.date.setEditable(false);
274
                    this.journal.setEnabled(false);
275
                }
276
 
277
            }
278
 
279
            public void update() {
280
                SQLRow row = EcritureSQLElement.this.getTable().getRow(getSelectedID());
281
                if (row.getBoolean("VALIDE")) {
282
                    System.out.println("Impossible de modifier une ecriture validée");
283
                } else {
284
                    super.update();
285
                }
286
            }
287
 
288
        };
289
    }
290
 
291
    /**
292
     * Validation d'un mouvement, implique la validation de l'ensemble de la piece
293
     *
294
     * @param idMvt
295
     */
296
    private static void validerMouvement(int idMvt) {
297
 
298
        if (idMvt == 1) {
299
            return;
300
        }
301
 
302
        SQLTable tableMvt = ((ComptaPropsConfiguration) Configuration.getInstance()).getSQLBaseSociete().getTable("MOUVEMENT");
303
        SQLRow rowMvt = tableMvt.getRow(idMvt);
304
 
305
        // On parcourt en profondeur
306
        if (rowMvt.getInt("ID_MOUVEMENT_PERE") > 1) {
307
            validerMouvement(rowMvt.getInt("ID_MOUVEMENT_PERE"));
308
        } else {
309
            validerMouvementProfondeur(idMvt);
310
        }
311
    }
312
 
313
    /**
314
     * Valider l'ensemble des mouvements formés par le sous arbre de du mouvement d'id idMvtPere
315
     *
316
     * @param idMvtPere
317
     */
318
    private static void validerMouvementProfondeur(int idMvtPere) {
319
        SQLBase base = ((ComptaPropsConfiguration) Configuration.getInstance()).getSQLBaseSociete();
320
        SQLTable tableMvt = ((ComptaPropsConfiguration) Configuration.getInstance()).getSQLBaseSociete().getTable("MOUVEMENT");
321
 
80 ilm 322
        SQLSelect selectFils = new SQLSelect();
18 ilm 323
        selectFils.addSelect(tableMvt.getField("ID"));
65 ilm 324
        selectFils.setWhere(tableMvt.getField("ID_MOUVEMENT_PERE"), "=", idMvtPere);
18 ilm 325
 
326
        List l = (List) base.getDataSource().execute(selectFils.asString(), new ArrayListHandler());
327
 
328
        // valide mouvements fils
329
        for (int i = 0; i < l.size(); i++) {
330
            Object[] tmp = (Object[]) l.get(i);
331
            validerMouvementProfondeur(Integer.parseInt(tmp[0].toString()));
332
        }
333
 
334
        // valide mouvement
335
        validationEcritures(idMvtPere);
336
    }
337
 
338
    /**
339
     * Valide l'ensemble des ecritures du mouvement
340
     *
341
     * @param idMvt Id du mouvement à valider
342
     */
343
    public static final void validationEcritures(int idMvt) {
344
        SQLBase base = ((ComptaPropsConfiguration) Configuration.getInstance()).getSQLBaseSociete();
345
        SQLTable tableEcriture = base.getTable("ECRITURE");
346
 
347
        SQLSelect selEcriture = new SQLSelect(base);
348
        selEcriture.addSelect(tableEcriture.getField("ID"));
349
 
350
        Where w = new Where(tableEcriture.getField("ID_MOUVEMENT"), "=", idMvt);
351
 
352
        selEcriture.setWhere(w);
353
 
354
        String reqEcriture = selEcriture.asString();
355
 
356
        Object obEcriture = base.getDataSource().execute(reqEcriture, new ArrayListHandler());
357
 
358
        List myListEcriture = (List) obEcriture;
359
 
360
        if (myListEcriture.size() != 0) {
361
 
362
            for (int i = 0; i < myListEcriture.size(); i++) {
363
                Object[] objTmp = (Object[]) myListEcriture.get(i);
364
                valideEcriture(Integer.parseInt(objTmp[0].toString()));
365
            }
366
        }
367
    }
368
 
369
    /**
370
     * Validation des ecritures avant la date d
371
     *
372
     * @param d date
373
     * @param cloture
374
     */
375
    public static final void validationEcrituresBefore(Date d, boolean cloture) {
376
 
377
        SQLBase base = ((ComptaPropsConfiguration) Configuration.getInstance()).getSQLBaseSociete();
378
        SQLTable tableEcriture = base.getTable("ECRITURE");
379
 
380
        // on recupere l'ensemble des mouvements à valider
381
        SQLSelect selEcriture = new SQLSelect(base);
382
        selEcriture.addSelect(tableEcriture.getField("ID_MOUVEMENT"));
383
        selEcriture.setDistinct(true);
384
        Where w1 = new Where(tableEcriture.getField("DATE"), "<=", d);
385
        Where w2 = new Where(tableEcriture.getField("VALIDE"), "=", Boolean.FALSE);
386
        selEcriture.setWhere(w1.and(w2));
387
        List l = (List) base.getDataSource().execute(selEcriture.asString(), new ArrayListHandler());
388
 
389
        // validation de tous les mouvements
390
        for (int i = 0; i < l.size(); i++) {
391
            Object[] tmp = (Object[]) l.get(i);
392
            System.err.println("Validation du mouvement " + tmp[0]);
393
            validationEcritures(Integer.parseInt(tmp[0].toString()));
394
        }
395
 
396
        if (cloture) {
397
 
398
            SQLTable tableExercice = Configuration.getInstance().getBase().getTable("EXERCICE_COMMON");
399
 
400
            SQLRow rowSociete = ((ComptaPropsConfiguration) Configuration.getInstance()).getRowSociete();
401
            SQLRow rowExercice = tableExercice.getRow(rowSociete.getInt("ID_EXERCICE_COMMON"));
402
            Date dateCloture = (Date) rowExercice.getObject("DATE_CLOTURE");
403
 
404
            if (dateCloture == null || dateCloture.before(d)) {
405
 
406
                SQLRowValues rowVals = new SQLRowValues(tableExercice);
407
                rowVals.put("DATE_CLOTURE", new java.sql.Date(d.getTime()));
408
                try {
409
                    rowVals.update(rowExercice.getID());
410
                } catch (SQLException e) {
411
                    e.printStackTrace();
412
                }
413
            }
414
        }
415
    }
416
 
417
    private static final void valideEcriture(int id) {
418
        SQLTable tableEcriture = ((ComptaPropsConfiguration) Configuration.getInstance()).getSQLBaseSociete().getTable("ECRITURE");
419
        SQLRowValues rowVals = new SQLRowValues(tableEcriture);
420
        rowVals.put("VALIDE", Boolean.TRUE);
421
        rowVals.put("DATE_VALIDE", new java.sql.Date(new Date().getTime()));
422
        rowVals.put("IDUSER_VALIDE", UserManager.getInstance().getCurrentUser().getId());
423
 
424
        try {
425
            rowVals.update(id);
426
        } catch (SQLException e) {
427
            e.printStackTrace();
428
        }
429
    }
430
 
431
    public void archiveMouvement(int idMvt) {
432
        SQLTable tableMouvement = ((ComptaPropsConfiguration) Configuration.getInstance()).getSQLBaseSociete().getTable("MOUVEMENT");
433
        SQLRow rowMvt = tableMouvement.getRow(idMvt);
434
 
435
        if (rowMvt.getInt("ID_MOUVEMENT_PERE") > 1) {
436
            archiveMouvement(rowMvt.getInt("ID_MOUVEMENT_PERE"));
437
        } else {
438
            archiveMouvementProfondeur(idMvt, true);
439
        }
440
    }
441
 
442
    /**
443
     * Archivage de l'ensemble des opérations liés au mouvement passé en parametre
444
     *
445
     * @param idMvtPere mouvement racine
446
     * @param dropPere suppression du mouvement pere
447
     */
448
    public void archiveMouvementProfondeur(int idMvtPere, boolean dropPere) {
449
        if (idMvtPere > 1) {
450
            SQLBase base = ((ComptaPropsConfiguration) Configuration.getInstance()).getSQLBaseSociete();
451
            SQLTable tableMvt = ((ComptaPropsConfiguration) Configuration.getInstance()).getSQLBaseSociete().getTable("MOUVEMENT");
452
 
73 ilm 453
            SQLSelect selectFils = new SQLSelect();
18 ilm 454
            selectFils.addSelect(tableMvt.getField("ID"));
65 ilm 455
            selectFils.setWhere(tableMvt.getField("ID_MOUVEMENT_PERE"), "=", idMvtPere);
18 ilm 456
 
457
            List l = (List) base.getDataSource().execute(selectFils.asString(), new ArrayListHandler());
458
 
459
            // archive mouvements fils
460
            for (int i = 0; i < l.size(); i++) {
461
                Object[] tmp = (Object[]) l.get(i);
462
                archiveMouvementProfondeur(Integer.parseInt(tmp[0].toString()), true);
463
            }
464
 
465
            // archive mouvement
466
            archiveEcritures(idMvtPere, dropPere);
467
 
468
        } else {
469
 
470
            System.err.println("Suppression du mouvement d'id 1 impossible.");
83 ilm 471
            JOptionPane.showMessageDialog(null, "Impossible d'archiver, le mouvement est indéfini.");
18 ilm 472
        }
473
    }
474
 
475
    // Suppression des ecritures associées à un mouvement
476
    private synchronized void archiveEcritures(final int idMvt, final boolean dropMvt) {
477
        final SQLBase base = ((ComptaPropsConfiguration) Configuration.getInstance()).getSQLBaseSociete();
478
        final SQLTable tableMvt = base.getTable("MOUVEMENT");
479
        final SQLTable tableEcriture = base.getTable("ECRITURE");
480
        final SQLRow rowMvt = tableMvt.getRow(idMvt);
481
 
482
        // on verifie que le mouvement n'est pas validé
483
        if (MouvementSQLElement.isEditable(idMvt)) {
484
 
485
            // on archive le mouvement
486
            if (dropMvt) {
487
                SQLElement elt = Configuration.getInstance().getDirectory().getElement(tableMvt);
488
                try {
489
                    elt.archive(idMvt);
490
                } catch (SQLException e) {
491
                    ExceptionHandler.handle("Erreur lors de la suppression du mouvement d'id [" + idMvt + "]", e);
492
                    e.printStackTrace();
493
                }
494
            } else {
495
 
496
                SQLFactory<Object> sqlFactory = new SQLFactory<Object>() {
497
                    @Override
498
                    public Object create() throws SQLException {
499
                        // on recupere l'ensemble des ecritures associées au mouvement
73 ilm 500
                        SQLSelect selEcritures = new SQLSelect();
18 ilm 501
                        selEcritures.addSelect(tableEcriture.getField("ID"));
65 ilm 502
                        selEcritures.setWhere(tableEcriture.getField("ID_MOUVEMENT"), "=", idMvt);
18 ilm 503
 
504
                        List l = (List) base.getDataSource().execute(selEcritures.asString(), new ArrayListHandler());
505
                        for (int i = 0; i < l.size(); i++) {
506
                            Object[] tmp = (Object[]) l.get(i);
73 ilm 507
                            archiveEcriture(tableEcriture.getRow(Integer.parseInt(tmp[0].toString())));
18 ilm 508
                        }
509
 
510
                        return null;
511
                    }
512
                };
513
 
514
                try {
515
                    SQLUtils.executeAtomic(base.getDataSource(), sqlFactory);
516
                } catch (SQLException e) {
73 ilm 517
 
518
                    ExceptionHandler.handle("Une erreur est survenue lors de la suppression des écritures.", e);
18 ilm 519
                }
520
            }
521
 
522
        } else {
523
            ExceptionHandler.handle("Impossible de supprimer le mouvement n°" + rowMvt.getInt("NUMERO") + " car il est validé.");
524
        }
525
    }
526
 
527
    @Override
528
    protected void archive(SQLRow row, boolean cutLinks) throws SQLException {
529
        // Si on supprime une ecriture on doit supprimer toutes les ecritures du mouvement associé
530
        System.err.println("Archivage des écritures");
531
        // archiveMouvement(row.getInt("ID_MOUVEMENT"));
532
        JFrame frame = new PanelFrame(new SuppressionEcrituresPanel(row.getInt("ID_MOUVEMENT")), "Suppression d'ecritures");
533
        frame.pack();
534
        frame.setResizable(false);
535
        frame.setLocationRelativeTo(null);
536
        frame.setVisible(true);
537
    }
538
 
539
    /**
540
     * Permet d'archiver une ecriture seule attention méthode à utiliser en vérifiant que la balance
541
     * est respectée
542
     *
543
     * @param row
544
     * @throws SQLException
545
     */
546
    public void archiveEcriture(SQLRow row) throws SQLException {
547
 
548
        if (!row.getBoolean("VALIDE")) {
549
 
550
            SQLRowValues rowVals = new SQLRowValues(this.getTable());
551
            rowVals.put("IDUSER_DELETE", UserManager.getInstance().getCurrentUser().getId());
552
            rowVals.update(row.getID());
553
 
83 ilm 554
            // Annulation du lettrage si l'ecriture est lettrée pour ne pas avoir de lettrage
555
            // déséquilibré
556
            final String codeLettrage = row.getString("LETTRAGE");
557
            if (codeLettrage != null && codeLettrage.trim().length() > 0) {
558
                UpdateBuilder builder = new UpdateBuilder(getTable());
559
                builder.setObject("LETTRAGE", "");
560
                builder.setObject("DATE_LETTRAGE", null);
561
                builder.setWhere(new Where(getTable().getField("LETTRAGE"), "=", codeLettrage));
562
                getTable().getDBSystemRoot().getDataSource().execute(builder.asString());
563
            }
564
 
18 ilm 565
            super.archive(row, true);
566
        } else {
567
            System.err.println("Impossible de supprimer une ecriture validée");
568
            JOptionPane.showMessageDialog(null, "Impossible de supprimer une ecriture validée. \n" + row);
569
        }
570
    }
571
 
572
    private static EditFrame frameSaisieKm = null;
573
 
574
    /**
575
     * Contrepassation d'un piece comptable à partir de l'id d'une écriture. Chargement d'un panel
576
     * Saisie au Km avec les ecritures inversées
577
     *
578
     * @param id
579
     */
580
    public static void contrePassationPiece(int id) {
581
 
582
        SQLBase base = ((ComptaPropsConfiguration) Configuration.getInstance()).getSQLBaseSociete();
583
 
584
        SQLTable tableEcriture = base.getTable("ECRITURE");
585
        SQLRow rowEcr = tableEcriture.getRow(id);
586
        final int idMvt = rowEcr.getInt("ID_MOUVEMENT");
587
        System.err.println("ID MOUVEMENT --> " + idMvt);
588
        if (frameSaisieKm == null) {
589
            frameSaisieKm = new EditFrame(Configuration.getInstance().getDirectory().getElement("SAISIE_KM"));
590
        }
591
 
592
        SwingUtilities.invokeLater(new Runnable() {
593
            public void run() {
594
                SaisieKmSQLElement.loadContrePassation(frameSaisieKm.getSQLComponent(), idMvt);
595
            }
596
        });
597
        frameSaisieKm.setVisible(true);
598
    }
57 ilm 599
 
600
    @Override
601
    protected String createCode() {
602
        return createCodeFromPackage() + ".entry.item";
603
    }
80 ilm 604
 
605
    public static void dupliquer(SQLRow selectedRow) {
606
 
607
        final SQLRow foreignMvt = selectedRow.getForeign("ID_MOUVEMENT");
608
        if (foreignMvt.getString("SOURCE").equalsIgnoreCase("SAISIE_KM")) {
609
            final SQLElement elementSaisieKm = Configuration.getInstance().getDirectory().getElement("SAISIE_KM");
610
            final SQLElement elementSaisieKmItem = Configuration.getInstance().getDirectory().getElement("SAISIE_KM_ELEMENT");
611
            final EditFrame frameCloneSaisieKm = new EditFrame(elementSaisieKm);
612
            int idSource = foreignMvt.getInt("IDSOURCE");
613
            SQLRow rowKm = elementSaisieKm.getTable().getRow(idSource);
614
            final SQLRowValues rowVals = elementSaisieKm.createCopy(idSource);
615
            rowVals.put("ID_MOUVEMENT", null);
616
            Collection<SQLRow> items = rowKm.getReferentRows(elementSaisieKm.getTable().getTable("SAISIE_KM_ELEMENT"));
617
            for (SQLRow sqlRow : items) {
618
                SQLRowValues sqlRowValues = elementSaisieKmItem.createCopy(sqlRow.getID());
619
                sqlRowValues.put("ID_ECRITURE", null);
620
                sqlRowValues.put("ID_SAISIE_KM", rowVals);
621
                System.err.println("ADD ELEMENT KM :: " + sqlRowValues.getID());
622
            }
623
 
624
            SwingUtilities.invokeLater(new Runnable() {
625
                public void run() {
626
                    frameCloneSaisieKm.getSQLComponent().select(rowVals);
627
                }
628
            });
629
            frameCloneSaisieKm.setVisible(true);
630
        } else {
631
            SwingUtilities.invokeLater(new Runnable() {
632
                public void run() {
633
                    JOptionPane.showMessageDialog(null, "La duplication n'est possible que sur les saisies au kilomètre");
634
                }
635
            });
636
        }
637
    }
18 ilm 638
}