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

/* 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.thematicmap.impl.compilation.process;

import java.io.File;

import java.io.IOException;

import java.text.MessageFormat;

import java.util.List;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.educa.thematicmap.compilation.CompilationException;

import org.gvsig.educa.thematicmap.compilation.ThematicMapCompiler;

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

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

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

import org.gvsig.fmap.mapcontext.layers.FLayer;

import org.gvsig.fmap.mapcontext.layers.FLayers;

import org.gvsig.fmap.mapcontext.layers.operations.SingleLayer;

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>

 * {@link ThematicMapCompiler} process step

 * </p>

 * <p>

 * This steps copy all layer data into workFolder. This process is:

 * <ul>

 * <li>Creates root base folder in workFolder</li>

 * <li>Iterates over every layer:

 * <ul>

 * <li>If is a layer's group, create a new folder and iterates over its children

 * </li>

 * <li>If is a layer, identify all files used by layer (data files,Symbology)

 * and do:

 * <ul>

 * <li>Copy file to layer work folder</li>

 * <li>register final location of file in {@link ProcessData#fileMapping}</li>

 * </ul>

 * </li>

 * </ul>

 * </li>

 * </ul>

 * </p>

 * <p>

 * From {@link ProcessData} Uses:

 * <ul>

 * <li>{@link ProcessData#workFolder}</li>

 * <li>{@link ProcessData#mapContext}</li>

 * </ul>

 * and Sets:

 * <ul>

 * <li>{@link ProcessData#fileMapping}</li>

 * <li>{@link ProcessData#mapContextFolder}</li>

 * <li>{@link ProcessData#rootLayersFolder}</li>

 * </ul>

 * </p>

 * 

 * @author gvSIG Team

 * @version $Id$

 * 

 */

public class CopyAllLayersFiles implements ProcessStep {

    private static final String ROOT_LAYERS_FOLDER_PATH_KEY =

        "RootLayersFolderPath";

    private static final String MAP_CONTEXT_FOLDER_PATH_KEY =

        "MapContextFolderPath";

    public static final String ROOT_LAYER_FOLDER_NAME = "layers";

    private final PersistenceManager persitenceMan;

    public CopyAllLayersFiles() {

        persitenceMan = ToolsLocator.getPersistenceManager();

    }

    /** {@inheridDoc} */

    public String getStepDescriptionKey() {

        return "coping_all_layers_files";

    }

    /** {@inheridDoc} */

    public String getStepDescription() {

        return "Coping all layers files";

    }

    @SuppressWarnings("unchecked")

    public void doProcess(ProcessData data, int stepPercent)

        throws CompilationException {

        LayerNamer namer = new LayerNamer();

        File mapContextFolder = new File(data.workFolder, "mapContext");

        mapContextFolder.mkdirs();

        File rootLayersFolder =

            new File(mapContextFolder, ROOT_LAYER_FOLDER_NAME);

        rootLayersFolder.mkdirs();

        data.mapContextFolder = mapContextFolder;

        data.rootLayersFolder = rootLayersFolder;

        data.values.put(MAP_CONTEXT_FOLDER_PATH_KEY,

            mapContextFolder.getAbsolutePath());

        data.values.put(ROOT_LAYERS_FOLDER_PATH_KEY,

            rootLayersFolder.getAbsolutePath());

        saveLayers(data, data.mapContext.getLayers(), mapContextFolder, namer);

    }

    /**

     * <p>

     * Copy all files related to a layer group into work folder

     * </p>

     * <p>

     * This creates a new folder (using layer's name) inside

     * <code>parentFolde</code> and iterates over children layers.

     * </p>

     * 

     * @param data

     *            Process data

     * @param layers

     *            layers to save

     * @param parentFolder

     *            parent folder to store al data

     * @param namer

     *            a layer-namer instance

     * @return

     * @throws CompilationException

     */

    private boolean saveLayers(ProcessData data, FLayers layers,

        File parentFolder, LayerNamer namer) throws CompilationException {

        // Get new folder for layer

        File myFolder = getLayerFolder(parentFolder, layers, namer);

        // Useful to show a layer identification

        String relativePath = getRelativePath(data, myFolder);

        // As this process could take long time, notify progress to listener.

        notifyStatus(data, relativePath);

        // Iterates children layers

        FLayer theLayer;

        for (int i = 0; i < layers.getLayersCount(); i++) {

            theLayer = layers.getLayer(i);

            if (theLayer instanceof SingleLayer) {

                // Layer

                saveLayer(data, (SingleLayer) theLayer, myFolder, namer);

            } else {

                // Group of layers

                saveLayers(data, (FLayers) theLayer, myFolder, namer);

            }

        }

        return true;

    }

    /**

     * Updates process status and notify it to process listener. Utility method.

     * 

     * @param data

     * @param relativePath

     */

    private void notifyStatus(ProcessData data, String relativePath) {

        data.status.setCurrentStepMessage(relativePath);

        data.notifyStatus();

    }

    /**

     * <p>

     * Copy all files related to a layer into work folder

     * </p>

     * <p>

     * This creates a new folder (using layer's name) inside

     * <code>parentFolde</code> and copies all related files.

     * </p>

     * 

     * @param data

     *            Process data

     * @param layers

     *            layers to save

     * @param parentFolder

     *            parent folder to store al data

     * @param namer

     *            a layer-namer instance

     * @return

     * @throws CompilationException

     */

    private void saveLayer(ProcessData data, SingleLayer layer,

        File parentFolder, LayerNamer namer) throws CompilationException {

        // Get new folder for layer

        File myFolder = getLayerFolder(parentFolder, layer, namer);

        // Useful to show a layer identification

        String relativePath = getRelativePath(data, myFolder);

        // As this process could take long time, notify progress to listener.

        notifyStatus(data, relativePath);

        PersistentState layerPerStatus;

        List<File> sourceFiles;

        try {

            // Gets status

            layerPerStatus = persitenceMan.getState(layer);

            // Gets related files

            sourceFiles = PersistenceUtils.getRelatedFiles(layerPerStatus);

        } catch (PersistenceException e) {

            throw new CompilationException(

                "problem getting info from layer: ".concat(relativePath), e);

        }

        File target;

        String targetRelativePath;

        // for every single layer

        for (File source : sourceFiles) {

            // get a new filename to copy file

            target = FileUtils.getNewFileName(myFolder, source.getName());

            // get relative file path to inform to the listener

            targetRelativePath = getRelativePath(data, target);

            notifyStatus(data, targetRelativePath);

            try {

                // Copy the file

                FileUtils.copyFile(source, target);

            } catch (IOException e) {

                throw new CompilationException(

                    MessageFormat.format(

                        "problem copying file related to  layer '{0}': '{1}' --> '{2}'",

                        relativePath, source.getAbsolutePath(),

                        target.getAbsolutePath()), e);

            }

            // Adds a new entry on finals file mapping

            data.fileMapping.put(source, target);

        }

    }

    /**

     * Gets file path relative to layer folder

     * 

     * @param data

     * @param file

     * @return

     */

    private String getRelativePath(ProcessData data, File file) {

        String rootLayerPath =

            (String) data.values.get(ROOT_LAYERS_FOLDER_PATH_KEY);

        String path = file.getAbsolutePath();

        if (FilenameUtils.equals(rootLayerPath, path)) {

            return "{Root Layer}";

        }

        return FilenameUtils.getRelativeTo(path, rootLayerPath);

    }

    /**

     * <p>

     * Generate a layer folder based on its name

     * </p>

     * <p>

     * Avoid problems of duplicate layer name

     * </p>

     * 

     * @param parentFolder

     * @param flayer

     * @param namer

     * @return

     */

    private File getLayerFolder(File parentFolder, FLayer flayer,

        LayerNamer namer) {

        // Uses FileUtils.getNewWritableFolder to avoid

        // duplicate names problem

        return FileUtils.getNewWritableFolder(parentFolder,

            namer.getLayerName(flayer));

    }

    /**

     * Utility class to get a layer name for those layers which hasn't

     * 

     * @author gvSIG Team

     * @version $Id$

     * 

     */

    private class LayerNamer {

        int count = 0;

        public String getLayerName(FLayer flayer) {

            if (flayer.getParentLayer() == null) {

                // root layer

                return ROOT_LAYER_FOLDER_NAME;

            }

            String name = flayer.getName();

            if (!StringUtils.isBlank(name)) {

                // has name

                return name;

            }

            count++;

            return "No_Name_Layer.".concat(StringUtils.right(

                "00".concat(String.valueOf(count)), 3));

        }

    }

}