Aplicación gvSIG con fines educativos » Mapas temáticos

<?xml version="1.0" encoding="ISO-8859-1"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

	<modelVersion>4.0.0</modelVersion>

	<artifactId>org.gvsig.educa.portableview.lib</artifactId>

	<packaging>pom</packaging>

	<name>org.gvsig.educa.portableview.lib</name>

	<parent>

		<groupId>org.gvsig</groupId>

		<artifactId>org.gvsig.educa.portableview</artifactId>

		<version>1.0.210</version>

	</parent>

	<modules>

		<module>org.gvsig.educa.portableview.lib.api</module>

		<module>org.gvsig.educa.portableview.lib.impl</module>

		<module>org.gvsig.educa.portableview.lib.prov.installer</module>

	</modules>

</project>

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

package org.gvsig.educa.portableview.impl;

import java.io.File;

import java.io.FileFilter;

/**

 * <p>

 * {@link FileFilter} implementation which identifies files that can be a

 * Portable View

 * </p>

 * <p>

 * This checks:

 * <ul>

 * <li>file exists</li>

 * <li>is a file</li>

 * <li>ends in "." + Portable view extension</li>

 * </ul>

 * </p>

 *

 * @author gvSIG Team

 * @version $Id$

 *

 */

public class PortableViewFileFilter implements FileFilter {

    private final String fileNameEnding;

    private final String fileExtension;

    public PortableViewFileFilter(String fileExtension) {

        this.fileExtension = fileExtension;

        fileNameEnding = ".".concat(fileExtension);

    }

    /**

     * Returns "."+{@link #getFileExtension()}

     *

     * @return

     */

    public String getFileNameEnding() {

        return fileNameEnding;

    }

    /**

     * Returns file name extension used to match files

     *

     * @return

     */

    public String getFileExtension() {

        return fileExtension;

    }

    /** {@inheridDoc} */

    public boolean accept(File pathname) {

        return pathname.exists() && pathname.isFile()

            && pathname.getName().endsWith(fileNameEnding);

    }

}

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

package org.gvsig.educa.portableview.impl;

import java.io.File;

import java.io.IOException;

import java.io.InputStream;

import java.util.zip.ZipException;

import org.gvsig.educa.portableview.PortableViewFileServices;

import org.gvsig.educa.portableview.impl.util.FileUtils;

import org.gvsig.educa.portableview.impl.util.FilenameUtils;

import org.gvsig.educa.portableview.impl.util.IOUtils;

import org.gvsig.educa.portableview.impl.util.PersistenceUtils;

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

/**

 * <p>

 * Default implementation of {@link PortableViewFileServices}

 * </p>

 * <p>

 * Delegates almost all methods in {@link FilenameUtils}

 * </p>

 * 

 * @author gvSIG Team

 * @version $Id$

 * 

 */

public class DefaultPortableViewFileServices implements PortableViewFileServices {

    private final PersistenceManager persistenceManager;

    /**

     *

     */

    public DefaultPortableViewFileServices() {

        persistenceManager = ToolsLocator.getPersistenceManager();

    }

    /** {@inheridDoc} */

    public void unzipFile(File zipFile, File outputFloder) throws ZipException,

        IOException {

        FileUtils.unzipFile(zipFile, outputFloder);

    }

    /** {@inheridDoc} */

    public void zipFolder(File rootFolder, File targetFile) throws IOException {

        FileUtils.zipFolder(rootFolder, targetFile);

    }

    /** {@inheridDoc} */

    public boolean isWritableFolder(File folder) {

        return FileUtils.isWritableFolder(folder);

    }

    /** {@inheridDoc} */

    public boolean isReadableFolder(File folder) {

        return FileUtils.isReadableFolder(folder);

    }

    /** {@inheridDoc} */

    public boolean isReadableFile(File file) {

        return FileUtils.isReadableFile(file);

    }

    /** {@inheridDoc} */

    public File getWritableFolder(File baseFolder, String baseName) {

        return FileUtils.getWritableFolder(baseFolder, baseName);

    }

    /** {@inheridDoc} */

    public File getNewWritableFolder(File baseFolder, String baseName) {

        return FileUtils.getNewWritableFolder(baseFolder, baseName);

    }

    /** {@inheridDoc} */

    public File getNewFileName(File baseFolder, String name) {

        return FileUtils.getNewFileName(baseFolder, name);

    }

    /** {@inheridDoc} */

    public File getRelativeTo(File path, File basePath) {

        return FileUtils.getRelativeTo(path, basePath);

    }

    /** {@inheridDoc} */

    public MapContext loadMapContext(File mapContext, File relativaPathFolder)

        throws IOException, PersistenceException {

        InputStream is = null;

        try {

            // open file

            is = FileUtils.openInputStream(mapContext);

            // load Persistence status from file

            PersistentState persistenceStatus =

                persistenceManager.loadState(is);

            // Adjust all path in persistence status to deploy folder

            PersistenceUtils.fixMapContextFilePaths(persistenceStatus,

                relativaPathFolder);

            // Create a new mapContext Instance and load it form persistence

            // status

            return (MapContext) persistenceManager.create(persistenceStatus);

        } finally {

            IOUtils.closeQuietly(is);

        }

    }

}

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

package org.gvsig.educa.portableview.impl.map;

import java.text.DateFormat;

import java.text.ParseException;

import java.util.Date;

import org.cresques.cts.IProjection;

import org.gvsig.educa.portableview.map.PortableViewInformation;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.DynObjectManager;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.Persistent;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

/**

 * Default implementation of {@link PortableViewInformation}

 *

 * @author gvSIG Team

 * @version $Id$

 *

 */

public class DefaultPortableViewInformation implements PortableViewInformation,

    Persistent {

    public static DynStruct dynDefinition;

    private String id;

    private String name;

    private String description;

    private int version;

    private int buildNumber;

    private Date creationTimestamp;

    private Envelope envelope;

    private IProjection crs;

    /** {@inheridDoc} */

    public String getId() {

        return id;

    }

    /** {@inheridDoc} */

    public String getName() {

        return name;

    }

    /** {@inheridDoc} */

    public String getDescription() {

        return description;

    }

    /** {@inheridDoc} */

    public int getVersion() {

        return version;

    }

    /** {@inheridDoc} */

    public int getBuildNumber() {

        return buildNumber;

    }

    /** {@inheridDoc} */

    public Date getCreationTimestamp() {

        return creationTimestamp;

    }

    /** {@inheridDoc} */

    public Envelope getFullEnvelope() {

        if (envelope == null) {

            return null;

        }

        try {

            return (Envelope) envelope.clone();

        } catch (CloneNotSupportedException e) {

            throw new IllegalStateException(e);

        }

    }

    /** {@inheridDoc} */

    public IProjection getCRS() {

        return crs;

    }

    /** {@inheridDoc} */

    public void saveToState(PersistentState state) throws PersistenceException {

        state.set("id", id);

        state.set("name", name);

        state.set("description", description);

        state.set("version", version);

        state.set("buildNumber", buildNumber);

        state.set("creationTimestamp", creationTimestamp);

        state.set("envelope", envelope);

        state.set("crs", crs);

    }

    /** {@inheridDoc} */

    public DynObject getDynObject() {

        DynObjectManager manager = ToolsLocator.getDynObjectManager();

        DynObject obj = manager.createDynObject(dynDefinition);

        obj.setDynValue("id", id);

        obj.setDynValue("name", name);

        obj.setDynValue("description", description);

        obj.setDynValue("version", version);

        obj.setDynValue("buildNumber", buildNumber);

        obj.setDynValue("creationTimestamp", creationTimestamp);

        obj.setDynValue("envelope", envelope);

        obj.setDynValue("crs", crs);

        return obj;

    }

    /** {@inheridDoc} */

    public void loadFromState(PersistentState state)

        throws PersistenceException {

        id = state.getString("id");

        name = state.getString("name");

        description = state.getString("description");

        version = state.getInt("version");

        buildNumber = state.getInt("buildNumber");

        creationTimestamp = state.getDate("creationTimestamp");

        envelope = (Envelope) state.get("envelope");

        crs = (IProjection) state.get("crs");

    }

    protected void setId(String id) {

        this.id = id;

    }

    protected void setName(String name) {

        this.name = name;

    }

    protected void setDescription(String description) {

        this.description = description;

    }

    protected void setVersion(int version) {

        this.version = version;

    }

    protected void setBuildNumber(int buildNumber) {

        this.buildNumber = buildNumber;

    }

    protected void setCreationTimestamp(Date creationTimestamp) {

        this.creationTimestamp = creationTimestamp;

    }

    protected void setFullEnvelope(Envelope envelope) {

        try {

            this.envelope = (Envelope) envelope.clone();

        } catch (CloneNotSupportedException e) {

            throw new IllegalArgumentException(e);

        }

    }

    protected void setCrs(IProjection crs) {

        this.crs = crs;

    }

    public DynStruct getDynDefinition() {

        return dynDefinition;

    }

    /**

     * Utility method to register {@link PortableViewInformation} definition in

     * the {@link PersistenceManager}

     */

    public static void registerPersistent() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

        DynStruct definition =

            manager.addDefinition(DefaultPortableViewInformation.class,

                PortableViewInformation.DYN_DEFINITION_NAME,

                "Portable View information", null, null);

        definition.addDynFieldString("id").setMandatory(true);

        definition.addDynFieldString("name").setMandatory(true);

        definition.addDynFieldString("description").setMandatory(true);

        definition.addDynFieldInt("version").setMandatory(true);

        definition.addDynFieldInt("buildNumber").setMandatory(true);

        definition.addDynFieldDate("creationTimestamp").setMandatory(true);

        definition.addDynFieldObject("envelope")

            .setClassOfValue(Envelope.class).setMandatory(true);

        definition.addDynFieldObject("crs").setClassOfValue(IProjection.class)

            .setMandatory(true);

        dynDefinition = definition;

    }

}

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

package org.gvsig.educa.portableview.impl.map;

import java.io.File;

import java.io.IOException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.educa.portableview.impl.MapResoucesManager;

import org.gvsig.educa.portableview.map.CantLoadContextException;

import org.gvsig.educa.portableview.map.InvalidPortableViewFormatException;

import org.gvsig.educa.portableview.map.PortableView;

import org.gvsig.educa.portableview.map.PortableViewInformation;

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposableManager;

/**

 * <p>

 * Default {@link PortableView} implementation

 * </p>

 * <p>

 * Delegates open/close operation on the {@link MapResoucesManager}

 * </p>

 *

 * @author gvSIG Team

 * @version $Id$

 *

 */

public class DefaultPortableView implements PortableView {

    private static final Logger LOG = LoggerFactory

        .getLogger(DefaultPortableView.class);

    private final DisposableManager disposableManager;

    private final File file;

    private final PortableViewInformation info;

    private final MapResoucesManager resourceManager;

    private MapContext mapContext;

    public DefaultPortableView(File file, PortableViewInformation info,

        MapResoucesManager resourceManager) {

        this.file = file;

        this.info = info;

        this.resourceManager = resourceManager;

        disposableManager = ToolsLocator.getDisposableManager();

        disposableManager.bind(this);

        resourceManager.addResource(this);

    }

    /** {@inheridDoc} */

    public PortableViewInformation getInformation() {

        return info;

    }

    /**

     * Returns source map file

     *

     * @return

     */

    public File getSourceFile() {

        return file;

    }

    /** {@inheridDoc} */

    public void open() throws IOException, InvalidPortableViewFormatException,

        CantLoadContextException {

        if (isOpen()) {

            throw new IllegalStateException("Map is already opened");

        }

        mapContext = resourceManager.openMap(this);

    }

    /** {@inheridDoc} */

    public boolean isOpen() {

        return resourceManager.isOpen(this);

    }

    /** {@inheridDoc} */

    public void close() throws IOException {

        if (!isOpen()) {

            // Nothing to do

            return;

        }

        resourceManager.closeMap(this);

        mapContext.dispose();

        mapContext = null;

    }

    /** {@inheridDoc} */

    public MapContext getMapContext() {

        if (!isOpen()) {

            throw new IllegalStateException("Map not open");

        }

        return mapContext;

    }

    /** {@inheridDoc} */

    public String getSourceFilePath() {

        return file.getAbsolutePath();

    }

    public void dispose() {

        disposableManager.release(this);

        try {

            close();

        } catch (IOException e) {

            LOG.warn("Problem dispossing PortableView", e);

        }

    }

}

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

package org.gvsig.educa.portableview.impl.map;

import java.io.File;

import java.io.IOException;

import java.io.InputStream;

import java.util.Enumeration;

import java.util.zip.ZipEntry;

import java.util.zip.ZipException;

import java.util.zip.ZipFile;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.educa.portableview.PortableViewFileServices;

import org.gvsig.educa.portableview.PortableViewLocator;

import org.gvsig.educa.portableview.impl.util.FileUtils;

import org.gvsig.educa.portableview.impl.util.IOUtils;

import org.gvsig.educa.portableview.map.CantLoadContextException;

import org.gvsig.educa.portableview.map.InvalidInstalledPortableViewException;

import org.gvsig.educa.portableview.map.InvalidPortableViewFormatException;

import org.gvsig.educa.portableview.map.PortableViewInformation;

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.installer.lib.api.InstallerLocator;

import org.gvsig.installer.lib.api.InstallerManager;

import org.gvsig.installer.lib.api.PackageInfo;

import org.gvsig.installer.lib.api.PackageInfoReader;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

/**

 * Utility class which contain methods to load data from a PortableView file

 *

 * @author gvSIG Team

 * @version $Id$

 *

 */

public class PortableViewLoader {

    @SuppressWarnings("unused")

    private static final Logger LOG = LoggerFactory

        .getLogger(PortableViewLoader.class);

    private final InstallerManager installerManager;

    private final PackageInfoReader packageInfoReader;

    private final PortableViewFileServices fileServices;

    /**

     *

     */

    public PortableViewLoader() {

        installerManager = InstallerLocator.getInstallerManager();

        packageInfoReader = installerManager.getDefaultPackageInfoReader();

        fileServices = PortableViewLocator.getFileServices();

    }

    /**

     * Loads the mapContext definition form the deploy folder of a portable view

     *

     * @param mapFile

     *            portable view file name (for problems messages)

     * @param deployFolder

     *            portable view deploy folder

     * @return

     * @throws InvalidPortableViewFormatException

     * @throws CantLoadContextException

     */

    public MapContext loadMapContextFromMapDeployFolder(File mapFile,

        File deployFolder) throws InvalidPortableViewFormatException,

        CantLoadContextException {

        // Prepares file path

        File mapContextFile =

            new File(deployFolder, "mapContext/mapContext.xml");

        // Check if file exists

        if (!mapContextFile.exists()) {

            throw new InvalidPortableViewFormatException(mapFile,

                "Missing mapContext/mapContext.xml file in deployed map: "

                    .concat(mapContextFile.getAbsolutePath()));

        }

        if (!mapContextFile.isFile()) {

            throw new InvalidPortableViewFormatException(mapFile,

                "mapContext/mapContext.xml file in deployed map is not a file: "

                    .concat(mapContextFile.getAbsolutePath()));

        }

        // Load map context

        MapContext mapContext;

        try {

            mapContext =

                fileServices.loadMapContext(mapContextFile, deployFolder);

            if (mapContext == null) {

                throw new CantLoadContextException(mapFile, mapContextFile,

                    "mapContext not loaded", null);

            }

            return mapContext;

        } catch (Exception e) {

            throw new CantLoadContextException(mapFile, mapContextFile, e);

        }

    }

    /**

     * Gets information from a portableViewFile without uncompress it

     *

     * @param portableViewfile

     * @return

     * @throws InvalidPortableViewFormatException

     */

    public PortableViewInformation getInformationFromMapFile(File portableViewfile)

        throws InvalidPortableViewFormatException {

        PersistenceManager persistenceManager =

            ToolsLocator.getPersistenceManager();

        // Try to open file

        ZipFile zipFile;

        try {

            zipFile = new ZipFile(portableViewfile);

        } catch (ZipException e1) {

            throw new InvalidPortableViewFormatException(portableViewfile,

                "Zip format problem", e1);

        } catch (IOException e1) {

            throw new InvalidPortableViewFormatException(portableViewfile, e1);

        }

        PersistentState pState = null;

        try {

            // gets zip file entries

            Enumeration<? extends ZipEntry> entries = zipFile.entries();

            ZipEntry entry;

            // look for MapInfo entry

            while (entries.hasMoreElements()) {

                entry = entries.nextElement();

                if (!entry.getName().equals("MapInfo.xml")) {

                    continue;

                }

                // Check it's a file

                if (entry.isDirectory()) {

                    throw new InvalidPortableViewFormatException(

                        portableViewfile, "MapInfo.xml is a directory");

                }

                // Load file into a persistence state

                InputStream is = null;

                try {

                    try {

                        is = zipFile.getInputStream(entry);

                        pState = persistenceManager.loadState(is);

                    } catch (IOException e) {

                        throw new InvalidPortableViewFormatException(

                            portableViewfile, "problem opening MapInfo.xml", e);

                    } catch (PersistenceException e) {

                        throw new InvalidPortableViewFormatException(

                            portableViewfile, "problem loading MapInfo.xml", e);

                    }

                } finally {

                    IOUtils.closeQuietly(is);

                }

            }

        } finally {

            // Close zip file

            IOUtils.closeQuietly(zipFile);

        }

        // If MapInfo file not found

        if (pState == null) {

            throw new IllegalArgumentException("Missing MapInfo.xml");

        }

        // Load data form persistence state

        DefaultPortableViewInformation info =

            new DefaultPortableViewInformation();

        try {

            info.loadFromState(pState);

        } catch (PersistenceException e) {

            throw new IllegalArgumentException("Invalid MapInfo.xml format", e);

        }

        return info;

    }

    public PackageInfo getPackageInfoFromInstalledPortableView(File folder)

        throws InvalidInstalledPortableViewException {

        // Check for package.info file

        File packageInfoFile = new File(folder, "package.info");

        if (!FileUtils.isReadableFile(packageInfoFile)) {

            return null;

        }

        PackageInfo packageInfo = installerManager.createPackageInfo();

        InputStream in = null;

        try {

            in = FileUtils.openInputStream(packageInfoFile);

            packageInfoReader.read(packageInfo, in);

        } catch (Exception ex) {

            throw new InvalidInstalledPortableViewException(folder, ex);

        } finally {

            IOUtils.closeQuietly(in);

        }

        return packageInfo;

    }

}

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

package org.gvsig.educa.portableview.impl.util;

import java.io.File;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.util.Collection;

import java.util.Enumeration;

import java.util.zip.ZipEntry;

import java.util.zip.ZipException;

import java.util.zip.ZipFile;

import java.util.zip.ZipOutputStream;

import org.apache.commons.io.DirectoryWalker;

import org.apache.commons.lang3.StringUtils;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * <p>

 * File utilities. Extends the provides by <i>apache-common-IO</i>

 * </p>

 *

 * @author gvSIG Team

 * @version $Id$

 *

 */

public abstract class FileUtils extends org.apache.commons.io.FileUtils {

	private static final Logger LOG = LoggerFactory.getLogger(FileUtils.class);

	public static final boolean UNIXLIKE_FILESYSTEM = File.separatorChar == '/';

	/**

	 * <p>

	 * Unzip a file into a folder

	 * </p>

	 *

	 * @param zipFile

	 * @param outputFloder

	 *            must exists. WARNING: <b>Contents will be removed before

	 *            unzip</b>

	 * @throws IOException

	 * @throws ZipException

	 * @throws IllegalArgumentException

	 *             if zipFile is not a file or outputFloder doesn't exists or is

	 *             read-only

	 */

	public static void unzipFile(File zipFile, File outputFloder)

			throws ZipException, IOException {

		if (LOG.isDebugEnabled()) {

			LOG.debug(

					"Unzip {} --> {}",

					new Object[] { zipFile.getAbsolutePath(),

							outputFloder.getAbsolutePath() });

		}

		// basic checks input file

		if (!zipFile.exists()) {

			throw new IllegalArgumentException("File '".concat(

					zipFile.getAbsolutePath()).concat("' no exists"));

		}

		if (!zipFile.isFile()) {

			throw new IllegalArgumentException("'".concat(

					zipFile.getAbsolutePath()).concat("' is not a file"));

		}

		if (!zipFile.canRead()) {

			throw new IllegalArgumentException("File '".concat(

					zipFile.getAbsolutePath()).concat("' can not be readed"));

		}

		// basic checks output file

		if (!outputFloder.exists()) {

			throw new IllegalArgumentException("Folder '".concat(

					outputFloder.getAbsolutePath()).concat("' not exists."));

		}

		if (!outputFloder.isDirectory()) {

			throw new IllegalArgumentException("'".concat(

					outputFloder.getAbsolutePath())

					.concat("' is not a folder."));

		}

		if (!outputFloder.canWrite()) {

			throw new IllegalArgumentException("Can't write on'".concat(

					outputFloder.getAbsolutePath()).concat("' folder."));

		}

		if (LOG.isTraceEnabled()) {

			LOG.trace("cleaning directory {}", outputFloder.getAbsolutePath());

		}

		cleanDirectory(outputFloder);

		// Extract file

		ZipFile openedZipFile = null;

		try {

			openedZipFile = new ZipFile(zipFile);

			Enumeration<? extends ZipEntry> entries = openedZipFile.entries();

			ZipEntry entry;

			File targetFile;

			// iterate over entries

			while (entries.hasMoreElements()) {

				entry = entries.nextElement();

				// compound target path

				targetFile = new File(outputFloder, entry.getName());

				if (entry.isDirectory()) {

					// Create folder

					if (LOG.isTraceEnabled()) {

						LOG.trace("creating folder {}",

								targetFile.getAbsolutePath());

					}

					if (!targetFile.mkdirs()) {

						throw new IOException("Can't create '".concat(

								targetFile.getAbsolutePath()).concat(

								"' folder."));

					}

				} else {

					// extract file from zip

					if (LOG.isTraceEnabled()) {

						LOG.trace("extracting file {}",

								targetFile.getAbsolutePath());

					}

					extractZipEntry(openedZipFile, entry, targetFile);

				}

			}

		} finally {

			IOUtils.closeQuietly(openedZipFile);

		}

	}

	/**

	 * Extract a zipEntry into a file

	 *

	 * @param zipFile

	 * @param entry

	 * @param target

	 *            (if exists will be overwrite)

	 * @throws IOException

	 */

	private static void extractZipEntry(ZipFile zipFile, ZipEntry entry,

			File target) throws IOException {

		InputStream is = null;

		OutputStream os = null;

		try {

			is = zipFile.getInputStream(entry);

			os = openOutputStream(target);

			IOUtils.copy(is, os);

		} finally {

			IOUtils.closeQuietly(is);

			IOUtils.closeQuietly(os);

		}

	}

	/**

	 * <p>

	 * Create a zip file which will contains all contents of a folder

	 * </p>

	 * <p>

	 * Files will be use relative path to <code>rootFolder</code>

	 * </p>

	 *

	 * @param rootFolder

	 *            rootFolder (must be an existing folder)

	 * @param targetFile

	 *            final file (must not exists)

	 * @throws IOException

	 * @throws IllegalArgumentException

	 *             if there are any problem in parameters

	 */

	public static void zipFolder(File rootFolder, File targetFile)

			throws IOException {

		if (LOG.isDebugEnabled()) {

			LOG.debug(

					"zip {} --> {}",

					new Object[] { rootFolder.getAbsolutePath(),

							targetFile.getAbsolutePath() });

		}

		if (!isReadableFolder(rootFolder)) {

			throw new IllegalArgumentException("Invalid folder");

		}

		if (targetFile.exists()) {

			throw new IllegalArgumentException("Target file already exists");

		}

		if (!isWritableFolder(targetFile.getParentFile())) {

			throw new IllegalArgumentException("Can't write in target folder");

		}

		RelativePathFolderZipper zipper = new RelativePathFolderZipper(

				rootFolder, targetFile);

		zipper.zip();

	}

	/**

	 * Informs if <code>folder</code> is a writable folder( exists & isDir &

	 * canWrite)

	 *

	 * @param folder

	 * @return

	 */

	public static boolean isWritableFolder(File folder) {

		return folder.exists() && folder.isDirectory() && folder.canWrite();

	}

	/**

	 * Informs if <code>folder</code> is a readable folder( exists & isDir &

	 * canRead)

	 *

	 * @param folder

	 * @return

	 */

	public static boolean isReadableFolder(File folder) {

		return folder.exists() && folder.isDirectory() && folder.canRead();

	}

	/**

	 * Informs if <code>file</code> is a readable file ( exists & isFile &

	 * canRead)

	 *

	 * @param folder

	 * @return

	 */

	public static boolean isReadableFile(File folder) {

		return folder.exists() && folder.isFile() && folder.canRead();

	}

	/**

	 * <p>

	 * Look for a folder on a <code>baseFolder</code> starts with

	 * <code>baseName</code> which is writable.

	 * </p>

	 * <p>

	 * The pattern is: <code>baseFolder/baseName.0000</code> where

	 * <code>000</code> it's a counter.

	 * </p>

	 *

	 * @param baseFolder

	 *            existing and writable folder

	 * @param baseName

	 *            start of new folder

	 * @return new folder

	 * @throws IllegalArgumentException

	 *             if base folder is not a writable folder

	 * @throws IllegalStateException

	 *             if can't found a suitable folder

	 */

	public static File getWritableFolder(File baseFolder, String baseName) {

		if (!isWritableFolder(baseFolder)) {

			throw new IllegalArgumentException(

					"base folder is not a Writable folder");

		}

		File folder = new File(baseFolder, baseName);

		int count = 0;

		String countStr;

		// while Exists but is not a writable folder

		while (folder.exists() && !isWritableFolder(folder)) {

			countStr = String.valueOf(count);

			if (countStr.length() > 4) {

				throw new IllegalStateException(

						" > than 9999 non-selectable folders");

			}

			countStr = StringUtils.right("000".concat(countStr), 3);

			// Generate a new folder name based on 'baseTemp' and the counter

			folder = new File(baseFolder, baseName.concat(".").concat(countStr));

			count++;

		}

		// Create folder if not exists

		if (!folder.exists()) {

			folder.mkdirs();

		}

		return folder;

	}

	/**

	 * <p>

	 * Create a new folder on a <code>baseFolder</code> starts with

	 * <code>baseName</code> which is new and writable.

	 * </p>

	 * <p>

	 * The pattern is: <code>baseFolder/baseName.0000</code> where

	 * <code>000</code> it's a counter.

	 * </p>

	 *

	 * @param baseFolder

	 *            existing and writable folder

	 * @param baseName

	 *            start of new folder

	 * @return new folder

	 * @throws IllegalArgumentException

	 *             if base folder is not a writable folder

	 * @throws IllegalStateException

	 *             if can't found a suitable folder

	 */

	public static File getNewWritableFolder(File baseFolder, String baseName) {

		if (!isWritableFolder(baseFolder)) {

			throw new IllegalArgumentException(

					"base folder is not a Writable folder: ".concat(baseFolder

							.getAbsolutePath()));

		}

		File folder = new File(baseFolder, baseName);

		int count = 0;

		String countStr;

		// while Exists but is not a writable folder

		while (folder.exists() && !isWritableFolder(folder)) {

			countStr = String.valueOf(count);

			if (countStr.length() > 4) {

				throw new IllegalStateException(

						" > than 999 non-selectable folders");

			}

			countStr = StringUtils.right("000".concat(countStr), 3);

			// Generate a new folder name based on 'baseTemp' and the counter

			folder = new File(baseFolder, baseName.concat(".").concat(countStr));

			count++;

		}

		// Create folder if not exists

		if (!folder.exists()) {

			folder.mkdirs();

		}

		return folder;

	}

	/**

	 * <p>

	 * Create {@link File} instance for a new file on a <code>baseFolder</code>

	 * starts with <code>baseName</code>.

	 * </p>

	 * <p>

	 * The pattern is: <code>baseFolder/baseName.0000.ext</code> where

	 * <code>000</code> it's a counter.

	 * </p>

	 * <p>

	 * This <b>no create</b> the file into the file system.

	 * </p>

	 *

	 * @param baseFolder

	 *            existing and writable folder

	 * @param name

	 *            start of new file

	 * @return new folder

	 * @throws IllegalArgumentException

	 *             if base folder is not a writable folder

	 * @throws IllegalStateException

	 *             if can't found a suitable folder

	 */

	public static File getNewFileName(File baseFolder, String name) {

		if (!isWritableFolder(baseFolder)) {

			throw new IllegalArgumentException(

					"base folder is not a Writable folder");

		}

		// Extract base

		String baseName = org.apache.commons.io.FilenameUtils.getBaseName(name);

		String extension = org.apache.commons.io.FilenameUtils

				.getExtension(name);

		File newFile = new File(baseFolder, name);

		int count = 0;

		String countStr;

		// while Exists but is not a writable folder

		while (newFile.exists()) {

			countStr = String.valueOf(count);

			if (countStr.length() > 4) {

				throw new IllegalStateException(

						" > than 999 non-selectable folders");

			}

			countStr = StringUtils.right("000".concat(countStr), 3);

			// Generate a new file name based on 'basename', the counter and the

			// extension of original name

			newFile = new File(baseFolder, baseName.concat(".")

					.concat(countStr).concat(extension));

			count++;

		}

		return newFile;

	}

	/**

	 * <p>

	 * Return <code>path</code> as relative from <code>basePath</code> only if

	 * <code>basePath</code> is an ancestor of <code>path</code>:

	 * </p>

	 *

	 * @param path

	 * @param basePath

	 * @return

	 * @see FilenameUtils#getRelativeTo(String, String)

	 */

	public static File getRelativeTo(File path, File basePath) {

		String basePathAbs = basePath.getAbsolutePath();

		if (basePath.isDirectory()) {

			basePathAbs = basePathAbs + File.separatorChar;

		}

		return new File(FilenameUtils.getRelativeTo(path.getAbsolutePath(),

				basePathAbs));

	}

	/**

	 * <p>

	 * This class generates a Zip file with the context of a folder. All entries

	 * in generated zip will be relatives to source folder.

	 * </p>

	 *

	 * @author gvSIG Team

	 * @version $Id$

	 *

	 */

	private static class RelativePathFolderZipper extends DirectoryWalker {

		private ZipOutputStream targetZip = null;

		private final File targetFile;

		private final File rootFolder;

		private final String rootFolderPath;

		/**

		 * Prepares compression process

		 *

		 * @param rootFolder

		 *            folder to compress

		 * @param targetFile

		 *            file to generate

		 */

		public RelativePathFolderZipper(File rootFolder, File targetFile) {

			super();

			this.rootFolder = rootFolder;

			this.targetFile = targetFile;

			this.rootFolderPath = rootFolder.getAbsolutePath()

					+ File.separatorChar;

		}

		/**

		 * Execute compression process

		 *

		 * @throws IOException

		 */

		public synchronized void zip() throws IOException {

			try {

				targetZip = new ZipOutputStream(openOutputStream(targetFile));

				walk(rootFolder, null);

			} finally {

				IOUtils.closeQuietly(targetZip);

				targetZip = null;

			}

		}

		/** {@inheridDoc} */

		@Override

		protected void handleFile(File file, int depth,

				@SuppressWarnings("rawtypes") Collection results)

				throws IOException {

			// Get path relative to root

			String relativePath = FilenameUtils.getRelativeTo(

					file.getAbsolutePath(), rootFolderPath);

			if (!UNIXLIKE_FILESYSTEM) {

				// Avoid problems about unzip in Linux when files was generated

				// on a windows

				relativePath = FilenameUtils.separatorsToUnix(relativePath);

			}

			InputStream in = null;

			try {

				if (LOG.isTraceEnabled()) {

					LOG.trace("adding file {} --> {}", file.getAbsolutePath(),

							relativePath);

				}

				targetZip.putNextEntry(new ZipEntry(relativePath));

				in = openInputStream(file);

				IOUtils.copy(in, targetZip);

				targetZip.closeEntry();

			} finally {

				IOUtils.closeQuietly(in);

			}

		}

	}

}

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

package org.gvsig.educa.portableview.impl.util;

/**

 * <p>

 * File name management utilities. Extends the provides by

 * <i>apache-common-IO</i>

 * </p>

 * 

 * @author gvSIG Team

 * @version $Id$

 * 

 */

public abstract class FilenameUtils extends org.apache.commons.io.FilenameUtils {

    /**

     * <p>

     * Return <code>path</code> as relative from <code>basePath</code> only if

     * <code>basePath</code> is an ancestor of <code>path</code>:

     * </p>

     * 

     * <pre>

     * path                     basePath            returns

     * ----------               -------------       ----------

     * /home/user/x.txt         /home/              user/x.txt

     * /home/user/x.txt         /home/user/         x.txt

     * ~/x.txt                  /home/              user/x.t

     * /tmp/x.txt               /home/              /tmp/x.txt

     * C:\foo\bar\xx.txt        C:                  foo\bar\xx.txt

     * C:\foo\bar\xx.txt        C:\foo\            bar\xx.txt

     * C:\foo\bar\xx.txt        C:\foo\bar\         xx.txt

     * </pre>

     * 

     * @param path

     * @param basePath

     * @return

     */

    public static String getRelativeTo(String path, String basePath) {

        if ((basePath.length() == 0) || (path.length() == 0)) {

            return path;

        }

        String absBasePath = getFullPath(basePath);

        String absPath = getFullPath(path);

        String name = getName(path);

        if (equals(absPath, absBasePath)) {

            return name;

        }

        if (absPath.startsWith(absBasePath)) {

            return getWithoutPrefix(concat(

                absPath.substring(absBasePath.length()), name));

        }

        return path;

    }

    /**

     * <p>

     * Return <code>path</code> as relative from <code>basePath</code> only if

     * <code>basePath</code> is an ancestor of <code>path</code>:

     * </p>

     * 

     * <pre>

     * path                     returns

     * ----------               -------------

     * /home/user/x.txt         home/user/x.txt

     * ~/x.txt                  x.txt

     * /tmp/x.txt               tmp/x.txt

     * C:/foo/bar/xx.txt        foo/bar/xx.txt

     * </pre>

     * 

     * @param path

     * @return

     */

    public static String getWithoutPrefix(String path) {

        return path.substring(getPrefixLength(path));

    }

}

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

package org.gvsig.educa.portableview.impl.util;

import java.io.File;

import java.net.MalformedURLException;

import java.net.URI;

import java.net.URISyntaxException;

import java.net.URL;

import java.util.HashSet;

import java.util.Iterator;

import java.util.Map;

import java.util.Set;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistentContext;