Metacat

use Digest::SHA1;

use File::stat;

use File::Basename;

$config->define("hasUpload", { DEFAULT => 'false'} );

$config->define("loginFormTemplate", { DEFAULT => 'loginForm.tmpl'} );

my $hasUpload = $config->hasUpload();

debug("Registry: Initialized -- stage set: $FORM::stage");

# Must have a config to use Metacat

if (!hasContent($FORM::cfg)) {

    debug("Registry: No configuration set.");

    print "Content-type: text/html\n\n";

    $$templateVars{'message'} = 'Error: The registry requires a skin name to continue.';

    $template->process( $loginFormTemplate, $templateVars);

    exit(0);

}

# Metacat isn't initialized, the registry will fail in strange ways.

if (!hasContent($metacatUrl)) {

    debug("Registry: No Metacat.");

    print "Content-type: text/html\n\n";

    $$templateVars{'message'} = 'Error: Metacat is not initialized! Make sure' . 

        ' MetacatUrl is set correctly in ' .  $FORM::cfg . '.cfg';

    $template->process( $loginFormTemplate, $templateVars);

    exit(0);

}

    if ( $session->is_empty ) {

        $$templateVars{'showInstructions'} = 'true';

        $$templateVars{'message'} = 'You must login to register your dataset.';

      $$templateVars{'hasUpload'} = $hasUpload;

# Create a metacat object

my $metacat = Metacat->new($metacatUrl);

    # Login to metacat

    my ($dname, $userPass) = getCredentials();

    my $response = $metacat->login($dname, $userPass);

    #my $testFile = $tmpdir . "/test-file.xml";

    #open (TFILE,">$testFile") || die ("Cant open xml file...\n");

    #print TFILE $xmldoc;

    #close(TFILE);

        debug("No response from Metacat");

  $metacat = Metacat->new($metacatUrl);

  my $errormsg = 0;

      # FIXME: skins dir isn't generally writeable by the HTTP server, use tmp instead

  #$metacat = Metacat->new($metacatUrl);

  #debug("scopeFile: $scopeFile");

    # scw: commented these out, don't seem to be matched to cfg setting

    #push(@invalidParams, "Data medium is missing.")

    #unless (hasContent($FORM::dataMedium) || $FORM::dataMedium =~ /elect/);

    #push(@invalidParams, "Usage rights are missing.")

    #unless (hasContent($FORM::useConstraints));

################################################################################

#

# Upload new file objects into Metacat, if they're present and valid.

#

################################################################################

sub allFileData {

    my %uploadedFiles = ();

    my $fileInfo;

    my $docid;

    for (my $fileNum = 0; $fileNum <= $FORM::upCount; $fileNum++) {

        my $fn = 'upload_' . $fileNum;

        if (hasContent(param($fn))) {

            debug("Registry: retrieving metadata for file: $fn");

            ($docid, $fileInfo) = fileMetadata($fileNum);

            $uploadedFiles{ $docid } = $fileInfo;

        }

    }

    return %uploadedFiles;

}

sub fileMetadata {

    my $fileNum = shift;

    my $fileHash = param("upload_$fileNum");

    my $fileName = param("uploadname_$fileNum");

    my $contentType = param("uploadtype_$fileNum");

    my $cleanName = $fileName;

    # normalize input filenames; Windows filenames include full paths

    $cleanName =~ s/.*[\/\\](.*)/$1/;

    my $outFile = $tmpdir . "/" . $cleanName;

    #debug("Reading file from disk: $outFile");

    my $fileSize = stat($outFile)->size;

    if ($fileSize == 0) {

        push(@errorMessages, "file $fileName is zero bytes!");

        debug( "Registry: file $fileName is zero bytes!");

    }

    # Now the file is on disk, send the object to Metacat

    my $session = CGI::Session->load();

    if ( $session->is_empty ) {

        push(@errorMessages, "Must be logged in to upload files.");

        debug( "Not logged in, cannot upload files.");

        return 0;

    }

    #my ($dname, $userPass) = getCredentials();

    #debug("Logging in with $dname, $userPass");

    #$metacat->login($username, $password);

    my $docid = newAccessionNumber($defaultScope);

    my $unique = uploadData($outFile, $docid);

    if (!$unique) {

        debug( "Registry: Updating lastid file");

        updateLastId($defaultScope);

    }

    my $entityid = $fileHash."001";

    my $distribid = $fileHash."002";

    my $uploadUrl = 'ecogrid://knb/' . $docid;

    # TODO:  should match the object promotion path, so that an

    #        Excel upload results in 'dataTable' in this field

    my $entityType = 'Other';

    my %dataInfo = (  'docid'       => $docid,

                      'entityid'    => $entityid,

                      'distribid'   => $distribid,

                      'fileName'    => $cleanName,

                      'fileSize'    => $fileSize,

                      'fileHash'    => $fileHash,

                      'contentType' => $contentType,

                      'url'         => $uploadUrl,

                      'entityType'  => $entityType,

                   );

    return ($docid, \%dataInfo);

}

sub processFile {

    my $fileName = shift;

    # test that we actually got a file

    if(!$fileName || cgi_error()) {

        debug("Error receiving file ". cgi_error());

    }

    # write file to disk, get SHA1 hash and size

    my ($outFile, $fileHash) = writeFile($fileName);

    my $fileSize = stat($outFile)->size;

    if ($fileSize == 0) {

        push(@errorMessages, "file $fileName is zero bytes!");

        debug( "Registry: file $fileName is zero bytes!");

    }

    # file is in Metacat, generate the pertinent EML elements

    my $contentType = uploadInfo($fileName)->{'Content-Type'};

    my %dataInfo = ( 'fileName'    => $fileName,

                     'fileHash'    => $fileHash,

                     'contentType' => $contentType,

                   );

    return \%dataInfo;

}

sub writeFile {

    my $fileName = shift;

    my $fileData;

    my $length = 0;

    my $buffer;

    my $cleanName = $fileName;

    # normalize input filenames; Windows filenames include full paths

    $cleanName =~ s/.*[\/\\](.*)/$1/;

    while (my $bytesRead = read($fileName, $buffer, 4096)) {

        $fileData .= $buffer;

        $length += $bytesRead;

    }

    # create SHA1 sum to store file hash

    my $ctx = Digest::SHA1->new;

    $ctx->add($fileData);

    my $digest = $ctx->hexdigest;

    my $outputName = $tmpdir . "/" . $cleanName;

    open(OUT,">$outputName") or die "Could not open: $!";

    print OUT $fileData;

    close(OUT);

    debug("Registry: output is: $outputName, length is: $length");

    return ($outputName, $digest);

}

sub uploadData {

    my $data = shift;

    my $docid = shift;

    debug("Registry: Upload -- Starting upload of $docid");

    my $response = $metacat->upload($docid, $data);

    if (!$response) {

        my $uploadMsg = $metacat->getMessage();

        debug("Registry: Upload -- Error is: $uploadMsg");

    } else {

        debug("Registry: Upload -- Success! New docid $docid");

    }

}

    #FIXME placeholder for $FORM element, should be determined by config

    if ($FORM::cfg eq "ebm") {

        return createProjectDocument();

    } else {

        return createDatasetDocument();

    }

}

sub createProjectDocument {

    my $doc = EMLStart();

    $doc .= titleElement();

    $doc .= creatorNameElement();

    $doc .= creatorElement();

    $doc .= pubElement();

    $doc .= setDisplayType('project');

    $doc .= keywordElement();

    $doc .= contactElement();

    # putting everything else under project

    $doc .= "<project>";

    $doc .= titleElement();

    my %originators = personnelCreate();

    $doc .= personnelList(\%originators, 'personnel');

    $doc .= abstractElement();

    $doc .= "<studyAreaDescription>\n";

    $doc .= coverageElement();

    $doc .= "</studyAreaDescription>\n";

    $doc .= "</project>";

    $doc .= accessElement();

    $doc .= datasetEnd();

    $doc .= EMLEnd();

    return $doc;

}

sub createDatasetDocument {

    my $doc = EMLStart();

    $doc .= titleElement();

    $doc .= creatorElement();

    $doc .= contactElement('creator');

    my %originators = personnelCreate();

    $doc .= personnelList(\%originators, 'associatedParty');

    $doc .= pubElement();

    $doc .= abstractElement();

#    $doc .= setDisplayType('dataset');

    $doc .= keywordElement();

    $doc .= distributionElement();

    $doc .= coverageElement();

    $doc .= contactElement();

    $doc .= methodsElement();

    $doc .= accessElement();

    my %fileData = allFileData();

    $doc .= entityElement(\%fileData);

    $doc .= datasetEnd();

    $doc .= addMetaElement(\%fileData);

    $doc .= EMLEnd();

}

# EML document creation functions

sub personnelCreate {

    # TODO: improve flow for personnel, associatedParty

    # element name => objects of that type

    my %orig = (

                'personnel'          => [],

            );

    push (@{$orig{personnel}}, [$FORM::providerGivenName, $FORM::providerSurName, 'Metadata Provider']);

    # Additional originators

    foreach my $origName (param()) {

        my $origNum = $origName;

        $origNum =~ s/origNamelast//; # get the index of the parameter 0 to 10

        if ( $origNum =~ /^([0-9])$/) {

            # do not generate EML for empty originator fields

            if (hasContent(param("origNamefirst" . $origNum))) {

                my $first = normalize(param("origNamefirst" . $origNum));

                my $last  = normalize(param("origNamelast" . $origNum));

                my $origRole = param("origRole" . $origNum);

                push (@{$orig{personnel}}, [$first, $last, $origRole]);

            }

        }

    }

    return %orig

}

sub personnelList {

    my ($orig, $type) = @_;

    my %orig = %$orig;

    my $elemList = "";

    foreach my $v (@{$orig->{'personnel'}}) {

        my ($first, $last, $role) = @$v;

        my $elemRole = $type;

        my $elem = "<individualName>\n";

        $elem .= "<givenName>".normalize($first)."</givenName>\n";

        $elem .= "<surName>".normalize($last)."</surName>\n";

        $elem .= "</individualName>\n";

        if ($role eq "Originator") {

            $elemRole = 'creator';

        }

        elsif ($role eq "Metadata Provider") {

            $elemRole = 'metadataProvider';

        }

        elsif ($role eq "Publisher") {

            $elemRole = 'publisher';

        }

        else {

            $elemRole = $type;

        }

        if (($elemRole eq 'personnel') && ($FORM::origNameOrgContact) ) {

            $elem .= "<organizationName>$FORM::origNameOrgContact</organizationName>\n";

        }

        if (($elemRole eq 'personnel') || ($elemRole eq 'associatedParty') ) {

            $elem .= "<role>".normalize($role)."</role>\n";

        }

        $elemList .= "<$elemRole>\n$elem</$elemRole>\n";

    }

    return $elemList;

}

sub entityElement() {

    my $entityObjects = shift;

    my %entityObjects = %$entityObjects;

    my $entityList = "";

    while ( my ($docid, $data) = each(%entityObjects) ) {

        my $entityStub = qq|<otherEntity id="$data->{'entityid'}" scope="document">

            <entityName>$data->{'fileName'}</entityName>

            <physical scope="document">

                <objectName>$data->{'fileName'}</objectName>

                <size>$data->{'fileSize'}</size>

                <authentication method="SHA1">$data->{'fileHash'}</authentication>

                <dataFormat>

                    <externallyDefinedFormat>

                        <formatName>$data->{'contentType'}</formatName>

                    </externallyDefinedFormat>

                </dataFormat>

                <distribution id="$data->{'distribid'}" scope="document">

                    <online>

                        <url function="download">$data->{'url'}</url>

                    </online>

                </distribution>

            </physical>

            <entityType>$data->{'entityType'}</entityType>

    </otherEntity>

|;

    $entityList .= $entityStub;

    }

    return $entityList;

}

sub addMetaElement() {

    my $entityObjects = shift;

    my %entityObjects = %$entityObjects;

    my $accessList = "";

    while ( my ($docid, $data) = each(%entityObjects) ) {

        my $accessStub = qq|<additionalMetadata>

            <describes>$data->{'distribid'}</describes>

                <access authSystem="knb" order="allowFirst">

                    <deny>

                        <principal>public</principal>

                        <permission>read</permission>

                    </deny>

                </access>

      </additionalMetadata>

    |;

        $accessList .= $accessStub;

    }

  return $accessList;

}

sub keywordElement() {

    my %kwSet, my $kwList = (), "";

    # process the standard keywords

    foreach my $kwName (param()) {

        my $kwNum = $kwName;

        $kwNum =~ s/keyword//; # get the index of the parameter 0, ..., 10

        if ( $kwNum =~ /^([0-9])$/ ){

            # don't generate xml for empty keyword fields

            # don't generate taxonomic keyword fields, those go in taxonomic coverage

            if (hasContent(param($kwName))) {

                my $kwType = param("kwType" . $kwNum);

                my $kwTh   = param("kwTh" . $kwNum);

                my $kw     = param("keyword" . $kwNum);

                push(@{$kwSet{$kwTh}}, [$kw, $kwType]);

            }

        }

    }

    # output keyword lists

    while ((my $thesaurus, my $a_ref) = each %kwSet) {

        my $kwElem .= "<keywordSet>\n";

        foreach my $x (@$a_ref) {

            my ($kw, $kwType) = @$x;

            $kwElem .= "<keyword ";

            if (hasContent($kwType) && $kwType != "None") {

                 $kwElem.= "keywordType=\"".lc($kwType)."\"";

            }

            $kwElem .= ">$kw</keyword>\n";

        }

        $kwElem .= "<keywordThesaurus>".normalize($thesaurus)."</keywordThesaurus>\n";

        $kwElem .= "</keywordSet>\n";

        $kwList .= $kwElem;

    }

    return $kwList;

}

sub EMLStart() {

    my $gmt = gmtime($now);

    $doc .= "<eml:eml

                      packageId=\"docid\" system=\"knb\"

                      xmlns:eml=\"eml://ecoinformatics.org/eml-2.0.1\"

                      xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"

                      xmlns:ds=\"eml://ecoinformatics.org/dataset-2.0.1\"

                      xmlns:stmml=\"http://www.xml-cml.org/schema/stmml\"

                      xsi:schemaLocation=\"eml://ecoinformatics.org/eml-2.0.1 eml.xsd\">\n";

    return $doc;

}

sub EMLEnd() {

    return  "</eml:eml>\n";

}

sub datasetEnd() {

    return "</dataset>\n";

}

sub setDisplayType {

   my $kwDisp = shift;

   if (!$kwDisp) {

       $kwDisp = 'dataset';

   }

   my $kw = "<keywordSet>\n";

   $kw .= "  <keyword>$kwDisp</keyword>\n";

   $kw .= "  <keywordThesaurus>EMLDisplayType</keywordThesaurus>\n";

   $kw .= "</keywordSet>\n";

   return $kw;

}

sub pubElement() {

    #add the publication Date to the eml document.

    my ($Day, $Month, $Year) = (localtime)[3,4,5];

    return "<pubDate>".sprintf("%03d-%02d-%02d", $Year + 1900, $Month + 1, $Day)."</pubDate>\n";

}

sub titleElement() {

        return "<title>".normalize($FORM::title)."</title>\n";

}

sub abstractElement() {

    return "<abstract>\n<para>".normalize($FORM::abstract)."</para>\n</abstract>\n";

}

sub creatorElement() {

    my $creators;

    if ($FORM::cfg eq 'nceas') {

        for (my $i = 0; $i < scalar(@FORM::wg); $i++) {

            $creators .= creatorNode($FORM::wg[$i]);

        }

    } else {

        $creators .= creatorNode($FORM::site);

    if ($FORM::cfg ne 'knb') {

        $creators .= creatorNode();

    }

    return $creators;

}

sub creatorNode {

    my $org = shift;

    my $content = "";

    if (!hasContent($org)) {

        $content = $organization;

    } else {

        $content = $org;

    return

    "<creator>\n<organizationName>".normalize($content)."</organizationName>\n</creator>\n";

}

sub creatorNameElement {

    my $role = shift;

    my $creator;

    if (!hasContent($role)) {

        $role ="creator";

    }

    $creator .= "<individualName>\n";

    $creator .= "<givenName>".normalize($FORM::origNamefirst0)."</givenName>\n";

    $creator .= "<surName>".normalize($FORM::origNamelast0)."</surName>\n";

    $creator .= "</individualName>\n";

    return "<$role>\n$creator</$role>\n"

}

sub methodsElement() {

    my $methods = "";

    if ((hasContent($FORM::methodTitle)) || scalar(@FORM::methodsPara) > 0 || ($FORM::methodPara[0] ne "")) {

        $methods = "<methods><methodStep><description><section>\n";

        if (hasContent($FORM::methodTitle)) {

            $methods .= "<title>".normalize($FORM::methodTitle)."</title>\n";

        for (my $i = 0; $i < scalar(@FORM::methodPara); $i++) {

            $methods .= "<para>".normalize($FORM::methodPara[$i])."</para>\n";

        $methods .= "</section></description></methodStep>\n";

        if (hasContent($FORM::studyExtentDescription)) {

            $methods .= "<sampling><studyExtent><description>\n";

            $methods .= "<para>".normalize($FORM::studyExtentDescription)."</para>\n";

            $methods .= "</description></studyExtent>\n";

            $methods .= "<samplingDescription>\n";

            $methods .= "<para>".normalize($FORM::samplingDescription)."</para>\n";

            $methods .= "</samplingDescription>\n";

            $methods .= "</sampling>\n";

        $methods .= "</methods>\n";

    return $methods

}

sub contactElement() {

    my $role = shift;

    my $cont = "";

    if (!hasContent($role)) {

        $role = 'contact';

    $cont .= "<individualName>\n";

    $cont .= "<givenName>".normalize($FORM::origNamefirstContact)."</givenName>\n";

    $cont .= "<surName>".normalize($FORM::origNamelastContact)."</surName>\n";

    $cont .= "</individualName>\n";

    if (hasContent($FORM::origDeliveryContact) ||

        hasContent($FORM::origCityContact) ||

        (hasContent($FORM::origStateContact) &&

        ($FORM::origStateContact !~ "Select state here.")) ||

        hasContent($FORM::origStateOtherContact) ||

        hasContent($FORM::origZIPContact) ||

        hasContent($FORM::origCountryContact)) {

        $cont .= "<address>\n";

        if (hasContent($FORM::origDeliveryContact)) {

            $cont .= "<deliveryPoint>".normalize($FORM::origDeliveryContact);

            $cont .= "</deliveryPoint>\n";

        if (hasContent($FORM::origCityContact)) {

            $cont .= "<city>".normalize($FORM::origCityContact)."</city>\n";

        if (hasContent($FORM::origStateContact) &&

            ($FORM::origStateContact !~ "Select state here.")) {

            $cont .= "<administrativeArea>".normalize($FORM::origStateContact);

            $cont .= "</administrativeArea>\n";

        } elsif (hasContent($FORM::origStateOtherContact)) {

            $cont .= "<administrativeArea>".normalize($FORM::origStateOtherContact);

            $cont .= "</administrativeArea>\n";

        }

        if (hasContent($FORM::origZIPContact)) {

            $cont .= "<postalCode>".normalize($FORM::origZIPContact)."</postalCode>\n";

        }

        if (hasContent($FORM::origCountryContact)) {

            $cont .= "<country>".normalize($FORM::origCountryContact)."</country>\n";

        }

        $cont .= "</address>\n";

    }

    if (hasContent($FORM::origPhoneContact)) {

        $cont .= "<phone>".normalize($FORM::origPhoneContact)."</phone>\n";

    }

    if (hasContent($FORM::origEmailContact)) {

        $cont .= "<electronicMailAddress>".normalize($FORM::origEmailContact);

        $cont .= "</electronicMailAddress>\n";

    return "<$role>\n$cont</$role>\n";

}

sub coverageElement(){

    my $cov = "";

    # temporal coverage

    if (hasContent($FORM::endingYear)) {

        $cov .= "<temporalCoverage>\n";

        $cov .= "<rangeOfDates>\n";

        if (hasContent($FORM::beginningMonth)) {

            my $month = ("JAN","FEB","MAR","APR","MAY","JUN",

                         "JUL","AUG","SEP","OCT","NOV","DEC")

            [$FORM::beginningMonth - 1];

            if (hasContent($FORM::beginningDay)) {

                $cov .= "<beginDate>\n";

                $cov .= "<calendarDate>";

                $cov .= normalize($FORM::beginningYear)."-".normalize($FORM::beginningMonth)."-".normalize($FORM::beginningDay);

                $cov .= "</calendarDate>\n";

                $cov .= "</beginDate>\n";

            } else {

                $cov .= "<beginDate>\n";

                $cov .= "<calendarDate>";

                $cov .= normalize($FORM::beginningYear)."-".normalize($FORM::beginningMonth)."-01";

                $cov .= "</calendarDate>\n";

                $cov .= "</beginDate>\n";

            }

        } else {

            $cov .= "<beginDate>\n";

            $cov .= "<calendarDate>";

            $cov .= normalize($FORM::beginningYear);

            $cov .= "</calendarDate>\n";

            $cov .= "</beginDate>\n";

        }

        if (hasContent($FORM::endingMonth)) {

            my $month = ("JAN","FEB","MAR","APR","MAY","JUN",

                 "JUL","AUG","SEP","OCT","NOV","DEC")

            [$FORM::endingMonth - 1];

            if (hasContent($FORM::endingDay)) {

                $cov .= "<endDate>\n";

                $cov .= "<calendarDate>";

                $cov .= normalize($FORM::endingYear)."-".normalize($FORM::endingMonth)."-".normalize($FORM::endingDay);

                $cov .= "</calendarDate>\n";

                $cov .= "</endDate>\n";

            } else {

                $cov .= "<endDate>\n";

                $cov .= "<calendarDate>";

                $cov .= normalize($FORM::endingYear)."-".normalize($FORM::endingMonth)."-01";

                $cov .= "</calendarDate>\n";

                $cov .= "</endDate>\n";

        } else {

            $cov .= "<endDate>\n";

            $cov .= "<calendarDate>";

            $cov .= normalize($FORM::endingYear);

            $cov .= "</calendarDate>\n";

            $cov .= "</endDate>\n";

        $cov .= "</rangeOfDates>\n";

        $cov .= "</temporalCoverage>\n";

    } else {

        if(hasContent($FORM::beginningYear)) {

            $cov .= "<temporalCoverage>\n";

            $cov .= "<singleDateTime>\n";

            if (hasContent($FORM::beginningMonth)) {

                my $month = ("JAN","FEB","MAR","APR","MAY","JUN",

                             "JUL","AUG","SEP","OCT","NOV","DEC")

                [$FORM::beginningMonth - 1];

                if (hasContent($FORM::beginningDay)) {

                    $cov .= "<calendarDate>";

                    $cov .= normalize($FORM::beginningYear)."-".normalize($FORM::beginningMonth)."-".normalize($FORM::beginningDay);

                    $cov .= "</calendarDate>\n";

                } else {

                    $cov .= "<calendarDate>";

                    $cov .= normalize($FORM::beginningYear)."-".normalize($FORM::beginningMonth)."-01";

                    $cov .= "</calendarDate>\n";

                }

            } else {

                $cov .= "<calendarDate>";

                $cov .= normalize($FORM::beginningYear);

                $cov .= "</calendarDate>\n";

            $cov .= "</singleDateTime>\n";

            $cov .= "</temporalCoverage>\n";

    # geographic coverage

    if(hasContent($FORM::geogdesc) || ($FORM::latDeg1 < 91 && $FORM::latDeg1 > -1 && $FORM::longDeg1 < 181 && $FORM::longDeg1 > -1)) {

        $cov .= "<geographicCoverage>\n";

        if(hasContent($FORM::geogdesc)) {

            $cov .= "<geographicDescription>".normalize($FORM::geogdesc)."</geographicDescription>\n";

        }

        if($latDeg1 < 91 && $latDeg1 > -1 && $longDeg1 < 181 && $longDeg1 > -1) {

            $cov .= "<boundingCoordinates>\n";

            # if the second latitude is missing, then set the second lat/long pair

            # equal to the first this makes a point appear like a rectangle

            if ($FORM::useSiteCoord || ($FORM::latDeg2 eq "" && $FORM::latMin2 eq "" && $FORM::latSec2 eq "")) {

                $latDeg2 = $latDeg1;

                $latMin2 = $latMin1;

                $latSec2 = $latSec1;

                $hemisphLat2 = $hemisphLat1;

                $longDeg2 = $longDeg1;

                $longMin2 = $longMin1;

                $longSec2 = $longSec1;

                $hemisphLong2 = $hemisphLong1;

            else

            {

                $latDeg2 = $FORM::latDeg2;

                $latMin2 = $FORM::latMin2;

                $latSec2 = $FORM::latSec2;

                $hemisphLat2 = $FORM::hemisphLat2;

                $longDeg2 = $FORM::longDeg2;

                $longMin2 = $FORM::longMin2;

                $longSec2 = $FORM::longSec2;

                $hemisphLong2 = $FORM::hemisphLong2;

            }

            my $hemisph;

            $hemisph = ($hemisphLong1 eq "W") ? -1 : 1;

            $cov .= "<westBoundingCoordinate>";

            my $var = $hemisph * ($longDeg1 + (60*$longMin1+$longSec1)/3600);

            $cov .= sprintf("%.4f\n", $var);

            $cov .= "</westBoundingCoordinate>\n";

            $hemisph = ($hemisphLong2 eq "W") ? -1 : 1;

            $cov .= "<eastBoundingCoordinate>";

            $var = $hemisph * ($longDeg2 + (60*$longMin2+$longSec2)/3600);

            $cov .= sprintf("%.4f\n", $var);

            $cov .= "</eastBoundingCoordinate>\n";

            $hemisph = ($hemisphLat1 eq "S") ? -1 : 1;

            $cov .= "<northBoundingCoordinate>";

            $var = $hemisph * ($latDeg1 + (60*$latMin1+$latSec1)/3600);

            $cov .= sprintf("%.4f\n", $var);

            $cov .= "</northBoundingCoordinate>\n";

            $hemisph = ($hemisphLat2 eq "S") ? -1 : 1;

            $cov .= "<southBoundingCoordinate>";

            $var = $hemisph * ($latDeg2 + (60*$latMin2+$latSec2)/3600);

            $cov .= sprintf("%.4f\n", $var);

            $cov .= "</southBoundingCoordinate>\n";

            $cov .= "</boundingCoordinates>\n";

        }

        $cov .= "</geographicCoverage>\n";

    # taxonomic coverage

    return "<coverage>\n$cov</coverage>\n"; 

}

sub distributionElement() {

    my $dist = "";

    if (hasContent($FORM::addComments)) {

        $dist .= "<additionalInfo>\n";

        $dist .= "<para>".normalize($FORM::addComments)."</para>\n";

        $dist .= "</additionalInfo>\n";

    if (hasContent($FORM::useConstraints) ||

        hasContent($FORM::useConstraintsOther)) {

        $dist .= "<intellectualRights>\n";

        if (hasContent($FORM::useConstraints)) {

            $dist .= "<para>".normalize($FORM::useConstraints)."</para>\n";

        if (hasContent($FORM::useConstraintsOther)) {

            $dist .= "<para>".normalize($FORM::useConstraintsOther)."</para>\n";

        $dist .= "</intellectualRights>\n";

    if (hasContent($FORM::url)) {

        $dist .= "<distribution>\n";

        $dist .= "<online>\n";

        $dist .= "<url>".normalize($FORM::url)."</url>\n";

        $dist .= "</online>\n";

        $dist .= "</distribution>\n";

    }

    $dist .= "<distribution>\n";

    $dist .= "<offline>\n";

    $dist .= "<mediumName>" . normalize($FORM::dataMedium)." ".normalize($FORM::dataMediumOther);

    $dist .= "</mediumName>\n";

    $dist .= "</offline>\n";

    $dist .= "</distribution>\n";

    return $dist;

}

#

sub accessElement {

    my $access = "";

    $access .= "<access authSystem=\"knb\" order=\"denyFirst\">\n";

    $access .= "<allow>\n";

    $access .= "<principal>$username</principal>\n";

    $access .= "<permission>all</permission>\n";

    $access .= "</allow>\n";

    if($FORM::username ne ''){

            $access .= "<allow>\n";

            $access .= "<principal>uid=$FORM::username,o=$FORM::organization,dc=ecoinformatics,dc=org</principal>\n";

            $access .= "<permission>all</permission>\n";

            $access .= "</allow>\n";

        my $session = CGI::Session->load();

            if ( !$session->is_empty ) {

                my $username = $session->param("username");

                $access .= "<allow>\n";

                $access .= "<principal>$username</principal>\n";

                $access .= "<permission>all</permission>\n";

                $access .= "</allow>\n";

    }

    } else {

        foreach(split(":",$moderators)) {

            $access .= "<allow>\n";