Application: gvSIG desktop » gvSIG desktop customize

package org.gvsig.customize;

import java.io.File;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Date;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Locale;

import java.util.Set;

import java.util.logging.Level;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import javax.swing.JComponent;

import javax.swing.JOptionPane;

import javax.swing.SwingUtilities;

import org.apache.commons.io.FileUtils;

import org.apache.commons.lang.BooleanUtils;

import org.apache.commons.lang3.LocaleUtils;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.IProjection;

import org.gvsig.andami.LocaleManager;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.PluginsLocator;

import org.gvsig.andami.PluginsManager;

import org.gvsig.andami.actioninfo.ActionInfo;

import org.gvsig.andami.actioninfo.ActionInfoManager;

import org.gvsig.andami.firewall.FirewallConfiguration;

import org.gvsig.andami.persistence.serverData.ServerDataPersistence;

import org.gvsig.andami.ui.mdiFrame.MainFrame;

import org.gvsig.app.ApplicationLocator;

import org.gvsig.app.ApplicationManager;

import org.gvsig.app.project.ProjectManager;

import org.gvsig.app.project.ProjectPreferences;

import org.gvsig.app.project.documents.view.ViewManager;

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

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

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

import org.gvsig.installer.lib.api.execution.InstallPackageService;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.observer.ObservableHelper;

import org.gvsig.tools.packageutils.PackageManager;

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

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

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.task.impl.BaseTaskStatus;

import org.gvsig.utils.swing.jcomboServer.ServerData;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class CustomizeTask implements Runnable {

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

    private static final String PROXY_SECTION = "httpproxy";

    private static final String CRS_SECTION = "crs";

    private static final String THEME_SECTION = "theme";

    private int errorCount = 0;

    private DynObject pluginProperties = null;

    private Class scriptingExtension = null;

    private PluginServices plugin = null;

    public CustomizeTask() {

    }

    private void showWindow(final JComponent component, final String title, final WindowManager.MODE mode) {

        if (!SwingUtilities.isEventDispatchThread()) {

            SwingUtilities.invokeLater(new Runnable() {

                @Override

                public void run() {

                    showWindow(component, title, mode);

                }

            });

            try {

                Thread.sleep(10);

            } catch (InterruptedException ex) {

                // Do nothing

            }

            return;

        }

        ToolsSwingLocator.getWindowManager().showWindow(

                component,

                title,

                mode

        );

    }

    private static class MyServerData {

        private final ServerDataPersistence serversDataPersistence;

        public MyServerData(ServerDataPersistence serversDataPersistence) {

            this.serversDataPersistence = serversDataPersistence;

        }

        public List<ServerData> getServerData() {

            return this.serversDataPersistence.getServerData();

        }

        public void remove(String serverAddress) {

            if (StringUtils.isBlank(serverAddress)) {

                return;

            }

            Iterator<ServerData> it = getServerData().iterator();

            while (it.hasNext()) {

                ServerData x = it.next();

                if (serverAddress.equalsIgnoreCase(x.getServerAddress())) {

                    it.remove();

                    return;

                }

            }

        }

        public void add(String server, String protocol) {

            if (StringUtils.isBlank(server)) {

                return;

            }

            this.add(new ServerData(server, protocol));

        }

        public void add(ServerData server) {

            String address = server.getServerAddress().trim();

            for (int i = 0; i < getServerData().size(); i++) {

                ServerData sd = getServerData().get(i);

                if (sd.getServerAddress().trim().equals(address)) {

                    getServerData().set(i, server);

                    return;

                }

            }

            getServerData().add(server);

        }

        public boolean contains(String serverAddress) {

            if (StringUtils.isBlank(serverAddress)) {

                return false;

            }

            serverAddress = serverAddress.trim();

            for (int i = 0; i < getServerData().size(); i++) {

                String address = getServerData().get(i).getServerAddress().trim();

                if (serverAddress.equalsIgnoreCase(address)) {

                    return true;

                }

            }

            return false;

        }

    }

    private PluginServices getPlugin() {

        if (this.plugin == null) {

            PluginsManager pluginsManager = PluginsLocator.getManager();

            this.plugin = pluginsManager.getPlugin(this);

        }

        return this.plugin;

    }

    protected PluginServices getPlugin(String name) {

        PluginsManager pluginsManager = PluginsLocator.getManager();

        return pluginsManager.getPlugin(name);

    }

    private Class getScriptingExtension() {

        if (this.scriptingExtension == null) {

            try {

                this.scriptingExtension = Class.forName("org.gvsig.scripting.app.extension.ScriptingExtension");

            } catch (Throwable ex) {

                return null;

            }

        }

        return this.scriptingExtension;

    }

    protected void errors_add(String message, Throwable th) {

        errorCount++;

        logger.warn(message, th);

    }

    protected int errors_count() {

        return errorCount;

    }

    protected void errors_reset() {

        this.errorCount = 0;

    }

    protected DynObject getPluginProperties() {

        if (this.pluginProperties == null) {

            this.pluginProperties = this.getPlugin().getPluginProperties();

        }

        return this.pluginProperties;

    }

    protected void setProperty(String name, Object value) {

        this.getPluginProperties().setDynValue(name, value);

    }

    protected Object getProperty(String name) {

        return this.getPluginProperties().getDynValue(name);

    }

    protected String getPropertyString(String name) {

        return (String) this.getProperty(name);

    }

    protected int getPropertyInt(String name) {

        return ((Integer) this.getProperty(name)).intValue();

    }

    protected boolean getPropertyBoolean(String name) {

        return ((Boolean) this.getProperty(name)).booleanValue();

    }

    protected void setValue(DynObject config, String section, String option, String value) {

        Object subconfig = config.getDynValue(section);

        if (subconfig instanceof DynObject) {

            ((DynObject) subconfig).setDynValue(option, value);

        } else {

            config.setDynValue(option, value);

        }

    }

    protected String getValue(DynObject config, String section, String option, String defaultValue) {

        String value = null;

        Object subconfig = null;

        if (!StringUtils.isBlank(section)) {

            subconfig = config.getDynValue(section);

        }

        if (subconfig instanceof DynObject) {

            Object v = ((DynObject) subconfig).getDynValue(option);

            if (v != null) {

                value = v.toString();

            }

        } else {

            Object v = config.getDynValue(option);

            if (v != null) {

                value = v.toString();

            }

        }

        if (StringUtils.isBlank(value)) {

            return defaultValue;

        }

        if (THEME_SECTION.equalsIgnoreCase(section)) {

            return value;

        }

        if (value.contains("${")) {

            value = expand(config, section, value);

        }

        return value;

    }

    private static final Pattern VARIABLE = Pattern.compile("[$][{]([a-zA-Z0-9_/]+)[}]");

    private String expand(DynObject config, String section, String s) {

        String s2 = s;

        String v = null;

        Matcher m = VARIABLE.matcher(s);

        while (m.find()) {

            String name = m.group(1);

            String[] ss = name.split("/");

            switch (ss.length) {

                case 2:

                    v = getValue(config, ss[0], ss[1], "");

                    break;

                case 1:

                    v = getValue(config, section, ss[0], "");

                    break;

                default:

                    v = name;

            }

            s2 = m.replaceFirst(v);

            m = VARIABLE.matcher(s2);

        }

        return s2;

    }

    private void configureLocale(DynObject config) {

        if (!BooleanUtils.isTrue((Boolean) getProperty("configureLocale"))) {

            return;

        }

        try {

            LocaleManager localeManager = PluginsLocator.getLocaleManager();

            String localeCode = getValue(config, null, "default_locale", "en");

            Locale locale = LocaleUtils.toLocale(localeCode);

            localeManager.setCurrentLocale(locale);

            logger.info("Set default locale to '" + localeCode + "'.");

            setProperty("configureLocale", Boolean.FALSE);

        } catch (Exception ex) {

            errors_add("Can't apply locale configuration.", ex);

        }

    }

    private void configureHttpproxy(DynObject config) {

        if (!BooleanUtils.isTrue((Boolean) getProperty("configureHTTPPproxy"))) {

            return;

        }

        try {

            FirewallConfiguration conf = getFirewallConfiguration();

            String host = getValue(config, "httpproxy", "host", "");

            String port = getValue(config, "httpproxy", "port", "");

            String nonProxyHosts = getValue(config, "httpproxy", "nonProxyHosts", "");

            String userName = getValue(config, "httpproxy", "username", "");

            String password = getValue(config, "httpproxy", "password", "");

            String enabled = getValue(config, "httpproxy", "enabled", "false");

            conf.setHost(host, port);

            conf.setNonProxyHosts(nonProxyHosts);

            if (!StringUtils.isBlank(userName)) {

                conf.setUserName(userName);

            }

            if (!StringUtils.isBlank(password)) {

                conf.setPassword(password);

            }

            conf.setEnabled(BooleanUtils.toBoolean(enabled));

            conf.apply();

            logger.info("Set httpproxy host:port to '" + host + ":" + port + "', enabled " + BooleanUtils.toBoolean(enabled) + ".");

            setProperty("configureHTTPPproxy", Boolean.FALSE);

        } catch (Exception ex) {

            errors_add("Can't apply proxy configuration.", ex);

        }

    }

    private FirewallConfiguration getFirewallConfiguration() {

        FirewallConfiguration conf = (FirewallConfiguration) ToolsLocator.getInstance().get(ToolsLocator.FIREWALL_MANAGER_NAME);

//        FirewallConfiguration conf = PluginsLocator.getManager().getFirewallConfiguration();

        return conf;

    }

    private boolean configureHttpproxyUser(DynObject config) {

        try {

            FirewallConfiguration conf = getFirewallConfiguration();

            String userName = conf.getUserName();

            String password = conf.getPassword();

            HttpProxyLoginDialog dialog = new HttpProxyLoginDialog();

            if (StringUtils.isBlank(userName)) {

                userName = getValue(config, "httpproxy", "username", "");

            }

            if (StringUtils.isBlank(password)) {

                password = getValue(config, "httpproxy", "password", "");

            }

            dialog.setUserName(userName);

            dialog.setPassword(password);

            if (dialog.login()) {

                conf.setUserName(dialog.getUserName());

                conf.setPassword(dialog.getPassword());

                conf.setEnabled(true);

                conf.apply();

            } else {

                conf.setUserName(dialog.getUserName());

                conf.setPassword("");

                conf.setEnabled(false);

                conf.apply();

            }

            logger.info("Set httpproxy user to '" + conf.getUserName() + "'.");

            logger.info("Set httpproxy password.");

            // Set values in config to allow variable sustitution

            setValue(config, "httpproxy", "username", conf.getUserName());

            setValue(config, "httpproxy", "password", conf.getPassword());

            return true;

        } catch (Exception ex) {

            errors_add("Can't apply username/password proxy configuration.", ex);

            return false;

        }

    }

    private void configureCRS(DynObject config) {

        if (!BooleanUtils.isTrue((Boolean) getProperty("configureProjection"))) {

            return;

        }

        try {

            ProjectManager projectManager = ApplicationLocator.getProjectManager();

            ProjectPreferences projectPreferences = projectManager.getProjectPreferences();

            DynObject crsOptions = (DynObject) config.getDynValue("CRS");

            IProjection proj = (IProjection) crsOptions.getDynValue("default_projection");

            projectPreferences.setDefaultProjection(proj.getFullCode());

            logger.info("Set default projection to '" + proj.getFullCode() + "'.");

            setProperty("configureProjection", Boolean.FALSE);

        } catch (Exception ex) {

            errors_add("Can't apply CRS configuration.", ex);

        }

    }

    private void configureServers(String protocol, String pluginName, List<DynObject> servers) {

        if (!getPropertyBoolean("configureOGCServers_" + protocol)) {

            return;

        }

        if (pluginName == null) {

            logger.info("Skip '" + pluginName + "' servers configurations..");

            return;

        }

        PluginServices plugin = getPlugin(pluginName);

        if (plugin == null) {

            logger.info("Skip '" + pluginName + "' servers configurations. Plugin not installed.");

            return;

        }

        ServerDataPersistence serversDataPersistence = (ServerDataPersistence) plugin.getPluginProperties().getDynValue("Servers");

        if (serversDataPersistence == null) {

            serversDataPersistence = new ServerDataPersistence(protocol);

            plugin.getPluginProperties().setDynValue("Servers", serversDataPersistence);

        }

        MyServerData serversData = new MyServerData(serversDataPersistence);

        for (int i = 0; i < servers.size(); i++) {

            String server = (String) servers.get(i).getDynValue("url");

            boolean remove = BooleanUtils.isTrue((Boolean) servers.get(i).getDynValue("remove"));

            if (remove) {

                serversData.remove(server);

                logger.info("Remove '" + protocol + "' server '" + server + "'.");

            } else {

                if (!serversData.contains(server)) {

                    serversData.add(server, protocol);

                    logger.info("Insert '" + protocol + "' server '" + server + "'.");

                }

            }

        }

        plugin.savePluginProperties();

        logger.info("Save properties of plugin '" + pluginName + "'.");

        setProperty("configureOGCServers_" + protocol, Boolean.FALSE);

    }

    private void createActionsScripts(DynObject config) {

        List<DynObject> scriptActions = (List<DynObject>) config.getDynValue("scriptActions");

        if (scriptActions == null) {

            return;

        }

        ActionInfoManager actionManager = PluginsLocator.getActionInfoManager();

        for (int i = 0; i < scriptActions.size(); i++) {

            DynObject scriptAction = scriptActions.get(i);

            String name = (String) scriptAction.getDynValue("name");

            ActionInfo action = actionManager.getAction(name);

            if (action == null) {

                String script = (String) scriptAction.getDynValue("script");

                String label = (String) scriptAction.getDynValue("label");

                String icon = (String) scriptAction.getDynValue("icon");

                long position = ((Long) (scriptAction.getDynValue("position"))).longValue();

                String tip = (String) scriptAction.getDynValue("tip");

                createActionScript(name, script, label, icon, position, tip);

            } else {

                logger.info("Can't create action script, action '" + name + "' already defined.");

            }

        }

    }

    private void addTOCActions(DynObject config) {

        List<DynObject> viewTOCActions = (List<DynObject>) config.getDynValue("viewTocActions");

        if (viewTOCActions == null) {

            return;

        }

        ActionInfoManager actionManager = PluginsLocator.getActionInfoManager();

        ProjectManager projectManager = ApplicationLocator.getProjectManager();

        ViewManager viewManager = (ViewManager) projectManager.getDocumentManager(ViewManager.TYPENAME);

        for (int i = 0; i < viewTOCActions.size(); i++) {

            DynObject viewTOCAction = viewTOCActions.get(i);

            String name = (String) viewTOCAction.getDynValue("name");

            ActionInfo action = actionManager.getAction(name);

            if (action != null) {

                String group = (String) viewTOCAction.getDynValue("group");

                int grouporder = ((Long) (viewTOCAction.getDynValue("grouporder"))).intValue();

                viewManager.addTOCContextAction(action, group, grouporder);

            } else {

                logger.info("Can't add context menu entry to the view TOC. Action '" + name + "' don't exists.");

            }

        }

    }

    private void addMenuActions(DynObject config) {

        List<DynObject> menuActions = (List<DynObject>) config.getDynValue("menuActions");

        if (menuActions == null) {

            return;

        }

        ActionInfoManager actionManager = PluginsLocator.getActionInfoManager();

        ApplicationManager application = ApplicationLocator.getManager();

        for (int i = 0; i < menuActions.size(); i++) {

            DynObject menuAction = menuActions.get(i);

            String name = (String) menuAction.getDynValue("name");

            ActionInfo action = actionManager.getAction(name);

            if (action != null) {

                String text = (String) menuAction.getDynValue("text");

                application.addMenu(action, text);

            } else {

                logger.info("Can't add menu entry. Action '" + name + "' don't exists.");

            }

        }

    }

    private void addToolActions(DynObject config) {

        List<DynObject> toolActions = (List<DynObject>) config.getDynValue("toolActions");

        if (toolActions == null) {

            return;

        }

        ActionInfoManager actionManager = PluginsLocator.getActionInfoManager();

        ApplicationManager application = ApplicationLocator.getManager();

        for (int i = 0; i < toolActions.size(); i++) {

            DynObject toolAction = toolActions.get(i);

            String name = (String) toolAction.getDynValue("name");

            ActionInfo action = actionManager.getAction(name);

            if (action != null) {

                String toolbarName = (String) toolAction.getDynValue("toolbarName");

                application.addTool(action, toolbarName);

            } else {

                logger.info("Can't add tool entry. Action '" + name + "' don't exists.");

            }

        }

    }

    private ActionInfo createActionScript(String actionName, String scriptName, String label, String iconName, long position, String tip) {

        ActionInfoManager actionManager = PluginsLocator.getActionInfoManager();

        Class scriptingExtension = this.getScriptingExtension();

        if (scriptingExtension == null) {

            logger.warn("Can't create action script '" + actionName + "', can't locate scripting extension");

            return null;

        }

        if (StringUtils.isBlank(iconName)) {

            iconName = null;

        }

        if (StringUtils.isBlank(tip)) {

            tip = actionName;

        }

        ActionInfo action = actionManager.createAction(scriptingExtension, actionName, label, scriptName, iconName, null, position, tip);

        return actionManager.registerAction(action);

    }

    @Override

    public void run() {

        errors_reset();

        MainFrame mainWindow = PluginsLocator.getMainFrame();

        try {

            Configuration configManager = new Configuration();

            DynObject config = configManager.load();

            if (config == null) {

                PluginsLocator.getMainFrame().messageDialog(

                        "_No_se_ha_podido_acceder_a_la_configuracion_de_personalizacion_Consulte_el_registro_de_errores_si_precisa_mas_informacion",

                        "_Atencion",

                        JOptionPane.WARNING_MESSAGE

                );

                return;

            }

            configureLocale(config);

            configureHttpproxy(config);

            DynObject httpProxyConfiguration = (DynObject) config.getDynValue("httpproxy");

            if (((Boolean) (httpProxyConfiguration.getDynValue("promptUserAndPassword"))).booleanValue()) {

                configureHttpproxyUser(config);

            }

            configureCRS(config);

            mainWindow.message("_Updating_server_information", JOptionPane.INFORMATION_MESSAGE);

            configureServers(

                    "WMS",

                    "org.gvsig.raster.wms.app.wmsclient",

                    (List<DynObject>) config.getDynValue("wmsUrls")

            );

            configureServers(

                    "WMTS",

                    "org.gvsig.raster.wmts.app.wmtsclient",

                    (List<DynObject>) config.getDynValue("wmsUrls")

            );

            configureServers(

                    "WCS",

                    "org.gvsig.raster.wcs.app.wcsclient",

                    (List<DynObject>) config.getDynValue("wmsUrls")

            );

            configureServers(

                    "WFS",

                    "org.gvsig.wfs.app.mainplugin",

                    (List<DynObject>) config.getDynValue("wmsUrls")

            );

//

//            configureAllPlugins(config);

//

            createActionsScripts(config);

            addTOCActions(config);

            addMenuActions(config);

            addToolActions(config);

        } catch (Exception ex) {

            errors_add("Problems apply defaut configuration.", ex);

        }

        if (errors_count() > 0) {

            mainWindow.messageDialog(

                    "_Se_han_producido_errores_actualizando_la_configuracion_por_defecto_Consulte_el_registro_de_errores_si_precisa_mas_informacion",

                    "_Setting_custom_configuration",

                    JOptionPane.WARNING_MESSAGE

            );

        }

        installAdditionalPackages();

        mainWindow.message(null, JOptionPane.INFORMATION_MESSAGE);

    }

    private Set loadDefaultPackages(File packages) throws IOException {

        Set defaultPackages = new HashSet<String>();

        List<String> lines = FileUtils.readLines(packages);

        defaultPackages.clear();

        for (String line : lines) {

            line = line.trim();

            if (line.startsWith("#") || line.startsWith(";")) {

                continue;

            }

            defaultPackages.add(line.toLowerCase());

        }

        return defaultPackages;

    }

    /**

     * Workaround to bug in SimpleTaskStatus of gvSIG 2.2.0

     */

    private static class MyTaskStatus extends BaseTaskStatus {

        public MyTaskStatus(String title) {

            super(title);

        }

        public MyTaskStatus(String tittle, long minValue, long maxValue) {

            super(tittle, minValue, maxValue);

        }

        public void message(String message) {

            this.lastModification = new Date();

            super.message(message);

        }

    }

    private void installAdditionalPackages() {

        if (!BooleanUtils.isTrue((Boolean) getProperty("installAdditionalComponents"))) {

            return;

        }

        File defaultPackagesFile = new File(getPlugin().getPluginDirectory(), "defaultPackages");

        if (!defaultPackagesFile.exists()) {

            logger.info("Skip additional package instalation (don't exists " + defaultPackagesFile.getAbsolutePath() + ").");

            return;

        }

        boolean needRestart = false;

        SimpleTaskStatus taskStatus = new MyTaskStatus("Installing additional components");

        InstallPackagesPanel dialog = new InstallPackagesPanel(taskStatus);

        try {

            taskStatus.add();

            taskStatus.setAutoremove(true);

            showWindow(

                    dialog,

                    "Terminating installation",

                    WindowManager.MODE.WINDOW

            );

            taskStatus.message("Preparing additional components installation");

            PluginsManager pluginsManmager = PluginsLocator.getManager();

            InstallerManager installerManager = InstallerLocator.getInstallerManager();

            InstallPackageService installer = null;

            List<PackageInfo> packagesToInstall = new ArrayList<PackageInfo>();

            Set<String> defaultSelectedPacakgeCodes = loadDefaultPackages(

                    defaultPackagesFile

            );

            installer = installerManager.getInstallPackageService();

            taskStatus.message("Searching available packages");

            installer.addBundlesFromDirectory(pluginsManmager.getInstallFolder());

            taskStatus.message("Filtering packages");

            for (String packageCode : defaultSelectedPacakgeCodes) {

                PackageInfo pkg = installer.getPackageInfo(packageCode);

                if (pkg != null) {

                    File folder = installerManager.getAddonFolder(pkg.getCode());

                    if (folder == null) {

                        packagesToInstall.add(pkg);

                    }

                }

            }

            if (!packagesToInstall.isEmpty()) {

                taskStatus.setRangeOfValues(1, packagesToInstall.size());

                for (int i = 0; i < packagesToInstall.size(); i++) {

                    PackageInfo pkg = packagesToInstall.get(i);

                    taskStatus.setCurValue(i + 1);

                    taskStatus.message("Installing " + pkg.getCode());

                    try {

                        logger.info("install package '" + pkg.getCode() + "'.");

                        installer.installPackage(pluginsManmager.getApplicationFolder(), pkg);

                        if (needRestart(installer,pkg)) {

                            needRestart = true;

                        }

                    } catch (Throwable th) {

                        logger.warn("can't install package '" + pkg.getCode() + "'.", th);

                    }

                }

                taskStatus.message("Installation terminated");

                taskStatus.terminate();

                setProperty("installAdditionalComponents", Boolean.FALSE);

                if (needRestart) {

                    dialog.message("Additional components installed succesfully. Restart applicaction.");

                } else {

                    dialog.message("Additional components installed succesfully.");

                }

            } else {

                taskStatus.message("Installation terminated");

                taskStatus.terminate();

                dialog.message("Additional components installed succesfully.");

            }

            setProperty("installAdditionalComponents", Boolean.FALSE);

        } catch (Throwable th) {

            taskStatus.cancel();

            dialog.message("Problems installing additional components");

            logger.warn("can't install additional packages.", th);

        } finally {

            taskStatus.remove();

        }

    }

    private boolean needRestart(InstallPackageService installer, PackageInfo pkg) {

//        return installer.needRestart(pkg);

        if( "plugin".equalsIgnoreCase(pkg.getType()) ) {

            return true;

        } else if( "symbols".equalsIgnoreCase(pkg.getType()) ) {

            return false;

        } else if( "jCRS_EPSG".equalsIgnoreCase(pkg.getType()) ) {

            return true;

        } else {

            return true;

        }

    }

}