Diff for /loncom/interface/loncoursedata.pm between versions 1.35 and 1.155

version 1.35, 2002/10/14 19:06:21 version 1.155, 2006/02/05 19:14:58
Line 1 Line 1
 # The LearningOnline Network with CAPA  # The LearningOnline Network with CAPA
 # (Publication Handler  
 #  #
 # $Id$  # $Id$
 #  #
Line 51  package Apache::loncoursedata; Line 50  package Apache::loncoursedata;
   
 use strict;  use strict;
 use Apache::Constants qw(:common :http);  use Apache::Constants qw(:common :http);
 use Apache::lonnet();  use Apache::lonnet;
 use Apache::lonhtmlcommon;  use 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 -------------------------------------------  sub LoadDiscussion {
       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) {
    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;
   }
   
   ################################################
   ################################################
   
 =pod  =pod
   
 =item &DownloadClasslist()  =item &make_into_hash($values);
   
 Collects lastname, generation, middlename, firstname, PID, and section for each  Returns a reference to a hash as described by $values.  $values is
 student from their environment database.  The section data is also download, though  assumed to be the result of 
 it is in a rough format, and is processed later.  The list of students is built from      join(':',map {&Apache::lonnet::escape($_)} %orighash);
 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  This is a helper function for get_current_state.
   
 Input: $courseID, $lastDownloadTime, $c  =cut
   
 $courseID:  The id of the course  ################################################
   ################################################
   sub make_into_hash {
       my $values = shift;
       my %tmp = map { &Apache::lonnet::unescape($_); }
                                              split(':',$values);
       return \%tmp;
   }
   
 $lastDownloadTime:  This is the date stamp for when this information was  
 last gathered.  If it is set to Not downloaded, it will gather the data  
 again, though it currently does not remove the old data.  
   
 $c: The connection class that can determine if the browser has aborted.  It  ################################################
 is used to short circuit this function so that it does not continue to   ################################################
 get information when there is no need.  
   
 Output: \%classlist  =pod
   
 \%classlist: A pointer to a hash containing the following data:  =head1 LOCAL DATA CACHING SUBROUTINES
   
 -A list of student name:domain (as keys) (known below as $name)  The local caching is done using MySQL.  There is no fall-back implementation
   if MySQL is not running.
   
 -A hash pointer for each student containing lastname, generation, firstname,  The programmers interface is to call &get_current_state() or some other
 middlename, and PID : Key is $name.studentInformation  primary interface subroutine (described below).  The internals of this 
   storage system are documented here.
   
 -A hash pointer to each students section data : Key is $name.section  There are six tables used to store student performance data (the results of
   a dumpcurrent).  Each of these tables is created in MySQL with a name of
   $courseid_*****, where ***** is 'symb', 'part', or whatever is appropriate 
   for the table.  The tables and their purposes are described below.
   
 -If there was an error in dump, it will be returned in the hash.  See  Some notes before we get started.
 the error codes for dump in lonnet.  Also, an error key will be   
 generated if an abort occurs.  
   
 =back  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!
   
 =cut  INDEXes work best on integer data.
   
 sub DownloadClasslist {  JOIN is used to combine data from many tables into one output.
     my ($courseID, $lastDownloadTime, $c)=@_;  
     my ($courseDomain,$courseNumber)=split(/\_/,$courseID);  
     my %classlist;  
   
     my $modifiedTime = &Apache::lonnet::GetFileTimestamp($courseDomain, $courseNumber,  
                                                          'classlist.db',   
                                                          $Apache::lonnet::perlvar{'lonUsersDir'});  
   
     # Always download the information if lastDownloadTime is set to  
     # Not downloaded, otherwise it is only downloaded if the file  
     # has been updated and has a more recent date stamp  
     if($lastDownloadTime ne 'Not downloaded' &&  
        $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);  lonmysql.pm is used for some of the interface, specifically the table creation
     foreach(keys (%classlist)) {  calls.  The inserts are done in bulk by directly calling the database handler.
         if(/^(con_lost|error|no_such_host)/i) {  The SELECT ... JOIN statement used to retrieve the data does not have an
     return;  interface in lonmysql.pm and I shudder at the thought of writing one.
         }  
     }  
   
     foreach my $name (keys(%classlist)) {  =head3 Table Descriptions
         if(defined($c) && ($c->aborted())) {  
             $classlist{'error'}='aborted';  
             return \%classlist;  
         }  
   
         my ($studentName,$studentDomain) = split(/\:/,$name);  =over 4
         # 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()) {  =item Tables used to store meta information
             $classlist{'error'}='aborted';  
             return \%classlist;  
         }  
   
         #Section  The following tables hold data required to keep track of the current status
         my %section=&Apache::lonnet::dump('roles',$studentDomain,$studentName);  of a students data in the tables or to look up the students data in the tables.
         $classlist{$name.':sections'}=\%section;  
     }  
   
     $classlist{'UpToDate'} = 'false';  =over 4
     $classlist{'lastDownloadTime'}=time;  
   
     return \%classlist;  =item $symb_table
 }  
   
 =pod  The symb_table has two columns.  The first is a 'symb_id' and the second
   is the text name for the 'symb' (limited to 64k).  The 'symb_id' is generated
   automatically by MySQL so inserts should be done on this table with an
   empty first element.  This table has its PRIMARY KEY on the 'symb_id'.
   
   =item $part_table
   
 =item &DownloadCourseInformation()  The part_table has two columns.  The first is a 'part_id' and the second
   is the text name for the 'part' (limited to 100 characters).  The 'part_id' is
   generated automatically by MySQL so inserts should be done on this table with
   an empty first element.  This table has its PRIMARY KEY on the 'part' (100
   characters) and a KEY on 'part_id'.
   
 Dump of all the course information for a single student.  The data can be  =item $student_table
 pruned by making use of dumps regular expression arguement.  This function  
 also takes a regular expression which it passes straight through to dump.    The student_table has 7 columns.  The first is a 'student_id' assigned by 
 The data is no escaped, because it is done elsewhere.  It also  MySQL.  The second is 'student' which is username:domain.  The third through
 checks the timestamp of the students course database file and only downloads  fifth are 'section', 'status' (enrollment status), and 'classification' 
 if it has been modified since the last download.  (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'.
   
   =back 
   
   =item Tables used to store current status data
   
   The following tables store data only about the students current status on 
   a problem, meaning only the data related to the last attempt on a problem.
   
 =over 4  =over 4
   
 Input: $namedata, $courseID, $lastDownloadTime, $WhatIWant  =item $performance_table
   
 $namedata: student name:domain  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.
   
 $courseID:  The id of the course  =back
   
 $lastDownloadTime:  This is the date stamp for when this information was  =item Tables used for storing historic data
 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 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.  
   
 Output: \%courseData  =over 4
   
   =item $fulldump_response_table
   
 \%courseData:  A hash pointer to the raw data from the students course  The response table holds data (documented in loncapa/docs/homework/datastorage)
 database.  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'.
   
 =back  =back
   
 =cut  =back
   
 sub DownloadCourseInformation {  =head3 Important Subroutines
     my ($namedata,$courseID,$lastDownloadTime,$WhatIWant)=@_;  
     my %courseData;  
     my ($name,$domain) = split(/\:/,$namedata);  
   
     my $modifiedTime = &Apache::lonnet::GetFileTimestamp($domain, $name,  Here is a brief overview of the subroutines which are likely to be of 
                                       $courseID.'.db',   interest:
                                       $Apache::lonnet::perlvar{'lonUsersDir'});  
   
     if($lastDownloadTime >= $modifiedTime && $modifiedTime >= 0) {  =over 4
         # Data is not gathered so return UpToDate as true.  This  
         # will be interpreted in ProcessClasslist  
         $courseData{$namedata.':lastDownloadTime'}=time;  
         $courseData{$namedata.':UpToDate'} = 'true';  
         return \%courseData;  
     }  
   
     # Download course data  =item &get_current_state(): programmers interface.
     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 &init_dbs(): table creation
     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;  =item &update_student_data(): data storage calls
 }  
   
 # ----- END DOWNLOAD INFORMATION ---------------------------------------  =item &get_student_data_from_performance_cache(): data retrieval
   
 =pod  =back
   
 =head1 PROCESSING FUNCTIONS  =head3 Main Documentation
   
 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  =cut
   
 # ----- PROCESSING FUNCTIONS ---------------------------------------  ################################################
   ################################################
   
   ################################################
   ################################################
   { # Begin scope of table identifiers
   
   my $current_course ='';
   my $symb_table;
   my $part_table;
   my $student_table;
   my $performance_table;
   my $parameters_table;
   my $fulldump_response_table;
   my $fulldump_part_table;
   my $fulldump_timestamp_table;
   my $weight_table;
   
   my @Tables;
   ################################################
   ################################################
   
 =pod  =pod
   
 =item &ProcessTopResourceMap()  =item &init_dbs()
   
 Trace through the "big hash" created in rat/lonuserstate.pm::loadmap.    Input: course id
 Basically, this function organizes a subset of the data and stores it in  
 cached data.  The data stored is the problems, sequences, sequence titles,  
 parts of problems, and their ordering.  Column width information is also   
 partially handled here on a per sequence basis.  
   
 =over 4  Output: 0 on success, positive integer on error
   
 Input: $cache, $c  This routine issues the calls to lonmysql to create the tables used to
   store student data.
   
 $cache:  A pointer to a hash to store the information  =cut
   
   ################################################
   ################################################
   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;
   }
   
 $c:  The connection class used to determine if an abort has been sent to the   ################################################
 browser  ################################################
   
 Output: A string that contains an error message or "OK" if everything went   =pod
 smoothly.  
   
 =back  =item &delete_caches()
   
   This routine drops all the tables associated with a course from the 
   MySQL database.
   
   Input: course id (optional, determined by environment if omitted) 
   
   Returns: nothing
   
 =cut  =cut
   
 sub ProcessTopResourceMap {  ################################################
     my ($cache,$c)=@_;  ################################################
     my %hash;  sub delete_caches {
     my $fn=$ENV{'request.course.fn'};      my $courseid = shift;
     if(-e "$fn.db") {      $courseid = $env{'request.course.id'} if (! defined($courseid));
  my $tieTries=0;      #
  while($tieTries < 3) {      &setup_table_names($courseid);
             if($c->aborted()) {      #
                 return;      my $dbh = &Apache::lonmysql::get_dbh();
             }      foreach my $table (@Tables) {
     if(tie(%hash,'GDBM_File',"$fn.db",&GDBM_READER(),0640)) {          my $command = 'DROP TABLE '.$table.';';
  last;          $dbh->do($command);
     }          if ($dbh->err) {
     $tieTries++;              &Apache::lonnet::logthis($command.' resulted in error: '.$dbh->errstr);
     sleep 1;  
  }  
  if($tieTries >= 3) {  
             return 'Coursemap undefined.';  
         }          }
     } else {  
         return 'Can not open Coursemap.';  
     }      }
       return;
   }
   
     my $oldkeys;  ################################################
     if(defined($cache->{'ResourceKeys'})) {  ################################################
         $oldkeys = $cache->{'ResourceKeys'};  
         foreach (split(':::', $cache->{'ResourceKeys'})) {  
             delete $cache->{$_};  
         }  
         delete $cache->{'ResourceKeys'};  
     }  
   
     # Initialize state machine.  Set information pointing to top level map.  
     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_'.  =pod
   $hash{'src_'.$currentResourceID}};  
     $currentResourceID=$hash{'map_start_'.  
      $hash{'src_'.$currentResourceID}};  
   
     if(!($currentResourceID) || !($lastResourceID)) {  
  $currentSequence=pop(@sequences);  
  $currentResourceID=pop(@currentResource);  
  $lastResourceID=pop(@finishResource);  
  if($currentSequence eq $topLevelSequenceNumber) {  
     last;  
  }  
     }  
             next;  
  }  
   
  # Handle gradable resources: exams, problems, etc  =item &get_part_id()
  $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};  Get the MySQL id of a problem part string.
 #            $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  Input: $part
  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);  Output: undef on error, integer $part_id on success.
     if($currentSequence eq $topLevelSequenceNumber) {  
  last;  
     }  
         }  
   
  # MOVE!!!  =item &get_part()
  # 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);  Get the string describing a part from the MySQL id of the problem part.
     my $newkeys = join(':::', @theKeys);  
     $cache->{'ResourceKeys'} = join(':::', $newkeys);  Input: $part_id
     if($newkeys ne $oldkeys) {  
         $cache->{'ResourceUpdated'} = 'true';  Output: undef on error, $part string on success.
     } else {  
         $cache->{'ResourceUpdated'} = 'false';  =cut
     }  
   
     unless (untie(%hash)) {  ################################################
         &Apache::lonnet::logthis("<font color=blue>WARNING: ".  ################################################
                                  "Could not untie coursemap $fn (browse)".  
                                  ".</font>");   my $have_read_part_table = 0;
   my %ids_by_part;
   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];
           }
     }      }
       return $ids_by_part{$part} if (exists($ids_by_part{$part}));
       return undef; # error
   }
   
     return 'OK';  sub get_part {
       my ($part_id) = @_;
       if (! exists($parts_by_id{$part_id})  || 
           ! defined($parts_by_id{$part_id}) ||
           $parts_by_id{$part_id} eq '') {
           my @Result = &Apache::lonmysql::get_rows($part_table);
           foreach (@Result) {
               $parts_by_id{$_->[0]}=$_->[1];
           }
       }
       return $parts_by_id{$part_id} if(exists($parts_by_id{$part_id}));
       return undef; # error
 }  }
   
   ################################################
   ################################################
   
 =pod  =pod
   
 =item &ProcessClasslist()  =item &get_symb_id()
   
 Taking the class list dumped from &DownloadClasslist(), all the   Get the MySQL id of a symb.
 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: $symb
 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 $symb_id on success.
   
 Input: $cache, $classlist, $courseID, $ChartDB, $c  =item &get_symb()
   
 $cache: A hash pointer to store the data  Get the symb associated with a MySQL symb_id.
   
 $classlist:  The hash of data collected about a student from   Input: $symb_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, $symb 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_symb_table = 0;
         if(((!$end) || time < $end) && ((!$start) || (time > $start))) {  my %ids_by_symb;
             $status='Active';  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];
         }          }
         $cache->{$name.':Status'}=$status;      }
         $cache->{$name.':section'}=$sec;      return $ids_by_symb{$symb} if(exists( $ids_by_symb{$symb}));
       return undef; # error
   }
   
         if($sec eq '' || !defined($sec) || $sec eq ' ') {  sub get_symb {
             $sec = 'none';      my ($symb_id) = @_;
         }      if (! exists($symbs_by_id{$symb_id})  || 
         if(defined($cache->{'sectionList'})) {          ! defined($symbs_by_id{$symb_id}) ||
             if($cache->{'sectionList'} !~ /(^$sec:|^$sec$|:$sec$|:$sec:)/) {          $symbs_by_id{$symb_id} eq '') {
                 $cache->{'sectionList'} .= ':'.$sec;          my @Result = &Apache::lonmysql::get_rows($symb_table);
             }          foreach (@Result) {
         } else {              $symbs_by_id{$_->[0]}=$_->[1];
             $cache->{'sectionList'} = $sec;  
         }          }
     }      }
       return $symbs_by_id{$symb_id} if(exists( $symbs_by_id{$symb_id}));
     $cache->{'ClasslistTimestamp'}=time;      return undef; # error
     $cache->{'NamesOfStudents'}=join(':::',@names);  
   
     return @names;  
 }  }
   
 =pod  ################################################
   ################################################
 =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 $cdom = $env{'course.'.$courseid.'.domain'};
       my $cnum = $env{'course.'.$courseid.'.num'};
       my $classlist = &get_classlist($cdom,$cnum);
       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  =pod
 processed and how (basically).  
   
 $name:  username:domain  =item &update_full_student_data($sname,$sdom,$courseid)
   
 The input is slightly different here, but is quite simple.  Does a lonnet::dump on a student to populate the courses tables.
 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  Input: $sname, $sdom, $courseid
   
 *NOTE:  There is no output, but an error message is stored away in the cache   Output: $returnstatus
 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  $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.
   
 =cut  =cut
   
 sub ExtractStudentData {  ################################################
     my ($input, $output, $data, $name)=@_;  ################################################
   sub update_full_student_data {
     if(!&CheckDateStampError($input, $data, $name)) {      my ($sname,$sdom,$courseid) = @_;
         return;      #
     }      # Set up database names
       &setup_table_names($courseid);
     # This little delete thing, should not be here.  Move some other      #
     # time though.      my $student_id = &get_student_id($sname,$sdom);
     my %allkeys;      my $student = $sname.':'.$sdom;
     if(defined($output->{$name.':keys'})) {      #
  foreach (split(':::', $output->{$name.':keys'})) {      my $returnstatus = 'okay';
     delete $output->{$name.':'.$_};      #
  }      # Download students data
         delete $output->{$name.':keys'};      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;
     my ($username,$domain)=split(':',$name);      #
       # Get database handle and clean out the tables 
     my $Version;      my $dbh = &Apache::lonmysql::get_dbh();
     my $problemsCorrect = 0;      $dbh->do('DELETE FROM '.$fulldump_response_table.' WHERE student_id='.
     my $totalProblems   = 0;               $student_id);
     my $problemsSolved  = 0;      $dbh->do('DELETE FROM '.$fulldump_part_table.' WHERE student_id='.
     my $numberOfParts   = 0;               $student_id);
     my $totalAwarded    = 0;      $dbh->do('DELETE FROM '.$fulldump_timestamp_table.' WHERE student_id='.
     foreach my $sequence (split(':', $data->{'orderedSequences'})) {               $student_id);
         foreach my $problemID (split(':', $data->{$sequence.':problems'})) {      #
             my $problem = $data->{$problemID.':problem'};      # Parse and store the data into a form we can handle
             my $LatestVersion = $input->{$name.':version:'.$problem};      my $partdata;
       my $respdata;
             # Output dashes for all the parts of this problem if there      while (my ($key,$value) = each(%studentdata)) {
             # is no version information about the current problem.          next if ($key =~ /^(\d+):(resource$|subnum$|keys:)/);
             $output->{$name.':'.$problemID.':NoVersion'} = 'false';          my ($transaction,$symb,$parameter) = split(':',$key);
             $allkeys{$name.':'.$problemID.':NoVersion'}++;          my $symb_id = &get_symb_id($symb);
             if(!$LatestVersion) {          if ($parameter eq 'timestamp') {
                 foreach my $part (split(/\:/,$data->{$sequence.':'.              # We can deal with 'timestamp' right away
                                                       $problemID.              my @timestamp_storage = ($symb_id,$student_id,
                                                       ':parts'})) {                                       $transaction,$value);
                     $output->{$name.':'.$problemID.':'.$part.':tries'} = 0;              my $store_command = 'INSERT IGNORE INTO '.$fulldump_timestamp_table.
                     $output->{$name.':'.$problemID.':'.$part.':awarded'} = 0;                  " VALUES ('".join("','",@timestamp_storage)."');";
                     $output->{$name.':'.$problemID.':'.$part.':code'} = ' ';              $dbh->do($store_command);
     $allkeys{$name.':'.$problemID.':'.$part.':tries'}++;              if ($dbh->err()) {
     $allkeys{$name.':'.$problemID.':'.$part.':awarded'}++;                  &Apache::lonnet::logthis('unable to execute '.$store_command);
     $allkeys{$name.':'.$problemID.':'.$part.':code'}++;                  &Apache::lonnet::logthis($dbh->errstr());
                     $totalProblems++;  
                 }  
                 $output->{$name.':'.$problemID.':NoVersion'} = 'true';  
                 next;  
             }              }
               next;
             my %partData=undef;          } elsif ($parameter eq 'version') {
             # Initialize part data, display skips correctly              next;
             # Skip refers to when a student made no submissions on that          } elsif ($parameter =~ /^resource\.(.*)\.(tries|
             # part/problem.                                                    award|
             foreach my $part (split(/\:/,$data->{$sequence.':'.                                                    awarded|
                                                  $problemID.                                                    previous|
                                                  ':parts'})) {                                                    solved|
                 $partData{$part.':tries'}=0;                                                    awarddetail|
                 $partData{$part.':code'}=' ';                                                    submission|
                 $partData{$part.':awarded'}=0;                                                    submissiongrading|
                 $partData{$part.':timestamp'}=0;                                                    molecule)\s*$/x){
                 foreach my $response (split(':', $data->{$sequence.':'.              # we do not have enough information to store an 
                                                          $problemID.':'.              # entire row, so we save it up until later.
                                                          $part.':responseIDs'})) {              my ($part_and_resp_id,$field) = ($1,$2);
                     $partData{$part.':'.$response.':submission'}='';              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;
                 }                  }
             }              }
           }
             # Looping through all the versions of each part, starting with the      }
             # oldest version.  Basically, it gets the most recent       ##
             # set of grade data for each part.      ## Store the part data
             my @submissions = ();      my $store_command = 'INSERT IGNORE INTO '.$fulldump_part_table.
     for(my $Version=1; $Version<=$LatestVersion; $Version++) {          ' VALUES '."\n";
                 foreach my $part (split(/\:/,$data->{$sequence.':'.      my $store_rows = 0;
                                                      $problemID.      while (my ($symb_id,$hash1) = each (%$partdata)) {
                                                      ':parts'})) {          while (my ($part_id,$hash2) = each (%$hash1)) {
               while (my ($transaction,$data) = each (%$hash2)) {
                     if(!defined($input->{"$name:$Version:$problem".                  $store_command .= "('".join("','",$symb_id,$part_id,
                                          ":resource.$part.solved"})) {                                              $student_id,
                         # No grade for this submission, so skip                                              $transaction,
                         next;                                              $data->{'tries'},
                     }                                              $data->{'award'},
                                               $data->{'awarded'},
                     my $tries=0;                                              $data->{'previous'})."'),";
                     my $code=' ';                  $store_rows++;
                     my $awarded=0;              }
           }
                     $tries = $input->{$name.':'.$Version.':'.$problem.      }
                                       ':resource.'.$part.'.tries'};      if ($store_rows) {
                     $awarded = $input->{$name.':'.$Version.':'.$problem.          chop($store_command);
                                         ':resource.'.$part.'.awarded'};          $dbh->do($store_command);
           if ($dbh->err) {
                     $partData{$part.':awarded'}=($awarded) ? $awarded : 0;              $returnstatus = 'error storing part data';
                     $partData{$part.':tries'}=($tries) ? $tries : 0;              &Apache::lonnet::logthis('insert error '.$dbh->errstr());
               &Apache::lonnet::logthis("While attempting\n".$store_command);
                     $partData{$part.':timestamp'}=$input->{$name.':'.$Version.':'.          }
                                                            $problem.      }
                                                            ':timestamp'};      ##
                     if(!$input->{$name.':'.$Version.':'.$problem.':resource.'.$part.      ## Store the response data
                                  '.previous'}) {      $store_command = 'INSERT IGNORE INTO '.$fulldump_response_table.
                         foreach my $response (split(':',          ' VALUES '."\n";
                                                    $data->{$sequence.':'.      $store_rows = 0;
                                                            $problemID.':'.      while (my ($symb_id,$hash1) = each (%$respdata)) {
                                                            $part.':responseIDs'})) {          while (my ($part_id,$hash2) = each (%$hash1)) {
                             @submissions=($input->{$name.':'.$Version.':'.              while (my ($resp_id,$hash3) = each (%$hash2)) {
                                                    $problem.                  while (my ($transaction,$data) = each (%$hash3)) {
                                                    ':resource.'.$part.'.'.                      my $submission = $data->{'submission'};
                                                    $response.'.submission'},                      # We have to be careful with user supplied input.
                                           @submissions);                      # 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...
                     my $val = $input->{$name.':'.$Version.':'.$problem.                      $submission = $dbh->quote($submission);
                                        ':resource.'.$part.'.solved'};                      $store_command .= "('".
                     if    ($val eq 'correct_by_student')   {$code = '*';}                           join("','",$symb_id,$part_id,
                     elsif ($val eq 'correct_by_override')  {$code = '+';}                               $resp_id,$student_id,
                     elsif ($val eq 'incorrect_attempted')  {$code = '.';}                                $transaction,
                     elsif ($val eq 'incorrect_by_override'){$code = '-';}                               $data->{'awarddetail'},
                     elsif ($val eq 'excused')              {$code = 'x';}                               $data->{'response_specific'},
                     elsif ($val eq 'ungraded_attempted')   {$code = '#';}                               $data->{'response_specific_value'}).
                     else                                   {$code = ' ';}                               "',".$submission."),";
                     $partData{$part.':code'}=$code;                      $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;
   }
   
             foreach my $part (split(/\:/,$data->{$sequence.':'.$problemID.  ################################################
                                                  ':parts'})) {  ################################################
                 $output->{$name.':'.$problemID.':'.$part.':wrong'} =   
                     $partData{$part.':tries'};  
  $allkeys{$name.':'.$problemID.':'.$part.':wrong'}++;  
   
                 if($partData{$part.':code'} eq '*') {  
                     $output->{$name.':'.$problemID.':'.$part.':wrong'}--;  
                     $problemsCorrect++;  
                 } elsif($partData{$part.':code'} eq '+') {  
                     $output->{$name.':'.$problemID.':'.$part.':wrong'}--;  
                     $problemsCorrect++;  
                 }  
   
                 $output->{$name.':'.$problemID.':'.$part.':tries'} =   =pod
                     $partData{$part.':tries'};  
                 $output->{$name.':'.$problemID.':'.$part.':code'} =  =item &update_student_data()
                     $partData{$part.':code'};  
                 $output->{$name.':'.$problemID.':'.$part.':awarded'} =  Input: $sname, $sdom, $courseid
                     $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') {  Output: $returnstatus, \%student_data
                     $totalProblems++;  
   $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);
       }
       #
       return @Results;
   }
   
   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);
   }
   
   sub store_student_data {
       my ($sname,$sdom,$courseid,$student_data) = @_;
       #
       my $student_id = &get_student_id($sname,$sdom);
       my $student = $sname.':'.$sdom;
       #
       my $returnstatus = 'okay';
       #
       # Remove all of the students data from the table
       my $dbh = &Apache::lonmysql::get_dbh();
       $dbh->do('DELETE FROM '.$performance_table.' WHERE student_id='.
                $student_id);
       $dbh->do('DELETE FROM '.$parameters_table.' WHERE student_id='.
                $student_id);
       #
       # Store away the data
       #
       my $starttime = Time::HiRes::time;
       my $elapsed = 0;
       my $rows_stored;
       my $store_parameters_command  = 'INSERT IGNORE INTO '.$parameters_table.
           ' VALUES '."\n";
       my $num_parameters = 0;
       my $store_performance_command = 'INSERT IGNORE INTO '.$performance_table.
           ' VALUES '."\n";
       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);
           #
           # Parameters
           while (my ($parameter,$value) = each(%$param_hash)) {
               if ($parameter !~ /(timestamp|resource\.(.*)\.(solved|tries|awarded|award|awarddetail|previous))/) {
                   my $sql_parameter = "('".join("','",
                                                 $symb_id,$student_id,
                                                 $parameter)."',".
                                                     $dbh->quote($value)."),\n";
                   $num_parameters ++;
                   if ($sql_parameter !~ /''/) {
                       $store_parameters_command .= $sql_parameter;
                       #$rows_stored++;
                 }                  }
             }              }
         }          }
           # Performance
         $output->{$name.':'.$sequence.':problemsCorrect'} = $problemsCorrect;          my %stored;
  $allkeys{$name.':'.$sequence.':problemsCorrect'}++;          while (my ($parameter,$value) = each(%$param_hash)) {
         $problemsSolved += $problemsCorrect;              next if ($parameter !~ /^resource\.(.*)\.(solved|awarded)$/);
  $problemsCorrect=0;              my $part = $1;
       next if ($part =~ /\./);
               next if (exists($stored{$part}));
               $stored{$part}++;
               #
               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));
               my $sql_performance = 
                   "('".join("','",$symb_id,$student_id,$part_id,$part,
                                   $solved,$tries,$awarded,$award,
                                   $awarddetail,$timestamp)."'),\n";
               $store_performance_command .= $sql_performance;
               $rows_stored++;
           }
       }
       if (! $rows_stored) { return ($returnstatus, undef); }
       $store_parameters_command =~ s|,\n$||;
       $store_performance_command =~ s|,\n$||;
       my $start = Time::HiRes::time;
       $dbh->do($store_performance_command);
       if ($dbh->err()) {
           &Apache::lonnet::logthis('performance 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('parameters 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);
   }
   
   ######################################
   ######################################
   
     $output->{$name.':problemsSolved'} = $problemsSolved;  =pod
     $output->{$name.':totalProblems'} = $totalProblems;  
     $output->{$name.':totalAwarded'} = $totalAwarded;  
     $allkeys{$name.':problemsSolved'}++;  
     $allkeys{$name.':totalProblems'}++;  
     $allkeys{$name.':totalAwarded'}++;  
   
     $output->{$name.':keys'} = join(':::', keys(%allkeys));  =item &ensure_tables_are_set_up($courseid)
   
     return;  Checks to be sure the MySQL tables for the given class are set up.
   If $courseid is omitted it will be obtained from the environment.
   
   Returns nothing on success and 'error' on failure
   
   =cut
   
   ######################################
   ######################################
   sub ensure_tables_are_set_up {
       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';
           }
       }
 }  }
   
 sub LoadDiscussion {  ################################################
     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) {  =pod
  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;  =item &ensure_current_data()
   
   Input: $sname, $sdom, $courseid
   
   Output: $status, $data
   
   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)
   
   Input: $sname, $sdom, $courseid
   
 These are just a couple of functions do various odd and end   Output: $status
 jobs.  There was also a couple of bulk functions added.  These are  
 &DownloadStudentCourseData(), &DownloadStudentCourseDataSeparate(), and  This routine ensures the fulldata (the data from a lonnet::dump, not a
 &CheckForResidualDownload().  These functions now act as the interface  lonnet::currentdump) for a given student is up to date.
 for downloading student course data.  The statistical modules should  The $student_table is queried to determine the time of the last update.  
 no longer make the calls to dump and download and process etc.  They  If the students fulldata is out of date, &update_full_student_data() is
 make calls to these bulk functions to get their data.  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.
   
 sub CheckDateStampError {  This routine is the heart of the local caching system.  See the description
     my ($courseData, $cache, $name)=@_;  of $performance_table, $symb_table, $student_table, and $part_table.  The
     if($courseData->{$name.':UpToDate'} eq 'true') {  main task is building the MySQL request.  The tables appear in the request
         $cache->{$name.':lastDownloadTime'} =   in the order in which they should be parsed by MySQL.  When searching
             $courseData->{$name.':lastDownloadTime'};  on a student the $student_table is used to locate the 'student_id'.  All
         if($courseData->{$name.':lastDownloadTime'} eq 'Not downloaded') {  rows in $performance_table which have a matching 'student_id' are returned,
             $cache->{$name.':updateTime'} = ' Not updated';  with data from $part_table and $symb_table which match the entries in
         } else {  $performance_table, 'part_id' and 'symb_id'.  When searching on a symb,
             $cache->{$name.':updateTime'}=  the $symb_table is processed first, with matching rows grabbed from 
                 localtime($courseData->{$name.':lastDownloadTime'});  $performance_table and filled in from $part_table and $student_table in
   that order.  
   
   Running 'EXPLAIN ' on the 'SELECT' statements generated can be quite 
   interesting, especially if you play with the order the tables are listed.  
   
   =cut
   
   ################################################
   ################################################
   sub get_student_data_from_performance_cache {
       my ($sname,$sdom,$symb,$courseid)=@_;
       my $student = $sname.':'.$sdom if (defined($sname) && defined($sdom));
       &setup_table_names($courseid);
       #
       # Return hash
       my $studentdata;
       #
       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()
   
 Determine if the cache database can be accessed with a tie.  It waits up to  Gather data on a given problem.  The database is assumed to be 
 ten seconds before returning failure.  This function exists to help with  populated and all local caching variables are assumed to be set
 the problems with stopping the data download.  When an abort occurs and the  properly.  This means you need to call &ensure_current_data for
 user quickly presses a form button and httpd child is created.  This  the students you are concerned with prior to calling this routine.
 child needs to wait for the other to finish (hopefully within ten seconds).  
   Inputs: $Sections, $status, $symb, $part, $courseid, $starttime, $endtime
   
 =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.
   
   =item $status String describing the status of students
   
 $ChartDB: The name of the cache database to be opened  =item $symb is the symb for the problem.
   
 Output: -1, 0, 1  =item $part is the part id you need statistics for
   
 -1: Could not tie database  =item $courseid is the course id, of course!
  0: Use cached data  
  1: New cache database created, use that.  =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:
   
 sub TestCacheData {  =over 4
     my ($ChartDB,$isRecalculate,$totalDelay)=@_;  
     my $isCached=-1;  =item num_students The number of students attempting the problem
     my %testData;        
     my $tieTries=0;  =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
   
     if(!defined($totalDelay)) {  =cut
         $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);
       if (!$sth) {
    die($dbh->errstr . " SQL: $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 $navmap = Apache::lonnavmaps::navmap->new();
       if (!defined($navmap)) {
           &Apache::lonnet::logthis('loncoursedata::populate_weight_table:'.$/.
                                    '  unable to get navmaps resource'.$/.
                                    '  '.join(' ',(caller)));
           return;
       }
       my @sequences = $navmap->retrieveResources(undef,
                                                  sub { shift->is_map(); },1,0,1);
       my @resources;
       foreach my $seq (@sequences) {
           push(@resources,$navmap->retrieveResources($seq,
                                                      sub {shift->is_problem();},
                                                      0,0,0));
       }
       if (! scalar(@resources)) {
           &Apache::lonnet::logthis('loncoursedata::populate_weight_table:'.$/.
                                    ' no resources returned for '.$courseid);
           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 (@resources) {
           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
 }  
   =item &limit_by_start_end_times
   
 sub DownloadStudentCourseData {  Build SQL WHERE condition which limits the data collected by the start
     my ($students,$checkDate,$cacheDB,$extract,$status,$courseID,$r,$c)=@_;  and end times provided
   
     my $title = 'LON-CAPA Statistics';  Inputs: $starttime, $endtime, $table
     my $heading = 'Download and Process Course Data';  
     my $studentCount = scalar(@$students);  
   
     my $WhatIWant;  Returns: $time_limits
     $WhatIWant = '(^version:|';  
     $WhatIWant .= '^\d+:.+?:(resource\.\d+\.';  =cut
     $WhatIWant .= '(solved|tries|previous|awarded|(\d+\.submission))\s*$';  
     $WhatIWant .= '|timestamp)';  
     $WhatIWant .= ')';  
 #    $WhatIWant = '.';  
   
     if($status eq 'true') {  ##########################################################
         &Apache::lonhtmlcommon::Create_PrgWin($r, $title, $heading);  ##########################################################
   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);
   }
   
   ######################################################
   ######################################################
   
   =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)
       $starttime (may be omitted)
       $endtime (may be omitted)
       $has_award_for (may be omitted)
   
   Returns; An array of arrays.  The sub arrays contain a student name and
   their score on the resources. $starttime and $endtime constrain the
   list to awards obtained during the given time limits. $has_score_on
   constrains the list to those students who at least attempted the
   resource identified by the given symb, which is used to filter out
   such students for statistics that would be adversely affected by such
   students. 
   
   =cut
   
     return 'OK';  ######################################################
   ######################################################
   sub RNK_student { return 0; };
   sub RNK_score   { return 1; };
   
   sub rank_students_by_scores_on_resources {
       my ($resources,$Sections,$enrollment,$courseid,$starttime,$endtime,$has_award_for) = @_;
       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 ($award_col, $award_join, $award_clause) = ('', '', '');
       if ($has_award_for) {
           my $resource_id = &get_symb_id($has_award_for);
           $award_col = ", perf.awarded";
           $award_join = "LEFT JOIN $performance_table AS perf ON perf.symb_id"
               ." = $resource_id AND perf.student_id = b.student_id ";
           $award_clause = "AND perf.awarded IS NOT NULL";
       }
       my $time_limits = &limit_by_start_end_time($starttime,$endtime,'a');
       my $request = "SELECT b.student,SUM(a.awarded*w.weight) AS score "
           ."$award_col 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 ".
           "$award_join 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 .= " $award_clause GROUP BY a.student_id ORDER BY score";
       #&Apache::lonnet::logthis('request = '.$/.$request);
       my $sth = $dbh->prepare($request) or die "Can't 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';  =pod
     my $heading = 'Download Course Data';  
   =item &get_sum_of_scores
   
     my $WhatIWant;  Inputs: $resource (hash ref, needs {'symb'} key),
     $WhatIWant = '(^version:|';  $part, (the part id),
     $WhatIWant .= '^\d+:.+?:(resource\.\d+\.';  $students (array ref, contents of array are scalars holding 'sname:sdom'),
     $WhatIWant .= '(solved|tries|previous|awarded|(\d+\.submission))\s*$';  $courseid
     $WhatIWant .= '|timestamp)';  
     $WhatIWant .= ')';  
   
     &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).
   
     my $studentCount = scalar(@$students);  =cut
     if($status eq 'true') {  
         &Apache::lonhtmlcommon::Create_PrgWin($r, $title, $heading);  ########################################################
   ########################################################
   sub get_sum_of_scores {
       my ($symb,$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($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.
           ' AS a WHERE ('.$symb_restriction.')';
       my ($max_possible) = &execute_SQL_request($dbh,$request);
       # &Apache::lonnet::logthis('request = '.$/.$request);
       return($min,$max,$ave,$std,$count,$max_possible);
   }
   
   
   ########################################################
   ########################################################
   
   =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
   
     return &CheckForResidualDownload($cacheDB, 'true', 'true',   =cut
                                      $courseID, $r, $c);  
   ########################################################
   ########################################################
   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,'.
           'SUM(a.awarded) AS count FROM '.
           $performance_table.' AS a '.
           '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(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=();  sub RDs_awarddetail   { return 3; }
     my %checkStudent;  sub RDs_submission    { return 2; }
     my $key;  sub RDs_timestamp     { return 1; }
     while(($key, undef) = each %downloadData) {  sub RDs_tries         { return 0; }
         my @temp = split(':', $key);  sub RDs_awarded       { return 4; }
         my $student = $temp[0].':'.$temp[1];  
         if(!defined($checkStudent{$student})) {  sub get_response_data_by_student {
             $checkStudent{$student}++;      my ($student,$symb,$response,$courseid) = @_;
             push(@students, $student);      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 ($sections,$enrollment,$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);
       if (! defined($symb_id)) {
           &Apache::lonnet::logthis('Unable to find symb for '.$symb.' in '.$courseid);
           return undef;
       }
       my $part_id = &get_part_id($part);
       if (! defined($part_id)) {
           &Apache::lonnet::logthis('Unable to find id for '.$part.' in '.$courseid);
           return undef;
       }
       #
       my $dbh = &Apache::lonmysql::get_dbh();
       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.awarded, a.tries, b.timestamp '.
           'FROM '.$fulldump_part_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 '.$student_table.' as d '.
           'ON a.student_id=d.student_id '.
           'WHERE '.
           'a.symb_id='.$symb_id.' AND a.part_id='.$part_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 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 $request = 'DROP TABLE IF EXISTS '.$tmptable;
   #    &Apache::lonnet::logthis('request = '.$/.$request);
       $dbh->do($request);
       #
       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,$enrollment_requirements) = 
           &limit_by_section_and_status($sections,$enrollment,'b');
       #
       my $time_requirements = &limit_by_start_end_time($starttime,$endtime,'a');
       ##
       $request = 'CREATE TEMPORARY TABLE IF NOT EXISTS '.$tmptable.
           ' SELECT a.student_id,SUM(a.awarded*c.weight) AS score FROM '.
           $performance_table.' AS a ';
       $request .= "LEFT JOIN ".$weight_table.' AS c ON a.symb_id=c.symb_id AND a.part_id=c.part_id ';
       if (defined($student_requirements) || defined($enrollment_requirements)) {
           $request .= ' LEFT JOIN '.$student_table.' AS b ON a.student_id=b.student_id';
       }
       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;
   }
   
   ################################################
   ################################################
   
   =pod
   
     return 'OK';  =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 2694  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
 information is returned from the classlist.db file and, if needed,  information is returned from the classlist.db file and, if needed,
 from the students environment.  from the students environment.
   
 Optional arguments are $cid, $cdom, and $cnum (course id, course domain,  Optional arguments are $cdom, and $cnum (course domain,
 and course number, respectively).  Any omitted arguments will be taken   and course number, respectively).  If either is ommitted the course
 from the current environment ($ENV{'request.course.id'},  will be taken from the current environment ($env{'request.course.id'},
 $ENV{'course.'.$cid.'.domain'}, and $ENV{'course.'.$cid.'.num'}).  $env{'course.'.$cid.'.domain'}, and $env{'course.'.$cid.'.num'}).
   
 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 ($cdom,$cnum) = @_;
     $cid = $cid || $ENV{'request.course.id'};      my $cid = $cdom.'_'.$cnum;
     $cdom = $cdom || $ENV{'course.'.$cid.'.domain'};      if (!defined($cdom) || !defined($cnum)) {
     $cnum = $cnum || $ENV{'course.'.$cid.'.num'};   $cid =  $env{'request.course.id'};
    my $now = time;   $cdom = $env{'course.'.$cid.'.domain'};
    $cnum = $env{'course.'.$cid.'.num'};
       }
       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 2779  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'};
             }              }
             # At this point, if we have the data (check for 'not available's              # Update the classlist with this students information
             # we could put it back into the classlist.db file.               if ($fullname ne 'not available') {
             # We have not decided to do that yet.   my $enrolldata = join(':',$end,$start,$id,$section,$fullname);
    my $reply=&Apache::lonnet::cput('classlist',
                                                   {$student => $enrolldata},
                                                   $cdom,$cnum);
                   if ($reply !~ /^(ok|delayed)/) {
                       &Apache::lonnet::logthis('Unable to update classlist for '.
                                                'student '.$sname.':'.$sdom.
                                                ' error:'.$reply);
                   }
               }
         }          }
         my $status='Expired';          my $status='Expired';
         if(((!$end) || $now < $end) && ((!$start) || ($now > $start))) {          if(((!$end) || $now < $end) && ((!$start) || ($now > $start))) {
             $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;
     }      }
Line 1467  sub get_classlist { Line 2818  sub get_classlist {
 1;  1;
 __END__  __END__
   
   

Removed from v.1.35  
changed lines
  Added in v.1.155


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