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

Diff for /rat/lonuserstate.pm between versions 1.149.2.5.2.2 and 1.149.4.1

version 1.149.2.5.2.2, 2022/05/29 12:35:02 version 1.149.4.1, 2020/04/07 20:57:02
Line 42  use Safe::Hole; Line 42  use Safe::Hole;
 use Opcode;  use Opcode;
 use Apache::lonenc;  use Apache::lonenc;
 use Fcntl qw(:flock);  use Fcntl qw(:flock);
 use LONCAPA qw(:DEFAULT :match);    use LONCAPA qw(:DEFAULT :match);
 use File::Basename;  use File::Basename;
   
     
Line 62  my %randomorder; # maps to order content Line 62  my %randomorder; # maps to order content
 my %randomizationcode; # code used to grade folder for bubblesheet exam   my %randomizationcode; # code used to grade folder for bubblesheet exam 
 my %encurl; # URLs in this folder are supposed to be encrypted  my %encurl; # URLs in this folder are supposed to be encrypted
 my %hiddenurl; # this URL (or complete folder) is supposed to be hidden  my %hiddenurl; # this URL (or complete folder) is supposed to be hidden
 my %deeplinkout; # this URL (or complete folder) unavailable in deep-link session  
 my %rescount; # count of unhidden items in each map  
 my %mapcount; # count of unhidden maps in each map  
   
 # ----------------------------------- Remove version from URL and store in hash  # ----------------------------------- Remove version from URL and store in hash
   
Line 243  sub loadmap { Line 240  sub loadmap {
   
     my @map_ids;      my @map_ids;
     my $codechecked;      my $codechecked;
     $rescount{$lpc} = 0;  
     $mapcount{$lpc} = 0;  
     while (my $token = $parser->get_token) {      while (my $token = $parser->get_token) {
  next if ($token->[0] ne 'S');   next if ($token->[0] ne 'S');
   
Line 254  sub loadmap { Line 249  sub loadmap {
     my $resource_id = &parse_resource($token,$lpc,$ispage,$uri,$courseid);      my $resource_id = &parse_resource($token,$lpc,$ispage,$uri,$courseid);
     if (defined $resource_id) {      if (defined $resource_id) {
  push(@map_ids, $resource_id);   push(@map_ids, $resource_id);
                 if ($hash{'src_'.$lpc.'.'.$resource_id}) {  
                     $rescount{$lpc} ++;  
                     if (($hash{'src_'.$lpc.'.'.$resource_id}=~/\.sequence$/) ||  
                         ($hash{'src_'.$lpc.'.'.$resource_id}=~/\.page$/)) {  
                         $mapcount{$lpc} ++;  
                     }  
                 }  
                 unless ($codechecked) {                  unless ($codechecked) {
                     my $startsymb =                      my $startsymb =
                        &Apache::lonnet::encode_symb($hash{'map_id_'.$lpc},$resource_id,                         &Apache::lonnet::encode_symb($hash{'map_id_'.$lpc},$resource_id,
Line 293  sub loadmap { Line 281  sub loadmap {
     # Handle randomization and random selection      # Handle randomization and random selection
   
     if ($randomize) {      if ($randomize) {
         unless (&is_advanced($courseid)) {          my $advanced;
           if ($env{'request.course.id'}) {
               $advanced = (&Apache::lonnet::allowed('adv') eq 'F');
           } else {
               $env{'request.course.id'} = $courseid;
               $advanced = (&Apache::lonnet::allowed('adv') eq 'F');
               $env{'request.course.id'} = '';
           }
           unless ($advanced) {
             # Order of resources is not randomized if user has and advanced role in the course.              # Order of resources is not randomized if user has and advanced role in the course.
     my $seed;      my $seed;
   
Line 376  sub loadmap { Line 372  sub loadmap {
     }      }
 }  }
   
 sub is_advanced {  
     my ($courseid) = @_;  
     my $advanced;  
     if ($env{'request.course.id'}) {  
         $advanced = (&Apache::lonnet::allowed('adv') eq 'F');  
     } else {  
         $env{'request.course.id'} = $courseid;  
         $advanced = (&Apache::lonnet::allowed('adv') eq 'F');  
         $env{'request.course.id'} = '';  
     }  
     return $advanced;  
 }  
   
 # -------------------------------------------------------------------- Resource  # -------------------------------------------------------------------- Resource
 #  #
Line 474  sub parse_resource { Line 458  sub parse_resource {
     # is not a page.  If the resource is a page then it must be      # is not a page.  If the resource is a page then it must be
     # assembled (at fetch time?).      # assembled (at fetch time?).
   
     if ($ispage) {      unless ($ispage) {
         if ($token->[2]->{'external'} eq 'true') { # external  
             $turi=~s{^http\://}{/ext/};  
         }  
     } else {  
  $turi=~/\.(\w+)$/;   $turi=~/\.(\w+)$/;
  my $embstyle=&Apache::loncommon::fileembstyle($1);   my $embstyle=&Apache::loncommon::fileembstyle($1);
  if ($token->[2]->{'external'} eq 'true') { # external   if ($token->[2]->{'external'} eq 'true') { # external
Line 570  sub parse_resource { Line 550  sub parse_resource {
     if (($turi=~/\.sequence$/) ||      if (($turi=~/\.sequence$/) ||
  ($turi=~/\.page$/)) {   ($turi=~/\.page$/)) {
  $hash{'is_map_'.$rid}=1;   $hash{'is_map_'.$rid}=1;
  if ((!$hiddenurl{$rid}) || (&is_advanced($courseid))) {   &loadmap($turi,$rid,$courseid);
     &loadmap($turi,$rid,$courseid);  
  }  
     }       } 
     return $token->[2]->{'id'};      return $token->[2]->{'id'};
 }  }
Line 905  sub simplify { Line 883  sub simplify {
 #    new value indicating how far the map has been traversed (the sofar).  #    new value indicating how far the map has been traversed (the sofar).
 #  #
 sub traceroute {  sub traceroute {
     my ($sofar,$rid,$beenhere,$encflag,$hdnflag,$cid)=@_;      my ($sofar,$rid,$beenhere,$encflag,$hdnflag)=@_;
     my $newsofar=$sofar=simplify($sofar);      my $newsofar=$sofar=simplify($sofar);
   
     unless ($beenhere=~/\&\Q$rid\E\&/) {      unless ($beenhere=~/\&\Q$rid\E\&/) {
Line 929  sub traceroute { Line 907  sub traceroute {
     $retfrid=$rid;      $retfrid=$rid;
  }   }
   
         my (@deeplink,@recurseup);  
         if ($hash{'is_map_'.$rid}) {  
             my ($cdom,$cnum) = split(/_/,$cid);  
             my $mapsrc = $hash{'src_'.$rid};  
             my $map_pc = $hash{'map_pc_'.$mapsrc};  
             my @pcs = split(/,/,$hash{'map_hierarchy_'.$map_pc});  
             shift(@pcs);  
             @recurseup = map { &Apache::lonnet::declutter($hash{'map_id_'.$_}) } reverse(@pcs);  
             my $mapname = &Apache::lonnet::declutter(&Apache::lonnet::deversion($mapsrc));  
             my $deeplinkval = &get_mapparam($env{'user.name'},$env{'user.domain'},$cnum,$cdom,  
                                             $rid,$mapname,'0.deeplink',\@recurseup);  
             if ($deeplinkval ne '') {  
                 @deeplink = ($deeplinkval,'map');  
             }  
         } else {  
             my @pcs = split(/,/,$hash{'map_hierarchy_'.$mapid});  
             shift(@pcs);  
             @recurseup = map { &Apache::lonnet::declutter($hash{'map_id_'.$_}) } reverse(@pcs);  
             @deeplink = &Apache::lonnet::EXT('resource.0.deeplink',$symb,'','','','',$cid,\@recurseup);  
         }  
         unless (@deeplink < 2) {  
             $hash{'deeplinkonly_'.$rid}=join(':',map { &escape($_); } @deeplink);  
         }  
   
  if (defined($hash{'conditions_'.$rid})) {   if (defined($hash{'conditions_'.$rid})) {
     $hash{'conditions_'.$rid}=simplify(      $hash{'conditions_'.$rid}=simplify(
            '('.$hash{'conditions_'.$rid}.')|('.$sofar.')');             '('.$hash{'conditions_'.$rid}.')|('.$sofar.')');
Line 974  sub traceroute { Line 928  sub traceroute {
  $hash{'map_start_'.$hash{'src_'.$rid}},   $hash{'map_start_'.$hash{'src_'.$rid}},
  $beenhere,   $beenhere,
  $encflag || $encurl{$rid},   $encflag || $encurl{$rid},
  $hdnflag || $hiddenurl{$rid},   $hdnflag || $hiddenurl{$rid});
                                 $cid);  
     }      }
  }   }
   
Line 1002  sub traceroute { Line 955  sub traceroute {
                 }                  }
  #  Recurse to resoruces that have to's to us.   #  Recurse to resoruces that have to's to us.
                 $newsofar=&traceroute($further,$hash{'goesto_'.$id},$beenhere,                  $newsofar=&traceroute($further,$hash{'goesto_'.$id},$beenhere,
       $encflag,$hdnflag,$cid);        $encflag,$hdnflag);
     }      }
  }   }
     }      }
Line 1161  sub hiddenurls { Line 1114  sub hiddenurls {
             if ($currentrids[$k]) {              if ($currentrids[$k]) {
  $hash{'randomout_'.$currentrids[$k]}=1;   $hash{'randomout_'.$currentrids[$k]}=1;
                 my ($mapid,$resid)=split(/\./,$currentrids[$k]);                  my ($mapid,$resid)=split(/\./,$currentrids[$k]);
                 if ($rescount{$mapid}) {  
                     $rescount{$mapid} --;  
                 }  
                 if ($hash{'is_map_'.$currentrids[$k]}) {  
                     if ($mapcount{$mapid}) {  
                         $mapcount{$mapid} --;  
                     }  
                 }  
                 $randomoutentry.='&'.                  $randomoutentry.='&'.
     &Apache::lonnet::encode_symb($hash{'map_id_'.$mapid},      &Apache::lonnet::encode_symb($hash{'map_id_'.$mapid},
  $resid,   $resid,
Line 1181  sub hiddenurls { Line 1126  sub hiddenurls {
     foreach my $rid (keys(%hiddenurl)) {      foreach my $rid (keys(%hiddenurl)) {
  $hash{'randomout_'.$rid}=1;   $hash{'randomout_'.$rid}=1;
  my ($mapid,$resid)=split(/\./,$rid);   my ($mapid,$resid)=split(/\./,$rid);
         if ($rescount{$mapid}) {  
             $rescount{$mapid} --;  
         }  
         if ($hash{'is_map_'.$rid}) {  
             if ($mapcount{$mapid}) {  
                 $mapcount{$mapid} --;  
             }  
         }  
  $randomoutentry.='&'.   $randomoutentry.='&'.
     &Apache::lonnet::encode_symb($hash{'map_id_'.$mapid},$resid,      &Apache::lonnet::encode_symb($hash{'map_id_'.$mapid},$resid,
  $hash{'src_'.$rid}).'&';   $hash{'src_'.$rid}).'&';
Line 1199  sub hiddenurls { Line 1136  sub hiddenurls {
     }      }
 }  }
   
 sub deeplinkouts {  
     my $deeplinkoutentry;  
     foreach my $rid (keys(%deeplinkout)) {  
         $hash{'deeplinkout_'.$rid}=1;  
         my ($mapid,$resid)=split(/\./,$rid);  
         $deeplinkoutentry.='&'.  
             &Apache::lonnet::encode_symb($hash{'map_id_'.$mapid},$resid,  
                                          $hash{'src_'.$rid}).'&';  
     }  
 # --------------------------------------- append deeplinkout entry to environment  
     if ($deeplinkoutentry) {  
         &Apache::lonnet::appenv({'acc.deeplinkout' => $deeplinkoutentry});  
     }  
 }  
   
 # -------------------------------------- populate big hash with map breadcrumbs  
   
 # Create map_breadcrumbs_$pc from map_hierarchy_$pc by omitting intermediate  
 # maps not shown in Course Contents table.  
   
 sub mapcrumbs {  
     my ($cid) = @_;  
     foreach my $key (keys(%rescount)) {  
         if ($hash{'map_hierarchy_'.$key}) {  
             my $skipnext = 0;  
             foreach my $id (split(/,/,$hash{'map_hierarchy_'.$key}),$key) {  
                 my $rid = $hash{'ids_'.$hash{'map_id_'.$id}};  
                 unless (($skipnext) || (!&is_advanced($cid) && $hash{'deeplinkout_'.$rid})) {  
                     $hash{'map_breadcrumbs_'.$key} .= "$id,";  
                 }  
                 unless (($id == 0) || ($id == 1)) {  
                     if ((!$rescount{$id}) || ($rescount{$id} == 1 && $mapcount{$id} == 1)) {  
                         $skipnext = 1;  
                     } else {  
                         $skipnext = 0;  
                     }  
                 }  
             }  
             $hash{'map_breadcrumbs_'.$key} =~ s/,$//;  
         }  
     }  
 }  
   
 # ---------------------------------------------------- Read map and all submaps  # ---------------------------------------------------- Read map and all submaps
   
 sub readmap {  sub readmap {
     my ($short,$critmsg_check) = @_;      my $short=shift;
     $short=~s/^\///;      $short=~s/^\///;
   
     # TODO:  Hidden dependency on current user:      # TODO:  Hidden dependency on current user:
Line 1262  sub readmap { Line 1156  sub readmap {
     }      }
     @cond=('true:normal');      @cond=('true:normal');
   
     unless (open(LOCKFILE,">","$fn.db.lock")) {      unless (open(LOCKFILE,">$fn.db.lock")) {
  #    # 
  # Most likely a permissions problem on the lockfile or its directory.   # Most likely a permissions problem on the lockfile or its directory.
  #   #
Line 1285  sub readmap { Line 1179  sub readmap {
     undef %randomizationcode;      undef %randomizationcode;
     undef %hiddenurl;      undef %hiddenurl;
     undef %encurl;      undef %encurl;
     undef %deeplinkout;  
     undef %rescount;  
     undef %mapcount;  
     $retfrid='';      $retfrid='';
     $errtext='';      $errtext='';
     my ($untiedhash,$untiedparmhash,$tiedhash,$tiedparmhash); # More state flags.      my ($untiedhash,$untiedparmhash,$tiedhash,$tiedparmhash); # More state flags.
Line 1434  sub readmap { Line 1325  sub readmap {
         undef %randomizationcode;          undef %randomizationcode;
         undef %hiddenurl;          undef %hiddenurl;
         undef %encurl;          undef %encurl;
         undef %deeplinkout;  
         undef %rescount;  
         undef %mapcount;  
         $errtext='';          $errtext='';
         $retfrid='';          $retfrid='';
  #   #
Line 1484  sub readmap { Line 1373  sub readmap {
   
 #  Depends on user must parameterize this as well..or separate as this is:  #  Depends on user must parameterize this as well..or separate as this is:
 #  more part of determining what someone sees on entering a course?  #  more part of determining what someone sees on entering a course?
 #  When lonuserstate::readmap() is called from lonroles.pm, i.e.,  
 #  after selecting a role in a course, critical_redirect will be called,  
 #  unless the course has a blocking event in effect, which suppresses  
 #  critical message checking (users without evb priv).  
 #  
   
     if ($critmsg_check) {      my @what=&Apache::lonnet::dump('critical',$env{'user.domain'},
         my ($redirect,$url) = &Apache::loncommon::critical_redirect();     $env{'user.name'});
         if ($redirect) {      if ($what[0]) {
             $retfurl = $url;   if (($what[0] ne 'con_lost') && ($what[0]!~/^error\:/)) {
       $retfurl='/adm/email?critical=display';
         }          }
     }       }
     return ($retfurl,$errtext);      return ($retfurl,$errtext);
 }  }
   
Line 1543  sub build_tmp_hashes { Line 1428  sub build_tmp_hashes {
     # Load the map.. note that loadmap may implicitly recurse if the map contains       # Load the map.. note that loadmap may implicitly recurse if the map contains 
     # sub-maps.      # sub-maps.
   
   
     &loadmap($uri,'0.0',$short);      &loadmap($uri,'0.0',$short);
   
     #  The code below only executes if there is a starting point for the map>      #  The code below only executes if there is a starting point for the map>
Line 1555  sub build_tmp_hashes { Line 1441  sub build_tmp_hashes {
                                  "request.course.uri" => $uri,                                   "request.course.uri" => $uri,
                                  "request.course.tied" => time});                                   "request.course.tied" => time});
         $env{'request.course.id'}=$short;          $env{'request.course.id'}=$short;
         &traceroute('0',$hash{'map_start_'.$uri},'&','','',$short);          &traceroute('0',$hash{'map_start_'.$uri},'&');
         &accinit($uri,$short,$fn);          &accinit($uri,$short,$fn);
         &hiddenurls();          &hiddenurls();
     }      }
Line 1589  sub build_tmp_hashes { Line 1475  sub build_tmp_hashes {
 # ---------------------------------------------------- Store away initial state  # ---------------------------------------------------- Store away initial state
     {      {
         my $cfh;          my $cfh;
         if (open($cfh,">","$fn.state")) {          if (open($cfh,">$fn.state")) {
             print $cfh join("\n",@cond);              print $cfh join("\n",@cond);
             $gotstate = 1;              $gotstate = 1;
         } else {          } else {
Line 1597  sub build_tmp_hashes { Line 1483  sub build_tmp_hashes {
                                      "Could not write statemap $fn for $uri.</font>");                                       "Could not write statemap $fn for $uri.</font>");
         }          }
     }      }
   
     # Was initial access via a deep-link?  
     my ($cdom,$cnum) = split(/_/,$short);  
     if (($cdom ne '') && ($env{'request.deeplink.login'} ne '')) {  
         my $deeplink_symb = &Apache::loncommon::deeplink_login_symb($cnum,$cdom);  
         if ($deeplink_symb) {  
             my ($loginrid,$deeplink_login_pc,$login_hierarchy);  
             my ($map,$resid,$url) = &Apache::lonnet::decode_symb($deeplink_symb);  
             $loginrid = $hash{'map_pc_'.&Apache::lonnet::clutter($map)}.'.'.$resid;  
             if ($deeplink_symb =~ /\.(page|sequence)$/) {  
                 $deeplink_login_pc = $hash{'map_pc_'.&Apache::lonnet::clutter($url)};  
             } else {  
                 $deeplink_login_pc = $hash{'map_pc_'.&Apache::lonnet::clutter($map)};  
             }  
             my $deeplink;  
             if ($hash{'deeplinkonly_'.$loginrid} ne '') {  
                 my @deeplinkinfo = map { &unescape($_); } split(/:/,$hash{'deeplinkonly_'.$loginrid});  
                 unless (@deeplinkinfo < 2) {  
                     $deeplink = $deeplinkinfo[0];  
                 }  
             }  
             if ($deeplink) {  
                 my $disallow;  
                 my ($state,$others,$listed,$scope,$protect) = split(/,/,$deeplink);  
                 if (($protect ne 'none') && ($protect ne '')) {  
                     my ($acctype,$item) = split(/:/,$protect);  
                     if ($acctype =~ /lti(c|d)$/) {  
                         unless ($env{'request.linkprot'} eq $item.$1.':'.$env{'request.deeplink.login'}) {  
                             $disallow = 1;  
                         }  
                     } elsif ($acctype eq 'key') {  
                         unless ($env{'request.linkkey'} eq $item) {  
                             $disallow = 1;  
                         }  
                     }  
                 }  
                 if ($disallow) {  
                     &Apache::lonnet::delenv('request.deeplink.login');  
                     if ($env{'request.deeplink.target'} ne '') {  
                         &Apache::lonnet::delenv('request.deeplink.target');  
                     }  
                 } else {  
                     if ($others eq 'hide') {  
                         my @recfolders;  
                         if ($scope eq 'rec') {  
                             foreach my $key (keys(%hash)) {  
                                 if ($key=~/^map_hierarchy_(\d+)$/) {  
                                     my $mpc = $1;  
                                     my @ids = split(/,/,$hash{$key});  
                                     if (grep(/^$deeplink_login_pc$/,@ids)) {  
                                         my $idx;  
                                         foreach my $mapid (@ids) {  
                                             if ($idx) {  
                                                 push(@recfolders,$mapid);  
                                             } elsif ($mapid == $deeplink_login_pc) {  
                                                 push(@recfolders,$mapid);  
                                                 $idx = $mapid;  
                                             }  
                                         }  
                                         push(@recfolders,$mpc);  
                                     }  
                                 }  
                             }  
                         }  
                         foreach my $key (keys(%hash)) {  
                             if ($key=~/^src_(.+)$/) {  
                                 my $rid = $1;  
                                 next if ($rid eq '0.0');  
                                 next if ($rid eq $loginrid);  
                                 if ($scope ne 'res') {  
                                     my $mapid = (split(/\./,$rid))[0];  
                                     next if ($mapid eq $deeplink_login_pc);  
                                     if ($scope eq 'rec') {  
                                         next if (grep(/^$mapid$/,@recfolders));  
                                     }  
                                 }  
                                 $deeplinkout{$rid} = 1;  
                             }  
                         }  
                     }  
                 }  
                 &deeplinkouts();  
             }  
         }  
     }  
     &mapcrumbs();  
     return $gotstate;      return $gotstate;
 }  }
   
Line 1712  sub evalstate { Line 1512  sub evalstate {
     if (-e $fn) {      if (-e $fn) {
  my @conditions=();   my @conditions=();
  {   {
     open(my $fh,"<",$fn);      open(my $fh,"<$fn");
     @conditions=<$fh>;      @conditions=<$fh>;
             close($fh);              close($fh);
  }     }  
Line 1744  sub evalstate { Line 1544  sub evalstate {
     return $state;      return $state;
 }  }
   
 sub get_mapparam {  
     my ($uname,$udom,$cnum,$cdom,$rid,$mapname,$what,$recurseupref) = @_;  
     unless ($mapname) { return; }  
   
 # ------------------------------------------------- Get coursedata (if present)  
     my $courseopt=&Apache::lonnet::get_courseresdata($cnum,$cdom);  
     if (!ref($courseopt)) {  
         undef($courseopt);  
     }  
   
 # --------------------------------------------------- Get userdata (if present)  
     my $useropt=&Apache::lonnet::get_userresdata($uname,$udom);  
     if (!ref($useropt)) {  
         undef($useropt);  
     }  
   
     my @recurseup;  
     if (ref($recurseupref) eq 'ARRAY') {  
         @recurseup = @{$recurseupref};  
     }  
   
     # Get the section if there is one.  
   
     my $cid = $cdom.'_'.$cnum;  
     my $csec=$env{'request.course.sec'};  
     my $cgroup='';  
     my @cgrps=split(/:/,$env{'request.course.groups'});  
     if (@cgrps > 0) {  
         @cgrps = sort(@cgrps);  
         $cgroup = $cgrps[0];  
     }  
   
     my $rwhat=$what;  
     $what=~s/^parameter\_//;  
     $what=~s/\_/\./;  
   
     # Build the hash keys for the lookup:  
   
     my $mapparm=$mapname.'___(all).'.$what;  
     my $recurseparm=$mapname.'___(rec).'.$what;  
     my $usercourseprefix=$cid;  
   
     my $grplevelm    = "$usercourseprefix.[$cgroup].$mapparm";  
     my $seclevelm    = "$usercourseprefix.[$csec].$mapparm";  
     my $courselevelm = "$usercourseprefix.$mapparm";  
   
     my $grpleveli    = "$usercourseprefix.[$cgroup].$recurseparm";  
     my $secleveli    = "$usercourseprefix.[$csec].$recurseparm";  
     my $courseleveli = "$usercourseprefix.$recurseparm";  
   
     # Check per user  
   
     if ($uname and defined($useropt)) {  
         if (defined($$useropt{$courselevelm})) {  
             return $$useropt{$courselevelm};  
         }  
         if (defined($$useropt{$courseleveli})) {  
             return $$useropt{$courseleveli};  
         }  
         foreach my $item (@recurseup) {  
             my $norecursechk=$usercourseprefix.'.'.$item.'___(all).'.$what;  
             if (defined($$useropt{$norecursechk})) {  
                 if ($what =~ /\.(encrypturl|hiddenresource)$/) {  
                     return $$useropt{$norecursechk};  
                 } else {  
                     last;  
                 }  
             }  
         }  
     }  
   
     # Check course -- group  
   
     if ($cgroup ne '' and defined ($courseopt)) {  
         if (defined($$courseopt{$grplevelm})) {  
             return $$courseopt{$grplevelm};  
         }  
         if (defined($$courseopt{$grpleveli})) {  
             return $$courseopt{$grpleveli};  
         }  
         foreach my $item (@recurseup) {  
             my $norecursechk=$usercourseprefix.'.['.$cgroup.'].'.$item.'___(all).'.$what;  
             if (defined($$courseopt{$norecursechk})) {  
                 if ($what =~ /\.(encrypturl|hiddenresource)$/) {  
                     return $$courseopt{$norecursechk};  
                 } else {  
                     last;  
                 }  
             }  
         }  
     }  
   
     # Check course -- section  
   
     if ($csec ne '' and defined($courseopt)) {  
         if (defined($$courseopt{$seclevelm})) {  
             return $$courseopt{$seclevelm};  
         }  
         if (defined($$courseopt{$secleveli})) {  
             return $$courseopt{$secleveli};  
         }  
         foreach my $item (@recurseup) {  
             my $norecursechk=$usercourseprefix.'.['.$csec.'].'.$item.'___(all).'.$what;  
             if (defined($$courseopt{$norecursechk})) {  
                 if ($what =~ /\.(encrypturl|hiddenresource)$/) {  
                     return $$courseopt{$norecursechk};  
                 } else {  
                     last;  
                 }  
             }  
         }  
     }  
   
     # Check the map parameters themselves:  
   
     if ($hash{'param_'.$rid}) {  
         my @items = split(/\&/,$hash{'param_'.$rid});  
         my $thisparm;  
         foreach my $item (@items) {  
             my ($esctype,$escname,$escvalue) = ($item =~ /^([^:]+):([^=]+)=(.*)$/);  
             my $name = &unescape($escname);  
             my $value = &unescape($escvalue);  
             if ($name eq $what) {  
                 $thisparm = $value;  
                 last;  
             }  
         }  
         if (defined($thisparm)) {  
             return $thisparm;  
         }  
     }  
   
    # Additional course parameters:  
   
     if (defined($courseopt)) {  
         if (defined($$courseopt{$courselevelm})) {  
             return $$courseopt{$courselevelm};  
         }  
   
         if (defined($$courseopt{$courseleveli})) {  
             return $$courseopt{$courseleveli};  
         }  
   
         if (@recurseup) {  
             foreach my $item (@recurseup) {  
                 my $norecursechk=$usercourseprefix.'.'.$item.'___(all).'.$what;  
                 if (defined($$courseopt{$norecursechk})) {  
                     if ($what =~ /\.(encrypturl|hiddenresource)$/) {  
                         return $$courseopt{$norecursechk};  
                     } else {  
                         last;  
                     }  
                 }  
             }  
         }  
     }  
     return undef;  
 }  
   
 #  This block seems to have code to manage/detect doubly defined  #  This block seems to have code to manage/detect doubly defined
 #  aliases in maps.  #  aliases in maps.
   
Removed from v.1.149.2.5.2.2  
changed lines
  Added in v.1.149.4.1

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