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.utils;

import org.openconcerto.utils.cc.ITransformerExn;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.Closeable;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.util.Enumeration;
import java.util.Set;
import java.util.function.Function;
import java.util.jar.JarEntry;
import java.util.jar.JarOutputStream;
import java.util.zip.CRC32;
import java.util.zip.DeflaterOutputStream;
import java.util.zip.InflaterInputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipException;
import java.util.zip.ZipOutputStream;

/**
 * Permet d'écrire dans un fichier zip.
 * 
 * @author ILM Informatique
 * @see org.openconcerto.utils.Unzip
 */
public class Zip implements Closeable {

    static public byte[] deflate(final String s) throws IOException {
        return deflate(s.getBytes(StringUtils.UTF8));
    }

    static public byte[] deflate(final byte[] b) throws IOException {
        final ByteArrayOutputStream bOut = new ByteArrayOutputStream();
        final DeflaterOutputStream out = new DeflaterOutputStream(bOut);
        out.write(b);
        out.close();
        return bOut.toByteArray();
    }

    static public ByteBuffer deflateToBuffer(final String s) throws IOException {
        return ByteBuffer.wrap(deflate(s));
    }

    static public String inflateToString(final ByteBuffer payload) throws IOException {
        return inflateToString(payload, payload.remaining());
    }

    static public String inflateToString(final ByteBuffer payload, final int length) throws IOException {
        final byte[] b = new byte[length];
        payload.get(b);
        return inflateToString(b);
    }

    static public String inflateToString(final byte[] b) throws IOException {
        return new String(inflate(b), StringUtils.UTF8);
    }

    static public byte[] inflate(final byte[] b) throws IOException {
        final InflaterInputStream in = new InflaterInputStream(new ByteArrayInputStream(b));
        final ByteArrayOutputStream out = new ByteArrayOutputStream();
        StreamUtils.copy(in, out);
        out.close();
        return out.toByteArray();
    }

    /**
     * Copie de from dans to seulement les entrées dont le nom n'est pas dans
     * <code>excludedEntries</code>.
     * 
     * @param from le zip source.
     * @param excludedEntries les noms des entrées à exclure.
     * @param to le zip de destination, s'il existe déjà les entrées de from seront ajoutées aux
     *        existantes.
     * @return le fichier zip dest.
     * @throws ZipException
     * @throws IOException
     */
    static public Zip createFrom(File from, File to, Set<String> excludedEntries) throws ZipException, IOException {
        Unzip unz = new Unzip(from);
        Zip res = new Zip(to);
        final Enumeration<? extends ZipEntry> en = unz.entries();
        while (en.hasMoreElements()) {
            final ZipEntry entry = en.nextElement();
            if (!excludedEntries.contains(entry.getName())) {
                res.zip(entry.getName(), unz.getInputStream(entry));
            }
        }
        unz.close();
        return res;
    }

    /**
     * Efface les entrées spécifées de src. Si dest existe, il sera ecrasé.
     * 
     * @param src le zip source.
     * @param entriesName les noms des entrées à effacer.
     * @param dest le zip de destination.
     * @throws ZipException
     * @throws IOException
     */
    static public void delete(File src, Set<String> entriesName, File dest) throws ZipException, IOException {
        if (dest.exists())
            dest.delete();
        createFrom(src, dest, entriesName).close();
    }

    static public Zip createJar(final OutputStream out) {
        return new Zip(out, JarOutputStream::new, JarEntry::new);
    }

    // *** Instance

    private final OutputStream outstream;
    private final ITransformerExn<OutputStream, ZipOutputStream, IOException> createZipStream;
    private ZipOutputStream zos;
    private final Function<String, ZipEntry> createEntry;
    // is an entry open, ie addEntry() has been called but closeEntry() not yet
    private boolean entryOpen;

    /**
     * Construit un fichier zip. ATTN Le fichier passé sera écrasé lors de la première écriture.
     * 
     * @param f le fichier dans lequel sauver, peut ne pas exister.
     * @throws FileNotFoundException if f cannot be written to.
     */
    public Zip(File f) throws FileNotFoundException {
        this(new FileOutputStream(f));
    }

    /**
     * Construit un fichier zip.
     * 
     * @param out un stream dans lequel écrire.
     */
    public Zip(OutputStream out) {
        this(out, ZipOutputStream::new, ZipEntry::new);
    }

    public Zip(OutputStream out, final ITransformerExn<OutputStream, ZipOutputStream, IOException> createZipStream, final Function<String, ZipEntry> createEntry) {
        this.outstream = out;
        this.createZipStream = createZipStream;
        this.zos = null;
        this.createEntry = createEntry;
        this.entryOpen = false;
    }

    @Override
    public synchronized void close() throws IOException {
        if (this.zos != null) {
            // ferme aussi le FileOutputStream
            this.zos.close();
        } else {
            this.outstream.close();
        }
    }

    // *** Ecriture

    private synchronized ZipOutputStream getOutStream() throws IOException {
        if (this.zos == null) {
            this.zos = this.createZipStream.transformChecked(this.outstream);
        }
        return this.zos;
    }

    public ZipEntry createEntry(String name) {
        return this.createEntry.apply(name);
    }

    /**
     * Ajoute newFile dans ce fichier. Il sera enregistré dans le zip directement à la racine.
     * 
     * @param newFile le fichier à ajouter.
     * @throws IOException si le fichier ne peut etre zippé.
     */
    public void zip(File newFile) throws IOException {
        // on ne garde que la derniere partie du chemin
        this.zip(newFile.getName(), newFile);
    }

    public void zip(final String entryName, final File newFile) throws IOException {
        final ZipEntry entry = this.createEntry(entryName);
        // TODO call ZipEntry.setCreationTime()
        entry.setTime(newFile.lastModified());
        try (final BufferedInputStream ins = new BufferedInputStream(new FileInputStream(newFile))) {
            this.zip(entry, ins);
        }
    }

    /**
     * Zippe le contenu de <code>in</code>.
     * 
     * @param name le nom de l'entrée.
     * @param in l'ajout.
     * @throws IOException si in ne peut etre zippé.
     */
    public void zip(String name, InputStream in) throws IOException {
        this.zip(this.createEntry(name), in);
    }

    public synchronized void zip(final ZipEntry entry, InputStream in) throws IOException {
        this.putNextEntry(entry);

        byte b[] = new byte[512];
        int len = 0;
        while ((len = in.read(b)) != -1) {
            this.getOutStream().write(b, 0, len);
        }

        this.closeEntry();
    }

    public void zip(String name, byte[] in, final boolean compressed) throws IOException {
        // don't make #zip(String, InputStream) call this method, it would require to read the
        // entire stream into memory
        if (compressed)
            this.zip(name, new ByteArrayInputStream(in));
        else
            this.zipNonCompressed(name, in);
    }

    /**
     * Zip the passed array with the {@link ZipEntry#STORED} method. This method takes care of the
     * CRC and size.
     * 
     * @param name the entry name.
     * @param in what to zip.
     * @throws IOException if an error occurs.
     */
    public synchronized void zipNonCompressed(String name, byte[] in) throws IOException {
        final ZipEntry entry = createEntry(name);
        entry.setMethod(ZipEntry.STORED);
        final CRC32 crc = new CRC32();
        crc.update(in);
        entry.setCrc(crc.getValue());
        entry.setSize(in.length);

        this.putNextEntry(entry);
        this.getOutStream().write(in);
        this.closeEntry();
    }

    /**
     * Adds a new entry to this zip file. ATTN you must close the returned stream before you can add
     * to this zip again.
     * 
     * @param name the name of the entry.
     * @return a stream to write to the entry.
     * @throws IOException if a pb occurs.
     */
    public synchronized OutputStream createEntryStream(String name) throws IOException {
        this.putNextEntry(name);
        return new BufferedOutputStream(this.getOutStream()) {
            public void close() throws IOException {
                this.flush();
                Zip.this.closeEntry();
            }
        };
    }

    private final synchronized void putNextEntry(String name) throws IOException, FileNotFoundException {
        this.putNextEntry(createEntry(name));
    }

    private final synchronized void putNextEntry(ZipEntry entry) throws IOException, FileNotFoundException {
        if (this.entryOpen)
            throw new IllegalStateException("previous entry not closed");
        this.entryOpen = true;
        this.getOutStream().putNextEntry(entry);
    }

    protected final synchronized void closeEntry() throws IOException {
        this.getOutStream().closeEntry();
        this.entryOpen = false;
    }

}