Diff for /loncom/interface/loncoursedata.pm between versions 1.36 and 1.141

version 1.36, 2002/10/16 13:43:34 version 1.141, 2004/11/02 20:48:02
Line 1 Line 1
 # The LearningOnline Network with CAPA  # The LearningOnline Network with CAPA
 # (Publication Handler  
 #  #
 # $Id$  # $Id$
 #  #
Line 53  use strict; Line 52  use strict;
 use Apache::Constants qw(:common :http);  use Apache::Constants qw(:common :http);
 use Apache::lonnet();  use Apache::lonnet();
 use Apache::lonhtmlcommon;  use Apache::lonhtmlcommon;
   use Time::HiRes;
   use Apache::lonmysql;
 use HTML::TokeParser;  use HTML::TokeParser;
 use GDBM_File;  use GDBM_File;
   
Line 65  and/or itself. Line 66  and/or itself.
   
 =cut  =cut
   
 # ----- DOWNLOAD INFORMATION -------------------------------------------  ####################################################
   ####################################################
   
 =pod  =pod
   
 =item &DownloadClasslist()  =item &get_sequence_assessment_data()
   
 Collects lastname, generation, middlename, firstname, PID, and section for each  Use lonnavmaps to build a data structure describing the order and 
 student from their environment database.  The section data is also download, though  assessment contents of each sequence in the current course.
 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  The returned structure is a hash reference. 
   
   { title => 'title',
     symb  => 'symb',
     src   => '/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.
   
 Input: $courseID, $lastDownloadTime, $c  
   
 $courseID:  The id of the course  =cut
   
 $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.  sub get_sequence_assessment_data {
       my $fn=$ENV{'request.course.fn'};
       ##
       ## use navmaps
       my $navmap = Apache::lonnavmaps::navmap->new();
       if (!defined($navmap)) {
           return 'Can not open Coursemap';
       }
       # We explicity grab the top level map because I am not sure we
       # are pulling it from the iterator.
       my $top_level_map = $navmap->getById('0.0');
       #
       my $iterator = $navmap->getIterator(undef, undef, undef, 1);
       my $curRes = $iterator->next(); # Top level sequence
       ##
       ## 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_level_map->symb();
       my $src   = $top_level_map->src();
       my $randompick = $top_level_map->randompick();
       #
       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   => [], 
                   randompick => $randompick,
               };
       push (@Sequences,$top);
       push (@Nested_Sequences, $top);
       #
       # We need to keep track of which sequences contain homework problems
       # 
       my $previous_too;
       my $previous;
       while (scalar(@Nested_Sequences)) {
           $previous_too = $previous;
           $previous = $curRes;
           $curRes = $iterator->next();
           my $currentmap = $Nested_Sequences[-1]; # Last one on the stack
           if ($curRes == $iterator->BEGIN_MAP()) {
               if (! ref($previous)) {
                   $previous = $previous_too;
               }
               if (! ref($previous)) {
                   next;
               }
               # get the map itself, instead of BEGIN_MAP
               $title = $previous->compTitle;
               $symb  = $previous->symb();
               $src   = $previous->src();
               $randompick = $previous->randompick();
               my $newmap = { title    => $title,
                              src      => $src,
                              symb     => $symb,
                              type     => 'container',
                              num_assess => 0,
                              randompick => $randompick,
                              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->src() !~ /\.survey$/);
           # Okay, from here on out we only deal with assessments
           $title = $curRes->compTitle();
           $symb  = $curRes->symb();
           $src   = $curRes->src();
           my $parts = $curRes->parts();
           my %partdata;
           foreach my $part (@$parts) {
               my @Responses = $curRes->responseType($part);
               my @Ids       = $curRes->responseIds($part);
               $partdata{$part}->{'ResponseTypes'}= \@Responses;
               $partdata{$part}->{'ResponseIds'}  = \@Ids;
               $partdata{$part}->{'Survey'}       = $curRes->is_survey($part);
               # Count how many responses of each type there are in this part
               foreach (@Responses) {
                   $partdata{$part}->{$_}++;
               }
           }
           my $assessment = { title => $title,
                              src   => $src,
                              symb  => $symb,
                              type  => 'assessment',
                              parts => $parts,
                              num_parts => scalar(@$parts),
                              partdata => \%partdata,
                          };
           push(@Assessments,$assessment);
           push(@{$currentmap->{'contents'}},$assessment);
           $currentmap->{'num_assess'}++;
           $currentmap->{'num_assess_parts'}+= scalar(@$parts);
       }
       return ($top,\@Sequences,\@Assessments);
   }
   
 $c: The connection class that can determine if the browser has aborted.  It  sub LoadDiscussion {
 is used to short circuit this function so that it does not continue to       my ($courseID)=@_;
 get information when there is no need.      my %Discuss=();
       my %contrib=&Apache::lonnet::dump(
                   $courseID,
                   $ENV{'course.'.$courseID.'.domain'},
                   $ENV{'course.'.$courseID.'.num'});
     
       #my %contrib=&DownloadCourseInformation($name, $courseID, 0);
   
 Output: \%classlist      foreach my $temp(keys %contrib) {
    if ($temp=~/^version/) {
       my $ver=$contrib{$temp};
       my ($dummy,$prb)=split(':',$temp);
       for (my $idx=1; $idx<=$ver; $idx++ ) {
    my $name=$contrib{"$idx:$prb:sendername"};
    $Discuss{"$name:$prb"}=$idx;
       }
    }
       }       
   
 \%classlist: A pointer to a hash containing the following data:      return \%Discuss;
   }
   
 -A list of student name:domain (as keys) (known below as $name)  ################################################
   ################################################
   
 -A hash pointer for each student containing lastname, generation, firstname,  =pod
 middlename, and PID : Key is $name.studentInformation  
   
 -A hash pointer to each students section data : Key is $name.section  =item &make_into_hash($values);
   
 -If there was an error in dump, it will be returned in the hash.  See  Returns a reference to a hash as described by $values.  $values is
 the error codes for dump in lonnet.  Also, an error key will be   assumed to be the result of 
 generated if an abort occurs.      join(':',map {&Apache::lonnet::escape($_)} %orighash);
   
 =back  This is a helper function for get_current_state.
   
 =cut  =cut
   
 sub DownloadClasslist {  ################################################
     my ($courseID, $lastDownloadTime, $c)=@_;  ################################################
     my ($courseDomain,$courseNumber)=split(/\_/,$courseID);  sub make_into_hash {
     my %classlist;      my $values = shift;
       my %tmp = map { &Apache::lonnet::unescape($_); }
     my $modifiedTime = &Apache::lonnet::GetFileTimestamp($courseDomain, $courseNumber,                                             split(':',$values);
                                                          'classlist.db',       return \%tmp;
                                                          $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' &&  
        $lastDownloadTime >= $modifiedTime && $modifiedTime >= 0) {  
         # Data is not gathered so return UpToDate as true.  This  
         # will be interpreted in ProcessClasslist  
         $classlist{'lastDownloadTime'}=time;  
         $classlist{'UpToDate'} = 'true';  
         return \%classlist;  
     }  
   
     %classlist=&Apache::lonnet::dump('classlist',$courseDomain, $courseNumber);  
     foreach(keys (%classlist)) {  
         if(/^(con_lost|error|no_such_host)/i) {  
     return;  
         }  
     }  
   
     foreach my $name (keys(%classlist)) {  ################################################
         if(defined($c) && ($c->aborted())) {  ################################################
             $classlist{'error'}='aborted';  
             return \%classlist;  =pod
         }  
   
         my ($studentName,$studentDomain) = split(/\:/,$name);  =head1 LOCAL DATA CACHING SUBROUTINES
         # Download student environment data, specifically the full name and id.  
         my %studentInformation=&Apache::lonnet::get('environment',  
                                                     ['lastname','generation',  
                                                      'firstname','middlename',  
                                                      'id'],  
                                                     $studentDomain,  
                                                     $studentName);  
         $classlist{$name.':studentInformation'}=\%studentInformation;  
   
         if($c->aborted()) {  The local caching is done using MySQL.  There is no fall-back implementation
             $classlist{'error'}='aborted';  if MySQL is not running.
             return \%classlist;  
         }  
   
         #Section  The programmers interface is to call &get_current_state() or some other
         my %section=&Apache::lonnet::dump('roles',$studentDomain,$studentName);  primary interface subroutine (described below).  The internals of this 
         $classlist{$name.':sections'}=\%section;  storage system are documented here.
     }  
   
     $classlist{'UpToDate'} = 'false';  There are six tables used to store student performance data (the results of
     $classlist{'lastDownloadTime'}=time;  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.
   
     return \%classlist;  Some notes before we get started.
 }  
   
 =pod  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!
   
 =item &DownloadCourseInformation()  INDEXes work best on integer data.
   
 Dump of all the course information for a single student.  The data can be  JOIN is used to combine data from many tables into one output.
 pruned by making use of dumps regular expression arguement.  This function  
 also takes a regular expression which it passes straight through to dump.    lonmysql.pm is used for some of the interface, specifically the table creation
 The data is no escaped, because it is done elsewhere.  It also  calls.  The inserts are done in bulk by directly calling the database handler.
 checks the timestamp of the students course database file and only downloads  The SELECT ... JOIN statement used to retrieve the data does not have an
 if it has been modified since the last download.  interface in lonmysql.pm and I shudder at the thought of writing one.
   
   =head3 Table Descriptions
   
 =over 4  =over 4
   
 Input: $namedata, $courseID, $lastDownloadTime, $WhatIWant  =item Tables used to store meta information
   
 $namedata: student name:domain  The following tables hold data required to keep track of the current status
   of a students data in the tables or to look up the students data in the tables.
   
 $courseID:  The id of the course  =over 4
   
 $lastDownloadTime:  This is the date stamp for when this information was  =item $symb_table
 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  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'.
   
 Output: \%courseData  =item $part_table
   
 \%courseData:  A hash pointer to the raw data from the students course  The part_table has two columns.  The first is a 'part_id' and the second
 database.  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'.
   
 =back  =item $student_table
   
 =cut  The student_table has 7 columns.  The first is a 'student_id' assigned by 
   MySQL.  The second is 'student' which is username:domain.  The third through
   fifth are 'section', 'status' (enrollment status), and 'classification' 
   (to be used in the future).  The sixth and seventh ('updatetime' and 
   'fullupdatetime') contain the time of last update and full update of student
   data.  This table has its PRIMARY KEY on the 'student_id' column and is indexed
   on 'student', 'section', and 'status'.
   
 sub DownloadCourseInformation {  =back 
     my ($namedata,$courseID,$lastDownloadTime,$WhatIWant)=@_;  
     my %courseData;  
     my ($name,$domain) = split(/\:/,$namedata);  
   
     my $modifiedTime = &Apache::lonnet::GetFileTimestamp($domain, $name,  =item Tables used to store current status data
                                       $courseID.'.db',   
                                       $Apache::lonnet::perlvar{'lonUsersDir'});  
   
     if($lastDownloadTime >= $modifiedTime && $modifiedTime >= 0) {  The following tables store data only about the students current status on 
         # Data is not gathered so return UpToDate as true.  This  a problem, meaning only the data related to the last attempt on a problem.
         # will be interpreted in ProcessClasslist  
         $courseData{$namedata.':lastDownloadTime'}=time;  
         $courseData{$namedata.':UpToDate'} = 'true';  
         return \%courseData;  
     }  
   
     # Download course data  =over 4
     if(!defined($WhatIWant)) {  
         # set the regular expression to everything by setting it to period  
         $WhatIWant = '.';  
     }  
     %courseData=&Apache::lonnet::dump($courseID, $domain, $name, $WhatIWant);  
     $courseData{'UpToDate'} = 'false';  
     $courseData{'lastDownloadTime'}=time;  
   
     my %newData;  =item $performance_table
     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;  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.
   
 # ----- END DOWNLOAD INFORMATION ---------------------------------------  =back
   
 =pod  =item Tables used for storing historic data
   
 =head1 PROCESSING FUNCTIONS  The following tables are used to store almost all of the transactions a student
   has made on a homework problem.  See loncapa/docs/homework/datastorage for 
   specific information about each of the parameters stored.  
   
 These functions process all the data for all the students.  Also, they  =over 4
 are the functions that access the cache database for writing the majority of  
 the time.  The downloading and caching were separated to reduce problems   
 with stopping downloading then can not tie hash to database later.  
   
 =cut  =item $fulldump_response_table
   
 # ----- PROCESSING FUNCTIONS ---------------------------------------  The response table holds data (documented in loncapa/docs/homework/datastorage)
   associated with a particular response id which is stored when a student 
   attempts a problem.  The following are the columns of the table, in order:
   'symb_id','part_id','response_id','student_id','transaction','tries',
   'awarddetail', 'response_specific' (data particular to the response
   type), 'response_specific_value', and 'submission (the text of the students
   submission).  The primary key is based on the first five columns listed above.
   
   =item $fulldump_part_table
   
   The part table holds data (documented in loncapa/docs/homework/datastorage)
   associated with a particular part id which is stored when a student attempts
   a problem.  The following are the columns of the table, in order:
   'symb_id','part_id','student_id','transaction','tries','award','awarded',
   and 'previous'.  The primary key is based on the first five columns listed 
   above.
   
   =item $fulldump_timestamp_table
   
   The timestamp table holds the timestamps of the transactions which are
   stored in $fulldump_response_table and $fulldump_part_table.  This data is
   about both the response and part data.  Columns: 'symb_id','student_id',
   'transaction', and 'timestamp'.  
   The primary key is based on the first 3 columns.
   
   =item $weight_table
   
   The weight table holds the weight for the problems used in the class.
   Whereas the weight of a problem can vary by section and student the data
   here is applied to the class as a whole.
   Columns: 'symb_id','part_id','response_id','weight'.
   
 =pod  =back
   
 =item &ProcessTopResourceMap()  =back
   
 Trace through the "big hash" created in rat/lonuserstate.pm::loadmap.    =head3 Important Subroutines
 Basically, this function organizes a subset of the data and stores it in  
 cached data.  The data stored is the problems, sequences, sequence titles,  Here is a brief overview of the subroutines which are likely to be of 
 parts of problems, and their ordering.  Column width information is also   interest:
 partially handled here on a per sequence basis.  
   
 =over 4  =over 4
   
 Input: $cache, $c  =item &get_current_state(): programmers interface.
   
 $cache:  A pointer to a hash to store the information  =item &init_dbs(): table creation
   
 $c:  The connection class used to determine if an abort has been sent to the   =item &update_student_data(): data storage calls
 browser  
   
 Output: A string that contains an error message or "OK" if everything went   =item &get_student_data_from_performance_cache(): data retrieval
 smoothly.  
   
 =back  =back
   
   =head3 Main Documentation
   
   =over 4
   
 =cut  =cut
   
 sub ProcessTopResourceMap {  ################################################
     my ($cache,$c)=@_;  ################################################
     my %hash;  
     my $fn=$ENV{'request.course.fn'};  
     if(-e "$fn.db") {  
  my $tieTries=0;  
  while($tieTries < 3) {  
             if($c->aborted()) {  
                 return;  
             }  
     if(tie(%hash,'GDBM_File',"$fn.db",&GDBM_READER(),0640)) {  
  last;  
     }  
     $tieTries++;  
     sleep 1;  
  }  
  if($tieTries >= 3) {  
             return 'Coursemap undefined.';  
         }  
     } else {  
         return 'Can not open Coursemap.';  
     }  
   
     my $oldkeys;  ################################################
     if(defined($cache->{'ResourceKeys'})) {  ################################################
         $oldkeys = $cache->{'ResourceKeys'};  { # Begin scope of table identifiers
         foreach (split(':::', $cache->{'ResourceKeys'})) {  
             delete $cache->{$_};  
         }  
         delete $cache->{'ResourceKeys'};  
     }  
   
     # Initialize state machine.  Set information pointing to top level map.  
     my (@sequences, @currentResource, @finishResource);  
     my ($currentSequence, $currentResourceID, $lastResourceID);  
   
     $currentResourceID=$hash{'ids_'.  
       &Apache::lonnet::clutter($ENV{'request.course.uri'})};  
     push(@currentResource, $currentResourceID);  
     $lastResourceID=-1;  
     $currentSequence=-1;  
     my $topLevelSequenceNumber = $currentSequence;  
   
     my %sequenceRecord;  
     my %allkeys;  
     while(1) {  
         if($c->aborted()) {  
             last;  
         }  
  # HANDLE NEW SEQUENCE!  
  #if page || sequence  
  if(defined($hash{'map_pc_'.$hash{'src_'.$currentResourceID}}) &&  
            !defined($sequenceRecord{$currentResourceID})) {  
             $sequenceRecord{$currentResourceID}++;  
     push(@sequences, $currentSequence);  
     push(@currentResource, $currentResourceID);  
     push(@finishResource, $lastResourceID);  
   
     $currentSequence=$hash{'map_pc_'.$hash{'src_'.$currentResourceID}};  
   
             # Mark sequence as containing problems.  If it doesn't, then  
             # it will be removed when processing for this sequence is  
             # complete.  This allows the problems in a sequence  
             # to be outputed before problems in the subsequences  
             if(!defined($cache->{'orderedSequences'})) {  
                 $cache->{'orderedSequences'}=$currentSequence;  
             } else {  
                 $cache->{'orderedSequences'}.=':'.$currentSequence;  
             }  
             $allkeys{'orderedSequences'}++;  
   
     $lastResourceID=$hash{'map_finish_'.  my $current_course ='';
   $hash{'src_'.$currentResourceID}};  my $symb_table;
     $currentResourceID=$hash{'map_start_'.  my $part_table;
      $hash{'src_'.$currentResourceID}};  my $student_table;
   my $performance_table;
     if(!($currentResourceID) || !($lastResourceID)) {  my $parameters_table;
  $currentSequence=pop(@sequences);  my $fulldump_response_table;
  $currentResourceID=pop(@currentResource);  my $fulldump_part_table;
  $lastResourceID=pop(@finishResource);  my $fulldump_timestamp_table;
  if($currentSequence eq $topLevelSequenceNumber) {  my $weight_table;
     last;  
  }  
     }  
             next;  
  }  
   
  # Handle gradable resources: exams, problems, etc  my @Tables;
  $currentResourceID=~/(\d+)\.(\d+)/;  ################################################
         my $partA=$1;  ################################################
         my $partB=$2;  
  if($hash{'src_'.$currentResourceID}=~  
    /\.(problem|exam|quiz|assess|survey|form)$/ &&  
    $partA eq $currentSequence &&   
            !defined($sequenceRecord{$currentSequence.':'.  
                                     $currentResourceID})) {  
             $sequenceRecord{$currentSequence.':'.$currentResourceID}++;  
     my $Problem = &Apache::lonnet::symbclean(  
   &Apache::lonnet::declutter($hash{'map_id_'.$partA}).  
   '___'.$partB.'___'.  
   &Apache::lonnet::declutter($hash{'src_'.  
  $currentResourceID}));  
   
     $cache->{$currentResourceID.':problem'}=$Problem;  
             $allkeys{$currentResourceID.':problem'}++;  
     if(!defined($cache->{$currentSequence.':problems'})) {  
  $cache->{$currentSequence.':problems'}=$currentResourceID;  
     } else {  
  $cache->{$currentSequence.':problems'}.=  
     ':'.$currentResourceID;  
     }  
             $allkeys{$currentSequence.':problems'}++;  
   
     my $meta=$hash{'src_'.$currentResourceID};  =pod
 #            $cache->{$currentResourceID.':title'}=  
 #                &Apache::lonnet::metdata($meta,'title');  
             $cache->{$currentResourceID.':title'}=  
                 $hash{'title_'.$currentResourceID};  
             $allkeys{$currentResourceID.':title'}++;  
             $cache->{$currentResourceID.':source'}=  
                 $hash{'src_'.$currentResourceID};  
             $allkeys{$currentResourceID.':source'}++;  
   
             # Get Parts for problem  
             my %beenHere;  
             foreach (split(/\,/,&Apache::lonnet::metadata($meta,'packages'))) {  
                 if(/^\w+response_\d+.*/) {  
                     my (undef, $partId, $responseId) = split(/_/,$_);  
                     if($beenHere{'p:'.$partId} ==  0) {  
                         $beenHere{'p:'.$partId}++;  
                         if(!defined($cache->{$currentSequence.':'.  
                                             $currentResourceID.':parts'})) {  
                             $cache->{$currentSequence.':'.$currentResourceID.  
                                      ':parts'}=$partId;  
                         } else {  
                             $cache->{$currentSequence.':'.$currentResourceID.  
                                      ':parts'}.=':'.$partId;  
                         }  
                         $allkeys{$currentSequence.':'.$currentResourceID.  
                                   ':parts'}++;  
                     }  
                     if($beenHere{'r:'.$partId.':'.$responseId} == 0) {  
                         $beenHere{'r:'.$partId.':'.$responseId}++;  
                         if(!defined($cache->{$currentSequence.':'.  
                                              $currentResourceID.':'.$partId.  
                                              ':responseIDs'})) {  
                             $cache->{$currentSequence.':'.$currentResourceID.  
                                      ':'.$partId.':responseIDs'}=$responseId;  
                         } else {  
                             $cache->{$currentSequence.':'.$currentResourceID.  
                                      ':'.$partId.':responseIDs'}.=':'.  
                                                                   $responseId;  
                         }  
                         $allkeys{$currentSequence.':'.$currentResourceID.':'.  
                                      $partId.':responseIDs'}++;  
                     }  
                     if(/^optionresponse/ &&   
                        $beenHere{'o:'.$partId.':'.$currentResourceID} == 0) {  
                         $beenHere{'o:'.$partId.$currentResourceID}++;  
                         if(defined($cache->{'OptionResponses'})) {  
                             $cache->{'OptionResponses'}.= ':::'.  
                                 $currentSequence.':'.$currentResourceID.':'.  
                                 $partId.':'.$responseId;  
                         } else {  
                             $cache->{'OptionResponses'}= $currentSequence.':'.  
                                 $currentResourceID.':'.  
                                 $partId.':'.$responseId;  
                         }  
                         $allkeys{'OptionResponses'}++;  
                     }  
                 }  
             }  
         }  
   
  # if resource == finish resource, then it is the end of a sequence/page  =item &init_dbs()
  if($currentResourceID eq $lastResourceID) {  
     # pop off last resource of sequence  
     $currentResourceID=pop(@currentResource);  
     $lastResourceID=pop(@finishResource);  
   
     if(defined($cache->{$currentSequence.':problems'})) {  
  # Capture sequence information here  
  $cache->{$currentSequence.':title'}=  
     $hash{'title_'.$currentResourceID};  
                 $allkeys{$currentSequence.':title'}++;  
                 $cache->{$currentSequence.':source'}=  
                     $hash{'src_'.$currentResourceID};  
                 $allkeys{$currentSequence.':source'}++;  
   
                 my $totalProblems=0;  
                 foreach my $currentProblem (split(/\:/,  
                                                $cache->{$currentSequence.  
                                                ':problems'})) {  
                     foreach (split(/\:/,$cache->{$currentSequence.':'.  
                                                    $currentProblem.  
                                                    ':parts'})) {  
                         $totalProblems++;  
                     }  
                 }  
  my @titleLength=split(//,$cache->{$currentSequence.  
                                                     ':title'});  
                 # $extra is 3 for problems correct and 3 for space  
                 # between problems correct and problem output  
                 my $extra = 6;  
  if(($totalProblems + $extra) > (scalar @titleLength)) {  
     $cache->{$currentSequence.':columnWidth'}=  
                         $totalProblems + $extra;  
  } else {  
     $cache->{$currentSequence.':columnWidth'}=  
                         (scalar @titleLength);  
  }  
                 $allkeys{$currentSequence.':columnWidth'}++;  
     } else {  
                 # Remove sequence from list, if it contains no problems to  
                 # display.  
                 $cache->{'orderedSequences'}=~s/$currentSequence//;  
                 $cache->{'orderedSequences'}=~s/::/:/g;  
                 $cache->{'orderedSequences'}=~s/^:|:$//g;  
             }  
   
     $currentSequence=pop(@sequences);  Input: course id
     if($currentSequence eq $topLevelSequenceNumber) {  
  last;  
     }  
         }  
   
  # MOVE!!!  Output: 0 on success, positive integer on error
  # move to next resource  
  unless(defined($hash{'to_'.$currentResourceID})) {  
     # big problem, need to handle.  Next is probably wrong  
             my $errorMessage = 'Big problem in ';  
             $errorMessage .= 'loncoursedata::ProcessTopLevelMap.';  
             $errorMessage .= '  bighash to_$currentResourceID not defined!';  
             &Apache::lonnet::logthis($errorMessage);  
     last;  
  }  
  my @nextResources=();  
  foreach (split(/\,/,$hash{'to_'.$currentResourceID})) {  
             if(!defined($sequenceRecord{$currentSequence.':'.  
                                         $hash{'goesto_'.$_}})) {  
                 push(@nextResources, $hash{'goesto_'.$_});  
             }  
  }  
  push(@currentResource, @nextResources);  
  # Set the next resource to be processed  
  $currentResourceID=pop(@currentResource);  
     }  
   
     my @theKeys = keys(%allkeys);  This routine issues the calls to lonmysql to create the tables used to
     my $newkeys = join(':::', @theKeys);  store student data.
     $cache->{'ResourceKeys'} = join(':::', $newkeys);  
     if($newkeys ne $oldkeys) {  
         $cache->{'ResourceUpdated'} = 'true';  
     } else {  
         $cache->{'ResourceUpdated'} = 'false';  
     }  
   
     unless (untie(%hash)) {  =cut
         &Apache::lonnet::logthis("<font color=blue>WARNING: ".  
                                  "Could not untie coursemap $fn (browse)".  ################################################
                                  ".</font>");   ################################################
   sub init_dbs {
       my ($courseid,$drop) = @_;
       &setup_table_names($courseid);
       #
       # Drop any of the existing tables
       if ($drop) {
           foreach my $table (@Tables) {
               &Apache::lonmysql::drop_table($table);
           }
       }
       #
       # 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) BINARY',
                         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) BINARY',
                         restrictions => 'NOT NULL UNIQUE'},
                       { name => 'section',
                         type => 'VARCHAR(100) BINARY',
                         restrictions => 'NOT NULL'},
                       { name => 'status',
                         type => 'VARCHAR(15) BINARY',
                         restrictions => 'NOT NULL'},
                       { name => 'classification',
                         type => 'VARCHAR(100) BINARY', },
                       { name => 'updatetime',
                         type => 'INT UNSIGNED'},
                       { name => 'fullupdatetime',
                         type => 'INT UNSIGNED'},
                       ],
           'PRIMARY KEY' => ['student_id'],
           'KEY' => [{ columns => ['student (100)',
                                   'section (100)',
                                   'status (15)',]},],
       };
       #
       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 => 'part',
                         type => 'VARCHAR(100) BINARY',
                         restrictions => 'NOT NULL'},                    
                       { name => 'solved',
                         type => 'TINYTEXT' },
                       { name => 'tries',
                         type => 'SMALLINT UNSIGNED' },
                       { name => 'awarded',
                         type => 'REAL' },
                       { 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 $fulldump_part_table_def = {
           id => $fulldump_part_table,
           permanent => 'no',
           columns => [
                       { name => 'symb_id',
                         type => 'MEDIUMINT UNSIGNED',
                         restrictions => 'NOT NULL'  },
                       { name => 'part_id',
                         type => 'MEDIUMINT UNSIGNED',
                         restrictions => 'NOT NULL' },
                       { name => 'student_id',
                         type => 'MEDIUMINT UNSIGNED',
                         restrictions => 'NOT NULL'  },
                       { name => 'transaction',
                         type => 'MEDIUMINT UNSIGNED',
                         restrictions => 'NOT NULL' },
                       { name => 'tries',
                         type => 'SMALLINT UNSIGNED',
                         restrictions => 'NOT NULL' },
                       { name => 'award',
                         type => 'TINYTEXT' },
                       { name => 'awarded',
                         type => 'REAL' },
                       { name => 'previous',
                         type => 'SMALLINT UNSIGNED' },
   #                    { name => 'regrader',
   #                      type => 'TINYTEXT' },
   #                    { name => 'afterduedate',
   #                      type => 'TINYTEXT' },
                       ],
           'PRIMARY KEY' => ['symb_id','part_id','student_id','transaction'],
           'KEY' => [
                     { columns=>['symb_id'] },
                     { columns=>['part_id'] },
                     { columns=>['student_id'] },
                     ],
       };
       #
       my $fulldump_response_table_def = {
           id => $fulldump_response_table,
           permanent => 'no',
           columns => [
                       { name => 'symb_id',
                         type => 'MEDIUMINT UNSIGNED',
                         restrictions => 'NOT NULL'  },
                       { name => 'part_id',
                         type => 'MEDIUMINT UNSIGNED',
                         restrictions => 'NOT NULL' },
                       { name => 'response_id',
                         type => 'MEDIUMINT UNSIGNED',
                         restrictions => 'NOT NULL'  },
                       { name => 'student_id',
                         type => 'MEDIUMINT UNSIGNED',
                         restrictions => 'NOT NULL'  },
                       { name => 'transaction',
                         type => 'MEDIUMINT UNSIGNED',
                         restrictions => 'NOT NULL' },
                       { name => 'awarddetail',
                         type => 'TINYTEXT' },
   #                    { name => 'message',
   #                      type => 'CHAR BINARY'},
                       { name => 'response_specific',
                         type => 'TINYTEXT' },
                       { name => 'response_specific_value',
                         type => 'TINYTEXT' },
                       { name => 'submission',
                         type => 'TEXT'},
                       ],
               'PRIMARY KEY' => ['symb_id','part_id','response_id','student_id',
                                 'transaction'],
               'KEY' => [
                         { columns=>['symb_id'] },
                         { columns=>['part_id','response_id'] },
                         { columns=>['student_id'] },
                         ],
       };
       my $fulldump_timestamp_table_def = {
           id => $fulldump_timestamp_table,
           permanent => 'no',
           columns => [
                       { name => 'symb_id',
                         type => 'MEDIUMINT UNSIGNED',
                         restrictions => 'NOT NULL'  },
                       { name => 'student_id',
                         type => 'MEDIUMINT UNSIGNED',
                         restrictions => 'NOT NULL'  },
                       { name => 'transaction',
                         type => 'MEDIUMINT UNSIGNED',
                         restrictions => 'NOT NULL' },
                       { name => 'timestamp',
                         type => 'INT UNSIGNED'},
                       ],
           'PRIMARY KEY' => ['symb_id','student_id','transaction'],
           'KEY' => [
                     { columns=>['symb_id'] },
                     { columns=>['student_id'] },
                     { columns=>['transaction'] },
                     ],
       };
       #
       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)'],
       };
       #
       my $weight_table_def = {
           id => $weight_table,
           permanent => 'no',
           columns => [{ name => 'symb_id',
                         type => 'MEDIUMINT UNSIGNED',
                         restrictions => 'NOT NULL'  },
                       { name => 'part_id',
                         type => 'MEDIUMINT UNSIGNED',
                         restrictions => 'NOT NULL'  },
                       { name => 'weight',
                         type => 'REAL',
                         restrictions => 'NOT NULL'  },
                       ],
           'PRIMARY KEY' => ['symb_id','part_id'],
       };
       #
       # 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($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;
       }
       #
       $tableid = &Apache::lonmysql::create_table($fulldump_part_table_def);
       if (! defined($tableid)) {
           &Apache::lonnet::logthis("error creating fulldump_part_table: ".
                                    &Apache::lonmysql::get_error());
           return 7;
       }
       #
       $tableid = &Apache::lonmysql::create_table($fulldump_response_table_def);
       if (! defined($tableid)) {
           &Apache::lonnet::logthis("error creating fulldump_response_table: ".
                                    &Apache::lonmysql::get_error());
           return 8;
       }
       $tableid = &Apache::lonmysql::create_table($fulldump_timestamp_table_def);
       if (! defined($tableid)) {
           &Apache::lonnet::logthis("error creating fulldump_timestamp_table: ".
                                    &Apache::lonmysql::get_error());
           return 9;
       }
       $tableid = &Apache::lonmysql::create_table($weight_table_def);
       if (! defined($tableid)) {
           &Apache::lonnet::logthis("error creating weight_table: ".
                                    &Apache::lonmysql::get_error());
           return 10;
       }
       return 0;
   }
   
   ################################################
   ################################################
   
     return 'OK';  =pod
   
   =item &delete_caches()
   
   =cut
   
   ################################################
   ################################################
   sub delete_caches {
       my $courseid = shift;
       $courseid = $ENV{'request.course.id'} if (! defined($courseid));
       #
       &setup_table_names($courseid);
       #
       my $dbh = &Apache::lonmysql::get_dbh();
       foreach my $table (@Tables) {
           my $command = 'DROP TABLE '.$table.';';
           $dbh->do($command);
           if ($dbh->err) {
               &Apache::lonnet::logthis($command.' resulted in error: '.$dbh->errstr);
           }
       }
       return;
 }  }
   
   ################################################
   ################################################
   
 =pod  =pod
   
 =item &ProcessClasslist()  =item &get_part_id()
   
 Taking the class list dumped from &DownloadClasslist(), all the   Get the MySQL id of a problem part string.
 students and their non-class information is processed using the   
 &ProcessStudentInformation() function.  A date stamp is also recorded for  
 when the data was processed.  
   
 Takes data downloaded for a student and breaks it up into managable pieces and   Input: $part
 stored in cache data.  The username, domain, class related date, PID,   
 full name, and section are all processed here.  
   
 =over 4  Output: undef on error, integer $part_id on success.
   
 Input: $cache, $classlist, $courseID, $ChartDB, $c  =item &get_part()
   
 $cache: A hash pointer to store the data  Get the string describing a part from the MySQL id of the problem part.
   
 $classlist:  The hash of data collected about a student from   Input: $part_id
 &DownloadClasslist().  The hash contains a list of students, a pointer   
 to a hash of student information for each student, and each students section   
 number.  
   
 $courseID:  The course ID  
   
 $ChartDB:  The name of the cache database file.  
   
 $c:  The connection class used to determine if an abort has been sent to the   
 browser  
   
 Output: @names  
   
 @names:  An array of students whose information has been processed, and are to   
 be considered in an arbitrary order.  The entries in @names are of the form  
 username:domain.  
   
 The values in $cache are as follows:  
   
  *NOTE: for the following $name implies username:domain  
  $name.':error'                  only defined if an error occured.  Value  
                                  contains the error message  
  $name.':lastDownloadTime'       unconverted time of the last update of a  
                                  student\'s course data  
  $name.'updateTime'              coverted time of the last update of a   
                                  student\'s course data  
  $name.':username'               username of a student  
  $name.':domain'                 domain of a student  
  $name.':fullname'               full name of a student  
  $name.':id'                     PID of a student  
  $name.':Status'                 active/expired status of a student  
  $name.':section'                section of a student  
   
 =back  Output: undef on error, $part string on success.
   
 =cut  =cut
   
 sub ProcessClasslist {  ################################################
     my ($cache,$classlist,$courseID,$c)=@_;  ################################################
     my @names=();  
   
     $cache->{'ClasslistTimeStamp'}=$classlist->{'lastDownloadTime'};  
     if($classlist->{'UpToDate'} eq 'true') {  
         return split(/:::/,$cache->{'NamesOfStudents'});;  
     }  
   
     foreach my $name (keys(%$classlist)) {  
         if($name =~ /\:section/ || $name =~ /\:studentInformation/ ||  
            $name eq '' || $name eq 'UpToDate' || $name eq 'lastDownloadTime') {  
             next;  
         }  
         if($c->aborted()) {  
             return ();  
         }  
         my $studentInformation = $classlist->{$name.':studentInformation'};  
         my $date = $classlist->{$name};  
         my ($studentName,$studentDomain) = split(/\:/,$name);  
   
         $cache->{$name.':username'}=$studentName;  
         $cache->{$name.':domain'}=$studentDomain;  
         # Initialize timestamp for student  
         if(!defined($cache->{$name.':lastDownloadTime'})) {  
             $cache->{$name.':lastDownloadTime'}='Not downloaded';  
             $cache->{$name.':updateTime'}=' Not updated';  
         }  
   
         my $error = 0;  
         foreach(keys(%$studentInformation)) {  
             if(/^(con_lost|error|no_such_host)/i) {  
                 $cache->{$name.':error'}=  
                     'Could not download student environment data.';  
                 $cache->{$name.':fullname'}='';  
                 $cache->{$name.':id'}='';  
                 $error = 1;  
             }  
         }  
         next if($error);  
         push(@names,$name);  
         $cache->{$name.':fullname'}=&ProcessFullName(  
                                           $studentInformation->{'lastname'},  
                                           $studentInformation->{'generation'},  
                                           $studentInformation->{'firstname'},  
                                           $studentInformation->{'middlename'});  
         $cache->{$name.':id'}=$studentInformation->{'id'};  
   
         my ($end, $start)=split(':',$date);  
         $courseID=~s/\_/\//g;  
         $courseID=~s/^(\w)/\/$1/;  
   
         my $sec='';  
         my $sectionData = $classlist->{$name.':sections'};  
         foreach my $key (keys (%$sectionData)) {  
             my $value = $sectionData->{$key};  
             if ($key=~/^$courseID(?:\/)*(\w+)*\_st$/) {  
                 my $tempsection=$1;  
                 if($key eq $courseID.'_st') {  
                     $tempsection='';  
                 }  
                 my (undef,$roleend,$rolestart)=split(/\_/,$value);  
                 if($roleend eq $end && $rolestart eq $start) {  
                     $sec = $tempsection;  
                     last;  
                 }  
             }  
         }  
   
         my $status='Expired';  my $have_read_part_table = 0;
         if(((!$end) || time < $end) && ((!$start) || (time > $start))) {  my %ids_by_part;
             $status='Active';  my %parts_by_id;
   
   sub get_part_id {
       my ($part) = @_;
       $part = 0 if (! defined($part));
       if (! $have_read_part_table) {
           my @Result = &Apache::lonmysql::get_rows($part_table);
           foreach (@Result) {
               $ids_by_part{$_->[1]}=$_->[0];
           }
           $have_read_part_table = 1;
       }
       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];
         }          }
         $cache->{$name.':Status'}=$status;      }
         $cache->{$name.':section'}=$sec;      return $ids_by_part{$part} if (exists($ids_by_part{$part}));
       return undef; # error
   }
   
         if($sec eq '' || !defined($sec) || $sec eq ' ') {  sub get_part {
             $sec = 'none';      my ($part_id) = @_;
         }      if (! exists($parts_by_id{$part_id})  || 
         if(defined($cache->{'sectionList'})) {          ! defined($parts_by_id{$part_id}) ||
             if($cache->{'sectionList'} !~ /(^$sec:|^$sec$|:$sec$|:$sec:)/) {          $parts_by_id{$part_id} eq '') {
                 $cache->{'sectionList'} .= ':'.$sec;          my @Result = &Apache::lonmysql::get_rows($part_table);
             }          foreach (@Result) {
         } else {              $parts_by_id{$_->[0]}=$_->[1];
             $cache->{'sectionList'} = $sec;  
         }          }
     }      }
       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.
   
     $cache->{'ClasslistTimestamp'}=time;  =item &get_symb()
     $cache->{'NamesOfStudents'}=join(':::',@names);  
   Get the symb associated with a MySQL symb_id.
   
   Input: $symb_id
   
   Output: undef on error, $symb on success.
   
   =cut
   
     return @names;  ################################################
   ################################################
   
   my $have_read_symb_table = 0;
   my %ids_by_symb;
   my %symbs_by_id;
   
   sub get_symb_id {
       my ($symb) = @_;
       if (! $have_read_symb_table) {
           my @Result = &Apache::lonmysql::get_rows($symb_table);
           foreach (@Result) {
               $ids_by_symb{$_->[1]}=$_->[0];
           }
           $have_read_symb_table = 1;
       }
       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
 }  }
   
 =pod  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
   }
   
 =item &ProcessStudentData()  ################################################
   ################################################
   
 Takes the course data downloaded for a student in   =pod
 &DownloadCourseInformation() and breaks it up into key value pairs  
 to be stored in the cached data.  The keys are comprised of the   
 $username:$domain:$keyFromCourseDatabase.  The student username:domain is  
 stored away signifying that the students information has been downloaded and   
 can be reused from cached data.  
   
 =over 4  =item &get_student_id()
   
 Input: $cache, $courseData, $name  Get the MySQL id of a student.
   
 $cache: A hash pointer to store data  Input: $sname, $dom
   
 $courseData:  A hash pointer that points to the course data downloaded for a   Output: undef on error, integer $student_id on success.
 student.  
   
 $name:  username:domain  =item &get_student()
   
 Output: None  Get student username:domain associated with the MySQL student_id.
   
 *NOTE:  There is no output, but an error message is stored away in the cache   Input: $student_id
 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  Output: undef on error, string $student (username:domain) on success.
   
 =cut  =cut
   
 sub ProcessStudentData {  ################################################
     my ($cache,$courseData,$name)=@_;  ################################################
   
     if(!&CheckDateStampError($courseData, $cache, $name)) {  my $have_read_student_table = 0;
         return;  my %ids_by_student;
   my %students_by_id;
   
   sub get_student_id {
       my ($sname,$sdom) = @_;
       my $student = $sname.':'.$sdom;
       if (! $have_read_student_table) {
           my @Result = &Apache::lonmysql::get_rows($student_table);
           foreach (@Result) {
               $ids_by_student{$_->[1]}=$_->[0];
           }
           $have_read_student_table = 1;
       }
       if (! exists($ids_by_student{$student})) {
           &populate_student_table();
           undef(%ids_by_student);
           undef(%students_by_id);
           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
   }
   
     # This little delete thing, should not be here.  Move some other  sub get_student {
     # time though.      my ($student_id) = @_;
     if(defined($cache->{$name.':keys'})) {      if (! exists($students_by_id{$student_id})  || 
  foreach (split(':::', $cache->{$name.':keys'})) {          ! defined($students_by_id{$student_id}) ||
     delete $cache->{$name.':'.$_};          $students_by_id{$student_id} eq '') {
  }          my @Result = &Apache::lonmysql::get_rows($student_table);
         delete $cache->{$name.':keys'};          foreach (@Result) {
               $students_by_id{$_->[0]}=$_->[1];
           }
     }      }
       return $students_by_id{$student_id} if(exists($students_by_id{$student_id}));
       return undef; # error
   }
   
     my %courseKeys;  sub populate_student_table {
     # user name:domain was prepended earlier in DownloadCourseInformation      my ($courseid) = @_;
     foreach (keys %$courseData) {      if (! defined($courseid)) {
  my $currentKey = $_;          $courseid = $ENV{'request.course.id'};
  $currentKey =~ s/^$name//;      }
  $courseKeys{$currentKey}++;      #
         $cache->{$_}=$courseData->{$_};      &setup_table_names($courseid);
       &init_dbs($courseid,0);
       my $dbh = &Apache::lonmysql::get_dbh();
       my $request = 'INSERT IGNORE INTO '.$student_table.
           "(student,section,status) VALUES ";
       my $classlist = &get_classlist($courseid);
       my $student_count=0;
       while (my ($student,$data) = each %$classlist) {
           my ($section,$status) = ($data->[&CL_SECTION()],
                                    $data->[&CL_STATUS()]);
           if ($section eq '' || $section =~ /^\s*$/) {
               $section = 'none';
           }
           $request .= "('".$student."','".$section."','".$status."'),";
           $student_count++;
       }
       return if ($student_count == 0);
       chop($request);
       $dbh->do($request);
       if ($dbh->err()) {
           &Apache::lonnet::logthis("error ".$dbh->errstr().
                                    " occured executing \n".
                                    $request);
     }      }
   
     $cache->{$name.':keys'} = join(':::', keys(%courseKeys));  
   
     return;      return;
 }  }
   
   ################################################
   ################################################
   
 =pod  =pod
   
 =item &ExtractStudentData()  =item &clear_internal_caches()
   
 HISTORY: This function originally existed in every statistics module,  Causes the internal caches used in get_student_id, get_student,
 and performed different tasks, the had some overlap.  Due to the need  get_symb_id, get_symb, get_part_id, and get_part to be undef'd.
 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  Needs to be called before the first operation with the MySQL database
   for a given Apache request.
   
 Input: $input, $output, $data, $name  =cut
   
 $input: A hash that contains the input data to be processed  ################################################
   ################################################
   sub clear_internal_caches {
       $have_read_part_table = 0;
       undef(%ids_by_part);
       undef(%parts_by_id);
       $have_read_symb_table = 0;
       undef(%ids_by_symb);
       undef(%symbs_by_id);
       $have_read_student_table = 0;
       undef(%ids_by_student);
       undef(%students_by_id);
   }
   
 $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  =pod
   
 The input is slightly different here, but is quite simple.  =item &update_full_student_data($sname,$sdom,$courseid)
 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  Does a lonnet::dump on a student to populate the courses tables.
   
 *NOTE:  There is no output, but an error message is stored away in the cache   Input: $sname, $sdom, $courseid
 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  Output: $returnstatus
   
 =cut  $returnstatus is a string describing any errors that occured.  'okay' is the
   default.
   
   This subroutine loads a students data using lonnet::dump and inserts
   it into the MySQL database.  The inserts are done on three tables, 
   $fulldump_response_table, $fulldump_part_table, and $fulldump_timestamp_table.
   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.
   
   Once the "fulldump" tables are updated, the tables used for chart and
   spreadsheet (which hold only the current state of the student on their
   homework, not historical data) are updated.  If all updates have occured 
   successfully, $student_table is updated to reflect the time of the update.
   
   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.
   
 sub ExtractStudentData {  =cut
     my ($input, $output, $data, $name)=@_;  
   
     if(!&CheckDateStampError($input, $data, $name)) {  ################################################
         return;  ################################################
   sub update_full_student_data {
       my ($sname,$sdom,$courseid) = @_;
       #
       # Set up database names
       &setup_table_names($courseid);
       #
       my $student_id = &get_student_id($sname,$sdom);
       my $student = $sname.':'.$sdom;
       #
       my $returnstatus = 'okay';
       #
       # Download students data
       my $time_of_retrieval = time;
       my @tmp = &Apache::lonnet::dump($courseid,$sdom,$sname);
       if (@tmp && $tmp[0] =~ /^error/) {
           $returnstatus = 'error retrieving full student data';
           return $returnstatus;
       } elsif (! @tmp) {
           $returnstatus = 'okay: no student data';
           return $returnstatus;
     }      }
       my %studentdata = @tmp;
       #
       # Get database handle and clean out the tables 
       my $dbh = &Apache::lonmysql::get_dbh();
       $dbh->do('DELETE FROM '.$fulldump_response_table.' WHERE student_id='.
                $student_id);
       $dbh->do('DELETE FROM '.$fulldump_part_table.' WHERE student_id='.
                $student_id);
       $dbh->do('DELETE FROM '.$fulldump_timestamp_table.' WHERE student_id='.
                $student_id);
       #
       # Parse and store the data into a form we can handle
       my $partdata;
       my $respdata;
       while (my ($key,$value) = each(%studentdata)) {
           next if ($key =~ /^(\d+):(resource$|subnum$|keys:)/);
           my ($transaction,$symb,$parameter) = split(':',$key);
           my $symb_id = &get_symb_id($symb);
           if ($parameter eq 'timestamp') {
               # We can deal with 'timestamp' right away
               my @timestamp_storage = ($symb_id,$student_id,
                                        $transaction,$value);
               my $store_command = 'INSERT IGNORE INTO '.$fulldump_timestamp_table.
                   " VALUES ('".join("','",@timestamp_storage)."');";
               $dbh->do($store_command);
               if ($dbh->err()) {
                   &Apache::lonnet::logthis('unable to execute '.$store_command);
                   &Apache::lonnet::logthis($dbh->errstr());
               }
               next;
           } elsif ($parameter eq 'version') {
               next;
           } elsif ($parameter =~ /^resource\.(.*)\.(tries|
                                                     award|
                                                     awarded|
                                                     previous|
                                                     solved|
                                                     awarddetail|
                                                     submission|
                                                     submissiongrading|
                                                     molecule)\s*$/x){
               # we do not have enough information to store an 
               # entire row, so we save it up until later.
               my ($part_and_resp_id,$field) = ($1,$2);
               my ($part,$part_id,$resp,$resp_id);
               if ($part_and_resp_id =~ /\./) {
                   ($part,$resp) = split(/\./,$part_and_resp_id);
                   $part_id = &get_part_id($part);
                   $resp_id = &get_part_id($resp);
               } else {
                   $part_id = &get_part_id($part_and_resp_id);
               }
               # Deal with part specific data
               if ($field =~ /^(tries|award|awarded|previous)$/) {
                   $partdata->{$symb_id}->{$part_id}->{$transaction}->{$field}=$value;
               }
               # deal with response specific data
               if (defined($resp_id) &&
                   $field =~ /^(awarddetail|
                                submission|
                                submissiongrading|
                                molecule)$/x) {
                   if ($field eq 'submission') {
                       # We have to be careful with user supplied input.
                       # most of the time we are okay because it is escaped.
                       # However, there is one wrinkle: submissions which end in
                       # and odd number of '\' cause insert errors to occur.  
                       # Best trap this somehow...
                       $value = $dbh->quote($value);
                   }
                   if ($field eq 'submissiongrading' || 
                       $field eq 'molecule') {
                       $respdata->{$symb_id}->{$part_id}->{$resp_id}->{$transaction}->{'response_specific'}=$field;
                       $respdata->{$symb_id}->{$part_id}->{$resp_id}->{$transaction}->{'response_specific_value'}=$value;
                   } else {
                       $respdata->{$symb_id}->{$part_id}->{$resp_id}->{$transaction}->{$field}=$value;
                   }
               }
           }
       }
       ##
       ## Store the part data
       my $store_command = 'INSERT IGNORE INTO '.$fulldump_part_table.
           ' VALUES '."\n";
       my $store_rows = 0;
       while (my ($symb_id,$hash1) = each (%$partdata)) {
           while (my ($part_id,$hash2) = each (%$hash1)) {
               while (my ($transaction,$data) = each (%$hash2)) {
                   $store_command .= "('".join("','",$symb_id,$part_id,
                                               $student_id,
                                               $transaction,
                                               $data->{'tries'},
                                               $data->{'award'},
                                               $data->{'awarded'},
                                               $data->{'previous'})."'),";
                   $store_rows++;
               }
           }
       }
       if ($store_rows) {
           chop($store_command);
           $dbh->do($store_command);
           if ($dbh->err) {
               $returnstatus = 'error storing part data';
               &Apache::lonnet::logthis('insert error '.$dbh->errstr());
               &Apache::lonnet::logthis("While attempting\n".$store_command);
           }
       }
       ##
       ## Store the response data
       $store_command = 'INSERT IGNORE INTO '.$fulldump_response_table.
           ' VALUES '."\n";
       $store_rows = 0;
       while (my ($symb_id,$hash1) = each (%$respdata)) {
           while (my ($part_id,$hash2) = each (%$hash1)) {
               while (my ($resp_id,$hash3) = each (%$hash2)) {
                   while (my ($transaction,$data) = each (%$hash3)) {
                       my $submission = $data->{'submission'};
                       # We have to be careful with user supplied input.
                       # most of the time we are okay because it is escaped.
                       # However, there is one wrinkle: submissions which end in
                       # and odd number of '\' cause insert errors to occur.  
                       # Best trap this somehow...
                       $submission = $dbh->quote($submission);
                       $store_command .= "('".
                           join("','",$symb_id,$part_id,
                                $resp_id,$student_id,
                                $transaction,
                                $data->{'awarddetail'},
                                $data->{'response_specific'},
                                $data->{'response_specific_value'}).
                                "',".$submission."),";
                       $store_rows++;
                   }
               }
           }
       }
       if ($store_rows) {
           chop($store_command);
           $dbh->do($store_command);
           if ($dbh->err) {
               $returnstatus = 'error storing response data';
               &Apache::lonnet::logthis('insert error '.$dbh->errstr());
               &Apache::lonnet::logthis("While attempting\n".$store_command);
           }
       }
       ##
       ## Update the students "current" data in the performance 
       ## and parameters tables.
       my ($status,undef) = &store_student_data
           ($sname,$sdom,$courseid,
            &Apache::lonnet::convert_dump_to_currentdump(\%studentdata));
       if ($returnstatus eq 'okay' && $status ne 'okay') {
           $returnstatus = 'error storing current data:'.$status;
       } elsif ($status ne 'okay') {
           $returnstatus .= ' error storing current data:'.$status;
       }        
       ##
       ## Update the students time......
       if ($returnstatus eq 'okay') {
           &store_updatetime($student_id,$time_of_retrieval,$time_of_retrieval);
           if ($dbh->err) {
               if ($returnstatus eq 'okay') {
                   $returnstatus = 'error updating student time';
               } else {
                   $returnstatus = 'error updating student time';
               }
           }
       }
       return $returnstatus;
   }
   
     # This little delete thing, should not be here.  Move some other  ################################################
     # time though.  ################################################
     my %allkeys;  
     if(defined($output->{$name.':keys'})) {  =pod
  foreach (split(':::', $output->{$name.':keys'})) {  
     delete $output->{$name.':'.$_};  =item &update_student_data()
  }  
         delete $output->{$name.':keys'};  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) = @_;
       #
       # Set up database names
       &setup_table_names($courseid);
       #
       my $student_id = &get_student_id($sname,$sdom);
       my $student = $sname.':'.$sdom;
       #
       my $returnstatus = 'okay';
       #
       # 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,undef);
     }      }
       if (scalar(@tmp) < 1) {
           return ('no data',undef);
       }
       my %student_data = @tmp;
       my @Results = &store_student_data($sname,$sdom,$courseid,\%student_data);
       #
       # Set the students update time
       if ($Results[0] eq 'okay') {
           &store_updatetime($student_id,$time_of_retrieval,$time_of_retrieval);
       }
       #
       return @Results;
   }
   
     my ($username,$domain)=split(':',$name);  sub store_updatetime {
       my ($student_id,$updatetime,$fullupdatetime)=@_;
       my $values = '';
       if (defined($updatetime)) {
           $values = 'updatetime='.$updatetime.' ';
       }
       if (defined($fullupdatetime)) {
           if ($values ne '') {
               $values .= ',';
           }
           $values .= 'fullupdatetime='.$fullupdatetime.' ';
       }
       return if ($values eq '');
       my $dbh = &Apache::lonmysql::get_dbh();
       my $request = 'UPDATE '.$student_table.' SET '.$values.
           ' WHERE student_id='.$student_id.' LIMIT 1';
       $dbh->do($request);
   }
   
     my $Version;  sub store_student_data {
     my $problemsCorrect = 0;      my ($sname,$sdom,$courseid,$student_data) = @_;
     my $totalProblems   = 0;      #
     my $problemsSolved  = 0;      my $student_id = &get_student_id($sname,$sdom);
     my $numberOfParts   = 0;      my $student = $sname.':'.$sdom;
     my $totalAwarded    = 0;      #
     foreach my $sequence (split(':', $data->{'orderedSequences'})) {      my $returnstatus = 'okay';
         foreach my $problemID (split(':', $data->{$sequence.':problems'})) {      #
             my $problem = $data->{$problemID.':problem'};      # Remove all of the students data from the table
             my $LatestVersion = $input->{$name.':version:'.$problem};      my $dbh = &Apache::lonmysql::get_dbh();
       $dbh->do('DELETE FROM '.$performance_table.' WHERE student_id='.
             # Output dashes for all the parts of this problem if there               $student_id);
             # is no version information about the current problem.      $dbh->do('DELETE FROM '.$parameters_table.' WHERE student_id='.
             $output->{$name.':'.$problemID.':NoVersion'} = 'false';               $student_id);
             $allkeys{$name.':'.$problemID.':NoVersion'}++;      #
             if(!$LatestVersion) {      # Store away the data
                 foreach my $part (split(/\:/,$data->{$sequence.':'.      #
                                                       $problemID.      my $starttime = Time::HiRes::time;
                                                       ':parts'})) {      my $elapsed = 0;
                     $output->{$name.':'.$problemID.':'.$part.':tries'} = 0;      my $rows_stored;
                     $output->{$name.':'.$problemID.':'.$part.':awarded'} = 0;      my $store_parameters_command  = 'INSERT IGNORE INTO '.$parameters_table.
                     $output->{$name.':'.$problemID.':'.$part.':code'} = ' ';          ' VALUES '."\n";
     $allkeys{$name.':'.$problemID.':'.$part.':tries'}++;      my $num_parameters = 0;
     $allkeys{$name.':'.$problemID.':'.$part.':awarded'}++;      my $store_performance_command = 'INSERT IGNORE INTO '.$performance_table.
     $allkeys{$name.':'.$problemID.':'.$part.':code'}++;          ' VALUES '."\n";
                     $totalProblems++;      return ('error',undef) 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)."',".
                                              $dbh->quote($value)."),\n";
                   $num_parameters ++;
                   if ($newstring !~ /''/) {
                       $store_parameters_command .= $newstring;
                       $rows_stored++;
                 }                  }
                 $output->{$name.':'.$problemID.':NoVersion'} = 'true';  
                 next;  
             }              }
               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($solved));
               $tries       = '' if (! defined($tries));
               $awarded     = '' if (! defined($awarded));
               $award       = '' if (! defined($award));
               $awarddetail = '' if (! defined($awarddetail));
               $newstring = "('".join("','",$symb_id,$student_id,$part_id,$part,
                                      $solved,$tries,$awarded,$award,
                                      $awarddetail,$timestamp)."'),\n";
               $store_performance_command .= $newstring;
               $rows_stored++;
           }
       }
       chop $store_parameters_command;
       chop $store_parameters_command;
       chop $store_performance_command;
       chop $store_performance_command;
       my $start = Time::HiRes::time;
       $dbh->do($store_performance_command);
       if ($dbh->err()) {
           &Apache::lonnet::logthis(' bigass insert error:'.$dbh->errstr());
           &Apache::lonnet::logthis('command = '.$store_performance_command);
           $returnstatus = 'error: unable to insert performance into database';
           return ($returnstatus,$student_data);
       }
       $dbh->do($store_parameters_command) if ($num_parameters>0);
       if ($dbh->err()) {
           &Apache::lonnet::logthis(' bigass insert error:'.$dbh->errstr());
           &Apache::lonnet::logthis('command = '.$store_parameters_command);
           &Apache::lonnet::logthis('rows_stored = '.$rows_stored);
           &Apache::lonnet::logthis('student_id = '.$student_id);
           $returnstatus = 'error: unable to insert parameters into database';
           return ($returnstatus,$student_data);
       }
       $elapsed += Time::HiRes::time - $start;
       return ($returnstatus,$student_data);
   }
   
             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  =pod
             # 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.  =item &ensure_tables_are_set_up($courseid)
                                                  ':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'} =   Checks to be sure the MySQL tables for the given class are set up.
                     $partData{$part.':tries'};  If $courseid is omitted it will be obtained from the environment.
                 $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') {  Returns nothing on success and 'error' on failure
                     $totalProblems++;  
                 }  =cut
             }  
         }  
   
         $output->{$name.':'.$sequence.':problemsCorrect'} = $problemsCorrect;  ######################################
  $allkeys{$name.':'.$sequence.':problemsCorrect'}++;  ######################################
         $problemsSolved += $problemsCorrect;  sub ensure_tables_are_set_up {
  $problemsCorrect=0;      my ($courseid) = @_;
       $courseid = $ENV{'request.course.id'} if (! defined($courseid));
       # 
       # Clean out package variables
       &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_performance,$found_parameters,$found_fulldump_part,
           $found_fulldump_response,$found_fulldump_timestamp,
           $found_weight);
       foreach (@CurrentTable) {
           $found_symb        = 1 if ($_ eq $symb_table);
           $found_student     = 1 if ($_ eq $student_table);
           $found_part        = 1 if ($_ eq $part_table);
           $found_performance = 1 if ($_ eq $performance_table);
           $found_parameters  = 1 if ($_ eq $parameters_table);
           $found_fulldump_part      = 1 if ($_ eq $fulldump_part_table);
           $found_fulldump_response  = 1 if ($_ eq $fulldump_response_table);
           $found_fulldump_timestamp = 1 if ($_ eq $fulldump_timestamp_table);
           $found_weight      = 1 if ($_ eq $weight_table);
       }
       if (!$found_symb          || 
           !$found_student       || !$found_part              ||
           !$found_performance   || !$found_parameters        ||
           !$found_fulldump_part || !$found_fulldump_response ||
           !$found_fulldump_timestamp || !$found_weight ) {
           if (&init_dbs($courseid,1)) {
               return 'error';
           }
     }      }
   }
   
     $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));  =pod
   
     return;  =item &ensure_current_data()
 }  
   
 sub LoadDiscussion {  Input: $sname, $sdom, $courseid
     my ($courseID)=@_;  
     my %Discuss=();  
     my %contrib=&Apache::lonnet::dump(  
                 $courseID,  
                 $ENV{'course.'.$courseID.'.domain'},  
                 $ENV{'course.'.$courseID.'.num'});  
     
     #my %contrib=&DownloadCourseInformation($name, $courseID, 0);  
   
     foreach my $temp(keys %contrib) {  Output: $status, $data
  if ($temp=~/^version/) {  
     my $ver=$contrib{$temp};  
     my ($dummy,$prb)=split(':',$temp);  
     for (my $idx=1; $idx<=$ver; $idx++ ) {  
  my $name=$contrib{"$idx:$prb:sendername"};  
  $Discuss{"$name:$prb"}=$idx;  
     }  
  }  
     }         
   
     return \%Discuss;  This routine ensures the data for a given student is up to date.
   The $student_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
       #
       $courseid = $ENV{'request.course.id'} if (! defined($courseid));
       &ensure_tables_are_set_up($courseid);
       #
       # Get the update time for the user
       my $updatetime = 0;
       my $modifiedtime = &Apache::lonnet::GetFileTimestamp
           ($sdom,$sname,$courseid.'.db',
            $Apache::lonnet::perlvar{'lonUsersDir'});
       #
       my $student_id = &get_student_id($sname,$sdom);
       my @Result = &Apache::lonmysql::get_rows($student_table,
                                                "student_id ='$student_id'");
       my $data = undef;
       if (@Result) {
           $updatetime = $Result[0]->[5];  # Ack!  This is dumb!
       }
       if ($modifiedtime > $updatetime) {
           ($status,$data) = &update_student_data($sname,$sdom,$courseid);
       }
       return ($status,$data);
 }  }
   
 # ----- END PROCESSING FUNCTIONS ---------------------------------------  ################################################
   ################################################
   
 =pod  =pod
   
 =head1 HELPER FUNCTIONS  =item &ensure_current_full_data($sname,$sdom,$courseid)
   
 These are just a couple of functions do various odd and end   Input: $sname, $sdom, $courseid
 jobs.  There was also a couple of bulk functions added.  These are  
 &DownloadStudentCourseData(), &DownloadStudentCourseDataSeparate(), and  Output: $status
 &CheckForResidualDownload().  These functions now act as the interface  
 for downloading student course data.  The statistical modules should  This routine ensures the fulldata (the data from a lonnet::dump, not a
 no longer make the calls to dump and download and process etc.  They  lonnet::currentdump) for a given student is up to date.
 make calls to these bulk functions to get their data.  The $student_table is queried to determine the time of the last update.  
   If the students fulldata is out of date, &update_full_student_data() is
   called.  
   
   The return value from the call to &update_full_student_data() is returned.
   
 =cut  =cut
   
 # ----- HELPER FUNCTIONS -----------------------------------------------  ################################################
   ################################################
   sub ensure_current_full_data {
       my ($sname,$sdom,$courseid) = @_;
       my $status = 'okay';   # return value
       #
       $courseid = $ENV{'request.course.id'} if (! defined($courseid));
       &ensure_tables_are_set_up($courseid);
       #
       # Get the update time for the user
       my $modifiedtime = &Apache::lonnet::GetFileTimestamp
           ($sdom,$sname,$courseid.'.db',
            $Apache::lonnet::perlvar{'lonUsersDir'});
       #
       my $student_id = &get_student_id($sname,$sdom);
       my @Result = &Apache::lonmysql::get_rows($student_table,
                                                "student_id ='$student_id'");
       my $updatetime;
       if (@Result && ref($Result[0]) eq 'ARRAY') {
           $updatetime = $Result[0]->[6];
       }
       if (! defined($updatetime) || $modifiedtime > $updatetime) {
           $status = &update_full_student_data($sname,$sdom,$courseid);
       }
       return $status;
   }
   
   ################################################
   ################################################
   
   =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 CheckDateStampError {  ################################################
     my ($courseData, $cache, $name)=@_;  ################################################
     if($courseData->{$name.':UpToDate'} eq 'true') {  sub get_student_data_from_performance_cache {
         $cache->{$name.':lastDownloadTime'} =       my ($sname,$sdom,$symb,$courseid)=@_;
             $courseData->{$name.':lastDownloadTime'};      my $student = $sname.':'.$sdom if (defined($sname) && defined($sdom));
         if($courseData->{$name.':lastDownloadTime'} eq 'Not downloaded') {      &setup_table_names($courseid);
             $cache->{$name.':updateTime'} = ' Not updated';      #
         } else {      # Return hash
             $cache->{$name.':updateTime'}=      my $studentdata;
                 localtime($courseData->{$name.':lastDownloadTime'});      #
       my $dbh = &Apache::lonmysql::get_dbh();
       my $request = "SELECT ".
           "d.symb,a.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 '');
       }
       ## Get misc parameters
       $request = 'SELECT c.symb,a.parameter,a.value '.
           "FROM $student_table AS b ".
           "LEFT JOIN $parameters_table AS a ON b.student_id=a.student_id ".
           "LEFT JOIN $symb_table AS c ON c.symb_id = a.symb_id ".
           "WHERE student='$student'";
       if (defined($symb) && $symb ne '') {
           $request .= " AND c.symb=".$dbh->quote($symb);
       }
       $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());
           if (defined($symb) && $symb ne '') {
               $studentdata = $studentdata->{$symb};
         }          }
         return 0;          return $studentdata;
     }      }
       #
     $cache->{$name.':lastDownloadTime'}=$courseData->{$name.':lastDownloadTime'};      foreach my $row (@{$sth->fetchall_arrayref}) {
     if($courseData->{$name.':lastDownloadTime'} eq 'Not downloaded') {          $rows_retrieved++;
         $cache->{$name.':updateTime'} = ' Not updated';          my ($symb,$parameter,$value) = (@$row);
     } else {          $studentdata->{$symb}->{$parameter}  = $value;
         $cache->{$name.':updateTime'}=  
             localtime($courseData->{$name.':lastDownloadTime'});  
     }      }
       #
     if(defined($courseData->{$name.':error'})) {      if (defined($symb) && $symb ne '') {
         $cache->{$name.':error'}=$courseData->{$name.':error'};          $studentdata = $studentdata->{$symb};
         return 0;  
     }      }
       return $studentdata;
     return 1;  
 }  }
   
   ################################################
   ################################################
   
 =pod  =pod
   
 =item &ProcessFullName()  =item &get_current_state()
   
 Takes lastname, generation, firstname, and middlename (or some partial  Input: $sname,$sdom,$symb,$courseid
 set of this data) and returns the full name version as a string.  Format  
 is Lastname generation, firstname middlename or a subset of this.  
   
 =cut  Output: Described below
   
 sub ProcessFullName {  Retrieve the current status of a students performance.  $sname and
     my ($lastname, $generation, $firstname, $middlename)=@_;  $sdom are the only required parameters.  If $symb is undef the results
     my $Str = '';  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.
   
     # Strip whitespace preceeding & following name components.  If no data is found for $symb, or if the student has no performance data,
     $lastname   =~ s/(\s+$|^\s+)//g;  an empty list is returned.
     $generation =~ s/(\s+$|^\s+)//g;  
     $firstname  =~ s/(\s+$|^\s+)//g;  
     $middlename =~ s/(\s+$|^\s+)//g;  
   
     if($lastname ne '') {  =cut
  $Str .= $lastname;  
  $Str .= ' '.$generation if ($generation ne '');  ################################################
  $Str .= ',';  ################################################
         $Str .= ' '.$firstname  if ($firstname ne '');  sub get_current_state {
         $Str .= ' '.$middlename if ($middlename ne '');      my ($sname,$sdom,$symb,$courseid,$forcedownload)=@_;
       #
       $courseid = $ENV{'request.course.id'} if (! defined($courseid));
       #
       return () if (! defined($sname) || ! defined($sdom));
       #
       my ($status,$data) = &ensure_current_data($sname,$sdom,$courseid);
   #    &Apache::lonnet::logthis
   #        ('sname = '.$sname.
   #         ' domain = '.$sdom.
   #         ' status = '.$status.
   #         ' data is '.(defined($data)?'defined':'undefined'));
   #    while (my ($symb,$hash) = each(%$data)) {
   #        &Apache::lonnet::logthis($symb."\n----------------------------------");
   #        while (my ($key,$value) = each (%$hash)) {
   #            &Apache::lonnet::logthis("   ".$key." = ".$value);
   #        }
   #    }
       #
       if (defined($data) && defined($symb) && ref($data->{$symb})) {
           return %{$data->{$symb}};
       } elsif (defined($data) && ! defined($symb) && ref($data)) {
           return %$data;
       } 
       if ($status eq 'no data') {
           return ();
     } else {      } else {
         $Str .= $firstname      if ($firstname ne '');          if ($status ne 'okay' && $status ne '') {
         $Str .= ' '.$middlename if ($middlename ne '');              &Apache::lonnet::logthis('status = '.$status);
         $Str .= ' '.$generation if ($generation ne '');              return ();
           }
           my $returnhash = &get_student_data_from_performance_cache($sname,$sdom,
                                                         $symb,$courseid);
           return %$returnhash if (defined($returnhash));
     }      }
       return ();
     return $Str;  
 }  }
   
   ################################################
   ################################################
   
 =pod  =pod
   
 =item &TestCacheData()  =item &get_problem_statistics()
   
   Gather data on a given problem.  The database is assumed to be 
   populated and all local caching variables are assumed to be set
   properly.  This means you need to call &ensure_current_data for
   the students you are concerned with prior to calling this routine.
   
 Determine if the cache database can be accessed with a tie.  It waits up to  Inputs: $Sections, $status, $symb, $part, $courseid, $starttime, $endtime
 ten seconds before returning failure.  This function exists to help with  
 the problems with stopping the data download.  When an abort occurs and the  
 user quickly presses a form button and httpd child is created.  This  
 child needs to wait for the other to finish (hopefully within ten seconds).  
   
 =over 4  =over 4
   
 Input: $ChartDB  =item $Sections Array ref containing section names for students.  
   'all' is allowed to be the first (and only) item in the array.
   
 $ChartDB: The name of the cache database to be opened  =item $status String describing the status of students
   
 Output: -1, 0, 1  =item $symb is the symb for the problem.
   
 -1: Could not tie database  =item $part is the part id you need statistics for
  0: Use cached data  
  1: New cache database created, use that.  =item $courseid is the course id, of course!
   
   =item $starttime and $endtime are unix times which to use to limit
   the statistical data.
   
 =back  =back
   
 =cut  Outputs: See the code for up to date information.  A hash reference is
   returned.  The hash has the following keys defined:
   
   =over 4
   
   =item num_students The number of students attempting the problem
         
   =item tries The total number of tries for the students
         
   =item max_tries The maximum number of tries taken
         
   =item mean_tries The average number of tries
         
   =item num_solved The number of students able to solve the problem
         
   =item num_override The number of students whose answer is 'correct_by_override'
         
   =item deg_of_diff The degree of difficulty of the problem
         
   =item std_tries The standard deviation of the number of tries
         
   =item skew_tries The skew of the number of tries
   
   =item per_wrong The number of students attempting the problem who were not
   able to answer it correctly.
   
   =back
   
 sub TestCacheData {  =cut
     my ($ChartDB,$isRecalculate,$totalDelay)=@_;  
     my $isCached=-1;  
     my %testData;  
     my $tieTries=0;  
   
     if(!defined($totalDelay)) {  ################################################
         $totalDelay = 10;  ################################################
   sub get_problem_statistics {
       my ($Sections,$status,$symb,$part,$courseid,$starttime,$endtime) = @_;
       return if (! defined($symb) || ! defined($part));
       $courseid = $ENV{'request.course.id'} if (! defined($courseid));
       #
       &setup_table_names($courseid);
       my $symb_id = &get_symb_id($symb);
       my $part_id = &get_part_id($part);
       my $stats_table = $courseid.'_problem_stats';
       #
       my $dbh = &Apache::lonmysql::get_dbh();
       return undef if (! defined($dbh));
       #
       # Clean out the table
       $dbh->do('DROP TABLE '.$stats_table);  # May return an error
       my $request = 
           'CREATE TEMPORARY TABLE '.$stats_table.' '.
           'SELECT a.student_id,a.solved,a.award,a.awarded,a.tries '.
           'FROM '.$performance_table.' AS a ';
       #
       # See if we need to include some requirements on the students
       if ((defined($Sections) && lc($Sections->[0]) ne 'all') || 
           (defined($status)   && lc($status)        ne 'any')) {
           $request .= 'NATURAL LEFT JOIN '.$student_table.' AS b ';
       }
       $request .= ' WHERE a.symb_id='.$symb_id.' AND a.part_id='.$part_id;
       #
       # Limit the students included to those specified
       if (defined($Sections) && lc($Sections->[0]) ne 'all') {
           $request .= ' AND ('.
               join(' OR ', map { "b.section='".$_."'" } @$Sections
                    ).')';
       }
       if (defined($status) && lc($status) ne 'any') {
           $request .= " AND b.status='".$status."'";
       }
       #
       # Limit by starttime and endtime
       my $time_requirements = undef;
       if (defined($starttime)) {
           $time_requirements .= 'a.timestamp>='.$starttime;
           if (defined($endtime)) {
               $time_requirements .= ' AND a.timestamp<='.$endtime;
           }
       } elsif (defined($endtime)) {
           $time_requirements .= 'a.timestamp<='.$endtime;
       }
       if (defined($time_requirements)) {
           $request .= ' AND '.$time_requirements;
       }
       #
       # Finally, execute the request to create the temporary table
       $dbh->do($request);
       #
       # Collect the first suite of statistics
       $request = 'SELECT COUNT(*),SUM(tries),'.
           'AVG(tries),STD(tries) '.
           'FROM '.$stats_table;
       my ($num,$tries,$mean,$STD) = &execute_SQL_request
           ($dbh,$request);
       #
       $request = 'SELECT MAX(tries),MIN(tries) FROM '.$stats_table.
           ' WHERE awarded>0';
       if (defined($time_requirements)) {
           $request .= ' AND '.$time_requirements;
       }
       my ($max,$min) = &execute_SQL_request($dbh,$request);
       #
       $request = 'SELECT SUM(awarded) FROM '.$stats_table;
       if (defined($time_requirements)) {
           $request .= ' AND '.$time_requirements;
       }
       my ($Solved) = &execute_SQL_request($dbh,$request);
       #
       $request = 'SELECT SUM(awarded) FROM '.$stats_table.
           " WHERE solved='correct_by_override'";
       if (defined($time_requirements)) {
           $request .= ' AND '.$time_requirements;
       }
       my ($solved) = &execute_SQL_request($dbh,$request);
       #
       $Solved -= $solved;
       #
       $num    = 0 if (! defined($num));
       $tries  = 0 if (! defined($tries));
       $max    = 0 if (! defined($max));
       $min    = 0 if (! defined($min));
       $STD    = 0 if (! defined($STD));
       $Solved = 0 if (! defined($Solved) || $Solved < 0);
       $solved = 0 if (! defined($solved));
       #
       # Compute the more complicated statistics
       my $DegOfDiff = 'nan';
       $DegOfDiff = 1-($Solved)/$tries if ($tries>0);
       #
       my $SKEW = 'nan';
       my $wrongpercent = 0;
       my $numwrong = 'nan';
       if ($num > 0) {
           ($SKEW) = &execute_SQL_request($dbh,'SELECT SQRT(SUM('.
                                        'POWER(tries - '.$STD.',3)'.
                                        '))/'.$num.' FROM '.$stats_table);
           $numwrong = $num-$Solved;
           $wrongpercent=int(10*100*$numwrong/$num)/10;
     }      }
       #
       # Drop the temporary table
       $dbh->do('DROP TABLE '.$stats_table);  # May return an error
       #
       # Return result
       return { num_students => $num,
                tries        => $tries,
                max_tries    => $max,
                min_tries    => $min,
                mean_tries   => $mean,
                std_tries    => $STD,
                skew_tries   => $SKEW,
                num_solved   => $Solved,
                num_override => $solved,
                num_wrong    => $numwrong,
                per_wrong    => $wrongpercent,
                deg_of_diff  => $DegOfDiff };
   }
   
     if ((-e "$ChartDB") && (!$isRecalculate)) {  ##
  $isCached = 1;  ## This is a helper for get_statistics
     } else {  sub execute_SQL_request {
  $isCached = 0;      my ($dbh,$request)=@_;
   #    &Apache::lonnet::logthis($request);
       my $sth = $dbh->prepare($request);
       $sth->execute();
       my $row = $sth->fetchrow_arrayref();
       if (ref($row) eq 'ARRAY' && scalar(@$row)>0) {
           return @$row;
     }      }
       return ();
   }
   
     while($tieTries < $totalDelay) {  ######################################################
         my $result=0;  ######################################################
         if($isCached) {  
             $result=tie(%testData,'GDBM_File',$ChartDB,&GDBM_READER(),0640);  =pod
         } else {  
             $result=tie(%testData,'GDBM_File',$ChartDB,&GDBM_NEWDB(),0640);  =item &populate_weight_table
         }  
         if($result) {  =cut
             last;  
   ######################################################
   ######################################################
   sub populate_weight_table {
       my ($courseid) = @_;
       if (! defined($courseid)) {
           $courseid = $ENV{'request.course.id'};
       }
       #
       &setup_table_names($courseid);
       my ($top,$sequences,$assessments) = get_sequence_assessment_data();
       if (! defined($top) || ! ref($top)) {
           # There has been an error, better report it
           &Apache::lonnet::logthis('top is undefined');
           return;
       }
       #       Since we use lonnet::EXT to retrieve problem weights,
       #       to ensure current data we must clear the caches out.
       &Apache::lonnet::clear_EXT_cache_status();
       my $dbh = &Apache::lonmysql::get_dbh();
       my $request = 'INSERT IGNORE INTO '.$weight_table.
           "(symb_id,part_id,weight) VALUES ";
       my $weight;
       foreach my $res (@$assessments) {
           my $symb_id = &get_symb_id($res->{'symb'});
           foreach my $part (@{$res->{'parts'}}) {
               my $part_id = &get_part_id($part);
               $weight = &Apache::lonnet::EXT('resource.'.$part.'.weight',
                                              $res->{'symb'},
                                              undef,undef,undef);
               if (!defined($weight) || ($weight eq '')) { 
                   $weight=1;
               }
               $request .= "('".$symb_id."','".$part_id."','".$weight."'),";
         }          }
         $tieTries++;  
         sleep 1;  
     }      }
     if($tieTries >= $totalDelay) {      $request =~ s/(,)$//;
         return -1;  #    &Apache::lonnet::logthis('request = '.$/.$request);
       $dbh->do($request);
       if ($dbh->err()) {
           &Apache::lonnet::logthis("error ".$dbh->errstr().
                                    " occured executing \n".
                                    $request);
     }      }
       return;
   }
   
     untie(%testData);  ##########################################################
   ##########################################################
   
     return $isCached;  =pod
 }  
   
 sub DownloadStudentCourseData {  =item &limit_by_start_end_times
     my ($students,$checkDate,$cacheDB,$extract,$status,$courseID,$r,$c)=@_;  
   
     my $title = 'LON-CAPA Statistics';  Build SQL WHERE condition which limits the data collected by the start
     my $heading = 'Download and Process Course Data';  and end times provided
     my $studentCount = scalar(@$students);  
   
     my $WhatIWant;  Inputs: $starttime, $endtime, $table
     $WhatIWant = '(^version:|';  
     $WhatIWant .= '^\d+:.+?:(resource\.\d+\.';  
     $WhatIWant .= '(solved|tries|previous|awarded|(\d+\.submission))\s*$';  
     $WhatIWant .= '|timestamp)';  
     $WhatIWant .= ')';  
 #    $WhatIWant = '.';  
   
     if($status eq 'true') {  Returns: $time_limits
         &Apache::lonhtmlcommon::Create_PrgWin($r, $title, $heading);  
   =cut
   
   ##########################################################
   ##########################################################
   sub limit_by_start_end_time {
       my ($starttime,$endtime,$table) = @_;
       my $time_requirements = undef;
       if (defined($starttime)) {
           $time_requirements .= $table.".timestamp>='".$starttime."'";
           if (defined($endtime)) {
               $time_requirements .= " AND ".$table.".timestamp<='".$endtime."'";
           }
       } elsif (defined($endtime)) {
           $time_requirements .= $table.".timestamp<='".$endtime."'";
     }      }
       return $time_requirements;
   }
   
     my $displayString;  ##########################################################
     my $count=0;  ##########################################################
     foreach (@$students) {  
         my %cache;  
   
         if($c->aborted()) { return 'Aborted'; }  =pod
   
         if($status eq 'true') {  =item &limit_by_section_and_status
             $count++;  
             my $displayString = $count.'/'.$studentCount.': '.$_;  
             &Apache::lonhtmlcommon::Update_PrgWin($displayString, $r);  
         }  
   
         my $downloadTime='Not downloaded';  Build SQL WHERE condition which limits the data collected by section and
         my $needUpdate = 'false';  student status.
         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'; }  Inputs: $Sections (array ref)
       $enrollment (string: 'any', 'expired', 'active')
       $tablename The name of the table that holds the student data
   
         if($needUpdate eq 'true') {  Returns: $student_requirements,$enrollment_requirements
             $downloadTime = 'Not downloaded';  
  }  =cut
  my $courseData =   
     &DownloadCourseInformation($_, $courseID, $downloadTime,   ##########################################################
        $WhatIWant);  ##########################################################
  if(tie(%cache,'GDBM_File',$cacheDB,&GDBM_WRCREAT(),0640)) {  sub limit_by_section_and_status {
     foreach my $key (keys(%$courseData)) {      my ($Sections,$enrollment,$tablename) = @_;
  if($key =~ /^(con_lost|error|no_such_host)/i) {      my $student_requirements = undef;
     $courseData->{$_.':error'} = 'No course data for '.$_;      if ( (defined($Sections) && $Sections->[0] ne 'all')) {
     last;          $student_requirements = '('.
  }              join(' OR ', map { $tablename.".section='".$_."'" } @$Sections
     }                   ).')';
     if($extract eq 'true') {      }
  &ExtractStudentData($courseData, \%cache, \%cache, $_);      #
     } else {      my $enrollment_requirements=undef;
  &ProcessStudentData(\%cache, $courseData, $_);      if (defined($enrollment) && $enrollment ne 'Any') {
     }          $enrollment_requirements = $tablename.".status='".$enrollment."'";
     untie(%cache);  
  } else {  
     next;  
  }  
     }      }
     if($status eq 'true') { &Apache::lonhtmlcommon::Close_PrgWin($r); }      return ($student_requirements,$enrollment_requirements);
   }
   
   ######################################################
   ######################################################
   
     return 'OK';  =pod
   
   =item rank_students_by_scores_on_resources
   
   Inputs: 
       $resources: array ref of hash ref.  Each hash ref needs key 'symb'.
       $Sections: array ref of sections to include,
       $enrollment: string,
       $courseid (may be omitted)
   
   Returns; An array of arrays.  The sub arrays contain a student name and
   their score on the resources.
   
   =cut
   
   ######################################################
   ######################################################
   sub RNK_student { return 0; };
   sub RNK_score   { return 1; };
   
   sub rank_students_by_scores_on_resources {
       my ($resources,$Sections,$enrollment,$courseid,$starttime,$endtime) = @_;
       return if (! defined($resources) || ! ref($resources) eq 'ARRAY');
       if (! defined($courseid)) {
           $courseid = $ENV{'request.course.id'};
       }
       #
       &setup_table_names($courseid);
       my $dbh = &Apache::lonmysql::get_dbh();
       my ($section_limits,$enrollment_limits)=
           &limit_by_section_and_status($Sections,$enrollment,'b');
       my $symb_limits = '('.join(' OR ',map {'a.symb_id='.&get_symb_id($_);
                                          } @$resources
                                  ).')';
       my $time_limits = &limit_by_start_end_time($starttime,$endtime,'a');
       my $request = 'SELECT b.student,SUM(a.awarded*w.weight) AS score FROM '.
           $performance_table.' AS a '.
           'NATURAL LEFT JOIN '.$weight_table.' AS w '.
           'LEFT JOIN '.$student_table.' AS b ON a.student_id=b.student_id '.
           'WHERE ';
       if (defined($section_limits)) {
           $request .= $section_limits.' AND ';
       }
       if (defined($enrollment_limits)) {
           $request .= $enrollment_limits.' AND ';
       }
       if (defined($time_limits)) {
           $request .= $time_limits.' AND ';
       }
       if ($symb_limits ne '()') {
           $request .= $symb_limits.' AND ';
       }
       $request =~ s/( AND )$//;   # Remove extra conjunction
       $request =~ s/( WHERE )$//; # In case there were no limits placed on it
       $request .= ' GROUP BY a.student_id ORDER BY score';
       #&Apache::lonnet::logthis('request = '.$/.$request);
       my $sth = $dbh->prepare($request);
       $sth->execute();
       my $rows = $sth->fetchall_arrayref();
       return ($rows);
 }  }
   
 sub DownloadStudentCourseDataSeparate {  ########################################################
     my ($students,$checkDate,$cacheDB,$extract,$status,$courseID,$r,$c)=@_;  ########################################################
     my $residualFile = '/home/httpd/perl/tmp/'.$courseID.'DownloadFile.db';  
     my $title = 'LON-CAPA Statistics';  
     my $heading = 'Download Course Data';  
   
     my $WhatIWant;  =pod
     $WhatIWant = '(^version:|';  
     $WhatIWant .= '^\d+:.+?:(resource\.\d+\.';  =item &get_sum_of_scores
     $WhatIWant .= '(solved|tries|previous|awarded|(\d+\.submission))\s*$';  
     $WhatIWant .= '|timestamp)';  Inputs: $resource (hash ref, needs {'symb'} key),
     $WhatIWant .= ')';  $part, (the part id),
   $students (array ref, contents of array are scalars holding 'sname:sdom'),
   $courseid
   
     &CheckForResidualDownload($cacheDB, 'true', 'true', $courseID, $r, $c);  Returns: the sum of the score on the problem part over the students and the
      maximum possible value for the sum (taken from the weight table).
   
   =cut
   
     my $studentCount = scalar(@$students);  ########################################################
     if($status eq 'true') {  ########################################################
         &Apache::lonhtmlcommon::Create_PrgWin($r, $title, $heading);  sub get_sum_of_scores {
       my ($resource,$part,$students,$courseid,$starttime,$endtime) = @_;
       if (! defined($courseid)) {
           $courseid = $ENV{'request.course.id'};
       }
       if (defined($students) && 
           ((@$students == 0) ||
            (@$students == 1 && (! defined($students->[0]) || 
                                 $students->[0] eq ''))
            )
           ){
           undef($students);
     }      }
     my $count=0;      #
     my $displayString='';      &setup_table_names($courseid);
     foreach (@$students) {      my $dbh = &Apache::lonmysql::get_dbh();
         if($c->aborted()) {      my $time_limits = &limit_by_start_end_time($starttime,$endtime,'a');
             return 'Aborted';      my $request = 'SELECT SUM(a.awarded*w.weight),SUM(w.weight) FROM '.
         }          $performance_table.' AS a '.
           'NATURAL LEFT JOIN '.$weight_table.' AS w ';
       $request .= 'WHERE a.symb_id='.&get_symb_id($resource->{'symb'}).
           ' AND a.part_id='.&get_part_id($part);
       if (defined($time_limits)) {
           $request .= ' AND '.$time_limits;
       }
       if (defined($students)) {
           $request .= ' AND ('.
               join(' OR ',map {'a.student_id='.&get_student_id(split(':',$_));
                            } @$students).
                                ')';
       }
       my $sth = $dbh->prepare($request);
       $sth->execute();
       my $rows = $sth->fetchrow_arrayref();
       if ($dbh->err) {
           &Apache::lonnet::logthis('error 1 = '.$dbh->errstr());
           &Apache::lonnet::logthis('prepared then executed, fetchrow_arrayrefed'.
                                    $/.$request);
           return (undef,undef);
       }
       return ($rows->[0],$rows->[1]);
   }
   
         if($status eq 'true') {  ########################################################
             $count++;  ########################################################
             $displayString = $count.'/'.$studentCount.': '.$_;  
             &Apache::lonhtmlcommon::Update_PrgWin($displayString, $r);  
         }  
   
         my %cache;  =pod
         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()) {  =item &score_stats
             return 'Aborted';  
         }  
   
         if($needUpdate eq 'true') {  Inputs: $Sections, $enrollment, $symbs, $starttime,
             $downloadTime = 'Not downloaded';          $endtime, $courseid
  }  
   
         my $error = 0;  $Sections, $enrollment, $starttime, $endtime, and $courseid are the same as 
         my $courseData =   elsewhere in this module.  
             &DownloadCourseInformation($_, $courseID, $downloadTime,  $symbs is an array ref of symbs
                                        $WhatIWant);  
         my %downloadData;  Returns: minimum, maximum, mean, s.d., number of students, and maximum
         unless(tie(%downloadData,'GDBM_File',$residualFile,    possible of student scores on the given resources
                    &GDBM_WRCREAT(),0640)) {  
             return 'Failed to tie temporary download hash.';  =cut
         }  
         foreach my $key (keys(%$courseData)) {  ########################################################
             $downloadData{$key} = $courseData->{$key};  ########################################################
             if($key =~ /^(con_lost|error|no_such_host)/i) {  sub score_stats {
                 $error = 1;      my ($Sections,$enrollment,$symbs,$starttime,$endtime,$courseid)=@_;
                 last;      if (! defined($courseid)) {
             }          $courseid = $ENV{'request.course.id'};
         }  
         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); }      #
       &setup_table_names($courseid);
       my $dbh = &Apache::lonmysql::get_dbh();
       #
       my ($section_limits,$enrollment_limits)=
           &limit_by_section_and_status($Sections,$enrollment,'b');
       my $time_limits = &limit_by_start_end_time($starttime,$endtime,'a');
       my @Symbids = map { &get_symb_id($_); } @{$symbs};
       #
       my $stats_table = $courseid.'_problem_stats';
       my $symb_restriction = join(' OR ',map {'a.symb_id='.$_;} @Symbids);
       my $request = 'DROP TABLE '.$stats_table;
       $dbh->do($request);
       $request = 
           'CREATE TEMPORARY TABLE '.$stats_table.' '.
           'SELECT a.student_id,'.
           'SUM(a.awarded*w.weight) AS score FROM '.
           $performance_table.' AS a '.
           'NATURAL LEFT JOIN '.$weight_table.' AS w '.
           'LEFT JOIN '.$student_table.' AS b ON a.student_id=b.student_id '.
           'WHERE ('.$symb_restriction.')';
       if ($time_limits) {
           $request .= ' AND '.$time_limits;
       }
       if ($section_limits) {
           $request .= ' AND '.$section_limits;
       }
       if ($enrollment_limits) {
           $request .= ' AND '.$enrollment_limits;
       }
       $request .= ' GROUP BY a.student_id';
   #    &Apache::lonnet::logthis('request = '.$/.$request);
       my $sth = $dbh->prepare($request);
       $sth->execute();
       $request = 
           'SELECT AVG(score),STD(score),MAX(score),MIN(score),COUNT(score) '.
           'FROM '.$stats_table;
       my ($ave,$std,$max,$min,$count) = &execute_SQL_request($dbh,$request);
   #    &Apache::lonnet::logthis('request = '.$/.$request);
       
       $request = 'SELECT SUM(weight) FROM '.$weight_table.
           ' WHERE ('.$symb_restriction.')';
       my ($max_possible) = &execute_SQL_request($dbh,$request);
       # &Apache::lonnet::logthis('request = '.$/.$request);
       return($min,$max,$ave,$std,$count,$max_possible);
   }
   
   
     return &CheckForResidualDownload($cacheDB, 'true', 'true',   ########################################################
                                      $courseID, $r, $c);  ########################################################
   
   =pod
   
   =item &count_stats
   
   Inputs: $Sections, $enrollment, $symbs, $starttime,
           $endtime, $courseid
   
   $Sections, $enrollment, $starttime, $endtime, and $courseid are the same as 
   elsewhere in this module.  
   $symbs is an array ref of symbs
   
   Returns: minimum, maximum, mean, s.d., and number of students
     of the number of items correct on the given resources
   
   =cut
   
   ########################################################
   ########################################################
   sub count_stats {
       my ($Sections,$enrollment,$symbs,$starttime,$endtime,$courseid)=@_;
       if (! defined($courseid)) {
           $courseid = $ENV{'request.course.id'};
       }
       #
       &setup_table_names($courseid);
       my $dbh = &Apache::lonmysql::get_dbh();
       #
       my ($section_limits,$enrollment_limits)=
           &limit_by_section_and_status($Sections,$enrollment,'b');
       my $time_limits = &limit_by_start_end_time($starttime,$endtime,'a');
       my @Symbids = map { &get_symb_id($_); } @{$symbs};
       #
       my $stats_table = $courseid.'_problem_stats';
       my $symb_restriction = join(' OR ',map {'a.symb_id='.$_;} @Symbids);
       my $request = 'DROP TABLE '.$stats_table;
       $dbh->do($request);
       $request = 
           'CREATE TEMPORARY TABLE '.$stats_table.' '.
           'SELECT a.student_id,'.
           'COUNT(a.award) AS count FROM '.
           $performance_table.' AS a '.
           'LEFT JOIN '.$student_table.' AS b ON a.student_id=b.student_id '.
           'WHERE ('.$symb_restriction.')'.
           " AND a.award!='INCORRECT_ATTEMPTED'";
       if ($time_limits) {
           $request .= ' AND '.$time_limits;
       }
       if ($section_limits) {
           $request .= ' AND '.$section_limits;
       }
       if ($enrollment_limits) {
           $request .= ' AND '.$enrollment_limits;
       }
       $request .= ' GROUP BY a.student_id';
   #    &Apache::lonnet::logthis('request = '.$/.$request);
       my $sth = $dbh->prepare($request);
       $sth->execute();
       $request = 
           'SELECT AVG(count),STD(count),MAX(count),MIN(count),COUNT(count) '.
           'FROM '.$stats_table;
       my ($ave,$std,$max,$min,$count) = &execute_SQL_request($dbh,$request);
   #    &Apache::lonnet::logthis('request = '.$/.$request);
       return($min,$max,$ave,$std,$count);
 }  }
   
 sub CheckForResidualDownload {  ######################################################
     my ($cacheDB,$extract,$status,$courseID,$r,$c)=@_;  ######################################################
   
   =pod
   
   =item get_student_data
   
     my $residualFile = '/home/httpd/perl/tmp/'.$courseID.'DownloadFile.db';  =cut
     if(!-e $residualFile) {  
         return 'OK';  ######################################################
   ######################################################
   sub get_student_data {
       my ($students,$courseid) = @_;
       $courseid = $ENV{'request.course.id'} if (! defined($courseid));
       &setup_table_names($courseid);
       my $dbh = &Apache::lonmysql::get_dbh();
       return undef if (! defined($dbh));
       my $request = 'SELECT '.
           'student_id, student '.
           'FROM '.$student_table;
       if (defined($students)) {
           $request .= ' WHERE ('.
               join(' OR ', map {'student_id='.
                                     &get_student_id($_->{'username'},
                                                     $_->{'domain'})
                                 } @$students
                    ).')';
       }
       $request.= ' ORDER BY student_id';
       my $sth = $dbh->prepare($request);
       $sth->execute();
       if ($dbh->err) {
           &Apache::lonnet::logthis('error 2 = '.$dbh->errstr());
           &Apache::lonnet::logthis('prepared then executed '.$/.$request);
           return undef;
       }
       my $dataset = $sth->fetchall_arrayref();
       if (ref($dataset) eq 'ARRAY' && scalar(@$dataset)>0) {
           return $dataset;
     }      }
   }
   
     my %downloadData;  sub RD_student_id    { return 0; }
     my %cache;  sub RD_awarddetail   { return 1; }
     unless(tie(%downloadData,'GDBM_File',$residualFile,&GDBM_READER(),0640)) {  sub RD_response_eval { return 2; }
         return 'Can not tie database for check for residual download: tempDB';  sub RD_submission    { return 3; }
   sub RD_timestamp     { return 4; }
   sub RD_tries         { return 5; }
   sub RD_sname         { return 6; }
   
   sub get_response_data {
       my ($Sections,$enrollment,$symb,$response,$courseid) = @_;
       return undef if (! defined($symb) || 
                  ! defined($response));
       $courseid = $ENV{'request.course.id'} if (! defined($courseid));
       #
       &setup_table_names($courseid);
       my $symb_id = &get_symb_id($symb);
       if (! defined($symb_id)) {
           &Apache::lonnet::logthis('Unable to find symb for '.$symb.' in '.$courseid);
           return undef;
       }
       my $response_id = &get_part_id($response);
       if (! defined($response_id)) {
           &Apache::lonnet::logthis('Unable to find id for '.$response.' in '.$courseid);
           return undef;
     }      }
     unless(tie(%cache,'GDBM_File',$cacheDB,&GDBM_WRCREAT(),0640)) {      #
         untie(%downloadData);      my $dbh = &Apache::lonmysql::get_dbh();
         return 'Can not tie database for check for residual download: cacheDB';      return undef if (! defined($dbh));
       #
       my ($student_requirements,$enrollment_requirements) = 
           &limit_by_section_and_status($Sections,$enrollment,'d');
       my $request = 'SELECT '.
           'a.student_id, a.awarddetail, a.response_specific_value, '.
           'a.submission, b.timestamp, c.tries, d.student '.
           'FROM '.$fulldump_response_table.' AS a '.
           'LEFT JOIN '.$fulldump_timestamp_table.' AS b '.
           'ON a.symb_id=b.symb_id AND a.student_id=b.student_id AND '.
           'a.transaction = b.transaction '.
           'LEFT JOIN '.$fulldump_part_table.' AS c '.
           'ON a.symb_id=c.symb_id AND a.student_id=c.student_id AND '.        
           'a.part_id=c.part_id AND a.transaction = c.transaction '.
           'LEFT JOIN '.$student_table.' AS d '.
           'ON a.student_id=d.student_id '.
           'WHERE '.
           'a.symb_id='.$symb_id.' AND a.response_id='.$response_id;
       if (defined($student_requirements) || defined($enrollment_requirements)) {
           $request .= ' AND ';
           if (defined($student_requirements)) {
               $request .= $student_requirements.' AND ';
           }
           if (defined($enrollment_requirements)) {
               $request .= $enrollment_requirements.' AND ';
           }
           $request =~ s/( AND )$//;
       }
       $request .= ' ORDER BY b.timestamp';
   #    &Apache::lonnet::logthis("request =\n".$request);
       my $sth = $dbh->prepare($request);
       $sth->execute();
       if ($dbh->err) {
           &Apache::lonnet::logthis('error 3 = '.$dbh->errstr());
           &Apache::lonnet::logthis('prepared then executed '.$/.$request);
           return undef;
       }
       my $dataset = $sth->fetchall_arrayref();
       if (ref($dataset) eq 'ARRAY' && scalar(@$dataset)>0) {
           # Clear the \'s from around the submission
           for (my $i =0;$i<scalar(@$dataset);$i++) {
               $dataset->[$i]->[3] =~ s/(\'$|^\')//g;
           }
           return $dataset;
     }      }
   }
   
     my @students=();  
     my %checkStudent;  sub RDs_awarddetail   { return 3; }
     my $key;  sub RDs_submission    { return 2; }
     while(($key, undef) = each %downloadData) {  sub RDs_timestamp     { return 1; }
         my @temp = split(':', $key);  sub RDs_tries         { return 0; }
         my $student = $temp[0].':'.$temp[1];  sub RDs_awarded       { return 4; }
         if(!defined($checkStudent{$student})) {  
             $checkStudent{$student}++;  sub get_response_data_by_student {
             push(@students, $student);      my ($student,$symb,$response,$courseid) = @_;
       return undef if (! defined($symb) || 
                        ! defined($response));
       $courseid = $ENV{'request.course.id'} if (! defined($courseid));
       #
       &setup_table_names($courseid);
       my $symb_id = &get_symb_id($symb);
       my $response_id = &get_part_id($response);
       #
       my $student_id = &get_student_id($student->{'username'},
                                        $student->{'domain'});
       #
       my $dbh = &Apache::lonmysql::get_dbh();
       return undef if (! defined($dbh));
       my $request = 'SELECT '.
           'c.tries, b.timestamp, a.submission, a.awarddetail, e.awarded '.
           'FROM '.$fulldump_response_table.' AS a '.
           'LEFT JOIN '.$fulldump_timestamp_table.' AS b '.
           'ON a.symb_id=b.symb_id AND a.student_id=b.student_id AND '.
           'a.transaction = b.transaction '.
           'LEFT JOIN '.$fulldump_part_table.' AS c '.
           'ON a.symb_id=c.symb_id AND a.student_id=c.student_id AND '.        
           'a.part_id=c.part_id AND a.transaction = c.transaction '.
           'LEFT JOIN '.$student_table.' AS d '.
           'ON a.student_id=d.student_id '.
           'LEFT JOIN '.$performance_table.' AS e '.
           'ON a.symb_id=e.symb_id AND a.part_id=e.part_id AND '.
           'a.student_id=e.student_id AND c.tries=e.tries '.
           'WHERE '.
           'a.symb_id='.$symb_id.' AND a.response_id='.$response_id.
           ' AND a.student_id='.$student_id.' ORDER BY b.timestamp';
   #    &Apache::lonnet::logthis("request =\n".$request);
       my $sth = $dbh->prepare($request);
       $sth->execute();
       if ($dbh->err) {
           &Apache::lonnet::logthis('error 4 = '.$dbh->errstr());
           &Apache::lonnet::logthis('prepared then executed '.$/.$request);
           return undef;
       }
       my $dataset = $sth->fetchall_arrayref();
       if (ref($dataset) eq 'ARRAY' && scalar(@$dataset)>0) {
           # Clear the \'s from around the submission
           for (my $i =0;$i<scalar(@$dataset);$i++) {
               $dataset->[$i]->[2] =~ s/(\'$|^\')//g;
         }          }
           return $dataset;
     }      }
       return undef; # error occurred
   }
   
     my $heading = 'Process Course Data';  sub RT_student_id { return 0; }
     my $title = 'LON-CAPA Statistics';  sub RT_awarded    { return 1; }
     my $studentCount = scalar(@students);  sub RT_tries      { return 2; }
     if($status eq 'true') {  sub RT_timestamp  { return 3; }
         &Apache::lonhtmlcommon::Create_PrgWin($r, $title, $heading);  
   sub get_response_time_data {
       my ($students,$symb,$part,$courseid) = @_;
       return undef if (! defined($symb) || 
                        ! defined($part));
       $courseid = $ENV{'request.course.id'} if (! defined($courseid));
       #
       &setup_table_names($courseid);
       my $symb_id = &get_symb_id($symb);
       my $part_id = &get_part_id($part);
       #
       my $dbh = &Apache::lonmysql::get_dbh();
       return undef if (! defined($dbh));
       my $request = 'SELECT '.
           'a.student_id, a.awarded, a.tries, b.timestamp '.
           'FROM '.$fulldump_part_table.' AS a '.
           'NATURAL LEFT JOIN '.$fulldump_timestamp_table.' AS b '.
   #        'ON a.symb_id=b.symb_id AND a.student_id=b.student_id AND '.
   #        'a.transaction = b.transaction '.
           'WHERE '.
           'a.symb_id='.$symb_id.' AND a.part_id='.$part_id;
       if (defined($students)) {
           $request .= ' AND ('.
               join(' OR ', map {'a.student_id='.
                                     &get_student_id($_->{'username'},
                                                     $_->{'domain'})
                                 } @$students
                    ).')';
       }
       $request .= ' ORDER BY b.timestamp';
   #    &Apache::lonnet::logthis("request =\n".$request);
       my $sth = $dbh->prepare($request);
       $sth->execute();
       if ($dbh->err) {
           &Apache::lonnet::logthis('error 5 = '.$dbh->errstr());
           &Apache::lonnet::logthis('prepared then executed '.$/.$request);
           return undef;
       }
       my $dataset = $sth->fetchall_arrayref();
       if (ref($dataset) eq 'ARRAY' && scalar(@$dataset)>0) {
           return $dataset;
     }      }
   
     my $count=1;  }
     foreach my $name (@students) {  
         last if($c->aborted());  
   
         if($status eq 'true') {  ################################################
             my $displayString = $count.'/'.$studentCount.': '.$name;  ################################################
             &Apache::lonhtmlcommon::Update_PrgWin($displayString, $r);  
         }  
   
         if($extract eq 'true') {  =pod
             &ExtractStudentData(\%downloadData, \%cache, \%cache, $name);  
         } else {  
             &ProcessStudentData(\%cache, \%downloadData, $name);  
         }  
         $count++;  
     }  
   
     if($status eq 'true') { &Apache::lonhtmlcommon::Close_PrgWin($r); }  =item &get_student_scores($Sections,$Symbs,$enrollment,$courseid)
   
     untie(%cache);  =cut
     untie(%downloadData);  
   
     if(!$c->aborted()) {  ################################################
         my @files = ($residualFile);  ################################################
         unlink(@files);  sub get_student_scores {
       my ($Sections,$Symbs,$enrollment,$courseid,$starttime,$endtime) = @_;
       $courseid = $ENV{'request.course.id'} if (! defined($courseid));
       &setup_table_names($courseid);
       my $dbh = &Apache::lonmysql::get_dbh();
       return (undef) if (! defined($dbh));
       my $tmptable = $courseid.'_temp_'.time;
       #
       my $symb_requirements;
       if (defined($Symbs)  && @$Symbs) {
           $symb_requirements = '('.
               join(' OR ', map{ "(a.symb_id='".&get_symb_id($_->{'symb'}).
                                 "' AND a.part_id='".&get_part_id($_->{'part'}).
                                 "')"
                                 } @$Symbs).')';
     }      }
       #
       my $student_requirements;
       if ( (defined($Sections) && $Sections->[0] ne 'all')) {
           $student_requirements = '('.
               join(' OR ', map { "b.section='".$_."'" } @$Sections
                    ).')';
       }
       #
       my $enrollment_requirements=undef;
       if (defined($enrollment) && $enrollment ne 'Any') {
           $enrollment_requirements = "b.status='".$enrollment."'";
       }
       #
       my $time_requirements = undef;
       if (defined($starttime)) {
           $time_requirements .= "a.timestamp>='".$starttime."'";
           if (defined($endtime)) {
               $time_requirements .= " AND a.timestamp<='".$endtime."'";
           }
       } elsif (defined($endtime)) {
           $time_requirements .= "a.timestamp<='".$endtime."'";
       }
       ##
       ##
       my $request = 'CREATE TEMPORARY TABLE IF NOT EXISTS '.$tmptable.
           ' SELECT a.student_id,SUM(a.awarded) AS score FROM '.
           $performance_table.' AS a ';
       if (defined($student_requirements) || defined($enrollment_requirements)) {
           $request .= ' NATURAL LEFT JOIN '.$student_table.' AS b ';
       }
       if (defined($symb_requirements)      || 
           defined($student_requirements)   ||
           defined($enrollment_requirements) ) {
           $request .= ' WHERE ';
       }
       if (defined($symb_requirements)) {
           $request .= $symb_requirements.' AND ';
       }
       if (defined($student_requirements)) {
           $request .= $student_requirements.' AND ';
       }
       if (defined($enrollment_requirements)) {
           $request .= $enrollment_requirements.' AND ';
       }
       if (defined($time_requirements)) {
           $request .= $time_requirements.' AND ';
       }
       $request =~ s/ AND $//; # Strip of the trailing ' AND '.
       $request .= ' GROUP BY a.student_id';
   #    &Apache::lonnet::logthis("request = \n".$request);
       my $sth = $dbh->prepare($request);
       $sth->execute();
       if ($dbh->err) {
           &Apache::lonnet::logthis('error 6 = '.$dbh->errstr());
           &Apache::lonnet::logthis('prepared then executed '.$/.$request);
           return undef;
       }
       $request = 'SELECT score,COUNT(*) FROM '.$tmptable.' GROUP BY score';
   #    &Apache::lonnet::logthis("request = \n".$request);
       $sth = $dbh->prepare($request);
       $sth->execute();
       if ($dbh->err) {
           &Apache::lonnet::logthis('error 7 = '.$dbh->errstr());
           &Apache::lonnet::logthis('prepared then executed '.$/.$request);
           return undef;
       }
       my $dataset = $sth->fetchall_arrayref();
       return $dataset;
   }
   
     return 'OK';  ################################################
   ################################################
   
   =pod
   
   =item &setup_table_names()
   
   input: course id
   
   output: none
   
   Cleans up the package variables for local caching.
   
   =cut
   
   ################################################
   ################################################
   sub setup_table_names {
       my ($courseid) = @_;
       if (! defined($courseid)) {
           $courseid = $ENV{'request.course.id'};
       }
       #
       if (! defined($current_course) || $current_course ne $courseid) {
           # Clear out variables
           $have_read_part_table = 0;
           undef(%ids_by_part);
           undef(%parts_by_id);
           $have_read_symb_table = 0;
           undef(%ids_by_symb);
           undef(%symbs_by_id);
           $have_read_student_table = 0;
           undef(%ids_by_student);
           undef(%students_by_id);
           #
           $current_course = $courseid;
       }
       #
       # Set up database names
       my $base_id = $courseid;
       $symb_table        = $base_id.'_'.'symb';
       $part_table        = $base_id.'_'.'part';
       $student_table     = $base_id.'_'.'student';
       $performance_table = $base_id.'_'.'performance';
       $parameters_table  = $base_id.'_'.'parameters';
       $fulldump_part_table      = $base_id.'_'.'partdata';
       $fulldump_response_table  = $base_id.'_'.'responsedata';
       $fulldump_timestamp_table = $base_id.'_'.'timestampdata';
       $weight_table             = $base_id.'_'.'weight';
       #
       @Tables = (
                  $symb_table,
                  $part_table,
                  $student_table,
                  $performance_table,
                  $parameters_table,
                  $fulldump_part_table,
                  $fulldump_response_table,
                  $fulldump_timestamp_table,
                  $weight_table,
                  );
       return;
 }  }
   
 ################################################  ################################################
Line 1392  sub CheckForResidualDownload { Line 2791  sub CheckForResidualDownload {
   
 =pod  =pod
   
   =back
   
   =item End of Local Data Caching Subroutines
   
   =cut
   
   ################################################
   ################################################
   
   } # End scope of table identifiers
   
   ################################################
   ################################################
   
   =pod
   
   =head3 Classlist Subroutines
   
 =item &get_classlist();  =item &get_classlist();
   
 Retrieve the classist of a given class or of the current class.  Student  Retrieve the classist of a given class or of the current class.  Student
Line 1405  $ENV{'course.'.$cid.'.domain'}, and $ENV Line 2822  $ENV{'course.'.$cid.'.domain'}, and $ENV
   
 Returns a reference to a hash which contains:  Returns a reference to a hash which contains:
  keys    '$sname:$sdom'   keys    '$sname:$sdom'
  values  [$end,$start,$id,$section,$fullname]   values  [$sdom,$sname,$end,$start,$id,$section,$fullname,$status,$type,$lockedtype]
   
   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  =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 CL_TYPE     { return 8; }
   sub CL_LOCKEDTYPE   { return 9; }
   
 sub get_classlist {  sub get_classlist {
     my ($cid,$cdom,$cnum) = @_;      my ($cid,$cdom,$cnum) = @_;
     $cid = $cid || $ENV{'request.course.id'};      $cid = $cid || $ENV{'request.course.id'};
     $cdom = $cdom || $ENV{'course.'.$cid.'.domain'};      $cdom = $cdom || $ENV{'course.'.$cid.'.domain'};
     $cnum = $cnum || $ENV{'course.'.$cid.'.num'};      $cnum = $cnum || $ENV{'course.'.$cid.'.num'};
    my $now = time;      my $now = time;
     #      #
     my %classlist=&Apache::lonnet::dump('classlist',$cdom,$cnum);      my %classlist=&Apache::lonnet::dump('classlist',$cdom,$cnum);
     while (my ($student,$info) = each(%classlist)) {      while (my ($student,$info) = each(%classlist)) {
         return undef if ($student =~ /^(con_lost|error|no_such_host)/i);          if ($student =~ /^(con_lost|error|no_such_host)/i) {
               &Apache::lonnet::logthis('get_classlist error for '.$cid.':'.$student);
               return undef;
           }
         my ($sname,$sdom) = split(/:/,$student);          my ($sname,$sdom) = split(/:/,$student);
         my @Values = split(/:/,$info);          my @Values = split(/:/,$info);
         my ($end,$start,$id,$section,$fullname);          my ($end,$start,$id,$section,$fullname,$type,$lockedtype);
         if (@Values > 2) {          if (@Values > 2) {
             ($end,$start,$id,$section,$fullname) = @Values;              ($end,$start,$id,$section,$fullname,$type,$lockedtype) = @Values;
         } else { # We have to get the data ourselves          } else { # We have to get the data ourselves
             ($end,$start) = @Values;              ($end,$start) = @Values;
             $section = &Apache::lonnet::usection($sdom,$sname,$cid);              $section = &Apache::lonnet::getsection($sdom,$sname,$cid);
             my %info=&Apache::lonnet::get('environment',              my %info=&Apache::lonnet::get('environment',
                                           ['firstname','middlename',                                            ['firstname','middlename',
                                            'lastname','generation','id'],                                             'lastname','generation','id'],
Line 1438  sub get_classlist { Line 2873  sub get_classlist {
             if ($tmp =~/^(con_lost|error|no_such_host)/i) {              if ($tmp =~/^(con_lost|error|no_such_host)/i) {
                 $fullname = 'not available';                  $fullname = 'not available';
                 $id = 'not available';                  $id = 'not available';
                   &Apache::lonnet::logthis('unable to retrieve environment '.
                                            'for '.$sname.':'.$sdom);
             } else {              } else {
                 $fullname = &ProcessFullName(@info{qw/lastname generation                   $fullname = &Apache::lonnet::format_name(@info{qw/firstname middlename lastname generation/},'lastname');
                                                        firstname middlename/});  
                 $id = $info{'id'};                  $id = $info{'id'};
             }              }
             # Update the classlist with this students information              # Update the classlist with this students information
             if ($fullname ne 'not available') {              if ($fullname ne 'not available') {
                 my $enrolldata = join(':',$end,$start,$id,$section,$fullname);   my $enrolldata = join(':',$end,$start,$id,$section,$fullname);
                 my $reply=&Apache::lonnet::cput('classlist',   my $reply=&Apache::lonnet::cput('classlist',
                                                 {$student => $enrolldata},                                                  {$student => $enrolldata},
                                                 $cdom,$cnum);                                                  $cdom,$cnum);
                 if ($reply !~ /^(ok|delayed)/) {                  if ($reply !~ /^(ok|delayed)/) {
Line 1461  sub get_classlist { Line 2897  sub get_classlist {
             $status='Active';              $status='Active';
         }          }
         $classlist{$student} =           $classlist{$student} = 
             [$sdom,$sname,$end,$start,$id,$section,$fullname,$status];              [$sdom,$sname,$end,$start,$id,$section,$fullname,$status,$type,$lockedtype];
     }      }
     if (wantarray()) {      if (wantarray()) {
         return (\%classlist,['domain','username','end','start','id',          return (\%classlist,['domain','username','end','start','id',
                              'section','fullname','status']);                               'section','fullname','status','type','lockedtype']);
     } else {      } else {
         return \%classlist;          return \%classlist;
     }      }

Removed from v.1.36  
changed lines
  Added in v.1.141


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