source: trunk/gli/src/org/greenstone/gatherer/gems/MetadataSetManager.java@ 9647

/**
 *#########################################################################
 *
 * A component of the Gatherer application, part of the Greenstone digital
 * library suite from the New Zealand Digital Library Project at the
 * University of Waikato, New Zealand.
 *
 * <BR><BR>
 *
 * Author: John Thompson, Greenstone Digital Library, University of Waikato
 *
 * <BR><BR>
 *
 * Copyright (C) 1999 New Zealand Digital Library Project
 *
 * <BR><BR>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * <BR><BR>
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * <BR><BR>
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *########################################################################
 */
package org.greenstone.gatherer.gems;

import java.io.*;
import java.util.*;
import java.util.StringTokenizer;
import javax.swing.*;
import javax.swing.filechooser.*;
import javax.swing.tree.TreePath;
import org.greenstone.gatherer.Configuration;
import org.greenstone.gatherer.DebugStream;
import org.greenstone.gatherer.util.Utility;
import org.greenstone.gatherer.collection.CollectionManager;
import org.greenstone.gatherer.file.*;
import org.greenstone.gatherer.util.XMLTools;
import org.apache.xerces.parsers.*;
import org.apache.xml.serialize.*;
import org.w3c.dom.*;
import org.xml.sax.*;

/** This class is responsible for managing all the metadata sets in the collection and for providing methods for manipulating the aforementioned sets contents. 
 * @author John Thompson, Greenstone Digital Library, University of Waikato
 * @version 2.3b
 */
public class MetadataSetManager {
    static final public String HIDDEN = "hidden"; //The name of the hidden, or system, metadata set.
    static final public int MAX_LOADED_SETS = 64;
    static public CollectionManager col_man = null;
    static private Hashtable mds_hashtable = new Hashtable(); //A mapping from metadata namespace to metadata set.
    public GEMS gemsptr;
    

    /** Constructor. */
    public MetadataSetManager(GEMS gemscopy) {
        gemsptr = gemscopy;
        col_man = new CollectionManager();
    }


    public MetadataSet addSet(String namespace, String name) {
    MetadataSet mds = new MetadataSet(GEMS.METADATA_SET_TEMPLATE);
    mds.setAttribute("creator", "The Greenstone Librarian Interface");
    // Calculate lastchanged to right now on this machine by this user
    String user_name = System.getProperty("user.name");
    String machine_name = Utility.getMachineName();
    mds.setAttribute("lastchanged", Utility.getDateString() + " - " + user_name + " on " + machine_name);
    // And the remaining attributes.
    mds.setAttribute("namespace", namespace);
    // Add the name element.
    mds.setName(name);
    // this is the location for a global metadata set
    File mds_file = new File(Utility.METADATA_DIR, namespace + ".mds");
    mds.setFile(mds_file);
    mds_hashtable.put(namespace, mds);
    // fireSetChanged(mds);
    return mds;
    }


    /**
       Method to rename a metadata set.
       @param: current_set: The metadata set to rename
       @param: new_namspace: The new namespace for the current_set
       @param: new_name: The new (language-dependent) name for the current_set. Multiple names in different languages is not yet implemented in GEMS, but when it is, this method will need to be updated.

       @pre: There is not another metadata set with namespace new_namespace. Ie namespaces are unique.
       @post: The Name and namespace in the metadata file will have been updated. The filename will stay the same.

       @author Matthew Whyte
       Date last modified: 10/01/12
    */
    public void renameSet(MetadataSet current_set, String new_namespace, String new_name)
    {
    if(current_set != null)
        {
        String old_namespace = current_set.getNamespace();
        current_set.setNamespace(new_namespace); //Update the namespace
        current_set.setName(new_name); //Update the name
        mds_hashtable.remove(old_namespace); //Remove the old set from the hashtable
        mds_hashtable.put(new_namespace, current_set); //Add the new set to the hashtable
        }
    else
        {
        //This should not happen.
        System.err.println("Error: no such set \'" + current_set + "\'");
        }
    }


    /** Destructor. 
     */
    public void destroy() {
    mds_hashtable.clear();
    }


    /** Used to get all the (non-hidden) elements in this manager.
     * @return A Vector of ElementWrappers.
     */
    public Vector getElements() {
    return getElements(false);
    }

    public Vector getElements(boolean all) {
    return getElements(all, false);
    }


    /** Used to get all the elements in this manager.
     * @param all <i>true</i> if all elements, including hidden, should be returned.
     * @return A Vector of ElementWrappers.
     */
    public Vector getElements(boolean all, boolean force_extracted) {
    Vector all_elements = new Vector();
    for(Enumeration keys = mds_hashtable.keys(); keys.hasMoreElements(); ) {
        MetadataSet mds = (MetadataSet)mds_hashtable.get(keys.nextElement());
        if((!mds.getNamespace().equals(Utility.EXTRACTED_METADATA_NAMESPACE) && !mds.getNamespace().equals(HIDDEN)) 
           || (mds.getNamespace().equals(Utility.EXTRACTED_METADATA_NAMESPACE) && (Configuration.get("general.view_extracted_metadata", Configuration.COLLECTION_SPECIFIC) || force_extracted)) 
           || (mds.getNamespace().equals(Utility.EXTRACTED_METADATA_NAMESPACE) && mds.getNamespace().equals(HIDDEN) && all)) {
        ArrayList set_elements = mds.getElements();
        ///ystem.err.println("The set " + mds + " has " + set_elements.getLength() + " elements.");
        for(int i = 0; i < set_elements.size(); i++) {
            Element raw_element = (Element)set_elements.get(i);
            ElementWrapper element = new ElementWrapper(raw_element);
            // For now we do not add subfield elements and their parents, just the subfields.
            NodeList child_elements = raw_element.getElementsByTagName("Element");
            if(child_elements.getLength() == 0) {
            all_elements.add(element);
            }
        }
        }
    }
    Collections.sort(all_elements);
    return all_elements;
    }


    /** Retrieve a metadata element by its index.
     * @param index The specified index as an int.
     * @return An ElementWrapper containing the specied element, or <i>null</i> is no such element exists.
     */
    public ElementWrapper getElement(int index) {
    Vector elements = getElements(false);
    ElementWrapper result = null;
    if(0 <= index && index < elements.size()) {
        result = (ElementWrapper) elements.get(index);
    }
    return result;
    }

    /** Retrieve a metadata element by looking at the current metadata element. Note that this 'index' element may now be disconnected from the DOM model, so we have to reload the target element by the string method.
     * @param element The possibly out-of-data MetadataElement.
     * @return An ElementWrapper containing the specied element, or <i>null</i> is no such element exists.
     */
    public ElementWrapper getElement(ElementWrapper element) {
    return getElement(element.toString());
    }

    /** Retrieve a metadata element by its fully qualified name.
     * @param name The elements name as a String.
     * @return An ElementWrapper containing the specied element, or <i>null</i> is no such element exists.
     */

    public ElementWrapper getElement(String name) {
    return getElement(name, false);
    }

    public ElementWrapper getElement(String name, boolean perfect) {
    ///ystem.err.println("Retrieve element " + name);
    if(name == null) {
        ///ystem.err.println("No name!");
        return null;
    }
    ElementWrapper result = null;
    MetadataSet set = null;
    String element = null;
    // First we seperate off what set it is in, where we have '<set><namespace_separator><element>'.
    if(name.indexOf(MSMUtils.NS_SEP) != -1) {
        String namespace = name.substring(0, name.indexOf(MSMUtils.NS_SEP));
        // Retrieve the correct set if possible.
        set = (MetadataSet)mds_hashtable.get(namespace);
        namespace = null;
        // Now retrieve the element name.
        element = name.substring(name.indexOf(MSMUtils.NS_SEP) + 1);
    }
    // If we are looking for a perfect match, we can assume that no namespace means extracted metadata
    else if(!perfect) {
        // No namespace so assume that its extracted metadata.
        set = (MetadataSet)mds_hashtable.get(Utility.EXTRACTED_METADATA_NAMESPACE);
        element = name;
    }
    if(set != null) {
        // Now we have a set we are ready to locate the requested element. Break the remaining element name down by the subfield separator, attempting to retrieve the element indicated by each step.
        if(element.indexOf(MSMUtils.SF_SEP) != -1) {
        StringTokenizer tokenizer = new StringTokenizer(element, new Character(MSMUtils.SF_SEP).toString());
        // Has to be at least two tokens
        if(tokenizer.countTokens() >= 2) {
            Element current_element = set.getElement(tokenizer.nextToken());
            while(current_element != null && tokenizer.hasMoreTokens()) {
            current_element = set.getElement(current_element, tokenizer.nextToken());
            }
            if(current_element != null) {
            result = new ElementWrapper(current_element);
            current_element = null;
            }
        }
        tokenizer = null;
        }
        // No subelements - much easier.
        if(result == null) {
        ///ystem.err.print("Trying to match element " + element +"?");
        Element temp = set.getElement(element);
        if(temp != null) {
            result = new ElementWrapper(temp);
        }
        temp = null;
        }
        set = null;
    }
    element = null;
    return result;
    }

    /** Retrieve a certain named element from a certain named set.
     * @param set The metadata set whose element you want.
     * @param name The name of the element.
     * @return An ElementWrapper around the requested element, or null if no such set or element.
     */
    public ElementWrapper getElement(String set, String name) {
    if(mds_hashtable.containsKey(set)) {
        MetadataSet temp = (MetadataSet)mds_hashtable.get(set);
        return new ElementWrapper(temp.getElement(name));
    }
    return null;
    }


    /** Retrieve the named metadata set.
     * @param name The sets name as a String.
     * @return The MetadataSet as named, or null if no such set.
     */
    public MetadataSet getSet(String namespace) {
    if(mds_hashtable.containsKey(namespace)) {
        return (MetadataSet) mds_hashtable.get(namespace);
    }
    return null;
    }

    /** Method to retrieve all of the metadata sets loaded in this collection. 
     * @return A Vector of metadata sets.
     */
    public Vector getSets() {
    return getSets(true);
    }

    public Vector getSets(boolean include_greenstone_extracted) {
    Vector result = new Vector();
    for(Enumeration keys = mds_hashtable.keys(); keys.hasMoreElements(); ) {
        MetadataSet set = (MetadataSet)mds_hashtable.get(keys.nextElement());
        if(!set.getNamespace().equals(HIDDEN) && (include_greenstone_extracted || !set.getNamespace().equals(Utility.EXTRACTED_METADATA_NAMESPACE))) {
        result.add(set);
        }
    }
    return result;
    }
  

    public MetadataSet loadMetadataSet(File metadata_set_file)
    {
        File[] all_sets = new File[MAX_LOADED_SETS];
        MetadataSet tempSet;
        int i = 0;
        System.err.println("Loading metadata set file " + metadata_set_file + "...");
    MetadataSet metadata_set = new MetadataSet(metadata_set_file);
        
        //write out existing namespaces to all_sets[]...we use this to determine if a set is
        //already loaded-Attila 
        for(Enumeration keys = mds_hashtable.keys(); keys.hasMoreElements(); ) {
        //System.err.println("keys: " + keys.nextElement() + "\n"); //debug
        tempSet = (MetadataSet)mds_hashtable.get(keys.nextElement());        
            all_sets[i] = tempSet.getFile();
            i++;
    }
        
        //Now check our metadata.set's namespace to see if it is already loaded in all_sets
        for(int p = 0 ; p < i; p++) {
        if(metadata_set.getFile().compareTo(all_sets[p]) == 0) {
        gemsptr.warn_cant_load_set();
        return null; 
        }
        }
    
        //check if this metadata set belongs to a collection
        //if so, then change the metadata set's name in the interface to (collection) dublin core...
    String sep = new String(metadata_set.getFile().separator);
    StringTokenizer st = new StringTokenizer(metadata_set.getFile().toString(), sep);
    String colName = new String("");
    
        while ( st.hasMoreTokens() )
        {
           if(st.nextToken().compareTo("collect") == 0) {
           colName = st.nextToken();  
           break;
           }   
        }

    if (colName.equals("")) {
        mds_hashtable.put(metadata_set.getNamespace(), metadata_set);
    } else {
        metadata_set.setCollection(colName);
        mds_hashtable.put(metadata_set.getNamespace(), metadata_set);
    }
    return metadata_set;
    }


    /**
       Method to remove an element or subelement from a metadata set
       @param element the element to remove, as an <strong>ElementWrapper</strong>
       @param parent the parent of the element, as an <strong>ElementWrapper</strong> This is required if removing a subelement (can be null - this means the parent is the metadataset root.)
       @return void
       Modified by Matthew Whyte 19/01/04

       This should really be totally replaced by MetadataSet.removeElement --Matthew
     */
    public void removeElement(ElementWrapper element, ElementWrapper parent) {
    // Retrieve the metadata set this element belongs to.
    String namespace = element.getNamespace();
    //System.err.println("namespace is: " + namespace); //debug
    MetadataSet set = (MetadataSet) mds_hashtable.get(namespace);
    if(set != null) {
        //Remove the element
        set.removeElement(element.getElement(), parent);
    }
    else {
        //This should not happen - no such set, no such element.
        System.err.println("Cannot remove element \'" + element + "\' because there is no such set \'" + namespace + "\'");
    }
    }


    /**
       Rename the metadata element.
       @param oldElement An <strong>ElementWrapper</strong> we wish to rename
       @param newName A <strong>String</strong> which contains the new name of the element.
       @return An <strong>ElementWrapper</strong> around the newly named element
    */
    public void renameElement(ElementWrapper oldElement, String newName)
    {
    //Retrive the metadata set this element belongs to.
    String namespace = oldElement.getNamespace();
    MetadataSet set = (MetadataSet)mds_hashtable.get(namespace);
    if(set != null)
        {
        //System.err.println("newName is: " + newName); //debug
        set.renameElement(oldElement.getElement(), newName); //Rename the element
        }
    else
        {
        System.err.println("No such set " + namespace);
        }
    }


    public void save() {
    File file = new File(Utility.METADATA_DIR);
       
    if (!file.exists()) {
        System.out.println("trying to save a collection and the metadata directory does not exist - creating it!");
        
        file.mkdir();
    }
    // And make back ups of all existing metadata set files.
    File temp[] = file.listFiles();
    
    // Now save the latest versions of the metadata sets.
    for(Enumeration keys = mds_hashtable.keys(); keys.hasMoreElements(); ) {
        String namespace = (String) keys.nextElement();
        MetadataSet set = (MetadataSet) mds_hashtable.get(namespace);
        try {
        // just use the existing file path
        File mds_file = set.getFile();
        XMLTools.writeXMLFile(mds_file, set.getDocument());
        set.setSetChanged(false);
        }
        catch (Exception error) {
        error.printStackTrace();
        }
    }
    }
    
    public void removeSet(MetadataSet set) {
    mds_hashtable.remove(set.getNamespace());
        File f =  set.getFile();
        f.delete();
    }
}