[BACK]Return to lonuserstate.pm CVS log [TXT] [DIR] Up to [LON-CAPA] / rat

Diff for /rat/lonuserstate.pm between versions 1.4 and 1.133

version 1.4, 2000/08/22 15:26:28 version 1.133, 2009/11/15 21:31:23
Line 1 Line 1
 # The LearningOnline Network with CAPA  # The LearningOnline Network with CAPA
 # Construct and maintain state and binary representation of course for user  # Construct and maintain state and binary representation of course for user
 #  #
 # (Server for RAT Maps  # $Id$
 #  #
 # (Edit Handler for RAT Maps  # Copyright Michigan State University Board of Trustees
 # (TeX Content Handler  
 #  #
 # 05/29/00,05/30 Gerd Kortemeyer)  # This file is part of the LearningOnline Network with CAPA (LON-CAPA).
 # 7/1 Gerd Kortemeyer)  
 # 7/1,7/3,7/4,7/7,7/8,7/10 Gerd Kortemeyer)  
 #  #
 # 7/15,7/17,7/18,8/1,8/2,8/4,8/5,8/21,8/22 Gerd Kortemeyer  # LON-CAPA 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.
   #
   # LON-CAPA 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.
   #
   # You should have received a copy of the GNU General Public License
   # along with LON-CAPA; if not, write to the Free Software
   # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   #
   # /home/httpd/html/adm/gpl.txt
   #
   # http://www.lon-capa.org/
   #
   ###
   
 package Apache::lonuserstate;  package Apache::lonuserstate;
   
   # ------------------------------------------------- modules used by this module
 use strict;  use strict;
 use Apache::Constants qw(:common :http);  
 use Apache::File;  
 use HTML::TokeParser;  use HTML::TokeParser;
 use Apache::lonnet();  use Apache::lonnet;
   use Apache::lonlocal;
   use Apache::loncommon();
 use GDBM_File;  use GDBM_File;
   use Apache::lonmsg;
   use Safe;
   use Safe::Hole;
   use Opcode;
   use Apache::lonenc;
   use Fcntl qw(:flock);
   use LONCAPA;
    
   
 # ---------------------------------------------------- Globals for this package  # ---------------------------------------------------- Globals for this package
   
 my $pc;      # Package counter  my $pc;      # Package counter
 my %hash;    # The big tied hash  my %hash;    # The big tied hash
   my %parmhash;# The hash with the parameters
 my @cond;    # Array with all of the conditions  my @cond;    # Array with all of the conditions
 my $errtext; # variable with all errors  my $errtext; # variable with all errors
   my $retfrid; # variable with the very first RID in the course
   my $retfurl; # first URL
   my %randompick; # randomly picked resources
   my %randompickseed; # optional seed for randomly picking resources
   my %randomorder; # maps to order contents randomly
   my %encurl; # URLs in this folder are supposed to be encrypted
   my %hiddenurl; # this URL (or complete folder) is supposed to be hidden
   
 # --------------------------------------------------------- Loads map from disk  # ----------------------------------- Remove version from URL and store in hash
   
 sub loadmap {   sub versiontrack {
     my $uri=shift;      my $uri=shift;
     if ($hash{'map_pc_'.$uri}) { return OK; }      if ($uri=~/\.(\d+)\.\w+$/) {
    my $version=$1;
    $uri=~s/\.\d+\.(\w+)$/\.$1/;
           unless ($hash{'version_'.$uri}) {
       $hash{'version_'.$uri}=$version;
    }
       }
       return $uri;
   }
   
   # -------------------------------------------------------------- Put in version
   
   sub putinversion {
       my $uri=shift;
       my $key=$env{'request.course.id'}.'_'.&Apache::lonnet::clutter($uri);
       if ($hash{'version_'.$uri}) {
    my $version=$hash{'version_'.$uri};
    if ($version eq 'mostrecent') { return $uri; }
    if ($version eq &Apache::lonnet::getversion(
    &Apache::lonnet::filelocation('',$uri))) 
                { return $uri; }
    $uri=~s/\.(\w+)$/\.$version\.$1/;
       }
       &Apache::lonnet::do_cache_new('courseresversion',$key,&Apache::lonnet::declutter($uri),600);
       return $uri;
   }
   
   # ----------------------------------------- Processing versions file for course
   
   sub processversionfile {
       my %cenv=@_;
       my %versions=&Apache::lonnet::dump('resourceversions',
          $cenv{'domain'},
          $cenv{'num'});
       foreach my $ver (keys(%versions)) {
    if ($ver=~/^error\:/) { return; }
    $hash{'version_'.$ver}=$versions{$ver};
       }
   }
   
   # --------------------------------------------------------- Loads map from disk
   
   sub loadmap { 
       my ($uri,$parent_rid)=@_;
       if ($hash{'map_pc_'.$uri}) { 
    $errtext.='<p class="LC_error">'.
       &mt('Multiple use of sequence/page [_1]! The course will not function properly.','<tt>'.$uri.'</tt>').
       '</p>';
    return; 
       }
     $pc++;      $pc++;
     my $lpc=$pc;      my $lpc=$pc;
     $hash{'map_pc_'.$uri}=$lpc;      $hash{'map_pc_'.$uri}=$lpc;
     $hash{'map_id_'.$lpc}=$uri;      $hash{'map_id_'.$lpc}=$uri;
   
     my $fn='/home/httpd/html'.$uri;  # Determine and check filename
       my $fn=&Apache::lonnet::filelocation('',&putinversion($uri));
   
       my $ispage=($fn=~/\.page$/);
   
     unless (($fn=~/\.course$/) ||      unless (($fn=~/\.sequence$/) ||
             ($fn=~/\.sequence$/) ||  
             ($fn=~/\.page$/)) {               ($fn=~/\.page$/)) { 
        $errtext.="Invalid map: $fn\n";   $errtext.=&mt("<br />Invalid map: <tt>[_1]</tt>",$fn);
        return OK;    return; 
     }      }
   
     unless (-e $fn) {      my $instr=&Apache::lonnet::getfile($fn);
  my $returned=Apache::lonnet::repcopy($fn);  
         unless ($returned eq OK) {      if ($instr eq -1) {
            $errtext.="Could not import: $fn - ";          $errtext.=&mt('<br />Map not loaded: The file <tt>[_1]</tt> does not exist.',$fn);
            if ($returned eq HTTP_SERVICE_UNAVAILABLE) {   return;
       $errtext.="Server unavailable\n";  
            }  
            if ($returned eq HTTP_NOT_FOUND) {  
       $errtext.="File not found\n";  
            }  
            if ($returned eq FORBIDDEN) {  
       $errtext.="Access forbidden\n";  
            }  
            return OK;  
        }  
     }      }
   
     if (-e $fn) {  # Successfully got file, parse it
         my @content;  
         {  
     my $fh=Apache::File->new($fn);  
             @content=<$fh>;  
         }  
         my $instr=join('',@content);  
         my $parser = HTML::TokeParser->new(\$instr);  
         my $token;  
   
         my $linkpc=0;      my $parser = HTML::TokeParser->new(\$instr);
       $parser->attr_encoded(1);
       # first get all parameters
       while (my $token = $parser->get_token) {
    next if ($token->[0] ne 'S');
    if ($token->[1] eq 'param') {
       &parse_param($token,$lpc);
    } 
       }
       #reset parser
       $parser = HTML::TokeParser->new(\$instr);
       $parser->attr_encoded(1);
   
         $fn=~/\.(\w+)$/;      my $linkpc=0;
   
         $hash{'map_type_'.$lpc}=$1;      $fn=~/\.(\w+)$/;
   
         while ($token = $parser->get_token) {      $hash{'map_type_'.$lpc}=$1;
     if ($token->[0] eq 'S') {  
                 if ($token->[1] eq 'resource') {  
 # -------------------------------------------------------------------- Resource  
   
                     my $rid=$lpc.'.'.$token->[2]->{'id'};      my $randomize = ($randomorder{$parent_rid} =~ /^yes$/i);
   
                     $hash{'kind_'.$rid}='res';      my @map_ids;
                     $hash{'title_'.$rid}=$token->[2]->{'title'};      while (my $token = $parser->get_token) {
                     my $turi=$token->[2]->{'src'};   next if ($token->[0] ne 'S');
                     $hash{'src_'.$rid}=$turi;   if ($token->[1] eq 'resource') {
       push(@map_ids,&parse_resource($token,$lpc,$ispage,$uri));
                     if (defined($hash{'ids_'.$turi})) {   } elsif ($token->[1] eq 'link' && !$randomize) {
                         $hash{'ids_'.$turi}.=','.$rid;  # ----------------------------------------------------------------------- Links
                     } else {      &make_link(++$linkpc,$lpc,$token->[2]->{'to'},
                         $hash{'ids_'.$turi}=''.$rid;         $token->[2]->{'from'},
                     }         $token->[2]->{'condition'});
    } elsif ($token->[1] eq 'condition' && !$randomize) {
       &parse_condition($token,$lpc);
    }
       }
   
                     if ($token->[2]->{'src'}=~/\/\//) {      if ($randomize) {
                         $hash{'ext_'.$rid}='true:';   if (!$env{'request.role.adv'}) {
                     } else {      my $seed;
                         $hash{'ext_'.$rid}='false:';      if (defined($randompickseed{$parent_rid})) {
                     }   $seed = $randompickseed{$parent_rid};
                     if ($token->[2]->{'type'}) {      } else {
  $hash{'type_'.$rid}=$token->[2]->{'type'};   my ($mapid,$resid)=split(/\./,$parent_rid);
                         if ($token->[2]->{'type'} eq 'start') {   my $symb=
     $hash{'map_start_'.$uri}="$rid";      &Apache::lonnet::encode_symb($hash{'map_id_'.$mapid},
                         }   $resid,$hash{'src_'.$parent_rid});
                         if ($token->[2]->{'type'} eq 'finish') {  
     $hash{'map_finish_'.$uri}="$rid";   $seed = $symb;
                         }      }
                     }  else {  
                         $hash{'type_'.$rid}='normal';      my $rndseed=&Apache::lonnet::rndseed($seed);
                     }      &Apache::lonnet::setup_random_from_rndseed($rndseed);
       @map_ids=&Math::Random::random_permutation(@map_ids);
    }
    my $from = shift(@map_ids);
    my $from_rid = $lpc.'.'.$from;
    $hash{'map_start_'.$uri} = $from_rid;
    $hash{'type_'.$from_rid}='start';
   
    while (my $to = shift(@map_ids)) {
       &make_link(++$linkpc,$lpc,$to,$from);
       my $to_rid =  $lpc.'.'.$to;
       $hash{'type_'.$to_rid}='normal';
       $from = $to;
       $from_rid = $to_rid;
    }
   
                     if (($turi=~/\.course$/) ||   $hash{'map_finish_'.$uri}= $from_rid;
                         ($turi=~/\.sequence$/) ||   $hash{'type_'.$from_rid}='finish';
                         ($turi=~/\.page$/)) {      }
                         $hash{'is_map_'.$rid}=1;  
                         &loadmap($turi);  
                     }   
                       
                 } elsif ($token->[1] eq 'condition') {  
 # ------------------------------------------------------------------- Condition  
   
                     my $rid=$lpc.'.'.$token->[2]->{'id'};      $parser = HTML::TokeParser->new(\$instr);
       $parser->attr_encoded(1);
       # last parse out the mapalias params so as to ignore anything
       # refering to non-existant resources
       while (my $token = $parser->get_token) {
    next if ($token->[0] ne 'S');
    if ($token->[1] eq 'param') {
       &parse_mapalias_param($token,$lpc);
    } 
       }
   }
   
                     $hash{'kind_'.$rid}='cond';  
                     $cond[$#cond+1]=$token->[2]->{'value'};  
                     $hash{'condid_'.$rid}=$#cond;  
                     if ($token->[2]->{'type'}) {  
                         $cond[$#cond].=':'.$token->[2]->{'type'};  
                     }  else {  
                         $cond[$#cond].=':normal';  
                     }  
   
                 } elsif ($token->[1] eq 'link') {  # -------------------------------------------------------------------- Resource
 # ----------------------------------------------------------------------- Links  sub parse_resource {
       my ($token,$lpc,$ispage,$uri) = @_;
       if ($token->[2]->{'type'} eq 'zombie') { next; }
       my $rid=$lpc.'.'.$token->[2]->{'id'};
       
       $hash{'kind_'.$rid}='res';
       $hash{'title_'.$rid}=$token->[2]->{'title'};
       my $turi=&versiontrack($token->[2]->{'src'});
       if ($token->[2]->{'version'}) {
    unless ($hash{'version_'.$turi}) {
       $hash{'version_'.$turi}=$1;
    }
       }
       my $title=$token->[2]->{'title'};
       $title=~s/\&colon\;/\:/gs;
   #   my $symb=&Apache::lonnet::encode_symb($uri,
   #  $token->[2]->{'id'},
   #  $turi);
   #   &Apache::lonnet::do_cache_new('title',$symb,$title);
       unless ($ispage) {
    $turi=~/\.(\w+)$/;
    my $embstyle=&Apache::loncommon::fileembstyle($1);
    if ($token->[2]->{'external'} eq 'true') { # external
       $turi=~s/^https?\:\/\//\/adm\/wrapper\/ext\//;
    } elsif ($turi=~/^\/*uploaded\//) { # uploaded
       if (($embstyle eq 'img') 
    || ($embstyle eq 'emb')
    || ($embstyle eq 'wrp')) {
    $turi='/adm/wrapper'.$turi;
       } elsif ($embstyle eq 'ssi') {
    #do nothing with these
       } elsif ($turi!~/\.(sequence|page)$/) {
    $turi='/adm/coursedocs/showdoc'.$turi;
       }
    } elsif ($turi=~/\S/) { # normal non-empty internal resource
       my $mapdir=$uri;
       $mapdir=~s/[^\/]+$//;
       $turi=&Apache::lonnet::hreflocation($mapdir,$turi);
       if (($embstyle eq 'img') 
    || ($embstyle eq 'emb')
    || ($embstyle eq 'wrp')) {
    $turi='/adm/wrapper'.$turi;
       }
    }
       }
   # Store reverse lookup, remove query string
       my $idsuri=$turi;
       $idsuri=~s/\?.+$//;
       if (defined($hash{'ids_'.$idsuri})) {
    $hash{'ids_'.$idsuri}.=','.$rid;
       } else {
    $hash{'ids_'.$idsuri}=''.$rid;
       }
       
       if ($turi=~/\/(syllabus|aboutme|navmaps|smppg|bulletinboard)$/) {
    $turi.='?register=1';
       }
       
       $hash{'src_'.$rid}=$turi;
       
       if ($token->[2]->{'external'} eq 'true') {
    $hash{'ext_'.$rid}='true:';
       } else {
    $hash{'ext_'.$rid}='false:';
       }
       if ($token->[2]->{'type'}) {
    $hash{'type_'.$rid}=$token->[2]->{'type'};
    if ($token->[2]->{'type'} eq 'start') {
       $hash{'map_start_'.$uri}="$rid";
    }
    if ($token->[2]->{'type'} eq 'finish') {
       $hash{'map_finish_'.$uri}="$rid";
    }
       }  else {
    $hash{'type_'.$rid}='normal';
       }
       
       if (($turi=~/\.sequence$/) ||
    ($turi=~/\.page$/)) {
    $hash{'is_map_'.$rid}=1;
    &loadmap($turi,$rid);
       } 
       return $token->[2]->{'id'};
   }
   
                     $linkpc++;  sub make_link {
                     my $linkid=$lpc.'.'.$linkpc;      my ($linkpc,$lpc,$to,$from,$condition) = @_;
       
       my $linkid=$lpc.'.'.$linkpc;
       my $goesto=$lpc.'.'.$to;
       my $comesfrom=$lpc.'.'.$from;
       my $undercond=0;
   
                     my $goesto=$lpc.'.'.$token->[2]->{'to'};      if ($condition) {
                     my $comesfrom=$lpc.'.'.$token->[2]->{'from'};   $undercond=$lpc.'.'.$condition;
                     my $undercond=0;      }
   
                     if ($token->[2]->{'condition'}) {      $hash{'goesto_'.$linkid}=$goesto;
  $undercond=$lpc.'.'.$token->[2]->{'condition'};      $hash{'comesfrom_'.$linkid}=$comesfrom;
                     }      $hash{'undercond_'.$linkid}=$undercond;
   
                     $hash{'goesto_'.$linkid}=$goesto;      if (defined($hash{'to_'.$comesfrom})) {
                     $hash{'comesfrom_'.$linkid}=$comesfrom;   $hash{'to_'.$comesfrom}.=','.$linkid;
                     $hash{'undercond_'.$linkid}=$undercond;      } else {
    $hash{'to_'.$comesfrom}=''.$linkid;
                     if (defined($hash{'to_'.$comesfrom})) {      }
                         $hash{'to_'.$comesfrom}.=','.$linkid;      if (defined($hash{'from_'.$goesto})) {
                     } else {   $hash{'from_'.$goesto}.=','.$linkid;
                         $hash{'to_'.$comesfrom}=''.$linkid;      } else {
                     }   $hash{'from_'.$goesto}=''.$linkid;
                     if (defined($hash{'from_'.$goesto})) {      }
                         $hash{'from_'.$goesto}.=','.$linkid;  }
                     } else {  
                         $hash{'from_'.$goesto}=''.$linkid;  
                     }  
                 }   
   
             }  # ------------------------------------------------------------------- Condition
         }  sub parse_condition {
       my ($token,$lpc) = @_;
       my $rid=$lpc.'.'.$token->[2]->{'id'};
       
       $hash{'kind_'.$rid}='cond';
   
       my $condition = $token->[2]->{'value'};
       $condition =~ s/[\n\r]+/ /gs;
       push(@cond, $condition);
       $hash{'condid_'.$rid}=$#cond;
       if ($token->[2]->{'type'}) {
    $cond[$#cond].=':'.$token->[2]->{'type'};
       }  else {
    $cond[$#cond].=':normal';
       }
   }
   
   # ------------------------------------------------------------------- Parameter
   
   sub parse_param {
       my ($token,$lpc) = @_;
       my $referid=$lpc.'.'.$token->[2]->{'to'};
       my $name=$token->[2]->{'name'};
       my $part;
       if ($name=~/^parameter_(.*)_/) {
    $part=$1;
       } else {
    $part=0;
       }
       $name=~s/^.*_([^_]*)$/$1/;
       my $newparam=
    &escape($token->[2]->{'type'}).':'.
    &escape($part.'.'.$name).'='.
    &escape($token->[2]->{'value'});
       if (defined($hash{'param_'.$referid})) {
    $hash{'param_'.$referid}.='&'.$newparam;
     } else {      } else {
         $errtext.='Map not loaded: The file does not exist. ';   $hash{'param_'.$referid}=''.$newparam;
       }
       if ($token->[2]->{'name'}=~/^parameter_(0_)*randompick$/) {
    $randompick{$referid}=$token->[2]->{'value'};
       }
       if ($token->[2]->{'name'}=~/^parameter_(0_)*randompickseed$/) {
    $randompickseed{$referid}=$token->[2]->{'value'};
       }
       if ($token->[2]->{'name'}=~/^parameter_(0_)*randomorder$/) {
    $randomorder{$referid}=$token->[2]->{'value'};
       }
       if ($token->[2]->{'name'}=~/^parameter_(0_)*encrypturl$/) {
    if ($token->[2]->{'value'}=~/^yes$/i) {
       $encurl{$referid}=1;
    }
       }
       if ($token->[2]->{'name'}=~/^parameter_(0_)*hiddenresource$/) {
    if ($token->[2]->{'value'}=~/^yes$/i) {
       $hiddenurl{$referid}=1;
    }
       }
   }
   
   sub parse_mapalias_param {
       my ($token,$lpc) = @_;
       my $referid=$lpc.'.'.$token->[2]->{'to'};
       return if (!exists($hash{'src_'.$referid}));
   
       if ($token->[2]->{'name'}=~/^parameter_(0_)*mapalias$/) {
    &count_mapalias($token->[2]->{'value'},$referid);
    $hash{'mapalias_'.$token->[2]->{'value'}}=$referid;
     }      }
 }  }
   
 # --------------------------------------------------------- Simplify expression  # --------------------------------------------------------- Simplify expression
   
 sub simplify {  sub simplify {
    my $expression=shift;      my $expression=shift;
 # "True and" is nothing   # (0&1) = 1
    $expression=~s/0\&//g;      $expression=~s/\(0\&([_\.\d]+)\)/$1/g;
 # (8)=8  # (8)=8
    $expression=~s/\((\d+)\)/$1/g;      $expression=~s/\(([_\.\d]+)\)/$1/g;
 # 8&8=8  # 8&8=8
    $expression=~s/(\d+)\&\1/$1/g;      $expression=~s/([^_\.\d])([_\.\d]+)\&\2([^_\.\d])/$1$2$3/g;
 # 8|8=8  # 8|8=8
    $expression=~s/(\d+)\|\1/$1/g;      $expression=~s/([^_\.\d])([_\.\d]+)\|\2([^_\.\d])/$1$2$3/g;
 # (5&3)&4=5&3&4  # (5&3)&4=5&3&4
    $expression=~s/\((\d+)\&(\d+)\)\&(\d+)/$1\&$2\&$3/g;      $expression=~s/\(([_\.\d]+)((?:\&[_\.\d]+)+)\)\&([_\.\d]+[^_\.\d])/$1$2\&$3/g;
 # (((5&3)|(4&6)))=((5&3)|(4&6))  # (((5&3)|(4&6)))=((5&3)|(4&6))
    $expression=~      $expression=~
        s/\((\(\(\d+(?:\&\d+)*\)(?:\|\(\d+(?:\&\d+)*\))+\))\)/$1/g;   s/\((\(\([_\.\d]+(?:\&[_\.\d]+)*\)(?:\|\([_\.\d]+(?:\&[_\.\d]+)*\))+\))\)/$1/g;
 # ((5&3)|(4&6))|(1&2)=(5&3)|(4&6)|(1&2)  # ((5&3)|(4&6))|(1&2)=(5&3)|(4&6)|(1&2)
    $expression=~      $expression=~
        s/\((\(\d+(?:\&\d+)*\))((?:\|\(\d+(?:\&\d+)*\))+)\)\|(\(\d+(?:\&\d+)*\))/\($1$2\|$3\)/g;   s/\((\([_\.\d]+(?:\&[_\.\d]+)*\))((?:\|\([_\.\d]+(?:\&[_\.\d]+)*\))+)\)\|(\([_\.\d]+(?:\&[_\.\d]+)*\))/\($1$2\|$3\)/g;
    return $expression;      return $expression;
 }  }
   
 # -------------------------------------------------------- Build condition hash  # -------------------------------------------------------- Build condition hash
   
 sub traceroute {  sub traceroute {
     my ($sofar,$rid,$beenhere)=@_;      my ($sofar,$rid,$beenhere,$encflag,$hdnflag)=@_;
     $sofar=simplify($sofar);      my $newsofar=$sofar=simplify($sofar);
     unless ($beenhere=~/\&$rid\&/) {      unless ($beenhere=~/\&\Q$rid\E\&/) {
        $beenhere.=$rid.'&';     $beenhere.=$rid.'&';  
        if (defined($hash{'conditions_'.$rid})) {   my ($mapid,$resid)=split(/\./,$rid);
    $hash{'conditions_'.$rid}=simplify(   my $symb=&Apache::lonnet::encode_symb($hash{'map_id_'.$mapid},$resid,$hash{'src_'.$rid});
    my $hidden=&Apache::lonnet::EXT('resource.0.hiddenresource',$symb);
   
    if ($hdnflag || lc($hidden) eq 'yes') {
       $hiddenurl{$rid}=1;
    }
    if (!$hdnflag && lc($hidden) eq 'no') {
       delete($hiddenurl{$rid});
    }
   
    my $encrypt=&Apache::lonnet::EXT('resource.0.encrypturl',$symb);
    if ($encflag || lc($encrypt) eq 'yes') { $encurl{$rid}=1; }
    if (($retfrid eq '') && ($hash{'src_'.$rid})
       && ($hash{'src_'.$rid}!~/\.sequence$/)) {
       $retfrid=$rid;
    }
    if (defined($hash{'conditions_'.$rid})) {
       $hash{'conditions_'.$rid}=simplify(
            '('.$hash{'conditions_'.$rid}.')|('.$sofar.')');             '('.$hash{'conditions_'.$rid}.')|('.$sofar.')');
        } else {   } else {
            $hash{'conditions_'.$rid}=$sofar;      $hash{'conditions_'.$rid}=$sofar;
        }   }
        if (defined($hash{'is_map_'.$rid})) {  
            if (defined($hash{'map_start_'.$hash{'src_'.$rid}})) {   # if the expression is just the 0th condition keep it
        &traceroute($sofar,$hash{'map_start_'.$hash{'src_'.$rid}},'&');   # otherwise leave a pointer to this condition expression
                if (defined($hash{'map_finish_'.$hash{'src_'.$rid}})) {   $newsofar = ($sofar eq '0') ? $sofar : '_'.$rid;
    $sofar=  
                   $hash{'conditions_'.$hash{'map_finish_'.$hash{'src_'.$rid}}};   if (defined($hash{'is_map_'.$rid})) {
                }      if (defined($hash{'map_start_'.$hash{'src_'.$rid}})) {
            }   $sofar=$newsofar=
        }      &traceroute($sofar,
        if (defined($hash{'to_'.$rid})) {   $hash{'map_start_'.$hash{'src_'.$rid}},
           map {   $beenhere,
    $encflag || $encurl{$rid},
    $hdnflag || $hiddenurl{$rid});
       }
    }
    if (defined($hash{'to_'.$rid})) {
       foreach my $id (split(/\,/,$hash{'to_'.$rid})) {
  my $further=$sofar;   my $further=$sofar;
                 if ($hash{'undercond_'.$_}) {                  if ($hash{'undercond_'.$id}) {
    if (defined($hash{'condid_'.$hash{'undercond_'.$_}})) {      if (defined($hash{'condid_'.$hash{'undercond_'.$id}})) {
         $further=simplify('('.$further.')&('.   $further=simplify('('.'_'.$rid.')&('.
                               $hash{'condid_'.$hash{'undercond_'.$_}}.')');    $hash{'condid_'.$hash{'undercond_'.$id}}.')');
    } else {      } else {
                        $errtext.='Undefined condition ID: '   $errtext.=&mt('<br />Undefined condition ID: [_1]',$hash{'undercond_'.$id});
                                  .$hash{'undercond_'.$_}.'. ';      }
                    }  
                 }                  }
                 &traceroute($further,$hash{'goesto_'.$_},$beenhere);                  $newsofar=&traceroute($further,$hash{'goesto_'.$id},$beenhere,
           } split(/\,/,$hash{'to_'.$rid});        $encflag,$hdnflag);
        }      }
    }
     }      }
       return $newsofar;
 }  }
   
 # ------------------------------------------ Cascading conditions, quick access  # ------------------------------ Cascading conditions, quick access, parameters
   
 sub accinit {  sub accinit {
     my ($uri,$short,$fn)=@_;      my ($uri,$short,$fn)=@_;
     my %acchash=();      my %acchash=();
     my %captured=();      my %captured=();
     my $condcounter=0;      my $condcounter=0;
     $acchash{'acc.cond.0'}='0';      $acchash{'acc.cond.'.$short.'.0'}=0;
     map {      foreach my $key (keys(%hash)) {
        if ($_=~/^conditions/) {   if ($key=~/^conditions/) {
   my $expr=$hash{$_};      my $expr=$hash{$key};
           map {      # try to find and factor out common sub-expressions
              my $sub=$_;      foreach my $sub ($expr=~m/(\(\([_\.\d]+(?:\&[_\.\d]+)+\)(?:\|\([_\.\d]+(?:\&[_\.\d]+)+\))+\))/g) {
              my $orig=$_;   my $orig=$sub;
              $sub=~/\(\((\d+(:?\&\d+)*)(?:\&\d+)+\)(?:\|\(\1(?:\&\d+)+\))+\)/;  
              my $factor=$1;   my ($factor) = ($sub=~/\(\(([_\.\d]+\&(:?[_\.\d]+\&)*)(?:[_\.\d]+\&*)+\)(?:\|\(\1(?:[_\.\d]+\&*)+\))+\)/);
              $sub=~s/$factor\&//g;   next if (!defined($factor));
              $sub=~s/^\(/\($factor\&\(/;  
      $sub.=')';   $sub=~s/\Q$factor\E//g;
              $sub=simplify($sub);   $sub=~s/^\(/\($factor\(/;
              $orig=~s/(\W)/\\$1/g;   $sub.=')';
      $expr=~s/$orig/$sub/;   $sub=simplify($sub);
   } ($expr=~m/(\(\(\d+(?:\&\d+)+\)(?:\|\(\d+(?:\&\d+)+\))+\))/g);   $expr=~s/\Q$orig\E/$sub/;
           $hash{$_}=$expr;      }
           unless (defined($captured{$expr})) {      $hash{$key}=$expr;
       $condcounter++;      unless (defined($captured{$expr})) {
               $captured{$expr}=$condcounter;   $condcounter++;
               $acchash{'acc.cond.'.$condcounter}=$expr;   $captured{$expr}=$condcounter;
           }    $acchash{'acc.cond.'.$short.'.'.$condcounter}=$expr;
         }      } 
     } keys %hash;   } elsif ($key=~/^param_(\d+)\.(\d+)/) {
     map {      my $prefix=&Apache::lonnet::encode_symb($hash{'map_id_'.$1},$2,
  if ($_=~/^ids/) {      $hash{'src_'.$1.'.'.$2});
     my $resid=$hash{$_};      foreach my $param (split(/\&/,$hash{$key})) {
             my $uri=$hash{'src_'.$resid};   my ($typename,$value)=split(/\=/,$param);
             my @uriparts=split(/\//,$uri);   my ($type,$name)=split(/\:/,$typename);
             my $urifile=$uriparts[$#uriparts];   $parmhash{$prefix.'.'.&unescape($name)}=
             $#uriparts--;      &unescape($value);
             my $uripath=join('/',@uriparts);   $parmhash{$prefix.'.'.&unescape($name).'.type'}=
             if (defined($hash{'conditions_'.$resid})) {      &unescape($type);
   $urifile.=':'.$captured{$hash{'conditions_'.$resid}};      }
             } else {   }
                 $urifile.=':0';      }
       foreach my $key (keys(%hash)) {
    if ($key=~/^ids/) {
       foreach my $resid (split(/\,/,$hash{$key})) {
    my $uri=$hash{'src_'.$resid};
    my ($uripath,$urifile) =
       &Apache::lonnet::split_uri_for_cond($uri);
    if ($uripath) {
       my $uricond='0';
       if (defined($hash{'conditions_'.$resid})) {
    $uricond=$captured{$hash{'conditions_'.$resid}};
       }
       if (defined($acchash{'acc.res.'.$short.'.'.$uripath})) {
    if ($acchash{'acc.res.'.$short.'.'.$uripath}=~
       /(\&\Q$urifile\E\:[^\&]*)/) {
       my $replace=$1;
       my $regexp=$replace;
       #$regexp=~s/\|/\\\|/g;
       $acchash{'acc.res.'.$short.'.'.$uripath} =~
    s/\Q$regexp\E/$replace\|$uricond/;
    } else {
       $acchash{'acc.res.'.$short.'.'.$uripath}.=
    $urifile.':'.$uricond.'&';
    }
       } else {
    $acchash{'acc.res.'.$short.'.'.$uripath}=
       '&'.$urifile.':'.$uricond.'&';
       }
    } 
       }
    }
       }
       $acchash{'acc.res.'.$short.'.'}='&:0&';
       my $courseuri=$uri;
       $courseuri=~s/^\/res\///;
       my $regexp = 1;
       &Apache::lonnet::delenv('(acc\.|httpref\.)',$regexp);
       &Apache::lonnet::appenv(\%acchash);
   }
   
   # ---------------- Selectively delete from randompick maps and hidden url parms
   
   sub hiddenurls {
       my $randomoutentry='';
       foreach my $rid (keys %randompick) {
           my $rndpick=$randompick{$rid};
           my $mpc=$hash{'map_pc_'.$hash{'src_'.$rid}};
   # ------------------------------------------- put existing resources into array
           my @currentrids=();
           foreach my $key (sort(keys(%hash))) {
       if ($key=~/^src_($mpc\.\d+)/) {
    if ($hash{'src_'.$1}) { push @currentrids, $1; }
             }              }
             if (defined($acchash{'acc.res.'.$uripath})) {          }
  $acchash{'acc.res.'.$uripath}.=$urifile.'&';   # rids are number.number and we want to numercially sort on 
             } else {          # the second number
                 $acchash{'acc.res.'.$uripath}='&'.$urifile.'&';   @currentrids=sort {
       my (undef,$aid)=split(/\./,$a);
       my (undef,$bid)=split(/\./,$b);
       $aid <=> $bid;
    } @currentrids;
           next if ($#currentrids<$rndpick);
   # -------------------------------- randomly eliminate the ones that should stay
    my (undef,$id)=split(/\./,$rid);
           if ($randompickseed{$rid}) { $id=$randompickseed{$rid}; }
    my $rndseed=&Apache::lonnet::rndseed($id); # use id instead of symb
    &Apache::lonnet::setup_random_from_rndseed($rndseed);
    my @whichids=&Math::Random::random_permuted_index($#currentrids+1);
           for (my $i=1;$i<=$rndpick;$i++) { $currentrids[$whichids[$i]]=''; }
    #&Apache::lonnet::logthis("$id,$rndseed,".join(':',@whichids));
   # -------------------------------------------------------- delete the leftovers
           for (my $k=0; $k<=$#currentrids; $k++) {
               if ($currentrids[$k]) {
    $hash{'randomout_'.$currentrids[$k]}=1;
                   my ($mapid,$resid)=split(/\./,$currentrids[$k]);
                   $randomoutentry.='&'.
       &Apache::lonnet::encode_symb($hash{'map_id_'.$mapid},
    $resid,
    $hash{'src_'.$currentrids[$k]}
    ).'&';
             }              }
         }          }
     } keys %hash;      }
     &Apache::lonnet::appenv(%acchash,  # ------------------------------ take care of explicitly hidden urls or folders
                             "request.course"    => $short,      foreach my $rid (keys %hiddenurl) {
                             "request.course.fn" => $fn);    $hash{'randomout_'.$rid}=1;
    my ($mapid,$resid)=split(/\./,$rid);
    $randomoutentry.='&'.
       &Apache::lonnet::encode_symb($hash{'map_id_'.$mapid},$resid,
    $hash{'src_'.$rid}).'&';
       }
   # --------------------------------------- append randomout entry to environment
       if ($randomoutentry) {
    &Apache::lonnet::appenv({'acc.randomout' => $randomoutentry});
       }
 }  }
   
 # ---------------------------------------------------- Read map and all submaps  # ---------------------------------------------------- Read map and all submaps
   
 #  
 # Call with uri of course map, short name for course, and filename for  
 # binary structure  
 #  
   
 sub readmap {  sub readmap {
    my ($uri,$short,$fn)=@_;      my $short=shift;
    @cond=('true:normal');      $short=~s/^\///;
    if (tie(%hash,'GDBM_File',"$fn.db",&GDBM_WRCREAT,0640)) {      my %cenv=&Apache::lonnet::coursedescription($short,{'freshen_cache'=>1});
       my $fn=$cenv{'fn'};
       my $uri;
       $short=~s/\//\_/g;
       unless ($uri=$cenv{'url'}) { 
    &Apache::lonnet::logthis('<font color="blue">WARNING: '.
    "Could not load course $short.</font>"); 
    return ('',&mt('No course data available.'));;
       }
       @cond=('true:normal');
   
       unless (open(LOCKFILE,">$fn.db.lock")) {
           $errtext.='<br />'.&mt('Map not loaded - Lock file could not be opened when reading map:').' <tt>'.$fn.'</tt>.';
           $retfurl = '';
           return ($retfurl,$errtext);
       }
       my $lock=0;
       my $gotstate=0;
       if (flock(LOCKFILE,LOCK_EX|LOCK_NB)) {
    $lock=1;
           &unlink_tmpfiles($fn);
       }
       undef %randompick;
       undef %hiddenurl;
       undef %encurl;
       $retfrid='';
       my ($untiedhash,$untiedparmhash,$tiedhash,$tiedparmhash);
       if ($lock) {
           if (tie(%hash,'GDBM_File',"$fn.db",&GDBM_WRCREAT(),0640)) {
               $tiedhash = 1;
               if (tie(%parmhash,'GDBM_File',$fn.'_parms.db',&GDBM_WRCREAT(),0640)) {
                   $tiedparmhash = 1;
                   $gotstate = &build_tmp_hashes($uri,$fn,$short,\%cenv);
                   unless ($gotstate) {
                       &Apache::lonnet::logthis('Failed to write statemap at first attempt '.$fn.' for '.$uri.'.</font>');
                   }
                   $untiedparmhash = untie(%parmhash);
                   unless ($untiedparmhash) {
                       &Apache::lonnet::logthis('<font color="blue">WARNING: '.
                           'Could not untie coursemap parmhash '.$fn.' for '.$uri.'.</font>');
                   }
               }
               $untiedhash = untie(%hash);
               unless ($untiedhash) {
                   &Apache::lonnet::logthis('<font color="blue">WARNING: '.
                       'Could not untie coursemap hash '.$fn.' for '.$uri.'.</font>');
               }
           }
    flock(LOCKFILE,LOCK_UN);
       }
       unless ($lock && $tiedhash && $tiedparmhash) { 
    # if we are here it is likely because we are already trying to 
    # initialize the course in another child, busy wait trying to 
    # tie the hashes for the next 90 seconds, if we succeed forward 
    # them on to navmaps, if we fail, throw up the Could not init 
    # course screen
    if ($lock) {
       # Got the lock but not the DB files
       flock(LOCKFILE,LOCK_UN);
               $lock = 0;
    }
           if ($tiedhash) {
               unless($untiedhash) {
           untie(%hash);
               }
           }
           if ($tiedparmhash) {
               unless($untiedparmhash) {
                   untie(%parmhash);
               }
           }
    &Apache::lonnet::logthis('<font color="blue">WARNING: '.
    "Could not tie coursemap $fn for $uri.</font>");
           $tiedhash = '';
           $tiedparmhash = '';
    my $i=0;
    while($i<90) {
       $i++;
       sleep(1);
       if (flock(LOCKFILE,LOCK_EX|LOCK_NB)) {
                   $lock = 1;
    if (tie(%hash,'GDBM_File',"$fn.db",&GDBM_READER(),0640)) {
                       $tiedhash = 1;
       if (tie(%parmhash,'GDBM_File',$fn.'_parms.db',&GDBM_READER(),0640)) {
                           $tiedparmhash = 1;
                           if (-e "$fn.state") {
               $retfurl='/adm/navmaps';
               &Apache::lonnet::appenv({"request.course.id"  => $short,
                  "request.course.fn"  => $fn,
                "request.course.uri" => $uri});
               $untiedhash = untie(%hash);
               $untiedparmhash = untie(%parmhash);
                               $gotstate = 1;
               last;
           }
                           $untiedparmhash = untie(%parmhash);
               }
               $untiedhash = untie(%hash);
                   }
               }
    }
           if ($lock) {
               flock(LOCKFILE,LOCK_UN);
               $lock = 0;
               if ($tiedparmhash) {
                   unless ($untiedparmhash) {
                       &Apache::lonnet::logthis('<font color="blue">WARNING: '.
                           'Could not untie coursemap parmhash '.$fn.' for '.$uri.'.</font>');
                   }
               }
               if ($tiedparmhash) {
                   unless ($untiedhash) {
                       &Apache::lonnet::logthis('<font color="blue">WARNING: '.
                           'Could not untie coursemap hash '.$fn.' for '.$uri.'.</font>');
                   }
               }
           }
       }
       unless ($gotstate) {
           $lock = 0;
           &Apache::lonnet::logthis('<font color="blue">WARNING: '.
                        'Could not read statemap '.$fn.' for '.$uri.'.</font>');
           &unlink_tmpfiles($fn);
           if (flock(LOCKFILE,LOCK_EX|LOCK_NB)) {
               $lock=1;
           }
           undef %randompick;
           undef %hiddenurl;
           undef %encurl;
           $retfrid='';
           if ($lock) {
               if (tie(%hash,'GDBM_File',"$fn.db",&GDBM_WRCREAT(),0640)) {
                   if (tie(%parmhash,'GDBM_File',$fn.'_parms.db',&GDBM_WRCREAT(),0640)) {
                       $gotstate = &build_tmp_hashes($uri,$fn,$short,\%cenv);
                       unless ($gotstate) {
                           &Apache::lonnet::logthis('<font color="blue">WARNING: '.
                               'Failed to write statemap at second attempt '.$fn.' for '.$uri.'.</font>');
                       }
                       unless (untie(%parmhash)) {
                           &Apache::lonnet::logthis('<font color="blue">WARNING: '.
                               'Could not untie coursemap parmhash '.$fn.'.db for '.$uri.'.</font>');
                       }
                   } else {
                       &Apache::lonnet::logthis('<font color="blue">WARNING: '.
                           'Could not tie coursemap '.$fn.'__parms.db for '.$uri.'.</font>');
                   }
                   unless (untie(%hash)) {
                       &Apache::lonnet::logthis('<font color="blue">WARNING: '.
                           'Could not untie coursemap hash '.$fn.'.db for '.$uri.'.</font>');
                   }
               } else {
                  &Apache::lonnet::logthis('<font color="blue">WARNING: '.
                      'Could not tie coursemap '.$fn.'.db for '.$uri.'.</font>');
               }
               flock(LOCKFILE,LOCK_UN);
               $lock = 0;
           } else {
               &Apache::lonnet::logthis('<font color="blue">WARNING: '.
               'Could not obtain lock to tie coursemap hash '.$fn.'.db for '.$uri.'.</font>');
           }
       }
       close(LOCKFILE);
       unless (($errtext eq '') || ($env{'request.course.uri'} =~ m{^/uploaded/})) {
           &Apache::lonmsg::author_res_msg($env{'request.course.uri'},
                                           $errtext);
       }
   # ------------------------------------------------- Check for critical messages
   
       my @what=&Apache::lonnet::dump('critical',$env{'user.domain'},
      $env{'user.name'});
       if ($what[0]) {
    if (($what[0] ne 'con_lost') && ($what[0]!~/^error\:/)) {
       $retfurl='/adm/email?critical=display';
           }
       }
       return ($retfurl,$errtext);
   }
   
   sub build_tmp_hashes {
       my ($uri,$fn,$short,$cenvref) = @_;
       unless(ref($cenvref) eq 'HASH') {
           return;
       }
       my %cenv = %{$cenvref};
       my $gotstate = 0;
     %hash=();      %hash=();
       %parmhash=();
     $errtext='';      $errtext='';
     $pc=0;      $pc=0;
     loadmap($uri);      &clear_mapalias_count();
       &processversionfile(%cenv);
       my $furi=&Apache::lonnet::clutter($uri);
       $hash{'src_0.0'}=&versiontrack($furi);
       $hash{'title_0.0'}=&Apache::lonnet::metadata($uri,'title');
       $hash{'ids_'.$furi}='0.0';
       $hash{'is_map_0.0'}=1;
       &loadmap($uri,'0.0');
     if (defined($hash{'map_start_'.$uri})) {      if (defined($hash{'map_start_'.$uri})) {
           &Apache::lonnet::appenv({"request.course.id"  => $short,
                                    "request.course.fn"  => $fn,
                                    "request.course.uri" => $uri});
           $env{'request.course.id'}=$short;
         &traceroute('0',$hash{'map_start_'.$uri},'&');          &traceroute('0',$hash{'map_start_'.$uri},'&');
         &accinit($uri,$short,$fn);          &accinit($uri,$short,$fn);
           &hiddenurls();
       }
       $errtext .= &get_mapalias_errors();
   # ------------------------------------------------------- Put versions into src
       foreach my $key (keys(%hash)) {
           if ($key=~/^src_/) {
               $hash{$key}=&putinversion($hash{$key});
           } elsif ($key =~ /^(map_(?:start|finish|pc)_)(.*)/) {
               my ($type, $url) = ($1,$2);
               my $value = $hash{$key};
               $hash{$type.&putinversion($url)}=$value;
           }
     }      }
     unless (untie(%hash)) {  # ---------------------------------------------------------------- Encrypt URLs
       &Apache::lonnet::logthis("<font color=blue>WARNING: ".      foreach my $id (keys(%encurl)) {
                        "Could not untie coursemap $fn for $uri.</font>");   #           $hash{'src_'.$id}=&Apache::lonenc::encrypted($hash{'src_'.$id});
           $hash{'encrypted_'.$id}=1;
     }      }
   # ----------------------------------------------- Close hashes to finally store
   # --------------------------------- Routine must pass this point, no early outs
       $hash{'first_rid'}=$retfrid;
       my ($mapid,$resid)=split(/\./,$retfrid);
       $hash{'first_mapurl'}=$hash{'map_id_'.$mapid};
       my $symb=&Apache::lonnet::encode_symb($hash{'map_id_'.$mapid},$resid,$hash{'src_'.$retfrid});
       $retfurl=&add_get_param($hash{'src_'.$retfrid},{ 'symb' => $symb });
       if ($hash{'encrypted_'.$retfrid}) {
           $retfurl=&Apache::lonenc::encrypted($retfurl,(&Apache::lonnet::allowed('adv') ne 'F'));
       }
       $hash{'first_url'}=$retfurl;
   # ---------------------------------------------------- Store away initial state
     {      {
      my $cfh;          my $cfh;
      if ($cfh=Apache::File->new(">$fn.state")) {          if (open($cfh,">$fn.state")) {
         print $cfh join("\n",@cond);              print $cfh join("\n",@cond);
      } else {              $gotstate = 1;
       &Apache::lonnet::logthis("<font color=blie>WARNING: ".          } else {
                        "Could not write statemap $fn for $uri.</font>");               &Apache::lonnet::logthis("<font color=blue>WARNING: ".
      }                                       "Could not write statemap $fn for $uri.</font>");
     }            }
    } else {      }
       &Apache::lonnet::logthis("<font color=blie>WARNING: ".      return $gotstate;
                        "Could not tie coursemap $fn for $uri.</font>");   }
    }  
    return $errtext;  sub unlink_tmpfiles {
       my ($fn) = @_;
       if ($fn =~ m{^\Q$Apache::lonnet::perlvar{'lonUsersDir'}\E/tmp/}) {
           my @files = qw (.db _symb.db .state _parms.db);
           foreach my $file (@files) {
               if (-e $fn.$file) {
                   unless (unlink($fn.$file)) {
                       &Apache::lonnet::logthis("<font color=blue>WARNING: ".
                                    "Could not unlink ".$fn.$file."</font>");
                   }
               }
           }
       }
       return;
   }
   
   # ------------------------------------------------------- Evaluate state string
   
   sub evalstate {
       my $fn=$env{'request.course.fn'}.'.state';
       my $state='';
       if (-e $fn) {
    my @conditions=();
    {
       open(my $fh,"<$fn");
       @conditions=<$fh>;
               close($fh);
    }  
    my $safeeval = new Safe;
    my $safehole = new Safe::Hole;
    $safeeval->permit("entereval");
    $safeeval->permit(":base_math");
    $safeeval->deny(":base_io");
    $safehole->wrap(\&Apache::lonnet::EXT,$safeeval,'&EXT');
    foreach my $line (@conditions) {
       chomp($line);
       my ($condition,$weight)=split(/\:/,$line);
       if ($safeeval->reval($condition)) {
    if ($weight eq 'force') {
       $state.='3';
    } else {
       $state.='2';
    }
       } else {
    if ($weight eq 'stop') {
       $state.='0';
    } else {
       $state.='1';
    }
       }
    }
       }
       &Apache::lonnet::appenv({'user.state.'.$env{'request.course.id'} => $state});
       return $state;
   }
   
   {
       my %mapalias_cache;
       sub count_mapalias {
    my ($value,$resid) = @_;
     push(@{ $mapalias_cache{$value} }, $resid);
       }
   
       sub get_mapalias_errors {
    my $error_text;
    foreach my $mapalias (sort(keys(%mapalias_cache))) {
       next if (scalar(@{ $mapalias_cache{$mapalias} } ) == 1);
       my $count;
       my $which =
    join('</li><li>', 
        map {
    my $id = $_;
    if (exists($hash{'src_'.$id})) {
        $count++;
    }
    my ($mapid) = split(/\./,$id);
                            &mt('Resource "[_1]" <br /> in Map "[_2]"',
        $hash{'title_'.$id},
        $hash{'title_'.$hash{'ids_'.$hash{'map_id_'.$mapid}}});
        } (@{ $mapalias_cache{$mapalias} }));
       next if ($count < 2);
       $error_text .= '<div class="LC_error">'.
    &mt('Error: Found the mapalias "[_1]" defined multiple times.',
       $mapalias).
    '</div><ul><li>'.$which.'</li></ul>';
    }
    &clear_mapalias_count();
    return $error_text;
       }
       sub clear_mapalias_count {
    undef(%mapalias_cache);
       }
 }  }
    
 1;  1;
 __END__  __END__
   
   =head1 NAME
   
   Apache::lonuserstate - Construct and maintain state and binary representation
   of course for user
   
   =head1 SYNOPSIS
   
   Invoked by lonroles.pm.
   
   &Apache::lonuserstate::readmap($cdom.'/'.$cnum);
   
   =head1 INTRODUCTION
   
   This module constructs and maintains state and binary representation
   of course for user.
   
   This is part of the LearningOnline Network with CAPA project
   described at http://www.lon-capa.org.
   
   =head1 SUBROUTINES
   
   =over
   
   =item loadmap()
   
   Loads map from disk
   
   =item simplify()
   
   Simplify expression
   
   =item traceroute()
   
   Build condition hash
   
   =item accinit()
   
   Cascading conditions, quick access, parameters
   
   =item readmap()
   
   Read map and all submaps
   
   =item evalstate()
   
   Evaluate state string
   
   =back
   
   =cut
Removed from v.1.4  
changed lines
  Added in v.1.133

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
500 Internal Server Error

Internal Server Error

The server encountered an internal error or misconfiguration and was unable to complete your request.

Please contact the server administrator at root@localhost to inform them of the time this error occurred, and the actions you performed just before this error.

More information about this error may be available in the server error log.