Diff for /loncom/interface/lonnavmaps.pm between versions 1.509.2.5.4.3 and 1.537

version 1.509.2.5.4.3, 2018/04/29 16:16:05 version 1.537, 2017/12/18 23:13:53
Line 2 Line 2
 # Navigate Maps Handler  # Navigate Maps Handler
 #  #
 # $Id$  # $Id$
   
 #  #
 # Copyright Michigan State University Board of Trustees  # Copyright Michigan State University Board of Trustees
 #  #
Line 52  described at http://www.lon-capa.org. Line 51  described at http://www.lon-capa.org.
 X<lonnavmaps, overview> When a user enters a course, LON-CAPA examines the  X<lonnavmaps, overview> When a user enters a course, LON-CAPA examines the
 course structure and caches it in what is often referred to as the  course structure and caches it in what is often referred to as the
 "big hash" X<big hash>. You can see it if you are logged into  "big hash" X<big hash>. You can see it if you are logged into
 LON-CAPA, in a course, by going to /adm/test. (You may need to  LON-CAPA, in a course, by going to /adm/test. The content of 
 tweak the /home/httpd/lonTabs/htpasswd file to view it.) The  the hash will be under the heading "Big Hash".
 content of the hash will be under the heading "Big Hash".  
   Access to /adm/test is controlled by a domain configuration, 
   which a Domain Coordinator will set for a server's default domain
   via: Main Menu > Set domain configuration > Display (Access to 
   server status pages checked), and entering a username:domain
   or IP address in the "Show user environment" row. Users with
   an unexpired domain coordinator role in the server's domain
   automatically receive access to /adm/test.
   
 Big Hash contains, among other things, how resources are related  Big Hash contains, among other things, how resources are related
 to each other (next/previous), what resources are maps, which   to each other (next/previous), what resources are maps, which 
Line 78  Apache::lonnavmaps also provides fairly Line 84  Apache::lonnavmaps also provides fairly
 rendering navmaps, and last but not least, provides the navmaps  rendering navmaps, and last but not least, provides the navmaps
 view for when the user clicks the NAV button.  view for when the user clicks the NAV button.
   
 B<Note>: Apache::lonnavmaps I<only> works for the "currently  B<Note>: Apache::lonnavmaps by default will show information 
 logged in user"; if you want things like "due dates for another  for the "currently logged in user".  However, if information
 student" lonnavmaps can not directly retrieve information like  about resources is needed for a different user, e.g., a bubblesheet
 that. You need the EXT function. This module can still help,  exam which uses randomorder, or randompick needs to be printed or 
 because many things, such as the course structure, are constant  graded for named user(s) or specific CODEs, then the username,
   domain, or CODE can be passed as arguments when creating a new 
   navmap object.
   
   Note if you want things like "due dates for another student,
   you would use the EXT function instead of lonnavmaps.
   That said, the lonnavmaps module can still help, because many
   things, such as the course structure, are usually constant
 between users, and Apache::lonnavmaps can help by providing  between users, and Apache::lonnavmaps can help by providing
 symbs for the EXT call.  symbs for the EXT call.
   
Line 92  all, then documents the Apache::lonnavma Line 105  all, then documents the Apache::lonnavma
 is the key to accessing the Big Hash information, covers the use  is the key to accessing the Big Hash information, covers the use
 of the Iterator (which provides the logic for traversing the   of the Iterator (which provides the logic for traversing the 
 somewhat-complicated Big Hash data structure), documents the  somewhat-complicated Big Hash data structure), documents the
 Apache::lonnavmaps::Resource objects that are returned by   Apache::lonnavmaps::Resource objects that are returned singularly
   by: getBySymb(), getById(), getByMapPc(), and getResourceByUrl()
   (can also be as an array), or in an array by retrieveResources().
   
 =head1 Subroutine: render  =head1 Subroutine: render
   
Line 643  sub getDescription { Line 658  sub getDescription {
             } elsif ($slot_status == $res->RESERVABLE) {              } elsif ($slot_status == $res->RESERVABLE) {
                 $slotmsg = &mt('Reservable, reservations close [_1]',                  $slotmsg = &mt('Reservable, reservations close [_1]',
                            timeToHumanString($slot_time,'end'));                             timeToHumanString($slot_time,'end'));
             } elsif ($slot_status == $res->NEEDS_CHECKIN) {  
                 $slotmsg = &mt('Reserved, check-in needed - ends [_1]',  
                            timeToHumanString($slot_time,'end'));  
             } elsif ($slot_status == $res->RESERVABLE_LATER) {              } elsif ($slot_status == $res->RESERVABLE_LATER) {
                 $slotmsg = &mt('Reservable, reservations open [_1]',                  $slotmsg = &mt('Reservable, reservations open [_1]',
                            timeToHumanString($slot_time,'start'));                             timeToHumanString($slot_time,'start'));
Line 1003  sub render_resource { Line 1015  sub render_resource {
             }              }
         }          }
         if (((&Apache::lonnet::allowed('mdc',$env{'request.course.id'})) ||          if (((&Apache::lonnet::allowed('mdc',$env{'request.course.id'})) ||
              (&Apache::lonnet::allowed('cev',$env{'request.course.id'}))) &&                (&Apache::lonnet::allowed('cev',$env{'request.course.id'}))) &&
             ($resource->symb=~/\_\_\_[^\_]+\_\_\_uploaded/)) {              ($resource->symb=~/\_\_\_[^\_]+\_\_\_uploaded/)) {
             if (!$params->{'map_no_edit_link'}) {              if (!$params->{'map_no_edit_link'}) {
                 my $icon = &Apache::loncommon::lonhttpdurl('/res/adm/pages').'/editmap.png';                  my $icon = &Apache::loncommon::lonhttpdurl('/res/adm/pages').'/editmap.png';
Line 1134  sub render_quick_status { Line 1146  sub render_quick_status {
     my $linkclose = "</a>";      my $linkclose = "</a>";
   
  $result .= '<td class="LC_middle">';   $result .= '<td class="LC_middle">';
     if ($resource->is_problem() &&      if ($resource->is_gradable() &&
         !$firstDisplayed) {          !$firstDisplayed) {
         my $icon = $statusIconMap{$resource->simpleStatus($part)};          my $icon = $statusIconMap{$resource->simpleStatus($part)};
         my $alt = $iconAltTags{$icon};          my $alt = $iconAltTags{$icon};
Line 1159  sub render_long_status { Line 1171  sub render_long_status {
                                   
     my $color;      my $color;
     my $info = '';      my $info = '';
     if ($resource->is_problem() || $resource->is_practice()) {      if ($resource->is_gradable() || $resource->is_practice()) {
         $color = $colormap{$resource->status};          $color = $colormap{$resource->status};
   
         if (dueInLessThan24Hours($resource, $part)) {          if (dueInLessThan24Hours($resource, $part)) {
Line 1173  sub render_long_status { Line 1185  sub render_long_status {
             }              }
          }           }
     }      }
       
     if ($resource->kind() eq "res" &&      if (($resource->kind() eq "res") &&
         $resource->is_raw_problem() &&          ($resource->is_raw_problem() || $resource->is_gradable()) &&
         !$firstDisplayed) {          !$firstDisplayed) {
         if ($color) {$result .= '<span style="color:'.$color.'"'.$info.'><b>'; }          if ($color) {$result .= '<span style="color:'.$color.'"'.$info.'><b>'; }
         $result .= getDescription($resource, $part);          $result .= getDescription($resource, $part);
Line 1222  my @statuses = ($resObj->CORRECT, $resOb Line 1234  my @statuses = ($resObj->CORRECT, $resOb
   
 sub render_parts_summary_status {  sub render_parts_summary_status {
     my ($resource, $part, $params) = @_;      my ($resource, $part, $params) = @_;
     if (!$resource->is_problem() && !$resource->contains_problem) { return '<td></td>'; }      if (!$resource->is_gradable() && !$resource->contains_problem) { return '<td></td>'; }
     if ($params->{showParts}) {       if ($params->{showParts}) { 
  return '<td></td>';   return '<td></td>';
     }      }
Line 1600  END Line 1612  END
     # We also do this even if $args->{'suppressEmptySequences'}      # We also do this even if $args->{'suppressEmptySequences'}
     # is not true, so we can hide empty sequences for which the      # is not true, so we can hide empty sequences for which the
     # hiddenresource parameter is set to yes (at map level), or      # hiddenresource parameter is set to yes (at map level), or
     # mark as hidden for users who have $userCanSeeHidden.      # mark as hidden for users who have $userCanSeeHidden.  
     # Use DFS for speed, since structure actually doesn't matter,      # Use DFS for speed, since structure actually doesn't matter,
     # except what map has what resources.      # except what map has what resources.
   
Line 1608  END Line 1620  END
                                                      $it->{FIRST_RESOURCE},                                                       $it->{FIRST_RESOURCE},
                                                      $it->{FINISH_RESOURCE},                                                       $it->{FINISH_RESOURCE},
                                                      {}, undef, 1);                                                       {}, undef, 1);
   
     my $depth = 0;      my $depth = 0;
     $dfsit->next();      $dfsit->next();
     my $curRes = $dfsit->next();      my $curRes = $dfsit->next();
Line 1616  END Line 1627  END
         if ($curRes == $dfsit->BEGIN_MAP()) { $depth++; }          if ($curRes == $dfsit->BEGIN_MAP()) { $depth++; }
         if ($curRes == $dfsit->END_MAP()) { $depth--; }          if ($curRes == $dfsit->END_MAP()) { $depth--; }
   
         if (ref($curRes)) {          if (ref($curRes)) { 
             # Parallel pre-processing: Do sequences have non-filtered-out children?              # Parallel pre-processing: Do sequences have non-filtered-out children?
             if ($curRes->is_map()) {              if ($curRes->is_map()) {
                 $curRes->{DATA}->{HAS_VISIBLE_CHILDREN} = 0;                  $curRes->{DATA}->{HAS_VISIBLE_CHILDREN} = 0;
Line 1693  END Line 1704  END
  undef($args->{'sort'});   undef($args->{'sort'});
     }      }
   
       # Determine if page will be served with https in case
       # it contains a syllabus which uses an external URL
       # which points at an http site.
   
       my ($is_ssl,$cdom,$cnum,$hostname);
       if ($ENV{'SERVER_PORT'} == 443) {
           $is_ssl = 1;
           if ($r) {
               $hostname = $r->hostname();
           } else {
               $hostname = $ENV{'SERVER_NAME'};
           }
       }
       if ($env{'request.course.id'}) {
           $cdom = $env{'course.'.$env{'request.course.id'}.'.domain'};
           $cnum = $env{'course.'.$env{'request.course.id'}.'.num'};
       }
   
     while (1) {      while (1) {
  if ($args->{'sort'}) {   if ($args->{'sort'}) {
Line 1734  END Line 1762  END
                 next;                  next;
             } else {              } else {
                 my $mapname = &Apache::lonnet::declutter($curRes->src());                  my $mapname = &Apache::lonnet::declutter($curRes->src());
                 $mapname = &Apache::lonnet::deversion($mapname);                  $mapname = &Apache::lonnet::deversion($mapname); 
                 if (lc($navmap->get_mapparam(undef,$mapname,"0.hiddenresource")) eq 'yes') {                  if (lc($navmap->get_mapparam(undef,$mapname,"0.hiddenresource")) eq 'yes') {
                     if ($userCanSeeHidden) {                      if ($userCanSeeHidden) {
                         $args->{'mapHidden'} = 1;                          $args->{'mapHidden'} = 1;
Line 1826  END Line 1854  END
  $stack=$it->getStack();   $stack=$it->getStack();
     }      }
     ($src,$symb,$anchor)=getLinkForResource($stack);      ($src,$symb,$anchor)=getLinkForResource($stack);
             my $srcHasQuestion = $src =~ /\?/;               my $srcHasQuestion = $src =~ /\?/;
               if ($env{'request.course.id'}) {
                   if (($is_ssl) && ($src =~ m{^\Q/public/$cdom/$cnum/syllabus\E($|\?)}) &&
                       ($env{'course.'.$env{'request.course.id'}.'.externalsyllabus'} =~ m{^http://})) {
                       if ($hostname ne '') {
                           $src = 'http://'.$hostname.$src;
                       }
                       $src .= ($srcHasQuestion? '&amp;' : '?') . 'usehttp=1';
                       $srcHasQuestion = 1;
                   } elsif (($is_ssl) && ($src =~ m{^\Q/adm/wrapper/ext/\E(?!https:)})) {
                       if ($hostname ne '') {
                           $src = 'http://'.$hostname.$src;
                       }
                   }
               }
     if (defined($anchor)) { $anchor='#'.$anchor; }      if (defined($anchor)) { $anchor='#'.$anchor; }
             if (($args->{'caller'} eq 'sequence') && ($curRes->is_map())) {      if (($args->{'caller'} eq 'sequence') && ($curRes->is_map())) {
                 $args->{"resourceLink"} = $src.($srcHasQuestion?'&amp;':'?') .'navmap=1';          $args->{"resourceLink"} = $src.($srcHasQuestion?'&amp;':'?') .'navmap=1';
             } else {      } else {
                 $args->{"resourceLink"} = $src.          $args->{"resourceLink"} = $src.
     ($srcHasQuestion?'&amp;':'?') .      ($srcHasQuestion?'&amp;':'?') .
     'symb=' . &escape($symb).$anchor;      'symb=' . &escape($symb).$anchor;
             }      }
  }   }
         # Now, we've decided what parts to show. Loop through them and          # Now, we've decided what parts to show. Loop through them and
         # show them.          # show them.
Line 2155  sub change_user { Line 2197  sub change_user {
   
   
   
     # Now clear the parm cache and reconstruct the parm hash fromt he big_hash      # Now clear the parm cache and reconstruct the parm hash from the big_hash
     # param.xxxx keys.      # param.xxxx keys.
   
     $self->{PARM_CACHE} = {};      $self->{PARM_CACHE} = {};
Line 2620  sub parmval { Line 2662  sub parmval {
             return $self->{PARM_CACHE}->{$hashkey};              return $self->{PARM_CACHE}->{$hashkey};
         }          }
     }      }
   
     my $result = $self->parmval_real($what, $symb, $recurse);      my $result = $self->parmval_real($what, $symb, $recurse);
     $self->{PARM_CACHE}->{$hashkey} = $result;      $self->{PARM_CACHE}->{$hashkey} = $result;
     if (wantarray) {      if (wantarray) {
Line 2653  sub parmval_real { Line 2696  sub parmval_real {
   
     my ($mapname,$id,$fn)=&Apache::lonnet::decode_symb($symb);      my ($mapname,$id,$fn)=&Apache::lonnet::decode_symb($symb);
     $mapname = &Apache::lonnet::deversion($mapname);      $mapname = &Apache::lonnet::deversion($mapname);
       my $toolsymb = '';
       if ($fn =~ /ext\.tool$/) {
           $toolsymb = $symb;
       }
       my ($recursed,@recurseup); 
       
 # ----------------------------------------------------- Cascading lookup scheme  # ----------------------------------------------------- Cascading lookup scheme
     my $rwhat=$what;      my $rwhat=$what;
     $what=~s/^parameter\_//;      $what=~s/^parameter\_//;
     $what=~s/\_/\./;      $what=~s/\_/\./;
   
     my $symbparm=$symb.'.'.$what;      my $symbparm=$symb.'.'.$what;
       my $recurseparm=$mapname.'___(rec).'.$what;
     my $mapparm=$mapname.'___(all).'.$what;      my $mapparm=$mapname.'___(all).'.$what;
     my $usercourseprefix=$cid;      my $usercourseprefix=$cid;
       
   
   
     my $grplevel=$usercourseprefix.'.['.$cgroup.'].'.$what;      my $grplevel=$usercourseprefix.'.['.$cgroup.'].'.$what;
     my $grplevelr=$usercourseprefix.'.['.$cgroup.'].'.$symbparm;      my $grplevelr=$usercourseprefix.'.['.$cgroup.'].'.$symbparm;
       my $grpleveli=$usercourseprefix.'.['.$cgroup.'].'.$recurseparm;
     my $grplevelm=$usercourseprefix.'.['.$cgroup.'].'.$mapparm;      my $grplevelm=$usercourseprefix.'.['.$cgroup.'].'.$mapparm;
   
   
     my $seclevel= $usercourseprefix.'.['.$csec.'].'.$what;      my $seclevel= $usercourseprefix.'.['.$csec.'].'.$what;
     my $seclevelr=$usercourseprefix.'.['.$csec.'].'.$symbparm;      my $seclevelr=$usercourseprefix.'.['.$csec.'].'.$symbparm;
       my $secleveli=$usercourseprefix.'.['.$csec.'].'.$recurseparm;
     my $seclevelm=$usercourseprefix.'.['.$csec.'].'.$mapparm;      my $seclevelm=$usercourseprefix.'.['.$csec.'].'.$mapparm;
   
   
     my $courselevel= $usercourseprefix.'.'.$what;      my $courselevel= $usercourseprefix.'.'.$what;
     my $courselevelr=$usercourseprefix.'.'.$symbparm;      my $courselevelr=$usercourseprefix.'.'.$symbparm;
       my $courseleveli=$usercourseprefix.'.'.$recurseparm;
     my $courselevelm=$usercourseprefix.'.'.$mapparm;      my $courselevelm=$usercourseprefix.'.'.$mapparm;
   
   
Line 2687  sub parmval_real { Line 2740  sub parmval_real {
     if ($uname and defined($useropt)) {      if ($uname and defined($useropt)) {
         if (defined($$useropt{$courselevelr})) { return [$$useropt{$courselevelr},'resource']; }          if (defined($$useropt{$courselevelr})) { return [$$useropt{$courselevelr},'resource']; }
         if (defined($$useropt{$courselevelm})) { return [$$useropt{$courselevelm},'map']; }          if (defined($$useropt{$courselevelm})) { return [$$useropt{$courselevelm},'map']; }
           if (defined($$useropt{$courseleveli})) { return [$$useropt{$courseleveli},'map']; }
           unless ($recursed) {
               @recurseup = $self->recurseup_maps($mapname);
               $recursed = 1;
           }
           foreach my $item (@recurseup) {
               my $norecursechk=$usercourseprefix.'.'.$item.'___(all).'.$what;
               if (defined($$useropt{$norecursechk})) {
                   if ($what =~ /\.(encrypturl|hiddenresource)$/) {
                       return [$$useropt{$norecursechk},'map'];
                   } else {
                       last;
                   }
               }
               my $recursechk=$usercourseprefix.'.'.$item.'___(rec).'.$what;
               if (defined($$useropt{$recursechk})) { return [$$useropt{$recursechk},'map']; } 
           }
         if (defined($$useropt{$courselevel})) { return [$$useropt{$courselevel},'course']; }          if (defined($$useropt{$courselevel})) { return [$$useropt{$courselevel},'course']; }
     }      }
   
Line 2694  sub parmval_real { Line 2764  sub parmval_real {
     if ($cgroup ne '' and defined($courseopt)) {      if ($cgroup ne '' and defined($courseopt)) {
         if (defined($$courseopt{$grplevelr})) { return [$$courseopt{$grplevelr},'resource']; }          if (defined($$courseopt{$grplevelr})) { return [$$courseopt{$grplevelr},'resource']; }
         if (defined($$courseopt{$grplevelm})) { return [$$courseopt{$grplevelm},'map']; }          if (defined($$courseopt{$grplevelm})) { return [$$courseopt{$grplevelm},'map']; }
           if (defined($$courseopt{$grpleveli})) { return [$$courseopt{$grpleveli},'map']; } 
           unless ($recursed) {
               @recurseup = $self->recurseup_maps($mapname);
               $recursed = 1;
           }
           foreach my $item (@recurseup) {
               my $norecursechk=$usercourseprefix.'.['.$cgroup.'].'.$item.'___(all).'.$what;
               if (defined($$courseopt{$norecursechk})) {
                   if ($what =~ /\.(encrypturl|hiddenresource)$/) {
                       return [$$courseopt{$norecursechk},'map'];
                   } else {
                      last;
                   }
               }
               my $recursechk=$usercourseprefix.'.['.$cgroup.'].'.$item.'___(rec).'.$what;
               if (defined($$courseopt{$recursechk})) { return [$$courseopt{$recursechk},'map']; }      
           }
         if (defined($$courseopt{$grplevel})) { return [$$courseopt{$grplevel},'course']; }          if (defined($$courseopt{$grplevel})) { return [$$courseopt{$grplevel},'course']; }
     }      }
   
     if ($csec and defined($courseopt)) {      if ($csec ne '' and defined($courseopt)) {
         if (defined($$courseopt{$seclevelr})) { return [$$courseopt{$seclevelr},'resource']; }          if (defined($$courseopt{$seclevelr})) { return [$$courseopt{$seclevelr},'resource']; }
         if (defined($$courseopt{$seclevelm})) { return [$$courseopt{$seclevelm},'map']; }          if (defined($$courseopt{$seclevelm})) { return [$$courseopt{$seclevelm},'map']; }
           if (defined($$courseopt{$secleveli})) { return [$$courseopt{$secleveli},'map']; } 
           unless ($recursed) {
               @recurseup = $self->recurseup_maps($mapname);
               $recursed = 1;
           }
           foreach my $item (@recurseup) {
               my $norecursechk=$usercourseprefix.'.['.$csec.'].'.$item.'___(all).'.$what;
               if (defined($$courseopt{$norecursechk})) {
                   if ($what =~ /\.(encrypturl|hiddenresource)$/) {
                       return [$$courseopt{$norecursechk},'map'];
                   } else {
                       last;
                   }
               }
               my $recursechk=$usercourseprefix.'.['.$csec.'].'.$item.'___(rec).'.$what;
               if (defined($$courseopt{$recursechk})) { return [$$courseopt{$recursechk},'map']; }
           }
         if (defined($$courseopt{$seclevel})) { return [$$courseopt{$seclevel},'course']; }          if (defined($$courseopt{$seclevel})) { return [$$courseopt{$seclevel},'course']; }
     }      }
   
Line 2716  sub parmval_real { Line 2820  sub parmval_real {
   
     my $meta_rwhat=$rwhat;      my $meta_rwhat=$rwhat;
     $meta_rwhat=~s/\./_/g;      $meta_rwhat=~s/\./_/g;
     my $default=&Apache::lonnet::metadata($fn,$meta_rwhat);      my $default=&Apache::lonnet::metadata($fn,$meta_rwhat,$toolsymb);
     if (defined($default)) { return [$default,'resource']}      if (defined($default)) { return [$default,'resource']}
     $default=&Apache::lonnet::metadata($fn,'parameter_'.$meta_rwhat);      $default=&Apache::lonnet::metadata($fn,'parameter_'.$meta_rwhat,$toolsymb);
     if (defined($default)) { return [$default,'resource']}      if (defined($default)) { return [$default,'resource']}
 # --------------------------------------------------- fifth, check more course  # --------------------------------------------------- fifth, check more course
     if (defined($courseopt)) {      if (defined($courseopt)) {
         if (defined($$courseopt{$courselevelm})) { return [$$courseopt{$courselevelm},'map']; }          if (defined($$courseopt{$courselevelm})) { return [$$courseopt{$courselevelm},'map']; }
           if (defined($$courseopt{$courseleveli})) { return [$$courseopt{$courseleveli},'map']; }
           unless ($recursed) {
               @recurseup = $self->recurseup_maps($mapname);
               $recursed = 1;
           }
           foreach my $item (@recurseup) {
               my $norecursechk=$usercourseprefix.'.'.$item.'___(all).'.$what;
               if (defined($$courseopt{$norecursechk})) {
                   if ($what =~ /\.(encrypturl|hiddenresource)$/) {
                       return [$$courseopt{$norecursechk},'map'];
                   } else {
                       last;
                   }
               }
               my $recursechk=$usercourseprefix.'.'.$item.'___(rec).'.$what;
               if (defined($$courseopt{$recursechk})) {
                   return [$$courseopt{$recursechk},'map'];
               }
           }
         if (defined($$courseopt{$courselevel})) {          if (defined($$courseopt{$courselevel})) {
            my $ret = [$$courseopt{$courselevel},'course'];             my $ret = [$$courseopt{$courselevel},'course'];
            return $ret;             return $ret;
Line 2741  sub parmval_real { Line 2864  sub parmval_real {
        if (defined($partgeneral[0])) { return \@partgeneral; }         if (defined($partgeneral[0])) { return \@partgeneral; }
     }      }
     if ($recurse) { return []; }      if ($recurse) { return []; }
     my $pack_def=&Apache::lonnet::packages_tab_default($fn,'resource.'.$rwhat);      my $pack_def=&Apache::lonnet::packages_tab_default($fn,'resource.'.$rwhat,$toolsymb);
     if (defined($pack_def)) { return [$pack_def,'resource']; }      if (defined($pack_def)) { return [$pack_def,'resource']; }
     return [''];      return [''];
 }  }
Line 2859  sub map_printdates { Line 2982  sub map_printdates {
   
   
     my $opendate = $self->get_mapparam($res->symb(),'',"$part.printstartdate");      my $opendate = $self->get_mapparam($res->symb(),'',"$part.printstartdate");
     my $closedate= $self->get_mapparam($res->symb(),'', "$part.printenddate");      my $closedate= $self->get_mapparam($res->symb(),'',"$part.printenddate");
   
   
     return ($opendate, $closedate);      return ($opendate, $closedate);
Line 2889  sub get_mapparam { Line 3012  sub get_mapparam {
     my $result='';      my $result='';
     my ($recursed,@recurseup);      my ($recursed,@recurseup);
   
   
     # Figure out which map we are in.      # Figure out which map we are in.
   
     if ($symb && !$mapname) {      if ($symb && !$mapname) {
Line 2897  sub get_mapparam { Line 3021  sub get_mapparam {
         $mapname = &Apache::lonnet::deversion($mapname);          $mapname = &Apache::lonnet::deversion($mapname);
     }      }
   
   
     my $rwhat=$what;      my $rwhat=$what;
     $what=~s/^parameter\_//;      $what=~s/^parameter\_//;
     $what=~s/\_/\./;      $what=~s/\_/\./;
   
     # Build the hash keys for the lookup:      # Build the hash keys for the lookup:
   
     my $symbparm=$symb.'.'.$what;  
     my $mapparm=$mapname.'___(all).'.$what;      my $mapparm=$mapname.'___(all).'.$what;
       my $recurseparm=$mapname.'___(rec).'.$what; 
     my $usercourseprefix=$cid;      my $usercourseprefix=$cid;
   
   
     my $grplevel    = "$usercourseprefix.[$cgroup].$mapparm";      my $grplevelm    = "$usercourseprefix.[$cgroup].$mapparm";
     my $seclevel    = "$usercourseprefix.[$csec].$mapparm";      my $seclevelm    = "$usercourseprefix.[$csec].$mapparm";
     my $courselevel = "$usercourseprefix.$mapparm";      my $courselevelm = "$usercourseprefix.$mapparm";
   
       my $grpleveli    = "$usercourseprefix.[$cgroup].$recurseparm";
       my $secleveli    = "$usercourseprefix.[$csec].$recurseparm";
       my $courseleveli = "$usercourseprefix.$recurseparm";
   
     # Get handy references to the hashes we need in $self:      # Get handy references to the hashes we need in $self:
   
Line 2924  sub get_mapparam { Line 3052  sub get_mapparam {
   
   
     if ($uname and defined($useropt)) {      if ($uname and defined($useropt)) {
  if (defined($$useropt{$courselevel})) {   if (defined($$useropt{$courselevelm})) {
     return $$useropt{$courselevel};      return $$useropt{$courselevelm};
  }   }
         if ($what =~ /\.(encrypturl|hiddenresource)$/) {          if (defined($$useropt{$courseleveli})) {
             unless ($recursed) {              return $$useropt{$courseleveli};
                 @recurseup = $self->recurseup_maps($mapname);          }
                 $recursed = 1;          unless ($recursed) {
             }              @recurseup = $self->recurseup_maps($mapname);
             foreach my $item (@recurseup) {              $recursed = 1;
                 my $norecursechk=$usercourseprefix.'.'.$item.'___(all).'.$what;          }
                 if (defined($$useropt{$norecursechk})) {          foreach my $item (@recurseup) {
                     if ($what =~ /\.(encrypturl|hiddenresource)$/) {              my $norecursechk=$usercourseprefix.'.'.$item.'___(all).'.$what;
                         return $$useropt{$norecursechk};              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};
               }
         }          }
     }      }
   
Line 2948  sub get_mapparam { Line 3083  sub get_mapparam {
   
   
     if ($cgroup ne '' and defined ($courseopt)) {      if ($cgroup ne '' and defined ($courseopt)) {
  if (defined($$courseopt{$grplevel})) {   if (defined($$courseopt{$grplevelm})) {
     return $$courseopt{$grplevel};      return $$courseopt{$grplevelm};
  }   }
         if ($what =~ /\.(encrypturl|hiddenresource)$/) {          if (defined($$courseopt{$grpleveli})) {
             unless ($recursed) {              return $$courseopt{$grpleveli};
                 @recurseup = $self->recurseup_maps($mapname);          }
                 $recursed = 1;          unless ($recursed) {
             }              @recurseup = $self->recurseup_maps($mapname);
             foreach my $item (@recurseup) {              $recursed = 1;
                 my $norecursechk=$usercourseprefix.'.['.$cgroup.'].'.$item.'___(all).'.$what;          }
                 if (defined($$courseopt{$norecursechk})) {          foreach my $item (@recurseup) {
                     if ($what =~ /\.(encrypturl|hiddenresource)$/) {              my $norecursechk=$usercourseprefix.'.['.$cgroup.'].'.$item.'___(all).'.$what;
                         return $$courseopt{$norecursechk};              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      # Check course -- section
   
   
       if ($csec ne '' and defined($courseopt)) {
    if (defined($$courseopt{$seclevelm})) {
       return $$courseopt{$seclevelm};
     if ($csec and defined($courseopt)) {  
  if (defined($$courseopt{$seclevel})) {  
     return $$courseopt{$seclevel};  
  }   }
         if ($what =~ /\.(encrypturl|hiddenresource)$/) {          if (defined($$courseopt{$secleveli})) {
             unless ($recursed) {              return $$courseopt{$secleveli};
                 @recurseup = $self->recurseup_maps($mapname);          }
                 $recursed = 1;          unless ($recursed) {
             }              @recurseup = $self->recurseup_maps($mapname);
             foreach my $item (@recurseup) {              $recursed = 1;
                 my $norecursechk=$usercourseprefix.'.['.$csec.'].'.$item.'___(all).'.$what;          }
                 if (defined($$courseopt{$norecursechk})) {          foreach my $item (@recurseup) {
                     if ($what =~ /\.(encrypturl|hiddenresource)$/) {              my $norecursechk=$usercourseprefix.'.['.$csec.'].'.$item.'___(all).'.$what;
                         return $$courseopt{$norecursechk};              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:      # Check the map parameters themselves:
Line 2998  sub get_mapparam { Line 3144  sub get_mapparam {
         my $symbparm=$symb.'.'.$what;          my $symbparm=$symb.'.'.$what;
         my $thisparm = $$parmhash{$symbparm};          my $thisparm = $$parmhash{$symbparm};
         if (defined($thisparm)) {          if (defined($thisparm)) {
             return $thisparm;      return $thisparm;
         }          }
     }      }
   
Line 3006  sub get_mapparam { Line 3152  sub get_mapparam {
     # Additional course parameters:      # Additional course parameters:
   
     if (defined($courseopt)) {      if (defined($courseopt)) {
  if (defined($$courseopt{$courselevel})) {   if (defined($$courseopt{$courselevelm})) {
     return $$courseopt{$courselevel};      return $$courseopt{$courselevelm};
  }   }
         if ($what =~ /\.(encrypturl|hiddenresource)$/) {          unless ($recursed) {
             unless ($recursed) {              @recurseup = $self->recurseup_maps($mapname);
                 @recurseup = $self->recurseup_maps($mapname);              $recursed = 1;
                 $recursed = 1;          }
             }          if (@recurseup) {
             foreach my $item (@recurseup) {              foreach my $item (@recurseup) {
                 my $norecursechk=$usercourseprefix.'.'.$item.'___(all).'.$what;                  my $norecursechk=$usercourseprefix.'.'.$item.'___(all).'.$what;
                 if (defined($$courseopt{$norecursechk})) {                  if (defined($$courseopt{$norecursechk})) {
                     if ($what =~ /\.(encrypturl|hiddenresource)$/) {                      if ($what =~ /\.(encrypturl|hiddenresource)$/) {
                         return $$courseopt{$norecursechk};                          return $$courseopt{$norecursechk};
                       } else {
                           last;
                     }                      }
                 }                  }
                   my $recursechk=$usercourseprefix.'.'.$item.'___(rec).'.$what;
                   if (defined($$courseopt{$recursechk})) {
                       return $$courseopt{$recursechk};
                   }
             }              }
         }          }
     }      }
     return undef; # Unefined if we got here.      return undef; # Undefined if we got here.
 }  }
   
 sub course_printdates {  sub course_printdates {
Line 3066  sub getcourseparam { Line 3218  sub getcourseparam {
     $what=~s/^parameter\_//;      $what=~s/^parameter\_//;
     $what=~s/\_/\./;      $what=~s/\_/\./;
   
   
     my $symbparm = $symb . '.' . $what;  
     my $mapparm=$mapname.'___(all).'.$what;  
   
     # Local refs to the hashes we're going to look at:      # Local refs to the hashes we're going to look at:
   
     my $useropt   = $self->{USER_OPT};      my $useropt   = $self->{USER_OPT};
Line 4072  sub new { Line 4220  sub new {
           
     # This is a speed optimization, to avoid calling symb() too often.      # This is a speed optimization, to avoid calling symb() too often.
     $self->{SYMB} = $self->symb();      $self->{SYMB} = $self->symb();
      
     return $self;      return $self;
 }  }
   
Line 4198  sub enclosing_map_src { Line 4346  sub enclosing_map_src {
 }  }
 sub symb {  sub symb {
     my $self=shift;      my $self=shift;
     if (defined($self->{SYMB})) { return $self->{SYMB}; }      if (defined $self->{SYMB}) { return $self->{SYMB}; }
     (my $first, my $second) = $self->{ID} =~ /(\d+).(\d+)/;      (my $first, my $second) = $self->{ID} =~ /(\d+).(\d+)/;
     my $symbSrc = &Apache::lonnet::declutter($self->src());      my $symbSrc = &Apache::lonnet::declutter($self->src());
     my $symb = &Apache::lonnet::declutter($self->navHash('map_id_'.$first))       my $symb = &Apache::lonnet::declutter($self->navHash('map_id_'.$first)) 
Line 4331  sub is_problem { Line 4479  sub is_problem {
     }      }
     return 0;      return 0;
 }  }
   sub is_tool {
       my $self=shift;
       my $src = $self->src();
       return ($src =~ /ext\.tool$/);
   }
   sub is_gradable {
       my $self=shift;
       my $src = $self->src();
       if (($src =~ /$LONCAPA::assess_re/) ||
           (($self->is_tool()) && ($self->parmval('gradable',0) =~ /^yes$/i))) {
           return !($self->is_practice());
       }
   }
 #  #
 #  The has below is the set of status that are considered 'incomplete'  #  The has below is the set of status that are considered 'incomplete'
 #  #
Line 4742  sub duedate { Line 4903  sub duedate {
     if ($interval[0] =~ /^(\d+)/) {      if ($interval[0] =~ /^(\d+)/) {
         my $timelimit = $1;          my $timelimit = $1;
         my $first_access=&Apache::lonnet::get_first_access($interval[1],          my $first_access=&Apache::lonnet::get_first_access($interval[1],
                                                           $self->{SYMB});                                                             $self->{SYMB});
  if (defined($first_access)) {   if (defined($first_access)) {
             my $interval = $first_access+$timelimit;              my $interval = $first_access+$timelimit;
     $date = (!$due_date || $interval < $due_date) ? $interval       $date = (!$due_date || $interval < $due_date) ? $interval 
Line 4844  sub getReturnHash { Line 5005  sub getReturnHash {
     my $self = shift;      my $self = shift;
           
     if (!defined($self->{RETURN_HASH})) {      if (!defined($self->{RETURN_HASH})) {
         my %tmpHash  = &Apache::lonnet::restore($self->{SYMB},undef,$self->{DOMAIN},$self->{USERNAME});          #my %tmpHash  = &Apache::lonnet::restore($self->{SYMB},undef,$self->{DOMAIN},$self->{USERNAME});
         $self->{RETURN_HASH} = \%tmpHash;          #$self->{RETURN_HASH} = \%tmpHash;
           # When info is retrieved for several resources (as when rendering a directory),
           # it is much faster to use the user profile dump and avoid repeated lonnet requests
           # (especially since lonnet::currentdump is using Lond directly whenever possible,
           # and lonnet::restore is not at this point).
           $self->{NAV_MAP}->get_user_data();
           $self->{RETURN_HASH} = $self->{NAV_MAP}->{STUDENT_DATA}->{$self->{SYMB}};
     }      }
 }         }       
   
Line 4986  sub parts { Line 5153  sub parts {
     my $self = shift;      my $self = shift;
   
     if ($self->ext) { return []; }      if ($self->ext) { return []; }
       if (($self->is_tool()) &&
           ($self->is_gradable())) { return ['0']; }
   
     $self->extractParts();      $self->extractParts();
     return $self->{PARTS};      return $self->{PARTS};
Line 5076  sub extractParts { Line 5245  sub extractParts {
     my %parts;      my %parts;
   
     # Retrieve part count, if this is a problem      # Retrieve part count, if this is a problem
     if ($self->is_problem()) {      if ($self->is_raw_problem()) {
  my $partorder = &Apache::lonnet::metadata($self->src(), 'partorder');   my $partorder = &Apache::lonnet::metadata($self->src(), 'partorder');
         my $metadata = &Apache::lonnet::metadata($self->src(), 'packages');          my $metadata = &Apache::lonnet::metadata($self->src(), 'packages');
   
Line 5360  Attempted, and not yet graded. Line 5529  Attempted, and not yet graded.
   
 Attempted, and credit received for attempt (survey and anonymous survey only).  Attempted, and credit received for attempt (survey and anonymous survey only).
   
   =item * B<INCORRECT_BY_PASSBACK>:
   
   Attempted, but wrong for LTI Tool Provider by passback of grade
   
   =item * B<CORRECT_BY_PASSBACK>:
   
   Correct for LTI Tool Provider by passback of grade
   
 =back  =back
   
 =cut  =cut
Line 5372  sub CORRECT_BY_OVERRIDE   { return 14; } Line 5549  sub CORRECT_BY_OVERRIDE   { return 14; }
 sub EXCUSED               { return 15; }  sub EXCUSED               { return 15; }
 sub ATTEMPTED             { return 16; }  sub ATTEMPTED             { return 16; }
 sub CREDIT_ATTEMPTED      { return 17; }  sub CREDIT_ATTEMPTED      { return 17; }
   sub INCORRECT_BY_PASSBACK { return 18; }
   sub CORRECT_BY_PASSBACK   { return 19; }
   
 sub getCompletionStatus {  sub getCompletionStatus {
     my $self = shift;      my $self = shift;
Line 5386  sub getCompletionStatus { Line 5565  sub getCompletionStatus {
     if ($status eq 'correct_by_override') {      if ($status eq 'correct_by_override') {
  return $self->CORRECT_BY_OVERRIDE;   return $self->CORRECT_BY_OVERRIDE;
     }      }
       if ($status eq 'correct_by_passback') {
           return $self->CORRECT_BY_PASSBACK;
       }
     if ($status eq 'incorrect_attempted') {return $self->INCORRECT; }      if ($status eq 'incorrect_attempted') {return $self->INCORRECT; }
     if ($status eq 'incorrect_by_override') {return $self->INCORRECT_BY_OVERRIDE; }      if ($status eq 'incorrect_by_override') {return $self->INCORRECT_BY_OVERRIDE; }
       if ($status eq 'incorrect_by_passback') {return $self->INCORRECT_BY_PASSBACK; }
     if ($status eq 'excused') {return $self->EXCUSED; }      if ($status eq 'excused') {return $self->EXCUSED; }
     if ($status eq 'ungraded_attempted') {return $self->ATTEMPTED; }      if ($status eq 'ungraded_attempted') {return $self->ATTEMPTED; }
     if ($status eq 'credit_attempted') {      if ($status eq 'credit_attempted') {
Line 5541  sub status { Line 5724  sub status {
   
     # There are a few whole rows we can dispose of:      # There are a few whole rows we can dispose of:
     if ($completionStatus == CORRECT ||      if ($completionStatus == CORRECT ||
         $completionStatus == CORRECT_BY_OVERRIDE ) {          $completionStatus == CORRECT_BY_OVERRIDE ||
           $completionStatus == CORRECT_BY_PASSBACK ) {
  if ( $suppressFeedback ) { return ANSWER_SUBMITTED }   if ( $suppressFeedback ) { return ANSWER_SUBMITTED }
  my $awarded=$self->awarded($part);   my $awarded=$self->awarded($part);
  if ($awarded < 1 && $awarded > 0) {   if ($awarded < 1 && $awarded > 0) {
Line 5554  sub status { Line 5738  sub status {
   
     # If it's WRONG... and not open      # If it's WRONG... and not open
     if ( ($completionStatus == INCORRECT ||       if ( ($completionStatus == INCORRECT || 
   $completionStatus == INCORRECT_BY_OVERRIDE)    $completionStatus == INCORRECT_BY_OVERRIDE ||
     $completionStatus == INCORRECT_BY_PASSBACK)
  && (!$self->opendate($part) ||  $self->opendate($part) > time()) ) {   && (!$self->opendate($part) ||  $self->opendate($part) > time()) ) {
  return INCORRECT;   return INCORRECT;
     }      }
Line 5596  sub status { Line 5781  sub status {
     }      }
   
     # If it's WRONG...      # If it's WRONG...
     if ($completionStatus == INCORRECT || $completionStatus == INCORRECT_BY_OVERRIDE) {      if ($completionStatus == INCORRECT || $completionStatus == INCORRECT_BY_OVERRIDE ||
           $completionStatus == INCORRECT_BY_PASSBACK) {
         # and there are TRIES LEFT:          # and there are TRIES LEFT:
         if ($self->tries($part) < $self->maxtries($part) || !$self->maxtries($part)) {          if ($self->tries($part) < $self->maxtries($part) || !$self->maxtries($part)) {
             return $suppressFeedback ? ANSWER_SUBMITTED : TRIES_LEFT;              return $suppressFeedback ? ANSWER_SUBMITTED : TRIES_LEFT;
Line 5650  sub check_for_slot { Line 5836  sub check_for_slot {
                                 ($checkedin,$checkedinslot) = $self->checkedin();                                  ($checkedin,$checkedinslot) = $self->checkedin();
                                 unless ((grep(/^\Q$checkedin\E/,@proctors)) &&                                  unless ((grep(/^\Q$checkedin\E/,@proctors)) &&
                                         ($checkedinslot eq $slot_name)) {                                          ($checkedinslot eq $slot_name)) {
                                     return (NEEDS_CHECKIN,$end,$slot_name);                                       return (NEEDS_CHECKIN,undef,$slot_name); 
                                 }                                  }
                             }                              }
                             return (RESERVED,$end,$slot_name);                              return (RESERVED,$end,$slot_name);
Line 5696  sub check_for_slot { Line 5882  sub check_for_slot {
         my $reservable = &Apache::lonnet::get_reservable_slots($cnum,$cdom,$env{'user.name'},          my $reservable = &Apache::lonnet::get_reservable_slots($cnum,$cdom,$env{'user.name'},
                                                                $env{'user.domain'});                                                                 $env{'user.domain'});
         if (ref($reservable) eq 'HASH') {          if (ref($reservable) eq 'HASH') {
               my ($map) = &Apache::lonnet::decode_symb($symb);
             if ((ref($reservable->{'now_order'}) eq 'ARRAY') && (ref($reservable->{'now'}) eq 'HASH')) {              if ((ref($reservable->{'now_order'}) eq 'ARRAY') && (ref($reservable->{'now'}) eq 'HASH')) {
                 foreach my $slot (reverse (@{$reservable->{'now_order'}})) {                  foreach my $slot (reverse (@{$reservable->{'now_order'}})) {
                     my $canuse;                      my $canuse;
                     if (($reservable->{'now'}{$slot}{'symb'} eq '') ||                      if ($reservable->{'now'}{$slot}{'symb'} eq '') {
                         ($reservable->{'now'}{$slot}{'symb'} eq $symb)) {  
                         $canuse = 1;                          $canuse = 1;
                       } else {
                           my %oksymbs;
                           my @slotsymbs = split(/\s*,\s*/,$reservable->{'now'}{$slot}{'symb'});
                           map { $oksymbs{$_} = 1; } @slotsymbs;
                           if ($oksymbs{$symb}) {
                               $canuse = 1;
                           } else {
                               foreach my $item (@slotsymbs) {
                                   if ($item =~ /\.(page|sequence)$/) {
                                       (undef,undef, my $sloturl) = &Apache::lonnet::decode_symb($item);
                                       if (($map ne '') && ($map eq $sloturl)) {
                                           $canuse = 1;
                                           last;
                                       }
                                   }
                               }
                           }
                     }                      }
                     if ($canuse) {                      if ($canuse) {
                         if ($checkedin) {                          if ($checkedin) {
Line 5722  sub check_for_slot { Line 5925  sub check_for_slot {
             if ((ref($reservable->{'future_order'}) eq 'ARRAY') && (ref($reservable->{'future'}) eq 'HASH')) {              if ((ref($reservable->{'future_order'}) eq 'ARRAY') && (ref($reservable->{'future'}) eq 'HASH')) {
                 foreach my $slot (@{$reservable->{'future_order'}}) {                  foreach my $slot (@{$reservable->{'future_order'}}) {
                     my $canuse;                      my $canuse;
                     if (($reservable->{'future'}{$slot}{'symb'} eq '') ||                      if ($reservable->{'future'}{$slot}{'symb'} eq '') {
                         ($reservable->{'future'}{$slot}{'symb'} eq $symb)) {                          $canuse = 1;
                       } elsif ($reservable->{'future'}{$slot}{'symb'} =~ /,/) {
                           my %oksymbs;
                           my @slotsymbs = split(/\s*,\s*/,$reservable->{'future'}{$slot}{'symb'});
                           map { $oksymbs{$_} = 1; } @slotsymbs;
                           if ($oksymbs{$symb}) {
                               $canuse = 1;
                           } else {
                               foreach my $item (@slotsymbs) {
                                   if ($item =~ /\.(page|sequence)$/) {
                                       (undef,undef, my $sloturl) = &Apache::lonnet::decode_symb($item);
                                       if (($map ne '') && ($map eq $sloturl)) {
                                           $canuse = 1;
                                           last;
                                       }
                                   }
                               }
                           }
                       } elsif ($reservable->{'future'}{$slot}{'symb'} eq $symb) {
                         $canuse = 1;                          $canuse = 1;
                     }                      }
                     if ($canuse) {                      if ($canuse) {

Removed from v.1.509.2.5.4.3  
changed lines
  Added in v.1.537


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