Diff for /rat/lonuserstate.pm between versions 1.152 and 1.170

version 1.152, 2017/09/03 18:19:09 version 1.170, 2022/10/05 16:11:25
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 196  sub loadmap { Line 199  sub loadmap {
         $errtext.= '<br />'          $errtext.= '<br />'
                   .&mt('Map not loaded: The file [_1] does not exist.',                    .&mt('Map not loaded: The file [_1] does not exist.',
                        "<tt>$fn</tt>");                         "<tt>$fn</tt>");
           $hash{'map_type_'.$lpc}='none';
           if (&is_advanced($courseid)) {
               $errtext .= &error_detail($parent_rid,$courseid,$ispage,$uri);
           }
  return;   return;
     }      }
   
Line 240  sub loadmap { Line 247  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 249  sub loadmap { Line 258  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 281  sub loadmap { Line 297  sub loadmap {
     # Handle randomization and random selection      # Handle randomization and random selection
   
     if ($randomize) {      if ($randomize) {
         my $advanced;          unless (&is_advanced($courseid)) {
         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 372  sub loadmap { Line 380  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;
   }
   
   sub error_detail {
       my ($parent_rid,$courseid,$ispage,$uri) = @_;
       my $errinfo;
       if ($courseid) {
           my $courseurl = &Apache::lonnet::courseid_to_courseurl($courseid);
           if ($parent_rid =~ /^(\d+)\.(\d+)$/) {
               my ($parent_pc,$parent_id) = ($1,$2);
               my ($parent_type,$published,$uploaded,$canedit,$role,$switchserver,$audom,$auname,
                   $editfile,$filerole,$fileswitch,$audomfile,$aunamefile);
               if (($parent_pc eq '0') && ($hash{'map_id_1'} =~ m{^/res/($match_domain)/($match_username)/.+\.(sequence|page)$})) {
                   ($audomfile,$aunamefile) = ($1,$2);
                   ($editfile,$filerole,$fileswitch) = &canedit_published($audomfile,$aunamefile);
                   if ($fileswitch) {
                       unless ((&Apache::lonnet::will_trust('othcoau',$env{'user.domain'},$audomfile)) &&
                               (&Apache::lonnet::will_trust('coaurem',$audomfile,$env{'user.domain'}))) {
                           undef($editfile);
                       }
                   }
                   $errinfo = &mt('Top level published sequence file is missing.');
               } else {
                   if ($parent_pc eq '1') {
                       if ($hash{'map_id_1'} eq "/uploaded$courseurl/default.sequence") {
                           $uploaded = 1;
                           if (&Apache::lonnet::allowed('mdc',$courseid)) {
                               $canedit = 1;
                           }
                           $errinfo = &mt('Map is referenced in the top level ([_1]Main Content[_2]) folder.',
                                          '<span class="LC_cusr_emph">','</span>');
                       } elsif ($hash{'map_id_1'} =~ m{^/res/($match_domain)/($match_username)/.+\.(sequence|page)$}) {
                           ($audom,$auname) = ($1,$2);
                           ($canedit,$role,$switchserver) = &canedit_published($audom,$auname);
                           $published = 1;
                           $errinfo = &mt('Map is referenced in the top level published sequence file.');
                       }
                   } else {
                       if ($hash{'map_id_'.$parent_pc} =~ m{^\Q/uploaded$courseurl/default_\E\d+\.(sequence|page)$}) {
                           $uploaded = 1;
                           if (&Apache::lonnet::allowed('mdc',$courseid)) {
                               $canedit = 1;
                           }
                       } elsif ($hash{'map_id_'.$parent_pc} =~ m{^/res/($match_domain)/($match_username)/.+\.(sequence|page)$}) {
                           ($audom,$auname) = ($1,$2);
                           ($canedit,$role,$switchserver) = &canedit_published($audom,$auname);
                           $published = 1;
                       }
                       if (exists($hash{'ids_'.$hash{'map_id_'.$parent_pc}})) {
                           $parent_type = $hash{'map_type_'.$parent_pc};
                           if ($published) {
                               $errinfo = &mt("Map is referenced in the published $parent_type file: [_1].",
                                              '<span class="LC_cusr_emph">'.$hash{'map_id_'.$parent_pc}.'</span>');
                           } else {
                               my $title = $hash{'title_'.$hash{'ids_'.$hash{'map_id_'.$parent_pc}}};
                               if ($title ne '') {
                                   my $mapdesc;
                                   if ($parent_type eq 'sequence') {
                                       $mapdesc = 'folder';
                                   } else {
                                       $mapdesc = 'composite page';
                                   }
                                   $errinfo = &mt("Map is referenced in the $mapdesc named: [_1].",
                                                  '<span class="LC_cusr_emph">'.$title.'</span>');
                               }
                               my @containers = split(/,/,$hash{'map_hierarchy_'.$parent_pc});
                               shift(@containers);
                               my $folderpath;
                               foreach my $id (@containers) {
                                   my $name;
                                   if ($id == 1) {
                                       $name = &mt('Main Content');
                                   } elsif ($hash{'title_'.$hash{'ids_'.$hash{'map_id_'.$id}}} ne '') {
                                       $name = $hash{'title_'.$hash{'ids_'.$hash{'map_id_'.$id}}};
                                   }
                                   if ($name ne '') {
                                       $folderpath .= $name.' &raquo; ';
                                   }
                               }
                               if ($title eq '') {
                                   $folderpath =~ s/\Q &raquo; \E$//;
                               } else {
                                   $folderpath .= $title;
                               }
                               if ($folderpath) {
                                   $errinfo .= '<br />'.&mt('Hierarchy is: [_1]',
                                                       '<span class="LC_cusr_emph">'.$folderpath.'</span>');
                               }
                           }
                       }
                   }
                   if ($uri =~ m{^/res/($match_domain)/($match_username)/.+\.(sequence|page)$}) {
                       ($audomfile,$aunamefile) = ($1,$2);
                       ($editfile,$filerole,$fileswitch) = &canedit_published($audomfile,$aunamefile);
                       if ($fileswitch) {
                           unless ((&Apache::lonnet::will_trust('othcoau',$env{'user.domain'},$audomfile)) &&
                                   (&Apache::lonnet::will_trust('coaurem',$audomfile,$env{'user.domain'}))) {
                               undef($editfile);
                           }
                       }
                   }
               }
               if ($errinfo) {
                   $errinfo = '<br />'.$errinfo.'<br />';
               }
               if ($editfile) {
                   if ($errinfo ne '') {
                       $errinfo .= '<br />';
                   }
                   if ($canedit) {
                       $errinfo .= &mt('One way to rectify this problem is to create and publish the missing file');
                   } else {
                       $errinfo .= &mt('To rectify this problem, create and publish the missing file');
                   }
                   my $fileurl = $uri;
                   $fileurl =~s{^/res/}{/priv/};
                   if ($fileswitch) {
                       my $rolename = &Apache::lonnet::plaintext($filerole);
                       my $rolecode;
                       if ($filerole eq 'au') {
                           $rolecode = 'au./'.$audomfile.'/';
                       } else {
                           $rolecode = $filerole.'./'.$audomfile.'/'.$aunamefile;
                       }
                       $errinfo .= '.<br />'.&mt('You will need to [_1]switch server[_2].',
                                                '<a href="/adm/switchserver?otherserver='.$switchserver.'&amp;role='.$rolecode.
                                                '&amp;origurl='.&escape($fileurl).'">','</a>');
                   } else {
                       &js_escape(\$fileurl);
                       $errinfo .= ':&nbsp;<a href="javascript:go('."'$fileurl'".');">'.&mt('Create the missing file').'</a>';
                   }
               }
               if ($canedit) {
                   if ($errinfo ne '') {
                       $errinfo .= '<br />';
                   }
                   if ($published) {
                       my $rolename = &Apache::lonnet::plaintext($role);
                       my $rolecode;
                       if ($role eq 'au') {
                           $rolecode = 'au./'.$audom.'/';
                       } else {
                           $rolecode = $role.'./'.$audom.'/'.$auname;
                       }
                       if ($editfile) {
                           $errinfo .= &mt('Another way is to edit the parent map to remove the reference to the missing file');
                       } else {
                           $errinfo .= &mt('To rectify this problem edit the parent map to remove the reference to the missing file');
                       }
                       my $mapurl = $hash{'map_id_'.$parent_pc};
                       $mapurl =~s{^/res/}{/priv/};
                       if ($switchserver) {
                           $errinfo .= '.<br />';
                           if ((&Apache::lonnet::will_trust('othcoau',$env{'user.domain'},$audom)) &&
                               (&Apache::lonnet::will_trust('coaurem',$audom,$env{'user.domain'}))) {
                               $errinfo .= &mt('You will need to [_1]switch server[_2].',
                                               '<a href="/adm/switchserver?otherserver='.$switchserver.'&amp;role='.$rolecode.
                                               '&amp;origurl='.&escape($mapurl).'">','</a>');
                           } else {
                               $errinfo .= &mt('Session switch required but prohibited.');
                           }
                       } else {
                           &js_escape(\$mapurl);
                           $errinfo .= ':&nbsp;<a href="javascript:go('."'$mapurl'".');">'.&mt('Edit the map').'</a>';
                       }
                   } elsif ($uploaded && $courseid) {
                       my ($dest,$linktext);
                       my $crstype = &Apache::loncommon::course_type($courseid);
                       if ($parent_pc eq '1') {
                           $dest = '/adm/coursedocs?folderpath='.&escape('default&Main%20Content:::::');
                           $linktext = &mt('Edit Folder');
                       } elsif ($hash{'ids_'.$hash{'map_id_'.$parent_pc}} =~ /^(\d+)\.(\d+)$/) {
                           my ($editmap,$editidx) = ($1,$2);
                           my $symb = &Apache::lonnet::encode_symb($hash{'map_id_'.$editmap},
                                                                        $editidx,$hash{'map_id_'.$parent_pc});
                           $dest = '/adm/coursedocs?command=directnav&amp;symb='.&escape($symb);
                           if ($parent_type eq 'sequence') {
                               $linktext = &mt('Edit Folder');
                           } else {
                               $linktext = &mt('Edit Composite Page');
                           }
                       } else {
                           $dest = '/adm/coursedocs?folderpath='.&escape('default&Main%20Content:::::');
                           $linktext = &mt("Edit $crstype");
                       }
                       if ($editfile) {
                           $errinfo .= &mt("Another way is to use the $crstype Editor to delete the reference to the missing file");
                       } else {
                           $errinfo .= &mt("To rectify this problem use the $crstype Editor to delete the reference to the missing file");
                       }
                       $errinfo .= ':&nbsp;<a href="javascript:go('."'$dest'".');">'.$linktext.'</a>';
                   }
                   $errinfo .= '<br />';
               }
           }
       }
       return $errinfo;
   }
   
   sub canedit_published {
       my ($audom,$auname) = @_;
       my ($canedit,$role,$switchserver);
       my $now = time;
       if (($auname eq $env{'user.name'}) && ($audom eq $env{'user.domain'})) {
           if (exists($env{"user.role.au./$audom/"})) {
               my ($start,$end) = split(/\./,$env{"user.role.au./$audom/"});
               unless (($end && $end < $now) || ($start && $start > $now)) {
                   $canedit = 1;
                   $role = 'au';
               }
           }
       }
       unless ($canedit) {
           foreach my $possrole ('ca','aa') {
               if (exists($env{"user.role.$possrole./$audom/$auname"})) {
                   my ($end,$start) = split(/\./,$env{"user.role.$possrole./$audom/$auname"});
                   unless (($end && $end < time) || ($start && $start > time)) {
                       $canedit = 1;
                       $role = $possrole;
                       last;
                   }
               }
           }
       }
       if ($canedit) {
           my $auhome = &Apache::lonnet::homeserver($auname,$audom);
           my @ids=&Apache::lonnet::current_machine_ids();
           if (($auhome ne 'no_host') && (!grep(/^\Q$auhome\E$/,@ids))) {
               $switchserver = $auhome;
           }
       }
       return ($canedit,$role,$switchserver);
   }
   
 # -------------------------------------------------------------------- Resource  # -------------------------------------------------------------------- Resource
 #  #
Line 458  sub parse_resource { Line 709  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?).
   
     unless ($ispage) {      if ($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 550  sub parse_resource { Line 805  sub parse_resource {
     if (($turi=~/\.sequence$/) ||      if (($turi=~/\.sequence$/) ||
  ($turi=~/\.page$/)) {   ($turi=~/\.page$/)) {
  $hash{'is_map_'.$rid}=1;   $hash{'is_map_'.$rid}=1;
  &loadmap($turi,$rid,$courseid);   if ((!$hiddenurl{$rid}) || (&is_advanced($courseid))) {
       &loadmap($turi,$rid,$courseid);
    }
     }       } 
     return $token->[2]->{'id'};      return $token->[2]->{'id'};
 }  }
Line 883  sub simplify { Line 1140  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)=@_;      my ($sofar,$rid,$beenhere,$encflag,$hdnflag,$cid)=@_;
     my $newsofar=$sofar=simplify($sofar);      my $newsofar=$sofar=simplify($sofar);
   
     unless ($beenhere=~/\&\Q$rid\E\&/) {      unless ($beenhere=~/\&\Q$rid\E\&/) {
Line 907  sub traceroute { Line 1164  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 928  sub traceroute { Line 1209  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 955  sub traceroute { Line 1237  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);        $encflag,$hdnflag,$cid);
     }      }
  }   }
     }      }
Line 1114  sub hiddenurls { Line 1396  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 1126  sub hiddenurls { Line 1416  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 1136  sub hiddenurls { Line 1434  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=shift;      my ($short,$critmsg_check) = @_;
     $short=~s/^\///;      $short=~s/^\///;
   
     # TODO:  Hidden dependency on current user:      # TODO:  Hidden dependency on current user:
Line 1156  sub readmap { Line 1497  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 1174  sub readmap { Line 1515  sub readmap {
         &unlink_tmpfiles($fn);          &unlink_tmpfiles($fn);
     }      }
     undef %randompick;      undef %randompick;
       undef %randompickseed;
       undef %randomorder;
       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 1317  sub readmap { Line 1664  sub readmap {
             $lock=1;              $lock=1;
         }          }
         undef %randompick;          undef %randompick;
           undef %randompickseed;
           undef %randomorder;
           undef %randomizationcode;
         undef %hiddenurl;          undef %hiddenurl;
         undef %encurl;          undef %encurl;
           undef %deeplinkout;
           undef %rescount;
           undef %mapcount;
         $errtext='';          $errtext='';
         $retfrid='';          $retfrid='';
  #   #
Line 1366  sub readmap { Line 1719  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).
   #
   
     my @what=&Apache::lonnet::dump('critical',$env{'user.domain'},      if ($critmsg_check) {
    $env{'user.name'});          my ($redirect,$url) = &Apache::loncommon::critical_redirect();
     if ($what[0]) {          if ($redirect) {
  if (($what[0] ne 'con_lost') && ($what[0]!~/^error\:/)) {              $retfurl = $url;
     $retfurl='/adm/email?critical=display';  
         }          }
     }      }
     return ($retfurl,$errtext);      return ($retfurl,$errtext);
Line 1421  sub build_tmp_hashes { Line 1778  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 1434  sub build_tmp_hashes { Line 1790  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},'&');          &traceroute('0',$hash{'map_start_'.$uri},'&','','',$short);
         &accinit($uri,$short,$fn);          &accinit($uri,$short,$fn);
         &hiddenurls();          &hiddenurls();
     }      }
Line 1468  sub build_tmp_hashes { Line 1824  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 1476  sub build_tmp_hashes { Line 1832  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 1505  sub evalstate { Line 1947  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 1537  sub evalstate { Line 1979  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;
                   }
               }
               my $recursechk=$usercourseprefix.'.'.$item.'___(rec).'.$what;
               if (defined($$useropt{$recursechk})) {
                   return $$useropt{$recursechk};
               }
           }
       }
   
       # 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;
                   }
               }
               my $recursechk=$usercourseprefix.'.['.$cgroup.'].'.$item.'___(rec).'.$what;
               if (defined($$courseopt{$recursechk})) {
                   return $$courseopt{$recursechk};
               }
           }
       }
   
       # 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;
                   }
               }
               my $recursechk=$usercourseprefix.'.['.$csec.'].'.$item.'___(rec).'.$what;
               if (defined($$courseopt{$recursechk})) {
                   return $$courseopt{$recursechk};
               }
           }
       }
   
       # 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;
                       }
                   }
                   my $recursechk=$usercourseprefix.'.'.$item.'___(rec).'.$what;
                   if (defined($$courseopt{$recursechk})) {
                       return $$courseopt{$recursechk};
                   }
               }
           }
       }
       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.152  
changed lines
  Added in v.1.170


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