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

Diff for /loncom/interface/loncoursedata.pm between versions 1.2 and 1.46

version 1.2, 2002/07/17 12:38:25 version 1.46, 2003/02/13 22:52:48
Line 35  loncoursedata Line 35  loncoursedata
   
 =head1 SYNOPSIS  =head1 SYNOPSIS
   
 Set of functions that download and process student information.  Set of functions that download and process student and course information.
   
 =head1 PACKAGES USED  =head1 PACKAGES USED
   
  Apache::Constants qw(:common :http)   Apache::Constants qw(:common :http)
  Apache::lonnet()   Apache::lonnet()
    Apache::lonhtmlcommon
  HTML::TokeParser   HTML::TokeParser
  GDBM_File   GDBM_File
   
Line 51  package Apache::loncoursedata; Line 52  package Apache::loncoursedata;
 use strict;  use strict;
 use Apache::Constants qw(:common :http);  use Apache::Constants qw(:common :http);
 use Apache::lonnet();  use Apache::lonnet();
   use Apache::lonhtmlcommon;
 use HTML::TokeParser;  use HTML::TokeParser;
 use GDBM_File;  use GDBM_File;
   
Line 58  use GDBM_File; Line 60  use GDBM_File;
   
 =head1 DOWNLOAD INFORMATION  =head1 DOWNLOAD INFORMATION
   
 This section contains all the files that get data from other servers   This section contains all the functions that get data from other servers 
 and/or itself.  There is one function that has a call to get remote  and/or itself.
 information but isn't included here which is ProcessTopLevelMap.  The  
 usage was small enough to be ignored, but that portion may be moved  
 here in the future.  
   
 =cut  =cut
   
Line 70  here in the future. Line 69  here in the future.
   
 =pod  =pod
   
 =item &DownloadNamePIDSection()  =item &DownloadClasslist()
   
 Collects lastname, generation, middlename, firstname, PID, and section for each  Collects lastname, generation, middlename, firstname, PID, and section for each
 student from their environment database.  The list of students is built from  student from their environment database.  The section data is also download, though
 collecting a classlist for the course that is to be displayed.  it is in a rough format, and is processed later.  The list of students is built from
   collecting a classlist for the course that is to be displayed.  Once the classlist
   has been downloaded, its date stamp is recorded.  Unless the datestamp for the
   class database is reset or is modified, this data will not be downloaded again.  
   Also, there was talk about putting the fullname and section
   and perhaps other pieces of data into the classlist file.  This would
   reduce the number of different file accesses and reduce the amount of 
   processing on this side.
   
 =over 4  =over 4
   
 Input: $courseID, $c  Input: $courseID, $lastDownloadTime, $c
   
 $courseID:  The id of the course  $courseID:  The id of the course
   
   $lastDownloadTime:  This is the date stamp for when this information was
   last gathered.  If it is set to Not downloaded, it will gather the data
   again, though it currently does not remove the old data.
   
 $c: The connection class that can determine if the browser has aborted.  It  $c: The connection class that can determine if the browser has aborted.  It
 is used to short circuit this function so that it doesn't continue to   is used to short circuit this function so that it does not continue to 
 get information when there is no need.  get information when there is no need.
   
 Output: \%classlist  Output: \%classlist
Line 93  Output: \%classlist Line 103  Output: \%classlist
 -A list of student name:domain (as keys) (known below as $name)  -A list of student name:domain (as keys) (known below as $name)
   
 -A hash pointer for each student containing lastname, generation, firstname,  -A hash pointer for each student containing lastname, generation, firstname,
 middlename, and PID : Key is $name.'studentInformation'  middlename, and PID : Key is $name.studentInformation
   
 -A hash pointer to each students section data : Key is $name.section  -A hash pointer to each students section data : Key is $name.section
   
   -If there was an error in dump, it will be returned in the hash.  See
   the error codes for dump in lonnet.  Also, an error key will be 
   generated if an abort occurs.
   
 =back  =back
   
 =cut  =cut
   
 sub DownloadStudentNamePIDSection {  sub DownloadClasslist {
     my ($courseID, $c)=@_;      my ($courseID, $lastDownloadTime, $c)=@_;
     my ($courseDomain,$courseNumber)=split(/\_/,$courseID);      my ($courseDomain,$courseNumber)=split(/\_/,$courseID);
       my %classlist;
   
     my %classlist=&Apache::lonnet::dump('classlist',$courseDomain,      my $modifiedTime = &Apache::lonnet::GetFileTimestamp($courseDomain, $courseNumber,
                                         $courseNumber);                                                           'classlist.db', 
     my ($checkForError)=keys (%classlist);                                                           $Apache::lonnet::perlvar{'lonUsersDir'});
     if($checkForError =~ /^(con_lost|error|no_such_host)/i) {  
       # Always download the information if lastDownloadTime is set to
       # Not downloaded, otherwise it is only downloaded if the file
       # has been updated and has a more recent date stamp
       if($lastDownloadTime ne 'Not downloaded' &&
          $lastDownloadTime >= $modifiedTime && $modifiedTime >= 0) {
           # Data is not gathered so return UpToDate as true.  This
           # will be interpreted in ProcessClasslist
           $classlist{'lastDownloadTime'}=time;
           $classlist{'UpToDate'} = 'true';
         return \%classlist;          return \%classlist;
     }      }
   
       %classlist=&Apache::lonnet::dump('classlist',$courseDomain, $courseNumber);
       foreach(keys (%classlist)) {
           if(/^(con_lost|error|no_such_host)/i) {
       return;
           }
       }
   
     foreach my $name (keys(%classlist)) {      foreach my $name (keys(%classlist)) {
         if($c->aborted()) {          if(defined($c) && ($c->aborted())) {
             $classlist{'error'}='aborted';              $classlist{'error'}='aborted';
             return \%classlist;              return \%classlist;
         }          }
Line 135  sub DownloadStudentNamePIDSection { Line 166  sub DownloadStudentNamePIDSection {
   
         #Section          #Section
         my %section=&Apache::lonnet::dump('roles',$studentDomain,$studentName);          my %section=&Apache::lonnet::dump('roles',$studentDomain,$studentName);
         $classlist{$name.':section'}=\%section;          $classlist{$name.':sections'}=\%section;
     }      }
   
       $classlist{'UpToDate'} = 'false';
       $classlist{'lastDownloadTime'}=time;
   
     return \%classlist;      return \%classlist;
 }  }
   
 =pod  =pod
   
 =item &DownloadStudentCourseInformation()  =item &DownloadCourseInformation()
   
 Dump of all the course information for a single student.  There is no  Dump of all the course information for a single student.  The data can be
 pruning of data, it is all stored in a hash and returned.  pruned by making use of dumps regular expression arguement.  This function
   also takes a regular expression which it passes straight through to dump.  
   The data is no escaped, because it is done elsewhere.  It also
   checks the timestamp of the students course database file and only downloads
   if it has been modified since the last download.
   
 =over 4  =over 4
   
 Input: $name, $courseID  Input: $namedata, $courseID, $lastDownloadTime, $WhatIWant
   
 $name: student name:domain  $namedata: student name:domain
   
 $courseID:  The id of the course  $courseID:  The id of the course
   
   $lastDownloadTime:  This is the date stamp for when this information was
   last gathered.  If it is set to Not downloaded, it will gather the data
   again, though it currently does not remove the old data.
   
   $WhatIWant:  Regular expression used to get selected data with dump
   
 Output: \%courseData  Output: \%courseData
   
 \%courseData:  A hash pointer to the raw data from the student's course  \%courseData:  A hash pointer to the raw data from the students course
 database.  database.
   
 =back  =back
   
 =cut  =cut
   
 sub DownloadStudentCourseInformation {  sub DownloadCourseInformation {
     my ($name,$courseID)=@_;      my ($namedata,$courseID,$lastDownloadTime,$WhatIWant)=@_;
     my ($studentName,$studentDomain) = split(/\:/,$name);      my %courseData;
       my ($name,$domain) = split(/\:/,$namedata);
     # Download student course data  
     my %courseData=&Apache::lonnet::dump($courseID,$studentDomain,      my $modifiedTime = &Apache::lonnet::GetFileTimestamp($domain, $name,
  $studentName);                                        $courseID.'.db', 
     return \%courseData;                                        $Apache::lonnet::perlvar{'lonUsersDir'});
   
       if($lastDownloadTime ne 'Not downloaded' && 
          $lastDownloadTime >= $modifiedTime && $modifiedTime >= 0) {
           # Data is not gathered so return UpToDate as true.  This
           # will be interpreted in ProcessClasslist
           $courseData{$namedata.':lastDownloadTime'}=time;
           $courseData{$namedata.':UpToDate'} = 'true';
           return \%courseData;
       }
   
       # Download course data
       if(!defined($WhatIWant)) {
           # set the regular expression to everything by setting it to period
           $WhatIWant = '.';
       }
       %courseData=&Apache::lonnet::dump($courseID, $domain, $name, $WhatIWant);
       $courseData{'UpToDate'} = 'false';
       $courseData{'lastDownloadTime'}=time;
   
       my %newData;
       foreach (keys(%courseData)) {
           # need to have the keys to be prepended with the name:domain of the
           # student to reduce data collision later.
           $newData{$namedata.':'.$_} = $courseData{$_};
       }
   
       return \%newData;
 }  }
   
 # ----- END DOWNLOAD INFORMATION ---------------------------------------  # ----- END DOWNLOAD INFORMATION ---------------------------------------
Line 182  sub DownloadStudentCourseInformation { Line 253  sub DownloadStudentCourseInformation {
 =head1 PROCESSING FUNCTIONS  =head1 PROCESSING FUNCTIONS
   
 These functions process all the data for all the students.  Also, they  These functions process all the data for all the students.  Also, they
 are the only functions that access the cache database for writing.  Thus  are the functions that access the cache database for writing the majority of
 they are the only functions that cache data.  The downloading and caching  the time.  The downloading and caching were separated to reduce problems 
 were separated to reduce problems with stopping downloading then can't  with stopping downloading then can not tie hash to database later.
 tie hash to database later.  
   
 =cut  =cut
   
 # ----- PROCESSING FUNCTIONS ---------------------------------------  # ----- PROCESSING FUNCTIONS ---------------------------------------
   
   
   
   =pod
   
   =item &get_sequence_assessment_data()
   
   AT THIS TIME THE USE OF THIS FUNCTION IS *NOT* RECOMMENDED
   
   Use lonnavmaps to build a data structure describing the order and 
   assessment contents of each sequence in the current course.
   
   The returned structure is a hash reference. 
   
   { title  => 'title',
     symb   => 'symb',
     source => '/s/o/u/r/c/e',
     type  => (container|assessment),
     contents     => [ {},{},{},{} ], # only for container
     parts        => [11,13,15],      # only for assessment
     response_ids => [12,14,16]       # only for assessment
   }
   
   $hash->{'contents'} is a reference to an array of hashes of the same structure.
   
   =cut
   
   sub get_sequence_assessment_data {
       return undef;
       my $fn=$ENV{'request.course.fn'};
       &Apache::lonnet::logthis('filename = '.$fn);
       ##
       ## use navmaps
       my $navmap = Apache::lonnavmaps::navmap->new($fn.".db",$fn."_parms.db",
                                                    1,0);
       if (!defined($navmap)) {
           return 'Can not open Coursemap';
       }
       my $iterator = $navmap->getIterator(undef, undef, undef, 1);
       ##
       ## Prime the pump 
       ## 
       ## We are going to loop until we run out of sequences/pages to explore for
       ## resources.  This means we have to start out with something to look
       ## at.
       my $curRes = $iterator->next(); # BEGIN_MAP
       $curRes = $iterator->next(); # The sequence itself
       #
       my $title = $curRes->title();
       my $symb  = $curRes->symb();
       my $src   = $curRes->src();
       #
       my @Nested_Sequences = ();   # Stack of sequences, keeps track of depth
       my $top = { title    => $title,
                   symb     => $symb,
                   type     => 'container',
                   num_assess => 0,
                   contents   => [], };
       push (@Nested_Sequences, $top);
       #
       # We need to keep track of which sequences contain homework problems
       # 
       while (scalar(@Nested_Sequences)) {
           $curRes = $iterator->next();
           my $currentmap = $Nested_Sequences[-1]; # Last one on the stack
           if ($curRes == $iterator->BEGIN_MAP()) {
               # get the map itself, instead of BEGIN_MAP
               $curRes = $iterator->next(); 
               $title = $curRes->title();
               $symb  = $curRes->symb();
               $src   = $curRes->src();
               my $newmap = { title    => $title,
                              src      => $src,
                              symb     => $symb,
                              type     => 'container',
                              num_assess => 0,
                              contents   => [],
                          };
               push (@{$currentmap->{'contents'}},$newmap); # this is permanent
               push (@Nested_Sequences, $newmap); # this is a stack
               next;
           }
           if ($curRes == $iterator->END_MAP()) {
               pop(@Nested_Sequences);
               next;
           }
           next if (! ref($curRes));
           next if (! $curRes->is_problem() && !$curRes->randomout);
           # Okay, from here on out we only deal with assessments
           $title = $curRes->title();
           $symb  = $curRes->symb();
           $src   = $curRes->src();
           my $parts = $curRes->parts();
           my $assessment = { title => $title,
                              src   => $src,
                              symb  => $symb,
                              type  => 'assessment',
                          };
           push(@{$currentmap->{'contents'}},$assessment);
           $currentmap->{'num_assess'}++;
       }
       return $top;
   }
   
 =pod  =pod
   
 =item &ProcessTopResourceMap()  =item &ProcessTopResourceMap()
Line 227  sub ProcessTopResourceMap { Line 400  sub ProcessTopResourceMap {
             if($c->aborted()) {              if($c->aborted()) {
                 return;                  return;
             }              }
     if(tie(%hash,'GDBM_File',"$fn.db",&GDBM_READER,0640)) {      if(tie(%hash,'GDBM_File',"$fn.db",&GDBM_READER(),0640)) {
  last;   last;
     }      }
     $tieTries++;      $tieTries++;
Line 240  sub ProcessTopResourceMap { Line 413  sub ProcessTopResourceMap {
         return 'Can not open Coursemap.';          return 'Can not open Coursemap.';
     }      }
   
       my $oldkeys;
       delete $cache->{'OptionResponses'};
       if(defined($cache->{'ResourceKeys'})) {
           $oldkeys = $cache->{'ResourceKeys'};
           foreach (split(':::', $cache->{'ResourceKeys'})) {
               delete $cache->{$_};
           }
           delete $cache->{'ResourceKeys'};
       }
   
     # Initialize state machine.  Set information pointing to top level map.      # Initialize state machine.  Set information pointing to top level map.
     my (@sequences, @currentResource, @finishResource);      my (@sequences, @currentResource, @finishResource);
     my ($currentSequence, $currentResourceID, $lastResourceID);      my ($currentSequence, $currentResourceID, $lastResourceID);
   
     $currentResourceID=$hash{'ids_/res/'.$ENV{'request.course.uri'}};      $currentResourceID=$hash{'ids_'.
         &Apache::lonnet::clutter($ENV{'request.course.uri'})};
     push(@currentResource, $currentResourceID);      push(@currentResource, $currentResourceID);
     $lastResourceID=-1;      $lastResourceID=-1;
     $currentSequence=-1;      $currentSequence=-1;
     my $topLevelSequenceNumber = $currentSequence;      my $topLevelSequenceNumber = $currentSequence;
   
       my %sequenceRecord;
       my %allkeys;
     while(1) {      while(1) {
         if($c->aborted()) {          if($c->aborted()) {
             last;              last;
         }          }
  # HANDLE NEW SEQUENCE!   # HANDLE NEW SEQUENCE!
  #if page || sequence   #if page || sequence
  if(defined($hash{'map_pc_'.$hash{'src_'.$currentResourceID}})) {   if(defined($hash{'map_pc_'.$hash{'src_'.$currentResourceID}}) &&
              !defined($sequenceRecord{$currentResourceID})) {
               $sequenceRecord{$currentResourceID}++;
     push(@sequences, $currentSequence);      push(@sequences, $currentSequence);
     push(@currentResource, $currentResourceID);      push(@currentResource, $currentResourceID);
     push(@finishResource, $lastResourceID);      push(@finishResource, $lastResourceID);
Line 272  sub ProcessTopResourceMap { Line 460  sub ProcessTopResourceMap {
             } else {              } else {
                 $cache->{'orderedSequences'}.=':'.$currentSequence;                  $cache->{'orderedSequences'}.=':'.$currentSequence;
             }              }
               $allkeys{'orderedSequences'}++;
   
     $lastResourceID=$hash{'map_finish_'.      $lastResourceID=$hash{'map_finish_'.
   $hash{'src_'.$currentResourceID}};    $hash{'src_'.$currentResourceID}};
Line 286  sub ProcessTopResourceMap { Line 475  sub ProcessTopResourceMap {
     last;      last;
  }   }
     }      }
               next;
  }   }
   
  # Handle gradable resources: exams, problems, etc   # Handle gradable resources: exams, problems, etc
Line 294  sub ProcessTopResourceMap { Line 484  sub ProcessTopResourceMap {
         my $partB=$2;          my $partB=$2;
  if($hash{'src_'.$currentResourceID}=~   if($hash{'src_'.$currentResourceID}=~
    /\.(problem|exam|quiz|assess|survey|form)$/ &&     /\.(problem|exam|quiz|assess|survey|form)$/ &&
    $partA eq $currentSequence) {     $partA eq $currentSequence && 
              !defined($sequenceRecord{$currentSequence.':'.
                                       $currentResourceID})) {
               $sequenceRecord{$currentSequence.':'.$currentResourceID}++;
     my $Problem = &Apache::lonnet::symbclean(      my $Problem = &Apache::lonnet::symbclean(
   &Apache::lonnet::declutter($hash{'map_id_'.$partA}).    &Apache::lonnet::declutter($hash{'map_id_'.$partA}).
   '___'.$partB.'___'.    '___'.$partB.'___'.
Line 302  sub ProcessTopResourceMap { Line 495  sub ProcessTopResourceMap {
  $currentResourceID}));   $currentResourceID}));
   
     $cache->{$currentResourceID.':problem'}=$Problem;      $cache->{$currentResourceID.':problem'}=$Problem;
               $allkeys{$currentResourceID.':problem'}++;
     if(!defined($cache->{$currentSequence.':problems'})) {      if(!defined($cache->{$currentSequence.':problems'})) {
  $cache->{$currentSequence.':problems'}=$currentResourceID;   $cache->{$currentSequence.':problems'}=$currentResourceID;
     } else {      } else {
  $cache->{$currentSequence.':problems'}.=   $cache->{$currentSequence.':problems'}.=
     ':'.$currentResourceID;      ':'.$currentResourceID;
     }      }
               $allkeys{$currentSequence.':problems'}++;
   
     my $meta=$hash{'src_'.$currentResourceID};      my $meta=$hash{'src_'.$currentResourceID};
 #            $cache->{$currentResourceID.':title'}=  #            $cache->{$currentResourceID.':title'}=
 #                &Apache::lonnet::metdata($meta,'title');  #                &Apache::lonnet::metdata($meta,'title');
             $cache->{$currentResourceID.':title'}=              $cache->{$currentResourceID.':title'}=
                 $hash{'title_'.$currentResourceID};                  $hash{'title_'.$currentResourceID};
               $allkeys{$currentResourceID.':title'}++;
               $cache->{$currentResourceID.':source'}=
                   $hash{'src_'.$currentResourceID};
               $allkeys{$currentResourceID.':source'}++;
   
             # Get Parts for problem              # Get Parts for problem
     foreach (split(/\,/,&Apache::lonnet::metadata($meta,'keys'))) {              my %beenHere;
  if($_=~/^stores\_(\d+)\_tries$/) {              foreach (split(/\,/,&Apache::lonnet::metadata($meta,'packages'))) {
     my $Part=&Apache::lonnet::metadata($meta,$_.'.part');                  if(/^\w+response_\d+.*/) {
                     if(!defined($cache->{$currentSequence.':'.                      my (undef, $partId, $responseId) = split(/_/,$_);
                                           $currentResourceID.':parts'})) {                      if($beenHere{'p:'.$partId} ==  0) {
                         $cache->{$currentSequence.':'.$currentResourceID.                          $beenHere{'p:'.$partId}++;
                                    ':parts'}=$Part;                          if(!defined($cache->{$currentSequence.':'.
                     } else {                                              $currentResourceID.':parts'})) {
                         $cache->{$currentSequence.':'.$currentResourceID.                              $cache->{$currentSequence.':'.$currentResourceID.
                                    ':parts'}.=':'.$Part;                                       ':parts'}=$partId;
                           } else {
                               $cache->{$currentSequence.':'.$currentResourceID.
                                        ':parts'}.=':'.$partId;
                           }
                           $allkeys{$currentSequence.':'.$currentResourceID.
                                     ':parts'}++;
                       }
                       if($beenHere{'r:'.$partId.':'.$responseId} == 0) {
                           $beenHere{'r:'.$partId.':'.$responseId}++;
                           if(!defined($cache->{$currentSequence.':'.
                                                $currentResourceID.':'.$partId.
                                                ':responseIDs'})) {
                               $cache->{$currentSequence.':'.$currentResourceID.
                                        ':'.$partId.':responseIDs'}=$responseId;
                           } else {
                               $cache->{$currentSequence.':'.$currentResourceID.
                                        ':'.$partId.':responseIDs'}.=':'.
                                                                     $responseId;
                           }
                           $allkeys{$currentSequence.':'.$currentResourceID.':'.
                                        $partId.':responseIDs'}++;
                     }                      }
                     foreach (split(/\,/,                      if(/^optionresponse/ && 
                              &Apache::lonnet::metadata($meta,'packages'))) {                         $beenHere{'o:'.$partId.':'.$currentResourceID} == 0) {
                         if($_=~/^optionresponse\_($Part)\_(\w+)$/) {                          $beenHere{'o:'.$partId.$currentResourceID}++;
                             if(defined($cache->{'OptionResponses'})) {                          if(defined($cache->{'OptionResponses'})) {
                                 $cache->{'OptionResponses'}.= ':::'.                              $cache->{'OptionResponses'}.= ':::'.
                                     $hash{'src_'.$currentResourceID}.'::'.                                  $currentSequence.':'.$currentResourceID.':'.
                                     $hash{'title_'.$currentResourceID}.'::'.                                  $partId.':'.$responseId;
                                     $Part.'::'.$Problem;                          } else {
                             } else {                              $cache->{'OptionResponses'}= $currentSequence.':'.
                                 $cache->{'OptionResponses'}=                                  $currentResourceID.':'.
                                     $hash{'src_'.$currentResourceID}.'::'.                                  $partId.':'.$responseId;
                                     $hash{'title_'.$currentResourceID}.'::'.  
                                     $Part.'::'.$Problem;  
                             }  
                         }                          }
                           $allkeys{'OptionResponses'}++;
                     }                      }
                 }                  }
     }              }
  }          }
   
  # if resource == finish resource, then it is the end of a sequence/page   # if resource == finish resource, then it is the end of a sequence/page
  if($currentResourceID eq $lastResourceID) {   if($currentResourceID eq $lastResourceID) {
Line 357  sub ProcessTopResourceMap { Line 575  sub ProcessTopResourceMap {
  # Capture sequence information here   # Capture sequence information here
  $cache->{$currentSequence.':title'}=   $cache->{$currentSequence.':title'}=
     $hash{'title_'.$currentResourceID};      $hash{'title_'.$currentResourceID};
                   $allkeys{$currentSequence.':title'}++;
                 $cache->{$currentSequence.':source'}=                  $cache->{$currentSequence.':source'}=
                     $hash{'src_'.$currentResourceID};                      $hash{'src_'.$currentResourceID};
                   $allkeys{$currentSequence.':source'}++;
   
                 my $totalProblems=0;                  my $totalProblems=0;
                 foreach my $currentProblem (split(/\:/,                  foreach my $currentProblem (split(/\:/,
Line 372  sub ProcessTopResourceMap { Line 592  sub ProcessTopResourceMap {
                 }                  }
  my @titleLength=split(//,$cache->{$currentSequence.   my @titleLength=split(//,$cache->{$currentSequence.
                                                     ':title'});                                                      ':title'});
                 # $extra is 3 for problems correct and 3 for space                  # $extra is 5 for problems correct and 3 for space
                 # between problems correct and problem output                  # between problems correct and problem output
                 my $extra = 6;                  my $extra = 8;
  if(($totalProblems + $extra) > (scalar @titleLength)) {   if(($totalProblems + $extra) > (scalar @titleLength)) {
     $cache->{$currentSequence.':columnWidth'}=      $cache->{$currentSequence.':columnWidth'}=
                         $totalProblems + $extra;                          $totalProblems + $extra;
Line 382  sub ProcessTopResourceMap { Line 602  sub ProcessTopResourceMap {
     $cache->{$currentSequence.':columnWidth'}=      $cache->{$currentSequence.':columnWidth'}=
                         (scalar @titleLength);                          (scalar @titleLength);
  }   }
                   $allkeys{$currentSequence.':columnWidth'}++;
     } else {      } else {
                 # Remove sequence from list, if it contains no problems to                  # Remove sequence from list, if it contains no problems to
                 # display.                  # display.
Line 394  sub ProcessTopResourceMap { Line 615  sub ProcessTopResourceMap {
     if($currentSequence eq $topLevelSequenceNumber) {      if($currentSequence eq $topLevelSequenceNumber) {
  last;   last;
     }      }
  }          }
   
  # MOVE!!!   # MOVE!!!
  # move to next resource   # move to next resource
  unless(defined($hash{'to_'.$currentResourceID})) {   unless(defined($hash{'to_'.$currentResourceID})) {
     # big problem, need to handle.  Next is probably wrong      # big problem, need to handle.  Next is probably wrong
     last;              my $errorMessage = 'Big problem in ';
               $errorMessage .= 'loncoursedata::ProcessTopLevelMap.';
               $errorMessage .= "  bighash to_$currentResourceID not defined!";
               &Apache::lonnet::logthis($errorMessage);
       if (!defined($currentResourceID)) {last;}
  }   }
  my @nextResources=();   my @nextResources=();
  foreach (split(/\,/,$hash{'to_'.$currentResourceID})) {   foreach (split(/\,/,$hash{'to_'.$currentResourceID})) {
     push(@nextResources, $hash{'goesto_'.$_});              if(!defined($sequenceRecord{$currentSequence.':'.
                                           $hash{'goesto_'.$_}})) {
                   push(@nextResources, $hash{'goesto_'.$_});
               }
  }   }
  push(@currentResource, @nextResources);   push(@currentResource, @nextResources);
  # Set the next resource to be processed   # Set the next resource to be processed
  $currentResourceID=pop(@currentResource);   $currentResourceID=pop(@currentResource);
     }      }
   
       my @theKeys = keys(%allkeys);
       my $newkeys = join(':::', @theKeys);
       $cache->{'ResourceKeys'} = join(':::', $newkeys);
       if($newkeys ne $oldkeys) {
           $cache->{'ResourceUpdated'} = 'true';
       } else {
           $cache->{'ResourceUpdated'} = 'false';
       }
   
     unless (untie(%hash)) {      unless (untie(%hash)) {
         &Apache::lonnet::logthis("<font color=blue>WARNING: ".          &Apache::lonnet::logthis("<font color=blue>WARNING: ".
                                  "Could not untie coursemap $fn (browse)".                                   "Could not untie coursemap $fn (browse)".
Line 422  sub ProcessTopResourceMap { Line 659  sub ProcessTopResourceMap {
   
 =pod  =pod
   
 =item &ProcessSection()  =item &ProcessClasslist()
   
   Taking the class list dumped from &DownloadClasslist(), all the 
   students and their non-class information is processed using the 
   &ProcessStudentInformation() function.  A date stamp is also recorded for
   when the data was processed.
   
 Determine the section number for a student for the class.  A student can have   Takes data downloaded for a student and breaks it up into managable pieces and 
 multiple sections for the same class.  The correct one is chosen.  stored in cache data.  The username, domain, class related date, PID, 
   full name, and section are all processed here.
   
 =over 4  =over 4
   
 Input: $sectionData, $courseid, $ActiveFlag  Input: $cache, $classlist, $courseID, $ChartDB, $c
   
 $sectionData:  A pointer to a hash containing all section data for this   $cache: A hash pointer to store the data
 student for the class  
   
 $courseid:  The course ID.  $classlist:  The hash of data collected about a student from 
   &DownloadClasslist().  The hash contains a list of students, a pointer 
   to a hash of student information for each student, and each students section 
   number.
   
 $ActiveFlag:  The student's active status (Active/Expired)  $courseID:  The course ID
   
 Output: $oldsection, $cursection, or -1  $ChartDB:  The name of the cache database file.
   
   $c:  The connection class used to determine if an abort has been sent to the 
   browser
   
 $oldsection and $cursection and sections number that will be displayed in the   Output: @names
 chart.  
   
 -1 is returned if an error occurs.  @names:  An array of students whose information has been processed, and are to 
   be considered in an arbitrary order.  The entries in @names are of the form
   username:domain.
   
   The values in $cache are as follows:
   
    *NOTE: for the following $name implies username:domain
    $name.':error'                  only defined if an error occured.  Value
                                    contains the error message
    $name.':lastDownloadTime'       unconverted time of the last update of a
                                    student\'s course data
    $name.'updateTime'              coverted time of the last update of a 
                                    student\'s course data
    $name.':username'               username of a student
    $name.':domain'                 domain of a student
    $name.':fullname'               full name of a student
    $name.':id'                     PID of a student
    $name.':Status'                 active/expired status of a student
    $name.':section'                section of a student
   
 =back  =back
   
 =cut  =cut
   
 sub ProcessSection {  sub ProcessClasslist {
     my ($sectionData,$courseid,$ActiveFlag)=@_;      my ($cache,$classlist,$courseID,$c)=@_;
     $courseid=~s/\_/\//g;      my @names=();
     $courseid=~s/^(\w)/\/$1/;  
   
     my $cursection='-1';  
     my $oldsection='-1';  
     my $status='Expired';  
     my $section='';  
     foreach my $key (keys (%$sectionData)) {  
  my $value = $sectionData->{$key};  
         if ($key=~/^$courseid(?:\/)*(\w+)*\_st$/) {  
     $section=$1;  
     if($key eq $courseid.'_st') {  
  $section='';  
     }  
   
     my ($dummy,$end,$start)=split(/\_/,$value);      $cache->{'ClasslistTimeStamp'}=$classlist->{'lastDownloadTime'};
     my $now=time;      if($classlist->{'UpToDate'} eq 'true') {
             my $notactive=0;          return split(/:::/,$cache->{'NamesOfStudents'});;
             if ($start) {      }
                 if($now<$start) {  
                     $notactive=1;      foreach my $name (keys(%$classlist)) {
                 }          if($name =~ /\:section/ || $name =~ /\:studentInformation/ ||
             }             $name eq '' || $name eq 'UpToDate' || $name eq 'lastDownloadTime') {
             if($end) {              next;
                 if ($now>$end) {          }
                     $notactive=1;          if($c->aborted()) {
                 }              return ();
             }          }
             if($notactive == 0) {          my $studentInformation = $classlist->{$name.':studentInformation'};
                 $status='Active';          my $date = $classlist->{$name};
                 $cursection=$section;          my ($studentName,$studentDomain) = split(/\:/,$name);
                 last;  
           $cache->{$name.':username'}=$studentName;
           $cache->{$name.':domain'}=$studentDomain;
           # Initialize timestamp for student
           if(!defined($cache->{$name.':lastDownloadTime'})) {
               $cache->{$name.':lastDownloadTime'}='Not downloaded';
               $cache->{$name.':updateTime'}=' Not updated';
           }
   
           my $error = 0;
           foreach(keys(%$studentInformation)) {
               if(/^(con_lost|error|no_such_host)/i) {
                   $cache->{$name.':error'}=
                       'Could not download student environment data.';
                   $cache->{$name.':fullname'}='';
                   $cache->{$name.':id'}='';
                   $error = 1;
             }              }
             if($notactive == 1) {          }
                 $oldsection=$section;          next if($error);
           push(@names,$name);
           $cache->{$name.':fullname'}=&ProcessFullName(
                                             $studentInformation->{'lastname'},
                                             $studentInformation->{'generation'},
                                             $studentInformation->{'firstname'},
                                             $studentInformation->{'middlename'});
           $cache->{$name.':id'}=$studentInformation->{'id'};
   
           my ($end, $start)=split(':',$date);
           $courseID=~s/\_/\//g;
           $courseID=~s/^(\w)/\/$1/;
   
           my $sec='';
           my $sectionData = $classlist->{$name.':sections'};
           foreach my $key (keys (%$sectionData)) {
               my $value = $sectionData->{$key};
               if ($key=~/^$courseID(?:\/)*(\w+)*\_st$/) {
                   my $tempsection=$1;
                   if($key eq $courseID.'_st') {
                       $tempsection='';
                   }
                   my (undef,$roleend,$rolestart)=split(/\_/,$value);
                   if($roleend eq $end && $rolestart eq $start) {
                       $sec = $tempsection;
                       last;
                   }
             }              }
  }  
     }  
     if($status eq $ActiveFlag) {  
         if($cursection eq '-1') {  
             return $oldsection;  
         }          }
         return $cursection;  
     }          my $status='Expired';
     if($ActiveFlag eq 'Any') {          if(((!$end) || time < $end) && ((!$start) || (time > $start))) {
         if($cursection eq '-1') {              $status='Active';
             return $oldsection;          }
           $cache->{$name.':Status'}=$status;
           $cache->{$name.':section'}=$sec;
   
           if($sec eq '' || !defined($sec) || $sec eq ' ') {
               $sec = 'none';
           }
           if(defined($cache->{'sectionList'})) {
               if($cache->{'sectionList'} !~ /(^$sec:|^$sec$|:$sec$|:$sec:)/) {
                   $cache->{'sectionList'} .= ':'.$sec;
               }
           } else {
               $cache->{'sectionList'} = $sec;
         }          }
         return $cursection;  
     }      }
     return '-1';  
       $cache->{'ClasslistTimestamp'}=time;
       $cache->{'NamesOfStudents'}=join(':::',@names);
   
       return @names;
 }  }
   
 =pod  =pod
   
 =item &ProcessNamePIDSection()  =item &ProcessStudentData()
   
 Takes data downloaded for a student and breaks it up into managable pieces and   Takes the course data downloaded for a student in 
 stored in cache data.  The username, domain, class related date, PID,   &DownloadCourseInformation() and breaks it up into key value pairs
 full name, and section are all processed here.  to be stored in the cached data.  The keys are comprised of the 
   $username:$domain:$keyFromCourseDatabase.  The student username:domain is
   stored away signifying that the students information has been downloaded and 
   can be reused from cached data.
   
 =over 4  =over 4
   
 Input: $cache, $studentInformation, $section, $date, $name, $courseID  Input: $cache, $courseData, $name
   
 $cache:  A hash pointer to store the data  
   
 $studentInformation:  Student information is what was requested in   
 &DownloadPrerequistedData().  See that function for what data is requested.  
   
 $section: A hash pointer to class section related information.  
   
 $date:  A composite of the start and end date for this class for this  $cache: A hash pointer to store data
 student.  Format:  end:start  
   
 $name:  the username:domain information  $courseData:  A hash pointer that points to the course data downloaded for a 
   student.
   
 $courseID: The course ID  $name:  username:domain
   
 Output: None  Output: None
   
 *NOTE:  There is no return value, but if an error occurs a key is added to   *NOTE:  There is no output, but an error message is stored away in the cache 
 the cache data with the value being the error message.  The key is   data.  This is checked in &FormatStudentData().  The key username:domain:error 
 username:domain:error.  It will only exist if an error occurs.  will only exist if an error occured.  The error is an error from 
   &DownloadCourseInformation().
   
 =back  =back
   
 =cut  =cut
   
 sub ProcessStudentNamePIDSection {  sub ProcessStudentData {
     my ($cache,$studentInformation,$section,$date,$name,$courseID,$status)=@_;      my ($cache,$courseData,$name)=@_;
     my ($studentName,$studentDomain) = split(/\:/,$name);  
       if(!&CheckDateStampError($courseData, $cache, $name)) {
     $cache->{$name.':username'}=$studentName;          return;
     $cache->{$name.':domain'}=$studentDomain;  
     $cache->{$name.':date'}=$date;  
   
     my ($checkForError)=keys(%$studentInformation);  
     if($checkForError =~ /^(con_lost|error|no_such_host)/i) {  
  $cache->{$name.':error'}=  
     'Could not download student environment data.';  
  $cache->{$name.':fullname'}='';  
  $cache->{$name.':id'}='';  
     } else {  
  $cache->{$name.':fullname'}=&ProcessFullName(  
                                           $studentInformation->{'lastname'},  
           $studentInformation->{'generation'},  
           $studentInformation->{'firstname'},  
                                           $studentInformation->{'middlename'});  
  $cache->{$name.':id'}=$studentInformation->{'id'};  
     }      }
   
     my $sec=&ProcessSection($section, $courseID, $status);      # This little delete thing, should not be here.  Move some other
     if($sec != -1) {      # time though.
         $cache->{$name.':section'}=$sec;      if(defined($cache->{$name.':keys'})) {
     } else {   foreach (split(':::', $cache->{$name.':keys'})) {
         $cache->{$name.':section'}='';      delete $cache->{$name.':'.$_};
    }
           delete $cache->{$name.':keys'};
       }
   
       my %courseKeys;
       # user name:domain was prepended earlier in DownloadCourseInformation
       foreach (keys %$courseData) {
    my $currentKey = $_;
    $currentKey =~ s/^$name//;
    $courseKeys{$currentKey}++;
           $cache->{$_}=$courseData->{$_};
     }      }
   
       $cache->{$name.':keys'} = join(':::', keys(%courseKeys));
   
     return;      return;
 }  }
   
 =pod  =pod
   
 =item &ProcessClassList()  =item &ExtractStudentData()
   
 Taking the class list dumped from &DownloadPrerequisiteData(), all the   HISTORY: This function originally existed in every statistics module,
 students and their non-class information is processed using the   and performed different tasks, the had some overlap.  Due to the need
 &ProcessStudentInformation() function.  A date stamp is also recorded for  for the data from the different modules, they were combined into
 when the data was processed.  a single function.
   
   This function now extracts all the necessary course data for a student
   from what was downloaded from their homeserver.  There is some extra
   time overhead compared to the ProcessStudentInformation function, but
   it would have had to occurred at some point anyways.  This is now
   typically called while downloading the data it will process.  It is
   the brother function to ProcessStudentInformation.
   
 =over 4  =over 4
   
 Input: $cache, $classlist, $courseID, $ChartDB, $c  Input: $input, $output, $data, $name
   
 $cache: A hash pointer to store the data  $input: A hash that contains the input data to be processed
   
 $classlist:  The hash of data collected about a student from   $output: A hash to contain the processed data
 &DownloadPrerequisteData().  The hash contains a list of students, a pointer   
 to a hash of student information for each student, and each student's section   
 number.  
   
 $courseID:  The course ID  $data: A hash containing the information on what is to be
   processed and how (basically).
   
 $ChartDB:  The name of the cache database file.  $name:  username:domain
   
 $c:  The connection class used to determine if an abort has been sent to the   The input is slightly different here, but is quite simple.
 browser  It is currently used where the $input, $output, and $data
   can and are often the same hashes, but they do not need
   to be.
   
 Output: @names  Output: None
   
 @names:  An array of students whose information has been processed, and are to   *NOTE:  There is no output, but an error message is stored away in the cache 
 be considered in an arbitrary order.  data.  This is checked in &FormatStudentData().  The key username:domain:error 
   will only exist if an error occured.  The error is an error from 
   &DownloadCourseInformation().
   
 =back  =back
   
 =cut  =cut
   
 sub ProcessClassList {  sub ExtractStudentData {
     my ($cache,$classlist,$courseID,$status,$c)=@_;      my ($input, $output, $data, $name)=@_;
     my @names=();  
   
     foreach my $name (keys(%$classlist)) {      if(!&CheckDateStampError($input, $data, $name)) {
         if($name =~ /\:section/ || $name =~ /\:studentInformation/ ||          return;
            $name eq '') {  
             next;  
         }  
         if($c->aborted()) {  
             last;  
         }  
         push(@names,$name);  
         &ProcessStudentNamePIDSection($cache,  
                                      $classlist->{$name.':studentInformation'},  
                                      $classlist->{$name.':section'},  
                                      $classlist->{$name},  
                                      $name,$courseID,$status);  
     }      }
   
     # Time of download      # This little delete thing, should not be here.  Move some other
     $cache->{'time'}=localtime();      # time though.
       my %allkeys;
     return @names;      if(defined($output->{$name.':keys'})) {
 }   foreach (split(':::', $output->{$name.':keys'})) {
       delete $output->{$name.':'.$_};
    }
           delete $output->{$name.':keys'};
       }
   
 =pod      my ($username,$domain)=split(':',$name);
   
 =item &ProcessStudentData()      my $Version;
       my $problemsCorrect = 0;
       my $totalProblems   = 0;
       my $problemsSolved  = 0;
       my $numberOfParts   = 0;
       my $totalAwarded    = 0;
       foreach my $sequence (split(':', $data->{'orderedSequences'})) {
           foreach my $problemID (split(':', $data->{$sequence.':problems'})) {
               my $problem = $data->{$problemID.':problem'};
               my $LatestVersion = $input->{$name.':version:'.$problem};
   
               # Output dashes for all the parts of this problem if there
               # is no version information about the current problem.
               $output->{$name.':'.$problemID.':NoVersion'} = 'false';
               $allkeys{$name.':'.$problemID.':NoVersion'}++;
               if(!$LatestVersion) {
                   foreach my $part (split(/\:/,$data->{$sequence.':'.
                                                         $problemID.
                                                         ':parts'})) {
                       $output->{$name.':'.$problemID.':'.$part.':tries'} = 0;
                       $output->{$name.':'.$problemID.':'.$part.':awarded'} = 0;
                       $output->{$name.':'.$problemID.':'.$part.':code'} = ' ';
       $allkeys{$name.':'.$problemID.':'.$part.':tries'}++;
       $allkeys{$name.':'.$problemID.':'.$part.':awarded'}++;
       $allkeys{$name.':'.$problemID.':'.$part.':code'}++;
                       $totalProblems++;
                   }
                   $output->{$name.':'.$problemID.':NoVersion'} = 'true';
                   next;
               }
   
 Takes the course data downloaded for a student in               my %partData=undef;
 &DownloadStudentCourseInformation() and breaks it up into key value pairs              # Initialize part data, display skips correctly
 to be stored in the cached data.  The keys are comprised of the               # Skip refers to when a student made no submissions on that
 $username:$domain:$keyFromCourseDatabase.  The student username:domain is              # part/problem.
 stored away signifying that the student's information has been downloaded and               foreach my $part (split(/\:/,$data->{$sequence.':'.
 can be reused from cached data.                                                   $problemID.
                                                    ':parts'})) {
                   $partData{$part.':tries'}=0;
                   $partData{$part.':code'}=' ';
                   $partData{$part.':awarded'}=0;
                   $partData{$part.':timestamp'}=0;
                   foreach my $response (split(':', $data->{$sequence.':'.
                                                            $problemID.':'.
                                                            $part.':responseIDs'})) {
                       $partData{$part.':'.$response.':submission'}='';
                   }
               }
   
 =over 4              # Looping through all the versions of each part, starting with the
               # oldest version.  Basically, it gets the most recent 
               # set of grade data for each part.
               my @submissions = ();
       for(my $Version=1; $Version<=$LatestVersion; $Version++) {
                   foreach my $part (split(/\:/,$data->{$sequence.':'.
                                                        $problemID.
                                                        ':parts'})) {
   
                       if(!defined($input->{"$name:$Version:$problem".
                                            ":resource.$part.solved"})) {
                           # No grade for this submission, so skip
                           next;
                       }
   
 Input: $cache, $courseData, $name                      my $tries=0;
                       my $code=' ';
                       my $awarded=0;
   
                       $tries = $input->{$name.':'.$Version.':'.$problem.
                                         ':resource.'.$part.'.tries'};
                       $awarded = $input->{$name.':'.$Version.':'.$problem.
                                           ':resource.'.$part.'.awarded'};
   
                       $partData{$part.':awarded'}=($awarded) ? $awarded : 0;
                       $partData{$part.':tries'}=($tries) ? $tries : 0;
   
                       $partData{$part.':timestamp'}=$input->{$name.':'.$Version.':'.
                                                              $problem.
                                                              ':timestamp'};
                       if(!$input->{$name.':'.$Version.':'.$problem.':resource.'.$part.
                                    '.previous'}) {
                           foreach my $response (split(':',
                                                      $data->{$sequence.':'.
                                                              $problemID.':'.
                                                              $part.':responseIDs'})) {
                               @submissions=($input->{$name.':'.$Version.':'.
                                                      $problem.
                                                      ':resource.'.$part.'.'.
                                                      $response.'.submission'},
                                             @submissions);
                           }
                       }
   
 $cache: A hash pointer to store data                      my $val = $input->{$name.':'.$Version.':'.$problem.
                                          ':resource.'.$part.'.solved'};
                       if    ($val eq 'correct_by_student')   {$code = '*';} 
                       elsif ($val eq 'correct_by_override')  {$code = '+';}
                       elsif ($val eq 'incorrect_attempted')  {$code = '.';} 
                       elsif ($val eq 'incorrect_by_override'){$code = '-';}
                       elsif ($val eq 'excused')              {$code = 'x';}
                       elsif ($val eq 'ungraded_attempted')   {$code = '#';}
                       else                                   {$code = ' ';}
                       $partData{$part.':code'}=$code;
                   }
               }
   
 $courseData:  A hash pointer that points to the course data downloaded for a               foreach my $part (split(/\:/,$data->{$sequence.':'.$problemID.
 student.                                                   ':parts'})) {
                   $output->{$name.':'.$problemID.':'.$part.':wrong'} = 
                       $partData{$part.':tries'};
    $allkeys{$name.':'.$problemID.':'.$part.':wrong'}++;
   
                   if($partData{$part.':code'} eq '*') {
                       $output->{$name.':'.$problemID.':'.$part.':wrong'}--;
                       $problemsCorrect++;
                   } elsif($partData{$part.':code'} eq '+') {
                       $output->{$name.':'.$problemID.':'.$part.':wrong'}--;
                       $problemsCorrect++;
                   }
   
 $name:  username:domain                  $output->{$name.':'.$problemID.':'.$part.':tries'} = 
                       $partData{$part.':tries'};
                   $output->{$name.':'.$problemID.':'.$part.':code'} =
                       $partData{$part.':code'};
                   $output->{$name.':'.$problemID.':'.$part.':awarded'} =
                       $partData{$part.':awarded'};
    $allkeys{$name.':'.$problemID.':'.$part.':tries'}++;
    $allkeys{$name.':'.$problemID.':'.$part.':code'}++;
    $allkeys{$name.':'.$problemID.':'.$part.':awarded'}++;
   
                   $totalAwarded += $partData{$part.':awarded'};
                   $output->{$name.':'.$problemID.':'.$part.':timestamp'} =
                       $partData{$part.':timestamp'};
    $allkeys{$name.':'.$problemID.':'.$part.':timestamp'}++;
   
                   foreach my $response (split(':', $data->{$sequence.':'.
                                                            $problemID.':'.
                                                            $part.':responseIDs'})) {
                       $output->{$name.':'.$problemID.':'.$part.':'.$response.
                                 ':submission'}=join(':::',@submissions);
       $allkeys{$name.':'.$problemID.':'.$part.':'.$response.
        ':submission'}++;
                   }
   
 Output: None                  if($partData{$part.':code'} ne 'x') {
                       $totalProblems++;
                   }
               }
           }
   
 *NOTE:  There is no output, but an error message is stored away in the cache           $output->{$name.':'.$sequence.':problemsCorrect'} = $problemsCorrect;
 data.  This is checked in &FormatStudentData().  The key username:domain:error    $allkeys{$name.':'.$sequence.':problemsCorrect'}++;
 will only exist if an error occured.  The error is an error from           $problemsSolved += $problemsCorrect;
 &DownloadStudentCourseInformation().   $problemsCorrect=0;
       }
   
 =back      $output->{$name.':problemsSolved'} = $problemsSolved;
       $output->{$name.':totalProblems'} = $totalProblems;
       $output->{$name.':totalAwarded'} = $totalAwarded;
       $allkeys{$name.':problemsSolved'}++;
       $allkeys{$name.':totalProblems'}++;
       $allkeys{$name.':totalAwarded'}++;
   
 =cut      $output->{$name.':keys'} = join(':::', keys(%allkeys));
   
 sub ProcessStudentData {      return;
     my ($cache,$courseData,$name)=@_;  }
   
     my ($checkForError) = keys(%$courseData);  sub LoadDiscussion {
     if($checkForError =~ /^(con_lost|error|no_such_host)/i) {      my ($courseID)=@_;
         $cache->{$name.':error'}='Could not download course data.';      my %Discuss=();
     } else {      my %contrib=&Apache::lonnet::dump(
         foreach my $key (keys (%$courseData)) {                  $courseID,
             $cache->{$name.':'.$key}=$courseData->{$key};                  $ENV{'course.'.$courseID.'.domain'},
         }                  $ENV{'course.'.$courseID.'.num'});
         if(defined($cache->{'NamesOfStudents'})) {    
             $cache->{'NamesOfStudents'}.=':::'.$name;      #my %contrib=&DownloadCourseInformation($name, $courseID, 0);
         } else {  
             $cache->{'NamesOfStudents'}=$name;      foreach my $temp(keys %contrib) {
         }   if ($temp=~/^version/) {
     }      my $ver=$contrib{$temp};
       my ($dummy,$prb)=split(':',$temp);
       for (my $idx=1; $idx<=$ver; $idx++ ) {
    my $name=$contrib{"$idx:$prb:sendername"};
    $Discuss{"$name:$prb"}=$idx;
       }
    }
       }       
   
     return;      return \%Discuss;
 }  }
   
 # ----- END PROCESSING FUNCTIONS ---------------------------------------  # ----- END PROCESSING FUNCTIONS ---------------------------------------
Line 695  sub ProcessStudentData { Line 1134  sub ProcessStudentData {
 =head1 HELPER FUNCTIONS  =head1 HELPER FUNCTIONS
   
 These are just a couple of functions do various odd and end   These are just a couple of functions do various odd and end 
 jobs.  jobs.  There was also a couple of bulk functions added.  These are
   &DownloadStudentCourseData(), &DownloadStudentCourseDataSeparate(), and
   &CheckForResidualDownload().  These functions now act as the interface
   for downloading student course data.  The statistical modules should
   no longer make the calls to dump and download and process etc.  They
   make calls to these bulk functions to get their data.
   
 =cut  =cut
   
 # ----- HELPER FUNCTIONS -----------------------------------------------  # ----- HELPER FUNCTIONS -----------------------------------------------
   
   sub CheckDateStampError {
       my ($courseData, $cache, $name)=@_;
       if($courseData->{$name.':UpToDate'} eq 'true') {
           $cache->{$name.':lastDownloadTime'} = 
               $courseData->{$name.':lastDownloadTime'};
           if($courseData->{$name.':lastDownloadTime'} eq 'Not downloaded') {
               $cache->{$name.':updateTime'} = ' Not updated';
           } else {
               $cache->{$name.':updateTime'}=
                   localtime($courseData->{$name.':lastDownloadTime'});
           }
           return 0;
       }
   
       $cache->{$name.':lastDownloadTime'}=$courseData->{$name.':lastDownloadTime'};
       if($courseData->{$name.':lastDownloadTime'} eq 'Not downloaded') {
           $cache->{$name.':updateTime'} = ' Not updated';
       } else {
           $cache->{$name.':updateTime'}=
               localtime($courseData->{$name.':lastDownloadTime'});
       }
   
       if(defined($courseData->{$name.':error'})) {
           $cache->{$name.':error'}=$courseData->{$name.':error'};
           return 0;
       }
   
       return 1;
   }
   
 =pod  =pod
   
 =item &ProcessFullName()  =item &ProcessFullName()
Line 715  sub ProcessFullName { Line 1189  sub ProcessFullName {
     my ($lastname, $generation, $firstname, $middlename)=@_;      my ($lastname, $generation, $firstname, $middlename)=@_;
     my $Str = '';      my $Str = '';
   
       # Strip whitespace preceeding & following name components.
       $lastname   =~ s/(\s+$|^\s+)//g;
       $generation =~ s/(\s+$|^\s+)//g;
       $firstname  =~ s/(\s+$|^\s+)//g;
       $middlename =~ s/(\s+$|^\s+)//g;
   
     if($lastname ne '') {      if($lastname ne '') {
  $Str .= $lastname.' ';   $Str .= $lastname;
  if($generation ne '') {   $Str .= ' '.$generation if ($generation ne '');
     $Str .= $generation;   $Str .= ',';
  } else {          $Str .= ' '.$firstname  if ($firstname ne '');
     chop($Str);          $Str .= ' '.$middlename if ($middlename ne '');
  }  
  $Str .= ', ';  
  if($firstname ne '') {  
     $Str .= $firstname.' ';  
  }  
  if($middlename ne '') {  
     $Str .= $middlename;  
  } else {  
     chop($Str);  
     if($firstname eq '') {  
  chop($Str);  
     }  
  }  
     } else {      } else {
  if($firstname ne '') {          $Str .= $firstname      if ($firstname ne '');
     $Str .= $firstname.' ';          $Str .= ' '.$middlename if ($middlename ne '');
  }          $Str .= ' '.$generation if ($generation ne '');
  if($middlename ne '') {  
     $Str .= $middlename.' ';  
  }  
  if($generation ne '') {  
     $Str .= $generation;  
  } else {  
     chop($Str);  
  }  
     }      }
   
     return $Str;      return $Str;
Line 769  $ChartDB: The name of the cache database Line 1228  $ChartDB: The name of the cache database
   
 Output: -1, 0, 1  Output: -1, 0, 1
   
 -1: Couldn't tie database  -1: Could not tie database
  0: Use cached data   0: Use cached data
  1: New cache database created, use that.   1: New cache database created, use that.
   
Line 796  sub TestCacheData { Line 1255  sub TestCacheData {
     while($tieTries < $totalDelay) {      while($tieTries < $totalDelay) {
         my $result=0;          my $result=0;
         if($isCached) {          if($isCached) {
             $result=tie(%testData,'GDBM_File',$ChartDB,&GDBM_READER,0640);              $result=tie(%testData,'GDBM_File',$ChartDB,&GDBM_READER(),0640);
         } else {          } else {
             $result=tie(%testData,'GDBM_File',$ChartDB,&GDBM_NEWDB,0640);              $result=tie(%testData,'GDBM_File',$ChartDB,&GDBM_NEWDB(),0640);
         }          }
         if($result) {          if($result) {
             last;              last;
Line 815  sub TestCacheData { Line 1274  sub TestCacheData {
     return $isCached;      return $isCached;
 }  }
   
 #sub CheckStatus {  sub DownloadStudentCourseData {
 #    my ($name, $data, $status)=@_;      my ($students,$checkDate,$cacheDB,$extract,$status,$courseID,$r,$c)=@_;
   
       my $title = 'LON-CAPA Statistics';
       my $heading = 'Download and Process Course Data';
       my $studentCount = scalar(@$students);
   
       my $WhatIWant;
       $WhatIWant = '(^version:|';
       $WhatIWant .= '^\d+:.+?:(resource\.\d+\.';
       $WhatIWant .= '(solved|tries|previous|awarded|(\d+\.submission))\s*$';#'
       $WhatIWant .= '|timestamp)';
       $WhatIWant .= ')';
   #    $WhatIWant = '.';
   
 #    if($status eq 'Any') {      if($status eq 'true') {
 #        my $section = ' ';          &Apache::lonhtmlcommon::Create_PrgWin($r, $title, $heading);
 #        foreach (split(':',$data->{$name.':Sections'})) {      }
 #            if($data->{$name.':'.$_.'Status'} eq 'Active') {  
 #                return $_;      my $displayString;
 #            }      my $count=0;
 #            $section = $_;      foreach (@$students) {
 #        }          my %cache;
 #        return $_;  
 #    }          if($c->aborted()) { return 'Aborted'; }
   
 #    foreach (split(':',$data->{$name.':Sections'})) {          if($status eq 'true') {
 #        if($data->{$name.':'.$_.'Status'} eq $status) {              $count++;
 #            return $_;              my $displayString = $count.'/'.$studentCount.': '.$_;
 #        }              &Apache::lonhtmlcommon::Update_PrgWin($displayString, $r);
 #    }          }
   
 #    foreach (split(':',$data->{$name.':Sections'})) {  
 #        if($data->{$name.':'.$_.'Status'} eq 'Any') {  
 #            return $_;  
 #        }  
 #    }  
   
 #    return 'not found';          my $downloadTime='Not downloaded';
 #}          my $needUpdate = 'false';
           if($checkDate eq 'true'  && 
              tie(%cache,'GDBM_File',$cacheDB,&GDBM_READER(),0640)) {
               $downloadTime = $cache{$_.':lastDownloadTime'};
               $needUpdate = $cache{'ResourceUpdated'};
               untie(%cache);
           }
   
           if($c->aborted()) { return 'Aborted'; }
   
           if($needUpdate eq 'true') {
               $downloadTime = 'Not downloaded';
    }
    my $courseData = 
       &DownloadCourseInformation($_, $courseID, $downloadTime, 
          $WhatIWant);
    if(tie(%cache,'GDBM_File',$cacheDB,&GDBM_WRCREAT(),0640)) {
       foreach my $key (keys(%$courseData)) {
    if($key =~ /^(con_lost|error|no_such_host)/i) {
       $courseData->{$_.':error'} = 'No course data for '.$_;
       last;
    }
       }
       if($extract eq 'true') {
    &ExtractStudentData($courseData, \%cache, \%cache, $_);
       } else {
    &ProcessStudentData(\%cache, $courseData, $_);
       }
       untie(%cache);
    } else {
       next;
    }
       }
       if($status eq 'true') { &Apache::lonhtmlcommon::Close_PrgWin($r); }
   
       return 'OK';
   }
   
   sub DownloadStudentCourseDataSeparate {
       my ($students,$checkDate,$cacheDB,$extract,$status,$courseID,$r,$c)=@_;
       my $residualFile = $Apache::lonnet::tmpdir.$courseID.'DownloadFile.db';
       my $title = 'LON-CAPA Statistics';
       my $heading = 'Download Course Data';
   
       my $WhatIWant;
       $WhatIWant = '(^version:|';
       $WhatIWant .= '^\d+:.+?:(resource\.\d+\.';
       $WhatIWant .= '(solved|tries|previous|awarded|(\d+\.submission))\s*$';#'
       $WhatIWant .= '|timestamp)';
       $WhatIWant .= ')';
   
       &CheckForResidualDownload($cacheDB, 'true', 'true', $courseID, $r, $c);
   
       my $studentCount = scalar(@$students);
       if($status eq 'true') {
           &Apache::lonhtmlcommon::Create_PrgWin($r, $title, $heading);
       }
       my $count=0;
       my $displayString='';
       foreach (@$students) {
           if($c->aborted()) {
               return 'Aborted';
           }
   
           if($status eq 'true') {
               $count++;
               $displayString = $count.'/'.$studentCount.': '.$_;
               &Apache::lonhtmlcommon::Update_PrgWin($displayString, $r);
           }
   
           my %cache;
           my $downloadTime='Not downloaded';
           my $needUpdate = 'false';
           if($checkDate eq 'true'  && 
              tie(%cache,'GDBM_File',$cacheDB,&GDBM_READER(),0640)) {
               $downloadTime = $cache{$_.':lastDownloadTime'};
               $needUpdate = $cache{'ResourceUpdated'};
               untie(%cache);
           }
   
           if($c->aborted()) {
               return 'Aborted';
           }
   
           if($needUpdate eq 'true') {
               $downloadTime = 'Not downloaded';
    }
   
           my $error = 0;
           my $courseData = 
               &DownloadCourseInformation($_, $courseID, $downloadTime,
                                          $WhatIWant);
           my %downloadData;
           unless(tie(%downloadData,'GDBM_File',$residualFile,
                      &GDBM_WRCREAT(),0640)) {
               return 'Failed to tie temporary download hash.';
           }
           foreach my $key (keys(%$courseData)) {
               $downloadData{$key} = $courseData->{$key};
               if($key =~ /^(con_lost|error|no_such_host)/i) {
                   $error = 1;
                   last;
               }
           }
           if($error) {
               foreach my $deleteKey (keys(%$courseData)) {
                   delete $downloadData{$deleteKey};
               }
               $downloadData{$_.':error'} = 'No course data for '.$_;
           }
           untie(%downloadData);
       }
       if($status eq 'true') { &Apache::lonhtmlcommon::Close_PrgWin($r); }
   
       return &CheckForResidualDownload($cacheDB, 'true', 'true', 
                                        $courseID, $r, $c);
   }
   
   sub CheckForResidualDownload {
       my ($cacheDB,$extract,$status,$courseID,$r,$c)=@_;
   
       my $residualFile = $Apache::lonnet::tmpdir.$courseID.'DownloadFile.db';
       if(!-e $residualFile) {
           return 'OK';
       }
   
       my %downloadData;
       my %cache;
       unless(tie(%downloadData,'GDBM_File',$residualFile,&GDBM_READER(),0640)) {
           return 'Can not tie database for check for residual download: tempDB';
       }
       unless(tie(%cache,'GDBM_File',$cacheDB,&GDBM_WRCREAT(),0640)) {
           untie(%downloadData);
           return 'Can not tie database for check for residual download: cacheDB';
       }
   
       my @students=();
       my %checkStudent;
       my $key;
       while(($key, undef) = each %downloadData) {
           my @temp = split(':', $key);
           my $student = $temp[0].':'.$temp[1];
           if(!defined($checkStudent{$student})) {
               $checkStudent{$student}++;
               push(@students, $student);
           }
       }
   
       my $heading = 'Process Course Data';
       my $title = 'LON-CAPA Statistics';
       my $studentCount = scalar(@students);
       if($status eq 'true') {
           &Apache::lonhtmlcommon::Create_PrgWin($r, $title, $heading);
       }
   
       my $count=1;
       foreach my $name (@students) {
           last if($c->aborted());
   
           if($status eq 'true') {
               my $displayString = $count.'/'.$studentCount.': '.$name;
               &Apache::lonhtmlcommon::Update_PrgWin($displayString, $r);
           }
   
           if($extract eq 'true') {
               &ExtractStudentData(\%downloadData, \%cache, \%cache, $name);
           } else {
               &ProcessStudentData(\%cache, \%downloadData, $name);
           }
           $count++;
       }
   
       if($status eq 'true') { &Apache::lonhtmlcommon::Close_PrgWin($r); }
   
       untie(%cache);
       untie(%downloadData);
   
       if(!$c->aborted()) {
           my @files = ($residualFile);
           unlink(@files);
       }
   
       return 'OK';
   }
   
   
   ################################################
   ################################################
   
   =pod
   
   =item &get_current_state($sname,$sdom,$symb,$courseid);
   
   Retrive the current status of a students performance.  $sname and
   $sdom are the only required parameters.  If $symb is undef the results
   of a &Apache::lonnet::currentdump() will be returned.  
   If $courseid is undef it will be retrieved from the environment.
   
   The return structure is based on &Apache::lonnet::currentdump.  If
   $symb is unspecified, all the students data is returned in a hash of
   the form:
   ( 
     symb1 => { param1 => value1, param2 => value2 ... },
     symb2 => { param1 => value1, param2 => value2 ... },
   )
   
   If $symb is specified, a hash of 
   (
     param1 => value1, 
     param2 => value2,
   )
   is returned.
   
   Eventually this routine will cache the results locally.
   
   If no data is found for $symb, or if the student has not performance data,
   an empty list is returned.
   
   =cut
   
   ################################################
   ################################################
   
   sub get_current_state {
       my ($sname,$sdom,$symb,$courseid)=@_;
       return undef if (! defined($sname) || ! defined($sdom));
       $courseid = $ENV{'request.course.id'} if (! defined($courseid));
       # For a first pass, just get a currentdump and return the requested
       # results
       my @tmp = &Apache::lonnet::currentdump($courseid,$sdom,$sname);
       if (! ((scalar(@tmp) > 0) && ($tmp[0] !~ /^error:/)) ) {
           &Apache::lonnet::logthis('error getting data for '.$sname.':'.$sdom.
                                    'in course '.$courseid);
           return ();
       }
       my %student_data = @tmp;
       if (! defined($symb)) {
           return %student_data;
       } elsif (exists($student_data{$symb})) {
           return %{$student_data{$symb}};
       } else {
           return ();
       }
   }
   
   ################################################
   ################################################
   
   =pod
   
   =item &get_classlist();
   
   Retrieve the classist of a given class or of the current class.  Student
   information is returned from the classlist.db file and, if needed,
   from the students environment.
   
   Optional arguments are $cid, $cdom, and $cnum (course id, course domain,
   and course number, respectively).  Any omitted arguments will be taken 
   from the current environment ($ENV{'request.course.id'},
   $ENV{'course.'.$cid.'.domain'}, and $ENV{'course.'.$cid.'.num'}).
   
   Returns a reference to a hash which contains:
    keys    '$sname:$sdom'
    values  [$end,$start,$id,$section,$fullname]
   
   =cut
   
   ################################################
   ################################################
   
   sub get_classlist {
       my ($cid,$cdom,$cnum) = @_;
       $cid = $cid || $ENV{'request.course.id'};
       $cdom = $cdom || $ENV{'course.'.$cid.'.domain'};
       $cnum = $cnum || $ENV{'course.'.$cid.'.num'};
      my $now = time;
       #
       my %classlist=&Apache::lonnet::dump('classlist',$cdom,$cnum);
       while (my ($student,$info) = each(%classlist)) {
           return undef if ($student =~ /^(con_lost|error|no_such_host)/i);
           my ($sname,$sdom) = split(/:/,$student);
           my @Values = split(/:/,$info);
           my ($end,$start,$id,$section,$fullname);
           if (@Values > 2) {
               ($end,$start,$id,$section,$fullname) = @Values;
           } else { # We have to get the data ourselves
               ($end,$start) = @Values;
               $section = &Apache::lonnet::getsection($sdom,$sname,$cid);
               my %info=&Apache::lonnet::get('environment',
                                             ['firstname','middlename',
                                              'lastname','generation','id'],
                                             $sdom, $sname);
               my ($tmp) = keys(%info);
               if ($tmp =~/^(con_lost|error|no_such_host)/i) {
                   $fullname = 'not available';
                   $id = 'not available';
                   &Apache::lonnet::logthis('unable to retrieve environment '.
                                            'for '.$sname.':'.$sdom);
               } else {
                   $fullname = &ProcessFullName(@info{qw/lastname generation 
                                                          firstname middlename/});
                   $id = $info{'id'};
               }
               # Update the classlist with this students information
               if ($fullname ne 'not available') {
                   my $enrolldata = join(':',$end,$start,$id,$section,$fullname);
                   my $reply=&Apache::lonnet::cput('classlist',
                                                   {$student => $enrolldata},
                                                   $cdom,$cnum);
                   if ($reply !~ /^(ok|delayed)/) {
                       &Apache::lonnet::logthis('Unable to update classlist for '.
                                                'student '.$sname.':'.$sdom.
                                                ' error:'.$reply);
                   }
               }
           }
           my $status='Expired';
           if(((!$end) || $now < $end) && ((!$start) || ($now > $start))) {
               $status='Active';
           }
           $classlist{$student} = 
               [$sdom,$sname,$end,$start,$id,$section,$fullname,$status];
       }
       if (wantarray()) {
           return (\%classlist,['domain','username','end','start','id',
                                'section','fullname','status']);
       } else {
           return \%classlist;
       }
   }
   
 # ----- END HELPER FUNCTIONS --------------------------------------------  # ----- END HELPER FUNCTIONS --------------------------------------------
   
 1;  1;
 __END__  __END__
   
   
Removed from v.1.2  
changed lines
  Added in v.1.46

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