Application: gvSIG desktop » gvSIG scripting

/* 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.scripting.app.extension;

import java.io.File;

import java.io.IOException;

import java.nio.file.FileVisitOption;

import static java.nio.file.FileVisitOption.FOLLOW_LINKS;

import java.nio.file.FileVisitResult;

import java.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.nio.file.SimpleFileVisitor;

import java.nio.file.attribute.BasicFileAttributes;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.EnumSet;

import java.util.List;

import javax.swing.JOptionPane;

import org.apache.commons.io.FileUtils;

import org.gvsig.andami.IconThemeHelper;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.PluginsLocator;

import org.gvsig.andami.PluginsManager;

import org.gvsig.andami.plugins.Extension;

import org.gvsig.app.ApplicationLocator;

import org.gvsig.app.ApplicationManager;

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

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

import org.gvsig.scripting.ScriptingBaseScript;

import org.gvsig.scripting.ScriptingFolder;

import org.gvsig.scripting.ScriptingLocator;

import org.gvsig.scripting.ScriptingManager;

import org.gvsig.scripting.swing.api.JScriptingComposer;

import org.gvsig.scripting.swing.api.ScriptingSwingLocator;

import org.gvsig.scripting.swing.api.ScriptingUIManager;

import org.gvsig.tools.dynobject.DynObject;

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

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

import org.gvsig.tools.swing.api.ToolsSwingLocator;

import org.gvsig.tools.swing.api.windowmanager.WindowManager;

import org.gvsig.tools.swing.impl.windowmanager.DefaultWindowManager;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.installer.lib.spi.InstallerProviderLocator;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

public class ScriptingExtension extends Extension {

    private static final Logger logger = LoggerFactory.getLogger(ScriptingExtension.class);

    private PluginServices plugin = null;

    /*

     * la funcion log y las constantes estan pensadas para usarlas desde los scripts.

    */

    public static final int INFO = 0;

    public static final int TRACE = 1;

    public static final int WARN = 2;

    public static final int ERROR = 3;

    public static void log(String message) {

        log(INFO,message,null);

    }

    public static void log(int level, String message) {

        log(level,message,null);

    }

    public static void log(int level, String message, Throwable th) {

        switch(level) {

            case TRACE:

                logger.trace(message, th);

                break;

            case ERROR:

                logger.error(message, th);

                break;

            case WARN:

                logger.warn(message, th);

                break;

            default:

            case INFO:

                logger.info(message, th);

                break;

        }

    }

    @Override

    public  PluginServices getPlugin() {

        if( this.plugin == null ) {

            this.plugin = PluginsLocator.getManager().getPlugin(ScriptingExtension.class);

        }

        return this.plugin;

    }

    @Override

    public void execute(String actionCommand) {

        this.execute(actionCommand, null);

    }

    @Override

    public void execute(String command, Object[] args) {

        ScriptingUIManager uimanager = ScriptingSwingLocator.getUIManager();

        WindowManager winmanager = ToolsSwingLocator.getWindowManager();

        if ("tools-scripting-launcher".equalsIgnoreCase(command)) {

            winmanager.showWindow(uimanager.createLauncher().asJComponent(), uimanager.getTranslation("Scripting_Launcher"), WindowManager.MODE.TOOL);

        } else if ("tools-scripting-composer".equalsIgnoreCase(command)) {

            DynObject preferences = this.getPlugin().getPluginProperties();

            Boolean composerUseHisWindowManager = (Boolean) preferences.getDynValue("ComposerUseHisWindowManager");

            ScriptingUIManager uiManager = ScriptingSwingLocator.getUIManager();

            if (composerUseHisWindowManager) {

                winmanager = new DefaultWindowManager();

                uiManager.setWindowManager(winmanager);

            }

            JScriptingComposer composer = uimanager.createComposer();

            uiManager.showWindow(composer.asJComponent(), uimanager.getTranslation("Scripting_Composer"));

        } else {

            ScriptingBaseScript script = uimanager.getManager().getScript(command);

            if (script != null) {

                script.run(args);

            } else {

                ApplicationManager application = ApplicationLocator.getManager();

                application.messageDialog("Can't locate script '" + command + "'.", "ScriptLaunch", JOptionPane.OK_OPTION);

            }

        }

    }

    public void initialize() {

        IconThemeHelper.registerIcon("action", "tools-scripting-launcher", this);

        IconThemeHelper.registerIcon("action", "tools-scripting-composer", this);

        IconThemeHelper.registerIcon("action", "tools-scripting-console-jython", this);

    }

    private void addLinkToPreviousVersion(ScriptingManager manager) {

        String contents = "[Unit]\n"

                + "type = Folder\n"

                + "name = Previous version\n"

                + "description =\n"

                + "createdBy =\n"

                + "version =\n"

                + "\n"

                + "[Folder]\n"

                + "path = ../../org.gvsig.scripting.app.extension/scripts\n\n\n";

        File previousVersion = new File(manager.getUserFolder().getFile(), "previous_version.inf");

        if (!previousVersion.exists()) {

            try {

                FileUtils.writeStringToFile(previousVersion, contents);

            } catch (IOException ex) {

                logger.warn("Can't create ScriptingFolder file in '" + previousVersion.getAbsolutePath() + "'.", ex);

            }

        }

    }

    @Override

    public void postInitialize() {

        super.postInitialize();

        ScriptingManager manager = ScriptingLocator.getManager();

        PluginsManager pluginManager = PluginsLocator.getManager();

        File home = this.getPlugin().getPluginHomeFolder();

        manager.setHomeFolder(home);

        this.addLinkToPreviousVersion(manager);

        List<File> pluginsFolders = new ArrayList<>();

        for (File f : pluginManager.getPluginsFolders()) {

            pluginsFolders.addAll(Arrays.asList(f.listFiles()));

        }

        for (File pluginFolder : pluginsFolders) {

            File scriptsFolder = new File(pluginFolder, "scripting/scripts");

            if (scriptsFolder.exists()) {

                manager.registerSystemFolder(pluginFolder.getName(), scriptsFolder);

            }

            File libFolder = new File(pluginFolder, "scripting/lib");

            if (libFolder.exists()) {

                manager.addLibFolder(libFolder);

            }

        }

        pluginManager.addStartupTask(

                "ExecuteAutorunScripts",

                new ExecuteAutorunScriptsOnStartup(),

                true,

                600

        );

        manager.setPackagesFolder(pluginManager.getInstallFolder());

        File localAddonRepositoryFolder = new File(manager.getRootUserFolder(), "addons");

        if (!localAddonRepositoryFolder.exists()) {

            try {

                FileUtils.forceMkdir(localAddonRepositoryFolder);

            } catch (IOException ex) {

                logger.info("Can't create addons folder in '" + localAddonRepositoryFolder.getAbsolutePath() + "'.", ex);

            }

        }

        ProviderManager providerManager = InstallerProviderLocator.getProviderManager();

        InstallerManager installerManager = InstallerLocator.getInstallerManager();

        ProviderFactory factory = manager.getInstallerFactory();

        providerManager.addProviderFactory(factory);

        installerManager.setDefaultLocalAddonRepository(

                localAddonRepositoryFolder,

                factory.getName()

        );

        factory = manager.getHelpInstallerFactory();

        providerManager.addProviderFactory(factory);

        installerManager.setDefaultLocalAddonRepository(

                manager.getHelpManager().getHelpRoots().get(0),

                factory.getName()

        );

    }

    @Override

    public boolean isEnabled() {

        return true;

    }

    @Override

    public boolean isVisible() {

        return true;

    }

    private static class ExecuteAutorunScriptsOnStartup implements Runnable {

        @Override

        public void run() {

            Thread th = new Thread(new ExecuteAutorunScripts());

            th.start();

        }

    }

    private static class ExecuteAutorunScripts implements Runnable {

        @Override

        public void run() {

            final ScriptingManager manager = ScriptingLocator.getManager();

            manager.loadEngines();

            final PluginsManager pluginManager = PluginsLocator.getManager();

            final ApplicationManager application = ApplicationLocator.getManager();

            final I18nManager i18nManager = ToolsLocator.getI18nManager();

//            try {

//                ScriptingHelpManager helpmanager = manager.getHelpManager();

//                PluginServices plugin = pluginManager.getPlugin(this);

//                File scriptingfolder = new File(plugin.getPluginDirectory(), "scripting");

//                File helpfolder = new File(scriptingfolder, "help");

//                for (File folder : helpfolder.listFiles()) {

//                    File helpindex = new File(folder, "help-index.xml");

//                    try {

//                        if( helpindex.exists() ) {

//                            helpmanager.addMethods(helpindex.toURI().toURL());

//                        }

//                    } catch (Exception e) {

//                        logger.info("Can't add metothods from '" + helpindex.getAbsolutePath() + "'.", e);

//                    }

//                }

//            } catch (Exception e) {

//                logger.info("Can't add metothods.", e);

//            }

            try {

                List<File> pluginsFolders = new ArrayList<>();

                for (File f : pluginManager.getPluginsFolders()) {

                    pluginsFolders.addAll(Arrays.asList(f.listFiles()));

                }

                File autorun_file = null;

                ScriptingBaseScript autorun;

                application.message(

                        i18nManager.getTranslation("_Searching_autorun_scripts_Xhorizontal_ellipsisX"),

                        JOptionPane.INFORMATION_MESSAGE

                );

                for (File pluginFolder : pluginsFolders) {

                    autorun_file = new File(pluginFolder, "scripting/scripts/autorun.inf");

                    if (autorun_file.exists()) {

                        autorun = manager.getScript(autorun_file);

                        if (autorun.isEnabled()) {

                            logger.info("running autorun script '" + autorun_file.getAbsolutePath() + "'.");

                            try {

                                application.message(

                                        i18nManager.getTranslation(

                                                "_Running_autorun_script_from_XnameX",

                                                new String[]{autorun.getFile().getParentFile().getName()}

                                        ),

                                        JOptionPane.INFORMATION_MESSAGE

                                );

                            } catch (Exception ex) {

                                // Ignore it

                            }

                            try {

                                autorun.run();

                            } catch (Exception ex) {

                                logger.warn("Can't execute autorun from '" + autorun_file.getAbsolutePath() + "'.", ex);

                            }

                        } else {

                            logger.info("Skip autorun script '" + autorun_file.getAbsolutePath() + "'.");

                        }

                    }

                }

                SimpleFileVisitor<Path> visitor = new SimpleFileVisitor<Path>() {

                    @Override

                    public FileVisitResult visitFile(Path path, BasicFileAttributes bfa) throws IOException {

                        File file = path.toFile();

                        if ("autorun.inf".equalsIgnoreCase(file.getName())) {

                            if (file.exists()) {

                                ScriptingBaseScript autorun = manager.getScript(file);

                                if( autorun.isEnabled() ) {

                                    logger.info("running autorun script '" + file.getAbsolutePath() + "'.");

                                    try {

                                        application.message(

                                                i18nManager.getTranslation(

                                                        "_Running_autorun_script_from_XnameX",

                                                        new String[]{autorun.getFile().getParentFile().getName()}

                                                ),

                                                JOptionPane.INFORMATION_MESSAGE

                                        );

                                    } catch (Exception ex) {

                                        // Ignore

                                    }

                                    try {

                                        autorun.run();

                                    } catch (Exception ex) {

                                        logger.warn("Can't execute autorun from '" + file.getAbsolutePath() + "'.", ex);

                                    }

                                } else {

                                    logger.info("Skip autorun script '" + file.getAbsolutePath() + "'.");

                                }

                            }

                        }

                        return FileVisitResult.CONTINUE;

                    }

                };

                try {

                    EnumSet<FileVisitOption> opts = EnumSet.of(FOLLOW_LINKS);

                    Files.walkFileTree(Paths.get(manager.getRootUserFolder().toURI()), opts, Integer.MAX_VALUE, visitor);

                    List<ScriptingFolder> folders = manager.getAlternativeUserFolders();

                    for (ScriptingFolder folder : folders) {

                        Files.walkFileTree(Paths.get(folder.getFile().toURI()), opts, Integer.MAX_VALUE, visitor);

                    }

                } catch (Exception ex) {

                    logger.warn("Can't execute autoruns in home.", ex);

                }

            } finally {

                logger.info("Running autorun scripts terminated.");

                application.message("", JOptionPane.INFORMATION_MESSAGE);

            }

        }

    }

}