OpenConcerto

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

svn://code.openconcerto.org/openconcerto

Rev

Rev 21 | Rev 57 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
18 ilm 1
/*
2
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
3
 *
4
 * Copyright 2011 OpenConcerto, by ILM Informatique. All rights reserved.
5
 *
6
 * The contents of this file are subject to the terms of the GNU General Public License Version 3
7
 * only ("GPL"). You may not use this file except in compliance with the License. You can obtain a
8
 * copy of the License at http://www.gnu.org/licenses/gpl-3.0.html See the License for the specific
9
 * language governing permissions and limitations under the License.
10
 *
11
 * When distributing the software, include this License Header Notice in each file.
12
 */
13
 
14
 package org.openconcerto.erp.generationDoc;
15
 
16
import org.openconcerto.erp.config.ComptaPropsConfiguration;
17
import org.openconcerto.erp.core.common.element.StyleSQLElement;
18
import org.openconcerto.openoffice.ODPackage;
19
import org.openconcerto.openoffice.spreadsheet.MutableCell;
20
import org.openconcerto.openoffice.spreadsheet.Sheet;
21
import org.openconcerto.openoffice.spreadsheet.SpreadSheet;
22
import org.openconcerto.sql.Configuration;
23
import org.openconcerto.sql.element.SQLElement;
24
import org.openconcerto.sql.model.SQLField;
25
import org.openconcerto.sql.model.SQLRow;
26
import org.openconcerto.sql.model.SQLRowAccessor;
27
import org.openconcerto.sql.model.SQLTable;
28
import org.openconcerto.utils.ExceptionHandler;
29
import org.openconcerto.utils.GestionDevise;
30
import org.openconcerto.utils.StreamUtils;
31
 
32
import java.awt.Point;
33
import java.io.File;
34
import java.io.FileNotFoundException;
35
import java.io.IOException;
36
import java.io.InputStream;
37
import java.lang.reflect.InvocationTargetException;
38
import java.text.DateFormat;
39
import java.text.SimpleDateFormat;
40
import java.util.Collection;
41
import java.util.Date;
42
import java.util.HashMap;
43
import java.util.List;
44
import java.util.Map;
45
 
46
import javax.swing.JOptionPane;
47
import javax.swing.SwingUtilities;
48
 
49
import org.jdom.Document;
50
import org.jdom.Element;
51
import org.jdom.JDOMException;
52
import org.jdom.input.SAXBuilder;
53
 
54
/**
55
 * Génération d'un document sxc à partir d'un modéle sxc et d'un fichier xml du meme nom (doc.sxc et
56
 * doc.xml) <element location="D4" (type="fill" || type="replace" replacePattern="_" ||
57
 * type="codesMissions" ||type="DescriptifArticle" || type="DateEcheance"> <field base="Societe"
58
 * table="AFFAIRE" name="NUMERO"/> </element>
59
 *
60
 *
61
 * @author Administrateur
62
 *
63
 */
64
public class OOgenerationXML {
65
 
66
    private static DateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy");
67
 
68
    // Cache pour la recherche des styles
69
    private static Map<Sheet, Map<String, Map<Integer, String>>> cacheStyle = new HashMap<Sheet, Map<String, Map<Integer, String>>>();
70
 
71
    // Cache pour les SQLRow du tableau
72
    private static Map<String, List<? extends SQLRowAccessor>> rowsEltCache = new HashMap<String, List<? extends SQLRowAccessor>>();
73
 
74
    private static int answer = JOptionPane.NO_OPTION;
75
 
25 ilm 76
    public static synchronized File createDocument(String templateId, File outputDirectory, final String expectedFileName, SQLRow row, SQLRow rowLanguage) {
77
        final String langage = rowLanguage != null ? rowLanguage.getString("CHEMIN") : null;
18 ilm 78
        cacheStyle.clear();
79
        OOXMLCache.clearCache();
80
        rowsEltCache.clear();
81
        taxe.clear();
82
        cacheForeign.clear();
83
 
25 ilm 84
        File fDest = new File(outputDirectory, expectedFileName);
18 ilm 85
 
86
        if (fDest.exists()) {
87
 
88
            if (SwingUtilities.isEventDispatchThread()) {
89
                answer = JOptionPane.showConfirmDialog(null, "Voulez vous regénérer et écraser l'ancien document?", "Génération du document", JOptionPane.YES_NO_OPTION);
90
                Thread.dumpStack();
91
            } else {
92
                try {
93
                    SwingUtilities.invokeAndWait(new Runnable() {
94
                        @Override
95
                        public void run() {
96
 
97
                            answer = JOptionPane.showConfirmDialog(null, "Voulez vous regénérer et écraser l'ancien document?", "Génération du document", JOptionPane.YES_NO_OPTION);
98
                        }
99
                    });
100
                } catch (InterruptedException e) {
101
                    e.printStackTrace();
102
                } catch (InvocationTargetException e) {
103
                    e.printStackTrace();
104
                }
105
            }
106
            if (answer != JOptionPane.YES_OPTION) {
107
                return fDest;
108
            }
109
        }
110
 
111
        Date d = new Date();
112
        SAXBuilder builder = new SAXBuilder();
113
        try {
114
 
25 ilm 115
            if (needAnnexe(templateId, row, rowLanguage)) {
116
                // check if it exists
117
                final String annexeTemplateId = templateId + "_annexe";
118
                InputStream annexeStream = TemplateManager.getInstance().getTemplate(annexeTemplateId, langage, null);
119
                if (annexeStream != null) {
120
                    templateId = annexeTemplateId;
121
                    System.err.println("modele With annexe " + templateId);
18 ilm 122
                }
123
            }
124
 
25 ilm 125
            System.err.println("Using template id: " + templateId);
126
            final InputStream xmlConfiguration = TemplateManager.getInstance().getTemplateConfiguration(templateId, langage, null);
18 ilm 127
 
25 ilm 128
            Document doc = builder.build(xmlConfiguration);
18 ilm 129
 
130
            // On initialise un nouvel élément racine avec l'élément racine du document.
131
            Element racine = doc.getRootElement();
132
 
133
            // Liste des <element>
134
            List<Element> listElts = racine.getChildren("element");
135
 
136
            // Création et génération du fichier OO
25 ilm 137
            final InputStream template = TemplateManager.getInstance().getTemplate(templateId, langage, null);
138
 
139
            final SpreadSheet spreadSheet = new ODPackage(template).getSpreadSheet();
19 ilm 140
            try {
141
                // On remplit les cellules de la feuille
142
                parseElementsXML(listElts, row, spreadSheet);
18 ilm 143
 
19 ilm 144
                // Liste des <element>
145
                List<Element> listTable = racine.getChildren("table");
18 ilm 146
 
19 ilm 147
                for (Element tableChild : listTable) {
148
                    // On remplit les cellules du tableau
149
                    parseTableauXML(tableChild, row, spreadSheet, rowLanguage);
150
                }
151
            } catch (Exception e) {
25 ilm 152
                ExceptionHandler.handle("Impossible de remplir le document " + templateId + " " + ((rowLanguage == null) ? "" : rowLanguage.getString("CHEMIN")), e);
18 ilm 153
            }
154
            // Sauvegarde du fichier
25 ilm 155
            return saveSpreadSheet(spreadSheet, outputDirectory, expectedFileName, templateId, rowLanguage);
18 ilm 156
 
157
        } catch (final JDOMException e) {
158
 
159
            e.printStackTrace();
160
            SwingUtilities.invokeLater(new Runnable() {
161
                public void run() {
25 ilm 162
                    ExceptionHandler.handle("Erreur lors de la génération du fichier " + expectedFileName, e);
18 ilm 163
                }
164
            });
165
        } catch (final IOException e) {
166
 
167
            e.printStackTrace();
168
            SwingUtilities.invokeLater(new Runnable() {
169
                public void run() {
25 ilm 170
                    ExceptionHandler.handle("Erreur lors de la création du fichier " + expectedFileName, e);
18 ilm 171
                }
172
            });
173
        }
174
        return null;
175
    }
176
 
177
    /**
178
     * Remplit le tableau
179
     *
180
     * @param tableau
181
     * @param elt
182
     * @param id
183
     * @param sheet
184
     */
19 ilm 185
    private static void parseTableauXML(Element tableau, SQLRow row, SpreadSheet spreadsheet, SQLRow rowLanguage) {
18 ilm 186
 
187
        if (tableau == null) {
188
            return;
189
        }
190
 
191
        Object o = tableau.getAttributeValue("sheet");
192
        int idSheet = (o == null) ? 0 : Integer.valueOf(o.toString().trim());
193
 
194
        Sheet sheet = spreadsheet.getSheet(idSheet);
195
        // Derniere colonne du tableau permet de ne pas chercher sur toutes les colonnes
196
        // et d'optimiser la recherche
197
        Object oLastColTmp = tableau.getAttributeValue("lastColumn");
198
        int lastColumn = -1;
199
        int endPageLine = Integer.valueOf(tableau.getAttributeValue("endPageLine"));
200
        if (oLastColTmp != null) {
201
            lastColumn = sheet.resolveHint(oLastColTmp.toString() + 1).x + 1;
202
        }
203
 
204
        Map<String, Map<Integer, String>> mapStyle = searchStyle(sheet, lastColumn, endPageLine);
205
 
206
        if (tableau.getAttributeValue("table").equalsIgnoreCase("TVA")) {
207
            fillTaxe(tableau, sheet, mapStyle, false);
208
            return;
209
        }
19 ilm 210
        int nbPage = fillTable(tableau, row, sheet, mapStyle, true, rowLanguage);
18 ilm 211
        int firstLine = Integer.valueOf(tableau.getAttributeValue("firstLine"));
212
        int endLine = Integer.valueOf(tableau.getAttributeValue("endLine"));
213
        Object printRangeObj = sheet.getPrintRanges();
214
 
215
        System.err.println("Nombre de page == " + nbPage);
216
        if (nbPage == 1) {
19 ilm 217
            fillTable(tableau, row, sheet, mapStyle, false, rowLanguage);
18 ilm 218
        } else {
219
            if (printRangeObj != null) {
220
                String s = printRangeObj.toString();
221
                String[] range = s.split(":");
222
 
223
                for (int i = 0; i < range.length; i++) {
224
                    String string = range[i];
225
                    range[i] = string.subSequence(string.indexOf('.') + 1, string.length()).toString();
226
                }
227
 
228
                int rowEnd = -1;
229
                if (range.length > 1) {
230
                    rowEnd = sheet.resolveHint(range[1]).y + 1;
19 ilm 231
                    int rowEndNew = rowEnd * (nbPage);
18 ilm 232
                    String sNew = s.replaceAll(String.valueOf(rowEnd), String.valueOf(rowEndNew));
233
                    sheet.setPrintRanges(sNew);
234
                    System.err.println(" ******  Replace print ranges; Old:" + rowEnd + "--" + s + " New:" + rowEndNew + "--" + sNew);
235
                }
236
            }
237
 
238
            // le nombre d'éléments ne tient pas dans le tableau du modéle
239
            // On duplique la premiere page sans ce qui se trouve apres le tableau
240
            sheet.duplicateFirstRows(endLine, 1);
241
 
242
            // On agrandit le tableau pour qu'il remplisse la premiere page
243
            int lineToAdd = endPageLine - endLine;
244
            String repeatedCount = tableau.getAttributeValue("repeatedCount");
245
            if (repeatedCount != null && repeatedCount.trim().length() > 0) {
246
                int count = Integer.valueOf(repeatedCount);
247
                sheet.duplicateRows(firstLine, lineToAdd / count, count);
248
                final int rest = lineToAdd % count;
249
                // Si le nombre de ligne ne termine pas à la fin de la page
250
                if (rest != 0) {
251
                    sheet.insertDuplicatedRows(firstLine + lineToAdd - rest, rest);
252
                }
253
            } else {
254
                sheet.insertDuplicatedRows(firstLine, lineToAdd);
255
            }
256
 
257
            // On duplique la premiere page si on a besoin de plus de deux pages
258
            System.err.println("nbPage == " + nbPage);
259
            if (nbPage > 2) {
260
                sheet.duplicateFirstRows(endPageLine, nbPage - 2);
261
            }
19 ilm 262
            String pageRef = tableau.getAttributeValue("pageRef");
263
            if (pageRef != null && pageRef.trim().length() > 0) {
264
                MutableCell<SpreadSheet> cell = sheet.getCellAt(pageRef);
265
                cell.setValue("Page 1/" + nbPage);
266
                for (int i = 1; i < nbPage; i++) {
267
                    MutableCell<SpreadSheet> cell2 = sheet.getCellAt(cell.getX(), cell.getY() + (endPageLine * i));
268
                    cell2.setValue("Page " + (i + 1) + "/" + nbPage);
269
                }
270
            }
271
            fillTable(tableau, row, sheet, mapStyle, false, rowLanguage);
18 ilm 272
        }
273
 
274
    }
275
 
276
    /**
277
     * Remplit le tableau d'éléments avec les données
278
     *
279
     * @param tableau Element Xml contenant les informations sur le tableau
280
     * @param elt SQLElement (ex : Bon de livraison)
281
     * @param id id de l'élément de la table
282
     * @param sheet feuille calc à remplir
283
     * @param mapStyle styles trouvés dans la page
284
     * @param test remplir ou non avec les valeurs
285
     * @return le nombre de page
286
     */
287
    static Map<SQLRowAccessor, Map<String, Object>> taxe = new HashMap<SQLRowAccessor, Map<String, Object>>();
288
    private static Map<String, Map<Integer, SQLRowAccessor>> cacheForeign = new HashMap<String, Map<Integer, SQLRowAccessor>>();
289
 
290
    protected static SQLRowAccessor getForeignRow(SQLRowAccessor row, SQLField field) {
291
        Map<Integer, SQLRowAccessor> c = cacheForeign.get(field.getName());
292
 
293
        int i = row.getInt(field.getName());
294
 
295
        if (c != null && c.get(i) != null) {
296
            System.err.println("get foreign row From Cache ");
297
            return c.get(i);
298
        } else {
299
 
300
            SQLRowAccessor foreign = row.getForeign(field.getName());
301
 
302
            if (c == null) {
303
                Map<Integer, SQLRowAccessor> map = new HashMap<Integer, SQLRowAccessor>();
304
                map.put(i, foreign);
305
                cacheForeign.put(field.getName(), map);
306
            } else {
307
                c.put(i, foreign);
308
            }
309
 
310
            return foreign;
311
        }
312
        // return row.getForeignRow(field.getName());
313
 
314
    }
315
 
19 ilm 316
    private static int fillTable(Element tableau, SQLRow row, Sheet sheet, Map<String, Map<Integer, String>> mapStyle, boolean test, SQLRow rowLanguage) {
18 ilm 317
 
318
        if (tableau == null) {
319
            return 1;
320
        }
321
 
322
        int nbPage = 1;
323
        int nbCellules = 0;
324
 
325
        OOXMLTableElement tableElement = new OOXMLTableElement(tableau, row);
326
        int currentLineTmp = tableElement.getFirstLine();
327
        int currentLine = tableElement.getFirstLine();
328
 
329
        SQLElement styleElt = Configuration.getInstance().getDirectory().getElement("STYLE");
330
 
331
        boolean cache = false;
332
        String ref = tableau.getAttributeValue("table") + "_" + row.getTable().getName() + row.getID();
333
        if (rowsEltCache.get(ref) == null) {
334
            rowsEltCache.put(ref, tableElement.getRows());
335
        } else {
336
            cache = true;
337
        }
338
        List<Element> listElts = tableau.getChildren("element");
339
 
340
        // on remplit chaque ligne à partir des rows recuperées
21 ilm 341
        int numeroRef = 0;
18 ilm 342
        for (SQLRowAccessor rowElt : rowsEltCache.get(ref)) {
21 ilm 343
            numeroRef++;
18 ilm 344
            if (!cache && rowElt.getTable().getFieldRaw("ID_TAXE") != null) {
345
                SQLRowAccessor rowTaxe = getForeignRow(rowElt, rowElt.getTable().getField("ID_TAXE"));
346
                long ht = 0;
347
                if (rowElt.getTable().getFieldRaw("T_PV_HT") != null) {
348
                    ht = rowElt.getLong("T_PV_HT");
349
                }
350
 
351
                if (taxe.get(rowTaxe) != null) {
352
 
353
                    final Object object = taxe.get(rowTaxe).get("MONTANT_HT");
354
                    long montant = (object == null) ? 0 : (Long) object;
355
                    taxe.get(rowTaxe).put("MONTANT_HT", montant + ht);
356
                } else {
357
                    Map<String, Object> m = new HashMap<String, Object>();
358
                    m.put("MONTANT_HT", ht);
359
                    taxe.put(rowTaxe, m);
360
                }
361
 
362
            }
363
 
364
            Map<String, Integer> mapNbCel = new HashMap<String, Integer>();
365
            final boolean included = isIncluded(tableElement.getFilterId(), tableElement.getForeignTableWhere(), tableElement.getFilterId(), tableElement.getFieldWhere(), rowElt);
366
            if (included || tableElement.getTypeStyleWhere()) {
367
 
368
                String styleName = null;
369
                if (tableElement.getSQLElement().getTable().contains("ID_STYLE")) {
370
                    styleName = styleElt.getTable().getRow(rowElt.getInt("ID_STYLE")).getString("NOM");
371
                }
372
 
373
                if (included && tableElement.getTypeStyleWhere()) {
374
                    styleName = "Titre 1";
375
                }
376
 
377
                if (!included) {
378
                    styleName = "Normal";
379
                }
380
 
381
                int nbCellule = 1;
382
 
383
                String tmp;
384
                if (styleName != null && tableElement.getListBlankLineStyle().contains(styleName)) {
385
                    tmp = null;
386
                } else {
387
                    tmp = styleName;
388
                }
389
                boolean first = true;
390
 
391
                int tableLine = 1;
19 ilm 392
                int toAdd = 0;
21 ilm 393
 
394
                Map<Element, Object> mapValues = new HashMap<Element, Object>();
18 ilm 395
                for (Element e : listElts) {
396
 
19 ilm 397
                    OOXMLTableField tableField = new OOXMLTableField(e, rowElt, tableElement.getSQLElement(), rowElt.getID(), tableElement.getTypeStyleWhere() ? -1 : tableElement.getFilterId(),
21 ilm 398
                            rowLanguage, numeroRef);
399
                    final Object value = tableField.getValue();
18 ilm 400
 
21 ilm 401
                    mapValues.put(e, value);
402
                    fill("A1", value, sheet, false, null, tmp, true, tableField.isMultilineAuto());
403
                    final int fill = fill("A1", value, sheet, false, null, tmp, true, tableField.isMultilineAuto());
18 ilm 404
                    if ((currentLine + fill) > (tableElement.getEndPageLine() * nbPage)) {
405
                        currentLine = currentLineTmp + tableElement.getEndPageLine();
406
                        // currentLine = nbPage * endLine + fisrtLine;
407
                        currentLineTmp = currentLine;
408
                        nbPage++;
409
                    }
21 ilm 410
                }
18 ilm 411
 
21 ilm 412
                // on remplit chaque cellule de la ligne
413
                for (Element e : listElts) {
414
 
415
                    OOXMLTableField tableField = new OOXMLTableField(e, rowElt, tableElement.getSQLElement(), rowElt.getID(), tableElement.getTypeStyleWhere() ? -1 : tableElement.getFilterId(),
416
                            rowLanguage, numeroRef);
417
 
18 ilm 418
                    if (!test && styleName != null && tableElement.getListBlankLineStyle().contains(styleName) && first) {
19 ilm 419
                        toAdd++;
18 ilm 420
                        currentLine++;
421
                        // nbCellule = Math.max(nbCellule, 2);
422
                        first = false;
423
                    }
424
 
425
                    if (mapNbCel.get(e.getAttributeValue("location").trim()) != null) {
426
                        nbCellule = mapNbCel.get(e.getAttributeValue("location").trim());
427
                    } else {
428
                        nbCellule = 1;
429
                    }
430
                    int line = tableField.getLine();
431
                    if (tableField.getLine() > 1) {
432
                        line = Math.max(nbCellule + ((tableLine == tableField.getLine()) ? 0 : 1), tableField.getLine());
433
                    }
434
                    tableLine = tableField.getLine();
435
                    String loc = e.getAttributeValue("location").trim() + (currentLine + (line - 1));
436
 
437
                    // Cellule pour un style défini
438
                    List<String> listBlankStyle = tableField.getBlankStyle();
439
 
19 ilm 440
                    // nbCellule = Math.max(nbCellule, tableField.getLine());
18 ilm 441
 
442
                    if (styleName == null || !listBlankStyle.contains(styleName)) {
443
 
444
                        try {
21 ilm 445
                            Object value = mapValues.get(e);
18 ilm 446
                            // if (value != null && value.toString().trim().length() > 0) {
447
                            if (tableField.isNeeding2Lines() && tableField.getLine() == 1) {
448
                                loc = e.getAttributeValue("location").trim() + (currentLine + 1);
449
                                styleName = null;
450
                            }
451
                            final Point resolveHint = sheet.resolveHint(loc);
452
                            if (test || sheet.isCellValid(resolveHint.x, resolveHint.y)) {
21 ilm 453
 
454
                                String styleNameTmp = styleName;
455
                                if (tableField.getStyle().trim().length() > 0) {
456
                                    styleNameTmp = tableField.getStyle();
457
                                }
458
 
459
                                Map<Integer, String> mTmp = styleName == null ? null : mapStyle.get(styleNameTmp);
18 ilm 460
                                String styleOO = null;
461
                                if (mTmp != null) {
462
 
463
                                    Object oTmp = mTmp.get(Integer.valueOf(resolveHint.x));
464
                                    styleOO = oTmp == null ? null : oTmp.toString();
465
                                }
466
 
467
                                int tmpCelluleAffect = fill(test ? "A1" : loc, value, sheet, tableField.isTypeReplace(), null, styleOO, test, tableField.isMultilineAuto());
468
                                // tmpCelluleAffect = Math.max(tmpCelluleAffect,
469
                                // tableField.getLine());
21 ilm 470
                                if (tableField.getLine() != 1 && (!tableField.isLineOption() || (value != null && value.toString().trim().length() > 0))) {
19 ilm 471
                                    if (nbCellule >= tableField.getLine()) {
472
                                        tmpCelluleAffect = tmpCelluleAffect + nbCellule;
473
                                    } else {
474
                                        tmpCelluleAffect += tableField.getLine() - 1;
475
                                    }
476
                                }
477
 
18 ilm 478
                                if (tableField.isNeeding2Lines()) {
479
                                    nbCellule = Math.max(nbCellule, 2);
480
                                } else {
481
                                    nbCellule = Math.max(nbCellule, tmpCelluleAffect);
482
                                }
483
                            } else {
484
                                System.err.println("Cell not valid at " + loc);
485
                            }
486
                            // }
487
                        } catch (IndexOutOfBoundsException indexOut) {
488
                            System.err.println("Cell not valid at " + loc);
489
                        }
490
                    }
491
                    mapNbCel.put(e.getAttributeValue("location").trim(), nbCellule);
492
                }
493
 
494
                for (String s : mapNbCel.keySet()) {
495
                    nbCellule = Math.max(nbCellule, mapNbCel.get(s));
496
                }
497
 
498
                currentLine += nbCellule;
19 ilm 499
                nbCellules += (nbCellule + toAdd);
18 ilm 500
 
501
            }
502
        }
503
        int d = nbCellules / (tableElement.getEndPageLine() - tableElement.getFirstLine());
504
        int r = nbCellules % (tableElement.getEndPageLine() - tableElement.getFirstLine());
505
 
506
        if (d == 0) {
507
            d++;
508
            if (nbCellules > (tableElement.getEndLine() - tableElement.getFirstLine() + 1)) {
509
                d++;
510
            }
511
        } else {
512
            if (r > (tableElement.getEndLine() - tableElement.getFirstLine() + 1)) {
513
                d += 2;
514
            } else {
515
                d++;
516
            }
517
        }
518
        return d;
519
    }
520
 
521
    private static void fillTaxe(Element tableau, Sheet sheet, Map<String, Map<Integer, String>> mapStyle, boolean test) {
522
 
523
        int line = Integer.valueOf(tableau.getAttributeValue("firstLine"));
524
        List<Element> listElts = tableau.getChildren("element");
525
 
526
        for (SQLRowAccessor rowTaxe : taxe.keySet()) {
527
 
528
            Map<String, Object> m = taxe.get(rowTaxe);
529
            // on remplit chaque cellule de la ligne
530
            for (Element e : listElts) {
531
 
532
                String loc = e.getAttributeValue("location").trim() + line;
533
                String name = e.getAttributeValue("name");
534
                String typeComp = e.getAttributeValue("type");
535
                if (name == null) {
536
                    System.err.println("OOgenerationXML.fillTaxe() --> name == null");
537
                } else {
538
                    Object value = m.get(name);
539
                    if (name.equalsIgnoreCase("MONTANT_TVA")) {
540
                        value = Math.round(((Long) m.get("MONTANT_HT") * rowTaxe.getFloat("TAUX") / 100.0));
541
                    } else if (name.equalsIgnoreCase("NOM")) {
542
                        value = rowTaxe.getString("NOM");
543
                        // TODO prefix et suffix
544
                        String prefix = e.getAttributeValue("prefix");
545
                        if (prefix != null) {
546
                            value = prefix + value;
547
                        }
548
                        String suffix = e.getAttributeValue("suffix");
549
                        if (suffix != null) {
550
                            value = value + suffix;
551
                        }
552
                    }
553
                    if (typeComp != null && typeComp.equalsIgnoreCase("Devise")) {
554
 
555
                        value = Double.valueOf(GestionDevise.currencyToString((Long) value, false));
556
                    }
557
                    fill(test ? "A1" : loc, value, sheet, false, null, null, test, false);
558
                }
559
            }
560
            line++;
561
        }
562
    }
563
 
564
    /**
565
     * Parse l'ensemble des éléments du fichier et insere les valeurs dans le fichier sxc
566
     *
567
     * @param elts
568
     * @param sqlElt
569
     * @param id
570
     */
571
    private static void parseElementsXML(List<Element> elts, SQLRow row, SpreadSheet spreadSheet) {
572
        SQLElement sqlElt = Configuration.getInstance().getDirectory().getElement(row.getTable());
573
        for (Element elt : elts) {
574
 
575
            OOXMLElement OOElt = new OOXMLElement(elt, sqlElt, row.getID(), row);
576
            Object result = OOElt.getValue();
577
            if (result != null) {
578
                Object o = elt.getAttributeValue("sheet");
579
                int sheet = (o == null) ? 0 : Integer.valueOf(o.toString().trim());
580
                fill(elt.getAttributeValue("location"), result, spreadSheet.getSheet(sheet), OOElt.isTypeReplace(), OOElt.getReplacePattern(), null, false, OOElt.isMultilineAuto());
581
            }
582
        }
583
    }
584
 
585
    private static boolean isIncluded(int filterID, String foreignTable, int id, String fieldWhere, SQLRowAccessor rowElt) {
586
 
587
        // No filter
588
        if (filterID <= 1) {
589
            return true;
590
        } else {
591
            // Filter id in foreign table (FICHE_RENDEZ_VOUS<-POURCENT_SERVICE[ID_VERIFICATEUR]
592
            if (foreignTable != null) {
593
                boolean b = false;
594
                SQLTable table = Configuration.getInstance().getRoot().findTable(foreignTable);
595
                Collection<? extends SQLRowAccessor> set = rowElt.getReferentRows(table);
596
                for (SQLRowAccessor row : set) {
597
                    b = b || (row.getInt(fieldWhere) == filterID);
598
                }
599
                return b;
600
            } else {
601
                return (filterID == id);
602
            }
603
        }
604
    }
605
 
606
    /**
607
     * Permet de remplir une cellule
608
     *
609
     * @param location position de la cellule exemple : A3
610
     * @param value valeur à insérer dans la cellule
611
     * @param sheet feuille sur laquelle on travaille
612
     * @param replace efface ou non le contenu original de la cellule
613
     * @param styleOO style à appliquer
614
     */
615
    private static int fill(String location, Object value, Sheet sheet, boolean replace, String replacePattern, String styleOO, boolean test, boolean controleMultiline) {
616
 
617
        int nbCellule = (test && styleOO == null) ? 2 : 1;
618
        // est ce que la cellule est valide
619
        if (test || sheet.isCellValid(sheet.resolveHint(location).x, sheet.resolveHint(location).y)) {
620
 
621
            MutableCell cell = sheet.getCellAt(location);
622
 
623
            // on divise en 2 cellules si il y a des retours à la ligne
624
            if (controleMultiline && value != null && value.toString().indexOf('\n') >= 0) {
625
                String[] values = value.toString().split("\n");
626
                if (!test) {
627
 
628
                    Point p = sheet.resolveHint(location);
629
                    int y = 0;
630
                    for (String string : values) {
631
                        if (string != null && string.trim().length() != 0) {
632
                            try {
633
                                MutableCell c = sheet.getCellAt(p.x, p.y + y);
634
                                setCellValue(c, string, replace, replacePattern);
635
                                if (styleOO != null) {
21 ilm 636
                                    c.setStyleName(styleOO);
18 ilm 637
                                }
638
                                y++;
639
                            } catch (IllegalArgumentException e) {
640
                                JOptionPane.showMessageDialog(null, "La cellule " + location + " n'existe pas ou est fusionnée.", "Erreur pendant la génération", JOptionPane.ERROR_MESSAGE);
641
                            }
642
                        }
643
                    }
644
 
645
                    // String firstPart = value.toString().substring(0,
646
                    // value.toString().indexOf('\n'));
647
                    // String secondPart = value.toString().substring(value.toString().indexOf('\n')
648
                    // + 1, value.toString().length());
649
                    // secondPart = secondPart.replace('\n', ',');
650
                    // // System.err.println("Set cell value 1 " + value);
651
                    // setCellValue(cell, firstPart, replace, replacePattern);
652
                    // if (styleOO != null) {
653
                    // cell.setStyleName(styleOO);
654
                    // }
655
                    //
656
                    // Point p = sheet.resolveHint(location);
657
                    // System.err.println("Get Cell At " + p.x + " : " + p.y);
658
 
659
                }
660
                nbCellule = values.length;
661
            } else {
662
                if (!test) {
663
                    // application de la valeur
664
                    // System.err.println("Set cell value 2 " + value);
665
                    setCellValue(cell, value, replace, replacePattern);
666
 
667
                    // Application du style
668
                    if (styleOO != null) {
669
                        cell.setStyleName(styleOO);
670
                    }
671
                }
672
            }
673
        }
674
        return nbCellule;
675
    }
676
 
677
    /**
678
     * remplit une cellule
679
     *
680
     * @param cell
681
     * @param value
682
     * @param replace
683
     */
684
    private static void setCellValue(MutableCell cell, Object value, boolean replace, String replacePattern) {
685
        if (value == null) {
19 ilm 686
            return;
687
            // value = "";
18 ilm 688
        }
689
 
690
        if (replace) {
691
            if (replacePattern != null) {
692
                cell.replaceBy(replacePattern, value.toString());
693
            } else {
694
                cell.replaceBy("_", value.toString());
695
            }
696
        } else {
697
            cell.setValue(value);
698
        }
699
    }
700
 
701
    /**
702
     * Sauver le document au format OpenOffice. Si le fichier existe déjà, le fichier existant sera
703
     * renommé sous la forme nomFic_1.sxc.
704
     *
705
     * @param ssheet SpreadSheet à sauvegarder
706
     * @param pathDest répertoire de destination du fichier
707
     * @param fileName nom du fichier à créer
708
     * @return un File pointant sur le fichier créé
709
     * @throws IOException
710
     */
711
 
25 ilm 712
    private static File saveSpreadSheet(SpreadSheet ssheet, File pathDest, String fileName, String templateId, SQLRow rowLanguage) throws IOException {
713
        final String langage = rowLanguage != null ? rowLanguage.getString("CHEMIN") : null;
18 ilm 714
        // Test des arguments
715
        if (ssheet == null || pathDest == null || fileName.trim().length() == 0) {
716
            throw new IllegalArgumentException();
717
        }
718
 
719
        // Renommage du fichier si il existe déja
720
        File fDest = new File(pathDest, fileName + ".ods");
721
 
722
        if (!pathDest.exists()) {
723
            pathDest.mkdirs();
724
        }
725
 
25 ilm 726
        fDest = SheetUtils.convertToOldFile(fileName, pathDest, fDest);
18 ilm 727
 
728
        // Sauvegarde
729
        try {
730
            ssheet.saveAs(fDest);
731
        } catch (FileNotFoundException e) {
732
            final File file = fDest;
733
            SwingUtilities.invokeLater(new Runnable() {
734
                public void run() {
735
                    try {
736
                        JOptionPane.showMessageDialog(null, "Le fichier " + file.getCanonicalPath() + " n'a pu être créé. \n Vérifiez qu'il n'est pas déjà ouvert.");
737
                    } catch (IOException e) {
738
                        e.printStackTrace();
739
                    }
740
                }
741
            });
742
 
743
            e.printStackTrace();
744
        }
745
 
746
        // Copie de l'odsp
747
        try {
748
            File odspOut = new File(pathDest, fileName + ".odsp");
25 ilm 749
            final InputStream odspIn = TemplateManager.getInstance().getTemplatePrintConfiguration(templateId, langage, null);
18 ilm 750
            if (odspIn != null) {
751
                StreamUtils.copy(odspIn, odspOut);
752
            }
753
        } catch (FileNotFoundException e) {
754
            System.err.println("Le fichier odsp n'existe pas.");
755
        }
756
        return fDest;
757
    }
758
 
759
    /**
760
     * parcourt l'ensemble de la feuille pour trouver les style définit
761
     */
762
    private static Map<String, Map<Integer, String>> searchStyle(Sheet sheet, int colEnd, int rowEnd) {
763
 
764
        if (cacheStyle.get(sheet) != null) {
765
            return cacheStyle.get(sheet);
766
        }
767
 
768
        Map<String, Map<Integer, String>> mapStyleDef = StyleSQLElement.getMapAllStyle();
769
 
770
        // on parcourt chaque ligne de la feuille pour recuperer les styles
771
        int columnCount = (colEnd == -1) ? sheet.getColumnCount() : (colEnd + 1);
772
        System.err.println("End column search : " + columnCount);
773
 
774
        int rowCount = (rowEnd > 0) ? rowEnd : sheet.getRowCount();
775
        System.err.println("End row search : " + rowCount);
776
        for (int i = 0; i < rowCount; i++) {
777
            int x = 0;
778
            Map<Integer, String> mapCellStyle = new HashMap<Integer, String>();
779
            String style = "";
780
 
781
            for (int j = 0; j < columnCount; j++) {
782
 
783
                try {
784
                    if (sheet.isCellValid(j, i)) {
785
 
786
                        MutableCell c = sheet.getCellAt(j, i);
787
                        String cellStyle = c.getStyleName();
788
 
789
                        try {
790
                            if (mapStyleDef.containsKey(c.getValue().toString())) {
791
                                style = c.getValue().toString();
792
                            }
793
                        } catch (IllegalStateException e) {
794
                            e.printStackTrace();
795
                        }
796
                        mapCellStyle.put(Integer.valueOf(x), cellStyle);
797
                        if (style.trim().length() != 0) {
798
                            c.clearValue();
799
                            if (!style.trim().equalsIgnoreCase("Normal") && mapStyleDef.get("Normal") != null) {
800
                                String styleCell = mapStyleDef.get("Normal").get(Integer.valueOf(x));
801
                                if (styleCell != null && styleCell.length() != 0) {
802
                                    c.setStyleName(styleCell);
803
                                }
804
                            }
805
                        }
806
                    }
807
                } catch (IndexOutOfBoundsException e) {
808
                    System.err.println("Index out of bounds Exception");
809
                }
810
                x++;
811
            }
812
 
813
            if (style.length() > 0) {
814
                mapStyleDef.put(style, mapCellStyle);
815
            }
816
        }
817
        cacheStyle.put(sheet, mapStyleDef);
818
        return mapStyleDef;
819
    }
820
 
25 ilm 821
    public static boolean needAnnexe(String templateId, SQLRow row, SQLRow rowLanguage) {
822
        final String langage = rowLanguage != null ? rowLanguage.getString("CHEMIN") : null;
823
        final SAXBuilder builder = new SAXBuilder();
18 ilm 824
        try {
25 ilm 825
            final InputStream xmlConfiguration = TemplateManager.getInstance().getTemplateConfiguration(templateId, langage, null);
826
            final Document doc = builder.build(xmlConfiguration);
827
            final InputStream template = TemplateManager.getInstance().getTemplate(templateId, langage, null);
18 ilm 828
 
25 ilm 829
            final SpreadSheet spreadSheet = new ODPackage(template).getSpreadSheet();
18 ilm 830
 
831
            // On initialise un nouvel élément racine avec l'élément racine du document.
832
            Element racine = doc.getRootElement();
833
 
834
            List<Element> listTable = racine.getChildren("table");
835
 
836
            Element tableau;
837
            if (listTable.size() == 0) {
838
                return false;
839
            } else {
840
                if (listTable.get(0).getAttributeValue("table").equalsIgnoreCase("TVA")) {
841
                    tableau = listTable.get(1);
842
                } else {
843
                    tableau = listTable.get(0);
844
                }
845
            }
846
            final Sheet sheet = spreadSheet.getSheet(0);
847
 
848
            Object oLastColTmp = tableau.getAttributeValue("lastColumn");
849
            int lastColumn = -1;
850
            int endPageLine = Integer.valueOf(tableau.getAttributeValue("endPageLine"));
851
            if (oLastColTmp != null) {
852
                lastColumn = sheet.resolveHint(oLastColTmp.toString() + 1).x + 1;
853
            }
854
 
855
            Map<String, Map<Integer, String>> mapStyle = searchStyle(sheet, lastColumn, endPageLine);
856
 
19 ilm 857
            int nbPage = fillTable(tableau, row, sheet, mapStyle, true, rowLanguage);
18 ilm 858
 
859
            return nbPage > 1;
860
        } catch (final JDOMException e) {
861
 
862
            e.printStackTrace();
863
        } catch (FileNotFoundException e) {
864
            e.printStackTrace();
865
        } catch (IOException e) {
866
            e.printStackTrace();
867
        }
868
        return false;
869
    }
870
 
871
    protected static String getStringProposition(SQLRow rowProp) {
872
 
873
        return "Notre proposition " + rowProp.getString("NUMERO") + " du " + dateFormat.format(rowProp.getObject("DATE"));
874
    }
875
 
876
    public static void main(String[] args) {
877
        ComptaPropsConfiguration conf = ComptaPropsConfiguration.create();
878
        System.err.println("Conf created");
879
        Configuration.setInstance(conf);
880
        conf.setUpSocieteDataBaseConnexion(36);
881
        System.err.println("Connection Set up");
882
        SQLElement elt = Configuration.getInstance().getDirectory().getElement("DEVIS");
883
 
884
        System.err.println("Start Genere");
19 ilm 885
        // genere("Devis", "C:\\", "Test", elt.getTable().getRow(19));
18 ilm 886
        System.err.println("Stop genere");
887
    }
888
}