Metacat

/*

 * HarvestDocument.java

 *

 * Created on January 14, 2004, 4:37 PM

 */

package edu.ucsb.nceas.metacat.harvesterClient;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.IOException;

import java.io.StringReader;

import java.net.MalformedURLException;

import java.net.URL;

import edu.ucsb.nceas.metacat.client.InsufficientKarmaException;

import edu.ucsb.nceas.metacat.client.Metacat;

import edu.ucsb.nceas.metacat.client.MetacatException;

import edu.ucsb.nceas.metacat.client.MetacatInaccessibleException;

import edu.ucsb.nceas.utilities.IOUtil;

/**

 * HarvestDocument manages operations and data for a single document to be

 * harvested.

 * 

 * @author  costa

 */

public class HarvestDocument {

  private String documentName;  

  String documentType;

  String documentURL;

  private Harvester harvester;

  private HarvestSiteSchedule harvestSiteSchedule;

  int identifier;

  int revision;

  String scope;

  /**

   * Creates a new instance of HarvestDocument. Initialized with the data

   * that was read from a single <document> element in site document list.

   * 

   * @param harvester            the parent Harvester object

   * @param harvestSiteSchedule  the parent HarvestSiteSchedule object

   * @param scope                the value of the <scope> element

   * @param identifier           the value of the <identifier> element

   * @param revision             the value of the <revision> element

   * @param documentType         the value of the <documentType> element

   * @param documentURL          the value of the <documentURL> element

   */

  public HarvestDocument(

                          Harvester harvester,

                          HarvestSiteSchedule harvestSiteSchedule,

                          String scope,

                          int identifier,

                          int revision,

                          String documentType,

                          String documentURL

                        ) {

    this.harvester = harvester;

    this.harvestSiteSchedule = harvestSiteSchedule;

    this.documentType = documentType;

    this.documentURL = documentURL;

    this.scope = scope;

    this.identifier = identifier;

    this.revision = revision;

    this.documentName = scope + "." + identifier;

  }

  /**

   * Retrieve the document from the site using its <documentURL> value.

   * 

   * @return   A StringReader containing the document string.

   */

  private StringReader getSiteDocument() {

    String documentString;

    InputStream inputStream;

    InputStreamReader inputStreamReader;

    StringReader stringReader = null;

    URL url;

    try {

      url = new URL(documentURL);

      inputStream = url.openStream();

      inputStreamReader = new InputStreamReader(inputStream);

      documentString = IOUtil.getAsString(inputStreamReader, true);

      stringReader = new StringReader(documentString);

      harvester.addLogEntry(0, "", "GetDocSuccess", 

                            harvestSiteSchedule.siteScheduleID, null, "");

    }

    catch (MalformedURLException e) {

      harvester.addLogEntry(1, "MalformedURLException", "GetDocError", 

                            harvestSiteSchedule.siteScheduleID, this, 

                            "MalformedURLException: " + e.getMessage());

    }

    catch (IOException e) {

      harvester.addLogEntry(1, "IOException", "GetDocError", 

                            harvestSiteSchedule.siteScheduleID, this, 

                            "IOException: " + e.getMessage());

    }

    return stringReader;

  }

  /**

   * Harvest the document from the site. Unless Metacat already has the

   * document, retrieve the document from the site and put (insert or

   * update) it to Metacat. If Metacat already has the document, determine

   * the highest revision stored in Metacat so that this can be reported

   * back to the user.

   */

  public void harvestDocument() {

    int highestRevision;

    String metacatReturnString;

    StringReader stringReader;

    /* If metacat already has this document, determine the highest revision in

     * metacat and report it to the user; else, insert or delete the document 

     * into metacat.

     */

    if (metacatHasDocument()) {

      highestRevision = metacatHighestRevision();

      harvester.addLogEntry(0, 

                            "Metacat has document: " + documentName +

                            ", highest revision: " + highestRevision, 

                            "MetacatHasDoc", 

                            harvestSiteSchedule.siteScheduleID, null, "");

    }

    else {

      stringReader = getSiteDocument();

      if (stringReader != null) {

        if (parseDocument()) {

          putMetacatDocument(stringReader);

        }

      }

    }

  }

  /**

   * Logs a metacat document error to the harvest detail log. 

   *

   * @param insert               true if insert operation, false is update

   * @param metacatReturnString  string returned from the insert or update

   * @param exceptionName        name of the exception class

   * @param e                    the exception object

   */

  private void logMetacatError (boolean insert, 

                                String metacatReturnString,

                                String exceptionName,

                                Exception e

                               ) {

    if (insert) {

      harvester.addLogEntry(1, metacatReturnString, "InsertDocError", 

                                harvestSiteSchedule.siteScheduleID, 

                                this, exceptionName + ": " + e.getMessage());

    }

    else {

      harvester.addLogEntry(1, metacatReturnString, "UpdateDocError", 

                                harvestSiteSchedule.siteScheduleID, 

                                this, exceptionName + ": " + e.getMessage());

    }

  }

  /**

   * Boolean to determine whether Metacat already has this document.

   * 

   * @return  true if Metacat has the document, otherwise false

   */

  private boolean metacatHasDocument() {

    boolean     hasDocument = false;

    return hasDocument;

  }

  /**

   * Determines the highest revision that Metacat has for this document.

   * 

   * @return  int representing the highest revision for this document in Metacat

   */

  private int metacatHighestRevision() {

    int         highestRevision = 0;

    return highestRevision;

  }

  /**

   * Parse the document to determine whether it is valid EML prior to inserting

   * or updating it to Metacat. This is QA/QC measure. Currently unimplemented.

   * 

   * @return  true if the document is valid EML, otherwise false

   */

  private boolean parseDocument () {

    boolean success = true;

    if (success) {

      harvester.addLogEntry(0, "", "ValidateDocSuccess", 

                            harvestSiteSchedule.siteScheduleID, null, "");

    }

    else {

      harvester.addLogEntry(1, "Error validating document", "ValidateDocError", 

                            harvestSiteSchedule.siteScheduleID, this, "");

    }

    return success;

  }

  /**

   * Print the data fields and values in this HarvestDocument object.

   */

  void printOutput() {

    System.out.println("scope:                " + scope);

    System.out.println("identifier:           " + identifier);

    System.out.println("revision:             " + revision);

    System.out.println("documentType:         " + documentType);

    System.out.println("documentURL:          " + documentURL);

    System.out.println("documentName:         " + documentName);

  }

  /**

   * Insert or update this document to Metacat. If revision equals 1, do an

   * insert; otherwise, do an update.

   */

  private void putMetacatDocument(StringReader stringReader) {

    String docid = scope + "." + identifier + "." + revision;

    boolean insert = (revision == 1);

    Metacat metacat = harvester.metacat;

    String metacatReturnString = "";

    if (harvester.connectToMetacat()) {

      try {

        if (insert) {

          metacatReturnString = metacat.insert(docid, stringReader, null);

          harvester.addLogEntry(0, docid + " : " + metacatReturnString, 

                                "InsertDocSuccess", 

                                harvestSiteSchedule.siteScheduleID, 

                                null, "");

        }

        else {

          metacatReturnString = metacat.update(docid, stringReader, null);

          harvester.addLogEntry(0, docid + " : " + metacatReturnString, 

                                "UpdateDocSuccess", 

                                harvestSiteSchedule.siteScheduleID, 

                                null, "");

        }

      }

      catch (MetacatInaccessibleException e) {

        logMetacatError(insert, metacatReturnString, 

                        "MetacatInaccessibleException", e);

      }

      catch (InsufficientKarmaException e) {

        logMetacatError(insert, metacatReturnString, 

                        "InsufficientKarmaException", e);

      }

      catch (MetacatException e) {

        logMetacatError(insert, metacatReturnString, "MetacatException", e);

      }

      catch (IOException e) {

        logMetacatError(insert, metacatReturnString, "IOException", e);

      }

    }

  }

}