[csms-cvs] csms-core/src/java/org/fanfoot/scoring Event.java,NONE,1.1 EventParser.java,NONE,1.1 Even

SourceForge Headquarters 1320 Columbia Street Suite 310 San Diego, CA 92101 +1 (858) 422-6466

Update of /cvsroot/csms/csms-core/src/java/org/fanfoot/scoring
In directory usw-pr-cvs1:/tmp/cvs-serv10082/java/org/fanfoot/scoring

Added Files:
	Event.java EventParser.java EventParserConfiguration.java 
	EventParserConfigurationException.java 
	EventParserListener.java EventPattern.java Events.java 
	Scores.java ScoringConfiguration.java 
	ScoringConfigurationException.java 
Log Message:
Initial auto scoring application import

--- NEW FILE: Event.java ---
/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is Community Sports Management System.
 *
 * The Initial Developer of the Original Code is
 * We know What you Want.net
 *
 * Portions created by the Initial Developer are Copyright (C) 2002
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *
 * Ross Gardler <ross [at] saafe.org>
 * Mike Lever <mikel [at] fanfoot.com>
 * Stuart Gardler <stuart [at] wkwyw.net>
 *
 * ***** END LICENSE BLOCK ***** */

/*
 * Event.java
 *
 * Created on 20 September 2002, 21:59
 */
package org.fanfoot.scoring;

import java.util.Enumeration;
import java.util.Hashtable;
import javax.xml.parsers.ParserConfigurationException;
import org.saafe.utils.XMLUtils;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Text;
import java.util.logging.Logger;
import java.util.logging.Level;

/**
 * An event in a live game that may have an impact on the fantasy game
 * @author  rgardler
 */
public class Event {
    /** Holds value of property src which indicates where this event record came from. */
    private String src = "";

    /** Holds value of property type. */
    private String type = "";

    /** The parts describing this event */
    Hashtable parts = new Hashtable();

    /** Holds value of property UID. */
    private String UID = "";

    final Logger logger = Logger.getLogger("org.fanfoot.scoring");

    /** Creates a new instance of Event of the type indicated
     * @param strType the type of this event
     * @param strGroupUID a unique identifier for the group of events that
     *this event belongs to. From this a unique event identifier will be
     *created.
     */
    public Event(String strType) {
        this.setType(strType);
    }

    /** Getter for property src.
    * @return Value of property src.
    *
    */
    public String getSrc() {
        return this.src;
    }

    /** Setter for property src.
     * @param src New value of property src.
     *
     */
    public void setSrc(String src) {
        this.src = src;
    }

    /** Getter for property type.
     * @return Value of property type.
     *
     */
    public String getType() {
        return this.type;
    }

    /** Setter for property type.
     * @param type New value of property type.
     *
     */
    public void setType(String type) {
        this.type = type;
    }

    /**
     * Get the part of the event named.
     * @param strPart name of the part required
     * @return value of the part requested
     */
    public String getPart(String strPart) {
        return (String) parts.get(strPart);
    }

    /**
     * Add the named part and value to the collection of parts.
     * @param strName name of the part, nulls are converted to an empty string
     * @param strValue value of the part
     */
    public void putPart(String strName, String strValue) {
        if (strValue == null) 
            strValue = "";
        parts.put(strName, strValue);
    }

    /**
     * Get all the parts for this event.
     * @retrun Hashtable containing all the parts, indexed by part name
     */
    public Hashtable getParts() {
        return this.parts;
    }

    /**
     * Get all part names for this event.
     * @return the part names present in this event
     */
    public Enumeration getPartNames() {
        return parts.keys();
    }

    /** Return an XML DOM representation of this event
     * @return Document XML DOM representation of this event
     */
    public Document toXMLDoc() throws ParserConfigurationException {
        logger.entering("org.fanfoot.scoring.Event", "toXMLDoc()");

        Document doc = XMLUtils.createXMLDoc();
        appendXMLTo(doc);

        logger.finest("Root element of document is named " + doc.getDocumentElement().getNodeName());
        logger.exiting("org.fanfoot.scoring.Event", "toXMLDoc()");
        return doc;
    }

    /** Append this event as a DOM node to the supplied XMl Docmuent.
     * @param doc the document to append to
     */
     public void appendXMLTo(Document doc) {
        Element root = doc.createElement("event");
        if (doc.getDocumentElement() == null) {
            doc.appendChild(root);
        } else {
            doc.getDocumentElement().appendChild(root);
        }

        Element elem = doc.createElement("uid");
        Text text = doc.createTextNode(this.getUID());
        elem.appendChild(text);
        root.appendChild(elem);

        elem=doc.createElement("type");
        text = doc.createTextNode(this.getType());
        elem.appendChild(text);
        root.appendChild(elem);

        elem=doc.createElement("src");
        text = doc.createTextNode(this.getSrc());
        elem.appendChild(text);
        root.appendChild(elem);

        Enumeration enuPartNames = this.getPartNames();
        String strPartName;
        String strPartValue;
        while (enuPartNames.hasMoreElements()) {
            strPartName = (String)enuPartNames.nextElement();
            strPartValue = this.getPart(strPartName);
            elem = doc.createElement(strPartName);
            if (strPartValue != "") {
                text = doc.createTextNode(strPartValue);
                elem.appendChild(text);
            }
            root.appendChild(elem);
        }  
     }

    /** Getter for property UID.
     * @return Value of property UID.
     *
     */
    public String getUID() {
        return this.UID;
    }

    /** Setter for property UID.
     * @param UID New value of property UID.
     *
     */
    public void setUID(String UID) {
        this.UID = UID;
    }

}

--- NEW FILE: EventParser.java ---
/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is Community Sports Management System.
 *
 * The Initial Developer of the Original Code is
 * We know What you Want.net
 *
 * Portions created by the Initial Developer are Copyright (C) 2002
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *
 * Ross Gardler <ross [at] saafe.org>
 * Mike Lever <mikel [at] fanfoot.com>
 * Stuart Gardler <stuart [at] wkwyw.net>
 *
 * ***** END LICENSE BLOCK ***** */

/*
 * EventParser.java
 *
 * Created on 21 September 2002, 11:51
 */
package org.fanfoot.scoring;

import java.io.File;
import java.io.IOException;

import java.net.MalformedURLException;
import java.net.URL;

import java.util.ArrayList;
import java.util.EventObject;
import java.util.Vector;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.regex.Matcher;

import org.saafe.utils.XMLUtils;

import org.w3c.dom.Document;

/**
 * Parsers a file looking for events that may be important in a fantasy game.
 * Creates a set of Event objects from a given commentary/statistics file.
 * @author  rgardler
 */
public class EventParser {
    /** Holds value of property conf. */
    private EventParserConfiguration conf;
    final Logger logger = Logger.getLogger("org.fanfoot.scoring");
    private Vector listeners = new Vector(); // list of Listeners
    private Document docCommentary = null; // the original commentary document

    /** Creates a new instance of EventParser 
     */
    public EventParser() {
        super();
    }

    /** Creates a new instance of EventParser 
     * @param strURL the url of the configuration file for this parser
     * @throws EventParserConfigurationException
     */
    public EventParser(String strURL) throws EventParserConfigurationException {
        super();
        conf = new EventParserConfiguration(strURL);
    }

    /**
     * Parse the supplied resource
     * @param strURL the URL of the resource to parse
     * @param strType the type of resource this is (this corresponds
     * to the sourceType element of the matcher element in the config file
     * @return Events found in the resource
     */
    public Events parse(String strURL, String strType)
                 throws MalformedURLException, IOException, 
                        EventParserConfigurationException {
        URL url = new URL(strURL);

        return parse(url, strType);
    }

    /**
     * Parse the supplied file
     * @param file the file to parse
     * @param strType the type of resource this is (this corresponds
     * to the sourceType element of the matcher element in the config file
     * @return Events found in the resource
     */
    public Events parse(File file, String strType) throws IOException, 
                                                          EventParserConfigurationException {
        return parse(file.toURL(), strType);
    }

    /**
    * Parse the supplied resource
    * @param url the URL of the resource to parse
    * @param strType the type of resource this is (this corresponds
    * to the sourceType element of the matcher element in the config file
    * @return Events found in the resource
    */
    public Events parse(URL url, String strType) throws MalformedURLException, 
                                                        IOException, 
                                                        EventParserConfigurationException {
        docCommentary = XMLUtils.loadTidiedHTML(url);
        this.notifyRetrievedCommentary();

        StringBuffer sbData = new StringBuffer();
        XMLUtils.appendAllText(docCommentary.getDocumentElement(), sbData);

        String strData = sbData.toString();
        logger.finest("Live Data: " + strData);

        ArrayList patterns = conf.getPatternsForType(strType);

        Events evtsResult = new Events();
        String strEventsUID = parseEventsUID(strData, strType);
        evtsResult.setUID(strEventsUID);
        logger.info("UID for these events is: " + strEventsUID);

        Events evtsCurrent;
        EventPattern p;

        logger.info("Start processing " + patterns.size() + 
                    " event patterns.");

        for (int i = 0; i < patterns.size(); i++) {
            p = (EventPattern) patterns.get(i);
            evtsCurrent = processEvents(p, strData);

            if (evtsCurrent != null) {
                evtsResult.addAll(evtsCurrent, this.conf);
            }
        }

        return evtsResult;
    }

    /**
     * Extract all events matched by the supplied pattern in
     * the supplied textual data.
     * @param p Pattern matching the event
     * @param strData the data to look for events in
     * @return Events matched by the pattern
     */
    private Events processEvents(EventPattern p, String strData) {
        logger.entering("org.fanfoot.scoring.EventParser", 
                        "processEvents(eventPattern, strData)");

        Events evts = new Events();
        Matcher m = p.getRegexPattern().matcher(strData);
        String strPartValue;
        String strPartName;

        logger.finest("Looking for matches of type " + p.getType() + " (RE=" + 
                      p.getRegexPattern().pattern() + ")");

        while (m.find()) {
            logger.fine("Matched event in: " + m.group());

            Event evt = new Event(p.getType());

            // Extract the event parts and store them in the event object
            logger.finest("There are " + m.groupCount() + 
                          " groups in the match");

            for (int i = 1; i <= m.groupCount(); i++) {
                strPartValue = m.group(i).trim();
                strPartName = p.getPartName(i);
                evt.putPart(strPartName, strPartValue);
                logger.finest("Set " + strPartName + " to " + strPartValue + 
                              " (part #" + i + ")");
            }

            logger.fine("Added event of type " + p.getType());
            evts.add(evt);
        }

        logger.exiting("org.fanfoot.scoring.EventParser", 
                       "processEvents(eventPattern, strData)");

        return evts;
    }

    /** Create a Unique Identifier for a set of Events held in the
     * supplied game data string. This is done by matching the 
     * Regular Expression
     * in the UID child element of the events root element in the parser
     * configuration file.
     * @param strData the game data
     * @para, strType the type of data supplied
     * @returns String UID for this set of events
     * @throws EventParserConfigurationException
     */
    public String parseEventsUID(String strData, String strType)
                          throws EventParserConfigurationException {
        StringBuffer sb = new StringBuffer();
        Matcher m;

        logger.entering("org.fanfoot.scoring.EventParser", 
                        "parseEventUID(strData, strType");

        // get the UID element
        EventPattern uidPattern = this.conf.getEventsUIDPattern(strType);
        m = uidPattern.getRegexPattern().matcher(strData);
        logger.finest("UID pattern is " + 
                      uidPattern.getRegexPattern().pattern());

        // get the UID parts
        while (m.find()) {
            // Extract the UID parts and build the UID
            for (int i = 1; i <= m.groupCount(); i++) {
                sb.append('_');
                sb.append(m.group(i).trim());
            }
        }

        logger.exiting("org.fanfoot.scoring.EventParser", 
                       "parseEventUID(strData, strType");

        // concatenate the parts
        return sb.toString();
    }

    /** Getter for property conf.
    * @return Value of property conf.
    *
    */
    public EventParserConfiguration getConfiguration() {
        return this.conf;
    }

    /** Setter for property conf.
     * @param conf New value of property conf.
     *
     */
    public void setConfiguration(EventParserConfiguration conf) {
        this.conf = conf;
    }

    /** Load the configuration file indicated.
    * @param strConf URL from which to load configuration file
    *
    */
    public void loadConfiguration(String strConf)
                           throws EventParserConfigurationException {
        EventParserConfiguration conf = new EventParserConfiguration(strConf);
        setConfiguration(conf);
    }

    public synchronized void addListener(EventParserListener epl) {
        Vector v = (Vector) listeners.clone();
        v.addElement(epl);
        listeners = v;
    }

    public synchronized void removeListener(EventParserListener epl) {
        Vector v = (Vector) listeners.clone();
        v.removeElement(epl);
        listeners = v;
    }

    protected void notifyRetrievedCommentary() {
        logger.entering("org.fanfoot.scoring.EventParser", "notifyRetrievedCommentary()");
        Vector l;
        EventObject e = new EventObject(this);
        l = listeners; // Atomic assignment

        EventParserListener epl = null;
        for (int i = 0; i < l.size(); i++) {
            epl = (EventParserListener) l.elementAt(i);
            epl.retrievedCommentary(e);
        }
        logger.entering("org.fanfoot.scoring.EventParser", "notifyRetrievedCommentary()");
    }

    /**
     * Return the source code of the currently loaded commentary.
     * @return string containing the source code for the current commentary
     */
    public String getCommentarySource() {
        String strCommentary;
        try {
            strCommentary = XMLUtils.xmlToString(docCommentary);
        } catch (javax.xml.transform.TransformerConfigurationException tce) {
            logger.log(Level.WARNING, "Unable to convert commentary document to string", tce);
            strCommentary = "ERROR: Unable to convert commentary document to a string du to a Transformer Configuration problem";
        } catch (javax.xml.transform.TransformerException te) {
            logger.log(Level.WARNING, "Unable to convert commentary document to string", te);
            strCommentary = "ERROR: Unable to convert commentary document to a string du to a Transformer problem";
        }
        return strCommentary;
    }
}

--- NEW FILE: EventParserConfiguration.java ---
/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is Community Sports Management System.
 *
 * The Initial Developer of the Original Code is
 * We know What you Want.net
 *
 * Portions created by the Initial Developer are Copyright (C) 2002
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *
 * Ross Gardler <ross [at] saafe.org>
 * Mike Lever <mikel [at] fanfoot.com>
 * Stuart Gardler <stuart [at] wkwyw.net>
 *
 * ***** END LICENSE BLOCK ***** */

/*
 * EventParserConfiguration.java
 *
 * Created on 21 September 2002, 11:27
 */
package org.fanfoot.scoring;

import java.io.IOException;

import java.util.ArrayList;
import java.util.logging.Level;
import java.util.logging.Logger;

import javax.xml.parsers.ParserConfigurationException;

import org.apache.commons.jxpath.JXPathContext;

import org.apache.xpath.XPathAPI;

import org.saafe.utils.XMLUtils;

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

import org.xml.sax.SAXException;

/**
 * Reads an XML configuration file and builds a set of
 * Regular Expressions that are used to extract information from
 * a commentary/statistics resource.
 *
 * @author  rgardler
 */
public class EventParserConfiguration {
    Document confDocument;
    final Logger logger = Logger.getLogger("org.fanfoot.scoring");

    /** 
     * Creates a new instance of EventParserConfiguration 
     * using the indicated configuration file
     * @param strURL the URL of the configuration file to use
     */
    public EventParserConfiguration(String strURL)
                             throws EventParserConfigurationException {
        super();

        try {
            loadConfigFile(strURL);
        } catch (Exception e) {
            logger.log(Level.WARNING, 
                       "Problem loading parser config file " + strURL, e);
            throw new EventParserConfigurationException(
                    "Problem loading parser config file " + strURL + " " + e);
        }
    }

    /**
     * Read the comfiguration file indicated.
     * @param strURL the URL of the cofiguration file
     */
    private void loadConfigFile(String strURL)
                         throws ParserConfigurationException, DOMException, 
                                SAXException, IOException {
        confDocument = XMLUtils.parseXML(strURL);
    }

    /**
     * Get all patterns in the config file for a source of the indicated type.
     * @param String strSourceType Name indicating the value of the 
     * sourceType element of the requiered Patterns
     * @returns an arraylist of the patterns. Patterns are represented as 
     * java.util.regex.Patterns
     */
    public ArrayList getPatternsForType(String strSourceType) {
        NodeList ndl = confDocument.getElementsByTagName("pattern");

        // iterate over all the tags keeping only those that have a child
        // sourceType element with the value strSourceType
        ArrayList patterns = new ArrayList();
        Node node;

        for (int i = 0; i < ndl.getLength(); i++) {
            node = ndl.item(i);

            JXPathContext context = JXPathContext.newContext(node);

            if (context.getValue("/sourceType").equals(strSourceType)) {
                if (node.getParentNode().getNodeName().equals("event")) {
                    patterns.add(new EventPattern(node));
                }
            }
        }

        return patterns;
    }

    /** Get an Iterator of part names that are used to identify duplicate
     * events of the given type. If no duplicateDetection element exists then
     * an empty iterator will be returned.
     * @param strType the type we are considering
     */
    public java.util.Iterator getDuplicateDetectionParts(String strType) {
        JXPathContext context = JXPathContext.newContext(confDocument);
        java.util.Iterator it = context.iterate("/events/event[@type='" + strType + "']/duplicateDetection/part/@name");

        return it;
    }

    /**
     * Get the pattern for extracting the UID of the Events group
     * this configuration file is for.
     * @param strSourceType the source type we want to use
     * @return the event pattern for the UID
     * @throws EventParserConfigurationException
     * @refactor Precompile the XPath statements to improve speed
     */
    public EventPattern getEventsUIDPattern(String strSourceType)
                                     throws EventParserConfigurationException {
        String strXPathStatement = "/events/UID/pattern";
        EventPattern pattern = null;
        Node node = null;

        logger.finest("Node name of conf document element " + 
                      confDocument.getDocumentElement().getNodeName());

        try {
            node = XPathAPI.selectSingleNode(confDocument.getDocumentElement(), 
                                             strXPathStatement);
        } catch (Exception e) {
            throw new EventParserConfigurationException(
                    "Problem finding events UID pattern", e);
        }

        if (node != null) {
            pattern = new EventPattern(node);
            logger.finest("Node name returned by XPath statement (" + 
                          strXPathStatement + ") is " + node.getNodeName());
        } else {
            logger.finest("No node returned by XPath statement (" + 
                          strXPathStatement + ")");
        }

        return pattern;
    }
}

--- NEW FILE: EventParserConfigurationException.java ---
/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is Community Sports Management System.
 *
 * The Initial Developer of the Original Code is
 * We know What you Want.net
 *
 * Portions created by the Initial Developer are Copyright (C) 2002
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *
 * Ross Gardler <ross [at] saafe.org>
 * Mike Lever <mikel [at] fanfoot.com>
 * Stuart Gardler <stuart [at] wkwyw.net>
 *
 * ***** END LICENSE BLOCK ***** */

/*
 * EventParserConfigurationError.java
 *
 * Created on 21 September 2002, 11:41
 */
package org.fanfoot.scoring;

/**
 *
 * @author  rgardler
 */
public class EventParserConfigurationException extends java.lang.Exception {

    Exception root = null;

    /**
     * Creates a new instance of <code>EventParserConfigurationError</code> without detail message.
     */
    public EventParserConfigurationException() {
    }

    /**
     * Constructs an instance of <code>EventParserConfigurationError</code> with the specified detail message.
     * @param msg the detail message.
     */
    public EventParserConfigurationException(String msg) {
        super(msg);
    }

    /**
     * Constructs an instance of <code>EventParserConfigurationError</code>
     * with the specified detail message
     * and the root exception supplied
     * @param msg the detail message.
     */
    public EventParserConfigurationException(String msg, Exception e) {
        super(msg);
        root = e;
    }
}

--- NEW FILE: EventParserListener.java ---
/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is Community Sports Management System.
 *
 * The Initial Developer of the Original Code is
 * We know What you Want.net
 *
 * Portions created by the Initial Developer are Copyright (C) 2002
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *
 * Ross Gardler <ross [at] saafe.org>
 * Mike Lever <mikel [at] fanfoot.com>
 * Stuart Gardler <stuart [at] wkwyw.net>
 *
 * ***** END LICENSE BLOCK ***** */

/*
 * EventParserListener.java
 *
 * Created on 06 October 2002, 10:00
 */

package org.fanfoot.scoring;

import java.util.EventListener;
import java.util.EventObject;

/**
 * A listener to events generated by EventParser.
 * @see org.fanfoot.scoring.EventParser
 * @author  rgardler
 */
public abstract interface EventParserListener extends EventListener {

    /**
     * Loaded Commentay file.
     */
    public abstract void retrievedCommentary(EventObject e);

}

--- NEW FILE: EventPattern.java ---
/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is Community Sports Management System.
 *
 * The Initial Developer of the Original Code is
 * We know What you Want.net
 *
 * Portions created by the Initial Developer are Copyright (C) 2002
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *
 * Ross Gardler <ross [at] saafe.org>
 * Mike Lever <mikel [at] fanfoot.com>
 * Stuart Gardler <stuart [at] wkwyw.net>
 *
 * ***** END LICENSE BLOCK ***** */

/*
 * Pattern.java
 *
 * Created on 21 September 2002, 16:57
 */
package org.fanfoot.scoring;

import java.util.ArrayList;
import java.util.regex.Pattern;

import java.util.logging.Logger;

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

/**
 * A pattern with which to identify events that may affect fantasy scores
 * in a textual commentary or set of statistics.
 * @author  rgardler
 */
public class EventPattern {
    private Logger logger = Logger.getLogger("org.fanfoot.scoring");

    /** Holds value of property regexPattern which
     * is a regular expression pattern used for matching an event.*/
    private Pattern regexPattern;

    /** Holds value of property capturingGroup which contains the
     * name of each capturing group in the Pattern */
    private ArrayList capturingGroup = new ArrayList();

    /** Holds value of property type. */
    private String type;

    /** Creates a new instance of Pattern 
     * @param node a DOM node taken from a configuration file describing an event pattern
     */
    public EventPattern(Node node) {
        super();

        StringBuffer sb = new StringBuffer();
        String strGroupName;
        String strRE;
        NamedNodeMap atts;
        int idxGroup = 1;
            Node curNode = node.getFirstChild();

        Node childNode;
        while (curNode != null) {
            if (curNode.getNodeName().equals("part")) {
                childNode = curNode.getFirstChild();
                if (childNode.getNodeType() == node.TEXT_NODE) {
                    strRE = childNode.getNodeValue();
                    sb.append('(');
                    sb.append(strRE);
                    sb.append(')');
                    atts = curNode.getAttributes();
                    strGroupName = atts.getNamedItem("name").getNodeValue();
                    this.setCapturingGroup(idxGroup, strGroupName);
                    idxGroup = idxGroup + 1;
                    logger.fine("Added capturing group " + strGroupName + " with RE " + strRE);
                } else {
                    strRE = childNode.getFirstChild().getNodeValue();
                    sb.append('(');
                    sb.append(strRE);
                    sb.append(')');
                    atts = curNode.getAttributes();
                    strGroupName = atts.getNamedItem("name").getNodeValue();
                    this.setCapturingGroup(idxGroup, strGroupName);
                    idxGroup = idxGroup + 1;
                    logger.fine("Added capturing group " + strGroupName + " with RE " + strRE);
                }
            } else if (curNode.getNodeName().equals("unwantedPart")) {
                strRE = curNode.getFirstChild().getNodeValue();
                sb.append(strRE);
                logger.fine("Added non-capturing group with RE " + strRE);
            }

            curNode = curNode.getNextSibling();
        }

        regexPattern = Pattern.compile(sb.toString());

        Node eventNode = node.getParentNode();
        atts = eventNode.getAttributes();

        String strType = atts.getNamedItem("type").getFirstChild()
                             .getNodeValue();
        this.setType(strType);
    }

    /** Getter for property regexPattern.
     * @return Value of property regexPattern.
     *
     */
    public Pattern getRegexPattern() {
        return this.regexPattern;
    }

    /** Setter for property regexPattern.
     * @param regexPattern New value of property regexPattern.
     *
     */
    public void setRegexPattern(Pattern regexPattern) {
        this.regexPattern = regexPattern;
    }

    /** Indexed getter for property capturingGroup.
     * @param index Index of the property.
     * @return Value of the property at <CODE>index</CODE>.
     *
     */
    public String getCapturingGroup(int index) {
        return (String) this.capturingGroup.get(index - 1);
    }

    /** Get the part name for the indicate capturing group
     * @param index Index of the property.
     * @return Value of the property at <CODE>index</CODE>.
     *
     */
    public String getPartName(int index) {
        return getCapturingGroup(index);
    }

    /** Indexed setter for property capturingGroup.
     * @param index Index of the property.
     * @param capturingGroupName New value of the property at <CODE>index</CODE>.
     *
     */
    public void setCapturingGroup(int index, String capturingGroupName) {
        //this.capturingGroup.ensureCapacity(index);
        this.capturingGroup.add(index - 1, capturingGroupName);
    }

    /** Getter for property type.
     * @return Value of property type.
     *
     */
    public String getType() {
        return this.type;
    }

    /** Setter for property type.
     * @param type New value of property type.
     *
     */
    public void setType(String type) {
        this.type = type;
    }
}

--- NEW FILE: Events.java ---
/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is Community Sports Management System.
 *
 * The Initial Developer of the Original Code is
 * We know What you Want.net
 *
 * Portions created by the Initial Developer are Copyright (C) 2002
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *
 * Ross Gardler <ross [at] saafe.org>
 * Mike Lever <mikel [at] fanfoot.com>
 * Stuart Gardler <stuart [at] wkwyw.net>
 *
 * ***** END LICENSE BLOCK ***** */

/*
 * Events.java
 *
 * Created on 20 September 2002, 22:02
 */
package org.fanfoot.scoring;

import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Vector;
import java.util.logging.Logger;

import javax.xml.parsers.ParserConfigurationException;

import org.saafe.utils.XMLUtils;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Text;

/**
 * A collection of Events that have happened in a real game that may
 * affect the fantasy game.
 * @author  rgardler
 * @seeAlso org.fanfoot.scoring.Event
 */
public class Events {
    /** Holds value of property events. */
    private LinkedList events = new LinkedList();

    /** A list of all event types found in this collection */
    private Vector types = new Vector();

    /** Holds value of property uid. */
    private String uid = "";

    /** Holds value of property srcData. */
    private String srcData = "";
    final Logger logger = Logger.getLogger("org.fanfoot.scoring");

    /** Creates a new instance of Events 
     */
    public Events() {
        super();
    }

    /** Creates a new instance of Events 
     * @param strUID a unique identifier for this set of events, must be application unique
     */
    public Events(String strUID) {
        super();
        this.setUID(strUID);
    }

    /** 
     * Get the collection of events
     * @return the collection of events
     *
     */
    public List getEvents() {
        return this.events;
    }

    /** 
     * Get the event at the given index
     * @return the collection of events
     *
     */
    public Event getEvent(int idx) {
        return (Event) this.events.get(idx);
    }

    /** Add the supplied event to the Events list.
    * @param evt The event to add
    */
    public void add(Event evt) {
        if (!this.types.contains(evt.getType())) {
            this.types.add(evt.getType());
        }

        this.events.add(evt);
    }

    /**
     * Get the number of events in this collection.
     * @return int number of events in collection
     */
    public int size() {
        return this.events.size();
    }

    /**
     * Add all the supplied events to this Events collection.
     * @param evts the events to add
     * @param conf the vonfiguration for these events
     */
    public void addAll(Events evts) {
        Iterator iter = evts.getEvents().iterator();

        while (iter.hasNext())
            this.add((Event) iter.next());
    }

    /**
     * Add all the supplied events to this Events collection.
     * FIXME: implement duplicate checking
     * If a duplicate event (as indicated by the events configuration file)
     * is located then the second event is marked as a duplicate and
     * both events are marked as requireing validation.
     * 
     * @param evts the events to add
     * @param conf the vonfiguration for these events
     */
    public void addAll(Events evts, EventParserConfiguration conf) {
        Iterator iter = evts.getEvents().iterator();
        Event evt;

        while (iter.hasNext()) {
            evt = (Event) iter.next();

            if (!contains(evt, conf)) {
                this.add(evt);
            }
        }
    }

    /** Checks to see if this events collection contains the supplied
     * event by checking against the duplicateDetection config in the
     * configuration file.
     * @param evt the event to check for
     * @param conf the event parser configuration 
     * @return true if the events collection contains an identical event allready
     */
    public boolean contains(Event evt, EventParserConfiguration conf) {
        boolean contains = false; // indicates if an element that is equal does NOT exist
        boolean partsAreEqual = true; // indicates if the parts tested so far are equal
        Iterator events = this.getEventsByType(evt.getType()).iterator();
        Event existingEvt;
        Iterator parts;
        String strPart;

        while (events.hasNext() & !contains) {
            parts = conf.getDuplicateDetectionParts(evt.getType());

            if (parts.hasNext()) {
                partsAreEqual = true;
            } else {
                partsAreEqual = false;
            }

            existingEvt = (Event) events.next();
            logger.finest("Checking to see if event type " + existingEvt + 
                          " type (" + existingEvt.getType() + ") equals " + 
                          evt + " type (" + evt.getType() + ")");

            while (parts.hasNext()) {
                strPart = (String) parts.next();
                logger.finest("Checking to see if values for part " + 
                              strPart + " are equal (" + 
                              evt.getPart(strPart) + " = " + 
                              existingEvt.getPart(strPart) + ")");
                partsAreEqual = (evt.getPart(strPart).equals(existingEvt.getPart(
                                                                     strPart))) & 
                                partsAreEqual;
                logger.finest("All parts to date are equal = " + 
                              partsAreEqual);
            }

            contains = partsAreEqual;
        }

        return contains;
    }

    /** Get the names of all event types present
     * @return Enumeration of all event types
     */
    public Enumeration getTypes() {
        return this.types.elements();
    }

    /** Get all events in the collection of the indicated type.
     * @param strType the type of event requried
     * @return an ArrayList of all events of the supplied type
     */
    public ArrayList getEventsByType(String strType) {
        ArrayList result = new ArrayList();
        Event evt; // current event being processes
        Iterator li = events.iterator();

        while (li.hasNext()) {
            evt = (Event) li.next();

            if (evt.getType().equals(strType)) {
                result.add(evt);
            }
        }

        return result;
    }

    /** Getter for property UID.
     * @return Value of property UID.
     *
     */
    public String getUID() {
        return this.uid;
    }

    /** Setter for property UID.
     * @param UID New value of property UID.
     *
     */
    public void setUID(String UID) {
        this.uid = UID;
    }

    /** Getter for property srcData.
     * @return Value of property srcData.
     *
     */
    public String getSrcData() {
        return this.srcData;
    }

    /** Setter for property srcData.
     * @param srcData New value of property srcData.
     *
     */
    public void setSrcData(String srcData) {
        this.srcData = srcData;
    }

    /** Return an XML DOM representation of this event
     * @return Document XML DOM representation of this event
     */
    public Document toXMLDoc() throws ParserConfigurationException {
        Document doc = XMLUtils.createXMLDoc("events");
        Element root = doc.getDocumentElement();
        Element elem = doc.createElement("uid");
        Text text = doc.createTextNode(this.getUID());
        elem.appendChild(text);
        root.appendChild(elem);

        elem = doc.createElement("srcData");
        text = doc.createTextNode(this.getSrcData());
        elem.appendChild(text);
        root.appendChild(elem);

        Enumeration evtTypes = this.getTypes(); // all types of events
        String strType; // type of events currently being processed
        ArrayList typeEvts; // all events of a certain type
        Event evt; // event currently being processed

        while (evtTypes.hasMoreElements()) {
            strType = (String) evtTypes.nextElement();
            typeEvts = this.getEventsByType(strType);

            for (int i = 0; i < typeEvts.size(); i++) {
                evt = (Event) typeEvts.get(i);
                evt.appendXMLTo(doc);
            }
        }

        return doc;
    }
}

--- NEW FILE: Scores.java ---
/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is Community Sports Management System.
 *
 * The Initial Developer of the Original Code is
 * We know What you Want.net
 *
 * Portions created by the Initial Developer are Copyright (C) 2002
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *
 * Ross Gardler <ross [at] saafe.org>
 * Mike Lever <mikel [at] fanfoot.com>
 * Stuart Gardler <stuart [at] wkwyw.net>
 *
 * ***** END LICENSE BLOCK ***** */

/*
 * calculator.java
 *
 * Created on 24 September 2002, 13:21
 */
package org.fanfoot.scoring;

import java.util.logging.Level;
import java.util.logging.Logger;

import org.saafe.utils.XMLUtils;

import org.w3c.dom.Document;

/**
 * Calculates the score for each <code>Event</code> in a given events
 * collection.
 * @author  rgardler
 */
public class Scores {
    static final Logger logger = Logger.getLogger("org.fanfoot.scoring");

    /** Holds value of property events. */
    private Events events;

    /** Holds value of property conf. */
    private ScoringConfiguration conf;

    /** The document holding the scores. */
    private Document scoresDocument;

    /** Creates a new instance of calculator 
     * @parm evts the events to calculate the score from
     * @throws ScoringConfigurationException if unable to calculate scores
     */
    public Scores(Events evts, ScoringConfiguration sc)
           throws ScoringConfigurationException {
        this.setEvents(evts);
        this.setConfiguration(sc);
        this.calculate();
    }

    /** Getter for property events.
     * @return Value of property events.
     *
     */
    public Events getEvents() {
        return this.events;
    }

    /** Setter for property events.
     * @param events New value of property events.
     *
     */
    public void setEvents(Events events) {
        this.events = events;
    }

    /** Getter for property conf.
     * @return Value of property conf.
     *
     */
    public ScoringConfiguration getConfiguration() {
        return this.conf;
    }

    /** Setter for property conf.
     * @param conf New value of property conf.
     *
     */
    public void setConfiguration(ScoringConfiguration conf) {
        this.conf = conf;
    }

    /** Calculate the scores.
     * @return DOM document representing the scores
     * @throws ScoringConfigurationException if unalb to calculate scores
     */
    public Document calculate() throws ScoringConfigurationException {
        logger.entering("org.fanfoot.scoring.scores", "calculate()");

        Document doc = null;

        try {
            logger.finest("Events document root element is named " + 
                          getEvents().toXMLDoc().getDocumentElement().getNodeName());
            doc = XMLUtils.transform(getEvents().toXMLDoc(), 
                               getConfiguration().getXSL());
        } catch (Exception e) {
            logger.log(Level.WARNING, "Unable to calculate scores", e);
            throw new ScoringConfigurationException(
                    "Unable to calculate scores", e);
        }

        setScoresDocument(doc);

        logger.finest("Scores document root element is named " + 
                      getScoresDocument().getDocumentElement().getNodeName());
        logger.exiting("org.fanfoot.scoring.scores", "calculate()");

        return doc;
    }

    /** Getter for property scoresDocument.
     * @return Value of property scoresDocument.
     *
     */
    public Document getScoresDocument() {
        return this.scoresDocument;
    }

    /** Setter for property scoresDocument.
     * @param scoresDocument New value of property scoresDocument.
     *
     */
    public void setScoresDocument(Document scoresDocument) {
        this.scoresDocument = scoresDocument;
    }
}

--- NEW FILE: ScoringConfiguration.java ---
/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is Community Sports Management System.
 *
 * The Initial Developer of the Original Code is
 * We know What you Want.net
 *
 * Portions created by the Initial Developer are Copyright (C) 2002
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *
 * Ross Gardler <ross [at] saafe.org>
 * Mike Lever <mikel [at] fanfoot.com>
 * Stuart Gardler <stuart [at] wkwyw.net>
 *
 * ***** END LICENSE BLOCK ***** */

/*
 * ScoreConfiguration.java
 *
 * Created on 24 September 2002, 13:26
 */

package org.fanfoot.scoring;

import java.util.logging.Logger;
import java.util.logging.Level;

/**
 * A score configuration manages how scores are calculated from
 * events. This class is simply a wrapper for an XSL document
 * that is used to transfore the XML representation of a set
 * of <code>Events</code> into another XML document representing
 * the scores generated from those events.
 * @author  rgardler
 */
public class ScoringConfiguration {

    /** Holds value of property xSLURL. */
    private String xSLURL;

    static final Logger logger = Logger.getLogger("org.fanfoot.scoring");

    /** Creates a new instance of ScoreConfiguration 
     * @param strURL the url of the XSL stylesheet to generate scores from <code>Events</code>
     */
    public ScoringConfiguration(String strURL) {
        this.xSLURL = strURL;
    }

    /** Getter for property xSLURL.
     * @return Value of property xSLURL.
     *
     */
    public String getXSLURL() {
        return this.xSLURL;
    }

    /** Setter for property xSLURL.
     * @param xSLURL New value of property xSLURL.
     *
     */
    public void setXSLURL(String xSLURL) {
        this.xSLURL = xSLURL;
    }

    /**
     * Get XSL Document that is used to transform <code>Events</code> 
     * DOM documents into a score DOM document.
     * @return scores as a dom Document
     * @throws ScoringConfigurtionException if unable to load the XSL file
     * @refactor many times the XSL will not have changed so there is no need
     * to relod the document. Cache it here.
     */
    public org.w3c.dom.Document getXSL() throws ScoringConfigurationException {
        org.w3c.dom.Document doc;
        try {
            doc = org.saafe.utils.XMLUtils.parseXML(xSLURL);
        } catch (javax.xml.parsers.ParserConfigurationException pce) {
            logger.log(Level.WARNING, "Unable to parse scoring XSL", pce);
            throw new ScoringConfigurationException("Unable to parse scoring XSL", pce);
        } catch ( org.xml.sax.SAXException se) {
            logger.log(Level.WARNING, "Unable to parse scoring XSL", se);
            throw new ScoringConfigurationException("Unable to parse scoring XSL", se);
        } catch (java.io.IOException ioe) {
            logger.log(Level.WARNING, "Unable to parse scoring XSL", ioe);
            throw new ScoringConfigurationException("Unable to parse scoring XSL", ioe);
        }

        return doc;
    }
}

--- NEW FILE: ScoringConfigurationException.java ---
/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is Community Sports Management System.
 *
 * The Initial Developer of the Original Code is
 * We know What you Want.net
 *
 * Portions created by the Initial Developer are Copyright (C) 2002
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *
 * Ross Gardler <ross [at] saafe.org>
 * Mike Lever <mikel [at] fanfoot.com>
 * Stuart Gardler <stuart [at] wkwyw.net>
 *
 * ***** END LICENSE BLOCK ***** */

/*
 * ScoringConfigurationException.java
 *
 * Created on 24 September 2002, 13:37
 */

package org.fanfoot.scoring;

/**
 *
 * @author  rgardler
 */
public class ScoringConfigurationException extends java.lang.Exception {

    Exception root = null;

    /**
     * Creates a new instance of <code>ScoringConfigurationException</code> without detail message.
     */
    public ScoringConfigurationException() {
    }

    /**
     * Constructs an instance of <code>ScoringConfigurationException</code> with the specified detail message.
     * @param msg the detail message.
     */
    public ScoringConfigurationException(String msg) {
        super(msg);
    }

    /**
     * Constructs an instance of <code>ScoringConfigurationError</code>
     * with the specified detail message
     * and the root exception supplied
     * @param msg the detail message.
     */
    public ScoringConfigurationException(String msg, Exception e) {
        super(msg);
        root = e;
    }
}