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.ui.PreviewFrame;

import org.openconcerto.erp.core.customerrelationship.mail.EmailTemplate;

import org.openconcerto.erp.core.customerrelationship.mail.ValueListener;

import org.openconcerto.erp.core.sales.invoice.report.VenteFactureXmlSheet;

import org.openconcerto.erp.core.sales.quote.report.PaypalStamper;

import org.openconcerto.erp.generationDoc.element.TypeModeleSQLElement;

import org.openconcerto.erp.model.MouseSheetXmlListeListener;

import org.openconcerto.erp.preferences.PayPalPreferencePanel;

import org.openconcerto.erp.storage.CloudStorageEngine;

import org.openconcerto.erp.storage.StorageEngine;

import org.openconcerto.erp.storage.StorageEngines;

import org.openconcerto.openoffice.OOUtils;

import org.jopendocument.link.Component;

import org.openconcerto.sql.Configuration;

import org.openconcerto.sql.element.SQLComponent;

import org.openconcerto.sql.element.SQLElement;

import org.openconcerto.sql.model.SQLBase;

import org.openconcerto.sql.model.SQLRow;

import org.openconcerto.sql.model.SQLRowAccessor;

import org.openconcerto.sql.model.SQLTable;

import org.openconcerto.sql.preferences.SQLPreferences;

import org.openconcerto.sql.view.EditFrame;

import org.openconcerto.sql.view.EditPanel.EditMode;

import org.openconcerto.ui.FrameUtil;

import org.openconcerto.utils.Action;

import org.openconcerto.utils.ExceptionHandler;

import org.openconcerto.utils.cc.ITransformer;

import org.openconcerto.utils.i18n.Grammar;

import org.openconcerto.utils.i18n.TranslationManager;

import java.awt.GraphicsEnvironment;

import java.awt.print.PrinterJob;

import java.io.BufferedInputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.OutputStream;

import java.lang.Thread.UncaughtExceptionHandler;

import java.net.HttpURLConnection;

import java.net.URL;

import java.net.URLConnection;

import java.net.URLEncoder;

import java.nio.charset.StandardCharsets;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.StringJoiner;

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Future;

import java.util.concurrent.LinkedBlockingQueue;

import java.util.concurrent.ThreadFactory;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.concurrent.TimeUnit;

import javax.swing.JOptionPane;

import org.jopendocument.model.OpenDocument;

public abstract class SheetXml {

    private ITransformer<List<SQLRowAccessor>, List<SQLRowAccessor>> postProcess = null;

    public ITransformer<List<SQLRowAccessor>, List<SQLRowAccessor>> getPostProcess() {

        return postProcess;

    }

    // INSTEAD USE THE PREF IN L.O. CALC --> Formules, toujours recalculer

    private boolean refreshFormulasRequired = false;

    // return null to keep default value

    public interface StorageDirs {

        public File getDocumentOutputDirectory(SheetXml sheet);

        public File getPDFOutputDirectory(SheetXml sheet);

        public String getStoragePath(SheetXml sheet);

    }

    /**

     * Post process line

     *

     * @param postProcess

     */

    public void setPostProcess(ITransformer<List<SQLRowAccessor>, List<SQLRowAccessor>> postProcess) {

        this.postProcess = postProcess;

    }

    private static StorageDirs STORAGE_DIRS;

    // allow to redirect all documents

    public static void setStorageDirs(StorageDirs d) {

        STORAGE_DIRS = d;

    }

    public static final String DEFAULT_PROPERTY_NAME = "Default";

    protected SQLElement elt;

    // nom de l'imprimante à utiliser

    protected String printer;

    // id

    protected SQLRow row;

    // Language du document

    protected SQLRow rowLanguage;

    protected static final SQLBase base = ((ComptaPropsConfiguration) Configuration.getInstance()).getSQLBaseSociete();

    // single threaded and kill its thread after 3 seconds (to allow the program to exit)

    protected static final ExecutorService runnableQueue = new ThreadPoolExecutor(0, 1, 3L, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(), new ThreadFactory() {

        @Override

        public Thread newThread(Runnable r) {

            final Thread res = new Thread(r);

            res.setUncaughtExceptionHandler(DEFAULT_HANDLER);

            return res;

        }

    });

    protected static UncaughtExceptionHandler DEFAULT_HANDLER = new UncaughtExceptionHandler() {

        @Override

        public void uncaughtException(Thread t, Throwable e) {

            ExceptionHandler.handle("Erreur de generation", e);

        }

    };

    public final SQLElement getElement() {

        return this.elt;

    }

    public Future<SheetXml> showPrintAndExportAsynchronous(final boolean showDocument, final boolean printDocument, final boolean exportToPDF) {

        return showPrintAndExportAsynchronous(showDocument, printDocument, exportToPDF, Collections.emptyList());

    }

    /**

     * Show, print and export the document to PDF. This method is asynchronous, but is executed in a

     * single threaded queue shared with createDocument

     */

    public Future<SheetXml> showPrintAndExportAsynchronous(final boolean showDocument, final boolean printDocument, final boolean exportToPDF, List<Action> actions) {

        final Callable<SheetXml> c = new Callable<SheetXml>() {

            @Override

            public SheetXml call() throws Exception {

                showPrintAndExport(showDocument, printDocument, exportToPDF, actions);

                return SheetXml.this;

            }

        };

        return runnableQueue.submit(c);

    }

    public Future<SheetXml> showPrintAndExportAsynchronous(final boolean showDocument, final boolean printDocument, final boolean exportToPDF, final SQLElement element, SQLRow row) {

        final Callable<SheetXml> c = new Callable<SheetXml>() {

            @Override

            public SheetXml call() throws Exception {

                final List<Action> actions = new ArrayList<>();

                if (SheetXml.this instanceof AbstractSheetXml) {

                    final SQLTable table = element.getTable();

                    final Action emailAction = new Action(TranslationManager.getInstance().getTranslationForAction("document.pdf.send.email")) {

                        @Override

                        public void run(Object source) {

                            EmailTemplate.askTemplate(null, table.getDBRoot(), table.getName(), new ValueListener() {

                                @Override

                                public void valueSelected(Object value) {

                                    final MouseSheetXmlListeListener l = new MouseSheetXmlListeListener(element, ((AbstractSheetXml) SheetXml.this).getClass());

                                    l.sendMail((EmailTemplate) value, (AbstractSheetXml) SheetXml.this, true);

                                }

                            });

                        }

                    };

                    actions.add(emailAction);

                }

                final Action modifyAction = new Action(TranslationManager.getInstance().getTranslationForAction("modify") + " " + element.getName().getVariant(Grammar.DEFINITE_ARTICLE_SINGULAR)) {

                    @Override

                    public void run(Object source) {

                        if (source instanceof PreviewFrame) {

                            ((PreviewFrame) source).dispose();

                        }

                        final SQLComponent component = element.createDefaultComponent();

                        final EditFrame f = new EditFrame(component, EditMode.MODIFICATION);

                        f.selectionId(row.getID());

                        FrameUtil.show(f);

                    }

                };

                actions.add(modifyAction);

                showPrintAndExport(showDocument, printDocument, exportToPDF, actions);

                return SheetXml.this;

            }

        };

        return runnableQueue.submit(c);

    }

    public static Future<?> submitInQueue(final Runnable r) {

        return runnableQueue.submit(r);

    }

    public void showPrintAndExport(final boolean showDocument, final boolean printDocument, boolean exportToPDF) {

        showPrintAndExport(showDocument, printDocument, exportToPDF, Boolean.getBoolean("org.openconcerto.oo.useODSViewer"), false, Collections.emptyList());

    }

    public void showPrintAndExport(final boolean showDocument, final boolean printDocument, boolean exportToPDF, List<Action> actions) {

        showPrintAndExport(showDocument, printDocument, exportToPDF, Boolean.getBoolean("org.openconcerto.oo.useODSViewer"), false, actions);

    }

    public void showPrintAndExport(final boolean showDocument, final boolean printDocument, boolean exportToPDF, boolean useODSViewer, boolean exportPDFSynch) {

        showPrintAndExport(showDocument, printDocument, exportToPDF, useODSViewer, exportPDFSynch, Collections.emptyList());

    }

    /**

     * Show, print and export the document to PDF. This method is synchronous

     */

    public void showPrintAndExport(final boolean showDocument, final boolean printDocument, boolean exportToPDF, boolean useODSViewer, boolean exportPDFSynch, List<Action> actions) {

        final File generatedFile = getGeneratedFile();

        final File pdfFile = getGeneratedPDFFile();

        if (generatedFile == null || !generatedFile.exists()) {

            JOptionPane.showMessageDialog(null, "Fichier généré manquant : " + generatedFile);

            return;

        }

        try {

            if (!useODSViewer) {

                if (exportToPDF || printDocument) {

                    final Component doc = ComptaPropsConfiguration.getOOConnexion().loadDocument(generatedFile, !showDocument);

                    if (printDocument) {

                        Map<String, Object> map = new HashMap<String, Object>();

                        map.put("Name", this.printer);

                        doc.printDocument(map);

                    }

                    if (exportToPDF) {

                        doc.saveToPDF(pdfFile).get();

                    }

                    if (!showDocument) {

                        doc.close();

                    }

                } else {

                    openDocument(false);

                }

            } else {

                final OpenDocument doc = new OpenDocument(generatedFile);

                if (showDocument) {

                    showPreviewDocument(actions);

                }

                if (printDocument) {

                    // Print !

                    DefaultNXDocumentPrinter printer = new DefaultNXDocumentPrinter();

                    printer.print(Arrays.asList(doc));

                }

                // FIXME Profiler pour utiliser moins de ram --> ex : demande trop de mémoire pour

                // faire

                // un grand livre KD

                if (exportToPDF) {

                    Thread t = new Thread(new Runnable() {

                        @Override

                        public void run() {

                            createPDF(generatedFile, pdfFile, doc, getStoragePath());

                        }

                    }, "convert and upload to pdf");

                    t.setDaemon(true);

                    t.start();

                    if (exportPDFSynch) {

                        t.join();

                    }

                }

            }

        } catch (Exception e) {

            ExceptionHandler.handle("Impossible de charger le document OpenOffice " + pdfFile.getAbsolutePath() + "(viewer : " + useODSViewer + ")", e);

        }

    }

    MetaDataSheet meta;

    /**

     * MetaData à inclure lors de la génération

     *

     * @param meta

     */

    public void setMetaGeneration(MetaDataSheet meta) {

        this.meta = meta;

    }

    /**

     * MetaData à inclure lors de la génération

     *

     * @param meta

     */

    public MetaDataSheet getMetaGeneration() {

        return this.meta;

    }

    public void createPDF(final File generatedFile, final File pdfFile, final OpenDocument doc, String storagePath) {

        if (pdfFile == null) {

            throw new IllegalArgumentException("null PDF file");

        }

        try {

            SheetUtils.convert2PDF(doc, pdfFile);

        } catch (Exception e) {

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

        }

        if (!pdfFile.canRead()) {

            ExceptionHandler.handle("Le fichier PDF " + pdfFile.getAbsolutePath() + " ne peut être lu.");

        }

        storeWithStorageEngines(generatedFile, pdfFile, storagePath);

    }

    protected void storeWithStorageEngines(final File generatedFile, final File pdfFile, String storagePath) {

        List<StorageEngine> engines = StorageEngines.getInstance().getActiveEngines();

        for (StorageEngine storageEngine : engines) {

            if (storageEngine.isConfigured() && storageEngine.allowAutoStorage()) {

                final String path = storagePath;

                try {

                    storageEngine.connect();

                    final BufferedInputStream inStream = new BufferedInputStream(new FileInputStream(pdfFile));

                    storageEngine.store(inStream, path, pdfFile.getName(), true);

                    inStream.close();

                    storageEngine.disconnect();

                } catch (IOException e) {

                    ExceptionHandler.handle("Impossible de sauvegarder le PDF " + pdfFile.getAbsolutePath() + " vers " + path + "(" + storageEngine + ")", e);

                }

                if (storageEngine instanceof CloudStorageEngine) {

                    try {

                        storageEngine.connect();

                        final BufferedInputStream inStream = new BufferedInputStream(new FileInputStream(generatedFile));

                        storageEngine.store(inStream, path, generatedFile.getName(), true);

                        inStream.close();

                        storageEngine.disconnect();

                    } catch (IOException e) {

                        ExceptionHandler.handle("Impossible de sauvegarder le fichier généré " + generatedFile.getAbsolutePath() + " vers " + path + "(" + storageEngine + ")", e);

                    }

                }

            }

        }

    }

    public abstract String getDefaultTemplateId();

    /**

     * Path of the directory used for storage. Ex: Devis/2010

     */

    public final String getStoragePath() {

        final String res = STORAGE_DIRS == null ? null : STORAGE_DIRS.getStoragePath(this);

        if (res != null)

            return res;

        else

            return this.getStoragePathP();

    }

    public final File getDocumentOutputDirectory() {

        final File res = STORAGE_DIRS == null ? null : STORAGE_DIRS.getDocumentOutputDirectory(this);

        if (res != null)

            return res;

        else

            return this.getDocumentOutputDirectoryP();

    }

    public final File getPDFOutputDirectory() {

        final File res = STORAGE_DIRS == null ? null : STORAGE_DIRS.getPDFOutputDirectory(this);

        if (res != null)

            return res;

        else

            return this.getPDFOutputDirectoryP();

    }

    protected abstract String getStoragePathP();

    protected abstract File getDocumentOutputDirectoryP();

    protected abstract File getPDFOutputDirectoryP();

    /**

     * Name of the generated document (without extension), do not rely on this name.

     *

     * Use getGeneratedFile().getName() to get the generated file name.

     */

    public abstract String getName();

    /**

     * @return the template id for this template (ex: "sales.quote")

     */

    public String getTemplateId() {

        if (this.row != null && this.row.getTable().getFieldsName().contains("ID_MODELE")) {

            if (row.getObject("ID_MODELE") == null || row.isForeignEmpty("ID_MODELE")) {

                TypeModeleSQLElement typeModele = Configuration.getInstance().getDirectory().getElement(TypeModeleSQLElement.class);

                String modele = typeModele.getTemplateMapping().get(this.row.getTable().getName());

                if (modele == null) {

                    System.err.println("No default modele in table TYPE_MODELE for table " + this.row.getTable().getName());

                    Thread.dumpStack();

                    return getDefaultTemplateId();

                } else {

                    return modele;

                }

            } else {

                SQLRow rowModele = this.row.getForeignRow("ID_MODELE");

                return rowModele.getString("NOM");

            }

        }

        return getDefaultTemplateId();

    }

    public abstract Future<SheetXml> createDocumentAsynchronous();

    public void createDocument() throws InterruptedException, ExecutionException {

        createDocumentAsynchronous().get();

    }

    /**

     * get the File that is, or must be generated.

     *

     * @return a file (not null)

     */

    public abstract File getGeneratedFile();

    public File getGeneratedPDFFile() {

        return SheetUtils.getFileWithExtension(getGeneratedFile(), ".pdf");

    }

    public SQLRow getRowLanguage() {

        return this.rowLanguage;

    }

    public String getReference() {

        return "";

    }

    /**

     * Creates the document if needed and returns the generated file (OpenDocument)

     */

    public File getOrCreateDocumentFile() throws Exception {

        File f = getGeneratedFile();

        if (!f.exists()) {

            return createDocumentAsynchronous().get().getGeneratedFile();

        } else {

            return f;

        }

    }

    /**

     * Creates the document if needed and returns the generated file (OpenDocument)

     *

     * @param createRecent true for recreate the pdf document if older than ods

     * @return

     * @throws Exception

     *

     */

    public File getOrCreatePDFDocumentFile(boolean createRecent) throws Exception {

        return getOrCreatePDFDocumentFile(createRecent, Boolean.getBoolean("org.openconcerto.oo.useODSViewer"));

    }

    public File getOrCreatePDFDocumentFile(boolean createRecent, boolean useODSViewer) throws Exception {

        File f = getGeneratedPDFFile();

        if (!f.exists()) {

            getOrCreateDocumentFile();

            showPrintAndExport(false, false, true, useODSViewer, true, Collections.emptyList());

            return f;

        } else {

            File fODS = getOrCreateDocumentFile();

            if (fODS.lastModified() > f.lastModified()) {

                showPrintAndExport(false, false, true, useODSViewer, true, Collections.emptyList());

            }

            return f;

        }

    }

    /**

     * Open the document with the native application

     *

     * @param synchronous

     */

    public void openDocument(boolean synchronous) {

        Runnable r = new Runnable() {

            @Override

            public void run() {

                File f;

                try {

                    f = getOrCreateDocumentFile();

                    if (f != null && f.exists()) {

                        OOUtils.open(f);

                    } else {

                        if (!GraphicsEnvironment.isHeadless()) {

                            if (f != null) {

                                JOptionPane.showMessageDialog(null, "Le fichier " + f.getAbsolutePath() + " est manquant");

                            } else {

                                JOptionPane.showMessageDialog(null, "Fichier manquant");

                            }

                        } else {

                            if (f != null) {

                                throw new FileNotFoundException(f.getAbsolutePath() + " missing");

                            } else {

                                throw new NullPointerException("null document");

                            }

                        }

                    }

                } catch (Exception e) {

                    ExceptionHandler.handle("Impossible d'ouvrir le document.", e);

                }

            }

        };

        if (synchronous) {

            r.run();

        } else {

            Thread thread = new Thread(r, "openDocument: " + getGeneratedFile().getAbsolutePath());

            thread.setDaemon(true);

            thread.start();

        }

    }

    public void showPreviewDocument() throws Exception {

        showPreviewDocument(Collections.emptyList());

    }

    public void showPreviewDocument(List<Action> actions) throws Exception {

        File f = null;

        f = getOrCreateDocumentFile();

        PreviewFrame.show(f, actions);

    }

    public void printDocument() {

        printDocument(null);

    }

    public void printDocument(PrinterJob job) {

        try {

            final File f = getOrCreateDocumentFile();

            if (!Boolean.getBoolean("org.openconcerto.oo.useODSViewer")) {

                final Component doc = ComptaPropsConfiguration.getOOConnexion().loadDocument(f, true);

                doc.printDocument(job);

                doc.close();

            } else {

                // Load the spreadsheet.

                final OpenDocument doc = new OpenDocument(f);

                // Print !

                DefaultNXDocumentPrinter printer = new DefaultNXDocumentPrinter();

                printer.print(Arrays.asList(doc), job);

            }

        } catch (Exception e) {

            ExceptionHandler.handle("Impossible d'imprimer le document OpenOffice", e);

            e.printStackTrace();

        }

    }

    public SQLRow getSQLRow() {

        return this.row;

    }

    /**

     * Remplace tous les caracteres non alphanumeriques (seul le _ est autorisé) par un -. Cela

     * permet d'avoir toujours un nom de fichier valide.

     *

     * @param fileName nom du fichier à créer ex:FACTURE_2007/03/001

     * @return un nom fichier valide ex:FACTURE_2007-03-001

     */

    public static String getValidFileName(String fileName) {

        final StringBuffer result = new StringBuffer(fileName.length());

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

            char ch = fileName.charAt(i);

            // Si c'est un caractere alphanumerique

            if (Character.isLetterOrDigit(ch) || (ch == '_') || (ch == ' ')) {

                result.append(ch);

            } else {

                result.append('-');

            }

        }

        return result.toString();

    }

    public String getPrinter() {

        return this.printer;

    }

    public void setRefreshFormulasRequired(boolean refreshFormulasRequired) {

        this.refreshFormulasRequired = refreshFormulasRequired;

    }

    public boolean isRefreshFormulasRequired() {

            return refreshFormulasRequired;

    }

}