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

import java.util.Properties;

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 static org.gvsig.scripting.impl.DefaultScriptingManager.LOG;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.packageutils.PackageManager;

import org.gvsig.tools.util.FolderSet;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class DataFolderManager {

    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() {

            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);

                Properties props = getDataFolderRegister();

                props.setProperty(this.dataFolderId + ".processed", "true");

                saveDataFolderRegistry(props);

            } catch (IOException ex) {

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

            }

        }

        @Override

        public void leave() {

            Properties props = getDataFolderRegister();

            props.setProperty(this.dataFolderId + ".processed", "true");

            saveDataFolderRegistry(props);

        }

    }

    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);

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

            } catch (Throwable e) {

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

            }

        }

    }

    private Properties getDataFolderRegister() {

        File f = FileUtils.getFile(getHomeFolder(), "data.properties");

        Properties props = new Properties();

        if (f.exists()) {

            FileInputStream inStream = null;

            try {

                inStream = new FileInputStream(f);

                props.load(inStream);

            } catch (Exception ex) {

            } finally {

                IOUtils.closeQuietly(inStream);

            }

        }

        return props;

    }

    private void saveDataFolderRegistry(Properties props) {

        File f = FileUtils.getFile(getHomeFolder(), "data.properties");

        FileOutputStream out = null;

        try {

            out = new FileOutputStream(f);

            props.store(out, "");

        } catch (Exception ex) {

        } finally {

            IOUtils.closeQuietly(out);

        }

    }

    public File getDataFolder(String id) {

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

        createFolder(f);

        return f;

    }

    public void registerDataFolder(ScriptingFolder folderScript, String id) {

        String userPath = folderScript.getUserPath();

        Properties props = getDataFolderRegister();

        if ( StringUtils.equals(props.getProperty(id),userPath)) {

            return;

        }

        props.put(id, userPath);

        saveDataFolderRegistry(props);

    }

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

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

        Properties props = getDataFolderRegister();

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

            String dataFolderId = (String) key;

            boolean processed = BooleanUtils.toBoolean(props.getProperty(dataFolderId + ".processed"));

            if (!processed) {

                String dataFolderName = props.getProperty(dataFolderId);

                searchOldVersions(founds, currentVersion, folder, dataFolderId, dataFolderName);

            }

        }

        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 = FilenameUtils.getBaseName(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, "data", dataFolderId);

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

                        return true;

                    }

                } catch(Exception ex) {                    

                }

                return false;

            }

        });

        if( ArrayUtils.isEmpty(folders) ) {

            return;

        }

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

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

        DataFolderFound dataFolderFound = null;

        for (File folder : folders) {

            File oldDataFolder = FileUtils.getFile(folder, "data", 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);

        }

    }

}