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

/*
 *    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_TAG_SERVICE = "GateTag";

    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...");
    this.config_info = info;

    // set up short_service_info_ - for now just has name and type
    Element tag_service = this.doc.createElement(GSXML.SERVICE_ELEM);
    tag_service.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_ENRICH);
    tag_service.setAttribute(GSXML.NAME_ATT, GATE_TAG_SERVICE);
    this.short_service_info.appendChild(tag_service);


    // 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());
        this.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
        this.corpus = Factory.newCorpus("GSDL3 Corpus");
        this.application.setCorpus(this.corpus);
    }
    catch (Exception e) {
        e.printStackTrace();
    }

    return true;
    }

    protected Element getServiceDescription(String service, String lang, String subset) {

    if (!service.equals(GATE_TAG_SERVICE)) {
        return null;
    }
    Element tag_service = this.doc.createElement(GSXML.SERVICE_ELEM);
    tag_service.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_ENRICH);
    tag_service.setAttribute(GSXML.NAME_ATT, GATE_TAG_SERVICE);
    if (subset==null || subset.equals(GSXML.DISPLAY_TEXT_ELEM)) {
        tag_service.appendChild(GSXML.createDisplayTextElement(this.doc, GSXML.DISPLAY_TEXT_NAME, getTextString(service+".name", lang)));
        tag_service.appendChild(GSXML.createDisplayTextElement(this.doc, GSXML.DISPLAY_TEXT_DESCRIPTION, getTextString(service+".description", lang)));
        tag_service.appendChild(GSXML.createDisplayTextElement(this.doc, GSXML.DISPLAY_TEXT_SUBMIT, getTextString(service+".submit", lang)));
    } 
    if (subset==null || subset.equals(GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER)) {
        Element param_list = this.doc.createElement(GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
        createParameter(ANNOTATION_TYPE_PARAM, param_list, lang);
        tag_service.appendChild(param_list);
    }
    return tag_service;
    }


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

    if (name.equals(ANNOTATION_TYPE_PARAM)) {
        int len = this.annotation_types.length;
        String[] annotation_type_names = new String[len];
        for (int i = 0; i < len; i++) {
        annotation_type_names[i] = getTextString("param." + name + "." + this.annotation_types[i], lang);
        }
        
        param = GSXML.createParameterDescription(this.doc, name, getTextString("param." + name, lang), GSXML.PARAM_TYPE_ENUM_MULTI, this.annotation_types[0], this.annotation_types, annotation_type_names);
        param_list.appendChild(param);
    }
    
    }
    
    
    protected Element processGateTag(Element request)
    {
    // System.out.println("(GateTag) Request:\n" + converter_.getPrettyString(request));

    // Create a new (empty) result message
    Element result = this.doc.createElement(GSXML.RESPONSE_ELEM);
    result.setAttribute(GSXML.FROM_ATT, GATE_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: GateTag 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: GateTag 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>";
        Document annotated_content_doc = this.converter.getDOM(annotated_text);
        if (annotated_content_doc != null) {
        Element annotated_content = annotated_content_doc.getDocumentElement();
        doc_node.replaceChild(doc_node.getOwnerDocument().importNode(annotated_content, true), content);
        } else {
        System.err.println("GATEServices.processGateTag Error: Couldn't parse annotated text for doc node "+i);
        }
        
    }

    result.appendChild(this.doc.importNode(doc_node_list, true));
    // System.out.println("GateTag 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
        this.corpus.clear();
        this.corpus.add(doc);

        // Process the corpus
        this.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;
    }
    }
}