source: branches/ant-install-branch/gsdl3/src/java/org/greenstone/gsdl3/gs3build/metadata/METSFileGroup.java@ 9858

package org.greenstone.gsdl3.gs3build.metadata;

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

import java.net.URL;

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

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


import java.io.PrintWriter;

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

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

/**
 *  Child groups are indicated by colons.  E.g. Chapter1:Section1 would indicate
 *  the group "Section1" inside the "Chapter1" group...
 */

public class METSFileGroup
{ 
    List   children;
    List   childGroups;
    String id;
    
    public static final String SECTION_PARENT = "Section";
    public static final String GROUP_PARENT = "Group";
    
    public METSFileGroup(String id)
    { 
    this.children = new ArrayList();
    this.childGroups = new ArrayList();
    this.id = id;
    }
    
    /**
     *  Get the modified datestamp that applies for this file group.  An empty group
     *  will return <code>0</code>.
     *
     *  @return <code>long</code> the date modified as milliseconds from the 1st January 1970
     */
    public long getModifiedDatestamp()
    { 
    long reply = 0; // empty groups reply '0'
    
    Iterator childIter = children.iterator();
    while (childIter.hasNext()){
        METSFile file = (METSFile) childIter.next();
        long fileStamp = file.getModifiedDatestamp();
        if (fileStamp > reply) {
        reply = fileStamp;
        }
    }
    
    childIter = childGroups.iterator();
    while (childIter.hasNext()){
        METSFileGroup fileGroup = (METSFileGroup) childIter.next();
        long fileStamp = fileGroup.getModifiedDatestamp();
        if (fileStamp > reply) {
        reply = fileStamp;
        }
    }
    
    return reply;
    }
    
    /**
     *  Find all the occurrences of a given file, and place them
     *  in a <code>List</code>.
     */
    public void findGroups(URL findFile, List resultList)
    { 
    // find in this particular group
    Iterator childIter = children.iterator();
    while (childIter.hasNext()){
        METSFile file = (METSFile) childIter.next();
        if (file.equals(findFile))
        { resultList.add(this.id);
        }
    }
    
    // iterate over the child groups
    childIter = childGroups.iterator();
    while (childIter.hasNext()){
        METSFileGroup fileGroup = (METSFileGroup) childIter.next();
        
        fileGroup.findGroups(findFile, resultList);
    }
    }
    
    /**
     *  Get a sub group of this METSFileGroup.
     *
     *  @param <code>String</code> the name of the subgroup
     *  @return <code>METSFileGroup</code> the child group, which will
     *          be <code>null</code> if the group is not known.
     */
    public METSFileGroup getSubgroup(String id)
    { 
    String childId;
    
    int dotAt = id.indexOf(':');
    if (dotAt == -1){
        childId = null;
    }
    else{ 
        childId = id.substring(dotAt+1);
        id = id.substring(0, dotAt);
    }
    
    // iterate over the child groups
    Iterator childIter = childGroups.iterator();
    while (childIter.hasNext()){
        METSFileGroup group = (METSFileGroup) childIter.next();
        
        if (group.id.equals(id)) {
        if (childId == null) {
            return group;
        }
        else {
            return group.getSubgroup(childId);
        }
        }
    }
    return null;
    }
    
    /**
     *  Add a filegroup to this group of files.
     *
     *  @param <code>METSFileGroup</code> the filegroup.
     */
    public void addGroup(METSFileGroup group)
    { 
    this.childGroups.add(group);
    }
    
    /**
     *  Add a file to this group of files.
     *
     *  @param <code>METSFile</code> the file in a METS File object.
     */
    public void addFile(METSFile file)
    { 
    this.children.add(file);
    file.setGroup(this);
    if (!file.getID().isDefined()){
        file.setID(new METSFileID(this.id + "." + Integer.toString(this.children.size())));
    }
    }
    
    /**
     *  Get the nth child of the group
     *
     *  @param <code>int</code> the index into the group
     *  @return <code>METSFile</code> the corresponding child.  This may be <code>null</code>
     *          particularly if the index given falls outside of the valid range of child
     *          indexes.
     */
    public METSFile getFile(int index)
    { 
    if (index < 0 || index >= this.children.size()){
        return null;
    }
    
    return (METSFile) this.children.get(index);
    }
    
    /**
     *  Get all the files in the group as a <code>List</code>
     *
     *  @return <code>List</code> the file childen of the group.
     */
    public List getFiles()
    { 
    return this.children;
    }
    
    /**
     *  Get all the subgroups as a <code>List</code>
     */
    public List getSubgroups()
    { 
    return this.childGroups;
    }
    
    /**
     *  Get the number of files in the group
     *
     *  @return <code>int</code> the count
     */
    public int noOfFiles()
    { 
    return this.children.size();
    }
    
    /**
     *  Get the number of subgroups.
     */
    public int noOfSubgroups()
    { 
    return this.childGroups.size();
    }
    
    /**
     *  @return <code>String</code> the name of this group
     */
    public String getId()
    { 
    return this.id;
    }
    
    public static METSFileGroup parse_groupXML(Element element, METSFileSet set, String parseFilePath, METSFileGroup group)
    {
    //deal with mets:fileGrp
    NodeList children = element.getChildNodes();
    
    for (int c = 0; c < children.getLength(); c++) {
        if (children.item(c).getNodeType() != org.w3c.dom.Node.ELEMENT_NODE){
        continue;
        }
        Element child = (Element) children.item(c);
        String childName = child.getNodeName();
        
        if (childName.equals("mets:fileGrp")) {
        String groupId = child.getAttribute("ID");
        METSFileGroup childGroup = new METSFileGroup(groupId);
        
        if (group != null){
            group.addGroup(childGroup);
        } else {
            set.addGroup(childGroup);
        }
        METSFile file = METSFile.parse_file(child, childGroup, parseFilePath);
        }
    }
    return group;
    }

    /**
     *  Write the object in an XML METS format.
     *
     *  @param <code>PrintWriter</code> the printwriter being used to write the object
     */
    public void write(PrintWriter writer)
    { 
    String tag = XMLTools.getOpenTag("mets","fileGrp");
    tag = XMLTools.addAttribute(tag, "ID", this.id);
    writer.print("   ");   //indentation
    writer.println(tag);
    
    Iterator childIter = children.iterator();
    while (childIter.hasNext()){
        METSFile file = (METSFile) childIter.next();
        file.write(writer);
    }
    writer.print("   ");   //indentation
    writer.println(XMLTools.getCloseTag("mets","fileGrp"));
    }
    
    public boolean writeSQL(DocumentInterface document, String parentRef, boolean parentIsSection, 
                GS3SQLConnection connection)
    { 
    int sqlId = -1;
    // check if this node is in the database already
    GS3SQLSelect select = new GS3SQLSelect("filegroups");
    select.addField("*");
    GS3SQLWhereItem whereItem = new GS3SQLWhereItem("FileGroupID", "=", this.id);
    GS3SQLWhereItem whereDoc  = new GS3SQLWhereItem("DocID", "=", document.getID().toString());
    GS3SQLWhere where = new GS3SQLWhere(whereItem);
    where.add(whereDoc);
    select.setWhere(where);
    
    ResultSet results = null;
    Statement statement = null;
    
    try {
        statement = connection.createStatement();
        results = statement.executeQuery(select.toString());
        if (!results.first()) {
        GS3SQLInsert insert = new GS3SQLInsert("filegroups");
        
        insert.addValue("DocID", document.getID().toString());
        insert.addValue("FileGroupID", this.id);
        insert.addValue("ParentRef", parentRef, GS3SQLField.INTEGER_TYPE);
        insert.addValue("ParentType", parentIsSection ? SECTION_PARENT : GROUP_PARENT);
        
        statement.execute(insert.toString());
        }
        else {
        // TODO: update the data for this file group...
        }
    }
    catch (SQLException ex){
        System.err.println("METSFileGroup.writeSQL(): "+ex);
        return false;
    }
    
    // get the filegroup reference now
    try {
        results = statement.executeQuery(select.toString());
        if (results.first()) {
        sqlId = results.getInt("FileGroupRef");
        } else {
        statement.close();
        return false;
        }
        statement.close();
    } catch (SQLException sqlex) {
        System.err.println("METSFileGroup.writeSQL(): "+sqlex);
        return false;
    }
    // iterate over the child groups
    Iterator childIter = childGroups.iterator();
    while (childIter.hasNext()){
        METSFileGroup fileGroup = (METSFileGroup) childIter.next();
        
        if (!fileGroup.writeSQL(document, Integer.toString(sqlId), false, connection)){
        System.err.println("METSFileGroup.writeSQL(): Couldn't write FileGroup");
        return false;
        }
    }
    
    // iterate over the child files
    childIter = children.iterator();
    while (childIter.hasNext()){
        METSFile file = (METSFile) childIter.next();        
        if (!file.writeSQL(sqlId, connection)){
        System.err.println("METSFileGroup.writeSQL(): Couldn't write File");
        return false;
        }
    }
    
    return true;
    }
    
    public static METSFileGroup readSQL(DocumentInterface document, GS3SQLConnection connection,
                    ResultSet resultSet)
    {
    try {
        String ID         = resultSet.getString("FileGroupID");
        String parentType = resultSet.getString("ParentType");
        String parentRef  = resultSet.getString("ParentRef");
        
        // create the metadata block object
        METSFileGroup group = new METSFileGroup(ID);
        
        // get its metadata reference to retrieve divisions
        int groupRef = resultSet.getInt("FileGroupRef");
        
        // query the database for matching groups which are children of this one
        GS3SQLSelect select = new GS3SQLSelect("filegroups");
        select.addField("*");
        GS3SQLWhereItem whereItem = new GS3SQLWhereItem("ParentRef", "=", Integer.toString(groupRef),
                                GS3SQLField.INTEGER_TYPE);
        GS3SQLWhere where = new GS3SQLWhere(whereItem);
        whereItem = new GS3SQLWhereItem("ParentType", "=", METSFileGroup.GROUP_PARENT);
        where.add(whereItem);
        select.setWhere(where);
        
        Statement statement = connection.createStatement();
        
        // parse through the child groups
        ResultSet childSet = statement.executeQuery(select.toString());
        if (childSet.first()) {
        do {
            METSFileGroup fileGroup = METSFileGroup.readSQL(document, connection, childSet);
            if (fileGroup != null) {
            group.addGroup(fileGroup);
            }
        }
        while (childSet.next());
        }
        // now scan for file members
        select = new GS3SQLSelect("files");
        select.addField("*");
        whereItem = new GS3SQLWhereItem("FileGroupRef", "=", Integer.toString(groupRef), GS3SQLField.INTEGER_TYPE);
        where = new GS3SQLWhere(whereItem);
        select.setWhere(where);
        ResultSet childFileSet = statement.executeQuery(select.toString());
        if (childFileSet.first()) {
        do {
            METSFile file = METSFile.readSQL(connection, childFileSet);
            if (file != null) {
            group.addFile(file);
            }
        }
        while (childFileSet.next());
        }
        statement.close();
        return group;
    }
    catch (SQLException sqlEx){
        System.err.println("METSFileGroup.readSQL(): "+sqlEx);
        System.exit(1);
    }
    return null;
    }
}