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

Diff for /loncom/lonnet/perl/lonnet.pm between versions 1.333 and 1.339

version 1.333, 2003/03/06 21:08:21 version 1.339, 2003/03/14 15:08:20
Line 729  sub subscribe { Line 729  sub subscribe {
     $author=~s/\/home\/httpd\/html\/res\/([^\/]*)\/([^\/]*).*/$1\/$2/;      $author=~s/\/home\/httpd\/html\/res\/([^\/]*)\/([^\/]*).*/$1\/$2/;
     my ($udom,$uname)=split(/\//,$author);      my ($udom,$uname)=split(/\//,$author);
     my $home=homeserver($uname,$udom);      my $home=homeserver($uname,$udom);
     if ($home eq 'no_host') {       if ($home eq 'no_host') {
         return 'not_found';           return 'not_found';
     }      }
     my $answer=reply("sub:$fname",$home);      my $answer=reply("sub:$fname",$home);
     if (($answer eq 'con_lost') || ($answer eq 'rejected')) {      if (($answer eq 'con_lost') || ($answer eq 'rejected')) {
Line 2831  sub EXT { Line 2831  sub EXT {
     my ($varname,$symbparm,$udom,$uname,)=@_;      my ($varname,$symbparm,$udom,$uname,)=@_;
   
     unless ($varname) { return ''; }      unless ($varname) { return ''; }
   
     #get real user name/domain, courseid and symb      #get real user name/domain, courseid and symb
     my $courseid;      my $courseid;
     if (!($uname && $udom)) {      if (!($uname && $udom)) {
Line 2855  sub EXT { Line 2854  sub EXT {
     if ($realm eq 'user') {      if ($realm eq 'user') {
 # --------------------------------------------------------------- user.resource  # --------------------------------------------------------------- user.resource
  if ($space eq 'resource') {   if ($space eq 'resource') {
     my %restored=&restore(undef,undef,$udom,$uname);      if (defined($Apache::lonhomework::parsing_a_problem)) {
             return $restored{$qualifierrest};   return $Apache::lonhomework::history{$qualifierrest};
       } else {
    my %restored=&restore($symbparm,$courseid,$udom,$uname);
    return $restored{$qualifierrest};
       }
 # ----------------------------------------------------------------- user.access  # ----------------------------------------------------------------- user.access
         } elsif ($space eq 'access') {          } elsif ($space eq 'access') {
     # FIXME - not supporting calls for a specific user      # FIXME - not supporting calls for a specific user
Line 2891  sub EXT { Line 2894  sub EXT {
             return $uname;              return $uname;
 # ---------------------------------------------------- Any other user namespace  # ---------------------------------------------------- Any other user namespace
         } else {          } else {
             my $item=($rest)?$qualifier.'.'.$rest:$qualifier;              my %reply=&get($space,[$qualifierrest],$udom,$uname);
             my %reply=&get($space,[$item]);              return $reply{$qualifierrest};
             return $reply{$item};  
         }          }
     } elsif ($realm eq 'query') {      } elsif ($realm eq 'query') {
 # ---------------------------------------------- pull stuff out of query string  # ---------------------------------------------- pull stuff out of query string
Line 3010  sub EXT { Line 3012  sub EXT {
   
 # ------------------------------------------------------------------ Cascade up  # ------------------------------------------------------------------ Cascade up
  unless ($space eq '0') {   unless ($space eq '0') {
     my ($part,$id)=split(/\_/,$space);      my @parts=split(/_/,$space);
     if ($id) {      my $id=pop(@parts);
  my $partgeneral=&EXT('resource.'.$part.'.'.$qualifierrest,      my $part=join('_',@parts);
      $symbparm,$udom,$uname);      if ($part eq '') { $part='0'; }
  if (defined($partgeneral)) { return $partgeneral; }      my $partgeneral=&EXT('resource.'.$part.'.'.$qualifierrest,
     } else {   $symbparm,$udom,$uname);
  my $resourcegeneral=&EXT('resource.0.'.$qualifierrest,      if (defined($partgeneral)) { return $partgeneral; }
  $symbparm,$udom,$uname);  
  if (defined($resourcegeneral)) { return $resourcegeneral; }  
     }  
  }   }
   
 # ---------------------------------------------------- Any other user namespace  # ---------------------------------------------------- Any other user namespace
Line 3041  sub EXT { Line 3040  sub EXT {
     return '';      return '';
 }  }
   
   sub add_prefix_and_part {
       my ($prefix,$part)=@_;
       my $keyroot;
       if (defined($prefix) && $prefix !~ /^__/) {
    # prefix that has a part already
    $keyroot=$prefix;
       } elsif (defined($prefix)) {
    # prefix that is missing a part
    if (defined($part)) { $keyroot='_'.$part.substr($prefix,1); }
       } else {
    # no prefix at all
    if (defined($part)) { $keyroot='_'.$part; }
       }
       return $keyroot;
   }
   
 # ---------------------------------------------------------------- Get metadata  # ---------------------------------------------------------------- Get metadata
   
 sub metadata {  sub metadata {
Line 3069  sub metadata { Line 3084  sub metadata {
         }          }
         my %metathesekeys=();          my %metathesekeys=();
         unless ($filename=~/\.meta$/) { $filename.='.meta'; }          unless ($filename=~/\.meta$/) { $filename.='.meta'; }
  my $metastring=&getfile($perlvar{'lonDocRoot'}.'/res/'.$filename);   my $metastring=&getfile(&filelocation('',&clutter($filename)));
         my $parser=HTML::LCParser->new(\$metastring);          my $parser=HTML::LCParser->new(\$metastring);
         my $token;          my $token;
         undef %metathesekeys;          undef %metathesekeys;
         while ($token=$parser->get_token) {          while ($token=$parser->get_token) {
            if ($token->[0] eq 'S') {      if ($token->[0] eq 'S') {
      if (defined($token->[2]->{'package'})) {   if (defined($token->[2]->{'package'})) {
 #  #
 # This is a package - get package info  # This is a package - get package info
 #  #
       my $package=$token->[2]->{'package'};      my $package=$token->[2]->{'package'};
       my $keyroot='';      my $keyroot=&add_prefix_and_part($prefix,$token->[2]->{'part'});
               if (defined($prefix) && $prefix !~ /^__/) {      if (defined($token->[2]->{'id'})) { 
   # prefix that has a part already   $keyroot.='_'.$token->[2]->{'id'}; 
   $keyroot=$prefix;      }
               } elsif (defined($prefix)) {      if ($metacache{$uri.':packages'}) {
   # prefix that is missing a part   $metacache{$uri.':packages'}.=','.$package.$keyroot;
   if (defined($token->[2]->{'part'})) {      } else {
       $keyroot='_'.$token->[2]->{'part'}.substr($prefix,1);   $metacache{$uri.':packages'}=$package.$keyroot;
   }      }
       } else {      foreach (keys %packagetab) {
   # no prefix at all   if ($_=~/^$package\&/) {
   if (defined($token->[2]->{'part'})) {      my ($pack,$name,$subp)=split(/\&/,$_);
       $keyroot='_'.$token->[2]->{'part'};      my $value=$packagetab{$_};
   }      my $part=$keyroot;
       }      $part=~s/^\_//;
               if (defined($token->[2]->{'id'})) {       if ($subp eq 'display') {
                  $keyroot.='_'.$token->[2]->{'id'};    $value.=' [Part: '.$part.']';
       }      }
               if ($metacache{$uri.':packages'}) {      my $unikey='parameter'.$keyroot.'_'.$name;
                  $metacache{$uri.':packages'}.=','.$package.$keyroot;      $metathesekeys{$unikey}=1;
               } else {      $metacache{$uri.':'.$unikey.'.part'}=$part;
                  $metacache{$uri.':packages'}=$package.$keyroot;      unless (defined($metacache{$uri.':'.$unikey.'.'.$subp})) {
       }   $metacache{$uri.':'.$unikey.'.'.$subp}=$value;
               foreach (keys %packagetab) {      }
   if ($_=~/^$package\&/) {      if (defined($metacache{$uri.':'.$unikey.'.default'})) {
       my ($pack,$name,$subp)=split(/\&/,$_);   $metacache{$uri.':'.$unikey}=
                       my $value=$packagetab{$_};      $metacache{$uri.':'.$unikey.'.default'}
       my $part=$keyroot;   }
                       $part=~s/^\_//;   }
                       if ($subp eq 'display') {      }
   $value.=' [Part: '.$part.']';   } else {
                       }  
                       my $unikey='parameter'.$keyroot.'_'.$name;  
                       $metathesekeys{$unikey}=1;  
                       $metacache{$uri.':'.$unikey.'.part'}=$part;  
                       unless (defined($metacache{$uri.':'.$unikey.'.'.$subp})) {  
   $metacache{$uri.':'.$unikey.'.'.$subp}=$value;  
       }  
       if (defined($metacache{$uri.':'.$unikey.'.default'})) {  
   $metacache{$uri.':'.$unikey}=  
      $metacache{$uri.':'.$unikey.'.default'}  
       }  
                   }  
               }  
              } else {  
 #  #
 # This is not a package - some other kind of start tag  # This is not a package - some other kind of start tag
 #   #
               my $entry=$token->[1];      my $entry=$token->[1];
               my $unikey;      my $unikey;
               if ($entry eq 'import') {      if ($entry eq 'import') {
                  $unikey='';   $unikey='';
               } else {      } else {
                  $unikey=$entry;   $unikey=$entry;
       }      }
               if ($prefix) {      $unikey.=&add_prefix_and_part($prefix,$token->[2]->{'part'});
   $unikey.=$prefix;  
               } else {      if (defined($token->[2]->{'id'})) { 
                 if (defined($token->[2]->{'part'})) {    $unikey.='_'.$token->[2]->{'id'}; 
                    $unikey.='_'.$token->[2]->{'part'};       }
         }  
       }  
               if (defined($token->[2]->{'id'})) {   
                  $unikey.='_'.$token->[2]->{'id'};   
       }  
   
              if ($entry eq 'import') {      if ($entry eq 'import') {
 #  #
 # Importing a library here  # Importing a library here
 #                  #
                  if ($depthcount<20) {   if ($depthcount<20) {
      my $location=$parser->get_text('/import');      my $location=$parser->get_text('/import');
      my $dir=$filename;      my $dir=$filename;
      $dir=~s|[^/]*$||;      $dir=~s|[^/]*$||;
      $location=&filelocation($dir,$location);      $location=&filelocation($dir,$location);
      foreach (sort(split(/\,/,&metadata($uri,'keys',      foreach (sort(split(/\,/,&metadata($uri,'keys',
  $location,$unikey,         $location,$unikey,
  $depthcount+1)))) {         $depthcount+1)))) {
                          $metathesekeys{$_}=1;   $metathesekeys{$_}=1;
      }      }
  }   }
              } else {       } else { 
   
               if (defined($token->[2]->{'name'})) {    if (defined($token->[2]->{'name'})) { 
                  $unikey.='_'.$token->[2]->{'name'};       $unikey.='_'.$token->[2]->{'name'}; 
       }   }
               $metathesekeys{$unikey}=1;   $metathesekeys{$unikey}=1;
               foreach (@{$token->[3]}) {   foreach (@{$token->[3]}) {
   $metacache{$uri.':'.$unikey.'.'.$_}=$token->[2]->{$_};      $metacache{$uri.':'.$unikey.'.'.$_}=$token->[2]->{$_};
               }   }
       my $internaltext=&HTML::Entities::decode($parser->get_text('/'.$entry));   my $internaltext=&HTML::Entities::decode($parser->get_text('/'.$entry));
       my $default=$metacache{$uri.':'.$unikey.'.default'};   my $default=$metacache{$uri.':'.$unikey.'.default'};
       if ( $internaltext =~ /^\s*$/ && $default !~ /^\s*$/) {   if ( $internaltext =~ /^\s*$/ && $default !~ /^\s*$/) {
   # only ws inside the tag, and not in default, so use default   # only ws inside the tag, and not in default, so use default
                   # as value   # as value
   $metacache{$uri.':'.$unikey}=$default;      $metacache{$uri.':'.$unikey}=$default;
       } else {   } else {
   # either something interesting inside the tag or default    # either something interesting inside the tag or default
                   # uninteresting                    # uninteresting
   $metacache{$uri.':'.$unikey}=$internaltext;      $metacache{$uri.':'.$unikey}=$internaltext;
       }   }
 # end of not-a-package not-a-library import  # end of not-a-package not-a-library import
    }      }
 # end of not-a-package start tag  # end of not-a-package start tag
   }   }
 # the next is the end of "start tag"  # the next is the end of "start tag"
  }      }
        }   }
        $metacache{$uri.':keys'}=join(',',keys %metathesekeys);  # are there custom rights to evaluate
    if ($metacache{$uri.':copyright'} eq 'custom') {
   
       #
       # Importing a rights file here
       #
       unless ($depthcount) {
    my $location=$metacache{$uri.':customdistributionfile'};
    my $dir=$filename;
    $dir=~s|[^/]*$||;
    $location=&filelocation($dir,$location);
    foreach (sort(split(/\,/,&metadata($uri,'keys',
      $location,'_rights',
      $depthcount+1)))) {
       $metathesekeys{$_}=1;
    }
       }
    }
    $metacache{$uri.':keys'}=join(',',keys %metathesekeys);
  &metadata_generate_part0(\%metathesekeys,\%metacache,$uri);   &metadata_generate_part0(\%metathesekeys,\%metacache,$uri);
        $metacache{$uri.':allpossiblekeys'}=join(',',keys %metathesekeys);   $metacache{$uri.':allpossiblekeys'}=join(',',keys %metathesekeys);
        $metacache{$uri.':cachedtimestamp'}=time;   $metacache{$uri.':cachedtimestamp'}=time;
 # this is the end of "was not already recently cached  # this is the end of "was not already recently cached
     }      }
     return $metacache{$uri.':'.$what};      return $metacache{$uri.':'.$what};
Removed from v.1.333  
changed lines
  Added in v.1.339

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