OpenConcerto

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

svn://code.openconcerto.org/openconcerto

Rev

Rev 156 | 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;
142 ilm 20
import org.openconcerto.erp.core.edm.AttachmentAction;
156 ilm 21
import org.openconcerto.erp.core.finance.accounting.ui.AssociationAnalytiquePanel;
142 ilm 22
import org.openconcerto.erp.core.finance.accounting.ui.ConsultationCompteFrame;
19 ilm 23
import org.openconcerto.erp.core.finance.accounting.ui.LettrageRenderer;
24
import org.openconcerto.erp.core.finance.accounting.ui.ListEcritureRenderer;
142 ilm 25
import org.openconcerto.erp.core.finance.accounting.ui.ListeDesEcrituresPanel;
19 ilm 26
import org.openconcerto.erp.core.finance.accounting.ui.PointageRenderer;
18 ilm 27
import org.openconcerto.erp.core.finance.accounting.ui.SuppressionEcrituresPanel;
28
import org.openconcerto.sql.Configuration;
29
import org.openconcerto.sql.element.BaseSQLComponent;
30
import org.openconcerto.sql.element.SQLComponent;
31
import org.openconcerto.sql.element.SQLElement;
132 ilm 32
import org.openconcerto.sql.element.TreesOfSQLRows;
93 ilm 33
import org.openconcerto.sql.model.FieldPath;
18 ilm 34
import org.openconcerto.sql.model.SQLBase;
35
import org.openconcerto.sql.model.SQLRow;
36
import org.openconcerto.sql.model.SQLRowAccessor;
37
import org.openconcerto.sql.model.SQLRowValues;
38
import org.openconcerto.sql.model.SQLSelect;
39
import org.openconcerto.sql.model.SQLTable;
40
import org.openconcerto.sql.model.Where;
93 ilm 41
import org.openconcerto.sql.model.graph.Path;
18 ilm 42
import org.openconcerto.sql.request.ListSQLRequest;
83 ilm 43
import org.openconcerto.sql.request.UpdateBuilder;
18 ilm 44
import org.openconcerto.sql.sqlobject.ElementComboBox;
45
import org.openconcerto.sql.users.UserManager;
46
import org.openconcerto.sql.utils.SQLUtils;
47
import org.openconcerto.sql.utils.SQLUtils.SQLFactory;
48
import org.openconcerto.sql.view.EditFrame;
93 ilm 49
import org.openconcerto.sql.view.list.BaseSQLTableModelColumn;
156 ilm 50
import org.openconcerto.sql.view.list.IListe;
142 ilm 51
import org.openconcerto.sql.view.list.IListeAction.IListeEvent;
52
import org.openconcerto.sql.view.list.RowAction.PredicateRowAction;
19 ilm 53
import org.openconcerto.sql.view.list.SQLTableModelColumn;
142 ilm 54
import org.openconcerto.sql.view.list.SQLTableModelSource;
19 ilm 55
import org.openconcerto.sql.view.list.SQLTableModelSourceOnline;
18 ilm 56
import org.openconcerto.ui.DefaultGridBagConstraints;
57
import org.openconcerto.ui.JDate;
93 ilm 58
import org.openconcerto.ui.component.InteractionMode;
59
import org.openconcerto.utils.CollectionUtils;
18 ilm 60
import org.openconcerto.utils.ExceptionHandler;
142 ilm 61
import org.openconcerto.utils.convertor.ValueConvertor;
18 ilm 62
 
63
import java.awt.GridBagConstraints;
64
import java.awt.GridBagLayout;
142 ilm 65
import java.awt.event.ActionEvent;
18 ilm 66
import java.awt.event.KeyAdapter;
67
import java.awt.event.KeyEvent;
142 ilm 68
import java.math.BigDecimal;
69
import java.math.BigInteger;
18 ilm 70
import java.sql.SQLException;
71
import java.util.ArrayList;
80 ilm 72
import java.util.Collection;
18 ilm 73
import java.util.Date;
74
import java.util.List;
93 ilm 75
import java.util.Set;
18 ilm 76
 
142 ilm 77
import javax.swing.AbstractAction;
18 ilm 78
import javax.swing.JFrame;
79
import javax.swing.JLabel;
80
import javax.swing.JOptionPane;
81
import javax.swing.JTextField;
82
import javax.swing.SwingUtilities;
83
 
84
import org.apache.commons.dbutils.handlers.ArrayListHandler;
85
 
86
public class EcritureSQLElement extends ComptaSQLConfElement {
87
 
88
    public EcritureSQLElement() {
89
        super("ECRITURE", "une écriture", "écritures");
142 ilm 90
        PredicateRowAction actionAttachment = new PredicateRowAction(new AttachmentAction("ID_MOUVEMENT").getAction(), true);
91
        actionAttachment.setPredicate(IListeEvent.getSingleSelectionPredicate());
92
        getRowActions().add(actionAttachment);
156 ilm 93
 
94
        PredicateRowAction consult = new PredicateRowAction(new AbstractAction("Consultation du compte") {
95
            public void actionPerformed(ActionEvent event) {
96
                SQLRowAccessor row = IListe.get(event).getSelectedRow();
97
                consultationCompte(ComptePCESQLElement.getRow(row.getString("COMPTE_NUMERO"), row.getString("COMPTE_NOM")));
98
            }
99
        }, false);
100
        consult.setPredicate(IListeEvent.getSingleSelectionPredicate());
101
        getRowActions().add(consult);
102
 
103
        PredicateRowAction contre = new PredicateRowAction(new AbstractAction("Contrepassation") {
104
            public void actionPerformed(ActionEvent event) {
105
                EcritureSQLElement.contrePassationPiece(IListe.get(event).getSelectedId());
106
            }
107
        }, false);
108
        contre.setPredicate(IListeEvent.getSingleSelectionPredicate());
109
        getRowActions().add(contre);
110
        // menuDroit.add(new AbstractAction("Valider le mouvement") {
111
        // public void actionPerformed(ActionEvent event) {
112
        // if (JOptionPane.showConfirmDialog(null, "Etes vous sûr de vouloir valider le
113
        // mouvement?") == JOptionPane.YES_OPTION) {
114
        // EcritureSQLElement.validationEcritures(frame.getPanel().getListe().getSelectedRow().getInt("ID_MOUVEMENT"));
115
        // }
116
        // }
117
        // });
118
 
119
        PredicateRowAction clone = new PredicateRowAction(new AbstractAction("Dupliquer") {
120
            public void actionPerformed(ActionEvent event) {
121
                EcritureSQLElement.dupliquer(IListe.get(event).fetchSelectedRow());
122
            }
123
        }, false);
124
        clone.setPredicate(IListeEvent.getSingleSelectionPredicate());
125
        getRowActions().add(clone);
126
 
127
        PredicateRowAction an = new PredicateRowAction(new AbstractAction("Gérer l'analytique") {
128
            public void actionPerformed(ActionEvent event) {
129
                PanelFrame frameAssoc = new PanelFrame(new AssociationAnalytiquePanel(IListe.get(event).getSelectedRow().asRow()), "Association analytique");
130
                frameAssoc.setVisible(true);
131
            }
132
        }, false);
133
        an.setPredicate(IListeEvent.getSingleSelectionPredicate());
134
        getRowActions().add(an);
135
 
136
        PredicateRowAction show = new PredicateRowAction(new AbstractAction("Voir la source") {
137
            public void actionPerformed(ActionEvent event) {
138
 
139
                SQLRow row = IListe.get(event).fetchSelectedRow();
140
 
141
                MouvementSQLElement.showSource(row.getInt("ID_MOUVEMENT"));
142
            }
143
        }, false);
144
        show.setPredicate(IListeEvent.getSingleSelectionPredicate());
145
        getRowActions().add(show);
18 ilm 146
    }
147
 
132 ilm 148
    @Override
149
    protected String getParentFFName() {
150
        return "ID_MOUVEMENT";
151
    }
152
 
174 ilm 153
    @Override
154
    public boolean isPrivate() {
155
        return false;
156
    }
157
 
18 ilm 158
    // Impossible de modifier si validée
159
    // FIXME impossible de saisir une écriture avant la date de debut d'exercice --> de saisir de
160
    // document de gest comm
161
 
162
    public List<String> getListFields() {
163
        final List<String> l = new ArrayList<String>();
21 ilm 164
        l.add("VALIDE");
18 ilm 165
        l.add("ID_MOUVEMENT");
93 ilm 166
        if (getTable().contains("NOM_PIECE")) {
167
            l.add("NOM_PIECE");
168
        }
18 ilm 169
        // l.add("ID_COMPTE_PCE");
170
        l.add("COMPTE_NUMERO");
171
        l.add("COMPTE_NOM");
172
        // l.add("ID_JOURNAL");
173
        l.add("JOURNAL_NOM");
174
        l.add("NOM");
175
        l.add("DATE");
176
 
177
        l.add("DEBIT");
178
        l.add("CREDIT");
179
 
180
        return l;
181
    }
182
 
183
    protected List<String> getComboFields() {
184
        final List<String> l = new ArrayList<String>();
185
        l.add("NOM");
186
        l.add("DATE");
187
        l.add("DEBIT");
188
        l.add("CREDIT");
189
        l.add("ID_JOURNAL");
190
        l.add("ID_MOUVEMENT");
191
        return l;
192
    }
193
 
194
    @Override
132 ilm 195
    protected void _initListRequest(ListSQLRequest req) {
196
        super._initListRequest(req);
197
        req.addToGraphToFetch("VALIDE");
19 ilm 198
    }
199
 
142 ilm 200
    public void consultationCompte(SQLRowAccessor rowCpt) {
174 ilm 201
        final ListeDesEcrituresPanel panel = new ListeDesEcrituresPanel();
202
        final ConsultationCompteFrame f = new ConsultationCompteFrame(panel, rowCpt);
142 ilm 203
 
151 ilm 204
        f.getPanel().getListe().setModificationAllowed(false);
142 ilm 205
        f.pack();
206
        f.setVisible(true);
207
    }
208
 
19 ilm 209
    @Override
142 ilm 210
    protected void _initTableSource(SQLTableModelSource res) {
19 ilm 211
        super._initTableSource(res);
142 ilm 212
        BaseSQLTableModelColumn analytique = new BaseSQLTableModelColumn("Poste analytique", String.class) {
213
 
214
            @Override
215
            protected Object show_(SQLRowAccessor r) {
216
                Collection<? extends SQLRowAccessor> assocs = r.getReferentRows(getTable().getTable("ASSOCIATION_ANALYTIQUE"));
217
                StringBuffer res = new StringBuffer();
218
 
219
                for (SQLRowAccessor sqlRowAccessor : assocs) {
220
                    res.append(sqlRowAccessor.getForeign("ID_POSTE_ANALYTIQUE").getString("NOM"));
221
                    res.append(", ");
222
                }
223
 
224
                return res.toString();
225
            }
226
 
227
            @Override
228
            public Set<FieldPath> getPaths() {
229
                Path p = new Path(getTable());
230
                p = p.add(getTable().getTable("ASSOCIATION_ANALYTIQUE"));
231
                p = p.add(p.getLast().getForeignTable("ID_POSTE_ANALYTIQUE"));
232
                return CollectionUtils.createSet(new FieldPath(p, "NOM"));
233
            }
234
        };
235
        res.getColumns().add(analytique);
19 ilm 236
        for (SQLTableModelColumn col : res.getColumns()) {
237
            col.setRenderer(ListEcritureRenderer.UTILS.getRenderer(col.getRenderer()));
238
        }
239
    }
240
 
241
    public final SQLTableModelSourceOnline createPointageTableSource() {
242
        final List<String> listEcriture = new ArrayList<String>();
243
        listEcriture.add("POINTEE");
244
        listEcriture.add("DATE_POINTEE");
245
        listEcriture.add("ID_MOUVEMENT");
246
        listEcriture.add("NOM");
247
        listEcriture.add("DATE");
248
        listEcriture.add("DEBIT");
249
        listEcriture.add("CREDIT");
142 ilm 250
        final SQLTableModelSourceOnline res = this.instantiateTableSourceOnline(this.createListRequest(listEcriture));
251
        for (SQLTableModelColumn col : res.getColumns()) {
252
            if (col.getValueClass() == Long.class || col.getValueClass() == BigInteger.class) {
253
                col.setConverter(new ValueConvertor<Number, BigDecimal>() {
254
                    @Override
255
                    public BigDecimal convert(Number o) {
256
                        if (o == null) {
257
                            return BigDecimal.ZERO;
258
                        }
259
                        return new BigDecimal(o.longValue()).movePointLeft(2);
260
                    }
261
 
262
                    @Override
263
                    public Number unconvert(BigDecimal o) {
264
 
265
                        if (o == null) {
266
                            return 0;
267
                        }
268
                        return o.movePointRight(2);
269
                    }
270
                }, BigDecimal.class);
271
                col.setRenderer(CURRENCY_RENDERER);
272
            }
273
 
274
            col.setRenderer(PointageRenderer.UTILS.getRenderer(col.getRenderer()));
19 ilm 275
        }
142 ilm 276
        return this.initTableSource(res, true);
19 ilm 277
    }
278
 
279
    public final SQLTableModelSourceOnline createLettrageTableSource() {
280
        final List<String> listEcriture = new ArrayList<String>();
281
        listEcriture.add("LETTRAGE");
282
        listEcriture.add("ID_COMPTE_PCE");
283
        listEcriture.add("ID_MOUVEMENT");
94 ilm 284
        if (getTable().contains("NOM_PIECE")) {
285
            listEcriture.add("NOM_PIECE");
286
        }
19 ilm 287
        listEcriture.add("NOM");
288
        listEcriture.add("DATE_LETTRAGE");
289
        listEcriture.add("DATE");
290
        listEcriture.add("DEBIT");
291
        listEcriture.add("CREDIT");
142 ilm 292
        final SQLTableModelSourceOnline res = this.instantiateTableSourceOnline(this.createListRequest(listEcriture));
293
        for (SQLTableModelColumn col : res.getColumns()) {
294
            if (col.getValueClass() == Long.class || col.getValueClass() == BigInteger.class) {
295
                col.setConverter(new ValueConvertor<Number, BigDecimal>() {
296
                    @Override
297
                    public BigDecimal convert(Number o) {
298
                        if (o == null) {
299
                            return BigDecimal.ZERO;
300
                        }
301
                        return new BigDecimal(o.longValue()).movePointLeft(2);
302
                    }
19 ilm 303
 
142 ilm 304
                    @Override
305
                    public Number unconvert(BigDecimal o) {
93 ilm 306
 
142 ilm 307
                        if (o == null) {
308
                            return 0;
309
                        }
310
                        return o.movePointRight(2);
311
                    }
312
                }, BigDecimal.class);
313
                col.setRenderer(CURRENCY_RENDERER);
93 ilm 314
            }
142 ilm 315
            col.setRenderer(LettrageRenderer.UTILS.getRenderer(col.getRenderer()));
316
        }
317
        return this.initTableSource(res, true);
93 ilm 318
    }
319
 
18 ilm 320
    /*
321
     * (non-Javadoc)
322
     *
323
     * @see org.openconcerto.devis.SQLElement#getComponent()
324
     */
325
    public SQLComponent createComponent() {
326
        return new BaseSQLComponent(this) {
327
 
328
            private JTextField nom;
329
            private DeviseField debit;
330
            private DeviseField credit;
331
            private JDate date;
332
            private ElementComboBox journal;
333
 
334
            public void addViews() {
335
                this.setLayout(new GridBagLayout());
336
                final GridBagConstraints c = new DefaultGridBagConstraints();
337
 
338
                this.nom = new JTextField();
339
                this.debit = new DeviseField();
340
                this.credit = new DeviseField();
341
                this.date = new JDate();
342
                this.journal = new ElementComboBox();
343
                // Mouvement
344
                /*
345
                 * JLabel labelMouvement = new JLabel("Mouvement"); this.add(labelMouvement, c);
346
                 *
347
                 * c.gridx ++; c.weightx = 1; this.add(idMouvement, c);
348
                 */
349
 
350
                // Journal
351
                JLabel labelJournal = new JLabel("Journal");
352
                c.gridx = 0;
353
                this.add(labelJournal, c);
354
 
355
                c.gridx++;
356
                c.weightx = 1;
357
                this.add(this.journal, c);
358
 
359
                // Date
360
                JLabel labelDate = new JLabel("Date");
361
                c.gridx++;
362
                this.add(labelDate, c);
363
 
364
                c.gridx++;
365
                c.weightx = 1;
366
                this.add(this.date, c);
367
 
368
                // libellé
369
                JLabel labelNom = new JLabel("Libellé");
370
                c.gridy++;
371
                c.gridx = 0;
372
                this.add(labelNom, c);
373
 
374
                c.gridx++;
375
                c.weightx = 1;
376
                c.gridwidth = GridBagConstraints.REMAINDER;
377
                this.add(this.nom, c);
378
 
379
                // debit
380
                c.gridwidth = 1;
381
                JLabel labelDebit = new JLabel("Debit");
382
                c.gridy++;
383
                c.gridx = 0;
384
                this.add(labelDebit, c);
385
 
386
                c.gridx++;
387
                c.weightx = 1;
388
                this.add(this.debit, c);
389
                this.debit.addKeyListener(new KeyAdapter() {
390
                    public void keyReleased(KeyEvent e) {
391
                        if ((credit.getText().trim().length() != 0) && (debit.getText().trim().length() != 0)) {
392
                            credit.setText("");
393
                        }
394
                    }
395
                });
396
 
397
                // Credit
398
                JLabel labelCredit = new JLabel("Credit");
399
                c.gridx++;
400
                this.add(labelCredit, c);
401
 
402
                c.gridx++;
403
                c.weightx = 1;
404
                this.add(this.credit, c);
405
 
406
                this.credit.addKeyListener(new KeyAdapter() {
407
                    public void keyReleased(KeyEvent e) {
408
                        if ((debit.getText().trim().length() != 0) && (credit.getText().trim().length() != 0)) {
409
                            debit.setText("");
410
                        }
411
                    }
412
                });
413
 
414
                this.addSQLObject(this.nom, "NOM");
415
                this.addSQLObject(this.debit, "DEBIT");
416
                this.addSQLObject(this.credit, "CREDIT");
417
                this.addRequiredSQLObject(this.date, "DATE");
418
                this.addRequiredSQLObject(this.journal, "ID_JOURNAL");
419
            }
420
 
421
            @Override
422
            public void select(SQLRowAccessor r) {
423
                super.select(r);
424
 
425
                if (r != null && r.getBoolean("VALIDE")) {
426
                    this.nom.setEnabled(false);
427
                    this.debit.setEnabled(false);
428
                    this.credit.setEnabled(false);
93 ilm 429
                    this.date.setInteractionMode(InteractionMode.DISABLED);
18 ilm 430
                    this.journal.setEnabled(false);
431
                }
432
 
433
            }
434
 
435
            public void update() {
436
                SQLRow row = EcritureSQLElement.this.getTable().getRow(getSelectedID());
437
                if (row.getBoolean("VALIDE")) {
438
                    System.out.println("Impossible de modifier une ecriture validée");
439
                } else {
440
                    super.update();
441
                }
442
            }
443
 
444
        };
445
    }
446
 
447
    /**
448
     * Validation d'un mouvement, implique la validation de l'ensemble de la piece
449
     *
450
     * @param idMvt
451
     */
452
    private static void validerMouvement(int idMvt) {
453
 
454
        if (idMvt == 1) {
455
            return;
456
        }
457
 
458
        SQLTable tableMvt = ((ComptaPropsConfiguration) Configuration.getInstance()).getSQLBaseSociete().getTable("MOUVEMENT");
459
        SQLRow rowMvt = tableMvt.getRow(idMvt);
460
 
461
        // On parcourt en profondeur
462
        if (rowMvt.getInt("ID_MOUVEMENT_PERE") > 1) {
463
            validerMouvement(rowMvt.getInt("ID_MOUVEMENT_PERE"));
464
        } else {
465
            validerMouvementProfondeur(idMvt);
466
        }
467
    }
468
 
469
    /**
470
     * Valider l'ensemble des mouvements formés par le sous arbre de du mouvement d'id idMvtPere
471
     *
472
     * @param idMvtPere
473
     */
474
    private static void validerMouvementProfondeur(int idMvtPere) {
475
        SQLBase base = ((ComptaPropsConfiguration) Configuration.getInstance()).getSQLBaseSociete();
476
        SQLTable tableMvt = ((ComptaPropsConfiguration) Configuration.getInstance()).getSQLBaseSociete().getTable("MOUVEMENT");
477
 
80 ilm 478
        SQLSelect selectFils = new SQLSelect();
18 ilm 479
        selectFils.addSelect(tableMvt.getField("ID"));
65 ilm 480
        selectFils.setWhere(tableMvt.getField("ID_MOUVEMENT_PERE"), "=", idMvtPere);
18 ilm 481
 
482
        List l = (List) base.getDataSource().execute(selectFils.asString(), new ArrayListHandler());
483
 
484
        // valide mouvements fils
485
        for (int i = 0; i < l.size(); i++) {
486
            Object[] tmp = (Object[]) l.get(i);
487
            validerMouvementProfondeur(Integer.parseInt(tmp[0].toString()));
488
        }
489
 
490
        // valide mouvement
491
        validationEcritures(idMvtPere);
492
    }
493
 
494
    /**
495
     * Valide l'ensemble des ecritures du mouvement
496
     *
497
     * @param idMvt Id du mouvement à valider
498
     */
499
    public static final void validationEcritures(int idMvt) {
500
        SQLBase base = ((ComptaPropsConfiguration) Configuration.getInstance()).getSQLBaseSociete();
501
        SQLTable tableEcriture = base.getTable("ECRITURE");
502
 
503
        SQLSelect selEcriture = new SQLSelect(base);
504
        selEcriture.addSelect(tableEcriture.getField("ID"));
505
 
506
        Where w = new Where(tableEcriture.getField("ID_MOUVEMENT"), "=", idMvt);
507
 
508
        selEcriture.setWhere(w);
509
 
510
        String reqEcriture = selEcriture.asString();
511
 
512
        Object obEcriture = base.getDataSource().execute(reqEcriture, new ArrayListHandler());
513
 
514
        List myListEcriture = (List) obEcriture;
515
 
516
        if (myListEcriture.size() != 0) {
517
 
518
            for (int i = 0; i < myListEcriture.size(); i++) {
519
                Object[] objTmp = (Object[]) myListEcriture.get(i);
520
                valideEcriture(Integer.parseInt(objTmp[0].toString()));
521
            }
522
        }
523
    }
524
 
525
    /**
526
     * Validation des ecritures avant la date d
527
     *
528
     * @param d date
529
     * @param cloture
530
     */
531
    public static final void validationEcrituresBefore(Date d, boolean cloture) {
532
 
533
        SQLBase base = ((ComptaPropsConfiguration) Configuration.getInstance()).getSQLBaseSociete();
534
        SQLTable tableEcriture = base.getTable("ECRITURE");
535
 
536
        // on recupere l'ensemble des mouvements à valider
537
        SQLSelect selEcriture = new SQLSelect(base);
538
        selEcriture.addSelect(tableEcriture.getField("ID_MOUVEMENT"));
539
        selEcriture.setDistinct(true);
540
        Where w1 = new Where(tableEcriture.getField("DATE"), "<=", d);
541
        Where w2 = new Where(tableEcriture.getField("VALIDE"), "=", Boolean.FALSE);
542
        selEcriture.setWhere(w1.and(w2));
543
        List l = (List) base.getDataSource().execute(selEcriture.asString(), new ArrayListHandler());
544
 
545
        // validation de tous les mouvements
546
        for (int i = 0; i < l.size(); i++) {
547
            Object[] tmp = (Object[]) l.get(i);
548
            System.err.println("Validation du mouvement " + tmp[0]);
549
            validationEcritures(Integer.parseInt(tmp[0].toString()));
550
        }
551
 
552
        if (cloture) {
553
 
554
            SQLTable tableExercice = Configuration.getInstance().getBase().getTable("EXERCICE_COMMON");
555
 
556
            SQLRow rowSociete = ((ComptaPropsConfiguration) Configuration.getInstance()).getRowSociete();
557
            SQLRow rowExercice = tableExercice.getRow(rowSociete.getInt("ID_EXERCICE_COMMON"));
558
            Date dateCloture = (Date) rowExercice.getObject("DATE_CLOTURE");
559
 
560
            if (dateCloture == null || dateCloture.before(d)) {
561
 
562
                SQLRowValues rowVals = new SQLRowValues(tableExercice);
563
                rowVals.put("DATE_CLOTURE", new java.sql.Date(d.getTime()));
564
                try {
565
                    rowVals.update(rowExercice.getID());
566
                } catch (SQLException e) {
567
                    e.printStackTrace();
568
                }
569
            }
570
        }
571
    }
572
 
573
    private static final void valideEcriture(int id) {
574
        SQLTable tableEcriture = ((ComptaPropsConfiguration) Configuration.getInstance()).getSQLBaseSociete().getTable("ECRITURE");
575
        SQLRowValues rowVals = new SQLRowValues(tableEcriture);
576
        rowVals.put("VALIDE", Boolean.TRUE);
577
        rowVals.put("DATE_VALIDE", new java.sql.Date(new Date().getTime()));
578
        rowVals.put("IDUSER_VALIDE", UserManager.getInstance().getCurrentUser().getId());
579
 
580
        try {
581
            rowVals.update(id);
582
        } catch (SQLException e) {
583
            e.printStackTrace();
584
        }
585
    }
586
 
587
    public void archiveMouvement(int idMvt) {
588
        SQLTable tableMouvement = ((ComptaPropsConfiguration) Configuration.getInstance()).getSQLBaseSociete().getTable("MOUVEMENT");
589
        SQLRow rowMvt = tableMouvement.getRow(idMvt);
590
 
591
        if (rowMvt.getInt("ID_MOUVEMENT_PERE") > 1) {
592
            archiveMouvement(rowMvt.getInt("ID_MOUVEMENT_PERE"));
593
        } else {
594
            archiveMouvementProfondeur(idMvt, true);
595
        }
596
    }
597
 
598
    /**
599
     * Archivage de l'ensemble des opérations liés au mouvement passé en parametre
600
     *
601
     * @param idMvtPere mouvement racine
602
     * @param dropPere suppression du mouvement pere
603
     */
604
    public void archiveMouvementProfondeur(int idMvtPere, boolean dropPere) {
605
        if (idMvtPere > 1) {
606
            SQLBase base = ((ComptaPropsConfiguration) Configuration.getInstance()).getSQLBaseSociete();
607
            SQLTable tableMvt = ((ComptaPropsConfiguration) Configuration.getInstance()).getSQLBaseSociete().getTable("MOUVEMENT");
608
 
73 ilm 609
            SQLSelect selectFils = new SQLSelect();
18 ilm 610
            selectFils.addSelect(tableMvt.getField("ID"));
65 ilm 611
            selectFils.setWhere(tableMvt.getField("ID_MOUVEMENT_PERE"), "=", idMvtPere);
18 ilm 612
 
613
            List l = (List) base.getDataSource().execute(selectFils.asString(), new ArrayListHandler());
614
 
615
            // archive mouvements fils
616
            for (int i = 0; i < l.size(); i++) {
617
                Object[] tmp = (Object[]) l.get(i);
618
                archiveMouvementProfondeur(Integer.parseInt(tmp[0].toString()), true);
619
            }
620
 
621
            // archive mouvement
622
            archiveEcritures(idMvtPere, dropPere);
623
 
624
        } else {
625
 
626
            System.err.println("Suppression du mouvement d'id 1 impossible.");
83 ilm 627
            JOptionPane.showMessageDialog(null, "Impossible d'archiver, le mouvement est indéfini.");
18 ilm 628
        }
629
    }
630
 
631
    // Suppression des ecritures associées à un mouvement
93 ilm 632
    public synchronized void archiveEcritures(final int idMvt, final boolean dropMvt) {
18 ilm 633
        final SQLBase base = ((ComptaPropsConfiguration) Configuration.getInstance()).getSQLBaseSociete();
634
        final SQLTable tableMvt = base.getTable("MOUVEMENT");
635
        final SQLTable tableEcriture = base.getTable("ECRITURE");
636
        final SQLRow rowMvt = tableMvt.getRow(idMvt);
637
 
638
        // on verifie que le mouvement n'est pas validé
639
        if (MouvementSQLElement.isEditable(idMvt)) {
640
 
641
            // on archive le mouvement
642
            if (dropMvt) {
174 ilm 643
 
644
                SQLElement elt = getDirectory().getElement(tableMvt);
645
 
18 ilm 646
                try {
647
                    elt.archive(idMvt);
648
                } catch (SQLException e) {
649
                    ExceptionHandler.handle("Erreur lors de la suppression du mouvement d'id [" + idMvt + "]", e);
650
                    e.printStackTrace();
651
                }
652
            } else {
653
 
654
                SQLFactory<Object> sqlFactory = new SQLFactory<Object>() {
655
                    @Override
656
                    public Object create() throws SQLException {
657
                        // on recupere l'ensemble des ecritures associées au mouvement
73 ilm 658
                        SQLSelect selEcritures = new SQLSelect();
18 ilm 659
                        selEcritures.addSelect(tableEcriture.getField("ID"));
65 ilm 660
                        selEcritures.setWhere(tableEcriture.getField("ID_MOUVEMENT"), "=", idMvt);
18 ilm 661
 
662
                        List l = (List) base.getDataSource().execute(selEcritures.asString(), new ArrayListHandler());
663
                        for (int i = 0; i < l.size(); i++) {
664
                            Object[] tmp = (Object[]) l.get(i);
73 ilm 665
                            archiveEcriture(tableEcriture.getRow(Integer.parseInt(tmp[0].toString())));
18 ilm 666
                        }
667
 
668
                        return null;
669
                    }
670
                };
671
 
672
                try {
673
                    SQLUtils.executeAtomic(base.getDataSource(), sqlFactory);
674
                } catch (SQLException e) {
73 ilm 675
 
676
                    ExceptionHandler.handle("Une erreur est survenue lors de la suppression des écritures.", e);
18 ilm 677
                }
678
            }
679
 
680
        } else {
156 ilm 681
            JOptionPane.showMessageDialog(null, "Impossible de supprimer le mouvement n°" + rowMvt.getInt("NUMERO") + " car il est validé.");
18 ilm 682
        }
683
    }
684
 
685
    @Override
132 ilm 686
    protected void archive(TreesOfSQLRows trees, boolean cutLinks) throws SQLException {
687
        for (SQLRow row : trees.getRows()) {
688
            // Si on supprime une ecriture on doit supprimer toutes les ecritures du mouvement
689
            // associé
690
            System.err.println("Archivage des écritures");
691
            // archiveMouvement(row.getInt("ID_MOUVEMENT"));
692
            JFrame frame = new PanelFrame(new SuppressionEcrituresPanel(row.getInt("ID_MOUVEMENT")), "Suppression d'ecritures");
693
            frame.pack();
694
            frame.setResizable(false);
695
            frame.setLocationRelativeTo(null);
696
            frame.setVisible(true);
697
        }
18 ilm 698
    }
699
 
700
    /**
701
     * Permet d'archiver une ecriture seule attention méthode à utiliser en vérifiant que la balance
702
     * est respectée
703
     *
704
     * @param row
705
     * @throws SQLException
706
     */
707
    public void archiveEcriture(SQLRow row) throws SQLException {
708
 
709
        if (!row.getBoolean("VALIDE")) {
710
 
711
            SQLRowValues rowVals = new SQLRowValues(this.getTable());
712
            rowVals.put("IDUSER_DELETE", UserManager.getInstance().getCurrentUser().getId());
132 ilm 713
            rowVals.put("ARCHIVE", 1);
18 ilm 714
            rowVals.update(row.getID());
715
 
83 ilm 716
            // Annulation du lettrage si l'ecriture est lettrée pour ne pas avoir de lettrage
717
            // déséquilibré
718
            final String codeLettrage = row.getString("LETTRAGE");
719
            if (codeLettrage != null && codeLettrage.trim().length() > 0) {
720
                UpdateBuilder builder = new UpdateBuilder(getTable());
721
                builder.setObject("LETTRAGE", "");
722
                builder.setObject("DATE_LETTRAGE", null);
723
                builder.setWhere(new Where(getTable().getField("LETTRAGE"), "=", codeLettrage));
724
                getTable().getDBSystemRoot().getDataSource().execute(builder.asString());
725
            }
726
 
132 ilm 727
            // super.archive(row, true);
18 ilm 728
        } else {
729
            System.err.println("Impossible de supprimer une ecriture validée");
730
            JOptionPane.showMessageDialog(null, "Impossible de supprimer une ecriture validée. \n" + row);
731
        }
732
    }
733
 
734
    private static EditFrame frameSaisieKm = null;
735
 
736
    /**
737
     * Contrepassation d'un piece comptable à partir de l'id d'une écriture. Chargement d'un panel
738
     * Saisie au Km avec les ecritures inversées
739
     *
740
     * @param id
741
     */
742
    public static void contrePassationPiece(int id) {
743
 
744
        SQLBase base = ((ComptaPropsConfiguration) Configuration.getInstance()).getSQLBaseSociete();
745
 
746
        SQLTable tableEcriture = base.getTable("ECRITURE");
747
        SQLRow rowEcr = tableEcriture.getRow(id);
748
        final int idMvt = rowEcr.getInt("ID_MOUVEMENT");
749
        System.err.println("ID MOUVEMENT --> " + idMvt);
750
        if (frameSaisieKm == null) {
751
            frameSaisieKm = new EditFrame(Configuration.getInstance().getDirectory().getElement("SAISIE_KM"));
752
        }
753
 
754
        SwingUtilities.invokeLater(new Runnable() {
755
            public void run() {
756
                SaisieKmSQLElement.loadContrePassation(frameSaisieKm.getSQLComponent(), idMvt);
757
            }
758
        });
759
        frameSaisieKm.setVisible(true);
760
    }
57 ilm 761
 
762
    @Override
763
    protected String createCode() {
156 ilm 764
        return createCodeOfPackage() + ".entry.item";
57 ilm 765
    }
80 ilm 766
 
767
    public static void dupliquer(SQLRow selectedRow) {
768
 
769
        final SQLRow foreignMvt = selectedRow.getForeign("ID_MOUVEMENT");
770
        if (foreignMvt.getString("SOURCE").equalsIgnoreCase("SAISIE_KM")) {
771
            final SQLElement elementSaisieKm = Configuration.getInstance().getDirectory().getElement("SAISIE_KM");
772
            final SQLElement elementSaisieKmItem = Configuration.getInstance().getDirectory().getElement("SAISIE_KM_ELEMENT");
773
            final EditFrame frameCloneSaisieKm = new EditFrame(elementSaisieKm);
774
            int idSource = foreignMvt.getInt("IDSOURCE");
775
            SQLRow rowKm = elementSaisieKm.getTable().getRow(idSource);
776
            final SQLRowValues rowVals = elementSaisieKm.createCopy(idSource);
777
            rowVals.put("ID_MOUVEMENT", null);
778
            Collection<SQLRow> items = rowKm.getReferentRows(elementSaisieKm.getTable().getTable("SAISIE_KM_ELEMENT"));
779
            for (SQLRow sqlRow : items) {
780
                SQLRowValues sqlRowValues = elementSaisieKmItem.createCopy(sqlRow.getID());
781
                sqlRowValues.put("ID_ECRITURE", null);
782
                sqlRowValues.put("ID_SAISIE_KM", rowVals);
783
                System.err.println("ADD ELEMENT KM :: " + sqlRowValues.getID());
784
            }
785
 
786
            SwingUtilities.invokeLater(new Runnable() {
787
                public void run() {
788
                    frameCloneSaisieKm.getSQLComponent().select(rowVals);
789
                }
790
            });
791
            frameCloneSaisieKm.setVisible(true);
792
        } else {
793
            SwingUtilities.invokeLater(new Runnable() {
794
                public void run() {
795
                    JOptionPane.showMessageDialog(null, "La duplication n'est possible que sur les saisies au kilomètre");
796
                }
797
            });
798
        }
799
    }
18 ilm 800
}