source: trunk/gsdl3/src/java/org/greenstone/gsdl3/service/GATEServices.java@ 4098

/*
 *    GATEServices.java
 *    Copyright (C) 2002 New Zealand Digital Library, http://www.nzdl.org
 *
 *    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., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
package org.greenstone.gsdl3.service;


// Greenstone classes
import org.greenstone.gsdl3.util.*;

// GATE classes
import gate.*;
import gate.creole.*;
import gate.gui.*;
import gate.util.persistence.PersistenceManager;

// XML classes
import org.w3c.dom.Element; 
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

// General Java classes
import java.io.File;
import java.net.URL;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;


/**
 * <p>Title: GATE Greenstone3 integration</p>
 * <p>Description: </p>
 * <p>Copyright: Copyright (c) 2003</p>
 * <p>Company: University of Waikato</p>
 * @author unascribed
 * @version 1.0
 */

public class GATEServices
    extends ServiceRack {

    // the services on offer
    // these strings must match what is found in the properties file
    protected static final String GATE_POS_TAG_SERVICE = "GatePOSTag";

    protected static final String ANNOTATION_TYPE_PARAM = "annotationType";

    protected Element config_info_ = null;

    protected CorpusController application_;

    protected Corpus corpus_;

    protected String[] annotation_types_ = { "Date", "Location",
                         "Organization", "Person" };
    // Address, 

    /** constructor */
    public GATEServices()
    {
    }


    /** configure this service */
    public boolean configure(Element info, Element extra_info)
    {
    System.out.println("Configuring GATEServices...");
    config_info_ = info;

    // set up short_service_info_ - for now just has name and type
    Element tq_service = doc_.createElement(GSXML.SERVICE_ELEM);
    tq_service.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_ENRICH);
    tq_service.setAttribute(GSXML.NAME_ATT, GATE_POS_TAG_SERVICE);
    short_service_info_.appendChild(tq_service);

    // set up service_info_map_ - for now, just has the same elements as above
    // should have full details about each service incl params lists etc.
    Element tq_service_full = (Element) tq_service.cloneNode(true);
    Element param_list = doc_.createElement(GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
    createParameter(ANNOTATION_TYPE_PARAM, param_list, false, null);
    tq_service_full.appendChild(param_list);
    service_info_map_.put(GATE_POS_TAG_SERVICE, tq_service_full);

    // add some format info to service map if there is any
    // Element format = (Element) GSXML.getChildByTagName(info, GSXML.FORMAT_ELEM);
    // if (format != null) {
    //     format_info_map_.put(GATE_POS_TAG_SERVICE, doc_.importNode(format, true));
    // }

    // Configure GATE for use
    try {
        Gate.init();
        Gate.getUserConfig().put(GateConstants.DOCUMENT_ADD_SPACE_ON_UNPACK_FEATURE_NAME,
                     new Boolean(false));

        // MainFrame mainFrame = new MainFrame();
        // mainFrame.setSize(new java.awt.Dimension(800, 600));
        // mainFrame.setVisible(true);

        // Load the (pre-created) application
        URL applicationFileURL = ClassLoader.getSystemResource("gate.app");
        File applicationFile = new File(applicationFileURL.getFile());
        application_ = (CorpusController) PersistenceManager.loadObjectFromFile(applicationFile);

        /* Collection processing_resources = application.getPRs();
        Iterator pr_iterator = processing_resources.iterator();
        while (pr_iterator.hasNext()) {
        ProcessingResource pr = (ProcessingResource) pr_iterator.next();
        String pr_name = pr.getName();
        System.out.println("PR name: " + pr_name);
        if (pr_name.startsWith("ANNIE POS Tagger")) {
            String as_name = ((POSTagger) pr).getInputASName();
            System.out.println("AS name: " + as_name);
        }
        } */

        // Create a new corpus
        corpus_ = Factory.newCorpus("GSDL3 Corpus");
        application_.setCorpus(corpus_);
    }
    catch (Exception e) {
        e.printStackTrace();
    }

    return true;
    }


    /** creates a display element containing all the text strings needed to display
    the service page, in the language specified */
    protected Element createServiceDisplay(String service, String lang)
    {
    // Create a service display for the basic text query service
    Element display = doc_.createElement(GSXML.DISPLAY_ELEM);
    display.appendChild(GSXML.createTextElement(doc_, GSXML.DISPLAY_NAME_ELEM, getTextString(service+".name", lang)));
    display.appendChild(GSXML.createTextElement(doc_, GSXML.DISPLAY_SUBMIT_ELEM, getTextString(service+".submit", lang)));

    // now need to add in the params
    if (service.equals(GATE_POS_TAG_SERVICE)) {
        createParameter(ANNOTATION_TYPE_PARAM, display, true, lang);
    }

    return display;
    }


    /** creates a new param element and adds it to the param list */
    protected void createParameter(String name, Element param_list, 
                   boolean display, String lang)
    {
    Element param = null;

    if (name.equals(ANNOTATION_TYPE_PARAM)) {
        if (display) {
        int len = annotation_types_.length;
        String[] annotation_type_names = new String[len];
        for (int i = 0; i < len; i++) {
            annotation_type_names[i] = getTextString("param." + name + "." + annotation_types_[i], lang);
        }
        
        param = GSXML.createParameterDisplay(doc_, name, getTextString("param." + name, lang), annotation_types_, annotation_type_names);
        }
        else {
        param = GSXML.createParameterDescription(doc_, name, GSXML.PARAM_TYPE_ENUM_MULTI, annotation_types_[0], annotation_types_);
        }
    }
    
    // Add the parameter to the list
    if (param != null) {
        param_list.appendChild(param);
    }   
    }


    protected Element processGatePOSTag(Element request)
    {
    // System.out.println("(GatePOSTag) Request:\n" + converter_.getPrettyString(request));

    // Create a new (empty) result message
    Element result = doc_.createElement(GSXML.RESPONSE_ELEM);
    result.setAttribute(GSXML.FROM_ATT, GATE_POS_TAG_SERVICE);
    result.setAttribute(GSXML.TYPE_ATT, GSXML.REQUEST_TYPE_PROCESS);

    // Get the parameters of the request
    Element param_list = (Element) GSXML.getChildByTagName(request, GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
    if (param_list == null) {
        System.err.println("Error: GatePOSTag request had no paramList.");
        return result;  // Return the empty result
    }

    // Process the request parameters
    Set annTypes = new HashSet();
    Element param = (Element) param_list.getFirstChild();
    while (param != null) {
        // Identify the annotation types desired
        if (param.getAttribute(GSXML.NAME_ATT).equals("annotationType")) {
        String annotation_type = GSXML.getValue(param);
        String [] types = annotation_type.split(",");
        for (int i=0; i<types.length; i++) {
            annTypes.add(types[i]);
        }
        }

        param = (Element) param.getNextSibling();
    }

    // Get the request content 
        Element doc_node_list = (Element) GSXML.getChildByTagName(request, GSXML.DOC_NODE_ELEM+GSXML.LIST_MODIFIER);
    if (doc_node_list == null) {
        System.err.println("Error: GatePOSTag request specified no doc nodes.");
        return result;  // Return the empty result
    }

    // Process each document node in the list
    NodeList doc_nodes = doc_node_list.getChildNodes();
    for (int i = 0; i < doc_nodes.getLength(); i++) {
        Element doc_node = (Element) doc_nodes.item(i);
        Element content = (Element) GSXML.getChildByTagName(doc_node, "nodeContent");
        Node content_text = (Node) GSXML.getNodeTextNode(content);
        String text = content_text.getNodeValue();

        // GATE needs the text to be a valid HTML file
        text = "<html><head></head><body>" + text + "</body></html>";
        String annotated_text = processText(text, annTypes);

        // Remove the surrounding HTML tags
        annotated_text = annotated_text.substring(49, annotated_text.length() - 13);
        // System.out.println("GATE result:\n" + annotated_text);

        annotated_text = "<nodeContent>" + annotated_text + "</nodeContent>";
        Element annotated_content = converter_.getDOM(annotated_text).getDocumentElement();
        doc_node.replaceChild(doc_node.getOwnerDocument().importNode(annotated_content, true), content);
    }

    result.appendChild(doc_.importNode(doc_node_list, true));
    // System.out.println("GatePOSTag result:\n" + converter_.getPrettyString(result));
    return result;
    }


    public String processText(String text, Set annotationTypesToExport)
    {
    try {
        // Create a new document containing the text
        FeatureMap parameters = Factory.newFeatureMap();
        parameters.put("stringContent", text);
        parameters.put("markupAware", new Boolean(true));
        parameters.put("preserveOriginalContent", new Boolean(true));
        parameters.put("collectRepositioningInfo", new Boolean(true));
        Document doc = (Document) Factory.createResource("gate.corpora.DocumentImpl",
                                 parameters);

        // Add it to the corpus
        corpus_.clear();
        corpus_.add(doc);

        // Process the corpus
        application_.execute();

        // Extract all the annotations
        AnnotationSet annSet = doc.getAnnotations();

        // Return the desired annotations
        AnnotationSet outputAnnotations = annSet.get(annotationTypesToExport);
        String result = doc.toXml(outputAnnotations, false);
        Factory.deleteResource(doc);

        // 1. Escape the GATE result
        result = GSXML.xmlSafe(result);

        // 2. Unescape the annotation tags
        Iterator setIterator = annotationTypesToExport.iterator();
        while (setIterator.hasNext()) {
        String annotationType = (String) setIterator.next();
        result = result.replaceAll("&lt;" + annotationType + "&gt;",
                       "<annotation type=\"" + annotationType + "\">");
        result = result.replaceAll("&lt;/" + annotationType + "&gt;",
                       "</annotation>");
        }

        return result;
    }
    catch (Exception e) {
        e.printStackTrace();
        return null;
    }
    }
}