[BACK]Return to lonnavmaps.pm CVS log [TXT] [DIR] Up to [LON-CAPA] / loncom / interface

Diff for /loncom/interface/lonnavmaps.pm between versions 1.219 and 1.223

version 1.219, 2003/07/29 05:22:56 version 1.223, 2003/09/03 20:27:08
Line 129  sub real_handler { Line 129  sub real_handler {
     $r->send_http_header;      $r->send_http_header;
   
     # Create the nav map      # Create the nav map
     my $navmap = Apache::lonnavmaps::navmap->new(      my $navmap = Apache::lonnavmaps::navmap->new();
                         $ENV{"request.course.fn"}.".db",  
                         $ENV{"request.course.fn"}."_parms.db", 1, 1);  
   
   
     if (!defined($navmap)) {      if (!defined($navmap)) {
Line 161  sub real_handler { Line 159  sub real_handler {
   
     $r->rflush();      $r->rflush();
   
     # Now that we've displayed some stuff to the user, init the navmap  
     $navmap->init();  
   
     $r->rflush();  
   
     # Check that it's defined      # Check that it's defined
     if (!($navmap->courseMapDefined())) {      if (!($navmap->courseMapDefined())) {
         $r->print('<font size="+2" color="red">Coursemap undefined.</font>' .          $r->print('<font size="+2" color="red">Coursemap undefined.</font>' .
Line 175  sub real_handler { Line 168  sub real_handler {
   
     # See if there's only one map in the top-level, if we don't      # See if there's only one map in the top-level, if we don't
     # already have a filter... if so, automatically display it      # already have a filter... if so, automatically display it
       # (older code; should use retrieveResources)
     if ($ENV{QUERY_STRING} !~ /filter/) {      if ($ENV{QUERY_STRING} !~ /filter/) {
         my $iterator = $navmap->getIterator(undef, undef, undef, 0);          my $iterator = $navmap->getIterator(undef, undef, undef, 0);
         my $depth = 1;          my $curRes;
         $iterator->next();  
         my $curRes = $iterator->next();  
         my $sequenceCount = 0;          my $sequenceCount = 0;
         my $sequenceId;          my $sequenceId;
         while ($depth > 0) {          while ($curRes = $iterator->next()) {
             if ($curRes == $iterator->BEGIN_MAP()) { $depth++; }  
             if ($curRes == $iterator->END_MAP()) { $depth--; }  
               
             if (ref($curRes) && $curRes->is_sequence()) {              if (ref($curRes) && $curRes->is_sequence()) {
                 $sequenceCount++;                  $sequenceCount++;
                 $sequenceId = $curRes->map_pc();                  $sequenceId = $curRes->map_pc();
             }              }
               
             $curRes = $iterator->next();  
         }          }
                   
         if ($sequenceCount == 1) {          if ($sequenceCount == 1) {
Line 209  sub real_handler { Line 196  sub real_handler {
         $jumpToFirstHomework = 1;          $jumpToFirstHomework = 1;
         # Find the next homework problem that they can do.          # Find the next homework problem that they can do.
         my $iterator = $navmap->getIterator(undef, undef, undef, 1);          my $iterator = $navmap->getIterator(undef, undef, undef, 1);
         my $depth = 1;          my $curRes;
         $iterator->next();  
         my $curRes = $iterator->next();  
         my $foundDoableProblem = 0;          my $foundDoableProblem = 0;
         my $problemRes;          my $problemRes;
                   
         while ($depth > 0 && !$foundDoableProblem) {          while (($curRes = $iterator->next()) && !$foundDoableProblem) {
             if ($curRes == $iterator->BEGIN_MAP()) { $depth++; }  
             if ($curRes == $iterator->END_MAP()) { $depth--; }  
   
             if (ref($curRes) && $curRes->is_problem()) {              if (ref($curRes) && $curRes->is_problem()) {
                 my $status = $curRes->status();                  my $status = $curRes->status();
                 if ($curRes->completable()) {                  if ($curRes->completable()) {
Line 236  sub real_handler { Line 218  sub real_handler {
                     $ENV{'form.postsymb'} = $curRes->symb();                      $ENV{'form.postsymb'} = $curRes->symb();
                 }                  }
             }              }
         } continue {  
             $curRes = $iterator->next();  
         }          }
   
         # If we found no problems, print a note to that effect.          # If we found no problems, print a note to that effect.
Line 1172  sub render { Line 1152  sub render {
     if (!$ENV{'form.folderManip'} && !defined($args->{'iterator'})) {      if (!$ENV{'form.folderManip'} && !defined($args->{'iterator'})) {
         # Step 1: Check to see if we have a navmap          # Step 1: Check to see if we have a navmap
         if (!defined($navmap)) {          if (!defined($navmap)) {
             $navmap = Apache::lonnavmaps::navmap->new(              $navmap = Apache::lonnavmaps::navmap->new();
                         $ENV{"request.course.fn"}.".db",  
                         $ENV{"request.course.fn"}."_parms.db", 1, 1);  
             $mustCloseNavMap = 1;              $mustCloseNavMap = 1;
         }          }
         $navmap->init();  
   
         # Step two: Locate what kind of here marker is necessary          # Step two: Locate what kind of here marker is necessary
         # Determine where the "here" marker is and where the screen jumps to.          # Determine where the "here" marker is and where the screen jumps to.
Line 1195  sub render { Line 1172  sub render {
   
         # Step three: Ensure the folders are open          # Step three: Ensure the folders are open
         my $mapIterator = $navmap->getIterator(undef, undef, undef, 1);          my $mapIterator = $navmap->getIterator(undef, undef, undef, 1);
         my $depth = 1;          my $curRes;
         $mapIterator->next(); # discard the first BEGIN_MAP  
         my $curRes = $mapIterator->next();  
         my $found = 0;          my $found = 0;
                   
         # We only need to do this if we need to open the maps to show the          # We only need to do this if we need to open the maps to show the
         # current position. This will change the counter so we can't count          # current position. This will change the counter so we can't count
         # for the jump marker with this loop.          # for the jump marker with this loop.
         while ($depth > 0 && !$found) {          while (($curRes = $mapIterator->next()) && !$found) {
             if ($curRes == $mapIterator->BEGIN_MAP()) { $depth++; }  
             if ($curRes == $mapIterator->END_MAP()) { $depth--; }  
               
             if (ref($curRes) && $curRes->symb() eq $here) {              if (ref($curRes) && $curRes->symb() eq $here) {
                 my $mapStack = $mapIterator->getStack();                  my $mapStack = $mapIterator->getStack();
                                   
Line 1220  sub render { Line 1192  sub render {
                 }                  }
                 $found = 1;                  $found = 1;
             }              }
               
             $curRes = $mapIterator->next();  
         }                      }            
     }              }        
   
Line 1238  sub render { Line 1208  sub render {
                   
         # Step 1: Check to see if we have a navmap          # Step 1: Check to see if we have a navmap
         if (!defined($navmap)) {          if (!defined($navmap)) {
             $navmap = Apache::lonnavmaps::navmap->new($r,               $navmap = Apache::lonnavmaps::navmap->new();
                         $ENV{"request.course.fn"}.".db",  
                         $ENV{"request.course.fn"}."_parms.db", 1, 1);  
             $mustCloseNavMap = 1;              $mustCloseNavMap = 1;
         }          }
         # Paranoia: Make sure it's ready  
         $navmap->init();  
   
         # See if we're being passed a specific map          # See if we're being passed a specific map
         if ($args->{'iterator_map'}) {          if ($args->{'iterator_map'}) {
Line 1263  sub render { Line 1229  sub render {
     # Note this does not take filtering or hidden into account... need      # Note this does not take filtering or hidden into account... need
     # to be fixed?      # to be fixed?
     my $mapIterator = $navmap->getIterator(undef, undef, $filterHash, 0);      my $mapIterator = $navmap->getIterator(undef, undef, $filterHash, 0);
     my $depth = 1;      my $curRes;
     $mapIterator->next();  
     my $curRes = $mapIterator->next();  
     my $foundJump = 0;      my $foundJump = 0;
     my $counter = 0;      my $counter = 0;
           
     while ($depth > 0 && !$foundJump) {      while (($curRes = $mapIterator->next()) && !$foundJump) {
         if ($curRes == $mapIterator->BEGIN_MAP()) { $depth++; }  
         if ($curRes == $mapIterator->END_MAP()) { $depth--; }  
         if (ref($curRes)) { $counter++; }          if (ref($curRes)) { $counter++; }
                   
         if (ref($curRes) && $jump eq $curRes->symb()) {          if (ref($curRes) && $jump eq $curRes->symb()) {
Line 1282  sub render { Line 1244  sub render {
             $args->{'currentJumpIndex'} = $counter;              $args->{'currentJumpIndex'} = $counter;
             $foundJump = 1;              $foundJump = 1;
         }          }
           
         $curRes = $mapIterator->next();  
     }      }
   
     my $showParts = setDefault($args->{'showParts'}, 1);      my $showParts = setDefault($args->{'showParts'}, 1);
Line 1361  sub render { Line 1321  sub render {
                                                          $it->{FIRST_RESOURCE},                                                           $it->{FIRST_RESOURCE},
                                                          $it->{FINISH_RESOURCE},                                                           $it->{FINISH_RESOURCE},
                                                          {}, undef, 1);                                                           {}, undef, 1);
         $depth = 0;          my $depth = 0;
         $dfsit->next();          $dfsit->next();
         my $curRes = $dfsit->next();          my $curRes = $dfsit->next();
         while ($depth > -1) {          while ($depth > -1) {
Line 1393  sub render { Line 1353  sub render {
   
     my $displayedJumpMarker = 0;      my $displayedJumpMarker = 0;
     # Set up iteration.      # Set up iteration.
     $depth = 1;  
     $it->next(); # discard initial BEGIN_MAP  
     $curRes = $it->next();  
     my $now = time();      my $now = time();
     my $in24Hours = $now + 24 * 60 * 60;      my $in24Hours = $now + 24 * 60 * 60;
     my $rownum = 0;      my $rownum = 0;
Line 1403  sub render { Line 1360  sub render {
     # export "here" marker information      # export "here" marker information
     $args->{'here'} = $here;      $args->{'here'} = $here;
   
     while ($depth > 0) {      $args->{'indentLevel'} = -1; # first BEGIN_MAP takes this to 0
         if ($curRes == $it->BEGIN_MAP()) { $depth++; }      while ($curRes = $it->next()) {
         if ($curRes == $it->END_MAP()) { $depth--; }  
   
         # Maintain indentation level.          # Maintain indentation level.
         if ($curRes == $it->BEGIN_MAP() ||          if ($curRes == $it->BEGIN_MAP() ||
             $curRes == $it->BEGIN_BRANCH() ) {              $curRes == $it->BEGIN_BRANCH() ) {
Line 1559  sub render { Line 1514  sub render {
             $r->rflush();              $r->rflush();
         }          }
     } continue {      } continue {
         $curRes = $it->next();  
   
  if ($r) {   if ($r) {
     # If we have the connection, make sure the user is still connected      # If we have the connection, make sure the user is still connected
     my $c = $r->connection;      my $c = $r->connection;
Line 1646  To create a navmap object, use the follo Line 1599  To create a navmap object, use the follo
   
 =over 4  =over 4
   
 =item * B<Apache::lonnavmaps::navmap-E<gt>new>(navHashFile, parmHashFile,   =item * B<Apache::lonnavmaps::navmap-E<gt>new>():
   genCourseAndUserOptions, genMailDiscussStatus, getUserData):  
   
 Binds a new navmap object to the compiled nav map hash and parm hash  Creates a new navmap object. Returns the navmap object if this is
 given as filenames. genCourseAndUserOptions is a flag saying whether  successful, or B<undef> if not.
 the course options and user options hash should be generated. This is  
 for when you are using the parameters of the resources that require  
 them; see documentation in resource object  
 documentation. genMailDiscussStatus causes the nav map to retreive  
 information about the email and discussion status of  
 resources. Returns the navmap object if this is successful, or  
 B<undef> if not. You must check for undef; errors will occur when you  
 try to use the other methods otherwise. getUserData, if true, will   
 retreive the user's performance data for various problems.  
   
 =back  =back
   
 Once you have the $navmap object, call ->init() on it when you are ready  
 to use it. This allows you to check if the course map is defined (see  
 B<courseMapDefined> below) before engaging in potentially expensive   
 initialization routines for the genCourseAndUserOptions and   
 genMailDiscussStatus option.  
   
 When you are done with the $navmap object, you I<must> call   When you are done with the $navmap object, you I<must> call 
 $navmap->untieHashes(), or you'll prevent the current user from using that   $navmap->untieHashes(), or you'll prevent the current user from using that 
 course until the web server is restarted. (!)  course until the web server is restarted. (!)
Line 1692  sub new { Line 1629  sub new {
     my $class = ref($proto) || $proto;      my $class = ref($proto) || $proto;
     my $self = {};      my $self = {};
   
     $self->{NAV_HASH_FILE} = shift;  
     $self->{PARM_HASH_FILE} = shift;  
     $self->{GENERATE_COURSE_USER_OPT} = shift;  
     $self->{GENERATE_EMAIL_DISCUSS_STATUS} = shift;  
     $self->{GET_USER_DATA} = shift;  
   
     # Resource cache stores navmap resources as we reference them. We generate      # Resource cache stores navmap resources as we reference them. We generate
     # them on-demand so we don't pay for creating resources unless we use them.      # them on-demand so we don't pay for creating resources unless we use them.
     $self->{RESOURCE_CACHE} = {};      $self->{RESOURCE_CACHE} = {};
Line 1710  sub new { Line 1641  sub new {
   
     my %navmaphash;      my %navmaphash;
     my %parmhash;      my %parmhash;
     if (!(tie(%navmaphash, 'GDBM_File', $self->{NAV_HASH_FILE},      my $courseFn = $ENV{"request.course.fn"};
       if (!(tie(%navmaphash, 'GDBM_File', "${courseFn}.db",
               &GDBM_READER(), 0640))) {                &GDBM_READER(), 0640))) {
         return undef;          return undef;
     }      }
           
     if (!(tie(%parmhash, 'GDBM_File', $self->{PARM_HASH_FILE},      if (!(tie(%parmhash, 'GDBM_File', "${courseFn}_parms.db",
               &GDBM_READER(), 0640)))                &GDBM_READER(), 0640)))
     {      {
         untie %{$self->{PARM_HASH}};          untie %{$self->{PARM_HASH}};
Line 1724  sub new { Line 1656  sub new {
   
     $self->{NAV_HASH} = \%navmaphash;      $self->{NAV_HASH} = \%navmaphash;
     $self->{PARM_HASH} = \%parmhash;      $self->{PARM_HASH} = \%parmhash;
     $self->{INITED} = 0;      $self->{PARM_CACHE} = {};
   
     bless($self);      bless($self);
                   
     return $self;      return $self;
 }  }
   
 sub init {  sub generate_course_user_opt {
     my $self = shift;      my $self = shift;
     if ($self->{INITED}) { return; }      if ($self->{COURSE_USER_OPT_GENERATED}) { return; }
   
     # If the course opt hash and the user opt hash should be generated,      my $uname=$ENV{'user.name'};
     # generate them      my $udom=$ENV{'user.domain'};
     if ($self->{GENERATE_COURSE_USER_OPT}) {      my $uhome=$ENV{'user.home'};
         my $uname=$ENV{'user.name'};      my $cid=$ENV{'request.course.id'};
         my $udom=$ENV{'user.domain'};      my $chome=$ENV{'course.'.$cid.'.home'};
         my $uhome=$ENV{'user.home'};      my ($cdom,$cnum)=split(/\_/,$cid);
         my $cid=$ENV{'request.course.id'};      
         my $chome=$ENV{'course.'.$cid.'.home'};      my $userprefix=$uname.'_'.$udom.'_';
         my ($cdom,$cnum)=split(/\_/,$cid);      
               my %courserdatas; my %useropt; my %courseopt; my %userrdatas;
         my $userprefix=$uname.'_'.$udom.'_';      unless ($uhome eq 'no_host') { 
           
         my %courserdatas; my %useropt; my %courseopt; my %userrdatas;  
         unless ($uhome eq 'no_host') {   
 # ------------------------------------------------- Get coursedata (if present)  # ------------------------------------------------- Get coursedata (if present)
             unless ((time-$courserdatas{$cid.'.last_cache'})<240) {   unless ((time-$courserdatas{$cid.'.last_cache'})<240) {
                 my $reply=&Apache::lonnet::reply('dump:'.$cdom.':'.$cnum.      my $reply=&Apache::lonnet::reply('dump:'.$cdom.':'.$cnum.
                                                  ':resourcedata',$chome);       ':resourcedata',$chome);
                 # Check for network failure      # Check for network failure
                 if ( $reply =~ /no.such.host/i || $reply =~ /con_lost/i) {      if ( $reply =~ /no.such.host/i || $reply =~ /con_lost/i) {
                     $self->{NETWORK_FAILURE} = 1;   $self->{NETWORK_FAILURE} = 1;
                 } elsif ($reply!~/^error\:/) {      } elsif ($reply!~/^error\:/) {
                     $courserdatas{$cid}=$reply;   $courserdatas{$cid}=$reply;
                     $courserdatas{$cid.'.last_cache'}=time;   $courserdatas{$cid.'.last_cache'}=time;
                 }      }
             }   }
             foreach (split(/\&/,$courserdatas{$cid})) {   foreach (split(/\&/,$courserdatas{$cid})) {
                 my ($name,$value)=split(/\=/,$_);      my ($name,$value)=split(/\=/,$_);
                 $courseopt{$userprefix.&Apache::lonnet::unescape($name)}=      $courseopt{$userprefix.&Apache::lonnet::unescape($name)}=
                     &Apache::lonnet::unescape($value);   &Apache::lonnet::unescape($value);
             }   }
 # --------------------------------------------------- Get userdata (if present)  # --------------------------------------------------- Get userdata (if present)
             unless ((time-$userrdatas{$uname.'___'.$udom.'.last_cache'})<240) {   unless ((time-$userrdatas{$uname.'___'.$udom.'.last_cache'})<240) {
                 my $reply=&Apache::lonnet::reply('dump:'.$udom.':'.$uname.':resourcedata',$uhome);      my $reply=&Apache::lonnet::reply('dump:'.$udom.':'.$uname.':resourcedata',$uhome);
                 if ($reply!~/^error\:/) {      if ($reply!~/^error\:/) {
                     $userrdatas{$uname.'___'.$udom}=$reply;   $userrdatas{$uname.'___'.$udom}=$reply;
                     $userrdatas{$uname.'___'.$udom.'.last_cache'}=time;   $userrdatas{$uname.'___'.$udom.'.last_cache'}=time;
                 }      }
                 # check to see if network failed      # check to see if network failed
                 elsif ( $reply=~/no.such.host/i || $reply=~/con.*lost/i )      elsif ( $reply=~/no.such.host/i || $reply=~/con.*lost/i )
                 {      {
                     $self->{NETWORK_FAILURE} = 1;   $self->{NETWORK_FAILURE} = 1;
                 }      }
             }   }
             foreach (split(/\&/,$userrdatas{$uname.'___'.$udom})) {   foreach (split(/\&/,$userrdatas{$uname.'___'.$udom})) {
                 my ($name,$value)=split(/\=/,$_);      my ($name,$value)=split(/\=/,$_);
                 $useropt{$userprefix.&Apache::lonnet::unescape($name)}=      $useropt{$userprefix.&Apache::lonnet::unescape($name)}=
                     &Apache::lonnet::unescape($value);   &Apache::lonnet::unescape($value);
             }   }
             $self->{COURSE_OPT} = \%courseopt;   $self->{COURSE_OPT} = \%courseopt;
             $self->{USER_OPT} = \%useropt;   $self->{USER_OPT} = \%useropt;
         }  
     }     
   
     if ($self->{GENERATE_EMAIL_DISCUSS_STATUS}) {  
         my $cid=$ENV{'request.course.id'};  
         my ($cdom,$cnum)=split(/\_/,$cid);  
           
         my %emailstatus = &Apache::lonnet::dump('email_status');  
         my $logoutTime = $emailstatus{'logout'};  
         my $courseLeaveTime = $emailstatus{'logout_'.$ENV{'request.course.id'}};  
         $self->{LAST_CHECK} = (($courseLeaveTime > $logoutTime) ?  
                                $courseLeaveTime : $logoutTime);  
         my %discussiontime = &Apache::lonnet::dump('discussiontimes',   
                                                    $cdom, $cnum);  
         my %feedback=();  
         my %error=();  
         my $keys = &Apache::lonnet::reply('keys:'.  
                                           $ENV{'user.domain'}.':'.  
                                           $ENV{'user.name'}.':nohist_email',  
                                           $ENV{'user.home'});  
   
         foreach my $msgid (split(/\&/, $keys)) {  
             $msgid=&Apache::lonnet::unescape($msgid);  
             my $plain=&Apache::lonnet::unescape(&Apache::lonnet::unescape($msgid));  
             if ($plain=~/(Error|Feedback) \[([^\]]+)\]/) {  
                 my ($what,$url)=($1,$2);  
                 my %status=  
                     &Apache::lonnet::get('email_status',[$msgid]);  
                 if ($status{$msgid}=~/^error\:/) {   
                     $status{$msgid}='';   
                 }  
                   
                 if (($status{$msgid} eq 'new') ||   
                     (!$status{$msgid})) {   
                     if ($what eq 'Error') {  
                         $error{$url}.=','.$msgid;   
                     } else {  
                         $feedback{$url}.=','.$msgid;  
                     }  
                 }  
             }  
         }  
           
         $self->{FEEDBACK} = \%feedback;  
         $self->{ERROR_MSG} = \%error; # what is this? JB  
         $self->{DISCUSSION_TIME} = \%discussiontime;  
         $self->{EMAIL_STATUS} = \%emailstatus;  
           
     }      }
   
     if ($self->{GET_USER_DATA}) {      $self->{COURSE_USER_OPT_GENERATED} = 1;
  # Retreive performance data on problems      
  my %student_data = Apache::lonnet::currentdump($ENV{'request.course.id'},      return;
        $ENV{'user.domain'},  }
        $ENV{'user.name'});  
  $self->{STUDENT_DATA} = \%student_data;  sub generate_email_discuss_status {
       my $self = shift;
       if ($self->{EMAIL_DISCUSS_GENERATED}) { return; }
   
       my $cid=$ENV{'request.course.id'};
       my ($cdom,$cnum)=split(/\_/,$cid);
       
       my %emailstatus = &Apache::lonnet::dump('email_status');
       my $logoutTime = $emailstatus{'logout'};
       my $courseLeaveTime = $emailstatus{'logout_'.$ENV{'request.course.id'}};
       $self->{LAST_CHECK} = (($courseLeaveTime > $logoutTime) ?
      $courseLeaveTime : $logoutTime);
       my %discussiontime = &Apache::lonnet::dump('discussiontimes', 
          $cdom, $cnum);
       my %feedback=();
       my %error=();
       my $keys = &Apache::lonnet::reply('keys:'.
         $ENV{'user.domain'}.':'.
         $ENV{'user.name'}.':nohist_email',
         $ENV{'user.home'});
       
       foreach my $msgid (split(/\&/, $keys)) {
    $msgid=&Apache::lonnet::unescape($msgid);
    my $plain=&Apache::lonnet::unescape(&Apache::lonnet::unescape($msgid));
    if ($plain=~/(Error|Feedback) \[([^\]]+)\]/) {
       my ($what,$url)=($1,$2);
       my %status=
    &Apache::lonnet::get('email_status',[$msgid]);
       if ($status{$msgid}=~/^error\:/) { 
    $status{$msgid}=''; 
       }
       
       if (($status{$msgid} eq 'new') || 
    (!$status{$msgid})) { 
    if ($what eq 'Error') {
       $error{$url}.=','.$msgid; 
    } else {
       $feedback{$url}.=','.$msgid;
    }
       }
    }
     }      }
       
       $self->{FEEDBACK} = \%feedback;
       $self->{ERROR_MSG} = \%error; # what is this? JB
       $self->{DISCUSSION_TIME} = \%discussiontime;
       $self->{EMAIL_STATUS} = \%emailstatus;
       
       $self->{EMAIL_DISCUSS_GENERATED} = 1;
   }
   
     $self->{PARM_CACHE} = {};  sub get_user_data {
     $self->{INITED} = 1;      my $self = shift;
       if ($self->{RETRIEVED_USER_DATA}) { return; }
   
       # Retrieve performance data on problems
       my %student_data = Apache::lonnet::currentdump($ENV{'request.course.id'},
      $ENV{'user.domain'},
      $ENV{'user.name'});
       $self->{STUDENT_DATA} = \%student_data;
   
       $self->{RETRIEVED_USER_DATA} = 1;
 }  }
   
 # Internal function: Takes a key to look up in the nav hash and implements internal  # Internal function: Takes a key to look up in the nav hash and implements internal
Line 1893  sub untieHashes { Line 1831  sub untieHashes {
 sub hasDiscussion {  sub hasDiscussion {
     my $self = shift;      my $self = shift;
     my $symb = shift;      my $symb = shift;
       
       $self->generate_email_discuss_status();
   
     if (!defined($self->{DISCUSSION_TIME})) { return 0; }      if (!defined($self->{DISCUSSION_TIME})) { return 0; }
   
     #return defined($self->{DISCUSSION_TIME}->{$symb});      #return defined($self->{DISCUSSION_TIME}->{$symb});
Line 1907  sub getFeedback { Line 1848  sub getFeedback {
     my $self = shift;      my $self = shift;
     my $symb = shift;      my $symb = shift;
   
       $self->generate_email_discuss_status();
   
     if (!defined($self->{FEEDBACK})) { return ""; }      if (!defined($self->{FEEDBACK})) { return ""; }
           
     return $self->{FEEDBACK}->{$symb};      return $self->{FEEDBACK}->{$symb};
Line 1916  sub getFeedback { Line 1859  sub getFeedback {
 sub getErrors {   sub getErrors { 
     my $self = shift;      my $self = shift;
     my $src = shift;      my $src = shift;
       
       $self->generate_email_discuss_status();
   
     if (!defined($self->{ERROR_MSG})) { return ""; }      if (!defined($self->{ERROR_MSG})) { return ""; }
     return $self->{ERROR_MSG}->{$src};      return $self->{ERROR_MSG}->{$src};
 }  }
Line 2029  sub parmval_real { Line 1974  sub parmval_real {
     my $self = shift;      my $self = shift;
     my ($what,$symb,$recurse) = @_;      my ($what,$symb,$recurse) = @_;
   
       # Make sure the {USER_OPT} and {COURSE_OPT} hashes are populated
       $self->generate_course_user_opt();
   
     my $cid=$ENV{'request.course.id'};      my $cid=$ENV{'request.course.id'};
     my $csec=$ENV{'request.course.sec'};      my $csec=$ENV{'request.course.sec'};
     my $uname=$ENV{'user.name'};      my $uname=$ENV{'user.name'};
Line 2203  sub retrieveResources { Line 2151  sub retrieveResources {
     my @resources = ();      my @resources = ();
   
     # Run down the iterator and collect the resources.      # Run down the iterator and collect the resources.
     my $depth = 1;      my $curRes;
     $it->next();  
     my $curRes = $it->next();      while ($curRes = $it->next()) {
   
     while ($depth > 0) {  
         if ($curRes == $it->BEGIN_MAP()) {  
             $depth++;  
         }  
         if ($curRes == $it->END_MAP()) {  
             $depth--;  
         }  
           
         if (ref($curRes)) {          if (ref($curRes)) {
             if (!&$filterFunc($curRes)) {              if (!&$filterFunc($curRes)) {
                 next;                  next;
Line 2227  sub retrieveResources { Line 2166  sub retrieveResources {
             }              }
         }          }
   
     } continue {  
         $curRes = $it->next();  
     }      }
   
     return @resources;      return @resources;
Line 2304  new branch. The possible tokens are: Line 2241  new branch. The possible tokens are:
   
 =over 4  =over 4
   
   =item * B<END_ITERATOR>:
   
   The iterator has returned all that it's going to. Further calls to the
   iterator will just produce more of these. This is a "false" value, and
   is the only false value the iterator which will be returned, so it can
   be used as a loop sentinel.
   
 =item * B<BEGIN_MAP>:  =item * B<BEGIN_MAP>:
   
 A new map is being recursed into. This is returned I<after> the map  A new map is being recursed into. This is returned I<after> the map
Line 2334  consisting entirely of empty resources e Line 2278  consisting entirely of empty resources e
 ending resource, will cause a lot of BRANCH_STARTs and BRANCH_ENDs,  ending resource, will cause a lot of BRANCH_STARTs and BRANCH_ENDs,
 but only one resource will be returned.  but only one resource will be returned.
   
   =head2 Normal Usage
   
   Normal usage of the iterator object is to do the following:
   
    my $it = $navmap->getIterator([your params here]);
    my $curRes;
    while ($curRes = $it->next()) {
      [your logic here]
    }
   
   Note that inside of the loop, it's frequently useful to check if
   "$curRes" is a reference or not with the reference function; only
   resource objects will be references, and any non-references will 
   be the tokens described above.
   
   Also note there is some old code floating around that trys to track
   the depth of the iterator to see when it's done; do not copy that 
   code. It is difficult to get right and harder to understand then
   this. They should be migrated to this new style.
   
 =back  =back
   
 =cut  =cut
   
 # Here are the tokens for the iterator:  # Here are the tokens for the iterator:
   
   sub END_ITERATOR { return 0; }
 sub BEGIN_MAP { return 1; }    # begining of a new map  sub BEGIN_MAP { return 1; }    # begining of a new map
 sub END_MAP { return 2; }      # end of the map  sub END_MAP { return 2; }      # end of the map
 sub BEGIN_BRANCH { return 3; } # beginning of a branch  sub BEGIN_BRANCH { return 3; } # beginning of a branch
Line 2425  sub new { Line 2390  sub new {
           
         # prime the recursion          # prime the recursion
         $self->{$firstResourceName}->{DATA}->{$valName} = 0;          $self->{$firstResourceName}->{DATA}->{$valName} = 0;
         my $depth = 0;   $iterator->next();
         $iterator->next();  
         my $curRes = $iterator->next();          my $curRes = $iterator->next();
         while ($depth > -1) {   my $depth = 1;
             if ($curRes == $iterator->BEGIN_MAP()) { $depth++; }          while ($depth > 0) {
             if ($curRes == $iterator->END_MAP()) { $depth--; }      if ($curRes == $iterator->BEGIN_MAP()) { $depth++; }
               if ($curRes == $iterator->END_MAP()) { $depth--; }
   
             if (ref($curRes)) {              if (ref($curRes)) {
                 # If there's only one resource, this will save it                  # If there's only one resource, this will save it
                 # we have to filter empty resources from consideration here,                  # we have to filter empty resources from consideration here,
Line 2465  sub new { Line 2430  sub new {
                 $curRes->{DATA}->{DISPLAY_DEPTH} = $finalDepth;                  $curRes->{DATA}->{DISPLAY_DEPTH} = $finalDepth;
                 if ($finalDepth > $maxDepth) {$maxDepth = $finalDepth;}                  if ($finalDepth > $maxDepth) {$maxDepth = $finalDepth;}
             }              }
         } continue {  
             $curRes = $iterator->next();      $curRes = $iterator->next();
         }          }
     }      }
   
Line 2487  sub new { Line 2452  sub new {
     $self->{MAX_DEPTH} = $maxDepth;      $self->{MAX_DEPTH} = $maxDepth;
     $self->{STACK} = [];      $self->{STACK} = [];
     $self->{RECURSIVE_ITERATOR_FLAG} = 0;      $self->{RECURSIVE_ITERATOR_FLAG} = 0;
       $self->{FINISHED} = 0; # When true, the iterator has finished
   
     for (my $i = 0; $i <= $self->{MAX_DEPTH}; $i++) {      for (my $i = 0; $i <= $self->{MAX_DEPTH}; $i++) {
         push @{$self->{STACK}}, [];          push @{$self->{STACK}}, [];
Line 2504  sub new { Line 2470  sub new {
 sub next {  sub next {
     my $self = shift;      my $self = shift;
   
       if ($self->{FINISHED}) {
    return END_ITERATOR();
       }
   
     # If we want to return the top-level map object, and haven't yet,      # If we want to return the top-level map object, and haven't yet,
     # do so.      # do so.
     if ($self->{RETURN_0} && !$self->{HAVE_RETURNED_0}) {      if ($self->{RETURN_0} && !$self->{HAVE_RETURNED_0}) {
Line 2563  sub next { Line 2533  sub next {
             $self->{CURRENT_DEPTH}--;              $self->{CURRENT_DEPTH}--;
             return END_BRANCH();              return END_BRANCH();
         } else {          } else {
       $self->{FINISHED} = 1;
             return END_MAP();              return END_MAP();
         }          }
     }      }
Line 3059  sub symb { Line 3030  sub symb {
     my $self=shift;      my $self=shift;
     (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());
     return &Apache::lonnet::declutter(      my $symb = &Apache::lonnet::declutter($self->navHash('map_id_'.$first)) 
          $self->navHash('map_id_'.$first))   
         . '___' . $second . '___' . $symbSrc;          . '___' . $second . '___' . $symbSrc;
       return &Apache::lonnet::symbclean($symb);
 }  }
 sub title {   sub title { 
     my $self=shift;       my $self=shift; 
Line 3307  sub answerdate { Line 3278  sub answerdate {
 }  }
 sub awarded {   sub awarded { 
     my $self = shift; my $part = shift;      my $self = shift; my $part = shift;
       $self->{NAV_MAP}->get_user_data();
     if (!defined($part)) { $part = '0'; }      if (!defined($part)) { $part = '0'; }
     return $self->{NAV_MAP}->{STUDENT_DATA}->{$self->symb()}->{'resource.'.$part.'.awarded'};      return $self->{NAV_MAP}->{STUDENT_DATA}->{$self->symb()}->{'resource.'.$part.'.awarded'};
 }  }
Line 3899  sub status { Line 3871  sub status {
     # dimension and 5 entries on the other, which we want to colorize,      # dimension and 5 entries on the other, which we want to colorize,
     # plus network failure and "no date data at all".      # plus network failure and "no date data at all".
   
       #if ($self->{RESOURCE_ERROR}) { return NETWORK_FAILURE; }
     if ($completionStatus == NETWORK_FAILURE) { return NETWORK_FAILURE; }      if ($completionStatus == NETWORK_FAILURE) { return NETWORK_FAILURE; }
   
     my $suppressFeedback = lc($self->parmval("problemstatus", $part)) eq 'no';      my $suppressFeedback = lc($self->parmval("problemstatus", $part)) eq 'no';
Line 3945  sub status { Line 3918  sub status {
     if ($completionStatus == INCORRECT || $completionStatus == INCORRECT_BY_OVERRIDE) {      if ($completionStatus == INCORRECT || $completionStatus == INCORRECT_BY_OVERRIDE) {
         # 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 TRIES_LEFT;              return $suppressFeedback ? ANSWER_SUBMITTED : TRIES_LEFT;
         }          }
         return $suppressFeedback ? ANSWER_SUBMITTED : INCORRECT; # otherwise, return orange; student can't fix this          return $suppressFeedback ? ANSWER_SUBMITTED : INCORRECT; # otherwise, return orange; student can't fix this
     }      }
Removed from v.1.219  
changed lines
  Added in v.1.223

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