source: trunk/gsdl3/src/java/org/greenstone/gsdl3/gs3build/metadata/METSFile.java@ 9874

package org.greenstone.gsdl3.gs3build.metadata;

import java.io.PrintWriter;

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

import java.net.URL;
import java.net.URLConnection;

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

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.Text;

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

/**
 *  An individual METS component file for a document.  Many features of METS are not
 *  currently fully supported/used here, but member variables exist for all of the
 *  standard members.
 */

public class METSFile
{
    METSFileID    id;
    METSFilePos   location;
    String        MIMEType;
    int           sequenceNo;
    long          size;
    METSDate      created;
    long          checkSum;
    List          adminRefs;
    List          describeRefs;
    METSFileGroup group;
    
    /**
     *  Create a new METSFile object, with the given properties.  The remaining
     *  fields are filled in with default values.
     *
     *  @param <code>String</code> the id of the file
     *  @param <code>METSFilePos</code> the location of the file
     *  @param <code>String</code> the MIME type of the file
     */
    public METSFile(METSFileID id,  METSFilePos location, String mimeType)
    {
    this.id           = id;        // required
    this.location     = location;  // the location
    this.MIMEType     = mimeType;  // the MIME type;
    this.sequenceNo   = -1;       // -1 indicates unset
    this.size         = -1;        // -1 indicates unset
    this.checkSum     = -1;        // -1 indicates unset
    this.created      = null;
    this.adminRefs    = new ArrayList();
    this.describeRefs = new ArrayList();
    this.group        = null;
    }
    
    public boolean equals(URL url)
    { 
    return this.location.equals(url);
    }
    
    /**
     *  Set the parent group
     *
     *  @param <code>METSFileGroup</code> the new holding file group
     */
    public void setGroup(METSFileGroup group)
    { 
    this.group = group;
    }
    
    /**
     *  Get the parent group of this file
     *
     *  @return <code>METSFileGroup</code> the holding file group
     */
    public METSFileGroup getGroup()
    { 
    return this.group;
    }
    
    /**
     *  Get the identifier of this file
     *
     *  @return <code>METSFileID</code> the file identifier
     */
    public METSFileID getID()
    { 
    return this.id;
    }
    
    /**
     *  Set the identifier of this file
     *
     *  @param <code>METSFileID</code> the file identifier
     */
    public void setID(METSFileID id)
    { 
    this.id = id;
    }
    
    /**
     *  @return <code>String</code> the MIME (content) type of the file
     */
    public String getMIMEType()
    { 
    return this.MIMEType;
    }
    
    /**
     *  @return <code>URL</code> the location of the file.  This will often be in
     *          "file://" form.
     */
    public URL getLocation()
    { 
    return this.location.getLocation();
    }
    
    /**
     *  Take a url and make a METSFile object out of it - works out
     *  details such as the Mime type, identifiers and other necessary
     *  information to call the constructor for METSFile
     *
     *  @param <code>URL</code> the url of the object - this may be a 
     *                          reference to a file on the local filestore
     *
     *  @return <code>METSFile</code> the METS file object for the corresponding
     *                                document component.
     */
    public static METSFile makeMETSFile(URL url, String mimeType)
    {   
    METSFile reply = new METSFile(new METSFileID(), new METSFilePos(url), mimeType);
    return reply;
    }
    
    public static METSFile makeMETSFile(URL url)
    { 
    String mimeType;
    
    if (url.getProtocol().equals("file")){
        // TODO: Work out the MIME type
        mimeType = URLConnection.getFileNameMap().getContentTypeFor(url.toString().substring(7));
        if (mimeType == null) {
        mimeType = "text/plain";
        }
    } else { 
        // TODO: look up the MIME type through the pertinent connection
        mimeType = HTTPTools.getMIMEType(url);
    }
    // TODO: make the identifier...
    
    return makeMETSFile(url, mimeType);
    }
    
    /**
     *  Write the METS file in an XML to a text-output sink
     *
     *  @param <code>PrintWriter</code> the destination of the output
     */
    public void write(PrintWriter writer)
    { 
    String tag = XMLTools.getOpenTag("mets", "file");
    tag = XMLTools.addAttribute(tag, "MIMETYPE", this.MIMEType);
    tag = XMLTools.addAttribute(tag, "ID", this.id.toString());
    writer.print("      ");   //indentation
    writer.println(tag);
    
    tag = XMLTools.getOpenTag("mets", "FLocat");
    tag = XMLTools.addAttribute(tag, "LOCTYPE", this.location.getType());
    tag = XMLTools.addAttribute(tag, "xlink:href", this.location.getLocation().toString());
    
    tag = XMLTools.makeSingleton(tag);
    writer.print("         ");  //indentation
    writer.println(tag);
    
    writer.print("      ");   //indentation
    writer.println(XMLTools.getCloseTag("mets", "file"));
    }
    
    
    public boolean writeSQL(int groupReference, GS3SQLConnection connection)
    { 
    // check if this file is in the table already...
    GS3SQLAction action;
    
    GS3SQLSelect select = new GS3SQLSelect("files");
    select.addField("*");
    GS3SQLWhereItem whereItem = new GS3SQLWhereItem("FileGroupRef", "=", Integer.toString(groupReference),
                            GS3SQLField.INTEGER_TYPE);
    GS3SQLWhere  where  = new GS3SQLWhere(whereItem);
    whereItem = new GS3SQLWhereItem("FileID","=", this.id.toString());
    where.add(whereItem);
    select.setWhere(where);

    Statement statement = null;
    
    // if not, then make an insert action
    try {
        statement = connection.createStatement();
        ResultSet results = statement.executeQuery(select.toString());
        if (!results.first()){
        GS3SQLInsert insert = new GS3SQLInsert("files");
        
        insert.addValue("FileGroupRef", Integer.toString(groupReference), GS3SQLField.INTEGER_TYPE);
        insert.addValue("FileID", this.id.toString());
        
        action = insert;
        }
        else {
        GS3SQLUpdate update = new GS3SQLUpdate("files");
        
        update.setWhere(where);
        action = update;
        }
    }
    catch (SQLException ex){
        System.err.println("METSFile.writeSQL(): "+ex);
        return false;
    }
    action.addValue("FileLocType", this.location.getType());
    action.addValue("FileLocation", this.location.getLocation().toString());
    action.addValue("MIMEType", this.MIMEType);
    
    try {
        statement.execute(action.toString());
        statement.close();
        
    } catch (SQLException e) {
        System.err.println("METSFile.writeSQL():"+e);
        return false;
    }
    return true;
    }
    
    public static METSFile readSQL(GS3SQLConnection connection, ResultSet parentSet)
    { 
    try {
        String locType = parentSet.getString("FileLocType");
        String location = parentSet.getString("FileLocation");
        String mimeType = parentSet.getString("MIMEType");
        String id = parentSet.getString("FileID");
    
        METSFileID metsID = new METSFileID(id);
        METSFilePos metsFilePos = new METSFilePos(locType, location);
        
        METSFile reply = new METSFile(metsID, metsFilePos, mimeType);
        return reply;
    }
    catch (SQLException ex){
        System.out.println("METSFile.readSQL(): "+ex);
    }
    catch (java.net.MalformedURLException urlEx){
        System.out.println("METSFile.readSQL(): "+urlEx);
    }
    return null;
    }
    
    public static METSFile parse_file(Element element, METSFileGroup group, String parseFilePath)
    {
    NodeList children = element.getChildNodes();

    METSFile thisFile = null;
    
    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:file")){
        METSFile.parse_file(child, group, parseFilePath);
        } else if (childName.equals("mets:FLocat")) {
        String mimeType = element.getAttribute("MIMETYPE");
        String fileId = element.getAttribute("ID");   
        
        METSFilePos thisFilePos = METSFile.parse_flocateXML(child, parseFilePath, fileId);
        thisFile = new METSFile(new METSFileID(fileId), thisFilePos, mimeType);    
        group.addFile(thisFile);
        } else {
        System.err.println("Warning: unrecognised tag " +childName);
        }
    }
    return thisFile;
    }
    
    public static METSFilePos parse_flocateXML(Element element, String parseFilePath, String fileId)
    {
    METSFilePos thisFilePos = null;
    
    // get most of the information from the child FLocat node
    String locationType = element.getAttribute("LOCTYPE");
    String href = element.getAttribute("xlink:href");
    //String fileId = element.getAttribute("ID");
    try {
        thisFilePos = new METSFilePos(locationType, href);
        
        if (fileId.startsWith("default.")) {
        //retrieve the string after ..import/
        int importPosition = href.indexOf("import/")+7;
        href.substring(importPosition);
        if (fileId.equals("default.1")) {
            href = "file:" + parseFilePath+ "doctxt.xml";
        } else {
            href = "file:" + parseFilePath + href.substring(importPosition);
        }
        }
            thisFilePos = new METSFilePos(locationType, href);
    } catch (java.net.MalformedURLException ex) {
        // TODO: raise error
        System.err.println("METSFile.parse_flocateXML(): "+ex);
    }
    return thisFilePos;
    }
    
    
    /**
     *  Get the location of this file as a URL
     */
    public URL getURL()
    { 
    return this.location.getLocation();
    }
    
    /**
     *  Get modified file date
     */
    public long getModifiedDatestamp()
    { 
    return this.location.getModifiedDatestamp();
    }
    
    /**
     *  Overridden <code>toString</code> for convenience - returns the location of the file.
     *
     *  @return <code>String</code> the location of the file as a string
     */
    public String toString()
    {
    return this.location.toString();
    }
}