Diff for /loncom/interface/loncoursedata.pm between versions 1.40 and 1.178

version 1.40, 2002/12/11 21:41:02 version 1.178, 2006/12/28 21:01:39
Line 1 Line 1
 # The LearningOnline Network with CAPA  # The LearningOnline Network with CAPA
 # (Publication Handler  
 #  #
 # $Id$  # $Id$
 #  #
Line 50  Set of functions that download and proce Line 49  Set of functions that download and proce
 package Apache::loncoursedata;  package Apache::loncoursedata;
   
 use strict;  use strict;
 use Apache::Constants qw(:common :http);  use Apache::lonnet;
 use Apache::lonnet();  
 use Apache::lonhtmlcommon;  use Apache::lonhtmlcommon;
   use Apache::longroup;
   use Time::HiRes;
   use Apache::lonmysql;
 use HTML::TokeParser;  use HTML::TokeParser;
 use GDBM_File;  use GDBM_File;
   use lib '/home/httpd/lib/perl/';
   use LONCAPA;
   
 =pod  =pod
   
Line 65  and/or itself. Line 68  and/or itself.
   
 =cut  =cut
   
 # ----- DOWNLOAD INFORMATION -------------------------------------------  ################################################
   ################################################
   
 =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 {&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 { &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
   
   The part_table has two columns.  The first is a 'part_id' and the second
   is the text name for the 'part' (limited to 100 characters).  The 'part_id' is
   generated automatically by MySQL so inserts should be done on this table with
   an empty first element.  This table has its PRIMARY KEY on the 'part' (100
   characters) and a KEY on 'part_id'.
   
   =item $student_table
   
   The student_table has 7 columns.  The first is a 'student_id' assigned by 
   MySQL.  The second is 'student' which is username:domain.  The third through
   fifth are 'section', 'status' (enrollment status), and 'classification' 
   (to be used in the future).  The sixth and seventh ('updatetime' and 
   'fullupdatetime') contain the time of last update and full update of student
   data.  This table has its PRIMARY KEY on the 'student_id' column and is indexed
   on 'student', 'section', and 'status'.
   
   =item $groupnames_table
   
   The groupnames_table has 2 columns.  The first is a 'group_id' assigned by 
   MySQL.  The second is 'groupname' which is the name of the group in the course.
   
   =item $students_groups_table
   
 =item &DownloadCourseInformation()  The students_groups_table has 2 columns.  The first is the 'student_id', and the 
   second is the 'group_id'. These two columns comprise the PRIMARY KEY for this 
   table, as an individual student may be affiliated with more than one group at
   any time. This table is indexed on both student_id and group_id.
   
 Dump of all the course information for a single student.  The data can be  =back 
 pruned by making use of dumps regular expression arguement.  This function  
 also takes a regular expression which it passes straight through to dump.    =item Tables used to store current status data
 The data is no escaped, because it is done elsewhere.  It also  
 checks the timestamp of the students course database file and only downloads  The following tables store data only about the students current status on 
 if it has been modified since the last download.  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.  
   
   =over 4
   
 Output: \%courseData  =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', 'response_specific_value',
   'response_specific_2', 'response_specific_value_2', 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 $groupnames_table;
   my $students_groups_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
   
 $c:  The connection class used to determine if an abort has been sent to the   ################################################
 browser  ################################################
   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 => 'start',
                         type => 'INT',
                         restrictions => 'NOT NULL'},
                       { name => 'end',
                         type => 'INT',
                         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)',
                                   'start',
    'end']},],
       };
       #
       my $groupnames_table_def = {
           id => $groupnames_table,
           permanent => 'no',
           columns => [{ name => 'group_id',
                         type => 'MEDIUMINT UNSIGNED',
                         restrictions => 'NOT NULL',
                         auto_inc => 'yes', },
                       { name => 'groupname',
                         type => 'VARCHAR(100) BINARY',
                         restrictions => 'NOT NULL UNIQUE'},
                      ],
           'PRIMARY KEY' => ['group_id'],
           'KEY' => [{ columns => ['groupname (100)',]},],
       };
       #
       my $students_groups_table_def = {
           id => $students_groups_table,
           permanent => 'no',
           columns => [{ name => 'student_id',
                         type => 'MEDIUMINT UNSIGNED',
                         restrictions => 'NOT NULL', },
                       { name => 'group_id',
                         type => 'MEDIUMINT UNSIGNED',
                         restrictions => 'NOT NULL', },
                      ],
           'PRIMARY KEY' => ['student_id','group_id'],
           'KEY' => [{ columns => ['student_id'] },
                     { columns => ['group_id'] },],
       };
       #
       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 => 'response_specific_2',
                         type => 'TINYTEXT' },
                       { name => 'response_specific_value_2',
                         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;
       }
       $tableid = &Apache::lonmysql::create_table($groupnames_table_def);
       if (! defined($tableid)) {
           &Apache::lonnet::logthis("error creating groupnames_table: ".
                                    &Apache::lonmysql::get_error());
           return 11;
       }
       $tableid = &Apache::lonmysql::create_table($students_groups_table_def);
       if (! defined($tableid)) {
           &Apache::lonnet::logthis("error creating student_groups_table: ".
                                    &Apache::lonmysql::get_error());
           return 12;
       }
       return 0;
   }
   
 Output: A string that contains an error message or "OK" if everything went   ################################################
 smoothly.  ################################################
   
 =back  =pod
   
   =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;  ################################################
     delete $cache->{'OptionResponses'};  ################################################
     if(defined($cache->{'ResourceKeys'})) {  
         $oldkeys = $cache->{'ResourceKeys'};  
         foreach (split(':::', $cache->{'ResourceKeys'})) {  
             delete $cache->{$_};  
         }  
         delete $cache->{'ResourceKeys'};  
     }  
   
     # Initialize state machine.  Set information pointing to top level map.  
     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 5 for problems correct and 3 for space  
                 # between problems correct and problem output  
                 my $extra = 8;  
  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';  
     } else {  
         $cache->{'ResourceUpdated'} = 'false';  
     }  
   
     unless (untie(%hash)) {  Output: undef on error, $part string on success.
         &Apache::lonnet::logthis("<font color=blue>WARNING: ".  
                                  "Could not untie coursemap $fn (browse)".  =cut
                                  ".</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  =pod
   
 =item &ProcessStudentData()  =item &get_student_id()
   
 Takes the course data downloaded for a student in   Get the MySQL id of a student.
 &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  Input: $sname, $dom
   
 Input: $cache, $courseData, $name  Output: undef on error, integer $student_id on success.
   
 $cache: A hash pointer to store data  =item &get_student()
   
 $courseData:  A hash pointer that points to the course data downloaded for a   Get student username:domain associated with the MySQL student_id.
 student.  
   
 $name:  username:domain  Input: $student_id
   
 Output: None  Output: undef on error, string $student (username:domain) on success.
   
 *NOTE:  There is no output, but an error message is stored away in the cache   =cut
 data.  This is checked in &FormatStudentData().  The key username:domain:error   
 will only exist if an error occured.  The error is an error from   
 &DownloadCourseInformation().  
   
 =back  ################################################
   ################################################
   
 =cut  my $have_read_student_table = 0;
   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
   }
   
 sub ProcessStudentData {  sub get_student {
     my ($cache,$courseData,$name)=@_;      my ($student_id) = @_;
       if (! exists($students_by_id{$student_id})  || 
           ! defined($students_by_id{$student_id}) ||
           $students_by_id{$student_id} eq '') {
           my @Result = &Apache::lonmysql::get_rows($student_table);
           foreach (@Result) {
               $students_by_id{$_->[0]}=$_->[1];
           }
       }
       return $students_by_id{$student_id} if(exists($students_by_id{$student_id}));
       return undef; # error
   }
   
     if(!&CheckDateStampError($courseData, $cache, $name)) {  sub populate_student_table {
         return;      my ($courseid) = @_;
       if (! defined($courseid)) {
           $courseid = $env{'request.course.id'};
     }      }
       #
       &setup_table_names($courseid);
       &init_dbs($courseid,0);
       my $dbh = &Apache::lonmysql::get_dbh();
       my $request = 'INSERT IGNORE INTO '.$student_table.
           "(student,section,start,end) 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,$start,$end) = ($data->[&CL_SECTION()],
        $data->[&CL_START()],
        $data->[&CL_END()]);
           if ($section eq '' || $section =~ /^\s*$/) {
               $section = 'none';
           }
    if (!defined($start)) { $start = 0; }
    if (!defined($end))   { $end   = 0; }
           $request .= "('".$student."','".$section."','".$start."','".$end."'),";
           $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);
       }
       return;
   }
   
     # This little delete thing, should not be here.  Move some other  my $have_read_groupnames_table = 0;
     # time though.  my %ids_by_groupname;
     if(defined($cache->{$name.':keys'})) {  
  foreach (split(':::', $cache->{$name.':keys'})) {  sub get_group_id {
     delete $cache->{$name.':'.$_};      my ($groupname) = @_;
  }      if (! $have_read_groupnames_table) {
         delete $cache->{$name.':keys'};          my @Result = &Apache::lonmysql::get_rows($groupnames_table);
           foreach (@Result) {
               $ids_by_groupname{$_->[1]}=$_->[0];
           }
           $have_read_groupnames_table = 1;
       }
       if (! exists($ids_by_groupname{$groupname})) {
           &populate_groupnames_table();
           undef(%ids_by_groupname);
           my @Result = &Apache::lonmysql::get_rows($groupnames_table);
           foreach (@Result) {
               $ids_by_groupname{$_->[1]}=$_->[0];
           }
       }
       if (exists($ids_by_groupname{$groupname})) {
           return $ids_by_groupname{$groupname};
     }      }
       return undef; # error
   }
   
     my %courseKeys;  sub populate_groupnames_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}++;      &setup_table_names($courseid);
         $cache->{$_}=$courseData->{$_};      &init_dbs($courseid,0);
       my $dbh = &Apache::lonmysql::get_dbh();
       my $cdom = $env{'course.'.$courseid.'.domain'};
       my $cnum = $env{'course.'.$courseid.'.num'};
       my %curr_groups = &Apache::longroup::coursegroups($cdom,$cnum);
       return if (!%curr_groups);
       my $request = 'INSERT IGNORE INTO '.$groupnames_table.
                     '(groupname) VALUES ';
       foreach my $groupname (sort(keys(%curr_groups)),'none') {
           $request .= "('".$groupname."'),";
       }
       chop($request);
       $dbh->do($request);
       if ($dbh->err()) {
           &Apache::lonnet::logthis("error ".$dbh->errstr().
                                    " occured executing \n".
                                    $request);
     }      }
       return;
   }
   
   my $have_read_studentsgroups_table = 0;
   my %groupids_by_studentid;
   
   sub get_students_groupids {
       my ($student_id) = @_;
       if (! $have_read_studentsgroups_table) {
           my @Result = &Apache::lonmysql::get_rows($students_groups_table);
           foreach (@Result) {
               push(@{$groupids_by_studentid{$_->[0]}},$_->[1]);
           }
           $have_read_studentsgroups_table = 1;
       }
       if (! exists($groupids_by_studentid{$student_id})) {
           &populate_students_groups_table();
           undef(%groupids_by_studentid);
           my @Result = &Apache::lonmysql::get_rows($students_groups_table);
           foreach (@Result) {
               push(@{$groupids_by_studentid{$_->[0]}},$_->[1]);
           }
       }
       if (exists($groupids_by_studentid{$student_id})) {
           if (ref($groupids_by_studentid{$student_id}) eq 'ARRAY') {
               return @{$groupids_by_studentid{$student_id}};
           }
       }
       return undef; # error
   }
   
     $cache->{$name.':keys'} = join(':::', keys(%courseKeys));  
   
   sub populate_students_groups_table {
       my ($courseid) = @_;
       if (! defined($courseid)) {
           $courseid = $env{'request.course.id'};
       }
       #
       &setup_table_names($courseid);
       &init_dbs($courseid,0);
       my $dbh = &Apache::lonmysql::get_dbh();
       my $request = 'INSERT IGNORE INTO '.$students_groups_table.
           "(student_id,group_id) VALUES ";
       my $cdom = $env{'course.'.$courseid.'.domain'};
       my $cnum = $env{'course.'.$courseid.'.num'};
       my ($classlist,$keylist) = &get_classlist($cdom,$cnum);
       my ($classgroups,$studentgroups) = &get_group_memberships($classlist,
                                                                 $keylist,
                                                                 $cdom,$cnum);
       my $record_count = 0;
       foreach my $student (sort(keys(%{$classgroups}))) {
           my $student_id = &get_student_id(split(':',$student));
           my @studentsgroups = &get_students_groups($student,'Active',$classgroups);
           if (@studentsgroups < 1) {
               @studentsgroups = ('none');
           }
           foreach my $groupname (@studentsgroups) {
               my $group_id = &get_group_id($groupname);
               $request .= "('".$student_id."','".$group_id."'),";
               $record_count++;
           }
       }
       return if ($record_count == 0);
       chop($request);
       $dbh->do($request);
       if ($dbh->err()) {
           &Apache::lonnet::logthis("error ".$dbh->errstr().
                                    " occured executing \n".
                                    $request);
       }
     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);
       $have_read_groupnames_table = 0;
       undef(%ids_by_groupname);
   }
   
 $output: A hash to contain the processed data  
   
 $data: A hash containing the information on what is to be  ################################################
 processed and how (basically).  ################################################
   
 $name:  username:domain  sub symb_is_for_task {
       my ($symb) = @_;
       return ($symb =~ /\.task$/);
   }
   
 The input is slightly different here, but is quite simple.  ################################################
 It is currently used where the $input, $output, and $data  ################################################
 can and are often the same hashes, but they do not need  
 to be.  
   
 Output: None  =pod
   
 *NOTE:  There is no output, but an error message is stored away in the cache   =item &update_full_student_data($sname,$sdom,$courseid)
 data.  This is checked in &FormatStudentData().  The key username:domain:error   
 will only exist if an error occured.  The error is an error from   
 &DownloadCourseInformation().  
   
 =back  Does a lonnet::dump on a student to populate the courses tables.
   
 =cut  Input: $sname, $sdom, $courseid
   
 sub ExtractStudentData {  Output: $returnstatus
     my ($input, $output, $data, $name)=@_;  
   
     if(!&CheckDateStampError($input, $data, $name)) {  $returnstatus is a string describing any errors that occured.  'okay' is the
         return;  default.
     }  
   This subroutine loads a students data using lonnet::dump and inserts
     # This little delete thing, should not be here.  Move some other  it into the MySQL database.  The inserts are done on three tables, 
     # time though.  $fulldump_response_table, $fulldump_part_table, and $fulldump_timestamp_table.
     my %allkeys;  The INSERT calls are made directly by this subroutine, not through lonmysql 
     if(defined($output->{$name.':keys'})) {  because we do a 'bulk'insert which takes advantage of MySQLs non-SQL 
  foreach (split(':::', $output->{$name.':keys'})) {  compliant INSERT command to insert multiple rows at a time.  
     delete $output->{$name.':'.$_};  If anything has gone wrong during this process, $returnstatus is updated with 
  }  a description of the error.
         delete $output->{$name.':keys'};  
     }  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.
   
     my ($username,$domain)=split(':',$name);  =cut
   
     my $Version;  ################################################
     my $problemsCorrect = 0;  ################################################
     my $totalProblems   = 0;  sub update_full_student_data {
     my $problemsSolved  = 0;      my ($sname,$sdom,$courseid) = @_;
     my $numberOfParts   = 0;      #
     my $totalAwarded    = 0;      # Set up database names
     foreach my $sequence (split(':', $data->{'orderedSequences'})) {      &setup_table_names($courseid);
         foreach my $problemID (split(':', $data->{$sequence.':problems'})) {      #
             my $problem = $data->{$problemID.':problem'};      my $student_id = &get_student_id($sname,$sdom);
             my $LatestVersion = $input->{$name.':version:'.$problem};      my $student = $sname.':'.$sdom;
       #
             # Output dashes for all the parts of this problem if there      my $returnstatus = 'okay';
             # is no version information about the current problem.      #
             $output->{$name.':'.$problemID.':NoVersion'} = 'false';      # Download students data
             $allkeys{$name.':'.$problemID.':NoVersion'}++;      my $time_of_retrieval = time;
             if(!$LatestVersion) {      my @tmp = &Apache::lonnet::dumpstore($courseid,$sdom,$sname);
                 foreach my $part (split(/\:/,$data->{$sequence.':'.      if (@tmp && $tmp[0] =~ /^error/) {
                                                       $problemID.          $returnstatus = 'error retrieving full student data';
                                                       ':parts'})) {          return $returnstatus;
                     $output->{$name.':'.$problemID.':'.$part.':tries'} = 0;      } elsif (! @tmp) {
                     $output->{$name.':'.$problemID.':'.$part.':awarded'} = 0;          $returnstatus = 'okay: no student data';
                     $output->{$name.':'.$problemID.':'.$part.':code'} = ' ';          return $returnstatus;
     $allkeys{$name.':'.$problemID.':'.$part.':tries'}++;      }
     $allkeys{$name.':'.$problemID.':'.$part.':awarded'}++;      my %studentdata = @tmp;
     $allkeys{$name.':'.$problemID.':'.$part.':code'}++;      #
                     $totalProblems++;      # Get database handle and clean out the tables 
       my $dbh = &Apache::lonmysql::get_dbh();
       $dbh->do('DELETE FROM '.$fulldump_response_table.' WHERE student_id='.
                $student_id);
       $dbh->do('DELETE FROM '.$fulldump_part_table.' WHERE student_id='.
                $student_id);
       $dbh->do('DELETE FROM '.$fulldump_timestamp_table.' WHERE student_id='.
                $student_id);
       #
       # Parse and store the data into a form we can handle
       my $partdata;
       my $respdata;
       while (my ($key,$value) = each(%studentdata)) {
           next if ($key =~ /^(\d+):(resource$|subnum$|keys:)/);
           my ($transaction,$symb,$parameter) = split(':',$key);
           my $symb_id = &get_symb_id($symb);
           if ($parameter eq 'timestamp') {
               # We can deal with 'timestamp' right away
               my @timestamp_storage = ($symb_id,$student_id,
                                        $transaction,$value);
               my $store_command = 'INSERT IGNORE INTO '.$fulldump_timestamp_table.
                   " VALUES ('".join("','",@timestamp_storage)."');";
               $dbh->do($store_command);
               if ($dbh->err()) {
                   &Apache::lonnet::logthis('unable to execute '.$store_command);
                   &Apache::lonnet::logthis($dbh->errstr());
               }
               next;
           } elsif ($parameter eq 'version') {
               next;
    } elsif (&symb_is_for_task($symb)) {
       next if ($parameter !~ /^resource\.(.*)\.(award|
         awarded|
         solved|
         submission|
         portfiles|
         status|
         version|
         regrader)\s*$/x);
       my ($version_and_part_id, $field) = ($1,$2);
   
       next if ($version_and_part_id !~ /\./ 
        && $field ne 'regrader' && $field ne 'version');
   
       my ($version, $part, $instance) = 
    split(/\./,$version_and_part_id);
   
       #skip and instance dimension or criteria specific data
       next if (defined($instance) 
        && $instance ne $field
        && $instance ne 'bridgetask');
       
       if (!defined($part)) {
    $part = $version;
       }
       my $resp_id = &get_part_id('0');
       my $part_id = &get_part_id($part);
       
       if ($field eq 'version') {
    # for tasks each version is an attempt at it thus
    #     version -> tries
    $partdata->{$symb_id}{$part_id}{$transaction}{'tries'}=
       $value;
    # at new version time the record gets reset thus adding a
    # virtual response awarddetail of 'new_version'
    $respdata->{$symb_id}{$part_id}{$resp_id}{$transaction}{'response_specific'}='status';
    $respdata->{$symb_id}{$part_id}{$resp_id}{$transaction}{'response_specific_value'}='new_version';
   
       } elsif ($field eq 'award' || $field eq 'awarded' 
        || $field eq 'solved') {
    $partdata->{$symb_id}{$part_id}{$transaction}{$field}=
       $value;
       } elsif ($field eq 'portfiles') {
    # tasks only accepts portfolio submissions
    $value = $dbh->quote($value);
    $respdata->{$symb_id}{$part_id}{$resp_id}{$transaction}{'submission'}=$value;
       } elsif ($field eq 'status') {
    $respdata->{$symb_id}{$part_id}{$resp_id}{$transaction}{'response_specific'}=$field;
    $respdata->{$symb_id}{$part_id}{$resp_id}{$transaction}{'response_specific_value'}=$value;
       } elsif ($field eq 'regrader') {
    $respdata->{$symb_id}{$part_id}{$resp_id}{$transaction}{'response_specific_2'}=$field;
    $respdata->{$symb_id}{$part_id}{$resp_id}{$transaction}{'response_specific_value_2'}=$value;
       }
    } elsif ($parameter =~ /^resource\.(.*)\.(tries|
                                                     award|
                                                     awarded|
                                                     previous|
                                                     solved|
                                                     awarddetail|
                                                     submission|
                                                     submissiongrading|
                                                     molecule)\s*$/x){
               # we do not have enough information to store an 
               # entire row, so we save it up until later.
               my ($part_and_resp_id,$field) = ($1,$2);
               my ($part,$part_id,$resp,$resp_id);
               if ($part_and_resp_id =~ /\./) {
                   ($part,$resp) = split(/\./,$part_and_resp_id);
                   $part_id = &get_part_id($part);
                   $resp_id = &get_part_id($resp);
               } else {
                   $part_id = &get_part_id($part_and_resp_id);
               }
               # Deal with part specific data
               if ($field =~ /^(tries|award|awarded|previous)$/) {
                   $partdata->{$symb_id}->{$part_id}->{$transaction}->{$field}=$value;
               }
               # deal with response specific data
               if (defined($resp_id) &&
                   $field =~ /^(awarddetail|
                                submission|
                                submissiongrading|
                                molecule)$/x) {
                   if ($field eq 'submission') {
                       # We have to be careful with user supplied input.
                       # most of the time we are okay because it is escaped.
                       # However, there is one wrinkle: submissions which end in
                       # and odd number of '\' cause insert errors to occur.  
                       # Best trap this somehow...
                       $value = $dbh->quote($value);
                   }
                   if ($field eq 'submissiongrading' || 
                       $field eq 'molecule') {
                       $respdata->{$symb_id}->{$part_id}->{$resp_id}->{$transaction}->{'response_specific'}=$field;
                       $respdata->{$symb_id}->{$part_id}->{$resp_id}->{$transaction}->{'response_specific_value'}=$value;
                   } else {
                       $respdata->{$symb_id}->{$part_id}->{$resp_id}->{$transaction}->{$field}=$value;
                 }                  }
                 $output->{$name.':'.$problemID.':NoVersion'} = 'true';  
                 next;  
             }              }
           }
             my %partData=undef;      }
             # Initialize part data, display skips correctly      ##
             # Skip refers to when a student made no submissions on that      ## Store the part data
             # part/problem.      my $store_command = 'INSERT IGNORE INTO '.$fulldump_part_table.
             foreach my $part (split(/\:/,$data->{$sequence.':'.          ' VALUES '."\n";
                                                  $problemID.      my $store_rows = 0;
                                                  ':parts'})) {      while (my ($symb_id,$hash1) = each (%$partdata)) {
                 $partData{$part.':tries'}=0;          while (my ($part_id,$hash2) = each (%$hash1)) {
                 $partData{$part.':code'}=' ';              while (my ($transaction,$data) = each (%$hash2)) {
                 $partData{$part.':awarded'}=0;                  $store_command .= "('".join("','",$symb_id,$part_id,
                 $partData{$part.':timestamp'}=0;                                              $student_id,
                 foreach my $response (split(':', $data->{$sequence.':'.                                              $transaction,
                                                          $problemID.':'.                                              $data->{'tries'},
                                                          $part.':responseIDs'})) {                                              $data->{'award'},
                     $partData{$part.':'.$response.':submission'}='';                                              $data->{'awarded'},
                                               $data->{'previous'})."'),";
                   $store_rows++;
               }
           }
       }
       if ($store_rows) {
           chop($store_command);
           $dbh->do($store_command);
           if ($dbh->err) {
               $returnstatus = 'error storing part data';
               &Apache::lonnet::logthis('insert error '.$dbh->errstr());
               &Apache::lonnet::logthis("While attempting\n".$store_command);
           }
       }
       ##
       ## Store the response data
       $store_command = 'INSERT IGNORE INTO '.$fulldump_response_table.
           ' VALUES '."\n";
       $store_rows = 0;
       while (my ($symb_id,$hash1) = each (%$respdata)) {
           while (my ($part_id,$hash2) = each (%$hash1)) {
               while (my ($resp_id,$hash3) = each (%$hash2)) {
                   while (my ($transaction,$data) = each (%$hash3)) {
                       my $submission = $data->{'submission'};
                       # We have to be careful with user supplied input.
                       # most of the time we are okay because it is escaped.
                       # However, there is one wrinkle: submissions which end in
                       # and odd number of '\' cause insert errors to occur.  
                       # Best trap this somehow...
                       $submission = $dbh->quote($submission);
                       $store_command .= "('".
                           join("','",$symb_id,$part_id,
                                $resp_id,$student_id,
                                $transaction,
                                $data->{'awarddetail'},
                                $data->{'response_specific'},
                                $data->{'response_specific_value'},
                                $data->{'response_specific_2'},
                                $data->{'response_specific_value_2'}).
                                "',".$submission."),";
                       $store_rows++;
                 }                  }
             }              }
           }
       }
       if ($store_rows) {
           chop($store_command);
           $dbh->do($store_command);
           if ($dbh->err) {
               $returnstatus = 'error storing response data';
               &Apache::lonnet::logthis('insert error '.$dbh->errstr());
               &Apache::lonnet::logthis("While attempting\n".$store_command);
           }
       }
       ##
       ## Update the students "current" data in the performance 
       ## and parameters tables.
       my ($status,undef) = &store_student_data
           ($sname,$sdom,$courseid,
            &Apache::lonnet::convert_dump_to_currentdump(\%studentdata));
       if ($returnstatus eq 'okay' && $status ne 'okay') {
           $returnstatus = 'error storing current data:'.$status;
       } elsif ($status ne 'okay') {
           $returnstatus .= ' error storing current data:'.$status;
       }        
       ##
       ## Update the students time......
       if ($returnstatus eq 'okay') {
           &store_updatetime($student_id,$time_of_retrieval,$time_of_retrieval);
           if ($dbh->err) {
               if ($returnstatus eq 'okay') {
                   $returnstatus = 'error updating student time';
               } else {
                   $returnstatus = 'error updating student time';
               }
           }
       }
       return $returnstatus;
   }
   
             # Looping through all the versions of each part, starting with the  ################################################
             # oldest version.  Basically, it gets the most recent   ################################################
             # set of grade data for each part.  
             my @submissions = ();  
     for(my $Version=1; $Version<=$LatestVersion; $Version++) {  
                 foreach my $part (split(/\:/,$data->{$sequence.':'.  
                                                      $problemID.  
                                                      ':parts'})) {  
   
                     if(!defined($input->{"$name:$Version:$problem".  
                                          ":resource.$part.solved"})) {  
                         # No grade for this submission, so skip  
                         next;  
                     }  
   
                     my $tries=0;  =pod
                     my $code=' ';  
                     my $awarded=0;  
   
                     $tries = $input->{$name.':'.$Version.':'.$problem.  
                                       ':resource.'.$part.'.tries'};  
                     $awarded = $input->{$name.':'.$Version.':'.$problem.  
                                         ':resource.'.$part.'.awarded'};  
   
                     $partData{$part.':awarded'}=($awarded) ? $awarded : 0;  
                     $partData{$part.':tries'}=($tries) ? $tries : 0;  
   
                     $partData{$part.':timestamp'}=$input->{$name.':'.$Version.':'.  
                                                            $problem.  
                                                            ':timestamp'};  
                     if(!$input->{$name.':'.$Version.':'.$problem.':resource.'.$part.  
                                  '.previous'}) {  
                         foreach my $response (split(':',  
                                                    $data->{$sequence.':'.  
                                                            $problemID.':'.  
                                                            $part.':responseIDs'})) {  
                             @submissions=($input->{$name.':'.$Version.':'.  
                                                    $problem.  
                                                    ':resource.'.$part.'.'.  
                                                    $response.'.submission'},  
                                           @submissions);  
                         }  
                     }  
   
                     my $val = $input->{$name.':'.$Version.':'.$problem.  =item &update_student_data()
                                        ':resource.'.$part.'.solved'};  
                     if    ($val eq 'correct_by_student')   {$code = '*';}   
                     elsif ($val eq 'correct_by_override')  {$code = '+';}  
                     elsif ($val eq 'incorrect_attempted')  {$code = '.';}   
                     elsif ($val eq 'incorrect_by_override'){$code = '-';}  
                     elsif ($val eq 'excused')              {$code = 'x';}  
                     elsif ($val eq 'ungraded_attempted')   {$code = '#';}  
                     else                                   {$code = ' ';}  
                     $partData{$part.':code'}=$code;  
                 }  
             }  
   
             foreach my $part (split(/\:/,$data->{$sequence.':'.$problemID.  Input: $sname, $sdom, $courseid
                                                  ':parts'})) {  
                 $output->{$name.':'.$problemID.':'.$part.':wrong'} =   
                     $partData{$part.':tries'};  
  $allkeys{$name.':'.$problemID.':'.$part.':wrong'}++;  
   
                 if($partData{$part.':code'} eq '*') {  
                     $output->{$name.':'.$problemID.':'.$part.':wrong'}--;  
                     $problemsCorrect++;  
                 } elsif($partData{$part.':code'} eq '+') {  
                     $output->{$name.':'.$problemID.':'.$part.':wrong'}--;  
                     $problemsCorrect++;  
                 }  
   
                 $output->{$name.':'.$problemID.':'.$part.':tries'} =   Output: $returnstatus, \%student_data
                     $partData{$part.':tries'};  
                 $output->{$name.':'.$problemID.':'.$part.':code'} =  $returnstatus is a string describing any errors that occured.  'okay' is the
                     $partData{$part.':code'};  default.
                 $output->{$name.':'.$problemID.':'.$part.':awarded'} =  \%student_data is the data returned by a call to lonnet::currentdump.
                     $partData{$part.':awarded'};  
  $allkeys{$name.':'.$problemID.':'.$part.':tries'}++;  This subroutine loads a students data using lonnet::currentdump and inserts
  $allkeys{$name.':'.$problemID.':'.$part.':code'}++;  it into the MySQL database.  The inserts are done on two tables, 
  $allkeys{$name.':'.$problemID.':'.$part.':awarded'}++;  $performance_table and $parameters_table.  $parameters_table holds the data 
   that is not included in $performance_table.  See the description of 
                 $totalAwarded += $partData{$part.':awarded'};  $performance_table elsewhere in this file.  The INSERT calls are made
                 $output->{$name.':'.$problemID.':'.$part.':timestamp'} =  directly by this subroutine, not through lonmysql because we do a 'bulk'
                     $partData{$part.':timestamp'};  insert which takes advantage of MySQLs non-SQL compliant INSERT command to 
  $allkeys{$name.':'.$problemID.':'.$part.':timestamp'}++;  insert multiple rows at a time.  If anything has gone wrong during this
   process, $returnstatus is updated with a description of the error and
                 foreach my $response (split(':', $data->{$sequence.':'.  \%student_data is returned.  
                                                          $problemID.':'.  
                                                          $part.':responseIDs'})) {  Notice we do not insert the data and immediately query it.  This means it
                     $output->{$name.':'.$problemID.':'.$part.':'.$response.  is possible for there to be data returned this first time that is not 
                               ':submission'}=join(':::',@submissions);  available the second time.  CYA.
     $allkeys{$name.':'.$problemID.':'.$part.':'.$response.  
      ':submission'}++;  =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 %student_data = &Apache::lonnet::currentdump($courseid,$sdom,$sname);
       if (&Apache::lonnet::error(%student_data)) {
           &Apache::lonnet::logthis('error getting data for '.
                                    $sname.':'.$sdom.' in course '.$courseid.
                                    ':'.(%student_data)[0]);
           $returnstatus =(%student_data)[0] ;
           return ($returnstatus,undef);
       }
       if (scalar(keys(%student_data)) < 1) {
           return ('no data',undef);
       }
       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;
   }
   
                 if($partData{$part.':code'} ne 'x') {  sub store_updatetime {
                     $totalProblems++;      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;
       my $which = $2;
       next if ($part =~ /\./);
               next if (exists($stored{$part}));
               $stored{$part}++;
               #
               my $part_id = &get_part_id($part);
               next if (!defined($part_id));
       
               my ($solved,$awarded);
       if ($which eq 'solved') {
    $solved  = $value;
    $awarded = $param_hash->{'resource.'.$part.'.awarded'};
       } else {
    $solved  = $param_hash->{'resource.'.$part.'.solved'};
    $awarded = $value;
       }
               my $award   = $param_hash->{'resource.'.$part.'.award'};
               my $awarddetail = $param_hash->{'resource.'.$part.'.awarddetail'};
               my $timestamp = $param_hash->{'timestamp'};
       my $tries   = $param_hash->{'resource.'.$part.'.tries'};
       if (&symb_is_for_task($current_symb)) {
    $tries   = $param_hash->{'resource.'.$part.'.version'};
       }
               #
               $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;  ######################################
     $output->{$name.':totalProblems'} = $totalProblems;  ######################################
     $output->{$name.':totalAwarded'} = $totalAwarded;  
     $allkeys{$name.':problemsSolved'}++;  
     $allkeys{$name.':totalProblems'}++;  
     $allkeys{$name.':totalAwarded'}++;  
   
     $output->{$name.':keys'} = join(':::', keys(%allkeys));  =pod
   
     return;  =item &ensure_tables_are_set_up($courseid)
 }  
   
 sub LoadDiscussion {  Checks to be sure the MySQL tables for the given class are set up.
     my ($courseID)=@_;  If $courseid is omitted it will be obtained from the environment.
     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;  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_groups,$found_groupnames,$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_groups      = 1 if ($_ eq $students_groups_table);
           $found_groupnames  = 1 if ($_ eq $groupnames_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';
           }
       }
 }  }
   
 # ----- END PROCESSING FUNCTIONS ---------------------------------------  ################################################
   ################################################
   
 =pod  =pod
   
 =head1 HELPER FUNCTIONS  =item &ensure_current_data()
   
 These are just a couple of functions do various odd and end   Input: $sname, $sdom, $courseid
 jobs.  There was also a couple of bulk functions added.  These are  
 &DownloadStudentCourseData(), &DownloadStudentCourseDataSeparate(), and  
 &CheckForResidualDownload().  These functions now act as the interface  
 for downloading student course data.  The statistical modules should  
 no longer make the calls to dump and download and process etc.  They  
 make calls to these bulk functions to get their data.  
   
 =cut  Output: $status, $data
   
 # ----- HELPER FUNCTIONS -----------------------------------------------  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.
   
 sub CheckDateStampError {  =cut
     my ($courseData, $cache, $name)=@_;  
     if($courseData->{$name.':UpToDate'} eq 'true') {  
         $cache->{$name.':lastDownloadTime'} =   
             $courseData->{$name.':lastDownloadTime'};  
         if($courseData->{$name.':lastDownloadTime'} eq 'Not downloaded') {  
             $cache->{$name.':updateTime'} = ' Not updated';  
         } else {  
             $cache->{$name.':updateTime'}=  
                 localtime($courseData->{$name.':lastDownloadTime'});  
         }  
         return 0;  
     }  
   
     $cache->{$name.':lastDownloadTime'}=$courseData->{$name.':lastDownloadTime'};  ################################################
     if($courseData->{$name.':lastDownloadTime'} eq 'Not downloaded') {  ################################################
         $cache->{$name.':updateTime'} = ' Not updated';  sub ensure_current_data {
     } else {      my ($sname,$sdom,$courseid) = @_;
         $cache->{$name.':updateTime'}=      my $status = 'okay';   # return value
             localtime($courseData->{$name.':lastDownloadTime'});      #
       $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'});
       #
       if ($modifiedtime == -1) {
    return ('no data',undef);
     }      }
   
     if(defined($courseData->{$name.':error'})) {      my $student_id = &get_student_id($sname,$sdom);
         $cache->{$name.':error'}=$courseData->{$name.':error'};      my @Result = &Apache::lonmysql::get_rows($student_table,
         return 0;                                               "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);
   }
   
   ################################################
   ################################################
   
   =pod
   
     return 1;  =item &ensure_current_full_data($sname,$sdom,$courseid)
   
   Input: $sname, $sdom, $courseid
   
   Output: $status
   
   This routine ensures the fulldata (the data from a lonnet::dump, not a
   lonnet::currentdump) for a given student is up to date.
   The $student_table is queried to determine the time of the last update.  
   If the students fulldata is out of date, &update_full_student_data() is
   called.  
   
   The return value from the call to &update_full_student_data() is returned.
   
   =cut
   
   ################################################
   ################################################
   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  =pod
   
 =item &ProcessFullName()  =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.
   
 Takes lastname, generation, firstname, and middlename (or some partial  This routine is the heart of the local caching system.  See the description
 set of this data) and returns the full name version as a string.  Format  of $performance_table, $symb_table, $student_table, and $part_table.  The
 is Lastname generation, firstname middlename or a subset of this.  main task is building the MySQL request.  The tables appear in the request
   in the order in which they should be parsed by MySQL.  When searching
   on a student the $student_table is used to locate the 'student_id'.  All
   rows in $performance_table which have a matching 'student_id' are returned,
   with data from $part_table and $symb_table which match the entries in
   $performance_table, 'part_id' and 'symb_id'.  When searching on a symb,
   the $symb_table is processed first, with matching rows grabbed from 
   $performance_table and filled in from $part_table and $student_table in
   that order.  
   
   Running 'EXPLAIN ' on the 'SELECT' statements generated can be quite 
   interesting, especially if you play with the order the tables are listed.  
   
 =cut  =cut
   
 sub ProcessFullName {  ################################################
     my ($lastname, $generation, $firstname, $middlename)=@_;  ################################################
     my $Str = '';  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 $studentdata;
       }
       #
       foreach my $row (@{$sth->fetchall_arrayref}) {
           $rows_retrieved++;
           my ($symb,$parameter,$value) = (@$row);
           $studentdata->{$symb}->{$parameter}  = $value;
       }
       #
       if (defined($symb) && $symb ne '') {
           $studentdata = $studentdata->{$symb};
       }
       return $studentdata;
   }
   
   ################################################
   ################################################
   
   =pod
   
   =item &get_current_state()
   
   Input: $sname,$sdom,$symb,$courseid
   
     # Strip whitespace preceeding & following name components.  Output: Described below
     $lastname   =~ s/(\s+$|^\s+)//g;  
     $generation =~ s/(\s+$|^\s+)//g;  
     $firstname  =~ s/(\s+$|^\s+)//g;  
     $middlename =~ s/(\s+$|^\s+)//g;  
   
     if($lastname ne '') {  Retrieve the current status of a students performance.  $sname and
  $Str .= $lastname;  $sdom are the only required parameters.  If $symb is undef the results
  $Str .= ' '.$generation if ($generation ne '');  of an &Apache::lonnet::currentdump() will be returned.  
  $Str .= ',';  If $courseid is undef it will be retrieved from the environment.
         $Str .= ' '.$firstname  if ($firstname ne '');  
         $Str .= ' '.$middlename if ($middlename ne '');  The return structure is based on &Apache::lonnet::currentdump.  If
   $symb is unspecified, all the students data is returned in a hash of
   the form:
   ( 
     symb1 => { param1 => value1, param2 => value2 ... },
     symb2 => { param1 => value1, param2 => value2 ... },
   )
   
   If $symb is specified, a hash of 
   (
     param1 => value1, 
     param2 => value2,
   )
   is returned.
   
   If no data is found for $symb, or if the student has no performance data,
   an empty list is returned.
   
   =cut
   
   ################################################
   ################################################
   sub get_current_state {
       my ($sname,$sdom,$symb,$courseid,$forcedownload)=@_;
       #
       $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 ('error: '.$status,undef);
           }
           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, Groups, $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 $Groups Array ref containing group 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,$Groups,$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 ';
       }
       my ($groups_join,$group_limits) = &limit_by_group($Groups,'b','c','d');
       if (defined($groups_join)) {
           $request .= $groups_join;
       }
       $request .= ' WHERE a.symb_id='.$symb_id.' AND a.part_id='.$part_id;
       #
       # Limit the students included to those specified
       my ($section_limits,$enrollment_limits)=
           &limit_by_section_and_status($Sections,$status,'b');
       #
       # 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;
       }
       if (defined($section_limits)) {
           $request .= ' AND '.$section_limits;
       }
       if (defined($enrollment_limits)) {
           $request .= ' AND '.$enrollment_limits;
       }
       # Limit by group, as required
       if (defined($group_limits)) {
           $request .= ' AND '.$group_limits;
       }
       #
       # 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
 }  
   
 sub DownloadStudentCourseData {  =item &limit_by_start_end_times
     my ($students,$checkDate,$cacheDB,$extract,$status,$courseID,$r,$c)=@_;  
   
     my $title = 'LON-CAPA Statistics';  Build SQL WHERE condition which limits the data collected by the start
     my $heading = 'Download and Process Course Data';  and end times provided
     my $studentCount = scalar(@$students);  
   
     my $WhatIWant;  Inputs: $starttime, $endtime, $table
     $WhatIWant = '(^version:|';  
     $WhatIWant .= '^\d+:.+?:(resource\.\d+\.';  
     $WhatIWant .= '(solved|tries|previous|awarded|(\d+\.submission))\s*$';  
     $WhatIWant .= '|timestamp)';  
     $WhatIWant .= ')';  
 #    $WhatIWant = '.';  
   
     if($status eq 'true') {  Returns: $time_limits
         &Apache::lonhtmlcommon::Create_PrgWin($r, $title, $heading);  
   =cut
   
   ##########################################################
   ##########################################################
   sub limit_by_start_end_time {
       my ($starttime,$endtime,$table) = @_;
       my $time_requirements = undef;
       if (defined($starttime)) {
           $time_requirements .= $table.".timestamp>='".$starttime."'";
           if (defined($endtime)) {
               $time_requirements .= " AND ".$table.".timestamp<='".$endtime."'";
           }
       } elsif (defined($endtime)) {
           $time_requirements .= $table.".timestamp<='".$endtime."'";
     }      }
       return $time_requirements;
   }
   
     my $displayString;  ##########################################################
     my $count=0;  ##########################################################
     foreach (@$students) {  
         my %cache;  
   
         if($c->aborted()) { return 'Aborted'; }  =pod
   
         if($status eq 'true') {  =item &limit_by_section_and_status
             $count++;  
             my $displayString = $count.'/'.$studentCount.': '.$_;  
             &Apache::lonhtmlcommon::Update_PrgWin($displayString, $r);  
         }  
   
         my $downloadTime='Not downloaded';  Build SQL WHERE condition which limits the data collected by section and
         my $needUpdate = 'false';  student status.
         if($checkDate eq 'true'  &&   
            tie(%cache,'GDBM_File',$cacheDB,&GDBM_READER(),0640)) {  
             $downloadTime = $cache{$_.':lastDownloadTime'};  
             $needUpdate = $cache{'ResourceUpdated'};  
             untie(%cache);  
         }  
   
         if($c->aborted()) { return 'Aborted'; }  Inputs: $Sections (array ref)
       $enrollment (string: 'any', 'expired', 'active')
       $tablename The name of the table that holds the student data
   
         if($needUpdate eq 'true') {  Returns: $student_requirements,$enrollment_requirements
             $downloadTime = 'Not downloaded';  
  }  =cut
  my $courseData =   
     &DownloadCourseInformation($_, $courseID, $downloadTime,   ##########################################################
        $WhatIWant);  ##########################################################
  if(tie(%cache,'GDBM_File',$cacheDB,&GDBM_WRCREAT(),0640)) {  sub limit_by_section_and_status {
     foreach my $key (keys(%$courseData)) {      my ($Sections,$enrollment,$tablename) = @_;
  if($key =~ /^(con_lost|error|no_such_host)/i) {      my $student_requirements = undef;
     $courseData->{$_.':error'} = 'No course data for '.$_;      if ( (defined($Sections) && $Sections->[0] ne 'all')) {
     last;          $student_requirements = '('.
  }              join(' OR ', map { $tablename.".section='".$_."'" } @$Sections
     }                   ).')';
     if($extract eq 'true') {      }
  &ExtractStudentData($courseData, \%cache, \%cache, $_);      my $enrollment_requirements=undef;
     } else {      if (defined($enrollment) && $enrollment ne 'Any') {
  &ProcessStudentData(\%cache, $courseData, $_);   my $now = time();
     }   if ( $enrollment eq 'Future' ) {
     untie(%cache);      $enrollment_requirements = 
  } else {   "( $tablename.start > $now AND ".
     next;   "( $tablename.end = 0 OR $tablename.end > $now))";
    } elsif ( $enrollment eq 'Active' ) {
       $enrollment_requirements = 
    "(( $tablename.start = 0 OR $tablename.start < $now )  AND ".
    " ( $tablename.end   = 0 OR $tablename.end   > $now ))";
    } elsif ( $enrollment eq 'Expired' ) {
       $enrollment_requirements = 
    "(( $tablename.start < $now )  AND ".
    " ( $tablename.end   < $now ))";
  }   }
     }      }
     if($status eq 'true') { &Apache::lonhtmlcommon::Close_PrgWin($r); }      return ($student_requirements,$enrollment_requirements);
   }
   
   ######################################################
   ######################################################
                                                                                  
   =pod
                                                                                  
   =item &limit_by_group
                                                                                  
   Build SQL LEFT JOIN statement to include students_groups and groupnames tables and SQL WHERE condition which limits the data collected by group.
                                                                                  
   Inputs: $Groups (array ref)
       $stutable   The name of the table which holds the student data.
       $grptable   The name of the table which maps group_id to groupname.
       $stugrptab  The name of the table which holds student group affiliations.   
   Returns: $groups_join,$group_limits
      $groups_join  JOIN part of SQL statement (to include group related tables) 
      $group_limits SQL WHERE condition limiting to requested groups
   =cut
   
     return 'OK';  sub limit_by_group {
       my ($Groups,$stutable,$grptable,$stugrptab) = @_;
       my $groups_join = undef;
       my $group_limits = undef;
       if ( (defined($Groups) && $Groups->[0] ne 'all')) {
           $groups_join =
             ' LEFT JOIN '.$students_groups_table.
                        ' AS '.$stugrptab.' ON '.
                        $stugrptab.'.student_id = '.$stutable.'.student_id'.
             ' LEFT JOIN '.$groupnames_table.
                        ' AS '.$grptable.' ON '.
                        $stugrptab.'.group_id = '.$grptable.'.group_id ';
           $group_limits =
             ' ('.
                join(' OR ', map {  "$grptable.groupname='".$_."'" } @$Groups
              ).')';
       }
       return ($groups_join,$group_limits);
 }  }
   
 sub DownloadStudentCourseDataSeparate {  =pod
     my ($students,$checkDate,$cacheDB,$extract,$status,$courseID,$r,$c)=@_;  
     my $residualFile = '/home/httpd/perl/tmp/'.$courseID.'DownloadFile.db';  
     my $title = 'LON-CAPA Statistics';  
     my $heading = 'Download Course Data';  
   
     my $WhatIWant;  =item rank_students_by_scores_on_resources
     $WhatIWant = '(^version:|';  
     $WhatIWant .= '^\d+:.+?:(resource\.\d+\.';  
     $WhatIWant .= '(solved|tries|previous|awarded|(\d+\.submission))\s*$';  
     $WhatIWant .= '|timestamp)';  
     $WhatIWant .= ')';  
   
     &CheckForResidualDownload($cacheDB, 'true', 'true', $courseID, $r, $c);  Inputs: 
       $resources: array ref of hash ref.  Each hash ref needs key 'symb'.
       $Sections: array ref of sections to include,
       $Groups: array ref of groups 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. 
   
     my $studentCount = scalar(@$students);  =cut
     if($status eq 'true') {  
         &Apache::lonhtmlcommon::Create_PrgWin($r, $title, $heading);  ######################################################
   ######################################################
   sub RNK_student { return 0; };
   sub RNK_score   { return 1; };
   
   sub rank_students_by_scores_on_resources {
       my ($resources,$Sections,$Groups,$enrollment,$courseid,$starttime,$endtime,
           $has_award_for) = @_;
       return if (! defined($resources) || ! ref($resources) eq 'ARRAY');
       if (! defined($courseid)) {
           $courseid = $env{'request.course.id'};
     }      }
     my $count=0;      #
     my $displayString='';      &setup_table_names($courseid);
     foreach (@$students) {      my $dbh = &Apache::lonmysql::get_dbh();
         if($c->aborted()) {      my ($section_limits,$enrollment_limits)=
             return 'Aborted';          &limit_by_section_and_status($Sections,$enrollment,'b');
         }      my ($groups_join,$group_limits) = &limit_by_group($Groups,'b','c','d');
       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 $groups_join "; 
       my $limits;
       if (defined($section_limits)) {
           $limits .= $section_limits.' AND ';
       }
       if (defined($enrollment_limits)) {
           $limits .= $enrollment_limits.' AND ';
       }
       if (defined($time_limits)) {
           $limits .= $time_limits.' AND ';
       }
       if ($symb_limits ne '()') {
           $limits .= $symb_limits.' AND ';
       }
       if (defined($group_limits)) {
           $limits .= $group_limits.' AND ';
       }
       if ($limits) {
           $limits =~ s/( AND )$//;   # Remove extra conjunction
           $request .= "WHERE $limits";
       } 
       $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);
   }
   
         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 &get_sum_of_scores
             return 'Aborted';  
         }  
   
         if($needUpdate eq 'true') {  Inputs: $resource (hash ref, needs {'symb'} key),
             $downloadTime = 'Not downloaded';  $part, (the part id),
  }  $students (array ref, contents of array are scalars holding 'sname:sdom'),
   $courseid
   
         my $error = 0;  Returns: the sum of the score on the problem part over the students and the
         my $courseData =      maximum possible value for the sum (taken from the weight table).
             &DownloadCourseInformation($_, $courseID, $downloadTime,  
                                        $WhatIWant);  =cut
         my %downloadData;  
         unless(tie(%downloadData,'GDBM_File',$residualFile,  ########################################################
                    &GDBM_WRCREAT(),0640)) {  ########################################################
             return 'Failed to tie temporary download hash.';  sub get_sum_of_scores {
         }      my ($symb,$part,$students,$courseid,$starttime,$endtime) = @_;
         foreach my $key (keys(%$courseData)) {      if (! defined($courseid)) {
             $downloadData{$key} = $courseData->{$key};          $courseid = $env{'request.course.id'};
             if($key =~ /^(con_lost|error|no_such_host)/i) {      }
                 $error = 1;      if (defined($students) && 
                 last;          ((@$students == 0) ||
             }           (@$students == 1 && (! defined($students->[0]) || 
         }                                $students->[0] eq ''))
         if($error) {           )
             foreach my $deleteKey (keys(%$courseData)) {          ){
                 delete $downloadData{$deleteKey};          undef($students);
             }      }
             $downloadData{$_.':error'} = 'No course data for '.$_;      #
         }      &setup_table_names($courseid);
         untie(%downloadData);      my $dbh = &Apache::lonmysql::get_dbh();
       my $time_limits = &limit_by_start_end_time($starttime,$endtime,'a');
       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]);
   }
   
   ########################################################
   ########################################################
   
   =pod
   
   =item &score_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., number of students, and maximum
     possible of student scores on the given resources
   
   =cut
   
   ########################################################
   ########################################################
   sub score_stats {
       my ($Sections,$Groups,$enrollment,$symbs,$starttime,$endtime,$courseid)=@_;
       if (! defined($courseid)) {
           $courseid = $env{'request.course.id'};
     }      }
     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 ($groups_join,$group_limits) = &limit_by_group($Groups,'b','c','d');
       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 '.
           $groups_join;
       my $limit = ' WHERE ('.$symb_restriction.')';
       if ($time_limits) {
           $limit .= ' AND '.$time_limits;
       }
       if ($section_limits) {
           $limit .= ' AND '.$section_limits;
       }
       if ($enrollment_limits) {
           $limit .= ' AND '.$enrollment_limits;
       }
       if ($group_limits) {
           $limit .= ' AND '.$group_limits;
       }
       $request .= $limit.' 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, $Groups, $enrollment, $symbs, $starttime,
           $endtime, $courseid
   
     return &CheckForResidualDownload($cacheDB, 'true', 'true',   $Sections, $Groups $enrollment, $starttime, $endtime, and $courseid are the 
                                      $courseID, $r, $c);  same as elsewhere in this module.  
   $symbs is an array ref of symbs
   
   Returns: minimum, maximum, mean, s.d., and number of students
     of the number of items correct on the given resources
   
   =cut
   
   ########################################################
   ########################################################
   sub count_stats {
       my ($Sections,$Groups,$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 ($groups_join,$group_limits) = &limit_by_group($Groups,'b','c','d');
       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 '.
           $groups_join;
       my $limit =  ' WHERE ('.$symb_restriction.')';
       if ($time_limits) {
           $limit .= ' AND '.$time_limits;
       }
       if ($section_limits) {
           $limit .= ' AND '.$section_limits;
       }
       if ($enrollment_limits) {
           $limit .= ' AND '.$enrollment_limits;
       }
       if ($group_limits) {
           $limit .= ' AND '.$group_limits;
       }
       $request .= $limit.' 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_response_eval_2 { return 3; }
   sub RD_submission      { return 4; }
   sub RD_timestamp       { return 5; }
   sub RD_tries           { return 6; }
   sub RD_sname           { return 7; }
   
   sub get_response_data {
       my ($Sections,$Groups,$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 ($groups_join,$group_limits) = &limit_by_group($Groups,'d','e','f');
       my $request = 'SELECT '.
           'a.student_id, a.awarddetail, a.response_specific_value, '.
           'a.response_specific_value_2, 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 '.
           $groups_join;
       my $limit = ' WHERE '.
           'a.symb_id='.$symb_id.' AND a.response_id='.$response_id;
       if (defined($student_requirements)) {
           $limit .= ' AND '.$student_requirements;
       }
       if (defined($enrollment_requirements)) {
           $limit .= ' AND '.$enrollment_requirements;
       }
       if (defined($group_limits)) {
           $limit .= ' AND '.$group_limits;
       }
       $request .= $limit.' 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]->[&RD_submission()] =~ s/(\'$|^\')//g;
           }
           return $dataset;
     }      }
   }
   
     my @students=();  
     my %checkStudent;  sub RDs_awarddetail     { return 3; }
     my $key;  sub RDs_submission      { return 2; }
     while(($key, undef) = each %downloadData) {  sub RDs_timestamp       { return 1; }
         my @temp = split(':', $key);  sub RDs_tries           { return 0; }
         my $student = $temp[0].':'.$temp[1];  sub RDs_awarded         { return 4; }
         if(!defined($checkStudent{$student})) {  sub RDs_response_eval   { return 5; }
             $checkStudent{$student}++;  sub RDs_response_eval_2 { return 6; }
             push(@students, $student);  sub RDs_part_award      { return 7; }
   
   sub get_response_data_by_student {
       my ($student,$symb,$response,$courseid) = @_;
       return undef if (! defined($symb) || 
                        ! defined($response));
       $courseid = $env{'request.course.id'} if (! defined($courseid));
       #
       &setup_table_names($courseid);
       my $symb_id = &get_symb_id($symb);
       my $response_id = &get_part_id($response);
       #
       my $student_id = &get_student_id($student->{'username'},
                                        $student->{'domain'});
       #
       my $dbh = &Apache::lonmysql::get_dbh();
       return undef if (! defined($dbh));
       my $request = 'SELECT '.
           'c.tries, b.timestamp, a.submission, a.awarddetail, c.awarded, '.
    'a.response_specific_value, a.response_specific_value_2, c.award '.
           '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]->[&RDs_submission] =~ 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,$groups,$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 ($groups_join,$group_limits) = &limit_by_group($groups,'d','e','f');
       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 '.
           $groups_join;
       my $limit = ' WHERE '.
           'a.symb_id='.$symb_id.' AND a.part_id='.$part_id;
       if (defined($student_requirements)) {
           $limit .= ' AND '.$student_requirements;
       }
       if (defined($enrollment_requirements)) {
           $limit .= ' AND '.$enrollment_requirements;
       }
       if (defined($group_limits)) {
           $limit .= ' AND '.$group_limits;  
       }
       $request .= $limit.' 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') {  =pod
             my $displayString = $count.'/'.$studentCount.': '.$name;  
             &Apache::lonhtmlcommon::Update_PrgWin($displayString, $r);  
         }  
   
         if($extract eq 'true') {  =item &get_student_scores($Sections,$Groups,$Symbs,$enrollment,$courseid)
             &ExtractStudentData(\%downloadData, \%cache, \%cache, $name);  
         } else {  =cut
             &ProcessStudentData(\%cache, \%downloadData, $name);  
         }  ################################################
         $count++;  ################################################
   sub get_student_scores {
       my ($sections,$groups,$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 ($groups_join,$group_limits) = &limit_by_group($groups,'b','d','e');
       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($groups_join)) {
           $request .= $groups_join;
       }
       if (defined($symb_requirements)       || 
           defined($student_requirements)    ||
           defined($enrollment_requirements) ||
           defined($group_limits) ) {
           $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;
   }
   
   ################################################
   ################################################
   
     if($status eq 'true') { &Apache::lonhtmlcommon::Close_PrgWin($r); }  =pod
   
     untie(%cache);  =item &setup_table_names()
     untie(%downloadData);  
   
     if(!$c->aborted()) {  input: course id
         my @files = ($residualFile);  
         unlink(@files);  output: none
     }  
   Cleans up the package variables for local caching.
   
   =cut
   
     return 'OK';  ################################################
   ################################################
   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);
           $have_read_groupnames_table = 0;
           undef(%ids_by_groupname);
           #
           $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';
       $groupnames_table         = $base_id.'_'.'groupnames';
       $students_groups_table    = $base_id.'_'.'studentgroups';
       $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,
                  $groupnames_table,
                  $students_groups_table,
                  $performance_table,
                  $parameters_table,
                  $fulldump_part_table,
                  $fulldump_response_table,
                  $fulldump_timestamp_table,
                  $weight_table,
                  );
       return;
 }  }
   
 ################################################  ################################################
Line 1393  sub CheckForResidualDownload { Line 3041  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::getsection($sdom,$sname,$cid);              $section = &Apache::lonnet::getsection($sdom,$sname,$cid);
Line 1442  sub get_classlist { Line 3129  sub get_classlist {
                 &Apache::lonnet::logthis('unable to retrieve environment '.                  &Apache::lonnet::logthis('unable to retrieve environment '.
                                          'for '.$sname.':'.$sdom);                                           'for '.$sname.':'.$sdom);
             } else {              } else {
                 $fullname = &ProcessFullName(@info{qw/lastname generation                   $fullname = &Apache::lonnet::format_name(@info{qw/firstname middlename lastname generation/},'lastname');
                                                        firstname middlename/});  
                 $id = $info{'id'};                  $id = $info{'id'};
             }              }
             # Update the classlist with this students information              # Update the classlist with this students information
             if ($fullname ne 'not available') {              if ($fullname ne 'not available') {
                 my $enrolldata = join(':',$end,$start,$id,$section,$fullname);   my $enrolldata = join(':',$end,$start,$id,$section,$fullname);
                 my $reply=&Apache::lonnet::cput('classlist',   my $reply=&Apache::lonnet::cput('classlist',
                                                 {$student => $enrolldata},                                                  {$student => $enrolldata},
                                                 $cdom,$cnum);                                                  $cdom,$cnum);
                 if ($reply !~ /^(ok|delayed)/) {                  if ($reply !~ /^(ok|delayed)/) {
Line 1463  sub get_classlist { Line 3149  sub get_classlist {
         if(((!$end) || $now < $end) && ((!$start) || ($now > $start))) {          if(((!$end) || $now < $end) && ((!$start) || ($now > $start))) {
             $status='Active';              $status='Active';
         }          }
           if(($now < $start) && ((!$end) || $now < $end )) {
               $status='Future';
           }
         $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;
     }      }
 }  }
   
   sub get_group_memberships {
       my ($classlist,$keylist,$cdom,$cnum) = @_;
   
       return ({},{}) if (!ref($classlist) || !ref($keylist));
   
       my $cid = $cdom.'_'.$cnum;
       if (!defined($cdom) || !defined($cnum)) {
           $cid =  $env{'request.course.id'};
           $cdom = $env{'course.'.$cid.'.domain'};
           $cnum = $env{'course.'.$cid.'.num'};
       }
       my (%classgroups,%studentgroups);
       my $now = time;
       my $access_end = $env{'course.'.$cid.'.default_enrollment_end_date'};
       my %curr_groups =&Apache::longroup::coursegroups($cdom,$cnum);
       if (%curr_groups) {
           my $grpindex = scalar(@{$keylist});
           my %groupmemberhash = 
       &Apache::lonnet::get_group_membership($cdom,$cnum);
           foreach my $student (keys(%{$classlist})) {
               %{$classgroups{$student}} = ();
               my $hasgroup = 0;
               foreach my $status ('previous','future','active','aftercourse') {
                   %{$classgroups{$student}{$status}} = ();
               }
               foreach my $group (keys(%curr_groups)) {
                   if (defined($groupmemberhash{$group.':'.$student})) {
                       my ($end,$start) = split(/:/,$groupmemberhash{$group.':'.
                                                                       $student});
                       if ($start == -1) {
                           next;
                       } else {
                           $studentgroups{$group} ++;
                           $hasgroup = 1;
                           if ($end && $end < $now) {
                               $classgroups{$student}{'previous'}{$group} =
                                            $groupmemberhash{$group.':'.$student};
                               if ($classlist->{$student}[&CL_STATUS()] eq 'Expired') {
                                   if ($access_end && $access_end < $now) {
                                       if ($access_end - $end < 86400) {
                                           $classgroups{$student}{'aftercourse'}{$group} = $groupmemberhash{$group.':'.$student};
                                       }
                                   }
                               }
                           } elsif ($now > $start) {
                               if (!$end || $end > $now) {
                                   $classgroups{$student}{'active'}{$group} =
                                            $groupmemberhash{$group.':'.$student};
                               }
                           } else {
                               $classgroups{$student}{'future'}{$group} =
                                            $groupmemberhash{$group.':'.$student};
                           }
                       }
                   }
               }
               if (!$hasgroup) {
                   $studentgroups{'none'} ++;
               } else {
                   $classlist->{$student}->[$grpindex] = join(',',
                                 sort(keys(%{$classgroups{$student}{'active'}})));
               }
           }
       }
       return (\%classgroups,\%studentgroups);
   }
                                                                                      
   sub get_students_groups {
       my ($student,$enrollment_status,$classgroups) = @_;
       my @studentsgroups = ();
       if (ref($$classgroups{$student}{'active'}) eq 'HASH') {
           push(@studentsgroups,keys(%{$$classgroups{$student}{'active'}}));
       }
       if ($enrollment_status eq 'Any') {
           foreach my $status ('previous','future') {
               if (ref($$classgroups{$student}{$status}) eq 'HASH') {
                   push(@studentsgroups,keys(%{$$classgroups{$student}{$status}}));
               }
           }
       } else {
           if (ref($$classgroups{$student}{'aftercourse'}) eq 'HASH') {
               push(@studentsgroups,keys(%{$$classgroups{$student}{'aftercourse'}}));
           }
       }
       return @studentsgroups;
   }
   
   
 # ----- END HELPER FUNCTIONS --------------------------------------------  # ----- END HELPER FUNCTIONS --------------------------------------------
   
 1;  1;
 __END__  __END__
   
   

Removed from v.1.40  
changed lines
  Added in v.1.178


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