source: other-projects/tipple-android/tipple-lib/src/org/greenstone/android/tipple/base/GreenstoneXMLRetriever.java@ 26899

package org.greenstone.android.tipple.base;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import android.util.Log;




public class GreenstoneXMLRetriever 
{
    private String lib_name = null;
    //private String server_url = null;
    
    private String port = null;
    
    /*
     * vals contains the names of the Greenstone article metadata, and vals_translated is what they map to.
     * 
     * For example, if my article in the GS collection "tipple-universe" has the metadata "tp.Longitude", this class will
     * map it to "longitude", which is what Tipple is looking for when it's displaying locations.
     * 
     */
    private final String[] vals = new String[] { "tp.Longitude", "tp.Latitude", "Title", "Radius", "Text", "Elevation" };
    private final String[] vals_translated = new String[] { "longitude", "latitude", "title", "radius", "text", "elevation" };
    
    private Document getDocFromUrl(String uri)
    {
        Document doc = null;
        
        try
        {
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            //factory.setValidating(true);
            factory.setIgnoringElementContentWhitespace(true);
            
            URL url = new URL(uri);
            HttpURLConnection connection = (HttpURLConnection)url.openConnection();
            connection.setRequestMethod("GET");
            connection.connect();       
            InputStream stream = connection.getInputStream();
            
            DocumentBuilder builder = factory.newDocumentBuilder();     
            doc = builder.parse(stream);
        }
        catch(Exception ex)
        {
            ex.printStackTrace();
        }
        
        return doc;
    }
    
    private HashMap<String,String> retrieveDataFromHashId(String hash_id)
    {
        HashMap<String,String> datas = null;

        
        try
        {   
            Document doc = getDocFromUrl("http://localhost:" + port + "/greenstone3/library?a=d&d=" + hash_id + "&c=" + lib_name + "&sib=&ed=1&o=xml");
            
            datas = new HashMap<String,String>();
            
            NodeList nodeList = doc.getElementsByTagName("metadata");
            for (int i = 0; i < nodeList.getLength(); i++) 
            {
                
                Node node = nodeList.item(i);
                
                if( node.hasAttributes() )
                {
                    
                    NamedNodeMap map = node.getAttributes();            
                    Node n = map.getNamedItem("name");
                    
                    if(n != null)
                    {                       
                        String s = n.getTextContent();
                        
                        // iterate through the attribs we are looking for... ie tp.Lat, tp.Lng, tp.Radius
                        for(int x = 0; x < vals.length; x++)
                        {
                            // if the attribute of the node is e.g. "tp.Lat", etc. then let's grab the content of this node
                            if(s.equals(vals[x]))
                            {
                                datas.put( vals_translated[x], node.getTextContent() );
                            }
                        }
                    }
                }           
           }
            
           nodeList = doc.getElementsByTagName("nodeContent");
           Node node = nodeList.item(0);
            
           
           /*
            * TODO:
            * I have hardcoded radius for now, but you should add this as another metadata to the
            * collection "tipple-universe".
            * 
            */
           
           datas.put("radius", "0.2");
           datas.put("text", node.getTextContent());
           datas.put("elevation", "0");
            
        }
        catch(Exception ex)
        {
            ex.printStackTrace();
        }
        
        // if we got all the necessary data (lng,lat,radius,desc, and title)
        if( datas.size() == vals.length) // vals.length + the radius + the text content
        {       
            return datas;
        }
        
        // otherwise return null    
        return null;
    }
    
    public GreenstoneXMLRetriever(String port, String lib_name)
    {
        //this.server_url = server_url;
        this.port = port;
        this.lib_name = lib_name;
    }
    
    public ArrayList<String> query(double lng, double lat)
    {
        ArrayList<String> all_locations = new ArrayList<String>();
        
        String[] latlngs = convertLatLng(lng, lat);
        String short_lng = latlngs[0];
        String short_lat = latlngs[1];
        
        // ok, now construct a url  
        String query_url = "http://localhost:" + port + "/greenstone3/library?a=q&s=RawQuery&rt=rd&c=" +
                lib_name +
                "&s1.rawquery=" +
                "(LA:" +
                short_lat +
                "+AND+" +
                "LN:" +
                short_lng +
                ")" +
                "&excerptid=jsonNodes&o=xml";
        
        Log.d("GreenstoneXMLRetriever::query()", "Query URL constructed is: " + query_url);
        
        Document doc = getDocFromUrl(query_url);
        
        // presumably, if the doc is not null, we actually were able to access localhost
        if(doc != null)
        {
        
            NodeList nodeList = doc.getElementsByTagName("documentNode");       
            for (int i = 0; i < nodeList.getLength(); i++) 
            {
                
                Node node = nodeList.item(i);           
                if( node.hasAttributes() )
                {
                    
                    NamedNodeMap map = node.getAttributes();            
                    Node n = map.getNamedItem("nodeID");
                    
                    if(n != null)
                    {
                        String nodeID = n.getTextContent();
                        all_locations.add(nodeID);
                        
                        Log.d("GreenstoneXMLRetriever::query()", "HashID found from querying GS3 server: " + nodeID);
                    }
                }           
           }
            
           return all_locations;
       
       }
       
       // otherwise presumably we couldn't connect to localhost, so return null
       return null;

    }
    
    public String[] convertLatLng(double lng, double lat)
    {
        // ok, convert the doubles into strings
        String lng_short = String.valueOf(lng);
        String lat_short = String.valueOf(lat);
        
        // remove everything after the decimal place
        lng_short = lng_short.substring(0, lng_short.lastIndexOf('.'));
        lat_short = lat_short.substring(0, lat_short.lastIndexOf('.'));
        
        // if longitude is negative
        if(lng_short.charAt(0) == '-')
        {
            // then its west
            lng_short = lng_short.substring(1) + 'W';
        }
        else
        {
            // otherwise it's east
            lng_short = lng_short + 'E';            
        }
        
        // if latitude is negative
        if(lat_short.charAt(0) == '-')
        {
            lat_short = lat_short.substring(1) + 'S';
        }
        else
        {
            lat_short = lat_short + 'N';
        }
        
        return new String[] { lng_short, lat_short };
    }
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    public ArrayList< HashMap<String,String> > retrieveDataFromHashIds(ArrayList<String> hash_ids)
    {
        ArrayList< HashMap<String,String> > datas_container = new ArrayList< HashMap<String,String> >();
        

        for(int x = 0; x < hash_ids.size(); x++)
        {
            HashMap<String,String> hm = retrieveDataFromHashId( hash_ids.get(x) );
            
            // prepare hashmap (ie rename keys)         
            if( hm != null)
            {
                datas_container.add(hm);
            }
        }
        
        return datas_container;
    }

}