source: trunk/gsdl3/src/java/org/greenstone/gsdl3/gs3build/metadata/METSStructure.java@ 8742

package org.greenstone.gsdl3.gs3build.metadata;

import java.io.PrintWriter;

import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.LinkedHashMap;
import java.util.Iterator;

import java.sql.SQLException;
import java.sql.ResultSet;

import org.w3c.dom.Element;
import org.w3c.dom.NodeList;

import org.greenstone.gsdl3.gs3build.doctypes.DocumentInterface;

import org.greenstone.gsdl3.gs3build.util.XMLTools;
import org.greenstone.gsdl3.gs3build.database.*;

public class METSStructure extends AbstractStructure
{
    String label;
    String type;
    METSDivision divGroup;

    public static final String STRUCTURE_TYPE = "Structure";
  
    public METSStructure(String id, String label, String type)
    { 
    super(id);
    
    this.label    = label;
    this.type     = type;
    this.divGroup = null;
    }

    /**
     *  Show what sort of <code>AbstractStructure</code> this structure is...
     *
     *  @return <code>String The identifying string for a <code>METSStructure</code> type.
     */
    public String getStructureType()
    { return STRUCTURE_TYPE;
    }
  
    /**
     *  Find all the divisions that match a given list of file group
     *  identifiers...
     *
     *  @param <code>List</code> the list of identifiers to find
     *  @param <code>List</code> the list into which to place any
     *         matching identifiers.
     */
    public void findDivisionsForFiles(List listOfFileIdentifiers, List resultList)
    { Iterator groups = this.children.values().iterator();
    while (groups.hasNext())
    { METSDivision group = (METSDivision) groups.next();

    group.findDivisionsForFiles(listOfFileIdentifiers, resultList);
    }    
    }

    /**
     *  Add a division further into this structure.
     *
     *  @param <code>String</code> the identifier label for the division
     *         within which the division is to be added.
     *  @param <code>METSDivision</code> the division to add.   
     */
    public void addSubDivision(String divisionLabel, METSDivision division)
    { String topDivision = METSDivision.getTopDivisionName(divisionLabel);

    METSDivision child = (METSDivision) this.children.get(topDivision);
    if (child == null)
    { return;
    }

    child = child.getDivision(divisionLabel);

    if (child != null) {
    child.addDivision(division);
    }
    }

    /**
     *  Get a subdivision of a given identifier...
     * 
     *  @param <code>String</code> the identifier of the division
     *  @return <code>METSDivision</code> the division, which will be
     *          <code>null</code> if it is not found.
     */
    public METSDivision getDivision(String divisionLabel)
    { String topDivision = METSDivision.getTopDivisionName(divisionLabel);

    if (!topDivision.equals("All"))
    System.out.println("Top division is " + topDivision);
    METSDivision child = (METSDivision) this.children.get(topDivision);
    if (child == null)
    { System.out.println("No child found");
    Iterator groups = this.children.keySet().iterator();
    while (groups.hasNext()) {
        System.out.println(groups.next().toString());
    }
    return null;
    }


    child = child.getDivision(divisionLabel);

    return child;
    }


    /*
     *
     * parse an XML Element as a METSStructure Section
     *
     * @param <code>Element</code> the XML element which represents
     *  the mets:structMap itself 
     */
    
    public static METSStructure parseXML(Element element) 
    {
    String structId = element.getAttribute("ID");
    String structLabel = element.getAttribute("LABEL");
    String structType = element.getAttribute("TYPE");
 
    METSStructure thisStruct = new METSStructure (structId, structLabel, structType);
    
    NodeList divSecs = element.getChildNodes();
    if (divSecs != null) {
        for (int c = 0; c < divSecs.getLength(); c++) {
        if (divSecs.item(c).getNodeType() != org.w3c.dom.Node.ELEMENT_NODE){
            continue;
        }
        Element divElement = (Element) divSecs.item(c);
        String divName = divElement.getNodeName();
        if (divName.equals("mets:div")) {
            METSDivision division = METSDivision.parseXML(divElement);
            thisStruct.addDivision(division);
        } else {
            System.err.println("Error: mets:structMap was expecting mets:div but got "+divName);
        }
        }
    }
    return thisStruct;
    }
 
    /**
     *  Write this structure in XML(METS) format to a <code>PrintWriter</code>
     */
    public void write(PrintWriter writer)
    { 
    Iterator groups = this.children.values().iterator();
    
    String tag = XMLTools.getOpenTag("mets", "structMap");
    tag = XMLTools.addAttribute(tag, "ID", this.ID.toString());
    tag = XMLTools.addAttribute(tag, "TYPE", this.type);
    tag = XMLTools.addAttribute(tag, "LABEL", this.label);
    
    writer.println(tag);
    while (groups.hasNext()){
        METSDivision group = (METSDivision) groups.next();
        
        group.write(writer);
    }
    writer.println("</mets:structMap>");
    }
    
    
    /**
     *  Write this METSStructure to an SQL database....
     *
     *  @param <code>DocumentInterface</code> the enclosing document.
     *  @param <code>GS3SQLConnection</code> the SQL database connection.
     */
    public boolean writeSQL(DocumentInterface document, GS3SQLConnection connection)
    { 
    int sqlRef = -1;
    ResultSet results;

    // Prepare query to see if this structure has already been written
    GS3SQLSelect select = new GS3SQLSelect("structure");
    select.addField("StructureRef");
    GS3SQLWhereItem whereItem = new GS3SQLWhereItem("DocID", "=", document.getID().toString());
    GS3SQLWhereItem item = new GS3SQLWhereItem("StructureID", "=", this.ID.toString());
    GS3SQLWhere where = new GS3SQLWhere(whereItem);
    where.add(item);
    select.setWhere(where);

    // attempt to execute the query & get the current structure's reference
    try {
        connection.execute(select.toString());
        results = connection.getResultSet();
        if (results != null &&
        results.first()){
        sqlRef = results.getInt("structureRef");
        }
        else { 
        results = null;
        }
        
        if (results != null) {
        results.close();
        }
    }
    catch (SQLException sqlEx) {
        System.err.print(sqlEx);
        return false;
    }
    
    // insert a new structure if it wasn't there previously
    if (results == null) {
        GS3SQLInsert insert = new GS3SQLInsert("structure");
        insert.addValue("DocID", document.getID().toString());
        insert.addValue("StructureID", this.ID.toString());
        insert.addValue("StructureType", this.type);
        insert.addValue("Label", this.label);
        
        if (!connection.execute(insert.toString())) {
        return false;
        }
        
        // get the new structure reference by re-running the original select object
        connection.execute(select.toString());

        try {
        results = connection.getResultSet();
        results.first();
        sqlRef = results.getInt("StructureRef");
        }
        catch (SQLException sql) {
        System.err.println(sql);
        return false;
        }
    }
    else {
        GS3SQLUpdate update = new GS3SQLUpdate("structure");
        update.setWhere(where);
        
        update.addValue("StructureType", this.type);
        update.addValue("Label", this.label);
        
        connection.execute(update.toString());
    }
    
    // write out the child groups (Divisions) now...    
    Iterator groups = this.children.values().iterator();
    
    while (groups.hasNext()){
        METSDivision group = (METSDivision) groups.next();
        
        if (!group.writeSQL(document.getID(), sqlRef, true, connection)){
        return false;
        }
    }
    return true;
    }
    
    /**
     *  Read a METSStructure from a database - on entry, the current item in the
     *  <code>ResultSet</code> holds the row in the database with the structure's
     *  data.
     *
     *  @param <code>DocumentInterface</code> the document which owns the structure
     *  @param <code>GS3SQLConnection</code> the database connection itself, to load
     *         child objects through, etc.
     *  @param <code>ResultSet</code> pointing to the current row in the database.
     */
    public static METSStructure readSQL(DocumentInterface document, GS3SQLConnection connection,
                    ResultSet resultSet)
    {
    GS3SQLSelect select = null;
    
    try {
        String ID    = resultSet.getString("StructureID");
        String type  = resultSet.getString("StructureType");
        String label = resultSet.getString("Label");

        // create the metadata block object
        METSStructure structure = new METSStructure(ID, label, type);
      
        // get its metadata reference to retrieve divisions
        int structureRef = resultSet.getInt("StructureRef");

        // query the database for matching division for this structure block
        select = new GS3SQLSelect("divisions");
        select.addField("*");
        GS3SQLWhereItem whereItem = new GS3SQLWhereItem("ParentRef", "=", Integer.toString(structureRef),
                                GS3SQLField.INTEGER_TYPE);
        GS3SQLWhere where = new GS3SQLWhere(whereItem);
        whereItem = new GS3SQLWhereItem("ParentType", "=", METSStructure.STRUCTURE_TYPE);
        where.add(whereItem);
        select.setWhere(where);

        connection.execute(select.toString());

        // parse through the divisions
        ResultSet divisionSet = connection.getResultSet();
        if (divisionSet != null && divisionSet.first()) {
        do {
            METSDivision division = METSDivision.readSQL(connection, divisionSet);
            if (division != null) {
            structure.addDivision(division);
            }
        }
        while (divisionSet.next());
        }

        return structure;
    }
    catch (SQLException sqlEx)
        { System.out.println(sqlEx + " " + select.toString());
        System.exit(1);
        }
    return null;
    }
}