[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.3 and 1.149.2.6

version 1.149.2.5.2.3, 2022/10/05 22:54:00 version 1.149.2.6, 2024/07/03 02:16:44
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 %rescount; # count of unhidden items in each map
 my %mapcount; # count of unhidden maps in each map  my %mapcount; # count of unhidden maps in each map
   
Line 711  sub parse_resource { Line 710  sub parse_resource {
     } elsif ($turi!~/\.(sequence|page)$/) {      } elsif ($turi!~/\.(sequence|page)$/) {
  $turi='/adm/coursedocs/showdoc'.$turi;   $turi='/adm/coursedocs/showdoc'.$turi;
     }      }
         } elsif ($turi=~ m{^/adm/$match_domain/$match_courseid/\d+/ext\.tool$}) {  
             $turi='/adm/wrapper'.$turi;  
  } elsif ($turi=~/\S/) { # normal non-empty internal resource   } elsif ($turi=~/\S/) { # normal non-empty internal resource
     my $mapdir=$uri;      my $mapdir=$uri;
     $mapdir=~s/[^\/]+$//;      $mapdir=~s/[^\/]+$//;
Line 1123  sub simplify { Line 1120  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 1147  sub traceroute { Line 1144  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 1192  sub traceroute { Line 1165  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 1220  sub traceroute { Line 1192  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 1417  sub hiddenurls { Line 1389  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  # -------------------------------------- populate big hash with map breadcrumbs
   
 # Create map_breadcrumbs_$pc from map_hierarchy_$pc by omitting intermediate  # Create map_breadcrumbs_$pc from map_hierarchy_$pc by omitting intermediate
 # maps not shown in Course Contents table.  # maps not shown in Course Contents table.
   
 sub mapcrumbs {  sub mapcrumbs {
     my ($cid) = @_;  
     foreach my $key (keys(%rescount)) {      foreach my $key (keys(%rescount)) {
         if ($hash{'map_hierarchy_'.$key}) {          if ($hash{'map_hierarchy_'.$key}) {
             my $skipnext = 0;              my $skipnext = 0;
             foreach my $id (split(/,/,$hash{'map_hierarchy_'.$key}),$key) {              foreach my $id (split(/,/,$hash{'map_hierarchy_'.$key}),$key) {
                 my $rid = $hash{'ids_'.$hash{'map_id_'.$id}};                  unless ($skipnext) {
                 unless (($skipnext) || (!&is_advanced($cid) && $hash{'deeplinkout_'.$rid})) {  
                     $hash{'map_breadcrumbs_'.$key} .= "$id,";                      $hash{'map_breadcrumbs_'.$key} .= "$id,";
                 }                  }
                 unless (($id == 0) || ($id == 1)) {                  unless (($id == 0) || ($id == 1)) {
Line 1503  sub readmap { Line 1458  sub readmap {
     undef %randomizationcode;      undef %randomizationcode;
     undef %hiddenurl;      undef %hiddenurl;
     undef %encurl;      undef %encurl;
     undef %deeplinkout;  
     undef %rescount;      undef %rescount;
     undef %mapcount;      undef %mapcount;
     $retfrid='';      $retfrid='';
Line 1652  sub readmap { Line 1606  sub readmap {
         undef %randomizationcode;          undef %randomizationcode;
         undef %hiddenurl;          undef %hiddenurl;
         undef %encurl;          undef %encurl;
         undef %deeplinkout;  
         undef %rescount;          undef %rescount;
         undef %mapcount;          undef %mapcount;
         $errtext='';          $errtext='';
Line 1761  sub build_tmp_hashes { Line 1714  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 1773  sub build_tmp_hashes { Line 1727  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();
           &mapcrumbs();
     }      }
     $errtext .= &get_mapalias_errors();      $errtext .= &get_mapalias_errors();
 # ------------------------------------------------------- Put versions into src  # ------------------------------------------------------- Put versions into src
Line 1815  sub build_tmp_hashes { Line 1770  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 1962  sub evalstate { Line 1831  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.3  
changed lines
  Added in v.1.149.2.6

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