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.preferences.GenerationDocGlobalPreferencePanel;

import org.openconcerto.sql.model.DBRoot;

import org.openconcerto.sql.preferences.SQLPreferences;

import org.openconcerto.utils.ExceptionHandler;

import org.openconcerto.utils.FileUtils;

import java.awt.Color;

import java.awt.Desktop;

import java.io.ByteArrayInputStream;

import java.io.File;

import java.io.FileOutputStream;

import java.io.FilenameFilter;

import java.io.IOException;

import java.io.InputStream;

import java.util.ArrayList;

import java.util.Calendar;

import java.util.Collections;

import java.util.Comparator;

import java.util.GregorianCalendar;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import javax.swing.JOptionPane;

import javax.swing.SwingUtilities;

import org.apache.pdfbox.pdmodel.PDDocument;

import org.apache.pdfbox.pdmodel.PDDocumentInformation;

import org.apache.pdfbox.pdmodel.PDDocumentNameDictionary;

import org.apache.pdfbox.pdmodel.PDEmbeddedFilesNameTreeNode;

import org.apache.pdfbox.pdmodel.PDPage;

import org.apache.pdfbox.pdmodel.PDPageContentStream;

import org.apache.pdfbox.pdmodel.common.PDRectangle;

import org.apache.pdfbox.pdmodel.common.filespecification.PDComplexFileSpecification;

import org.apache.pdfbox.pdmodel.common.filespecification.PDEmbeddedFile;

import org.apache.pdfbox.pdmodel.graphics.form.PDFormXObject;

import org.apache.pdfbox.util.Matrix;

import org.jopendocument.model.OpenDocument;

import org.jopendocument.renderer.ODTRenderer;

import com.lowagie.text.PageSize;

import de.rototor.pdfbox.graphics2d.PdfBoxGraphics2D;

import de.rototor.pdfbox.graphics2d.PdfBoxGraphics2DFontTextDrawer;

import de.rototor.pdfbox.graphics2d.PdfBoxGraphics2DFontTextDrawerDefaultFonts;

public class SheetUtils {

    public static File convertToOldFile(DBRoot root, String fileName, File pathDest, File fDest) {

        // FIXME: !!!!!!!!

        return convertToOldFile(root, fileName, pathDest, fDest, ".ods");

    }

    public static File convertToOldFile(DBRoot root, String fileName, File pathDest, File fDest, String extension) {

        return convertToOldFile(root, fileName, pathDest, fDest, extension, true);

    }

    /**

     * Déplace le fichier, si il existe, dans le répertoire.

     *

     * @param fileName nom du fichier sans extension

     * @param pathDest

     * @param fDest

     * @return

     */

    public static File convertToOldFile(DBRoot root, String fileName, File pathDest, File fDest, String extension, boolean move) {

        SQLPreferences prefs = new SQLPreferences(root);

        if (prefs.getBoolean(GenerationDocGlobalPreferencePanel.HISTORIQUE, true) && fDest.exists()) {

            int i = 0;

            String destName = fileName;

            File pathOld = new File(pathDest, "Historique");

            pathOld.mkdirs();

            while (fDest.exists()) {

                destName = fileName + "_" + i;

                fDest = new File(pathOld, destName + extension);

                i++;

            }

            File fTmp = new File(pathDest, fileName + extension);

            if (move) {

                if (!fTmp.renameTo(fDest)) {

                    final File finalFile = fDest;

                    System.err.println("Unable to rename:" + fTmp.getAbsolutePath());

                    System.err.println("To:" + fDest.getAbsolutePath());

                    SwingUtilities.invokeLater(new Runnable() {

                        public void run() {

                            try {

                                JOptionPane.showMessageDialog(null, "Le fichier " + finalFile.getCanonicalPath()

                                        + " n'a pu être créé. \n Impossible de déplacer le fichier existant dans l'historique.\n Vérifier que le document n'est pas déjà ouvert.");

                            } catch (IOException e) {

                                e.printStackTrace();

                            }

                        }

                    });

                    return fTmp;

                }

            } else {

                try {

                    FileUtils.copyFile(fTmp, fDest);

                } catch (IOException exn) {

                    // TODO Bloc catch auto-généré

                    ExceptionHandler.handle("Une erreur est survenue lors de la copie du fichier.", exn);

                }

            }

            fDest = new File(pathDest, fileName + extension);

        }

        return fDest;

    }

    public static List<File> getHistorique(final String fileName, File pathDest) {

        File pathOld = new File(pathDest, "Historique");

        File[] files = pathOld.listFiles(new FilenameFilter() {

            @Override

            public boolean accept(File dir, String name) {

                return name.startsWith(fileName);

            }

        });

        List<File> result = new ArrayList<File>();

        if (files != null) {

            for (int i = 0; i < files.length; i++) {

                result.add(files[i]);

            }

        }

        Collections.sort(result, new Comparator<File>() {

            @Override

            public int compare(File o1, File o2) {

                // TODO Auto-generated method stub

                return o1.getName().compareTo(o2.getName());

            }

        });

        return result;

    }

    public static void convert2PDF(final OpenDocument doc, final File pdfFileToCreate) throws Exception {

        convert2PDF(doc, pdfFileToCreate, Collections.emptyList());

    }

    public static void convert2PDF(final OpenDocument doc, final File pdfFileToCreate, final List<PDFAttachment> attachments) throws Exception {

        assert (!SwingUtilities.isEventDispatchThread());

        System.out.println("SheetUtils convert2PDF " + doc.getLoadedFile().getAbsolutePath() + " -> " + pdfFileToCreate.getAbsolutePath());

        try {

            PDDocument document = new PDDocument();

            PDDocumentInformation info = new PDDocumentInformation();

            info.setCreator("OpenConcerto");

            info.setProducer("OpenConcerto");

            info.setCreationDate(Calendar.getInstance());

            info.setModificationDate(Calendar.getInstance());

            document.setDocumentInformation(info);

            // Attachments

            final PDEmbeddedFilesNameTreeNode efTree = new PDEmbeddedFilesNameTreeNode();

            final Map<String, PDComplexFileSpecification> efMap = new HashMap<>();

            for (final PDFAttachment att : attachments) {

                // first create the file specification, which holds the embedded file

                final PDComplexFileSpecification fs = new PDComplexFileSpecification();

                fs.setFile(att.getFileName());

                final InputStream is = new ByteArrayInputStream(att.getBytes());

                final PDEmbeddedFile ef = new PDEmbeddedFile(document, is);

                // set some of the attributes of the embedded file

                ef.setSubtype(att.getMimetype());

                ef.setSize(att.getBytes().length);

                ef.setCreationDate(new GregorianCalendar());

                fs.setEmbeddedFile(ef);

                efMap.put(att.getName(), fs);

            }

            efTree.setNames(efMap);

            // attachments are stored as part of the "names" dictionary in the document catalog

            final PDDocumentNameDictionary names = new PDDocumentNameDictionary(document.getDocumentCatalog());

            names.setEmbeddedFiles(efTree);

            document.getDocumentCatalog().setNames(names);

            PdfBoxGraphics2DFontTextDrawer fontTextDrawer = new PdfBoxGraphics2DFontTextDrawerDefaultFonts();

            final File dir = new File("Fonts");

            if (dir.exists()) {

                System.out.println("Using fonts dir : " + dir.getAbsolutePath());

                for (File f : dir.listFiles()) {

                    if (f.isFile() && f.getName().toLowerCase().endsWith(".ttf")) {

                        System.out.println("Registering font : " + f.getAbsolutePath());

                        fontTextDrawer.registerFont(f);

                    }

                }

            } else {

                System.out.println("No custom fonts dir found : " + dir.getAbsolutePath());

            }

            // Configure the renderer

            ODTRenderer renderer = new ODTRenderer(doc);

            renderer.setIgnoreMargins(false);

            renderer.setResizeFactor(100);

            renderer.setPaintMaxResolution(true);

            PDRectangle pageSize = PDRectangle.A4;

            // Scale the renderer to fit width or height

            final double widthFactor = renderer.getPrintWidth() / pageSize.getWidth();

            final double heightFactor = renderer.getPrintHeight() / pageSize.getHeight();

            final int resizeFactor = (int) Math.ceil(Math.max(widthFactor, heightFactor));

            renderer.setResizeFactor(resizeFactor);

            // Print pages

            for (int i = 0; i < renderer.getPrintedPagesNumber(); i++) {

                final PDPage page = new PDPage(pageSize);

                document.addPage(page);

                PdfBoxGraphics2D g2 = new PdfBoxGraphics2D(document, pageSize.getWidth(), pageSize.getHeight());

                g2.setFontTextDrawer(fontTextDrawer);

                // centrage horizontal, alignement vertical en haut

                final double hMargin = (pageSize.getWidth() - renderer.getPageWidthInPixel()) / 2.0;

                g2.translate(hMargin, 0);

                // Render

                renderer.setCurrentPage(i);

                renderer.paintComponent(g2);

                g2.dispose();

                final PDFormXObject xform = g2.getXFormObject();

                final Matrix matrix = new Matrix();

                matrix.translate(0, 0);

                final PDPageContentStream contentStream = new PDPageContentStream(document, page);

                contentStream.transform(matrix);

                contentStream.drawForm(xform);

                contentStream.close();

            }

            document.save(pdfFileToCreate);

            // Close the PDF document

            document.close();

        } catch (Exception originalExn) {

            ExceptionHandler.handle("Impossible de créer le PDF " + pdfFileToCreate.getAbsolutePath(), originalExn);

        }

    }

    /**

     * Get a new file with an other extension

     *

     * @param the file (ex: Test.ods)

     * @param the extension (ex: pdf)

     */

    static File getFileWithExtension(File file, String extension) {

        if (!extension.startsWith(".")) {

            extension = "." + extension;

        }

        String name = file.getName();

        int i = name.lastIndexOf(".");

        name = name.substring(0, i) + extension;

        final File f = new File(file.getParent(), name);

        return f;

    }

    public static void main(String[] args) throws Exception {

        // final OpenDocument doc = new OpenDocument(new File("Documents/Facture_FACT128.ods"));

        final OpenDocument doc = new OpenDocument(new File("../ODSViewer/documents/bug_marges_pdf/Devis.ods"));

        final File file = new File("out.pdf");

        convert2PDF(doc, file);

        Desktop.getDesktop().open(file);

    }

}