[BACK]Return to lonpublisher.pm CVS log [TXT] [DIR] Up to [LON-CAPA] / loncom / publisher

Diff for /loncom/publisher/lonpublisher.pm between versions 1.16 and 1.49

version 1.16, 2001/01/04 16:21:46 version 1.49, 2001/10/16 18:46:10
Line 6 Line 6
 # 05/29/00,05/30,10/11 Gerd Kortemeyer)  # 05/29/00,05/30,10/11 Gerd Kortemeyer)
 #  #
 # 11/28,11/29,11/30,12/01,12/02,12/04,12/23 Gerd Kortemeyer  # 11/28,11/29,11/30,12/01,12/02,12/04,12/23 Gerd Kortemeyer
   # 03/23 Guy Albertelli
   # 03/24,03/29,04/03 Gerd Kortemeyer
   # 04/16/2001 Scott Harrison
   # 05/03,05/05,05/07 Gerd Kortemeyer
   # 05/28/2001 Scott Harrison
   # 06/23,08/07,08/11,8/13,8/17,8/18,8/24,9/26 Gerd Kortemeyer
   # 10/3,10/8 Scott Harrison
   
 package Apache::lonpublisher;  package Apache::lonpublisher;
   
Line 15  use File::Copy; Line 22  use File::Copy;
 use Apache::Constants qw(:common :http :methods);  use Apache::Constants qw(:common :http :methods);
 use HTML::TokeParser;  use HTML::TokeParser;
 use Apache::lonxml;  use Apache::lonxml;
 use Apache::structuretags;  use Apache::lonhomework;
 use Apache::inputtags;  use Apache::loncacc;
 use Apache::response;  use DBI;
   
 my %addid;  my %addid;
 my %nokey;  my %nokey;
Line 29  my %metadatakeys; Line 36  my %metadatakeys;
   
 my $docroot;  my $docroot;
   
   my $cuname;
   my $cudom;
   
 # ----------------------------------------------- Evaluate string with metadata  # ----------------------------------------------- Evaluate string with metadata
   
 sub metaeval {  sub metaeval {
Line 40  sub metaeval { Line 50  sub metaeval {
            if ($token->[0] eq 'S') {             if ($token->[0] eq 'S') {
       my $entry=$token->[1];        my $entry=$token->[1];
               my $unikey=$entry;                my $unikey=$entry;
                 if (defined($token->[2]->{'package'})) { 
                     $unikey.='_package_'.$token->[2]->{'package'};
                 } 
               if (defined($token->[2]->{'part'})) {                 if (defined($token->[2]->{'part'})) { 
                  $unikey.='_'.$token->[2]->{'part'};                    $unikey.='_'.$token->[2]->{'part'}; 
       }        }
                 if (defined($token->[2]->{'id'})) { 
                     $unikey.='_'.$token->[2]->{'id'};
                 } 
               if (defined($token->[2]->{'name'})) {                 if (defined($token->[2]->{'name'})) { 
                  $unikey.='_'.$token->[2]->{'name'};                    $unikey.='_'.$token->[2]->{'name'}; 
       }        }
Line 56  sub metaeval { Line 72  sub metaeval {
               } @{$token->[3]};                } @{$token->[3]};
               if ($metadatafields{$unikey}) {                if ($metadatafields{$unikey}) {
   my $newentry=$parser->get_text('/'.$entry);    my $newentry=$parser->get_text('/'.$entry);
                   unless ($metadatafields{$unikey}=~/$newentry/) {                    unless (($metadatafields{$unikey}=~/$newentry/) ||
                             ($newentry eq '')) {
                      $metadatafields{$unikey}.=', '.$newentry;                       $metadatafields{$unikey}.=', '.$newentry;
   }    }
       } else {        } else {
Line 84  sub metaread { Line 101  sub metaread {
     return '<br><b>Processed file:</b> <tt>'.$fn.'</tt>';      return '<br><b>Processed file:</b> <tt>'.$fn.'</tt>';
 }  }
   
   # ---------------------------- convert 'time' format into a datetime sql format
   sub sqltime {
       my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) =
    localtime(@_[0]);
       $mon++; $year+=1900;
       return "$year-$mon-$mday $hour:$min:$sec";
   }
   
 # --------------------------------------------------------- Various form fields  # --------------------------------------------------------- Various form fields
   
 sub textfield {  sub textfield {
Line 110  sub selectbox { Line 135  sub selectbox {
   
 # -------------------------------------------------------- Publication Step One  # -------------------------------------------------------- Publication Step One
   
 sub publish {  sub urlfixup {
       my ($url,$target)=@_;
       unless ($url) { return ''; }
       my ($host)=($url=~/(?:http\:\/\/)*([^\/]+)/);
       map {
    if ($_ eq $host) {
       $url=~s/^http\:\/\///;
               $url=~s/^$host//;
           }
       } values %Apache::lonnet::hostname;
       if ($url=~/^http\:\/\//) { return $url; }
       $url=~s/\~$cuname/res\/$cudom\/$cuname/;
       if ($target) {
    $target=~s/\/[^\/]+$//;
          $url=&Apache::lonnet::hreflocation($target,$url);
       }
       return $url;
   }
   
   sub publish {
     my ($source,$target,$style)=@_;      my ($source,$target,$style)=@_;
     my $logfile;      my $logfile;
     my $scrout='';      my $scrout='';
       my $allmeta='';
       my $content='';
       my %allow=();
       undef %allow;
   
     unless ($logfile=Apache::File->new('>>'.$source.'.log')) {      unless ($logfile=Apache::File->new('>>'.$source.'.log')) {
  return    return 
Line 138  sub publish { Line 185  sub publish {
   
         my $maxindex=10;          my $maxindex=10;
         my $maxid=10;          my $maxid=10;
         my $content='';  
         my $needsfixup=0;          my $needsfixup=0;
   
         {          {
Line 175  sub publish { Line 222  sub publish {
           print $logfile "Needs ID and/or index fixup\n".            print $logfile "Needs ID and/or index fixup\n".
         "Max ID   : $maxid (min 10)\n".          "Max ID   : $maxid (min 10)\n".
                 "Max Index: $maxindex (min 10)\n";                  "Max Index: $maxindex (min 10)\n";
         }
           my $outstring='';            my $outstring='';
           my $parser=HTML::TokeParser->new(\$content);            my $parser=HTML::TokeParser->new(\$content);
           my $token;            my $token;
           while ($token=$parser->get_token) {            while ($token=$parser->get_token) {
               if ($token->[0] eq 'S') {                if ($token->[0] eq 'S') {
                   my $counter;                  my $counter;
   if ($counter=$addid{$token->[1]}) {                  my $tag=$token->[1];
                   unless ($tag eq 'allow') {  
                     my %parms=%{$token->[2]};
     if ($counter=$addid{$tag}) {
       if ($counter eq 'id') {        if ($counter eq 'id') {
   if (defined($token->[2]->{'id'})) {    unless (defined($parms{'id'})) {
       $outstring.=$token->[4];  
   } else {  
                               $maxid++;                                $maxid++;
                               my $thisid=' id="'.$maxid.'"';                                $parms{'id'}=$maxid;
       my $fixup=$token->[4];                                print $logfile 'ID: '.$tag.':'.$maxid."\n";
                               $fixup=~s/(\<\w+)/$1$thisid/;  
                               $outstring.=$fixup;  
                               print $logfile 'ID: '.$fixup."\n";  
                           }                            }
                       } else {                        } elsif ($counter eq 'index') {
    if (defined($token->[2]->{'index'})) {     unless (defined($parms{'index'})) {
       $outstring.=$token->[4];  
   } else {  
                               $maxindex++;                                $maxindex++;
                               my $thisindex=' index="'.$maxindex.'"';                                $parms{'index'}=$maxindex;
       my $fixup=$token->[4];                                print $logfile 'Index: '.$tag.':'.$maxindex."\n";
                               $fixup=~s/(\<\w+)/$1$thisindex/;  
                               $outstring.=$fixup;  
                               print $logfile 'Index: '.$fixup."\n";  
   }    }
       }        }
   } else {    } 
                       $outstring.=$token->[4];                    
                     map {
                         if (defined($parms{$_})) {
     my $oldurl=$parms{$_};
                             my $newurl=&urlfixup($oldurl,$target);
                             if ($newurl ne $oldurl) {
         $parms{$_}=$newurl;
                                 print $logfile 'URL: '.$tag.':'.$oldurl.' - '.
     $newurl."\n";
     }
                             $allow{$newurl}=1;
                         }
                     } ('src','href','background');
   
                     if ($tag eq 'applet') {
         my $codebase='';
                         if (defined($parms{'codebase'})) {
            my $oldcodebase=$parms{'codebase'};
                            unless ($oldcodebase=~/\/$/) {
                               $oldcodebase.='/';
                            }
                            $codebase=&urlfixup($oldcodebase,$target);
                            $codebase=~s/\/$//;    
                            if ($codebase ne $oldcodebase) {
        $parms{'codebase'}=$codebase;
                                print $logfile 'URL codebase: '.$tag.':'.
                                     $oldcodebase.' - '.
     $codebase."\n";
    }
                            $allow{$codebase.'/*'}=1;
         } else {
                           map {
                             if (defined($parms{$_})) {
         my $oldurl=$parms{$_};
                                 my $newurl=&urlfixup($oldurl,$target);
         $newurl=~s/\/[^\/]+$/\/\*/;
                                     print $logfile 'Allow: applet '.$_.':'.
                                     $oldurl.' allows '.
     $newurl."\n";
                                 $allow{$newurl}=1;
                             }
                           } ('archive','code','object');
                         }
                   }                    }
   
                     my $newparmstring='';
                     my $endtag='';
                     map {
                       if ($_ eq '/') {
                         $endtag=' /';
                       } else { 
                         my $quote=($parms{$_}=~/\"/?"'":'"');
                         $newparmstring.=' '.$_.'='.$quote.$parms{$_}.$quote;
       }
                     } keys %parms;
     
     $outstring.='<'.$tag.$newparmstring.$endtag.'>';
            } else {
      $allow{$token->[2]->{'src'}}=1;
    }
               } elsif ($token->[0] eq 'E') {                } elsif ($token->[0] eq 'E') {
                   $outstring.=$token->[2];                    unless ($token->[1] eq 'allow') {
                        $outstring.='</'.$token->[1].'>';
     }
               } else {                } else {
                   $outstring.=$token->[1];                    $outstring.=$token->[1];
               }                }
           }            }
   # ------------------------------------------------------------ Construct Allows
        unless ($style eq 'rat') {
    $scrout.='<h3>Dependencies</h3>';
    my $allowstr="\n";
           map {
              $allowstr.='<allow src="'.$_.'" />'."\n";
              $scrout.='<br>';
              unless ($_=~/\*/) {
          $scrout.='<a href="'.$_.'">';
              }
              $scrout.='<tt>'.$_.'</tt>';
              unless ($_=~/\*/) {
          $scrout.='</a>';
              }
           } keys %allow;
           $outstring=~s/(\<\/[^\>]+\>\s*)$/$allowstr$1/s;
       }
   # ------------------------------------------------------------- Write modified
   
         {          {
           my $org;            my $org;
           unless ($org=Apache::File->new('>'.$source)) {            unless ($org=Apache::File->new('>'.$source)) {
Line 225  sub publish { Line 344  sub publish {
           print $org $outstring;            print $org $outstring;
         }          }
   $content=$outstring;    $content=$outstring;
   
         if ($needsfixup) {
           print $logfile "End of ID and/or index fixup\n".            print $logfile "End of ID and/or index fixup\n".
         "Max ID   : $maxid (min 10)\n".          "Max ID   : $maxid (min 10)\n".
                 "Max Index: $maxindex (min 10)\n";                  "Max Index: $maxindex (min 10)\n";
       } else {        } else {
   print $logfile "Does not need ID and/or index fixup\n";    print $logfile "Does not need ID and/or index fixup\n";
       }        }
       }
 # --------------------------------------------- Initial step done, now metadata  # --------------------------------------------- Initial step done, now metadata
   
 # ---------------------------------------- Storage for metadata keys and fields  # ---------------------------------------- Storage for metadata keys and fields
Line 240  sub publish { Line 361  sub publish {
      %metadatakeys=();       %metadatakeys=();
             
      my %oldparmstores=();       my %oldparmstores=();
        
        $scrout.='<h3>Metadata Information</h3>';
   
 # ------------------------------------------------ First, check out environment  # ------------------------------------------------ First, check out environment
      unless (-e $source.'.meta') {       unless (-e $source.'.meta') {
Line 249  sub publish { Line 372  sub publish {
                   $ENV{'environment.generation'};                    $ENV{'environment.generation'};
         $metadatafields{'author'}=~s/\s+/ /g;          $metadatafields{'author'}=~s/\s+/ /g;
         $metadatafields{'author'}=~s/\s+$//;          $metadatafields{'author'}=~s/\s+$//;
         $metadatafields{'owner'}=$ENV{'user.name'}.'@'.$ENV{'user.domain'};          $metadatafields{'owner'}=$cuname.'@'.$cudom;
   
 # ------------------------------------------------ Check out directory hierachy  # ------------------------------------------------ Check out directory hierachy
   
         my $thisdisfn=$source;          my $thisdisfn=$source;
         $thisdisfn=~s/^\/home\/$ENV{'user.name'}\///;          $thisdisfn=~s/^\/home\/$cuname\///;
   
         my @urlparts=split(/\//,$thisdisfn);          my @urlparts=split(/\//,$thisdisfn);
         $#urlparts--;          $#urlparts--;
   
         my $currentpath='/home/'.$ENV{'user.name'}.'/';          my $currentpath='/home/'.$cuname.'/';
   
         map {          map {
     $currentpath.=$_.'/';      $currentpath.=$_.'/';
Line 289  sub publish { Line 412  sub publish {
     }      }
   
 # -------------------------------------------------- Parse content for metadata  # -------------------------------------------------- Parse content for metadata
       if ($style eq 'ssi') {
           my $oldenv=$ENV{'request.uri'};
   
         my $allmeta=Apache::lonxml::xmlparse('meta',$content);          $ENV{'request.uri'}=$target;
         &metaeval($allmeta);          $allmeta=Apache::lonxml::xmlparse('meta',$content);
           $ENV{'request.uri'}=$oldenv;
   
           &metaeval($allmeta);
       }
 # ---------------- Find and document discrepancies in the parameters and stores  # ---------------- Find and document discrepancies in the parameters and stores
   
         my $chparms='';          my $chparms='';
Line 314  sub publish { Line 442  sub publish {
         my $chparms='';          my $chparms='';
         map {          map {
     if (($_=~/^parameter/) || ($_=~/^stores/)) {      if (($_=~/^parameter/) || ($_=~/^stores/)) {
                 unless (($metadatafields{$_.'.name'}) || ($_=~/\.\w+$/)) {                  unless (($metadatafields{$_.'.name'}) ||
                           ($metadatafields{$_.'.package'}) || ($_=~/\.\w+$/)) {
     print $logfile 'Obsolete: '.$_."\n";      print $logfile 'Obsolete: '.$_."\n";
                     $chparms.=$_.' ';                      $chparms.=$_.' ';
                 }                  }
Line 351  sub publish { Line 480  sub publish {
             $textonly=~s/[^a-z\s]//g;              $textonly=~s/[^a-z\s]//g;
   
             my %keywords=();              my %keywords=();
             map {              my $j=0;
  unless ($nokey{$_}) {              my $word;
                    $keywords{$_}=1;              for (my $i=0; $i<length($textonly); $i++) {
                 }    my $ch.=substr($textonly,$i,1);
             } ($textonly=~m/(\w+)/g);   if ($ch=~/\s/) {
       if (length($word)) {
    unless ($nokey{$word}) {
       $keywords{$word}=1;
    }
       }
       $word='';
    }
    else {
       $word.=$ch;
    }
   # map {
   #    unless ($nokey{$_}) {
   # $keywords{$_}=1;
   #    } 
   # } ($textonly=~m/(\w+)/g);
       }
   
       my $sizkeys=scalar(keys %keywords); # use this value at some point
             map {              map {
  $keywords{$_}=1;   $keywords{$_}=1;
             } split(/\W+/,$metadatafields{'keywords'});              } split(/\W+/,$metadatafields{'keywords'});
Line 371  sub publish { Line 517  sub publish {
     $keywordout.="</tr><tr>\n";      $keywordout.="</tr><tr>\n";
                     $colcount=0;                      $colcount=0;
                 }                  }
                 $colcount++;   else {
       $colcount++;
    }
             } sort keys %keywords;              } sort keys %keywords;
             $keywordout.='</tr></table>';              $keywordout.='</tr></table>';
   
         }                   }         
           
  $scrout.=$keywordout;   $scrout.=$keywordout;
   
         $scrout.=&textfield('Additional Keywords','addkey','');          $scrout.=&textfield('Additional Keywords','addkey','');
Line 404  sub publish { Line 551  sub publish {
         
  $scrout.=&textfield('Publisher/Owner','owner',   $scrout.=&textfield('Publisher/Owner','owner',
                             $metadatafields{'owner'});                              $metadatafields{'owner'});
   # --------------------------------------------------- Correct copyright for rat        
       if ($style eq 'rat') {
          if ($metadatafields{'copyright'} eq 'public') { 
             delete $metadatafields{'copyright'};
          }
          delete $cprtag{'public'};
      }
   
         $scrout.=&selectbox('Copyright/Distribution','copyright',          $scrout.=&selectbox('Copyright/Distribution','copyright',
                             $metadatafields{'copyright'},%cprtag);                              $metadatafields{'copyright'},%cprtag);
   
     }  
     return $scrout.      return $scrout.
       '<p><input type="submit" value="Finalize Publication"></form>';        '<p><input type="submit" value="Finalize Publication"></form>';
 }  }
Line 417  sub publish { Line 570  sub publish {
   
 sub phasetwo {  sub phasetwo {
   
     my ($source,$target,$style)=@_;      my ($source,$target,$style,$distarget)=@_;
     my $logfile;      my $logfile;
     my $scrout='';      my $scrout='';
   
Line 481  sub phasetwo { Line 634  sub phasetwo {
        print $logfile "\nWrote metadata";         print $logfile "\nWrote metadata";
      }       }
   
   # -------------------------------- Synchronize entry with SQL metadata database
       my %perlvar;
       open (CONFIG,"/etc/httpd/conf/access.conf") || die "Can't read access.conf";
       my $configline;
       while ($configline=<CONFIG>) {
    if ($configline =~ /PerlSetVar/) {
       my ($dummy,$varname,$varvalue)=split(/\s+/,$configline);
       chomp($varvalue);
       $perlvar{$varname}=$varvalue;
    }
       }
       close(CONFIG);
   
       my $warning;
       my $dbh;
       {
    unless (
    $dbh = DBI->connect("DBI:mysql:loncapa","www",$perlvar{'lonSqlAccess'},{ RaiseError =>0,PrintError=>0})
    ) { 
       $warning='<font color=red>WARNING: Cannot connect to '.
    'database!</font>';
    }
    else {
       my %sqldatafields;
       $sqldatafields{'url'}=$distarget;
       my $sth=$dbh->prepare(
     'delete from metadata where url like binary'.
     '"'.$sqldatafields{'url'}.'"');
       $sth->execute();
       map {my $field=$metadatafields{$_}; $field=~s/\"/\'\'/g; 
    $sqldatafields{$_}=$field;}
       ('title','author','subject','keywords','notes','abstract',
        'mime','language','creationdate','lastrevisiondate','owner',
        'copyright');
       
       $sth=$dbh->prepare('insert into metadata values ('.
          '"'.delete($sqldatafields{'title'}).'"'.','.
          '"'.delete($sqldatafields{'author'}).'"'.','.
          '"'.delete($sqldatafields{'subject'}).'"'.','.
          '"'.delete($sqldatafields{'url'}).'"'.','.
          '"'.delete($sqldatafields{'keywords'}).'"'.','.
          '"'.'current'.'"'.','.
          '"'.delete($sqldatafields{'notes'}).'"'.','.
          '"'.delete($sqldatafields{'abstract'}).'"'.','.
          '"'.delete($sqldatafields{'mime'}).'"'.','.
          '"'.delete($sqldatafields{'language'}).'"'.','.
          '"'.
          sqltime(delete($sqldatafields{'creationdate'}))
          .'"'.','.
          '"'.
          sqltime(delete(
          $sqldatafields{'lastrevisiondate'})).'"'.','.
          '"'.delete($sqldatafields{'owner'}).'"'.','.
          '"'.delete(
          $sqldatafields{'copyright'}).'"'.')');
       $sth->execute();
       $dbh->disconnect;
       $scrout.='<p>Synchronized SQL metadata database';
       print $logfile "\nSynchronized SQL metadata database";
    }
       }
   
   
 # ----------------------------------------------------------- Copy old versions  # ----------------------------------------------------------- Copy old versions
         
 if (-e $target) {  if (-e $target) {
Line 598  if (-e $target) { Line 814  if (-e $target) {
   
 }  }
   
   # ---------------------------------------- Send update notifications, meta only
   
   {
   
       my $filename;
    
       $target=~/(.*)\/([^\/]+)$/;
       my $srcf=$2.'.meta';
       opendir(DIR,$1);
       while ($filename=readdir(DIR)) {
          if ($filename=~/$srcf\.(\w+)$/) {
      my $subhost=$1;
              if ($subhost ne 'meta') {
          $scrout.=
                   '<p>Notifying host for metadata only '.$subhost.':';
                  print $logfile 
                   "\nNotifying host for metadata only '.$subhost.':'";
                  my $reply=&Apache::lonnet::critical(
                                   'update:'.$target.'.meta',$subhost);
                  $scrout.=$reply;
                  print $logfile $reply;              
              }
          }
       }
       closedir(DIR);
   
   }
   
 # ------------------------------------------------ Provide link to new resource  # ------------------------------------------------ Provide link to new resource
   
     my $thisdistarget=$target;      my $thisdistarget=$target;
     $thisdistarget=~s/^$docroot//;      $thisdistarget=~s/^$docroot//;
   
     return $scrout.      my $thissrc=$source;
  '<p><a href="'.$thisdistarget.'"><font size=+2>View Target</font></a>';      $thissrc=~s/^\/home\/(\w+)\/public_html/\/priv\/$1/;
   
       my $thissrcdir=$thissrc;
       $thissrcdir=~s/\/[^\/]+$/\//;
   
   
       return $warning.$scrout.
         '<hr><a href="'.$thisdistarget.'"><font size=+2>View Target</font></a>'.
         '<p><a href="'.$thissrc.'"><font size=+2>Back to Source</font></a>'.
         '<p><a href="'.$thissrcdir.
         '"><font size=+2>Back to Source Directory</font></a>';
   
 }  }
   
 # ================================================================ Main Handler  # ================================================================ Main Handler
Line 618  sub handler { Line 873  sub handler {
      return OK;       return OK;
   }    }
   
 unless ($ENV{'form.pubdir'}) {  # Get query string for limited number of parameters
   
       map {
          my ($name, $value) = split(/=/,$_);
          $value =~ tr/+/ /;
          $value =~ s/%([a-fA-F0-9][a-fA-F0-9])/pack("C",hex($1))/eg;
          if ($name eq 'filename') {
              unless ($ENV{'form.'.$name}) {
                 $ENV{'form.'.$name}=$value;
      }
          }
       } (split(/&/,$ENV{'QUERY_STRING'}));
   
   
 # -------------------------------------------------------------- Check filename  # -------------------------------------------------------------- Check filename
   
   my $fn=$ENV{'form.filename'};    my $fn=$ENV{'form.filename'};
   
     
   unless ($fn) {     unless ($fn) { 
      $r->log_reason($ENV{'user.name'}.' at '.$ENV{'user.domain'}.       $r->log_reason($cuname.' at '.$cudom.
          ' trying to publish empty filename', $r->filename);            ' trying to publish empty filename', $r->filename); 
      return HTTP_NOT_FOUND;       return HTTP_NOT_FOUND;
   }     } 
   
   unless ($ENV{'user.home'} eq $r->dir_config('lonHostID')) {    ($cuname,$cudom)=
      $r->log_reason($ENV{'user.name'}.' at '.$ENV{'user.domain'}.      &Apache::loncacc::constructaccess($fn,$r->dir_config('lonDefDomain'));
     unless (($cuname) && ($cudom)) {
        $r->log_reason($cuname.' at '.$cudom.
          ' trying to publish file '.$ENV{'form.filename'}.           ' trying to publish file '.$ENV{'form.filename'}.
          ' ('.$fn.') - not homeserver ('.$ENV{'user.home'}.')',            ' ('.$fn.') - not authorized', 
          $r->filename);            $r->filename); 
      return HTTP_NOT_ACCEPTABLE;       return HTTP_NOT_ACCEPTABLE;
   }    }
   
   $fn=~s/^http\:\/\/[^\/]+\/\~(\w+)/\/home\/$1\/public_html/;    unless (&Apache::lonnet::homeserver($cuname,$cudom) 
             eq $r->dir_config('lonHostID')) {
        $r->log_reason($cuname.' at '.$cudom.
            ' trying to publish file '.$ENV{'form.filename'}.
            ' ('.$fn.') - not homeserver ('.
            &Apache::lonnet::homeserver($cuname,$cudom).')', 
            $r->filename); 
        return HTTP_NOT_ACCEPTABLE;
     }
   
     $fn=~s/^http\:\/\/[^\/]+//;
     $fn=~s/^\/\~(\w+)/\/home\/$1\/public_html/;
   
   my $targetdir='';    my $targetdir='';
   $docroot=$r->dir_config('lonDocRoot');     $docroot=$r->dir_config('lonDocRoot'); 
   if ($1 ne $ENV{'user.name'}) {    if ($1 ne $cuname) {
      $r->log_reason($ENV{'user.name'}.' at '.$ENV{'user.domain'}.       $r->log_reason($cuname.' at '.$cudom.
          ' trying to publish unowned file '.$ENV{'form.filename'}.           ' trying to publish unowned file '.$ENV{'form.filename'}.
          ' ('.$fn.')',            ' ('.$fn.')', 
          $r->filename);            $r->filename); 
      return HTTP_NOT_ACCEPTABLE;       return HTTP_NOT_ACCEPTABLE;
   } else {    } else {
       $targetdir=$docroot.'/res/'.$ENV{'user.domain'};        $targetdir=$docroot.'/res/'.$cudom;
   }    }
                                                                     
       
   unless (-e $fn) {     unless (-e $fn) { 
      $r->log_reason($ENV{'user.name'}.' at '.$ENV{'user.domain'}.       $r->log_reason($cuname.' at '.$cudom.
          ' trying to publish non-existing file '.$ENV{'form.filename'}.           ' trying to publish non-existing file '.$ENV{'form.filename'}.
          ' ('.$fn.')',            ' ('.$fn.')', 
          $r->filename);            $r->filename); 
Line 731  unless ($ENV{'form.phase'} eq 'two') { Line 1013  unless ($ENV{'form.phase'} eq 'two') {
       $thisdistarget=~s/^$docroot//;        $thisdistarget=~s/^$docroot//;
   
       my $thisdisfn=$thisfn;        my $thisdisfn=$thisfn;
       $thisdisfn=~s/^\/home\/$ENV{'user.name'}\/public_html\///;        $thisdisfn=~s/^\/home\/$cuname\/public_html\///;
   
       $r->print('<h2>Publishing '.        $r->print('<h2>Publishing '.
         &Apache::lonnet::filedescription($thistype).' <tt>'.          &Apache::lonnet::filedescription($thistype).' <tt>'.
         $thisdisfn.'</tt></h2><b>Target:</b> <tt>'.$thisdistarget.'</tt><p>');          $thisdisfn.'</tt></h2><b>Target:</b> <tt>'.$thisdistarget.'</tt><p>');
      
          if (($cuname ne $ENV{'user.name'}) || ($cudom ne $ENV{'user.domain'})) {
             $r->print('<h3><font color=red>Co-Author: '.$cuname.' at '.$cudom.
                  '</font></h3>');
         }
   
         if (&Apache::lonnet::fileembstyle($thistype) eq 'ssi') {
             $r->print('<br><a href="/adm/diff?filename=/~'.$cuname.'/'.
                       $thisdisfn.
      '&versionone=priv" target=cat>Diffs with Current Version</a><p>');
         }
       
 # ------------ We are publishing from $thisfn to $thistarget with $thisembstyle  # ------------ We are publishing from $thisfn to $thistarget with $thisembstyle
   
        unless ($ENV{'form.phase'} eq 'two') {         unless ($ENV{'form.phase'} eq 'two') {
           $r->print('<hr>'.&publish($thisfn,$thistarget,$thisembstyle));           $r->print(
             '<hr>'.&publish($thisfn,$thistarget,$thisembstyle));
        } else {         } else {
           $r->print('<hr>'.&phasetwo($thisfn,$thistarget,$thisembstyle));                 $r->print(
             '<hr>'.&phasetwo($thisfn,$thistarget,$thisembstyle,$thisdistarget)); 
        }           }  
   
   }    }
   $r->print('</body></html>');    $r->print('</body></html>');
 } else {  
   
   my $fn=$ENV{'form.filename'};  
   
   $fn=~s/\/[^\/]+$//;  
   my $thisprefix=$fn;  
   $thisprefix=~s/\/\~/\/priv\//;  
   
   $fn=~s/^http\:\/\/[^\/]+\/\~(\w+)/\/home\/$1\/public_html/;  
   
   unless ($fn) {   
      $r->log_reason($ENV{'user.name'}.' at '.$ENV{'user.domain'}.  
          ' trying to publish empty directory', $r->filename);   
      return HTTP_NOT_FOUND;  
   }   
   
 # ----------------------------------------------------------- Start page output  
   
   $r->content_type('text/html');  
   $r->send_http_header;  
   
   $r->print('<html><head><title>LON-CAPA Publishing Directory</title></head>');  
   $r->print(  
    '<body bgcolor="#FFFFFF"><img align=right src=/adm/lonIcons/lonlogos.gif>');  
   
   my $thisdisfn=$fn;  
   $thisdisfn=~s/^\/home\/$ENV{'user.name'}\/public_html\///;  
     
   $r->print('<h1>Publishing directory <tt>'.$thisdisfn.'</tt></h1>');  
   my $i=0;  
   $r->print('<script>');  
     my $filename;  
     opendir(DIR,$fn);  
        while ($filename=readdir(DIR)) {  
            $filename=~/\.(\w+)$/;  
            if ((&Apache::lonnet::fileembstyle($1)) && ($1 ne 'meta')) {  
       $r->print(<<ENDOPEN);  
       pub$i=window.open("$thisprefix/$filename","LONCAPApub$i",  
                                 "menubar=no,height=450,width=650");  
 ENDOPEN  
               $i++;       
    }  
        }  
     closedir(DIR);  
   $r->print('</script>');  
   
   $r->print('</body></html>');  
     
 }  
   return OK;    return OK;
 }  }
   
Removed from v.1.16  
changed lines
  Added in v.1.49

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>