root/tools/routingservice/trunk/src/jp/co/orkney/restlet/util/Configuration.java

package jp.co.orkney.restlet.util;

/**
 * Copyright (c) 2007 Orkney, Inc. <http://www.orkney.co.jp/>
 * 
 * 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 3 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, see <http://www.gnu.org/licenses/>.
 */

import java.io.File;
import java.io.IOException;
import java.math.BigDecimal;
import java.util.Iterator;
import java.util.List;
import java.util.StringTokenizer;
import java.util.Vector;

import org.jdom.Document;
import org.jdom.Element;
import org.jdom.JDOMException;
import org.jdom.input.SAXBuilder;
import org.jdom.output.XMLOutputter;

/**
 * <b>Configuration is a class which represents the webRouting Service's
 * configuration.</b>
 * <p>
 * A configuration is characterized by the following information:
 * <ul>
 * <li>An URL to access on XML configuration file</li>
 * <li>An port number</li>
 * <li>A localhost IP address</li>
 * <li>A vector containing all providers (see below)</li>
 * <li>The provider specified by GET or POST request</li>
 * <li>The service specified by GET or POST request</li>
 * <li>The data input format specified by GET or POST request</li>
 * <li>The data output format specified by GET or POST request</li>
 * </ul>
 * <br />
 * Structure of the vector "providers":<br /> > Provider 1<br /> > > Service 1<br /> > > >
 * Parameter 1<br /> > > > Parameter 2<br /> > > > ...<br /> > > > Parameter
 * n<br /> > > > Format 1<br /> > > > Format 2<br /> > > > ...<br /> > > >
 * Format n<br /> > Provider 2<br /> > > Service 2<br /> > > > ...<br /> >
 * Provider n<br /> > > ...<br /> > > > ...<br />
 * </p>
 * 
 * @author Matthieu Bilbille - Orkney Inc.
 * @version 1.0
 */
public class Configuration
{
    public static final String API_KEY = "api_key";

    public static final String SIGNATURE = "signature";

    public static final String CLIENT_ID = "id";

    private String urlConfigurationFile = "./configuration.xml";

    private String urlXMLTemplateQuery = "./pool.xml";

    private String commandCapabilities = "capabilities";

    private String versionNumber = "1.0.0";

    private String port;

    private String urlLog;

    private int modeLog;

    private String localhost;

    private String urlCss;

    public Vector<Provider> providers;

    private int askCapabilities; // -1 by default, 0 host capabilities, 1

    // provider "x" capabilities

    private Provider provider;

    private Service service;

    private Format formatIn;

    private Format formatOut;

    private int iProvider = 0;

    private int iService = 0;

    private int iFormat = 0;

    /**
     * Constructor Format.
     * <p>
     * Creates a new format with empty data (port, urlLog,...);
     * </p>
     */
    public Configuration()
    {
        port = "";
        urlLog = "";
        modeLog = 0;
        localhost = "";
        urlCss = "";
        askCapabilities = -1;
        providers = new Vector<Provider>();
        /*
         * provider = new Provider(); service = new Service(); formatIn = new
         * Format(); formatOut = new Format();
         */
        provider = null;
        service = null;
        formatIn = null;
        formatOut = null;
    }

    /**
     * Parses the XML configuration file and puts all this data in a vector<Provider>.
     * 
     */
    @SuppressWarnings("unchecked")
    public void parseXML()
    {
        SAXBuilder sxb = new SAXBuilder();
        Document document = null;
        try
        {
            document = sxb.build(new File(urlConfigurationFile));
        }
        catch (JDOMException e)
        {
            e.printStackTrace();
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
        Element root = document.getRootElement();

        port = root.getChild("port").getText();
        urlLog = root.getChild("log").getText();
        modeLog = Integer.parseInt(root.getChild("log").getAttributeValue(
                "mode"));
        //localhost = root.getChild("localhost").getText();
        //urlCss = root.getChild("css").getText();

        List<Element> listProviders = root.getChild("providers").getChildren(
                "provider");
        Iterator<Element> itProvider = listProviders.iterator();

        while (itProvider.hasNext())
        {
            Provider provider = new Provider();
            Element currentProvider = (Element) itProvider.next();
            provider.setName(currentProvider.getAttributeValue("name"));
            List<Element> listServices = currentProvider.getChild("services")
                    .getChildren("service");
            Iterator<Element> itService = listServices.iterator();
            Vector<Service> services = new Vector<Service>();

            while (itService.hasNext())
            {
                Service service = new Service();
                Element currentService = itService.next();
                service.setName(currentService.getAttributeValue("name"));

                service.setEnable(new Boolean(currentService
                        .getAttributeValue("enable")));
                service.setDatabaseConfiguration(new DatabaseConfiguration(
                        currentService.getChild("connection")
                                .getAttributeValue("driver"), currentService
                                .getChild("connection").getChildText("url"),
                        currentService.getChild("connection").getChildText(
                                "user"), currentService.getChild("connection")
                                .getChildText("password")));
                service.setDataProjection(currentService.getChild("projection")
                        .getAttributeValue("srid"));

                // TODO read units from the configuration
                // probably it is better to create Projection class

                Limit limit = service.getLimit();
                try
                {

                    limit.setDistance(Double.parseDouble(currentService
                            .getChild("limit").getAttributeValue("distance")));
                }
                catch (NullPointerException e)
                {
                    // This service has no distance limitations.
                    // Do nothing.
                }
                try
                {
                    limit.setExtent(parseExtent(currentService
                            .getChild("limit").getAttributeValue("extent")));
                }
                catch (NullPointerException ee)
                {
                    // This service has no extent limitations.
                    // Do nothing.
                }

                //service.setLimit(limit);

                List<Element> listSQL = currentService.getChild("sql")
                        .getChildren("query");
                Iterator<Element> itQuery = listSQL.iterator();
                while (itQuery.hasNext())
                {
                    Element currentQuery = itQuery.next();
                    if (currentQuery.getAttributeValue("transformProjectionIn")
                            .equals("false"))
                    {
                        if (currentQuery.getAttributeValue(
                                "transformProjectionOut").equals("false"))
                        {
                            // case: transformProjectionIn = FALSE &
                            // transformProjectionOut = FALSE
                            service.setSQL(currentQuery.getText(), 0);
                        }
                        else
                        {
                            // case: transformProjectionIn = FALSE &
                            // transformProjectionOut = TRUE
                            service.setSQL(currentQuery.getText(), 1);
                        }

                    }
                    else
                    {
                        if (currentQuery.getAttributeValue(
                                "transformProjectionOut").equals("false"))
                        {
                            // case: transformProjectionIn = TRUE &
                            // transformProjectionOut = FALSE
                            service.setSQL(currentQuery.getText(), 2);
                        }
                        else
                        {
                            // case: transformProjectionIn = TRUE &
                            // transformProjectionOut = TRUE
                            service.setSQL(currentQuery.getText(), 3);
                        }
                    }

                }
                
                List<Element> listParameters = currentService.getChild(
                        "parameters").getChildren("parameter");
                Iterator<Element> itParametre = listParameters.iterator();
                Vector<Parameter> parameters = new Vector<Parameter>();

                while (itParametre.hasNext())
                {
                    Element currentParameter = itParametre.next();
                    /*
                    parameter.setName(currentParameter
                            .getAttributeValue("name"));
                    parameter.setType(currentParameter
                            .getAttributeValue("type"));
                    parameter.setCodeName(currentParameter
                            .getAttributeValue("codename"));
                    parameter.setRequired(new Boolean(currentParameter
                            .getAttributeValue("required")));
                    parameter.setDefaultValue(currentParameter
                            .getAttributeValue("default"));
                    parameter.setValue(currentParameter
                            .getAttributeValue("default"));
                     */
                    Parameter parameter = new Parameter(currentParameter);          
                    parameters.add(parameter);
                }
                
                service.setParameters(parameters);
                

                
                List<Element> listFormat = currentService.getChild("formats")
                        .getChildren("format");
                Iterator<Element> itFormat = listFormat.iterator();
                Vector<Format> formats = new Vector<Format>();

                while (itFormat.hasNext())
                {
                    Element currentFormat = itFormat.next();
                    /*
                    format.setName(currentFormat.getAttributeValue("name"));
                    format.setSrid(currentFormat.getAttributeValue("srid"));
                    format.setEnableInput(new Boolean(currentFormat
                            .getAttributeValue("input")));
                    format.setEnableOutput(new Boolean(currentFormat
                            .getAttributeValue("output")));
                    format.setTemplate(currentFormat.getAttributeValue("template"));
                    */
                    Format format = new Format(currentFormat);
                    formats.add(format);
                }
                                
                if (service.getName().equals("security"))
                    provider.setAuthService(service);

                service.setFormats(formats);
                services.add(service);
            }
            provider.setServices(services);
            providers.add(provider);
        }
    }

    /**
     * Parses the URL request to define the provider, the service, the data
     * input and output format. The format of the URL must be:
     * root/version/provider/input_format/service.output_format
     * 
     * @param url
     *                the string to parse
     * @throws Exception
     *                 Creates an exception if the URL is wrong
     */
    public void parseURL(String url) throws Exception
    {
        // FORMAT: /version/provider/input/service.output

        String urlSplit[] = url.split("/");

        if (urlSplit[0].equals(commandCapabilities))
        {
            askCapabilities = 0;
            return;
        }
        if (!urlSplit[0].equals(versionNumber))
            throw new Exception("Invalid version number");

        if ((iProvider = isProvider(urlSplit[1])) != -1)
        {
            provider = providers.get(iProvider);
            if (urlSplit[1].equals(commandCapabilities))
            {
                askCapabilities = 1;
                return;
            }
        }
        else
            throw new Exception("Unknown provider");

        if ((iService = isService(urlSplit[3].split("\\.")[0])) != -1)
        {
            /*
             * Service tmpService = provider.getServices().get(iService);
             * service = new Service(tmpService.getName(), tmpService
             * .getDataProjection(), tmpService.getSQL(), tmpService
             * .isEnable(), tmpService.getParameters(), null, tmpService
             * .getDatabaseConfiguration(), tmpService.getLimit());
             */
            service = provider.getServices().get(iService);
        }
        else
            throw new Exception("unknown service");

        if ((iFormat = isInput(urlSplit[2])) != -1)
        {
            /*
            Format tmpFormat = providers.get(iProvider).getServices().get(
                    iService).getFormats().get(iFormat);
            formatIn = new Format(tmpFormat.getName(), tmpFormat.getSrid(),
                    tmpFormat.isEnableInput(), tmpFormat.isEnableOutput());
                */
            formatIn = providers.get(iProvider).getServices().get(
                    iService).getFormats().get(iFormat);
        }
        else
            throw new Exception("unknown input format");

        if ((iFormat = isOutput(urlSplit[3].split("\\.")[1].split("\\?")[0])) != -1)
        {
            /*
            Format tmpFormat = providers.get(iProvider).getServices().get(
                    iService).getFormats().get(iFormat);
            formatOut = new Format(tmpFormat.getName(), tmpFormat.getSrid(),
                    tmpFormat.isEnableInput(), tmpFormat.isEnableOutput());
            if (formatOut.getSrid() != null && !formatOut.getSrid().equals(""))
            {
                service.getParameter("sridOutput")
                        .setValue(formatOut.getSrid());
            }
            */
            formatOut = providers.get(iProvider).getServices().get(
                    iService).getFormats().get(iFormat);
        }
        else
            throw new Exception("unknown output format");
    }

    /**
     * Creates an object to write in the log file
     * 
     * @return a new Log object
     */
    public Log createLog()
    {
        return new Log(urlLog, modeLog);
    }

    /**
     * Determines whether this string is a provider name.
     * 
     * @param name
     *                a string
     * @return index of the provider in the vector<Provider>; otherwise
     *         returns -1
     */
    public int isProvider(String name)
    {
        for (int i = 0; i < providers.size(); i++)
        {
            if (providers.get(i).getName().equals(name))
                return i;
        }
        return -1;
    }

    /**
     * Determines whether this string is a service name.
     * 
     * @param name
     *                a string
     * @return index of the service in the vector<Service> of the parent
     *         provider; otherwise returns -1
     */
    public int isService(String name)
    {

        for (int i = 0; i < providers.get(iProvider).getServices().size(); i++)
        {
            if (providers.get(iProvider).getServices().get(i).getName().equals(
                    name))
                return i;
        }
        return -1;
    }

    /**
     * Determines whether this string is a input name and whether is enabled
     * for input data
     * 
     * @param name
     *                a string
     * @return index of the format in the vector<Format> of the parent
     *         service; otherwise returns -1
     */
    public int isInput(String name)
    {

        for (int i = 0; i < providers.get(iProvider).getServices()
                .get(iService).getFormats().size(); i++)
        {
            if (providers.get(iProvider).getServices().get(iService)
                    .getFormats().get(i).getName().equals(name)
                    && providers.get(iProvider).getServices().get(iService)
                            .getFormats().get(i).isEnableInput())
                return i;
        }
        return -1;
    }

    /**
     * Determines whether this string is a output name and whether is
     * enabled for output data
     * 
     * @param name
     *                a string
     * @return index of the format in the vector<Format> of the parent
     *         service; otherwise returns -1
     */
    public int isOutput(String name)
    {
        for (int i = 0; i < providers.get(iProvider).getServices()
                .get(iService).getFormats().size(); i++)
        {
            if (providers.get(iProvider).getServices().get(iService)
                    .getFormats().get(i).getName().equals(name)
                    && providers.get(iProvider).getServices().get(iService)
                            .getFormats().get(i).isEnableOutput())
                return i;
        }
        return -1;
    }

    /**
     * Gets the port number of the restlet
     * 
     * @return this restlet's port
     */
    public String getPort()
    {
        return port;
    }

    /**
     * Gets the localhost address
     * 
     * @return localhost address
     */
    public String getLocalhost()
    {
        return localhost;
    }

    /**
     * Gets the requested provider
     * 
     * @return the requested provider
     */
    public Provider getProvider()
    {
        return provider;
    }

    /**
     * Gets the requested service
     * 
     * @return the requested service
     */
    public Service getService()
    {
        return service;
    }

    /**
     * Gets the url of CSS file (for HTML output)
     * 
     * @return the CSS File
     */
    public String getCss()
    {
        return urlCss;
    }

    /**
     * Gets the database configuration of the requested service
     * 
     * @return the database configuration
     */
    public DatabaseConfiguration getConfigurationConnexion()
    {
        return service.getDatabaseConfiguration();
    }

    /**
     * Gets the parameters of the requested service
     * 
     * @return a vector<Parameter>
     */
    public Vector<Parameter> getParameters()
    {
        return service.getParameters();
    }

    /**
     * Gets the requested input data format
     * 
     * @return a format
     */
    public Format getFormatIn()
    {
        return formatIn;
    }

    /**
     * Gets the requested output data format
     * 
     * @return a format
     */
    public Format getFormatOut()
    {
        return formatOut;
    }

    public int askCapabilities()
    {
        return askCapabilities;
    }

    public String getCapabilities()
    {
        String res = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>\n";
        SAXBuilder sxb = new SAXBuilder();
        Document document = null;
        try
        {
            document = sxb.build(new File(urlConfigurationFile));
        }
        catch (JDOMException e)
        {
            e.printStackTrace();
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
        Element root = document.getRootElement();
        List<Element> listProviders = root.getChild("providers").getChildren(
                "provider");
        Iterator<Element> itProvider = listProviders.iterator();

        while (itProvider.hasNext())
        {
            Element currentProvider = (Element) itProvider.next();
            List<Element> listServices = currentProvider.getChild("services")
                    .getChildren("service");
            Iterator<Element> itService = listServices.iterator();
            while (itService.hasNext())
            {
                Element currentService = itService.next();
                currentService.removeChild("connection");
                currentService.removeChild("sql");
            }
        }

        switch (askCapabilities)
        {
        case 0:
            res += new XMLOutputter().outputString(root.getChild("providers"));
            break;
        case 1:
            res += new XMLOutputter()
                    .outputString(listProviders.get(iProvider));
            break;
        }
        return res;
    }

    public String getUrlXMLTemplateQuery()
    {
        return urlXMLTemplateQuery;
    }

    //This method parses an extent.
    //The format should be 'X1 Y1,X2 Y2'
    private Extent parseExtent(String coordinates)
    {
        BigDecimal[] coordinatesArray = null;
        int i = 0;

        StringTokenizer ll = new StringTokenizer(coordinates.trim(), ",");
        while (ll.hasMoreTokens())
        {
            StringTokenizer ur = new StringTokenizer(ll.nextToken().trim(), " ");
            while (ur.hasMoreTokens())
            {
                coordinatesArray[i] = new BigDecimal(ur.nextToken());
                ++i;
            }
        }

        Extent extent = new Extent(coordinatesArray[0], coordinatesArray[1],
                coordinatesArray[2], coordinatesArray[3]);

        return extent;
    }
}