OpenConcerto

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

svn://code.openconcerto.org/openconcerto

Rev

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