Aplicación gvSIG con fines educativos » Interfaz de usuario

/* 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;

import java.io.File;

import java.io.IOException;

import java.text.MessageFormat;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.lang3.ObjectUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.educa.thematicmap.ThematicMapException;

import org.gvsig.educa.thematicmap.ThematicMapManager;

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

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

import org.gvsig.educa.thematicmap.impl.compilation.DefaultThematicMapCompilation;

import org.gvsig.educa.thematicmap.impl.compilation.DefaultThematicMapCompiler;

import org.gvsig.educa.thematicmap.impl.map.DefaultThematicMap;

import org.gvsig.educa.thematicmap.impl.map.ThematicMapLoader;

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

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

import org.gvsig.educa.thematicmap.map.InvalidInstalledThematicMapException;

import org.gvsig.educa.thematicmap.map.InvalidThematicMapFormatException;

import org.gvsig.educa.thematicmap.map.ThematicMap;

import org.gvsig.educa.thematicmap.map.ThematicMapInformation;

import org.gvsig.educa.thematicmap.spi.ThematicMapProviderLocator;

import org.gvsig.i18n.Messages;

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.service.AbstractManager;

import org.gvsig.tools.service.Service;

import org.gvsig.tools.service.ServiceException;

import org.gvsig.tools.service.spi.ProviderManager;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Default {@link ThematicMapManager} implementation.

 * 

 * @author gvSIG Team

 * @version $Id$

 */

public class DefaultThematicMapManager extends AbstractManager implements

                ThematicMapManager {

        /**

         * Extension for Thematic Map files

         */

        public static String THEMATIC_MAP_FILE_EXTENSION = "gvsthm";

        private static final Logger LOG = LoggerFactory

                        .getLogger(DefaultThematicMapManager.class);

        public static final String BASENAME_FORMAT_STRING = "{0}-v{1}-BN{2}";

        public static final String PACKAGE_BASENAME_FORMAT_STRING = "ThematicMap-{0}-{1}-BN{2}";

        /**

         * Manager which manages when deploy/clean maps in temporal folder

         */

        private MapResoucesManager resourceManager;

        private final ThematicMapLoader mapLoader;

        private final InstallerManager installerManager;

        /**

         * Map Instalation's folder

         */

        private String installationFolderInput;

        private File installationFolder;

        private String temporalDelployFolderInput;

        private File temporalDeployMapFolder;

        private final ThematicMapFileFilter thematicMapFileFilter;

        public DefaultThematicMapManager(ProviderManager providerManager) {

                super(providerManager);

                // TODO Auto-generated constructor stub

                // initially, installation folder is null

                installationFolder = null;

                installationFolderInput = null;

                // default temporal folder tmp.dir + '/ThematicMap.tmp'

                temporalDeployMapFolder = FileUtils.getWritableFolder(

                                new File(System.getProperty("java.io.tmpdir")),

                                "ThematicMap.tmp");

                temporalDelployFolderInput = temporalDeployMapFolder.getAbsolutePath();

                // Create file filter to identify map candidate in a folder

                thematicMapFileFilter = new ThematicMapFileFilter(

                                THEMATIC_MAP_FILE_EXTENSION);

                // Create loader instance

                mapLoader = new ThematicMapLoader();

                // Create resource manager instance

                resourceManager = new MapResoucesManager(mapLoader);

                installerManager = InstallerLocator.getInstallerManager();

        }

        public DefaultThematicMapManager() {

//                super(new DefaultInstallerProviderManager());

//                this(ThematicMapProviderLocator.getManager());

                this(null);

        }

//        public DefaultThematicMapManager() {

//

//                // initially, installation folder is null

//                installationFolder = null;

//                installationFolderInput = null;

//

//                // default temporal folder tmp.dir + '/ThematicMap.tmp'

//                temporalDeployMapFolder = FileUtils.getWritableFolder(

//                                new File(System.getProperty("java.io.tmpdir")),

//                                "ThematicMap.tmp");

//                temporalDelployFolderInput = temporalDeployMapFolder.getAbsolutePath();

//

//                // Create file filter to identify map candidate in a folder

//                thematicMapFileFilter = new ThematicMapFileFilter(

//                                THEMATIC_MAP_FILE_EXTENSION);

//

//                // Create loader instance

//                mapLoader = new ThematicMapLoader();

//

//                // Create resource manager instance

//                resourceManager = new MapResoucesManager(mapLoader);

//

//                installerManager = InstallerLocator.getInstallerManager();

//        }

        /** {@inheridDoc} */

        public String getInstallationMapFolder() {

                return installationFolderInput;

        }

        /**

         * Checks if <code>folder</code> is a folder an is readable

         * 

         * @param folder

         * @return file representation of folder

         * @throws IllegalArgumentException

         */

        private File checkValidReadableFolder(String folder) {

                File fileObject = new File(folder);

                if (!FileUtils.isReadableFolder(fileObject)) {

                        throw new IllegalArgumentException("Invalid folder");

                }

                return fileObject;

        }

        /**

         * Checks if <code>folder</code> is a folder and is writable

         * 

         * @param folder

         * @return file representation of folder

         * @throws IllegalArgumentException

         */

        private File checkValidWritableFolder(String folder) {

                File fileObject = new File(folder);

                if (!FileUtils.isWritableFolder(fileObject)) {

                        throw new IllegalArgumentException("Invalid folder");

                }

                return fileObject;

        }

        /** {@inheridDoc} */

        public void setInstallationMapFolder(String folder) {

                installationFolder = checkValidReadableFolder(folder);

                installationFolderInput = folder;

        }

        /** {@inheridDoc} */

        public String getTemporalFolder() {

                return temporalDelployFolderInput;

        }

        /** {@inheridDoc} */

        public void setTemporalFolder(String folder) {

                if (FilenameUtils.equals(temporalDelployFolderInput, folder)) {

                        return;

                }

                temporalDeployMapFolder = checkValidWritableFolder(folder);

                temporalDelployFolderInput = folder;

                resourceManager.cleanAllResources();

        }

        /** {@inheridDoc} */

        public List<ThematicMap> getInstalledMaps() {

                return getMapsFromFolder(installationFolder);

        }

        /** {@inheridDoc} */

        public List<ThematicMap> getInstalledMaps(String folder) {

                File fileObject = checkValidReadableFolder(folder);

                return getMapsFromFolder(fileObject);

        }

        /**

         * <p>

         * Gets all maps from a folder

         * </p>

         * <p>

         * List all files which matches with filter and try to load it information.

         * If a file load throws an Invalid format found ignores this file.

         * </p>

         * 

         * @param folder

         * @return

         */

        private List<ThematicMap> getMapsFromFolder(File folder) {

                File[] files = folder.listFiles();

                List<ThematicMap> result = new ArrayList<ThematicMap>(files.length);

                ThematicMap map;

                for (File file : files) {

                        try {

                                map = getThematicMapIntalledFolder(file);

                        } catch (ThematicMapException ex) {

                                // Ignore this folder

                                if (LOG.isDebugEnabled()) {

                                        LOG.debug(

                                                        "Folder exception reading map from it (not a map): {}"

                                                                        .concat(file.getAbsolutePath()), ex);

                                }

                                continue;

                        }

                        result.add(map);

                }

                resourceManager.adjustResourceSize();

                return Collections.unmodifiableList(result);

        }

        /** {@inheridDoc} */

        public ThematicMap getMapFromFile(File file)

                        throws InvalidThematicMapFormatException {

                if (!thematicMapFileFilter.accept(file)) {

                        throw new InvalidThematicMapFormatException(file,

                                        "Bad file extension (".concat(

                                                        thematicMapFileFilter.getFileNameEnding()).concat(

                                                        ")"));

                }

                ThematicMapInformation info = resourceManager.getInfoOfFile(file);

                if (info == null) {

                        try {

                                info = mapLoader.getInformationFromMapFile(file);

                        } catch (Exception e) {

                                throw new InvalidThematicMapFormatException(file,

                                                "Can't load information file", e);

                        }

                }

                return createThematicMap(file, info);

        }

        public ThematicMap getMapById(String mapId) {

                List<ThematicMap> installedMaps = getInstalledMaps();

                for (ThematicMap map : installedMaps) {

                        if (ObjectUtils.equals(map.getInformation().getId(), mapId)) {

                                return map;

                        }

                }

                return null;

        }

        private ThematicMap createThematicMap(File file, ThematicMapInformation info) {

                return new DefaultThematicMap(file, info, resourceManager);

        }

        /** {@inheridDoc} */

        public boolean isMap(File file) {

                if (LOG.isDebugEnabled()) {

                        LOG.debug("Checking is map : {}", file.getAbsolutePath());

                }

                if (!thematicMapFileFilter.accept(file)) {

                        return false;

                }

                try {

                        return mapLoader.getInformationFromMapFile(file) != null;

                } catch (Exception e) {

                        LOG.debug("file is not a mapFile:", e);

                        return false;

                }

        }

        /** {@inheridDoc} */

        public ThematicMapCompilation createCompilationInstance() {

                return new DefaultThematicMapCompilation(this);

        }

        /** {@inheridDoc} */

        public ThematicMapCompiler createCompilerInstance() {

                return new DefaultThematicMapCompiler(THEMATIC_MAP_FILE_EXTENSION);

        }

        /** {@inheridDoc} */

        public void dispose() {

                resourceManager.dispose();

                resourceManager = null;

                ToolsLocator.getDisposableManager().release(this);

        }

        /** {@inheridDoc} */

        public void cleanAllTemporalData() {

                resourceManager.cleanAllResources();

        }

        /** {@inheridDoc} */

        public ThematicMapCompilation createCompilationInstanceFromMap(

                        ThematicMap map) throws InvalidThematicMapFormatException,

                        CantLoadContextException, IOException {

                if (!map.isOpen()) {

                        map.open();

                }

                return new DefaultThematicMapCompilation(map, this);

        }

        /**

         * Gets a ThematicMap from a installed maps

         * 

         * @param folder

         * @return

         * @throws InvalidInstalledThematicMapException

         */

        public ThematicMap getThematicMapIntalledFolder(File folder)

                        throws ThematicMapException {

                // Only readable folder

                if (!FileUtils.isReadableFolder(folder)) {

                        throw new InvalidInstalledThematicMapException(folder,

                                        "not a readable folder");

                }

                String code = folder.getName();

                // Load package info

                PackageInfo packageInfo = mapLoader

                                .getPackageInfoFromInstalledThematicMap(folder);

                if (packageInfo == null) {

                        throw new InvalidInstalledThematicMapException(folder,

                                        "missing package.info file");

                }

                if (!StringUtils.equals(code, packageInfo.getCode())) {

                        throw new InvalidInstalledThematicMapException(folder,

                                        "folder name doesn't match with package.info code");

                }

                if (!StringUtils.equals("ThematicMap", packageInfo.getType())) {

                        throw new InvalidInstalledThematicMapException(folder,

                                        "package.info type is not 'ThematicMap': "

                                                        .concat(packageInfo.getType()));

                }

                // Gets the thematic map file

                ThematicMap map;

                String mapFileName = getBaseFileNameFromInfo(packageInfo.getCode(),

                                packageInfo.getName(), packageInfo.getVersion().getMayor(),

                                packageInfo.getVersion().getBuild()).concat(

                                thematicMapFileFilter.getFileNameEnding());

                File mapFile = new File(folder, mapFileName);

                if (!mapFile.exists()) {

                        throw new InvalidInstalledThematicMapException(folder, "missing '"

                                        .concat(mapFileName).concat("' file"));

                }

                map = getMapFromFile(mapFile);

                if (map == null) {

                        // This must be unreachable code

                        throw new IllegalStateException();

                }

                ThematicMapInformation info = map.getInformation();

                // Compares pkgInfo.code and thmInfo.id

                if (!StringUtils.equals(packageInfo.getCode(), info.getId())) {

                        throw new InvalidInstalledThematicMapException(folder,

                                        "package.info code doesn't match with ThematicMap.id");

                }

                // Compares pkgInfo.version and thmInfo.version

                if (packageInfo.getVersion().getMayor() != info.getVersion()) {

                        throw new InvalidInstalledThematicMapException(folder,

                                        "package.info version doesn't match with ThematicMap.version");

                }

                // Compares pkgInfo.buildNumber and thmInfo.buildNumber

                if (packageInfo.getVersion().getBuild() != info.getBuildNumber()) {

                        throw new InvalidInstalledThematicMapException(folder,

                                        "package.info build doesn't match with ThematicMap.buildNumber");

                }

                return map;

        }

        /** {@inheridDoc} */

        public boolean isAThematicMapIntalledFolder(File folder) {

                if (!FileUtils.isReadableFolder(folder)) {

                        return false;

                }

                ThematicMap map;

                try {

                        map = getThematicMapIntalledFolder(folder);

                } catch (Exception ex) {

                        return false;

                }

                return map != null;

        }

        /** {@inheridDoc} */

        public String getBaseFileNameFromInfo(ThematicMapInformation info) {

                return getBaseFileNameFromInfo(info.getId(), info.getName(),

                                info.getVersion(), info.getBuildNumber());

        }

        /** {@inheridDoc} */

        public String getBaseFileNameFromInfo(String id, String name, int version,

                        int buildNumber) {

                return MessageFormat.format(BASENAME_FORMAT_STRING, id, version,

                                buildNumber);

        }

        /** {@inheridDoc} */

        public File generatePackageFile(String mapId, File targetFolder)

                        throws ThematicMapException, IOException {

                ThematicMap map = getMapById(mapId);

                if (map == null) {

                        throw new IllegalArgumentException("Thematic Map not foudn: '"

                                        .concat(mapId).concat("'"));

                }

                File mapFolder = new File(installationFolder, mapId);

                return generatePackageFile(mapFolder, targetFolder);

        }

        /** {@inheridDoc} */

        public File generatePackageFile(File thematicMapIntallFolder,

                        File targetFolder) throws ThematicMapException, IOException {

                // Checks if it's a map folder

                ThematicMap map = null;

                try {

                        map = getThematicMapIntalledFolder(thematicMapIntallFolder);

                } catch (Exception ex) {

                        throw new IllegalArgumentException("Source is not a map folder: '"

                                        .concat(thematicMapIntallFolder.getAbsolutePath()).concat(

                                                        "'"));

                }

                if (map == null) {

                        throw new IllegalArgumentException("Source is not a map folder: '"

                                        .concat(thematicMapIntallFolder.getAbsolutePath()).concat(

                                                        "'"));

                }

                // Check target folder

                if (!FileUtils.isWritableFolder(targetFolder)) {

                        throw new IllegalArgumentException(

                                        "Target is not a writable folder: '".concat(

                                                        targetFolder.getAbsolutePath()).concat("'"));

                }

                // Prepare target file name

                ThematicMapInformation info = map.getInformation();

                String pkgFileName = MessageFormat

                                .format(PACKAGE_BASENAME_FORMAT_STRING, info.getId(),

                                                info.getVersion(), info.getBuildNumber()).concat(".")

                                .concat(installerManager.getDefaultPackageFileExtension());

                File targetFile = new File(targetFolder, pkgFileName);

                // Prepare temporal folder

                File workFolder = FileUtils.getNewWritableFolder(

                                temporalDeployMapFolder, "__tmp__".concat(pkgFileName));

                File tempFolder = new File(workFolder, info.getId());

                // Copy all content of map folder

                FileUtils.copyDirectory(thematicMapIntallFolder, tempFolder, true);

                // Remove unused thematicMap files

                String mapFileName = FilenameUtils.getName(map.getSourceFilePath());

                File[] tmFiles = tempFolder.listFiles(thematicMapFileFilter);

                for (File thFile : tmFiles) {

                        if (!StringUtils.equals(thFile.getName(), mapFileName)) {

                                thFile.delete();

                        }

                }

                // Zip file

                FileUtils.zipFolder(workFolder, targetFile);

                return targetFile;

        }

        public String getTranslation(String key) {

                // TODO: add I18nManager usage when org.gvsig.tools.lib 2.1.0 becomes

                // available

                // return this.i18nmanager.getTranslation(key);

                return Messages.getText(key);

        }

        public Service getService(DynObject parameters) throws ServiceException {

                // return thematic map compilation (ThematicMapService)

                // supose que he d'agafar un identificador de parameters del mapa que busque

                // despres, buscar-lo i passar-lo a DefaultThematicMapCompilation i

                // tornar la compilacio.

                ThematicMap map = null;

                List<ThematicMap> mapsList = getInstalledMaps();

                // TODO: Get the thematicmap that has the given parameters

                DefaultThematicMapCompilation serviceCompilation = new DefaultThematicMapCompilation(

                                map, this);

                return serviceCompilation;

        }

        public ThematicMapCompilation createCompilationInstance(String gameName)

                        throws ServiceException {

                DynObject params = createServiceParameters(gameName);

//                DefaultThematicMapCompilation compilation = new DefaultThematicMapCompilation(this);

//                compilation.

                // Instanciar thematicmapcompilation i assignar-li params

                return null;

        }

}