source: gli/trunk/src/org/greenstone/gatherer/collection/BasicCollectionConfiguration.java@ 16267

/**
 *#########################################################################
 *
 * 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.collection;

import java.io.*;
import org.greenstone.gatherer.DebugStream;
import org.greenstone.gatherer.Dictionary;
import org.greenstone.gatherer.cdm.CommandTokenizer;
import org.greenstone.gatherer.util.Codec;
import org.greenstone.gatherer.util.StaticStrings;
import org.greenstone.gatherer.util.XMLTools;
import org.w3c.dom.*;

/** This class provides access to a collection configuration file. This version accepts either a valid xml document or a historical collect.cfg file. */
public class BasicCollectionConfiguration
    implements Comparable {
    
    private File file;
    private String creator = "";
    private String description = "";
    private String maintainer = "";
    private String name = "";
    private String is_public = "";
    private String collectgroup = "false";
    
    private String site = null; // used for gs3 colls
    
    public BasicCollectionConfiguration(File file) {
    this.file = file;
    try {
        String filename = file.getName().toLowerCase();
        if(!file.exists()) {
        return;
        }
        if(filename.endsWith(".cfg")) {
        FileInputStream fis = new FileInputStream(file);
        InputStreamReader isr = new InputStreamReader(fis, "UTF-8");
        BufferedReader br = new BufferedReader(isr);
        String command = null;
        while((command = br.readLine()) != null) {
            if(command.length() > 0) {
            // We have to test the end of command for the special character '\'. If found, remove it and append the next line, then repeat.
            while(command.trim().endsWith("\\")) {
                command = command.substring(0, command.lastIndexOf("\\"));
                String next_line = br.readLine();
                if (next_line != null) {
                command = command + "\n" + next_line;
                }
                next_line = null;
            }
            CommandTokenizer tokenizer = new CommandTokenizer(command, br);
            String command_type_str = tokenizer.nextToken();
            if (command_type_str == null) {
                // Bad command. Do nothing
                continue;
            }

            command_type_str = command_type_str.toLowerCase();
            if(command_type_str.equals(StaticStrings.COLLECTIONMETADATA_CREATOR_STR)) {
                creator = tokenizer.nextToken();
            }
            else if(command_type_str.equals(StaticStrings.COLLECTIONMETADATA_MAINTAINER_STR)) {
                maintainer = tokenizer.nextToken();
            }
            else if(command_type_str.equals(StaticStrings.COLLECTIONMETADATA_COLLECTGROUP_STR)) {
                collectgroup = tokenizer.nextToken();
            }
            else if(command_type_str.equalsIgnoreCase(StaticStrings.COLLECTIONMETADATA_STR)) {
                String meta_type_str = tokenizer.nextToken();
                String value_str = tokenizer.nextToken();
                // check for language
                String language_str = StaticStrings.ENGLISH_LANGUAGE_STR; // assume the no-lang ones are english, but we shouldn't really do this.
                if(meta_type_str != null && value_str != null) {
                meta_type_str = meta_type_str.toLowerCase();
                if(value_str.startsWith(StaticStrings.LBRACKET_CHARACTER) && value_str.endsWith(StaticStrings.RBRACKET_CHARACTER)) {
                    language_str = value_str.substring(value_str.indexOf(StaticStrings.EQUALS_CHARACTER) + 1, value_str.length() - 1);
                    language_str = language_str.toLowerCase();
                    value_str = tokenizer.nextToken();
                }
                // now we can work out which coll meta we are dealing with
                if (meta_type_str.equals(StaticStrings.COLLECTIONMETADATA_COLLECTIONNAME_STR)) {
                    // If this is the first collection title found, then use it, otherwise search for one that more closely matches our choosen interface language
                    if (name == null || language_str.equals(Dictionary.getLanguage())) {
                    name = Codec.transform(value_str, Codec.GREENSTONE_TO_TEXT);
                    }
                }
                else if (meta_type_str.equals(StaticStrings.COLLECTIONMETADATA_COLLECTIONEXTRA_STR)) {
                    // Again we are either looking for the first description, then after that a language specific one
                    if (description == null || language_str.equals(Dictionary.getLanguage())) {
                    description = Codec.transform(value_str, Codec.GREENSTONE_TO_TEXT);
                    }
                }
                }
                language_str = null;
                value_str = null;
                meta_type_str = null;
            } else {
                // we want to process all the tokens to make sure we get rid of multi line commands before trying to find the next one
                while (tokenizer.hasMoreTokens()) {
                    tokenizer.nextToken();
                }

            } // end of coll meta bit
            command_type_str = null;
            tokenizer = null;
            } // if command.length > 0
        } // while
        command = null;
        br.close();
        isr.close();
        br = null;
        isr = null;
        } // cfg file
        ///ystem.err.println("Parsed collect.cfg");
        ///ystem.err.println("name      = " + name);
        ///ystem.err.println("creator    = " + creator);
        ///ystem.err.println("maintainer  = " + maintainer);
        ///ystem.err.println("description = " + description);

        if(filename.endsWith(".xml")) {
        
        Document xml_file_doc = XMLTools.parseXMLFile(file);
        Element root = xml_file_doc.getDocumentElement();

        Node metadataListNode = XMLTools.getChildByTagNameIndexed(root, StaticStrings.METADATALIST_STR, 0);
        Node displayItemListNode = XMLTools.getChildByTagNameIndexed(root, StaticStrings.DISPLAYITEMLIST_STR, 0);
        String []strings = {creator,
                    maintainer,
                    is_public,
                    name,
                    description};
        String []att_names = {StaticStrings.COLLECTIONMETADATA_CREATOR_STR, 
                      StaticStrings.COLLECTIONMETADATA_MAINTAINER_STR,
                      StaticStrings.COLLECTIONMETADATA_PUBLIC_STR,
                      StaticStrings.NAME_STR,
                      StaticStrings.DESCRIPTION_STR};
        for (int i=0; i<strings.length; i++) {  
            Element e = XMLTools.getNamedElement((Element)metadataListNode, 
                StaticStrings.METADATA_STR, StaticStrings.NAME_ATTRIBUTE, att_names[i]);
            if (i >=3) {
            e = XMLTools.getNamedElement((Element)displayItemListNode, 
                  StaticStrings.DISPLAYITEM_STR, StaticStrings.NAME_ATTRIBUTE, att_names[i]);
            }
            if (e == null) {
            continue;
            }
            strings[i] = XMLTools.getNodeText(e);
        }

        }
    }
    catch(Exception error) {
        DebugStream.println("Error in CollectionConfiguration.<init>(): " + error);
        DebugStream.printStackTrace(error);
    }

    }

    /** Compare this configuration to another for ordering, which essentially compares two strings for ordering.
     * @param other the other Object which is presumably another basic collection configuration
     * @return an integer which is either <0, 0 or >0 if this configuration is naturally less than, equal to or greater than the target object
     */
    public int compareTo(Object other) {
    if(other == null) {
        return -1;
    }
    return toString().compareTo(other.toString());
    }

    public boolean equals(Object other) {
    return (compareTo(other) == 0);
    }

    /** Retrieve the creators email for this collection.
     * @return a String
     */
    public String getCreator() {
    return creator;
    }

    public String getDescription() {
    return description;
    }

    public File getFile() {
    return file;
    }
    
    public String getMaintainer() {
    return maintainer;
    }

    public String getName() {
    return name;
    }

    public String getIsPublic() {
    return is_public;
    }

    public String getCollectGroup() {
    return collectgroup;
    }
    
    /** Retrieve the short name for this collection which, given this current file is in <col_name>/etc/collect.cfg, is the name of this file's parent file's parent.
     * @return the short name of this collection as a String
     */
    public String getShortName() {
    return file.getParentFile().getParentFile().getName();
    }
    
    /** set the site for this coll */
    public void setSite(String site) {
    this.site = site;
    }
    
    
    /** Display the title for this collection. */
    public String toString() {
    if (this.site == null) {
        return getName() + StaticStrings.SPACE_CHARACTER + StaticStrings.OPEN_PARENTHESIS_CHARACTER + getShortName() + StaticStrings.CLOSE_PARENTHESIS_CHARACTER;
    } else {
        return getName() + StaticStrings.SPACE_CHARACTER + StaticStrings.OPEN_PARENTHESIS_CHARACTER + getShortName()+", "+this.site + StaticStrings.CLOSE_PARENTHESIS_CHARACTER;
    }
    }
}