WebSVN - OpenConcerto - Diff - Rev 149 and 156 - /trunk/OpenConcerto/src/org/openconcerto/erp/generationDoc/OOgenerationXML.java



import org.openconcerto.sql.model.SQLTable;
import org.openconcerto.utils.ExceptionHandler;
import org.openconcerto.utils.StreamUtils;
import org.openconcerto.utils.Tuple2;
import org.openconcerto.utils.cc.ITransformer;
import org.openconcerto.utils.io.BOMSkipper;
 
import java.awt.Point;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.lang.reflect.InvocationTargetException;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.nio.charset.Charset;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;

    private static int answer = JOptionPane.NO_OPTION;
 
    private DateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy");
 
    // Cache pour la recherche des styles
    private Map<Sheet, Map<String, Map<Integer, String>>> cacheStyle = new HashMap<>();
    private Map<SQLRowAccessor, Map<String, Object>> taxe = new HashMap<>();
    private Map<String, Map<Integer, SQLRowAccessor>> cacheForeign = new HashMap<>();
 
    // Cache pour les SQLRow du tableau
    private Map<String, List<? extends SQLRowAccessor>> rowsEltCache = new HashMap<>();
    private final OOXMLCache rowRefCache = new OOXMLCache();
    private final SQLRow row;
 
    public OOgenerationXML(SQLRow row) {
        this.row = row;

            if (xmlConfiguration == null) {
                JOptionPane.showMessageDialog(null, "Fichier de configuration manquant pour " + templateId + " " + ((rowLanguage == null) ? "" : rowLanguage.getString("CHEMIN")) + " "
                        + ((typeTemplate == null) ? "" : typeTemplate));
                return null;
            }
 
            final BufferedReader xmlConfigurationReader = new BufferedReader(new InputStreamReader(xmlConfiguration, Charset.forName("UTF8")));
            BOMSkipper.skip(xmlConfigurationReader);
            final Document doc = builder.build(xmlConfigurationReader);
            xmlConfigurationReader.close();
            xmlConfiguration.close();
 
            // On initialise un nouvel élément racine avec l'élément racine du document.
            Element racine = doc.getRootElement();
 

        Sheet sheet = spreadsheet.getSheet(idSheet);
        // Derniere colonne du tableau permet de ne pas chercher sur toutes les colonnes
        // et d'optimiser la recherche
        Object oLastColTmp = tableau.getAttributeValue("lastColumn");
        int lastColumn = -1;
        int endPageLine = Integer.parseInt(tableau.getAttributeValue("endPageLine"));
        if (oLastColTmp != null) {
            lastColumn = sheet.resolveHint(oLastColTmp.toString() + 1).x + 1;
        }
 
        Map<String, Map<Integer, String>> mapStyle = searchStyle(sheet, lastColumn, endPageLine);

        if (tableau.getAttributeValue("table").equalsIgnoreCase("TVA")) {
            fillTaxeDocumentMap(tableau, sheet, mapStyle, false);
            return;
        }
        int nbPage = fillTable(tableau, row, sheet, mapStyle, true, rowLanguage);
        int firstLine = Integer.parseInt(tableau.getAttributeValue("firstLine"));
        int endLine = Integer.parseInt(tableau.getAttributeValue("endLine"));
        Object printRangeObj = sheet.getPrintRanges();
 
        System.err.println("Nombre de page == " + nbPage);
        if (nbPage == 1) {
            fillTable(tableau, row, sheet, mapStyle, false, rowLanguage);

 
            // On agrandit le tableau pour qu'il remplisse la premiere page
            int lineToAdd = endPageLine - endLine;
            String repeatedCount = tableau.getAttributeValue("repeatedCount");
            if (repeatedCount != null && repeatedCount.trim().length() > 0) {
                int count = Integer.parseInt(repeatedCount);
                sheet.duplicateRows(firstLine, lineToAdd / count, count);
                final int rest = lineToAdd % count;
                // Si le nombre de ligne ne termine pas à la fin de la page
                if (rest != 0) {
                    sheet.insertDuplicatedRows(firstLine + lineToAdd - rest, rest);

                for (int i = 1; i < nbPageRef; i++) {
                    MutableCell<SpreadSheet> cell2 = sheet.getCellAt(cell.getX(), cell.getY() + (endPageLine * i));
                    cell2.setValue("Page " + (i + start) + "/" + nbPageRef);
                }
                if (pageAdd != null && pageAdd.trim().length() > 0) {
                    int pAdd = Integer.parseInt(pageAdd);
                    for (int i = 0; i < pAdd; i++) {
                        Sheet s = sheet.getSpreadSheet().getSheet(idSheet + i + 1);
                        MutableCell<SpreadSheet> cell2 = s.getCellAt(pageRef);
                        cell2.setValue("Page " + (nbPageRef - (pAdd - i) + 1) + "/" + nbPageRef);
                    }

        } else {
 
            SQLRowAccessor foreign = row.getForeign(field.getName());
 
            if (c == null) {
                Map<Integer, SQLRowAccessor> map = new HashMap<>();
                map.put(i, foreign);
                cacheForeign.put(field.getName(), map);
            } else {
                c.put(i, foreign);
            }
 
            return foreign;
        }
 
 
    }
 
    private void fillTaxe(Element tableau, List<? extends SQLRowAccessor> rows) {
        // getValuesFromElement(boolean achat, String fieldTotalHT, SQLRow row, SQLTable foreign,

        SQLTable tableElt = Configuration.getInstance().getRoot().findTable(tableau.getAttributeValue("table"));
        SQLBackgroundTableCacheItem cacheItem = SQLBackgroundTableCache.getInstance().getCacheForTable(tableElt.getTable("COMPTE_PCE"));
        SQLBackgroundTableCacheItem prefsCpt = SQLBackgroundTableCache.getInstance().getCacheForTable(tableElt.getTable("PREFS_COMPTE"));
        if (tableElt.contains("ID_TAXE") && tableElt.contains("T_PA_HT")) {
            boolean achat = tableElt.contains("T_PA_TTC");
            TotalCalculator calc = new TotalCalculator("T_PA_HT", achat ? "T_PA_HT" : "T_PV_HT", null, achat, null, null);
            String val = DefaultNXProps.getInstance().getStringProperty("ArticleService");
            Boolean bServiceActive = Boolean.valueOf(val);
 
            calc.setServiceActive(bServiceActive != null && bServiceActive);
            if (row.getTable().contains("ID_COMPTE_PCE_SERVICE") && !row.isForeignEmpty("ID_COMPTE_PCE_SERVICE")) {

            }
            calc.checkResult();
            Map<SQLRowAccessor, Tuple2<BigDecimal, BigDecimal>> taxeCalc = calc.getMapHtTVARowTaux();
            for (SQLRowAccessor sqlRow : taxeCalc.keySet()) {
                Tuple2<BigDecimal, BigDecimal> v = taxeCalc.get(sqlRow);
                Map<String, Object> m = new HashMap<>();
                m.put("MONTANT_HT", v.get0());
                m.put("MONTANT_TVA", v.get1());
                taxe.put(sqlRow, m);
            }
        }

        int currentLineTmp = tableElement.getFirstLine();
        int currentLine = tableElement.getFirstLine();
 
        StyleSQLElement styleElt = Configuration.getInstance().getDirectory().getElement(StyleSQLElement.class);
 
 
        String ref = tableau.getAttributeValue("table") + "_" + row.getTable().getName() + row.getID();
        if (rowsEltCache.get(ref) == null) {
            rowsEltCache.put(ref, tableElement.getRows());
 
 
        }
        List<Element> listElts = tableau.getChildren("element");
 
        fillTaxe(tableau, rowsEltCache.get(ref));
        // on remplit chaque ligne à partir des rows recuperées

                    currentLine++;
                    first = false;
                }
 
                // Cache des valeurs
                Map<Element, Object> mapValues = new HashMap<>();
 
                // Test si l'ensemble des donnees tient sur la page courante
                Map<String, Integer> tmpMapNbCel = new HashMap<>();
                int tmpNbCellule = fillTableLine(sheet, mapStyle, true, rowLanguage, tableElement, currentLine, listElts, numeroRef, rowElt, tmpMapNbCel, styleName, mapValues);
                for (String s : tmpMapNbCel.keySet()) {
                    tmpNbCellule = Math.max(tmpNbCellule, tmpMapNbCel.get(s));
                }
                if ((currentLine + tmpNbCellule) > (tableElement.getEndPageLine() * nbPage)) {

                    currentLineTmp = currentLine;
                    nbPage++;
                }
 
                // Remplissage reel des cellules
                Map<String, Integer> mapNbCel = new HashMap<>();
                int nbCellule = fillTableLine(sheet, mapStyle, test, rowLanguage, tableElement, currentLine, listElts, numeroRef, rowElt, mapNbCel, styleName, mapValues);
 
                for (String s : mapNbCel.keySet()) {
                    nbCellule = Math.max(nbCellule, mapNbCel.get(s));
                }

        return nbCellule;
    }
 
    private void fillTaxeDocumentMap(Element tableau, Sheet sheet, Map<String, Map<Integer, String>> mapStyle, boolean test) {
 
        int line = Integer.parseInt(tableau.getAttributeValue("firstLine"));
        List<Element> listElts = tableau.getChildren("element");
 
        for (SQLRowAccessor rowTaxe : taxe.keySet()) {
 
            Map<String, Object> m = taxe.get(rowTaxe);

 
            e.printStackTrace();
        }
 
        // Copie de l'odsp
 
        File odspOut = new File(pathDest, fileName + ".odsp");
        try (final InputStream odspIn = TemplateManager.getInstance().getTemplatePrintConfiguration(templateId, langage, null);) {
            if (odspIn != null) {
                StreamUtils.copy(odspIn, odspOut);
 
            }
        } catch (FileNotFoundException e) {
            System.err.println("OOgenerationXML.saveSpreadSheet() : Le fichier odsp n'existe pas.");
        }
        return fDest;

 
        int rowCount = (rowEnd > 0) ? rowEnd : sheet.getRowCount();
        System.err.println("End row search : " + rowCount);
        for (int i = 0; i < rowCount; i++) {
            int x = 0;
            Map<Integer, String> mapCellStyle = new HashMap<>();
            String style = "";
 
            for (int j = 0; j < columnCount; j++) {
 
                try {

            Element racine = doc.getRootElement();
 
            List<Element> listTable = racine.getChildren("table");
 
            Element tableau;
            if (listTable.isEmpty()) {
                return false;
            } else {
                if (listTable.get(0).getAttributeValue("table").equalsIgnoreCase("TVA")) {
                    tableau = listTable.get(1);
                } else {

            }
            final Sheet sheet = spreadSheet.getSheet(0);
 
            Object oLastColTmp = tableau.getAttributeValue("lastColumn");
            int lastColumn = -1;
            int endPageLine = Integer.parseInt(tableau.getAttributeValue("endPageLine"));
            if (oLastColTmp != null) {
                lastColumn = sheet.resolveHint(oLastColTmp.toString() + 1).x + 1;
            }
 
            Map<String, Map<Integer, String>> mapStyle = searchStyle(sheet, lastColumn, endPageLine);

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

svn://code.openconcerto.org/openconcerto

(root)/trunk/OpenConcerto/src/org/openconcerto/erp/generationDoc/OOgenerationXML.java - Rev 149 → 156

Rev 149		Rev 156
Line 35...		Line 35...
35	`import org.openconcerto.sql.model.SQLTable;`	35	`import org.openconcerto.sql.model.SQLTable;`
36	`import org.openconcerto.utils.ExceptionHandler;`	36	`import org.openconcerto.utils.ExceptionHandler;`
37	`import org.openconcerto.utils.StreamUtils;`	37	`import org.openconcerto.utils.StreamUtils;`
38	`import org.openconcerto.utils.Tuple2;`	38	`import org.openconcerto.utils.Tuple2;`
39	`import org.openconcerto.utils.cc.ITransformer;`	39	`import org.openconcerto.utils.cc.ITransformer;`
-		40	`import org.openconcerto.utils.io.BOMSkipper;`
40		41
41	`import java.awt.Point;`	42	`import java.awt.Point;`
-		43	`import java.io.BufferedReader;`
42	`import java.io.File;`	44	`import java.io.File;`
43	`import java.io.FileNotFoundException;`	45	`import java.io.FileNotFoundException;`
44	`import java.io.IOException;`	46	`import java.io.IOException;`
45	`import java.io.InputStream;`	47	`import java.io.InputStream;`
-		48	`import java.io.InputStreamReader;`
46	`import java.lang.reflect.InvocationTargetException;`	49	`import java.lang.reflect.InvocationTargetException;`
47	`import java.math.BigDecimal;`	50	`import java.math.BigDecimal;`
48	`import java.math.RoundingMode;`	51	`import java.math.RoundingMode;`
-		52	`import java.nio.charset.Charset;`
49	`import java.text.DateFormat;`	53	`import java.text.DateFormat;`
50	`import java.text.SimpleDateFormat;`	54	`import java.text.SimpleDateFormat;`
51	`import java.util.Collection;`	55	`import java.util.Collection;`
52	`import java.util.HashMap;`	56	`import java.util.HashMap;`
53	`import java.util.List;`	57	`import java.util.List;`
Line 75...		Line 79...
75	`private static int answer = JOptionPane.NO_OPTION;`	79	`private static int answer = JOptionPane.NO_OPTION;`
76		80
77	`private DateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy");`	81	`private DateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy");`
78		82
79	`// Cache pour la recherche des styles`	83	`// Cache pour la recherche des styles`
80	`private Map<Sheet, Map<String, Map<Integer, String>>> cacheStyle = new HashMap<Sheet, Map<String, Map<Integer, String>>>();`	84	`private Map<Sheet, Map<String, Map<Integer, String>>> cacheStyle = new HashMap<>();`
81	`private Map<SQLRowAccessor, Map<String, Object>> taxe = new HashMap<SQLRowAccessor, Map<String, Object>>();`	85	`private Map<SQLRowAccessor, Map<String, Object>> taxe = new HashMap<>();`
82	`private Map<String, Map<Integer, SQLRowAccessor>> cacheForeign = new HashMap<String, Map<Integer, SQLRowAccessor>>();`	86	`private Map<String, Map<Integer, SQLRowAccessor>> cacheForeign = new HashMap<>();`
83		87
84	`// Cache pour les SQLRow du tableau`	88	`// Cache pour les SQLRow du tableau`
85	`private Map<String, List<? extends SQLRowAccessor>> rowsEltCache = new HashMap<String, List<? extends SQLRowAccessor>>();`	89	`private Map<String, List<? extends SQLRowAccessor>> rowsEltCache = new HashMap<>();`
86	`private final OOXMLCache rowRefCache = new OOXMLCache();`	90	`private final OOXMLCache rowRefCache = new OOXMLCache();`
87	`private final SQLRow row;`	91	`private final SQLRow row;`
88		92
89	`public OOgenerationXML(SQLRow row) {`	93	`public OOgenerationXML(SQLRow row) {`