Application: gvSIG desktop » gvSIG scripting

package org.gvsig.scripting.impl;

import java.io.File;

import java.io.FileFilter;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Properties;

import java.util.Set;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.ArrayUtils;

import org.apache.commons.lang3.BooleanUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.scripting.DataFolderFound;

import org.gvsig.tools.packageutils.Version;

import org.gvsig.scripting.ScriptingFolder;

import org.gvsig.scripting.ScriptingManager;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.packageutils.PackageManager;

import org.gvsig.tools.util.FolderSet;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class DataFolderManager {

    private static final Logger LOGGER = LoggerFactory.getLogger(DataFolderManager.class);

    private static final String DATAFOLDER_FILENAME = "data";

    private class DataFolderRegisterEntry {

        public String folderId;

        public String folderPath;

        public boolean processed;

    }

    private class DataFolderRegister implements Iterable<DataFolderRegisterEntry> {

        private static final String DATAFOLDER_REGISTER_FILENAME = "data.properties";

        private static final String ID_KEY_SUFFIX = ".id";

        private static final String PATH_KEY_SUFFIX = ".path";

        private static final String PROCESSED_KEY_SUFFIX = ".processed";

        private Properties props;

        public DataFolderRegister() {

            File f = FileUtils.getFile(getHomeFolder(), DATAFOLDER_REGISTER_FILENAME);

            this.props = new Properties();

            if (f.exists()) {

                FileInputStream inStream = null;

                try {

                    inStream = new FileInputStream(f);

                    props.load(inStream);

                } catch (Exception ex) {

                } finally {

                    IOUtils.closeQuietly(inStream);

                }

            }

        }

        private String getPathKey(String id) {

            return id + PATH_KEY_SUFFIX;

        }

        private String getProcessedKey(String id) {

            return id + PROCESSED_KEY_SUFFIX;

        }

        private String getIdKey(String id) {

            return id + ID_KEY_SUFFIX;

        }

        private void save() {

            File f = FileUtils.getFile(getHomeFolder(), DATAFOLDER_REGISTER_FILENAME);

            FileOutputStream out = null;

            try {

                out = new FileOutputStream(f);

                this.props.store(out, "");

            } catch (Exception ex) {

            } finally {

                IOUtils.closeQuietly(out);

            }

        }

        public Iterator<DataFolderRegisterEntry> iterator() {

            Set<String> ids = new HashSet<>();

            for (Object key : props.keySet()) {

                if (StringUtils.endsWith((String) key, ID_KEY_SUFFIX)) {

                    ids.add(props.getProperty((String) key));

                }

            }

            final Iterator<String> it = ids.iterator();

            return new Iterator<DataFolderRegisterEntry>() {

                @Override

                public boolean hasNext() {

                    return it.hasNext();

                }

                @Override

                public DataFolderRegisterEntry next() {

                    String id = it.next();

                    return get(id);

                }

            };

        }

        public DataFolderRegisterEntry get(String id) {

            if( !this.props.containsKey(getIdKey(id)) ) {

                return null;

            }

            DataFolderRegisterEntry entry = new DataFolderRegisterEntry();

            entry.folderId = id;

            entry.folderPath = props.getProperty(getPathKey(id));

            entry.processed = BooleanUtils.toBoolean(props.getProperty(getProcessedKey(id)));

            return entry;

        }

        public  void put(DataFolderRegisterEntry entry) {

            this.put( entry.folderId, entry.folderPath,entry.processed);

        }

        public  void put(String id, String path, boolean processed) {

            this.props.setProperty(getIdKey(id), id);

            this.props.setProperty(getPathKey(id), path);

            this.props.setProperty(getProcessedKey(id), 

                    BooleanUtils.toStringTrueFalse(processed));

        }

    }

    private class DefaultDataFolderFound implements DataFolderFound {

        private final String dataFolderId;

        private final ScriptingFolder applicationFolder;

        private final File newDataFolder;

        private final File oldDataFolder;

        private final Version oldDataFolderVersion;

        public DefaultDataFolderFound(

                String dataFolderId,

                ScriptingFolder applicationFolder,

                File newDataFolder,

                File oldDataFolder,

                Version oldDataFolderVersion

        ) {

            this.dataFolderId = dataFolderId;

            this.applicationFolder = applicationFolder;

            this.newDataFolder = newDataFolder;

            this.oldDataFolder = oldDataFolder;

            this.oldDataFolderVersion = oldDataFolderVersion;

        }

        @Override

        public String getDataFolderId() {

            return this.dataFolderId;

        }

        @Override

        public ScriptingFolder getApplicationFolder() {

            return this.applicationFolder;

        }

        @Override

        public String getApplicationName() {

            if( this.applicationFolder==null ) {

                return null;

            }

            return this.applicationFolder.getName();

        }

        @Override

        public File getNewDataFolder() {

            return this.newDataFolder;

        }

        @Override

        public File getOldDataFolder() {

            return this.oldDataFolder;

        }

        @Override

        public Version getOldDataFolderVersion() {

            return this.oldDataFolderVersion;

        }

        @Override

        public void restore() {

            try {

                FileUtils.copyDirectory(this.oldDataFolder, this.newDataFolder);

                DataFolderRegister register = new DataFolderRegister();

                DataFolderRegisterEntry entry = register.get(this.dataFolderId);

                entry.processed = true;

                register.put(entry);

                register.save();

            } catch (IOException ex) {

                throw new RuntimeException("Can't restore data folder found.", ex);

            }

        }

        @Override

        public void leave() {

            DataFolderRegister register = new DataFolderRegister();

            DataFolderRegisterEntry entry = register.get(this.dataFolderId);

            entry.processed = true;

            register.put(entry);

            register.save();

        }

    }

    private final ScriptingManager manager;

    public DataFolderManager(ScriptingManager manager) {

        this.manager = manager;

    }

    private File getHomeFolder() {

        return this.manager.getHomeFolder();

    }

    private void createFolder(File f) {

        if (!f.exists()) {

            try {

                FileUtils.forceMkdir(f);

                LOGGER.info("Created scripting folder '" + f.getAbsolutePath() + "'");

            } catch (Throwable e) {

                LOGGER.warn("Can't Create scripting folder '" + f.getAbsolutePath() + "'");

            }

        }

    }

    public File getDataFolder(String id) {

        File f = FileUtils.getFile(getHomeFolder(), DATAFOLDER_FILENAME, id);

        createFolder(f);

        return f;

    }

    public void registerDataFolder(ScriptingFolder folderScript, String id) {

        DataFolderRegister register = new DataFolderRegister();

        DataFolderRegisterEntry entry = register.get(id); 

        if( entry != null ) {

            return;

        }

        register.put(id, folderScript.getUserPath(), false);

        register.save();

    }

    public List<DataFolderFound> searchOldVersions(Version currentVersion, FolderSet folder) {

        List<DataFolderFound> founds = new ArrayList<>();

        DataFolderRegister register = new DataFolderRegister();

        for (DataFolderRegisterEntry entry :  register) {

            if (!entry.processed) {

                searchOldVersions(founds, currentVersion, folder, entry.folderId, entry.folderPath);

            }

        }

        if (founds.isEmpty()) {

            return null;

        }

        return founds;

    }

    private void searchOldVersions(

            final List<DataFolderFound> founds,

            final Version currentVersion,

            final FolderSet folderSet,

            final String dataFolderId,

            final String dataFolderName

    ) {

        final PackageManager versionFactory = ToolsLocator.getPackageManager();

        File[] folders = folderSet.listFiles(new FileFilter() {

            @Override

            public boolean accept(File pathname) {

                if (!pathname.isDirectory()) {

                    return false;

                }

                try {

                    String name = pathname.getName();

                    // Falla con una excepcion si "name" no es una version valida

                    Version version = versionFactory.createVersion(name);

                    if (currentVersion.compareTo(version) == 0) {

                        return false;

                    }

                    File dataFolder = FileUtils.getFile(pathname, DATAFOLDER_FILENAME, dataFolderId);

                    if (dataFolder.exists() && dataFolder.isDirectory()) {

                        return true;

                    }

                } catch (Exception ex) {

                }

                return false;

            }

        });

        if (ArrayUtils.isEmpty(folders)) {

            return;

        }

        File newDataFolder = FileUtils.getFile(getHomeFolder(), DATAFOLDER_FILENAME, dataFolderId);

        ScriptingFolder applicationFolder = (ScriptingFolder) this.manager.getUnit(dataFolderName);

        if( applicationFolder==null ) {

            return;

        }

        DataFolderFound dataFolderFound = null;

        for (File folder : folders) {

            File oldDataFolder = FileUtils.getFile(folder, DATAFOLDER_FILENAME, dataFolderId);

            Version oldDataFolderVersion = versionFactory.createVersion(

                    FilenameUtils.getBaseName(folder.getName())

            );

            if (dataFolderFound == null

                    || oldDataFolderVersion.compareTo(dataFolderFound.getOldDataFolderVersion()) > 0) {

                dataFolderFound = new DefaultDataFolderFound(

                        dataFolderId,

                        applicationFolder,

                        newDataFolder,

                        oldDataFolder,

                        oldDataFolderVersion

                );

            }

        }

        if (dataFolderFound != null) {

            founds.add(dataFolderFound);

        }

    }

}