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.model;
15
 
16
import org.openconcerto.erp.config.ComptaPropsConfiguration;
174 ilm 17
import org.openconcerto.erp.core.customerrelationship.mail.EmailTemplate;
18
import org.openconcerto.erp.core.customerrelationship.mail.ValueListener;
18 ilm 19
import org.openconcerto.erp.generationDoc.AbstractSheetXml;
20
import org.openconcerto.sql.Configuration;
41 ilm 21
import org.openconcerto.sql.model.SQLBase;
18 ilm 22
import org.openconcerto.sql.model.SQLField;
23
import org.openconcerto.sql.model.SQLRow;
19 ilm 24
import org.openconcerto.sql.model.SQLRowAccessor;
93 ilm 25
import org.openconcerto.sql.model.SQLRowValues;
18 ilm 26
import org.openconcerto.sql.model.SQLTable;
27
import org.openconcerto.sql.view.list.IListe;
19 ilm 28
import org.openconcerto.sql.view.list.RowAction;
18 ilm 29
import org.openconcerto.ui.EmailComposer;
30
import org.openconcerto.utils.ExceptionHandler;
156 ilm 31
import org.openconcerto.utils.ListMap;
174 ilm 32
import org.openconcerto.utils.i18n.TranslationManager;
18 ilm 33
 
34
import java.awt.event.ActionEvent;
35
import java.io.File;
36
import java.lang.reflect.Constructor;
37
import java.util.ArrayList;
38
import java.util.List;
39
import java.util.Set;
156 ilm 40
import java.util.StringJoiner;
18 ilm 41
 
42
import javax.swing.AbstractAction;
65 ilm 43
import javax.swing.Action;
73 ilm 44
import javax.swing.JOptionPane;
41 ilm 45
import javax.swing.SwingUtilities;
18 ilm 46
 
25 ilm 47
public class MouseSheetXmlListeListener {
18 ilm 48
 
49
    private Class<? extends AbstractSheetXml> clazz;
50
    protected IListe liste;
51
 
52
    private boolean previewIsVisible = true;
53
    private boolean showIsVisible = true;
54
    private boolean printIsVisible = true;
55
    private boolean generateIsVisible = true;
28 ilm 56
    private boolean previewHeader = false;
57
    private boolean showHeader = false;
58
    private boolean generateHeader = false;
18 ilm 59
 
25 ilm 60
    public MouseSheetXmlListeListener(Class<? extends AbstractSheetXml> clazz) {
61
        this(clazz, true, true, true, true);
62
 
18 ilm 63
    }
64
 
25 ilm 65
    public MouseSheetXmlListeListener(Class<? extends AbstractSheetXml> clazz, boolean show, boolean preview, boolean print, boolean generate) {
18 ilm 66
        this.clazz = clazz;
67
        this.printIsVisible = print;
68
        this.previewIsVisible = preview;
69
        this.showIsVisible = show;
70
        this.generateIsVisible = generate;
71
    }
72
 
73
    protected Class<? extends AbstractSheetXml> getSheetClass() {
74
        return this.clazz;
75
    }
76
 
77
    protected AbstractSheetXml createAbstractSheet(SQLRow row) {
41 ilm 78
        try {
79
            Constructor<? extends AbstractSheetXml> ctor = getSheetClass().getConstructor(SQLRow.class);
80
            AbstractSheetXml sheet = ctor.newInstance(row);
81
            return sheet;
82
        } catch (Exception e) {
73 ilm 83
            ExceptionHandler.handle("sheet creation error", e);
18 ilm 84
        }
41 ilm 85
        return null;
18 ilm 86
    }
87
 
142 ilm 88
    public List<AbstractSheetXml> createAbstractSheets(List<SQLRow> rows) {
149 ilm 89
        final List<AbstractSheetXml> sheets = new ArrayList<>(rows.size());
142 ilm 90
        try {
91
            final Constructor<? extends AbstractSheetXml> ctor = getSheetClass().getConstructor(SQLRow.class);
92
            for (SQLRow row : rows) {
93
                AbstractSheetXml sheet = ctor.newInstance(row);
94
                sheets.add(sheet);
95
            }
96
        } catch (Exception e) {
97
            ExceptionHandler.handle("sheet creation error", e);
98
        }
99
        return sheets;
100
    }
101
 
41 ilm 102
    protected String getMailObject(SQLRow row) {
103
        return "";
104
    }
105
 
28 ilm 106
    public void setPreviewHeader(boolean previewHeader) {
107
        this.previewHeader = previewHeader;
108
    }
18 ilm 109
 
28 ilm 110
    public void setGenerateHeader(boolean generateHeader) {
111
        this.generateHeader = generateHeader;
112
    }
18 ilm 113
 
28 ilm 114
    public void setShowHeader(boolean showHeader) {
115
        this.showHeader = showHeader;
116
    }
117
 
174 ilm 118
    protected void sendMail(EmailTemplate template, final AbstractSheetXml sheet, final boolean readOnly) {
156 ilm 119
        List<AbstractSheetXml> l = new ArrayList<>(1);
142 ilm 120
        l.add(sheet);
174 ilm 121
        sendMail(template, l, readOnly);
142 ilm 122
    }
28 ilm 123
 
174 ilm 124
    protected void sendMail(EmailTemplate template, final List<AbstractSheetXml> sheets, final boolean readOnly) {
156 ilm 125
        final Thread t = new Thread() {
126
            @Override
127
            public void run() {
128
                ListMap<String, File> mailFilesMap = new ListMap<>();
129
                for (AbstractSheetXml sheet : sheets) {
130
                    String mail = "";
131
                    final SQLRow row = sheet.getSQLRow();
132
                    Set<SQLField> setContact = null;
133
                    SQLTable tableContact = Configuration.getInstance().getRoot().findTable("CONTACT");
134
                    setContact = row.getTable().getForeignKeys(tableContact);
18 ilm 135
 
156 ilm 136
                    Set<SQLField> setClient = null;
137
                    SQLTable tableClient = ((ComptaPropsConfiguration) Configuration.getInstance()).getSQLBaseSociete().getTable("CLIENT");
138
                    setClient = row.getTable().getForeignKeys(tableClient);
18 ilm 139
 
156 ilm 140
                    for (SQLField field : setContact) {
142 ilm 141
                        if (mail == null || mail.trim().length() == 0) {
156 ilm 142
                            mail = row.getForeignRow(field.getName()).getString("EMAIL");
142 ilm 143
                        }
18 ilm 144
                    }
156 ilm 145
                    String nomClient = "";
146
                    if (setClient != null && (mail == null || mail.trim().length() == 0)) {
147
                            for (SQLField field : setClient) {
148
                                SQLRow rowCli = row.getForeignRow(field.getName());
149
                                if (mail == null || mail.trim().length() == 0) {
150
                                    mail = rowCli.getString("MAIL");
151
                                }
152
                                nomClient = rowCli.getString("NOM");
153
                            }
154
                    }
18 ilm 155
 
156 ilm 156
                    if (mail.trim().length() == 0) {
157
                        mail = nomClient;
158
                    }
41 ilm 159
 
156 ilm 160
                    String table = row.getTable().getName();
161
                    if (table.equalsIgnoreCase("COMMANDE") || table.equalsIgnoreCase("DEMANDE_PRIX") || table.equalsIgnoreCase("FACTURE_FOURNISSEUR")) {
162
                        mail = "";
163
                    }
164
                    if (mail == null || mail.trim().length() == 0) {
165
                        SQLTable tableF = ((ComptaPropsConfiguration) Configuration.getInstance()).getSQLBaseSociete().getTable("FOURNISSEUR");
166
                        Set<SQLField> setF = null;
167
                        setF = row.getTable().getForeignKeys(tableF);
41 ilm 168
 
156 ilm 169
                        if (setF != null) {
170
 
171
                            for (SQLField field : setF) {
172
                                SQLRow rowF = row.getForeignRow(field.getName());
173
                                if (mail == null || mail.trim().length() == 0) {
174
                                    mail = rowF.getString("MAIL");
175
                                }
176
                            }
142 ilm 177
                        }
41 ilm 178
 
156 ilm 179
                        if (mail == null || mail.trim().length() == 0) {
180
                            SQLBase base = ((ComptaPropsConfiguration) Configuration.getInstance()).getSQLBaseSociete();
181
                            if (base.containsTable("MONTEUR")) {
182
                                SQLTable tableM = ((ComptaPropsConfiguration) Configuration.getInstance()).getSQLBaseSociete().getTable("MONTEUR");
183
                                Set<SQLField> setM = null;
184
                                setM = row.getTable().getForeignKeys(tableM);
185
                                if (setM != null) {
186
                                    for (SQLField field : setM) {
187
                                        SQLRow rowM = row.getForeignRow(field.getName());
188
                                        if (rowM.getForeignRow("ID_CONTACT_FOURNISSEUR") != null && !rowM.getForeignRow("ID_CONTACT_FOURNISSEUR").isUndefined()) {
189
                                            mail = rowM.getForeignRow("ID_CONTACT_FOURNISSEUR").getString("EMAIL");
190
                                        }
191
                                    }
142 ilm 192
                                }
41 ilm 193
                            }
194
                        }
156 ilm 195
                        if (mail == null || mail.trim().length() == 0) {
196
                            SQLBase base = ((ComptaPropsConfiguration) Configuration.getInstance()).getSQLBaseSociete();
197
                            if (base.containsTable("TRANSPORTEUR")) {
41 ilm 198
 
156 ilm 199
                                SQLTable tableM = ((ComptaPropsConfiguration) Configuration.getInstance()).getSQLBaseSociete().getTable("TRANSPORTEUR");
200
                                Set<SQLField> setM = null;
201
                                setM = row.getTable().getForeignKeys(tableM);
41 ilm 202
 
156 ilm 203
                                if (setM != null) {
41 ilm 204
 
156 ilm 205
                                    for (SQLField field : setM) {
206
                                        SQLRow rowM = row.getForeignRow(field.getName());
207
                                        if (rowM.getForeignRow("ID_CONTACT_FOURNISSEUR") != null && !rowM.getForeignRow("ID_CONTACT_FOURNISSEUR").isUndefined()) {
208
                                            mail = rowM.getForeignRow("ID_CONTACT_FOURNISSEUR").getString("EMAIL");
209
                                        }
210
                                    }
142 ilm 211
                                }
41 ilm 212
                            }
213
                        }
214
                    }
156 ilm 215
                    try {
216
                        if (readOnly) {
217
                            mailFilesMap.add(mail, sheet.getOrCreatePDFDocumentFile(true).getAbsoluteFile());
218
                        } else {
219
                            mailFilesMap.add(mail, sheet.getOrCreateDocumentFile().getAbsoluteFile());
220
 
221
                        }
222
                    } catch (Exception e) {
223
                        ExceptionHandler.handle("Impossible de charger le document PDF", e);
224
                    }
41 ilm 225
                }
18 ilm 226
 
156 ilm 227
                for (final String mailDest : mailFilesMap.keySet()) {
19 ilm 228
 
156 ilm 229
                    final List<File> files = mailFilesMap.get(mailDest);
142 ilm 230
 
156 ilm 231
                    SwingUtilities.invokeLater(new Runnable() {
41 ilm 232
 
156 ilm 233
                        @Override
234
                        public void run() {
235
                            try {
236
                                String subject = sheets.get(0).getReference();
174 ilm 237
                                if (template != null) {
238
                                    subject = template.getTitle() + " " + sheets.get(0).getReference().trim();
239
                                }
240
                                subject = subject.trim();
156 ilm 241
                                if (subject.isEmpty()) {
242
                                    final StringJoiner joiner = new StringJoiner(", ");
243
                                    for (File f : files) {
244
                                        joiner.add(f.getName());
245
                                    }
246
                                    subject = joiner.toString();
41 ilm 247
                                }
174 ilm 248
                                String message = getMailObject(sheets.get(0).getSQLRow());
249
                                if (template != null) {
250
                                    if (template.getText().contains("{message}")) {
251
                                        message = template.getText().replace("{message}", message);
252
                                    } else {
253
                                        message += template.getText();
254
                                    }
255
                                }
156 ilm 256
                                EmailComposer.getInstance().compose(mailDest, subject, message, files.toArray(new File[files.size()]));
257
                            } catch (Exception e) {
258
                                ExceptionHandler.handle("Impossible d'envoyer le courriel!", e);
41 ilm 259
                            }
156 ilm 260
                        }
261
                    });
18 ilm 262
                }
156 ilm 263
 
18 ilm 264
            }
265
 
156 ilm 266
        };
267
        t.start();
268
 
18 ilm 269
    }
270
 
25 ilm 271
    public List<RowAction> addToMenu() {
18 ilm 272
        return null;
273
    }
274
 
19 ilm 275
    public List<RowAction> getRowActions() {
149 ilm 276
        List<RowAction> l = new ArrayList<>();
19 ilm 277
 
278
        if (!Boolean.getBoolean("org.openconcerto.oo.useODSViewer")) {
279
            if (this.showIsVisible) {
67 ilm 280
                RowAction action = new RowAction(new AbstractAction() {
19 ilm 281
                    public void actionPerformed(ActionEvent ev) {
149 ilm 282
                        try {
283
                            createAbstractSheet(IListe.get(ev).fetchSelectedRow()).openDocument(false);
284
                        } catch (Exception e) {
285
                            ExceptionHandler.handle("Impossible d'ouvrir le fichier", e);
286
                        }
19 ilm 287
                    }
288
 
67 ilm 289
                }, this.previewHeader, "document.modify") {
142 ilm 290
 
19 ilm 291
                    @Override
21 ilm 292
                    public boolean enabledFor(IListeEvent evt) {
149 ilm 293
                        // On ne teste pas l'existence du fichier génété car les IOs peuvent prendre
294
                        // du temps
295
                        return evt.getSelectedRow() != null && (evt.getTotalRowCount() >= 1);
19 ilm 296
                    }
65 ilm 297
 
28 ilm 298
                };
299
                l.add(action);
19 ilm 300
 
301
            }
302
        } else {
174 ilm 303
            // ODS Viewer
19 ilm 304
            if (this.previewIsVisible) {
67 ilm 305
                l.add(new RowAction(new AbstractAction() {
19 ilm 306
                    public void actionPerformed(ActionEvent ev) {
25 ilm 307
                        try {
174 ilm 308
                            final AbstractSheetXml sheet = createAbstractSheet(IListe.get(ev).fetchSelectedRow());
309
                            final SQLTable table = IListe.get(ev).getSource().getPrimaryTable();
310
                            sheet.showPreviewDocument(TranslationManager.getInstance().getTranslationForAction("email"), new Runnable() {
311
 
312
                                @Override
313
                                public void run() {
314
                                    EmailTemplate.askTemplate(IListe.get(ev), table.getDBRoot(), new ValueListener() {
315
 
316
                                        @Override
317
                                        public void valueSelected(Object value) {
318
                                            sendMail((EmailTemplate) value, sheet, true);
319
                                        }
320
                                    });
321
 
322
                                }
323
                            });
25 ilm 324
                        } catch (Exception e) {
149 ilm 325
                            ExceptionHandler.handle("Impossible d'ouvrir le fichier", e);
25 ilm 326
                        }
19 ilm 327
                    }
328
 
67 ilm 329
                }, this.previewHeader, "document.preview") {
25 ilm 330
 
19 ilm 331
                    @Override
25 ilm 332
                    public boolean enabledFor(IListeEvent evt) {
149 ilm 333
                        // On ne teste pas l'existence du fichier génété car les IOs peuvent prendre
334
                        // du temps
335
                        return evt.getSelectedRow() != null && evt.getTotalRowCount() >= 1;
19 ilm 336
                    }
337
                });
25 ilm 338
 
19 ilm 339
            }
340
        }
341
 
342
        // action supplémentaire
25 ilm 343
        List<RowAction> list = addToMenu();
19 ilm 344
        if (list != null) {
25 ilm 345
            for (RowAction rowAction : list) {
346
                l.add(rowAction);
19 ilm 347
            }
348
        }
349
 
149 ilm 350
        if (Boolean.getBoolean("org.openconcerto.oo.useODSViewer") && this.showIsVisible) {
351
            l.add(new RowAction(new AbstractAction() {
352
                public void actionPerformed(ActionEvent ev) {
353
                    try {
80 ilm 354
                        createAbstractSheet(IListe.get(ev).fetchSelectedRow()).openDocument(false);
149 ilm 355
                    } catch (Exception e) {
356
                        ExceptionHandler.handle("Impossible d'ouvrir le fichier", e);
19 ilm 357
                    }
149 ilm 358
                }
359
            }, this.showHeader, "document.modify") {
142 ilm 360
 
149 ilm 361
                @Override
362
                public boolean enabledFor(IListeEvent evt) {
363
                    // On ne teste pas l'existence du fichier génété car les IOs peuvent prendre
364
                    // du temps
365
                    return evt.getSelectedRow() != null && evt.getTotalRowCount() >= 1;
366
                }
367
            });
368
 
19 ilm 369
        }
370
 
371
        if (this.printIsVisible) {
372
 
132 ilm 373
            // Impression rapide : imprime le ou les documents sélectionnés (les génère si besoin)
374
            // en proposant l'interface Java d'impression
149 ilm 375
            l.add(new RowAction(new PrintDocumentAction(this), false, "document.print") {
65 ilm 376
 
19 ilm 377
                @Override
25 ilm 378
                public boolean enabledFor(IListeEvent evt) {
132 ilm 379
                    return evt.getSelectedRow() != null && evt.getSelectedRows().size() > 0;
19 ilm 380
                }
381
            });
382
 
383
        }
384
 
149 ilm 385
        if (this.showIsVisible)
19 ilm 386
 
149 ilm 387
        {
388
 
144 ilm 389
            l.add(getSendMailPDF());
142 ilm 390
 
144 ilm 391
            l.add(getSendMail());
142 ilm 392
 
19 ilm 393
        }
394
        if (this.generateIsVisible) {
67 ilm 395
            l.add(new RowAction(new AbstractAction() {
19 ilm 396
                public void actionPerformed(ActionEvent ev) {
93 ilm 397
                    List<SQLRowValues> l = IListe.get(ev).getSelectedRows();
90 ilm 398
 
399
                    if (l.size() == 1) {
400
                        createDocument(ev);
401
                    } else {
402
                        createDocuments(l);
403
                    }
19 ilm 404
                }
67 ilm 405
            }, this.generateHeader, "document.create") {
73 ilm 406
 
19 ilm 407
                @Override
93 ilm 408
                public boolean enabledFor(List<SQLRowValues> selection) {
156 ilm 409
                    return selection != null && !selection.isEmpty();
19 ilm 410
                }
65 ilm 411
 
19 ilm 412
            });
413
        }
414
 
415
        return l;
416
    }
65 ilm 417
 
144 ilm 418
    public RowAction getSendMail() {
419
        return new RowAction(new AbstractAction() {
420
            public void actionPerformed(ActionEvent ev) {
174 ilm 421
                sendMail(ev, false);
144 ilm 422
            }
423
        }, false, "document.send.email") {
424
 
425
            @Override
426
            public boolean enabledFor(IListeEvent evt) {
149 ilm 427
                // On ne teste pas l'existence du fichier génété car les IOs peuvent prendre du
428
                // temps
429
                return evt.getSelectedRow() != null && evt.getTotalRowCount() >= 1;
144 ilm 430
            }
149 ilm 431
 
144 ilm 432
        };
433
    }
434
 
435
    public RowAction getSendMailPDF() {
436
        return new RowAction(new AbstractAction() {
437
            public void actionPerformed(ActionEvent ev) {
174 ilm 438
                sendMail(ev, true);
144 ilm 439
            }
440
        }, false, "document.pdf.send.email") {
441
 
442
            @Override
443
            public boolean enabledFor(IListeEvent evt) {
149 ilm 444
                // On ne teste pas l'existence du fichier génété car les IOs peuvent prendre du
445
                // temps
446
                return evt.getSelectedRow() != null && evt.getTotalRowCount() >= 1;
144 ilm 447
            }
149 ilm 448
 
144 ilm 449
        };
450
 
451
    }
452
 
93 ilm 453
    private void createDocuments(List<? extends SQLRowAccessor> selection) {
90 ilm 454
        int a = JOptionPane.showConfirmDialog(null, "Voulez vous recréer l'ensemble des documents sélectionnés?", "Génération de documents", JOptionPane.YES_NO_OPTION);
455
        if (a == JOptionPane.YES_OPTION) {
456
            for (SQLRowAccessor sqlRowAccessor : selection) {
457
                final AbstractSheetXml sheet = createAbstractSheet(sqlRowAccessor.getTable().getRow(sqlRowAccessor.getID()));
458
                sheet.createDocumentAsynchronous();
459
                sheet.showPrintAndExportAsynchronous(false, false, true);
460
            }
461
        }
462
    }
463
 
73 ilm 464
    private void createDocument(ActionEvent ev) {
80 ilm 465
        final AbstractSheetXml sheet = createAbstractSheet(IListe.get(ev).fetchSelectedRow());
73 ilm 466
        if (sheet.getGeneratedFile().exists()) {
467
            int a = JOptionPane.showConfirmDialog(null, "Voulez vous remplacer le document existant?", "Génération de documents", JOptionPane.YES_NO_OPTION);
468
            if (a == JOptionPane.YES_OPTION) {
469
                sheet.createDocumentAsynchronous();
470
                sheet.showPrintAndExportAsynchronous(true, false, true);
471
                return;
472
            }
473
        }
474
 
475
        try {
476
            sheet.getOrCreateDocumentFile();
477
            sheet.showPrintAndExportAsynchronous(true, false, false);
478
        } catch (Exception exn) {
479
            exn.printStackTrace();
480
        }
481
 
482
    }
483
 
65 ilm 484
    /**
485
     * Action sur le double clic
486
     *
487
     * @return
488
     */
489
    public RowAction getDefaultRowAction() {
67 ilm 490
        return new RowAction(new AbstractAction() {
65 ilm 491
            public void actionPerformed(ActionEvent ev) {
80 ilm 492
                final AbstractSheetXml sheet = createAbstractSheet(IListe.get(ev).fetchSelectedRow().asRow());
65 ilm 493
                try {
494
                    sheet.getOrCreateDocumentFile();
495
                    sheet.showPrintAndExportAsynchronous(true, false, true);
496
                } catch (Exception exn) {
497
                    ExceptionHandler.handle("Une erreur est survenue lors de la création du document.", exn);
498
                }
499
            }
67 ilm 500
        }, false, false, "document.create") {
142 ilm 501
 
65 ilm 502
            @Override
93 ilm 503
            public boolean enabledFor(List<SQLRowValues> selection) {
65 ilm 504
                return selection != null && selection.size() == 1;
505
            }
506
 
507
            @Override
508
            public Action getDefaultAction(final IListeEvent evt) {
509
                return this.getAction();
510
            }
511
        };
512
    }
174 ilm 513
 
514
    private void sendMail(ActionEvent ev, boolean pdf) {
515
        final List<SQLRowValues> selectedRows = IListe.get(ev).getSelectedRows();
516
        final SQLTable table = IListe.get(ev).getSource().getPrimaryTable();
517
        final List<SQLRow> rows = new ArrayList<>();
518
        for (SQLRowValues r : selectedRows) {
519
            rows.add(table.getRow(r.getID()));
520
        }
521
 
522
        EmailTemplate.askTemplate(IListe.get(ev), table.getDBRoot(), new ValueListener() {
523
 
524
            @Override
525
            public void valueSelected(Object value) {
526
                sendMail((EmailTemplate) value, createAbstractSheets(rows), pdf);
527
            }
528
        });
529
    }
18 ilm 530
}