source: trunk/greenstone3-extensions/gs3build/src/org/greenstone/gsdl3/gs3build/metadata/METSFileSet.java@ 12188

package org.greenstone.gsdl3.gs3build.metadata;

/**
 *  A class to hold all the alternative file structures
 *  for a particular METS Document
 */

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

import java.io.File;
import java.io.PrintWriter;

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

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


import java.net.URL;

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

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

public class METSFileSet
{ 
    Map    fileGroups;
    String reference;
    FileIdentifierFactory identifierFactory;
    FileGroupIdentifierFactory groupIdentifierFactory;
    
    class FileGroupIdentifierFactory extends AbstractIdentifierFactory
    {
    public static final String FILEGROUP_PRELUDE = "FG";
    
    public FileGroupIdentifierFactory()
    {
        super("FILEGROUP_PRELUDE");
    }
    }
    
    public METSFileSet()
    { 
    this.fileGroups = new HashMap();
    this.fileGroups.put("default", new METSFileGroup("default"));
    this.reference = null;
    this.identifierFactory = new FileIdentifierFactory();
    this.groupIdentifierFactory = new FileGroupIdentifierFactory();
    }
    
    public long getModifiedDatestamp()
    { 
    long reply = 0;
    
    Iterator groupsIter = this.fileGroups.values().iterator();
    while (groupsIter.hasNext()) {
        METSFileGroup group = (METSFileGroup) groupsIter.next();
        long groupStamp = group.getModifiedDatestamp();
        if (groupStamp > reply){
            reply = groupStamp;
        }
        }
    return reply;
    }
    
    
    /**
     *  Get a new FileGroup to lie within this fileset.  The group is not initialised with
     *  a parent, etc. - all that is done is the allocation of a unique group identifier.
     *
     *  @return <code>METSFileGroup</code> the new group.
     */
    public METSFileGroup createGroup()
    { 
    METSFileGroup group = new METSFileGroup(this.groupIdentifierFactory.getNextIdentifier());
    return group;
    }
    
    public METSFile createFile(METSFilePos filePos, String type)
    { 
    METSFile file = new METSFile(new METSFileID(this.identifierFactory.getNextIdentifier()), filePos, type);
    return file;
    }
    
    /**
     *  Get the group that corresponds to the given name...
     *
     *  @param <code>String</code> the name of the group.
     *  @return <code>METSFileGroup</code> the group object - this will be
     *          <code>null</code> if the group is not found
     */
    public METSFileGroup getGroup(String name)
    { 
    if (!this.fileGroups.containsKey(name)){
        return null;
    }
    return (METSFileGroup) this.fileGroups.get(name);
    }
    
    /**
     *  Get the Nth file from the default group...
     *
     *  @param <code>int</code> the index into the default group to use...
     *  @return <code>METSFile</code> the file.
     */
    public METSFile getFile(int index)
    { 
    METSFileGroup group = this.getGroup("default");

    if (group == null) {
        return null;
    }
    return group.getFile(0);
    }
    
    /**
     *  Add a file to the default file group
     */
    public void addFile(METSFile file)
    { 
    METSFileGroup defaultGroup = (METSFileGroup) this.fileGroups.get("default");
    defaultGroup.addFile(file);
    }
    
    /**
     *  Add a file to the default file group
     *
     *  @return <code>METSFile</code> an object that wraps the given url into
     *          a METS file object
     */
    public METSFile addFile(URL url)
    { 
    METSFile file = METSFile.makeMETSFile(url);
    this.addFile(file);
    return file;
    }
    
    public void addFile(METSFile file, String toGroup)
    { 
    METSFileGroup destGroup = (METSFileGroup) this.fileGroups.get(toGroup);
    
    if (destGroup == null){
        destGroup = new METSFileGroup(toGroup);
        this.fileGroups.put(destGroup.getId(), destGroup);
    }
    
    destGroup.addFile(file);
    }
    
    public void addFile(URL url, String toGroup)
    { 
    METSFile file = METSFile.makeMETSFile(url);
    this.addFile(file, toGroup);
    }
    
    /**
     *  Add a group at the top level of the METS File set.
     *
     *  @param <code>METSFileGroup</code> the file group to add.
     */
    public void addGroup(METSFileGroup group)
    { 
    this.fileGroups.put(group.getId(), group);
    }
    
    /**
     *  Get all the groups that contain a given URL/file.
     *
     *  @param <code>URL</code> the location of the file.
     *  @return <code>List</code> the list of group references that contain the file.
     */
    public List findGroups(URL file)
    { 
    List resultList = new ArrayList();
    
    Iterator groups = this.fileGroups.values().iterator();
    
    while (groups.hasNext()){
        METSFileGroup group = (METSFileGroup) groups.next();
        
        group.findGroups(file, resultList);
    }
    return resultList;
    }
    
    /*
     *
     *
     */
    public static METSFileSet parseXML(NodeList fileSecs, METSFileSet fileSet, String parseFilePath) 
    {
    //METSFileSet set = new METSFileSet();> 
    // this is in effect a group without a sense of 'self'...
    for (int c = 0; c < fileSecs.getLength(); c++) {
        if (fileSecs.item(c).getNodeType() != org.w3c.dom.Node.ELEMENT_NODE){
        continue;
        }
        
        METSFileGroup groups = METSFileGroup.parse_groupXML((Element)fileSecs.item(c), fileSet, parseFilePath, null);
    }
    return fileSet;
    }
    

    public void write(PrintWriter writer)
    { 
    Iterator groups = this.fileGroups.values().iterator();
    
    writer.println("<mets:fileSec>");
    while (groups.hasNext()){
        METSFileGroup group = (METSFileGroup) groups.next();
        
        group.write(writer);
    }
    writer.println("</mets:fileSec>");
    }
    
    public boolean writeSQL(DocumentInterface document, GS3SQLConnection connection)
    { 
    Iterator groups = this.fileGroups.values().iterator();
    
    // write the set if the reference does not already exist...
    if (this.reference == null){
        // Insert the file section into the database
        GS3SQLInsert insert = new GS3SQLInsert("filesection");
        insert.addValue("DocID", document.getID().toString());
        insert.addValue("FileSecID", "test"); // TODO: remove magic string
        
        Statement statement = null;
        try {
        statement = connection.createStatement();
        statement.execute(insert.toString());
        } catch (SQLException e) {
        System.err.println("METSFileSet.writeSQL(): "+e);
        return false;
        }
        
        // find the file section number
        GS3SQLSelect select = new GS3SQLSelect("filesection");
        select.addField("*");
        GS3SQLWhereItem whereItem = new GS3SQLWhereItem("FileSecID", "=", "test");
        GS3SQLWhereItem whereDoc  = new GS3SQLWhereItem("DocID", "=", document.getID().toString());
        GS3SQLWhere where = new GS3SQLWhere(whereItem);
        where.add(whereDoc);
        select.setWhere(where);
        
        try {
        ResultSet set = statement.executeQuery(select.toString());
        if (set.first()) {
            int sectionRef = set.getInt("FileSectionRef");
            
            this.reference = Integer.toString(sectionRef);
        }
        statement.close();
        }
        catch (SQLException ex){
        System.out.println("METSFileSet.writeSQL(): "+ex);
        return false;
        }
    }
    
    if (this.reference == null) {
        return false;
    }
    // write out the children
    while (groups.hasNext()){
        METSFileGroup group = (METSFileGroup) groups.next();
        
        if (!group.writeSQL(document, this.reference, true, connection)){
        return false;
        }
    }
    
    return true;
    }
    
    public static METSFileSet readSQL(DocumentInterface document, GS3SQLConnection connection)
    { 
    METSFileSet set = new METSFileSet();    
    
    // Get file sections from the filesection table (currently redundant)
    GS3SQLSelect select = new GS3SQLSelect("filesection");
    select.addField("*");
    GS3SQLWhereItem whereItem = new GS3SQLWhereItem("DocID", "=", document.getID().toString());
    select.setWhere(new GS3SQLWhere(whereItem));

    Statement statement = null;
    
    // Get the identifier for this file set, etc.
    int fileSetRef = -1;
    try {
        statement = connection.createStatement();
        ResultSet sections = statement.executeQuery(select.toString());
        if (sections.first()) {
        fileSetRef = sections.getInt("FileSectionRef");
        set.reference = Integer.toString(fileSetRef);
        } else {
        statement.close();
        return null;
        }
        
    }
    catch (SQLException ex){
        System.err.println("METSFileSet.readSQL() "+ex);
        return null;
    }
    // Get child file groups
    select = new GS3SQLSelect("filegroups");
    select.addField("*");
    whereItem = new GS3SQLWhereItem("DocID", "=", document.getID().toString());    
    GS3SQLWhere where = new GS3SQLWhere(whereItem);
    whereItem = new GS3SQLWhereItem("ParentRef", "=", Integer.toString(fileSetRef), 
                    GS3SQLField.INTEGER_TYPE);
    where.add(whereItem);
    whereItem = new GS3SQLWhereItem("ParentType", "=", METSFileGroup.SECTION_PARENT);
    where.add(whereItem);
    select.setWhere(where);
    // start going through the matching file groups
    try {
        ResultSet resultSet = statement.executeQuery(select.toString());
        if (resultSet.first()) {
        do {
            METSFileGroup filegroup = METSFileGroup.readSQL(document, connection, resultSet);
            if (filegroup != null) {
            set.addGroup(filegroup);
            }
        } while (resultSet.next());
        }
        statement.close();
    }
    catch (SQLException sqlEx) {
        System.out.println("METSFileSet.readSQL(): "+sqlEx);
        System.exit(1);
    }
    return set;
    }
    
}