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

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 * 
 * Copyright 2011-2019 OpenConcerto, by ILM Informatique. All rights reserved.
 * 
 * The contents of this file are subject to the terms of the GNU General Public License Version 3
 * only ("GPL"). You may not use this file except in compliance with the License. You can obtain a
 * copy of the License at http://www.gnu.org/licenses/gpl-3.0.html See the License for the specific
 * language governing permissions and limitations under the License.
 * 
 * When distributing the software, include this License Header Notice in each file.
 */
 
 package org.openconcerto.erp.generationDoc;

import org.openconcerto.erp.config.ComptaPropsConfiguration;
import org.openconcerto.erp.core.common.element.StyleSQLElement;
import org.openconcerto.openoffice.ODPackage;
import org.openconcerto.openoffice.spreadsheet.MutableCell;
import org.openconcerto.openoffice.spreadsheet.Sheet;
import org.openconcerto.openoffice.spreadsheet.SpreadSheet;
import org.openconcerto.openoffice.spreadsheet.Table;
import org.openconcerto.sql.Configuration;
import org.openconcerto.sql.model.SQLRow;
import org.openconcerto.utils.ExceptionHandler;
import org.openconcerto.utils.StreamUtils;
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.nio.charset.Charset;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import javax.swing.JOptionPane;
import javax.swing.SwingUtilities;

import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.JDOMException;
import org.jdom2.input.SAXBuilder;

public class OOgenerationListeColumnXML {

    // Cache pour la recherche des styles
    private static Map<Sheet, Map<String, Map<Integer, String>>> cacheStyle = new HashMap<>();

    public static File genere(String modele, File pathDest, String fileDest, Map<Integer, List<Map<String, Object>>> liste, Map<Integer, Map<String, Object>> values) {
        return genere(modele, pathDest, fileDest, liste, values, new HashMap<Integer, Map<Integer, String>>(), null, null);
    }

    public static File genere(String templateId, File pathDest, String fileDest, Map<Integer, List<Map<String, Object>>> liste, Map<Integer, Map<String, Object>> values,
            Map<Integer, Map<Integer, String>> mapStyle, List<String> sheetName, SQLRow rowLanguage) {
        cacheStyle.clear();
        final SAXBuilder builder = new SAXBuilder();
        try {
            InputStream xmlConfiguration = TemplateManager.getInstance().getTemplateConfiguration(templateId, rowLanguage != null ? rowLanguage.getString("CHEMIN") : null, null);
            if (xmlConfiguration == null) {
                throw new IllegalStateException("Template configuration " + templateId + " not found (" + TemplateManager.getInstance().getClass().getName() + ")");
            }
            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.
            final Element racine = doc.getRootElement();

            // Création et génération du fichier OO
            final InputStream template = TemplateManager.getInstance().getTemplate(templateId, rowLanguage != null ? rowLanguage.getString("CHEMIN") : null, null);
            if (template == null) {
                throw new IllegalStateException("Template " + templateId + " not found (" + TemplateManager.getInstance().getClass().getName() + ")");
            }
            final SpreadSheet spreadSheet = new ODPackage(template).getSpreadSheet();
            Sheet sheet0 = spreadSheet.getSheet(0);
            if (sheetName != null && sheetName.size() > 0) {
                for (int i = 1; i < sheetName.size(); i++) {
                    sheet0.copy(i, (sheetName != null) ? sheetName.get(i) : "Feuille " + i);
                }
                spreadSheet.getSheet(0).setName(sheetName.get(0));
            }

            for (Integer i : liste.keySet()) {
                final Sheet sheet = spreadSheet.getSheet(i);
                List children = racine.getChildren("element" + i);
                if (children.isEmpty()) {
                    children = racine.getChildren("element");
                }
                parseElementsXML(children, sheet, values.get(i));
                Element child = racine.getChild("table" + i);
                if (child == null) {
                    child = racine.getChild("table");
                }
                parseListeXML(child, liste.get(i), sheet, mapStyle.get(i));
            }
            // Sauvegarde du fichier
            return saveSpreadSheet(spreadSheet, pathDest, fileDest, templateId, rowLanguage);

        } catch (JDOMException e) {
            ExceptionHandler.handle("Erreur lors de la génération du fichier " + fileDest, e);
        } catch (IOException e) {
            ExceptionHandler.handle("Erreur lors de la création du fichier " + fileDest, e);
        }
        return null;
    }

    private static void parseElementsXML(List<Element> elts, Sheet sheet, Map<String, Object> values) {
        if (values == null) {
            return;
        }
        for (Element elt : elts) {

            String name = elt.getAttributeValue("ValueName");
            Object result = values.get(name);

            if (result != null) {
                boolean controlLine = elt.getAttributeValue("controleMultiline") == null ? true : !elt.getAttributeValue("controleMultiline").equalsIgnoreCase("false");
                boolean replace = elt.getAttributeValue("type").equalsIgnoreCase("Replace");
                String replacePattern = elt.getAttributeValue("replacePattern");
                fill(sheet.getCellAt(elt.getAttributeValue("location")), result, sheet, replace, replacePattern, null, false, controlLine);
            }
        }
    }

    /**
     * Remplit le tableau
     * 
     * @param tableau
     * @param elt
     * @param id
     * @param sheet
     */
    private static void parseListeXML(Element tableau, List<Map<String, Object>> liste, Sheet sheet, Map<Integer, String> style) {

        if (liste == null || tableau == null) {
            return;
        }
        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);
 
        fillTable(tableau, liste, sheet, mapStyle, false, style);
         
    }

    /**
     * Remplit le tableau d'éléments avec les données
     * 
     * @param tableau Element Xml contenant les informations sur le tableau
     * @param elt SQLElement (ex : Bon de livraison)
     * @param id id de l'élément de la table
     * @param sheet feuille calc à remplir
     * @param mapStyle styles trouvés dans la page
     * @param test remplir ou non avec les valeurs
     * @return le nombre de page
     */
    private static int fillTable(Element tableau, List<Map<String, Object>> liste, Sheet sheet, Map<String, Map<Integer, String>> mapStyle, boolean test, Map<Integer, String> style) {

        int endLine = Integer.parseInt(tableau.getAttributeValue("endLine"));

        List listElts = tableau.getChildren("element");

        Object o = null;
        // String columnSousTotal = tableau.getAttributeValue("groupSousTotalColumn");
        //
        // Map<String, Double> mapSousTotal = new HashMap<String, Double>();
        // Map<String, Double> mapTotal = new HashMap<String, Double>();

        // on remplit chaque colonnes à partir des rows recuperées
        sheet.setColumnCount(liste.size() + 5);
        Integer firstCol = Integer.valueOf(tableau.getAttributeValue("firstLine"));
        int currentCol = firstCol;
        for (int i = 0; i < liste.size(); i++) {
            Map<String, Object> mValues = liste.get(i);
            if (currentCol != firstCol) {
                for (int k = 0; k < endLine; k++) {
                    MutableCell<SpreadSheet> c1 = sheet.getCellAt(firstCol, k);
                    if (c1.getFormula() != null && c1.getFormula().trim().length() > 0) {
                        String formula = c1.getFormula();
                        MutableCell<SpreadSheet> c2 = sheet.getCellAt(currentCol, k);
                        System.err.println(formula);
                        formula = formula.replaceAll("(" + Table.toStr(c1.getX()) + ")" + "(\\d+)", Table.toStr(c2.getX()) + "$2");
                        formula = formula.replaceAll(Table.toStr(c1.getX()) + "\\$", Table.toStr(c2.getX()) + "\\$");
                        System.err.println(" replace by " + formula);
                        c2.getElement().setAttribute("formula", formula, c2.getElement().getNamespace());
                        c2.setStyleName(c1.getStyleName());
                    }
                }
            }

            String styleName = null;
            // int nbCellule = 1;
            // on remplit chaque cellule de la colonne
            for (Iterator j = listElts.iterator(); j.hasNext();) {

                // if ((currentLine - 1 + fill("A1", "test", sheet, false, null, null, true)) >
                // (endPageLine * nbPage)) {
                // currentLine = currentLineTmp + endPageLine;
                // currentLineTmp = currentLine;
                // nbPage++;
                // }

                Element e = (Element) j.next();
                MutableCell<SpreadSheet> cell = sheet.getCellAt(currentCol, Integer.valueOf(e.getAttributeValue("location").trim()));
                // String loc = e.getAttributeValue("location").trim() + currentLine;
                boolean controlLine = e.getAttributeValue("controleMultiline") == null ? true : !e.getAttributeValue("controleMultiline").equalsIgnoreCase("false");
                // Type normaux fill ou replace
                if (e.getAttributeValue("type").equalsIgnoreCase("fill") || e.getAttributeValue("type").equalsIgnoreCase("replace")) {

                    Object value = getElementValue(e, mValues);

                    boolean replace = e.getAttributeValue("type").equalsIgnoreCase("replace");

                    if (test || cell.isValid()) {
                        // if (style != null) {
                        // styleName = style.get(i);
                        // }
                        // Map mTmp = styleName == null ? null : (Map) mapStyle.get(styleName);
                        // String styleOO = null;
                        // if (mTmp != null) {
                        //
                        // Object oTmp = mTmp.get(new Integer(sheet.resolveHint(loc).x));
                        // styleOO = oTmp == null ? null : oTmp.toString();
                        // System.err.println("Set style " + styleOO);
                        // }
                        if (currentCol != firstCol) {
                            MutableCell<SpreadSheet> c2 = sheet.getCellAt(firstCol, cell.getPoint().y);
                            styleName = c2.getStyleName();
                        }
                        int tmpCelluleAffect = fill(cell, value, sheet, replace, null, styleName, test, controlLine);
                        // nbCellule = Math.max(nbCellule, tmpCelluleAffect);
                    } else {
                        System.err.println("Cell not valid at " + cell);
                    }
                }
            }
            // currentLine += nbCellule;
            currentCol++;

        }

        return 1;
    }

    private static void incrementTotal(String field, Double value, Map<String, Double> map) {
        Double d = map.get(field);
        if (d == null) {
            map.put(field, value);
        } else {
            map.put(field, d + value);
        }
    }

    private static Object getElementValue(Element elt, Map<String, Object> mValues) {
        Object res = "";

        final List eltFields = elt.getChildren("field");

        if (eltFields != null) {
            if (eltFields.size() > 1) {
                String result = "";
                for (Iterator j = eltFields.iterator(); j.hasNext();) {
                    Object o = getValueOfComposant((Element) j.next(), mValues);
                    if (o != null) {
                        result += o.toString() + " ";
                    }
                }
                res = result;
            } else {
                res = getValueOfComposant((Element) eltFields.get(0), mValues);
            }
        }
        return res;
    }

    /**
     * permet d'obtenir la valeur d'un élément field
     * 
     * @param eltField
     * @param row
     * @param elt
     * @param id
     * @return value of composant
     */
    private static Object getValueOfComposant(Element eltField, Map<String, Object> mValues) {

        String field = eltField.getAttributeValue("name");

        return mValues.get(field);
    }

    private static int fill(String location, Object value, Sheet sheet, boolean replace, String replacePattern, String styleOO, boolean test) {
        return fill(sheet.getCellAt(location), value, sheet, replace, replacePattern, styleOO, test, true);
    }

    /**
     * Permet de remplir une cellule
     * 
     * @param location position de la cellule exemple : A3
     * @param value valeur à insérer dans la cellule
     * @param sheet feuille sur laquelle on travaille
     * @param replace efface ou non le contenu original de la cellule
     * @param styleOO style à appliquer
     */
    private static int fill(MutableCell<SpreadSheet> cell, Object value, Sheet sheet, boolean replace, String replacePattern, String styleOO, boolean test, boolean controlLine) {

        int nbCellule = 1;
        // est ce que la cellule est valide
        if (test || cell.isValid()) {

            // on divise en 2 cellules si il y a des retours à la ligne
            if (controlLine && (value != null && value.toString().indexOf('\n') >= 0)) {

                if (!test) {
                    String firstPart = value.toString().substring(0, value.toString().indexOf('\n'));
                    String secondPart = value.toString().substring(value.toString().indexOf('\n') + 1, value.toString().length());
                    secondPart = secondPart.replace('\n', ',');
                    setCellValue(cell, firstPart, replace, replacePattern);
                    if (styleOO != null) {
                        cell.setStyleName(styleOO);
                    }

                    // Point p = sheet.resolveHint(location);
                    Point p = cell.getPoint();
                    try {
                        MutableCell cellSec = sheet.getCellAt(p.x, p.y + 1);
                        setCellValue(cellSec, secondPart, replace, replacePattern);
                    } catch (Exception ex) {
                        ex.printStackTrace();
                    }
                }
                nbCellule = 2;
            } else {
                if (!test) {
                    // application de la valeur
                    setCellValue(cell, value, replace, replacePattern);

                    // Application du style
                    if (styleOO != null) {
                        cell.setStyleName(styleOO);
                    }
                }
            }
        }
        return nbCellule;
    }

    /**
     * remplit une cellule
     * 
     * @param cell
     * @param value
     * @param replace
     */
    private static void setCellValue(MutableCell cell, Object value, boolean replace, String replacePattern) {
        if (value == null) {
            value = "";
        }

        if (replace) {
            if (replacePattern != null) {
                cell.replaceBy(replacePattern, value.toString());
            } else {
                cell.replaceBy("_", value.toString());
            }
        } else {
            cell.setValue(value);
        }
    }

    /**
     * Sauver le document au format OpenOffice. Si le fichier existe déjà, le fichier existant sera
     * renommé sous la forme nomFic_1.sxc.
     * 
     * @param ssheet SpreadSheet à sauvegarder
     * @param pathDest répertoire de destination du fichier
     * @param fileName nom du fichier à créer
     * @return un File pointant sur le fichier créé
     * @throws IOException
     */
    private static File saveSpreadSheet(SpreadSheet ssheet, File pathDest, String fileName, String templateId, SQLRow rowLanguage) throws IOException {

        // Test des arguments
        if (ssheet == null || pathDest == null || fileName.trim().length() == 0) {
            throw new IllegalArgumentException();
        }

        // Renommage du fichier si il existe déja
        File fDest = new File(pathDest, fileName + ".ods");

        if (!pathDest.exists()) {
            pathDest.mkdirs();
        }

        SheetUtils.convertToOldFile(((ComptaPropsConfiguration) Configuration.getInstance()).getRootSociete(), fileName, pathDest, fDest);

        // Sauvegarde
        try {
            ssheet.saveAs(fDest);
        } catch (FileNotFoundException e) {
            final File F = fDest;
            SwingUtilities.invokeLater(new Runnable() {
                public void run() {
                    try {
                        JOptionPane.showMessageDialog(null, "Le fichier " + F.getCanonicalPath() + " n'a pu être créé. \n Vérifiez qu'il n'est pas déjà ouvert.");
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            });

            e.printStackTrace();
        }

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

        return fDest;
    }

    /**
     * parcourt l'ensemble de la feuille pour trouver les style définit
     */
    private static Map<String, Map<Integer, String>> searchStyle(Sheet sheet, int colEnd, int rowEnd) {

        if (cacheStyle.get(sheet) != null) {
            return cacheStyle.get(sheet);
        }

        Map<String, Map<Integer, String>> mapStyleDef = StyleSQLElement.getMapAllStyle();

        // on parcourt chaque ligne de la feuille pour recuperer les styles
        int columnCount = (colEnd == -1) ? sheet.getColumnCount() : (colEnd + 1);
        System.err.println("End column search : " + columnCount);

        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<Integer, String>();
            String style = "";

            for (int j = 0; j < columnCount; j++) {

                try {
                    if (sheet.isCellValid(j, i)) {

                        MutableCell c = sheet.getCellAt(j, i);
                        String cellStyle = c.getStyleName();

                        try {
                            if (mapStyleDef.containsKey(c.getValue().toString())) {
                                style = c.getValue().toString();
                                // System.err.println("FIND STYLE " +
                                // c.getValue().toString() +
                                // " SET VALUE " + cellStyle);
                            }
                        } catch (IllegalStateException e) {
                            e.printStackTrace();
                        }
                        mapCellStyle.put(Integer.valueOf(x), cellStyle);
                        if (style.trim().length() != 0) {
                            c.clearValue();
                            // c.setStyle("Default");
                            if (!style.trim().equalsIgnoreCase("Normal") && mapStyleDef.get("Normal") != null) {
                                String styleCell = mapStyleDef.get("Normal").get(Integer.valueOf(x));
                                if (styleCell != null && styleCell.length() != 0) {
                                    c.setStyleName(styleCell);
                                }
                            }
                        }
                    }
                } catch (IndexOutOfBoundsException e) {
                    System.err.println("Index out of bounds Exception");
                }
                x++;
            }

            if (style.length() > 0) {
                mapStyleDef.put(style, mapCellStyle);
                // System.err.println("style " + mapCellStyle);
            }
        }
        cacheStyle.put(sheet, mapStyleDef);
        return mapStyleDef;
    }

    public static void main(String[] args) {
        ComptaPropsConfiguration conf = ComptaPropsConfiguration.create();
        System.err.println("Conf created");
        Configuration.setInstance(conf);
        conf.setUpSocieteDataBaseConnexion(36);
        System.err.println("Connection Set up");

        System.err.println("Start Genere");
        // genere("Devis", "C:\\", "Test", elt, 19);
        System.err.println("Stop genere");
    }
}