Diff for /loncom/interface/loncoursedata.pm between versions 1.9 and 1.59

version 1.9, 2002/07/30 23:07:10 version 1.59, 2003/03/20 19:58:37
Line 1 Line 1
 # The LearningOnline Network with CAPA  # The LearningOnline Network with CAPA
 # (Publication Handler  
 #  #
 # $Id$  # $Id$
 #  #
Line 35  loncoursedata Line 34  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 51  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 Time::HiRes;
   use Apache::lonmysql;
 use HTML::TokeParser;  use HTML::TokeParser;
 use GDBM_File;  use GDBM_File;
   
Line 58  use GDBM_File; Line 61  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 73  here in the future. Line 73  here in the future.
 =item &DownloadClasslist()  =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 104  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
Line 106  sub DownloadClasslist { Line 121  sub DownloadClasslist {
     my ($courseDomain,$courseNumber)=split(/\_/,$courseID);      my ($courseDomain,$courseNumber)=split(/\_/,$courseID);
     my %classlist;      my %classlist;
   
     my $modifiedTime = &GetFileTimestamp($courseDomain, $courseNumber,      my $modifiedTime = &Apache::lonnet::GetFileTimestamp($courseDomain, 
                                      'classlist.db',                                                            $courseNumber,
                                      $Apache::lonnet::perlvar{'lonUsersDir'});                                                           'classlist.db', 
                                    $Apache::lonnet::perlvar{'lonUsersDir'});
   
       # 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' &&      if($lastDownloadTime ne 'Not downloaded' &&
        $lastDownloadTime >= $modifiedTime && $modifiedTime >= 0) {         $lastDownloadTime >= $modifiedTime && $modifiedTime >= 0) {
           # Data is not gathered so return UpToDate as true.  This
           # will be interpreted in ProcessClasslist
         $classlist{'lastDownloadTime'}=time;          $classlist{'lastDownloadTime'}=time;
         $classlist{'UpToDate'} = 'true';          $classlist{'UpToDate'} = 'true';
         return \%classlist;          return \%classlist;
     }      }
   
     %classlist=&Apache::lonnet::dump('classlist',$courseDomain, $courseNumber);      %classlist=&Apache::lonnet::dump('classlist',$courseDomain, $courseNumber);
     my ($checkForError)=keys (%classlist);      foreach(keys (%classlist)) {
     if($checkForError =~ /^(con_lost|error|no_such_host)/i) {          if(/^(con_lost|error|no_such_host)/i) {
         return \%classlist;      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 159  sub DownloadClasslist { Line 181  sub DownloadClasslist {
   
 =item &DownloadCourseInformation()  =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.  It also  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  checks the timestamp of the students course database file and only downloads
 if it has been modified since the last download.  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
Line 182  database. Line 212  database.
 =cut  =cut
   
 sub DownloadCourseInformation {  sub DownloadCourseInformation {
     my ($namedata,$courseID,$lastDownloadTime)=@_;      my ($namedata,$courseID,$lastDownloadTime,$WhatIWant)=@_;
     my %courseData;      my %courseData;
     my ($name,$domain) = split(/\:/,$namedata);      my ($name,$domain) = split(/\:/,$namedata);
   
     my $modifiedTime = &GetFileTimestamp($domain, $name,      my $modifiedTime = &Apache::lonnet::GetFileTimestamp($domain, $name,
                                       $courseID.'.db',                                         $courseID.'.db', 
                                       $Apache::lonnet::perlvar{'lonUsersDir'});                                        $Apache::lonnet::perlvar{'lonUsersDir'});
   
     if($lastDownloadTime >= $modifiedTime) {      if($lastDownloadTime ne 'Not downloaded' && 
         $courseData{'lastDownloadTime'}=time;         $lastDownloadTime >= $modifiedTime && $modifiedTime >= 0) {
         $courseData{'UpToDate'} = 'true';          # 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;          return \%courseData;
     }      }
   
     # Download course data      # Download course data
     %courseData=&Apache::lonnet::dump($courseID, $domain, $name);      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{'UpToDate'} = 'false';
     $courseData{'lastDownloadTime'}=time;      $courseData{'lastDownloadTime'}=time;
     return \%courseData;  
       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 210  sub DownloadCourseInformation { Line 255  sub DownloadCourseInformation {
 =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),
     num_assess   => 2,               # only for container
     parts        => [11,13,15],      # only for assessment
     response_ids => [12,14,16],      # only for assessment
     contents     => [........]       # only for container
   }
   
   $hash->{'contents'} is a reference to an array of hashes of the same structure.
   
   Also returned are array references to the sequences and assessments contained
   in the course.
   
   
   =cut
   
   ####################################################
   ####################################################
   sub get_sequence_assessment_data {
       my $fn=$ENV{'request.course.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 $title = $ENV{'course.'.$ENV{'request.course.id'}.'.description'};
       my $symb  = 'top';
       my $src   = 'not applicable';
       #
       my @Sequences; 
       my @Assessments;
       my @Nested_Sequences = ();   # Stack of sequences, keeps track of depth
       my $top = { title    => $title,
                   src      => $src,
                   symb     => $symb,
                   type     => 'container',
                   num_assess => 0,
                   num_assess_parts => 0,
                   contents   => [], };
       push (@Sequences,$top);
       push (@Nested_Sequences, $top);
       #
       # We need to keep track of which sequences contain homework problems
       # 
       my $previous;
       my $curRes = $iterator->next(); # BEGIN_MAP
       $curRes = $iterator->next(); # The first item in the top level map.
       while (scalar(@Nested_Sequences)) {
           $previous = $curRes;
           $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
               $title = $previous->title();
               $symb  = $previous->symb();
               $src   = $previous->src();
               my $newmap = { title    => $title,
                              src      => $src,
                              symb     => $symb,
                              type     => 'container',
                              num_assess => 0,
                              contents   => [],
                          };
               push (@{$currentmap->{'contents'}},$newmap); # this is permanent
               push (@Sequences,$newmap);
               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',
                              parts => $parts,
                              num_parts => scalar(@$parts),
                          };
           push(@Assessments,$assessment);
           push(@{$currentmap->{'contents'}},$assessment);
           $currentmap->{'num_assess'}++;
           $currentmap->{'num_assess_parts'}+= scalar(@$parts);
       }
       $navmap->untieHashes();
       return ($top,\@Sequences,\@Assessments);
   }
   
   #################################################
   #################################################
   
 =pod  =pod
   
 =item &ProcessTopResourceMap()  =item &ProcessTopResourceMap()
Line 255  sub ProcessTopResourceMap { Line 422  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 268  sub ProcessTopResourceMap { Line 435  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 300  sub ProcessTopResourceMap { Line 482  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 314  sub ProcessTopResourceMap { Line 497  sub ProcessTopResourceMap {
     last;      last;
  }   }
     }      }
               next;
  }   }
   
  # Handle gradable resources: exams, problems, etc   # Handle gradable resources: exams, problems, etc
Line 322  sub ProcessTopResourceMap { Line 506  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 330  sub ProcessTopResourceMap { Line 517  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'}++;
   
             $cache->{$currentResourceID.':source'} =   
                 $hash{'src_'.$currentResourceID};  
     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'}=              $cache->{$currentResourceID.':source'}=
                 $hash{'src_'.$currentResourceID};                  $hash{'src_'.$currentResourceID};
               $allkeys{$currentResourceID.':source'}++;
   
             # Get Parts for problem              # Get Parts for problem
             my %beenHere;              my %beenHere;
Line 362  sub ProcessTopResourceMap { Line 551  sub ProcessTopResourceMap {
                             $cache->{$currentSequence.':'.$currentResourceID.                              $cache->{$currentSequence.':'.$currentResourceID.
                                      ':parts'}.=':'.$partId;                                       ':parts'}.=':'.$partId;
                         }                          }
                           $allkeys{$currentSequence.':'.$currentResourceID.
                                     ':parts'}++;
                     }                      }
                     if($beenHere{'r:'.$partId.':'.$responseId} == 0) {                      if($beenHere{'r:'.$partId.':'.$responseId} == 0) {
                         $beenHere{'r:'.$partId.':'.$responseId}++;                          $beenHere{'r:'.$partId.':'.$responseId}++;
Line 375  sub ProcessTopResourceMap { Line 566  sub ProcessTopResourceMap {
                                      ':'.$partId.':responseIDs'}.=':'.                                       ':'.$partId.':responseIDs'}.=':'.
                                                                   $responseId;                                                                    $responseId;
                         }                          }
                           $allkeys{$currentSequence.':'.$currentResourceID.':'.
                                        $partId.':responseIDs'}++;
                     }                      }
                     if(/^optionresponse/ &&                       if(/^optionresponse/ && 
                        $beenHere{'o:'.$partId.':'.$currentResourceID} == 0) {                         $beenHere{'o:'.$partId.':'.$currentResourceID} == 0) {
                         $beenHere{'o:'.$partId.$currentResourceID}++;                          $beenHere{'o:'.$partId.$currentResourceID}++;
                         if(defined($cache->{'OptionResponses'})) {                          if(defined($cache->{'OptionResponses'})) {
                             $cache->{'OptionResponses'}.= ':::'.                              $cache->{'OptionResponses'}.= ':::'.
                                 $currentResourceID.':'.                                  $currentSequence.':'.$currentResourceID.':'.
                                 $partId.':'.$responseId;                                  $partId.':'.$responseId;
                         } else {                          } else {
                             $cache->{'OptionResponses'}= $currentResourceID.                              $cache->{'OptionResponses'}= $currentSequence.':'.
                                 ':'.$partId.':'.$responseId;                                  $currentResourceID.':'.
                                   $partId.':'.$responseId;
                         }                          }
                           $allkeys{'OptionResponses'}++;
                     }                      }
                 }                  }
             }              }
Line 402  sub ProcessTopResourceMap { Line 597  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 417  sub ProcessTopResourceMap { Line 614  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 427  sub ProcessTopResourceMap { Line 624  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 439  sub ProcessTopResourceMap { Line 637  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 478  Takes data downloaded for a student and Line 692  Takes data downloaded for a student and
 stored in cache data.  The username, domain, class related date, PID,   stored in cache data.  The username, domain, class related date, PID, 
 full name, and section are all processed here.  full name, and section are all processed here.
   
   
 =over 4  =over 4
   
 Input: $cache, $classlist, $courseID, $ChartDB, $c  Input: $cache, $classlist, $courseID, $ChartDB, $c
Line 487  $cache: A hash pointer to store the data Line 700  $cache: A hash pointer to store the data
   
 $classlist:  The hash of data collected about a student from   $classlist:  The hash of data collected about a student from 
 &DownloadClasslist().  The hash contains a list of students, a pointer   &DownloadClasslist().  The hash contains a list of students, a pointer 
 to a hash of student information for each student, and each student's section   to a hash of student information for each student, and each students section 
 number.  number.
   
 $courseID:  The course ID  $courseID:  The course ID
Line 500  browser Line 713  browser
 Output: @names  Output: @names
   
 @names:  An array of students whose information has been processed, and are to   @names:  An array of students whose information has been processed, and are to 
 be considered in an arbitrary order.  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
   
Line 523  sub ProcessClasslist { Line 753  sub ProcessClasslist {
         if($c->aborted()) {          if($c->aborted()) {
             return ();              return ();
         }          }
         push(@names,$name);          my $studentInformation = $classlist->{$name.':studentInformation'};
         my $studentInformation = $classlist->{$name.':studentInformation'},          my $date = $classlist->{$name};
         my $sectionData = $classlist->{$name.':sections'},  
         my $date = $classlist->{$name},  
         my ($studentName,$studentDomain) = split(/\:/,$name);          my ($studentName,$studentDomain) = split(/\:/,$name);
   
         $cache->{$name.':username'}=$studentName;          $cache->{$name.':username'}=$studentName;
         $cache->{$name.':domain'}=$studentDomain;          $cache->{$name.':domain'}=$studentDomain;
           # Initialize timestamp for student
         if(!defined($cache->{$name.':lastDownloadTime'})) {          if(!defined($cache->{$name.':lastDownloadTime'})) {
             $cache->{$name.':lastDownloadTime'}='Not downloaded';              $cache->{$name.':lastDownloadTime'}='Not downloaded';
             $cache->{$name.':updateTime'}=' Not updated';              $cache->{$name.':updateTime'}=' Not updated';
         }          }
   
         my ($checkForError)=keys(%$studentInformation);          my $error = 0;
         if($checkForError =~ /^(con_lost|error|no_such_host)/i) {          foreach(keys(%$studentInformation)) {
             $cache->{$name.':error'}=              if(/^(con_lost|error|no_such_host)/i) {
                 'Could not download student environment data.';                  $cache->{$name.':error'}=
             $cache->{$name.':fullname'}='';                      'Could not download student environment data.';
             $cache->{$name.':id'}='';                  $cache->{$name.':fullname'}='';
         } else {                  $cache->{$name.':id'}='';
             $cache->{$name.':fullname'}=&ProcessFullName(                  $error = 1;
               }
           }
           next if($error);
           push(@names,$name);
           $cache->{$name.':fullname'}=&ProcessFullName(
                                           $studentInformation->{'lastname'},                                            $studentInformation->{'lastname'},
                                           $studentInformation->{'generation'},                                            $studentInformation->{'generation'},
                                           $studentInformation->{'firstname'},                                            $studentInformation->{'firstname'},
                                           $studentInformation->{'middlename'});                                            $studentInformation->{'middlename'});
             $cache->{$name.':id'}=$studentInformation->{'id'};          $cache->{$name.':id'}=$studentInformation->{'id'};
         }  
   
         my ($end, $start)=split(':',$date);          my ($end, $start)=split(':',$date);
         $courseID=~s/\_/\//g;          $courseID=~s/\_/\//g;
         $courseID=~s/^(\w)/\/$1/;          $courseID=~s/^(\w)/\/$1/;
   
         my $sec='';          my $sec='';
           my $sectionData = $classlist->{$name.':sections'};
         foreach my $key (keys (%$sectionData)) {          foreach my $key (keys (%$sectionData)) {
             my $value = $sectionData->{$key};              my $value = $sectionData->{$key};
             if ($key=~/^$courseID(?:\/)*(\w+)*\_st$/) {              if ($key=~/^$courseID(?:\/)*(\w+)*\_st$/) {
Line 563  sub ProcessClasslist { Line 797  sub ProcessClasslist {
                 if($key eq $courseID.'_st') {                  if($key eq $courseID.'_st') {
                     $tempsection='';                      $tempsection='';
                 }                  }
                 my ($dummy,$roleend,$rolestart)=split(/\_/,$value);                  my (undef,$roleend,$rolestart)=split(/\_/,$value);
                 if($roleend eq $end && $rolestart eq $start) {                  if($roleend eq $end && $rolestart eq $start) {
                     $sec = $tempsection;                      $sec = $tempsection;
                     last;                      last;
Line 604  Takes the course data downloaded for a s Line 838  Takes the course data downloaded for a s
 &DownloadCourseInformation() and breaks it up into key value pairs  &DownloadCourseInformation() and breaks it up into key value pairs
 to be stored in the cached data.  The keys are comprised of the   to be stored in the cached data.  The keys are comprised of the 
 $username:$domain:$keyFromCourseDatabase.  The student username:domain is  $username:$domain:$keyFromCourseDatabase.  The student username:domain is
 stored away signifying that the student's information has been downloaded and   stored away signifying that the students information has been downloaded and 
 can be reused from cached data.  can be reused from cached data.
   
 =over 4  =over 4
Line 632  will only exist if an error occured.  Th Line 866  will only exist if an error occured.  Th
 sub ProcessStudentData {  sub ProcessStudentData {
     my ($cache,$courseData,$name)=@_;      my ($cache,$courseData,$name)=@_;
   
     if($courseData->{'UpToDate'} eq 'true') {      if(!&CheckDateStampError($courseData, $cache, $name)) {
         $cache->{$name.':lastDownloadTime'}=$courseData->{'lastDownloadTime'};  
         if($courseData->{'lastDownloadTime'} eq 'Not downloaded') {  
             $cache->{$name.':updateTime'} = ' Not updated';  
         } else {  
             $cache->{$name.':updateTime'}=  
                 localtime($courseData->{'lastDownloadTime'});  
         }  
         return;          return;
     }      }
   
     my @courseKeys = keys(%$courseData);      # This little delete thing, should not be here.  Move some other
       # time though.
       if(defined($cache->{$name.':keys'})) {
    foreach (split(':::', $cache->{$name.':keys'})) {
       delete $cache->{$name.':'.$_};
    }
           delete $cache->{$name.':keys'};
       }
   
     foreach (@courseKeys) {      my %courseKeys;
         if(/^(con_lost|error|no_such_host)/i) {      # user name:domain was prepended earlier in DownloadCourseInformation
             $cache->{$name.':error'}='Could not download course data.';      foreach (keys %$courseData) {
             return;   my $currentKey = $_;
         }   $currentKey =~ s/^$name//;
    $courseKeys{$currentKey}++;
           $cache->{$_}=$courseData->{$_};
     }      }
   
     $cache->{$name.':lastDownloadTime'}=$courseData->{'lastDownloadTime'};      $cache->{$name.':keys'} = join(':::', keys(%courseKeys));
     if($courseData->{'lastDownloadTime'} eq 'Not downloaded') {  
         $cache->{$name.':updateTime'} = ' Not updated';      return;
     } else {  }
         $cache->{$name.':updateTime'}=  
             localtime($courseData->{'lastDownloadTime'});  =pod
   
   =item &ExtractStudentData()
   
   HISTORY: This function originally existed in every statistics module,
   and performed different tasks, the had some overlap.  Due to the need
   for the data from the different modules, they were combined into
   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
   
   Input: $input, $output, $data, $name
   
   $input: A hash that contains the input data to be processed
   
   $output: A hash to contain the processed data
   
   $data: A hash containing the information on what is to be
   processed and how (basically).
   
   $name:  username:domain
   
   The input is slightly different here, but is quite simple.
   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: None
   
   *NOTE:  There is no output, but an error message is stored away in the cache 
   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
   
   =cut
   
   sub ExtractStudentData {
       my ($input, $output, $data, $name)=@_;
   
       if(!&CheckDateStampError($input, $data, $name)) {
           return;
     }      }
     foreach (@courseKeys) {  
         $cache->{$name.':'.$_}=$courseData->{$_};      # This little delete thing, should not be here.  Move some other
       # time though.
       my %allkeys;
       if(defined($output->{$name.':keys'})) {
    foreach (split(':::', $output->{$name.':keys'})) {
       delete $output->{$name.':'.$_};
    }
           delete $output->{$name.':keys'};
       }
   
       my ($username,$domain)=split(':',$name);
   
       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;
               }
   
               my %partData=undef;
               # Initialize part data, display skips correctly
               # Skip refers to when a student made no submissions on that
               # part/problem.
               foreach my $part (split(/\:/,$data->{$sequence.':'.
                                                    $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'}='';
                   }
               }
   
               # 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;
                       }
   
                       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);
                           }
                       }
   
                       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;
                   }
               }
   
               foreach my $part (split(/\:/,$data->{$sequence.':'.$problemID.
                                                    ':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++;
                   }
   
                   $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'}++;
                   }
   
                   if($partData{$part.':code'} ne 'x') {
                       $totalProblems++;
                   }
               }
           }
   
           $output->{$name.':'.$sequence.':problemsCorrect'} = $problemsCorrect;
    $allkeys{$name.':'.$sequence.':problemsCorrect'}++;
           $problemsSolved += $problemsCorrect;
    $problemsCorrect=0;
     }      }
   
       $output->{$name.':problemsSolved'} = $problemsSolved;
       $output->{$name.':totalProblems'} = $totalProblems;
       $output->{$name.':totalAwarded'} = $totalAwarded;
       $allkeys{$name.':problemsSolved'}++;
       $allkeys{$name.':totalProblems'}++;
       $allkeys{$name.':totalAwarded'}++;
   
       $output->{$name.':keys'} = join(':::', keys(%allkeys));
   
     return;      return;
 }  }
   
 sub LoadDiscussion {  sub LoadDiscussion {
     my ( $courseID)=@_;      my ($courseID)=@_;
     my %Discuss=();      my %Discuss=();
     my %contrib=&Apache::lonnet::dump(      my %contrib=&Apache::lonnet::dump(
                 $courseID,                  $courseID,
Line 697  sub LoadDiscussion { Line 1156  sub LoadDiscussion {
 =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 717  sub ProcessFullName { Line 1211  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 771  $ChartDB: The name of the cache database Line 1250  $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 798  sub TestCacheData { Line 1277  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 817  sub TestCacheData { Line 1296  sub TestCacheData {
     return $isCached;      return $isCached;
 }  }
   
 sub GetFileTimestamp {  sub DownloadStudentCourseData {
     my ($studentDomain,$studentName,$filename,$root)=@_;      my ($students,$checkDate,$cacheDB,$extract,$status,$courseID,$r,$c)=@_;
     $studentDomain=~s/\W//g;  
     $studentName=~s/\W//g;      my $title = 'LON-CAPA Statistics';
     my $subdir=$studentName.'__';      my $heading = 'Download and Process Course Data';
     $subdir =~ s/(.)(.)(.).*/$1\/$2\/$3/;      my $studentCount = scalar(@$students);
     my $proname="$studentDomain/$subdir/$studentName";  
     $proname .= '/'.$filename;      my $WhatIWant;
     my @dir = &Apache::lonnet::dirlist($proname, $studentDomain, $studentName,      $WhatIWant = '(^version:|';
                                        $root);      $WhatIWant .= '^\d+:.+?:(resource\.\d+\.';
     my $fileStat = $dir[0];      $WhatIWant .= '(solved|tries|previous|awarded|(\d+\.submission))\s*$';#'
     my @stats = split('&', $fileStat);      $WhatIWant .= '|timestamp)';
     if(@stats) {      $WhatIWant .= ')';
         return $stats[9];  #    $WhatIWant = '.';
   
       my %prog_state;
       if($status eq 'true') {
           %prog_state=&Apache::lonhtmlcommon::Create_PrgWin($r, $title,
          $heading,($#$students)+1);
       }
   
       foreach (@$students) {
           my %cache;
   
           if($c->aborted()) { return 'Aborted'; }
   
           if($status eq 'true') {
               &Apache::lonhtmlcommon::Increment_PrgWin($r,\%prog_state,
     'last student '.$_);
           }
   
           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,\%prog_state); }
   
       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);
       my %prog_state;
       if($status eq 'true') {
           %prog_state=&Apache::lonhtmlcommon::Create_PrgWin($r, $title,
        $heading,($#$students)+1);
       }
       my $displayString='';
       foreach (@$students) {
           if($c->aborted()) {
               return 'Aborted';
           }
   
           if($status eq 'true') {
               &Apache::lonhtmlcommon::Increment_PrgWin($r,\%prog_state,
     'last student '.$_);
           }
   
           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,
     \%prog_state); }
   
       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);
       my %prog_state;
       if($status eq 'true') {
           %prog_state=&Apache::lonhtmlcommon::Create_PrgWin($r, $title,
         $heading,$#students+1);
       }
   
       my $count=1;
       foreach my $name (@students) {
           last if($c->aborted());
   
           if($status eq 'true') {
       &Apache::lonhtmlcommon::Increment_PrgWin($r,\%prog_state,
        'last student '.$name);
           }
   
           if($extract eq 'true') {
               &ExtractStudentData(\%downloadData, \%cache, \%cache, $name);
           } else {
               &ProcessStudentData(\%cache, \%downloadData, $name);
           }
           $count++;
       }
   
       if($status eq 'true') { &Apache::lonhtmlcommon::Close_PrgWin($r,
      \%prog_state); }
   
       untie(%cache);
       untie(%downloadData);
   
       if(!$c->aborted()) {
           my @files = ($residualFile);
           unlink(@files);
       }
   
       return 'OK';
   }
   
   
   ################################################
   ################################################
   
   =pod
   
   =item &make_into_hash($values);
   
   Returns a reference to a hash as described by $values.  $values is
   assumed to be the result of 
       join(':',map {&Apache::lonnet::escape($_)} %orighash);
   
   This is a helper function for get_current_state.
   
   =cut
   
   ################################################
   ################################################
   sub make_into_hash {
       my $values = shift;
       my %tmp = map { &Apache::lonnet::unescape($_); }
                                              split(':',$values);
       return \%tmp;
   }
   
   
   ################################################
   ################################################
   
   =pod
   
   =head1 LOCAL DATA CACHING SUBROUTINES
   
   The local caching is done using MySQL.  There is no fall-back implementation
   if MySQL is not running.
   
   The programmers interface is to call &get_current_state() or some other
   primary interface subroutine (described below).  The internals of this 
   storage system are documented here.
   
   There are six tables used to store student performance data (the results of
   a dumpcurrent).  Each of these tables is created in MySQL with a name of
   $courseid_*****, where ***** is 'symb', 'part', or whatever is appropriate 
   for the table.  The tables and their purposes are described below.
   
   Some notes before we get started.
   
   Each table must have a PRIMARY KEY, which is a column or set of columns which
   will serve to uniquely identify a row of data.  NULL is not allowed!
   
   INDEXes work best on integer data.
   
   JOIN is used to combine data from many tables into one output.
   
   lonmysql.pm is used for some of the interface, specifically the table creation
   calls.  The inserts are done in bulk by directly calling the database handler.
   The SELECT ... JOIN statement used to retrieve the data does not have an
   interface in lonmysql.pm and I shudder at the thought of writing one.
   
   =head3 Table Descriptions
   
   =over 4
   
   =item $symb_table
   
   The symb_table has two columns.  The first is a 'symb_id' and the second
   is the text name for the 'symb' (limited to 64k).  The 'symb_id' is generated
   automatically by MySQL so inserts should be done on this table with an
   empty first element.  This table has its PRIMARY KEY on the 'symb_id'.
   
   =item $part_table
   
   The part_table has two columns.  The first is a 'part_id' and the second
   is the text name for the 'part' (limited to 100 characters).  The 'part_id' is
   generated automatically by MySQL so inserts should be done on this table with
   an empty first element.  This table has its PRIMARY KEY on the 'part' (100
   characters) and a KEY on 'part_id'.
   
   =item $student_table
   
   The student_table has two columns.  The first is a 'student_id' and the second
   is the text description of the 'student' (typically username:domain) (less
   than 100 characters).  The 'student_id' is automatically generated by MySQL.
   The use of the name 'student_id' is loaded, I know, but this ID is used ONLY 
   internally to the MySQL database and is not the same as the students ID 
   (stored in the students environment).  This table has its PRIMARY KEY on the
   'student' (100 characters).
   
   =item $updatetime_table
   
   The updatetime_table has two columns.  The first is 'student' (100 characters,
   typically username:domain).  The second is 'updatetime', which is an unsigned
   integer, NOT a MySQL date.  This table has its PRIMARY KEY on 'student' (100
   characters).
   
   =item $performance_table
   
   The performance_table has 9 columns.  The first three are 'symb_id', 
   'student_id', and 'part_id'.  These comprise the PRIMARY KEY for this table
   and are directly related to the $symb_table, $student_table, and $part_table
   described above.  MySQL does better indexing on numeric items than text,
   so we use these three "index tables".  The remaining columns are
   'solved', 'tries', 'awarded', 'award', 'awarddetail', and 'timestamp'.
   These are either the MySQL type TINYTEXT or various integers ('tries' and 
   'timestamp').  This table has KEYs of 'student_id' and 'symb_id'.
   For use of this table, see the functions described below.
   
   =item $parameters_table
   
   The parameters_table holds the data that does not fit neatly into the
   performance_table.  The parameters table has four columns: 'symb_id',
   'student_id', 'parameter', and 'value'.  'symb_id', 'student_id', and
   'parameter' comprise the PRIMARY KEY for this table.  'parameter' is 
   limited to 255 characters.  'value' is limited to 64k characters.
   
   =back
   
   =head3 Important Subroutines
   
   Here is a brief overview of the subroutines which are likely to be of 
   interest:
   
   =over 4
   
   =item &get_current_state(): programmers interface.
   
   =item &init_dbs(): table creation
   
   =item &update_student_data(): data storage calls
   
   =item &get_student_data_from_performance_cache(): data retrieval
   
   =back
   
   =head3 Main Documentation
   
   =over 4
   
   =cut
   
   ################################################
   ################################################
   
   ################################################
   ################################################
   {
   
   my $current_course ='';
   my $symb_table;
   my $part_table;
   my $student_table;
   my $updatetime_table;
   my $performance_table;
   my $parameters_table;
   
   ################################################
   ################################################
   
   =pod
   
   =item &setup_table_names()
   
   input: course id
   
   output: none
   
   Sets the package variables for the MySQL table names:
   
   =over 4
   
   =item $symb_table
   
   =item $part_table
   
   =item $student_table
   
   =item $updatetime_table
   
   =item $performance_table
   
   =item $parameters_table
   
   =back
   
   =cut
   
   ################################################
   ################################################
   sub setup_table_names {
       my $courseid = shift;
       if (! defined($courseid)) {
           $courseid = $ENV{'request.course.id'};
       }
       #
       # Set up database names
       my $base_id = $courseid;
       $symb_table        = $base_id.'_'.'symb';
       $part_table        = $base_id.'_'.'part';
       $student_table     = $base_id.'_'.'student';
       $updatetime_table  = $base_id.'_'.'updatetime';
       $performance_table = $base_id.'_'.'performance';
       $parameters_table  = $base_id.'_'.'parameters';
       return;
   }
   
   ################################################
   ################################################
   
   =pod
   
   =item &init_dbs()
   
   Input: course id
   
   Output: 0 on success, positive integer on error
   
   This routine issues the calls to lonmysql to create the tables used to
   store student data.
   
   =cut
   
   ################################################
   ################################################
   sub init_dbs {
       my $courseid = shift;
       &setup_table_names($courseid);
       #
       # Note - changes to this table must be reflected in the code that 
       # stores the data (calls &Apache::lonmysql::store_row with this table
       # id
       my $symb_table_def = {
           id => $symb_table,
           permanent => 'no',
           columns => [{ name => 'symb_id',
                         type => 'MEDIUMINT UNSIGNED',
                         restrictions => 'NOT NULL',
                         auto_inc     => 'yes', },
                       { name => 'symb',
                         type => 'MEDIUMTEXT',
                         restrictions => 'NOT NULL'},
                       ],
           'PRIMARY KEY' => ['symb_id'],
       };
       #
       my $part_table_def = {
           id => $part_table,
           permanent => 'no',
           columns => [{ name => 'part_id',
                         type => 'MEDIUMINT UNSIGNED',
                         restrictions => 'NOT NULL',
                         auto_inc     => 'yes', },
                       { name => 'part',
                         type => 'VARCHAR(100)',
                         restrictions => 'NOT NULL'},
                       ],
           'PRIMARY KEY' => ['part (100)'],
           'KEY' => [{ columns => ['part_id']},],
       };
       #
       my $student_table_def = {
           id => $student_table,
           permanent => 'no',
           columns => [{ name => 'student_id',
                         type => 'MEDIUMINT UNSIGNED',
                         restrictions => 'NOT NULL',
                         auto_inc     => 'yes', },
                       { name => 'student',
                         type => 'VARCHAR(100)',
                         restrictions => 'NOT NULL'},
                       ],
           'PRIMARY KEY' => ['student (100)'],
           'KEY' => [{ columns => ['student_id']},],
       };
       #
       my $updatetime_table_def = {
           id => $updatetime_table,
           permanent => 'no',
           columns => [{ name => 'student',
                         type => 'VARCHAR(100)',
                         restrictions => 'NOT NULL UNIQUE',},
                       { name => 'updatetime',
                         type => 'INT UNSIGNED',
                         restrictions => 'NOT NULL' },
                       ],
           'PRIMARY KEY' => ['student (100)'],
       };
       #
       my $performance_table_def = {
           id => $performance_table,
           permanent => 'no',
           columns => [{ name => 'symb_id',
                         type => 'MEDIUMINT UNSIGNED',
                         restrictions => 'NOT NULL'  },
                       { name => 'student_id',
                         type => 'MEDIUMINT UNSIGNED',
                         restrictions => 'NOT NULL'  },
                       { name => 'part_id',
                         type => 'MEDIUMINT UNSIGNED',
                         restrictions => 'NOT NULL' },
                       { name => 'solved',
                         type => 'TINYTEXT' },
                       { name => 'tries',
                         type => 'SMALLINT UNSIGNED' },
                       { name => 'awarded',
                         type => 'TINYTEXT' },
                       { name => 'award',
                         type => 'TINYTEXT' },
                       { name => 'awarddetail',
                         type => 'TINYTEXT' },
                       { name => 'timestamp',
                         type => 'INT UNSIGNED'},
                       ],
           'PRIMARY KEY' => ['symb_id','student_id','part_id'],
           'KEY' => [{ columns=>['student_id'] },
                     { columns=>['symb_id'] },],
       };
       #
       my $parameters_table_def = {
           id => $parameters_table,
           permanent => 'no',
           columns => [{ name => 'symb_id',
                         type => 'MEDIUMINT UNSIGNED',
                         restrictions => 'NOT NULL'  },
                       { name => 'student_id',
                         type => 'MEDIUMINT UNSIGNED',
                         restrictions => 'NOT NULL'  },
                       { name => 'parameter',
                         type => 'TINYTEXT',
                         restrictions => 'NOT NULL'  },
                       { name => 'value',
                         type => 'MEDIUMTEXT' },
                       ],
           'PRIMARY KEY' => ['symb_id','student_id','parameter (255)'],
       };
       #
       # Create the tables
       my $tableid;
       $tableid = &Apache::lonmysql::create_table($symb_table_def);
       if (! defined($tableid)) {
           &Apache::lonnet::logthis("error creating symb_table: ".
                                    &Apache::lonmysql::get_error());
           return 1;
       }
       #
       $tableid = &Apache::lonmysql::create_table($part_table_def);
       if (! defined($tableid)) {
           &Apache::lonnet::logthis("error creating part_table: ".
                                    &Apache::lonmysql::get_error());
           return 2;
       }
       #
       $tableid = &Apache::lonmysql::create_table($student_table_def);
       if (! defined($tableid)) {
           &Apache::lonnet::logthis("error creating student_table: ".
                                    &Apache::lonmysql::get_error());
           return 3;
       }
       #
       $tableid = &Apache::lonmysql::create_table($updatetime_table_def);
       if (! defined($tableid)) {
           &Apache::lonnet::logthis("error creating updatetime_table: ".
                                    &Apache::lonmysql::get_error());
           return 4;
       }
       #
       $tableid = &Apache::lonmysql::create_table($performance_table_def);
       if (! defined($tableid)) {
           &Apache::lonnet::logthis("error creating preformance_table: ".
                                    &Apache::lonmysql::get_error());
           return 5;
       }
       #
       $tableid = &Apache::lonmysql::create_table($parameters_table_def);
       if (! defined($tableid)) {
           &Apache::lonnet::logthis("error creating parameters_table: ".
                                    &Apache::lonmysql::get_error());
           return 6;
       }
       return 0;
   }
   
   ################################################
   ################################################
   
   =pod
   
   =item &get_part_id()
   
   Get the MySQL id of a problem part string.
   
   Input: $part
   
   Output: undef on error, integer $part_id on success.
   
   =item &get_part()
   
   Get the string describing a part from the MySQL id of the problem part.
   
   Input: $part_id
   
   Output: undef on error, $part string on success.
   
   =cut
   
   ################################################
   ################################################
   
   my %ids_by_part;
   my %parts_by_id;
   
   sub get_part_id {
       my ($part) = @_;
       if (! exists($ids_by_part{$part})) {
           &Apache::lonmysql::store_row($part_table,[undef,$part]);
           undef(%ids_by_part);
           my @Result = &Apache::lonmysql::get_rows($part_table);
           foreach (@Result) {
               $ids_by_part{$_->[1]}=$_->[0];
           }
       }
       return $ids_by_part{$part} if (exists($ids_by_part{$part}));
       return undef; # error
   }
   
   sub get_part {
       my ($part_id) = @_;
       if (! exists($parts_by_id{$part_id})  || 
           ! defined($parts_by_id{$part_id}) ||
           $parts_by_id{$part_id} eq '') {
           my @Result = &Apache::lonmysql::get_rows($part_table);
           foreach (@Result) {
               $parts_by_id{$_->[0]}=$_->[1];
           }
       }
       return $parts_by_id{$part_id} if(exists($parts_by_id{$part_id}));
       return undef; # error
   }
   
   ################################################
   ################################################
   
   =pod
   
   =item &get_symb_id()
   
   Get the MySQL id of a symb.
   
   Input: $symb
   
   Output: undef on error, integer $symb_id on success.
   
   =item &get_symb()
   
   Get the symb associated with a MySQL symb_id.
   
   Input: $symb_id
   
   Output: undef on error, $symb on success.
   
   =cut
   
   ################################################
   ################################################
   
   my %ids_by_symb;
   my %symbs_by_id;
   
   sub get_symb_id {
       my ($symb) = @_;
       if (! exists($ids_by_symb{$symb})) {
           &Apache::lonmysql::store_row($symb_table,[undef,$symb]);
           undef(%ids_by_symb);
           my @Result = &Apache::lonmysql::get_rows($symb_table);
           foreach (@Result) {
               $ids_by_symb{$_->[1]}=$_->[0];
           }
       }
       return $ids_by_symb{$symb} if(exists( $ids_by_symb{$symb}));
       return undef; # error
   }
   
   sub get_symb {
       my ($symb_id) = @_;
       if (! exists($symbs_by_id{$symb_id})  || 
           ! defined($symbs_by_id{$symb_id}) ||
           $symbs_by_id{$symb_id} eq '') {
           my @Result = &Apache::lonmysql::get_rows($symb_table);
           foreach (@Result) {
               $symbs_by_id{$_->[0]}=$_->[1];
           }
       }
       return $symbs_by_id{$symb_id} if(exists( $symbs_by_id{$symb_id}));
       return undef; # error
   }
   
   ################################################
   ################################################
   
   =pod
   
   =item &get_student_id()
   
   Get the MySQL id of a student.
   
   Input: $sname, $dom
   
   Output: undef on error, integer $student_id on success.
   
   =item &get_student()
   
   Get student username:domain associated with the MySQL student_id.
   
   Input: $student_id
   
   Output: undef on error, string $student (username:domain) on success.
   
   =cut
   
   ################################################
   ################################################
   
   my %ids_by_student;
   my %students_by_id;
   
   sub get_student_id {
       my ($sname,$sdom) = @_;
       my $student = $sname.':'.$sdom;
       if (! exists($ids_by_student{$student})) {
           &Apache::lonmysql::store_row($student_table,[undef,$student]);
           undef(%ids_by_student);
           my @Result = &Apache::lonmysql::get_rows($student_table);
           foreach (@Result) {
               $ids_by_student{$_->[1]}=$_->[0];
           }
       }
       return $ids_by_student{$student} if(exists( $ids_by_student{$student}));
       return undef; # error
   }
   
   sub get_student {
       my ($student_id) = @_;
       if (! exists($students_by_id{$student_id})  || 
           ! defined($students_by_id{$student_id}) ||
           $students_by_id{$student_id} eq '') {
           my @Result = &Apache::lonmysql::get_rows($student_table);
           foreach (@Result) {
               $students_by_id{$_->[0]}=$_->[1];
           }
       }
       return $students_by_id{$student_id} if(exists($students_by_id{$student_id}));
       return undef; # error
   }
   
   ################################################
   ################################################
   
   =pod
   
   =item &update_student_data()
   
   Input: $sname, $sdom, $courseid
   
   Output: $returnstatus, \%student_data
   
   $returnstatus is a string describing any errors that occured.  'okay' is the
   default.
   \%student_data is the data returned by a call to lonnet::currentdump.
   
   This subroutine loads a students data using lonnet::currentdump and inserts
   it into the MySQL database.  The inserts are done on two tables, 
   $performance_table and $parameters_table.  $parameters_table holds the data 
   that is not included in $performance_table.  See the description of 
   $performance_table elsewhere in this file.  The INSERT calls are made
   directly by this subroutine, not through lonmysql because we do a 'bulk'
   insert which takes advantage of MySQLs non-SQL compliant INSERT command to 
   insert multiple rows at a time.  If anything has gone wrong during this
   process, $returnstatus is updated with a description of the error and
   \%student_data is returned.  
   
   Notice we do not insert the data and immediately query it.  This means it
   is possible for there to be data returned this first time that is not 
   available the second time.  CYA.
   
   =cut
   
   ################################################
   ################################################
   sub update_student_data {
       my ($sname,$sdom,$courseid) = @_;
       #
       my $student_id = &get_student_id($sname,$sdom);
       my $student = $sname.':'.$sdom;
       #
       my $returnstatus = 'okay';
       #
       # Set up database names
       &setup_table_names($courseid);
       #
       # Download students data
       my $time_of_retrieval = time;
       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.
                                    ':'.$tmp[0]);
           $returnstatus = 'error getting data';
           return $returnstatus;
       }
       if (scalar(@tmp) < 1) {
           return ('no data',undef);
       }
       my %student_data = @tmp;
       #
       # Remove all of the students data from the table
       &Apache::lonmysql::remove_from_table($performance_table,'student_id',
                                            $student_id);
       #
       # Store away the data
       #
       my $starttime = Time::HiRes::time;
       my $elapsed = 0;
       my $rows_stored;
       my $store_parameters_command  = 'INSERT INTO '.$parameters_table.
           ' VALUES ';
       my $store_performance_command = 'INSERT INTO '.$performance_table.
           ' VALUES ';
       my $dbh = &Apache::lonmysql::get_dbh();
       return 'error' if (! defined($dbh));
       while (my ($current_symb,$param_hash) = each(%student_data)) {
           #
           # make sure the symb is set up properly
           my $symb_id = &get_symb_id($current_symb);
           #
           # Load data into the tables
           while (my ($parameter,$value) = each (%$param_hash)) {
               my $newstring;
               if ($parameter !~ /(timestamp|resource\.(.*)\.(solved|tries|awarded|award|awarddetail|previous))/) {
                   $newstring = "('".join("','",
                                          $symb_id,$student_id,
                                          $parameter,$value)."'),";
                   if ($newstring !~ /''/) {
                       $store_parameters_command .= $newstring;
                       $rows_stored++;
                   }
               }
               next if ($parameter !~ /^resource\.(.*)\.solved$/);
               #
               my $part = $1;
               my $part_id = &get_part_id($part);
               next if (!defined($part_id));
               my $solved  = $value;
               my $tries   = $param_hash->{'resource.'.$part.'.tries'};
               my $awarded = $param_hash->{'resource.'.$part.'.awarded'};
               my $award   = $param_hash->{'resource.'.$part.'.award'};
               my $awarddetail = $param_hash->{'resource.'.$part.'.awarddetail'};
               my $timestamp = $param_hash->{'timestamp'};
               $solved      = '' if (! defined($awarded));
               $tries       = '' if (! defined($tries));
               $awarded     = '' if (! defined($awarded));
               $award       = '' if (! defined($award));
               $awarddetail = '' if (! defined($awarddetail));
               $newstring = "('".join("','",$symb_id,$student_id,$part_id,
                                      $solved,$tries,$awarded,$award,
                                      $awarddetail,$timestamp)."'),";
               $store_performance_command .= $newstring;
               $rows_stored++;
           }
       }
       chop $store_parameters_command;
       chop $store_performance_command;
       my $start = Time::HiRes::time;
       $dbh->do($store_parameters_command);
       if ($dbh->err()) {
           &Apache::lonnet::logthis(' bigass insert error:'.$dbh->errstr());
           &Apache::lonnet::logthis('command = '.$store_performance_command);
           $returnstatus = 'error: unable to insert parameters into database';
           return $returnstatus,\%student_data;
       }
       $dbh->do($store_performance_command);
       if ($dbh->err()) {
           &Apache::lonnet::logthis(' bigass insert error:'.$dbh->errstr());
           &Apache::lonnet::logthis('command = '.$store_parameters_command);
           $returnstatus = 'error: unable to insert performance into database';
           return $returnstatus,\%student_data;
       }
       $elapsed += Time::HiRes::time - $start;
       #
       # Set the students update time
       &Apache::lonmysql::replace_row($updatetime_table,
                                      [$student,$time_of_retrieval]);
       return ($returnstatus,\%student_data);
   }
   
   ################################################
   ################################################
   
   =pod
   
   =item &ensure_current_data()
   
   Input: $sname, $sdom, $courseid
   
   Output: $status, $data
   
   This routine ensures the data for a given student is up to date.  It calls
   &init_dbs() if the tables do not exist.  The $updatetime_table is queried
   to determine the time of the last update.  If the students data is out of
   date, &update_student_data() is called.  The return values from the call
   to &update_student_data() are returned.
   
   =cut
   
   ################################################
   ################################################
   sub ensure_current_data {
       my ($sname,$sdom,$courseid) = @_;
       my $status = 'okay';   # return value
       #
       &setup_table_names($courseid);
       #
       # if the tables do not exist, make them
       my @CurrentTable = &Apache::lonmysql::tables_in_db();
       my ($found_symb,$found_student,$found_part,$found_update,
           $found_performance,$found_parameters);
       foreach (@CurrentTable) {
           $found_symb        = 1 if ($_ eq $symb_table);
           $found_student     = 1 if ($_ eq $student_table);
           $found_part        = 1 if ($_ eq $part_table);
           $found_update      = 1 if ($_ eq $updatetime_table);
           $found_performance = 1 if ($_ eq $performance_table);
           $found_parameters  = 1 if ($_ eq $parameters_table);
       }
       if (!$found_symb        || !$found_update || 
           !$found_student     || !$found_part   ||
           !$found_performance || !$found_parameters) {
           if (&init_dbs($courseid)) {
               return 'error';
           }
       }
       #
       # Get the update time for the user
       my $updatetime = 0;
       my $modifiedtime = 1;
       #
       my $student = $sname.':'.$sdom;
       my @Result = &Apache::lonmysql::get_rows($updatetime_table,
                                                "student ='$student'");
       my $data = undef;
       if (@Result) {
           $updatetime = $Result[0]->[1];
       }
       if ($modifiedtime > $updatetime) {
           ($status,$data) = &update_student_data($sname,$sdom,$courseid);
       }
       return ($status,$data);
   }
   
   ################################################
   ################################################
   
   =pod
   
   =item &get_student_data_from_performance_cache()
   
   Input: $sname, $sdom, $symb, $courseid
   
   Output: hash reference containing the data for the given student.
   If $symb is undef, all the students data is returned.
   
   This routine is the heart of the local caching system.  See the description
   of $performance_table, $symb_table, $student_table, and $part_table.  The
   main task is building the MySQL request.  The tables appear in the request
   in the order in which they should be parsed by MySQL.  When searching
   on a student the $student_table is used to locate the 'student_id'.  All
   rows in $performance_table which have a matching 'student_id' are returned,
   with data from $part_table and $symb_table which match the entries in
   $performance_table, 'part_id' and 'symb_id'.  When searching on a symb,
   the $symb_table is processed first, with matching rows grabbed from 
   $performance_table and filled in from $part_table and $student_table in
   that order.  
   
   Running 'EXPLAIN ' on the 'SELECT' statements generated can be quite 
   interesting, especially if you play with the order the tables are listed.  
   
   =cut
   
   ################################################
   ################################################
   sub get_student_data_from_performance_cache {
       my ($sname,$sdom,$symb,$courseid)=@_;
       my $student = $sname.':'.$sdom if (defined($sname) && defined($sdom));
       &setup_table_names();
       #
       # Return hash
       my $studentdata;
       #
       my $dbh = &Apache::lonmysql::get_dbh();
       my $request = "SELECT ".
           "d.symb,c.part,a.solved,a.tries,a.awarded,a.award,a.awarddetail,".
               "a.timestamp ";
       if (defined($student)) {
           $request .= "FROM $student_table AS b ".
               "LEFT JOIN $performance_table AS a ON b.student_id=a.student_id ".
               "LEFT JOIN $part_table AS c ON c.part_id = a.part_id ".
               "LEFT JOIN $symb_table AS d ON d.symb_id = a.symb_id ".
                   "WHERE student='$student'";
           if (defined($symb) && $symb ne '') {
               $request .= " AND d.symb='".$dbh->quote($symb)."'";
           }
       } elsif (defined($symb) && $symb ne '') {
           $request .= "FROM $symb_table as d ".
               "LEFT JOIN $performance_table AS a ON d.symb_id=a.symb_id ".
               "LEFT JOIN $part_table    AS c ON c.part_id = a.part_id ".
               "LEFT JOIN $student_table AS b ON b.student_id = a.student_id ".
                   "WHERE symb='".$dbh->quote($symb)."'";
       }
       my $starttime = Time::HiRes::time;
       my $rows_retrieved = 0;
       my $sth = $dbh->prepare($request);
       $sth->execute();
       if ($sth->err()) {
           &Apache::lonnet::logthis("Unable to execute MySQL request:");
           &Apache::lonnet::logthis("\n".$request."\n");
           &Apache::lonnet::logthis("error is:".$sth->errstr());
           return undef;
       }
       foreach my $row (@{$sth->fetchall_arrayref}) {
           $rows_retrieved++;
           my ($symb,$part,$solved,$tries,$awarded,$award,$awarddetail,$time) = 
               (@$row);
           my $base = 'resource.'.$part;
           $studentdata->{$symb}->{$base.'.solved'}  = $solved;
           $studentdata->{$symb}->{$base.'.tries'}   = $tries;
           $studentdata->{$symb}->{$base.'.awarded'} = $awarded;
           $studentdata->{$symb}->{$base.'.award'}   = $award;
           $studentdata->{$symb}->{$base.'.awarddetail'} = $awarddetail;
           $studentdata->{$symb}->{'timestamp'} = $time if (defined($time) && $time ne '');
       }
       return $studentdata;
   }
   
   ################################################
   ################################################
   
   =pod
   
   =item &get_current_state()
   
   Input: $sname,$sdom,$symb,$courseid
   
   Output: Described below
   
   Retrieve the current status of a students performance.  $sname and
   $sdom are the only required parameters.  If $symb is undef the results
   of an &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.
   
   If no data is found for $symb, or if the student has no performance data,
   an empty list is returned.
   
   =cut
   
   ################################################
   ################################################
   sub get_current_state {
       my ($sname,$sdom,$symb,$courseid,$forcedownload)=@_;
       if ($current_course ne $courseid) {
           # Clear out variables
           undef(%ids_by_part);
           undef(%parts_by_id);
           undef(%ids_by_symb);
           undef(%symbs_by_id);
           undef(%ids_by_student);
           undef(%students_by_id);
           $current_course = $courseid;
       }
       return () if (! defined($sname) || ! defined($sdom));
       #
       $courseid = $ENV{'request.course.id'} if (! defined($courseid));
       #
       my ($status,$data) = &ensure_current_data($sname,$sdom,$courseid);
       #
       if (defined($data)) {
           return %$data;
       } elsif ($status eq 'no data') {
           return ();
     } else {      } else {
         return -1;          if ($status ne 'okay' && $status ne '') {
               &Apache::lonnet::logthis('status = '.$status);
               return ();
           }
           my $returnhash = &get_student_data_from_performance_cache($sname,$sdom,
                                                         $symb,$courseid);
           return %$returnhash if (defined($returnhash));
       }
       return ();
   }
   
   ################################################
   ################################################
   
   =pod
   
   =back
   
   =item End of Local Data Caching Subroutines
   
   =cut
   
   ################################################
   ################################################
   
   
   }
   ################################################
   ################################################
   
   =pod
   
   =head3 Classlist Subroutines
   
   =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  [$sdom,$sname,$end,$start,$id,$section,$fullname,$status]
   
   The constant values CL_SDOM, CL_SNAME, CL_END, etc. can be used
   as indices into the returned list to future-proof clients against
   changes in the list order.
   
   =cut
   
   ################################################
   ################################################
   
   sub CL_SDOM     { return 0; }
   sub CL_SNAME    { return 1; }
   sub CL_END      { return 2; }
   sub CL_START    { return 3; }
   sub CL_ID       { return 4; }
   sub CL_SECTION  { return 5; }
   sub CL_FULLNAME { return 6; }
   sub CL_STATUS   { return 7; }
   
   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;
     }      }
 }  }
   
Line 840  sub GetFileTimestamp { Line 2551  sub GetFileTimestamp {
   
 1;  1;
 __END__  __END__
   
   

Removed from v.1.9  
changed lines
  Added in v.1.59


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