|
version 1.11, 2001/11/22 17:05:07
|
version 1.58, 2002/07/08 16:50:03
|
|
Line 1
|
Line 1
|
| # The LearningOnline Network with CAPA |
# The LearningOnline Network with CAPA |
| |
# (Publication Handler |
| |
# |
| |
# $Id$ |
| |
# |
| |
# Copyright Michigan State University Board of Trustees |
| |
# |
| |
# This file is part of the LearningOnline Network with CAPA (LON-CAPA). |
| |
# |
| |
# LON-CAPA is free software; you can redistribute it and/or modify |
| |
# it under the terms of the GNU General Public License as published by |
| |
# the Free Software Foundation; either version 2 of the License, or |
| |
# (at your option) any later version. |
| |
# |
| |
# LON-CAPA is distributed in the hope that it will be useful, |
| |
# but WITHOUT ANY WARRANTY; without even the implied warranty of |
| |
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| |
# GNU General Public License for more details. |
| |
# |
| |
# You should have received a copy of the GNU General Public License |
| |
# along with LON-CAPA; if not, write to the Free Software |
| |
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| |
# |
| |
# /home/httpd/html/adm/gpl.txt |
| |
# |
| |
# http://www.lon-capa.org/ |
| |
# |
| # Homework Performance Chart |
# Homework Performance Chart |
| # |
# |
| # (Navigate Maps Handler |
# (Navigate Maps Handler |
|
Line 6
|
Line 32
|
| # (Page Handler |
# (Page Handler |
| # |
# |
| # (TeX Content Handler |
# (TeX Content Handler |
| # |
# YEAR=2000 |
| # 05/29/00,05/30 Gerd Kortemeyer) |
# 05/29/00,05/30 Gerd Kortemeyer) |
| # 08/30,08/31,09/06,09/14,09/15,09/16,09/19,09/20,09/21,09/23, |
# 08/30,08/31,09/06,09/14,09/15,09/16,09/19,09/20,09/21,09/23, |
| # 10/02,10/10,10/14,10/16,10/18,10/19,10/31,11/6,11/14,11/16 Gerd Kortemeyer) |
# 10/02,10/10,10/14,10/16,10/18,10/19,10/31,11/6,11/14,11/16 Gerd Kortemeyer) |
| # |
# YEAR=2001 |
| # 3/1/1,6/1,17/1,29/1,30/1 Gerd Kortemeyer) |
# 3/1/1,6/1,17/1,29/1,30/1,31/1 Gerd Kortemeyer) |
| # |
|
| # 1/31 Gerd Kortemeyer |
|
| # |
|
| # 7/10/01 Behrouz Minaei |
# 7/10/01 Behrouz Minaei |
| # 9/8 Gerd Kortemeyer |
# 9/8 Gerd Kortemeyer |
| # 10/18/01, 10/19/01 Behrouz Minaei |
# 10/1, 10/19, 11/17, 11/22, 11/24, 11/28 12/18 Behrouz Minaei |
| # 11/17/01, 11/22/01 Behrouz Minaei |
# YEAR=2002 |
| |
# 2/1, 2/6, 2/19, 2/28 Behrouz Minaei |
| |
# |
| |
### |
| |
|
| |
=pod |
| |
|
| |
=head1 NAME |
| |
|
| |
lonchart |
| |
|
| |
=head1 SYNOPSIS |
| |
|
| |
Quick display of students grades for a course in a compressed table format. |
| |
|
| |
=head1 DESCRIPTION |
| |
|
| |
This module process all student grades for a course and turns them into a |
| |
table like structure. |
| |
|
| |
This is part of the LearningOnline Network with CAPA project |
| |
described at http://www.lon-capa.org |
| |
|
| |
lonchart presents the user with a condensed view all a course's data. The |
| |
class title, the number of students, and the date for the last update of the |
| |
displayed data. There is also a legend that describes the chart values. |
| |
|
| |
For each valid grade for a student is linked with a submission record for that |
| |
problem. The ability to add and remove columns of data from the chart was |
| |
added for reducing the burden of having to scroll through large quantities |
| |
of data. The interface also allows for sorting of students by username, |
| |
last name, and section number of class. Active and expired students are |
| |
also available. |
| |
|
| |
The interface is controlled by three primary buttons: Recalculate Chart, |
| |
Refresh Chart, and Reset Selections. Recalculate Chart will update |
| |
the chart to the most recent data and keep the display settings for the chart |
| |
the same. Refresh Chart is used to redisplay the chart after selecting |
| |
different output formatting. Reset Selections is used to set the chart |
| |
display options back to default values. |
| |
|
| |
=head1 CODE LAYOUT DESCRIPTION |
| |
|
| |
The code is broken down into five components: formatting data for printing, |
| |
downloading data from servers, processing data, helper functions, |
| |
and the central processing functions. The module is broken into chunks |
| |
for each component. |
| |
|
| |
=head1 PACKAGES USED |
| |
|
| |
Apache::Constants qw(:common :http) |
| |
Apache::lonnet() |
| |
Apache::loncommon() |
| |
HTML::TokeParser |
| |
GDBM_File |
| |
|
| |
=cut |
| |
|
| package Apache::lonchart; |
package Apache::lonchart; |
| |
|
| use strict; |
use strict; |
| use Apache::Constants qw(:common :http); |
use Apache::Constants qw(:common :http); |
| use Apache::lonnet(); |
use Apache::lonnet(); |
| |
use Apache::loncommon(); |
| use HTML::TokeParser; |
use HTML::TokeParser; |
| use GDBM_File; |
use GDBM_File; |
| |
|
| # -------------------------------------------------------------- Module Globals |
#my $jr; |
| my %hash; |
|
| my @cols; |
=pod |
| my @rowlabels; |
|
| my @students; |
=head1 FORMAT DATA FOR PRINTING |
| my $r; |
|
| |
=cut |
| # ------------------------------------------------------------- Find out status |
|
| |
# ----- FORMAT PRINT DATA ---------------------------------------------- |
| sub ExtractStudentData { |
|
| my ($index,$coid)=@_; |
=pod |
| my ($sname,$sdom) = split( /\:/, $students[$index] ); |
|
| my $shome=&Apache::lonnet::homeserver( $sname,$sdom ); |
=item &FormatStudentInformation() |
| my $reply=&Apache::lonnet::reply('dump:'.$sdom.':'.$sname.':'.$coid,$shome ); |
|
| my %result=(); |
This function produces a formatted string of the student's information: |
| my $ResId; |
username, domain, section, full name, and PID. |
| my $Code; |
|
| my $Tries; |
=over 4 |
| my $Wrongs; |
|
| my %TempHash; |
Input: $cache, $name, $studentInformation, $spacePadding |
| |
|
| |
$cache: This is a pointer to a hash that is tied to the cached data |
| |
|
| |
$name: The name and domain of the current student in name:domain format |
| |
|
| |
$studentInformation: A pointer to an array holding the names used to |
| |
|
| |
remove data from the hash. They represent the name of the data to be removed. |
| |
|
| |
$spacePadding: Extra spaces that represent the space between columns |
| |
|
| |
Output: $Str |
| |
|
| |
$Str: Formatted string. |
| |
|
| |
=back |
| |
|
| |
=cut |
| |
|
| |
sub FormatStudentInformation { |
| |
my ($cache,$name,$studentInformation,$spacePadding)=@_; |
| |
my $Str=''; |
| |
|
| |
for(my $index=0; $index<(scalar @$studentInformation); $index++) { |
| |
if(!&ShouldShowColumn($cache, 'heading'.$index)) { |
| |
next; |
| |
} |
| |
my $data=$cache->{$name.':'.$studentInformation->[$index]}; |
| |
$Str .= $data; |
| |
|
| |
my @dataLength=split(//,$data); |
| |
my $length=scalar @dataLength; |
| |
$Str .= (' 'x($cache->{$studentInformation->[$index].'Length'}- |
| |
$length)); |
| |
$Str .= $spacePadding; |
| |
} |
| |
|
| |
return $Str; |
| |
} |
| |
|
| |
=pod |
| |
|
| |
=item &FormatStudentData() |
| |
|
| |
First, FormatStudentInformation is called and prefixes the course information. |
| |
This function produces a formatted string of the student's course information. |
| |
Each column of data represents all the problems for a given sequence. For |
| |
valid grade data, a link is created for that problem to a submission record |
| |
for that problem. |
| |
|
| |
=over 4 |
| |
|
| |
Input: $name, $studentInformation, $spacePadding, $ChartDB |
| |
|
| |
$name: The name and domain of the current student in name:domain format |
| |
|
| |
$studentInformation: A pointer to an array holding the names used to |
| |
remove data from the hash. They represent |
| |
the name of the data to be removed. |
| |
|
| |
$spacePadding: Extra spaces that represent the space between columns |
| |
|
| |
$ChartDB: The name of the cached data database which will be tied to that |
| |
database. |
| |
|
| |
Output: $Str |
| |
|
| |
$Str: Formatted string that is an entire row of the chart. It is a |
| |
concatenation of student information and student course information. |
| |
|
| |
=back |
| |
|
| |
=cut |
| |
|
| |
sub FormatStudentData { |
| |
my ($name,$studentInformation,$spacePadding,$ChartDB)=@_; |
| |
my ($sname,$sdom) = split(/\:/,$name); |
| |
my $Str; |
| |
my %CacheData; |
| |
|
| |
unless(tie(%CacheData,'GDBM_File',$ChartDB,&GDBM_READER,0640)) { |
| |
return ''; |
| |
} |
| |
# Handle Student information ------------------------------------------ |
| |
# Handle user data |
| |
$Str=&FormatStudentInformation(\%CacheData, $name, $studentInformation, |
| |
$spacePadding); |
| |
|
| |
# Handle errors |
| |
if($CacheData{$name.':error'} =~ /environment/) { |
| |
$Str .= '<br>'; |
| |
untie(%CacheData); |
| |
return $Str; |
| |
} |
| |
|
| |
if($CacheData{$name.':error'} =~ /course/) { |
| |
$Str .= '<br>'; |
| |
untie(%CacheData); |
| |
return $Str; |
| |
} |
| |
|
| |
# Handle problem data ------------------------------------------------ |
| my $Version; |
my $Version; |
| my $ProbNo; |
my $problemsCorrect = 0; |
| my $PrTotal; |
my $totalProblems = 0; |
| my $LatestVersion; |
my $problemsSolved = 0; |
| |
my $numberOfParts = 0; |
| my $Str=substr($students[$index]. |
foreach my $sequence (split(/\:/,$CacheData{'orderedSequences'})) { |
| ' ',0,14).' ! '. |
if(!&ShouldShowColumn(\%CacheData, 'sequence'.$sequence)) { |
| substr($rowlabels[$index]. |
next; |
| ' ',0,45).' ! '; |
} |
| unless ($reply=~/^error\:/) { |
|
| map { |
my $characterCount=0; |
| my ($name,$value)=split(/\=/,&Apache::lonnet::unescape($_)); |
foreach my $problemID (split(/\:/,$CacheData{$sequence.':problems'})) { |
| $result{$name}=$value; |
my $problem = $CacheData{$problemID.':problem'}; |
| } split(/\&/,$reply); |
my $LatestVersion = $CacheData{$name.":version:$problem"}; |
| $ProbNo = 0; |
|
| $PrTotal = 0; |
# Output blanks for all the parts of this problem if there |
| my $IterationNo = 0; |
# is no version information about the current problem. |
| foreach $ResId (@cols) { |
if(!$LatestVersion) { |
| if ($IterationNo == 0) {$IterationNo++; next;} |
foreach my $part (split(/\:/,$CacheData{$sequence.':'. |
| if (!$ResId) { |
$problemID. |
| my $PrNo = sprintf( "%3d", $ProbNo ); |
':parts'})) { |
| $Str .= ' '.'<font color="#007700">'.$PrNo.'</font> '; |
$Str .= ' '; |
| $PrTotal += $ProbNo; |
$totalProblems++; |
| $ProbNo=0; |
$characterCount++; |
| next; |
} |
| } |
next; |
| $ResId=~/(\d+)\.(\d+)/; |
} |
| my $meta=$hash{'src_'.$ResId}; |
|
| # $r->print($m.'<br>'); |
my %partData=undef; |
| # $r->rflush(); |
# Initialize part data, display skips correctly |
| my $PartNo = 0; |
# Skip refers to when a student made no submissions on that |
| undef %TempHash; |
# part/problem. |
| map { |
foreach my $part (split(/\:/,$CacheData{$sequence.':'. |
| if ($_=~/^stores\_(\d+)\_tries$/) { |
$problemID. |
| my $Part=&Apache::lonnet::metadata($meta,$_.'.part'); |
':parts'})) { |
| if ( $TempHash{"$Part"} eq '' ) { |
$partData{$part.':tries'}=0; |
| $TempHash{"$Part"} = $Part; |
$partData{$part.':code'}=' '; |
| $TempHash{$PartNo}=$Part; |
} |
| $TempHash{"$Part.Code"} = ' '; |
|
| $PartNo++; |
# 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. |
| |
for(my $Version=1; $Version<=$LatestVersion; $Version++) { |
| |
foreach my $part (split(/\:/,$CacheData{$sequence.':'. |
| |
$problemID. |
| |
':parts'})) { |
| |
|
| |
if(!defined($CacheData{$name.":$Version:$problem". |
| |
":resource.$part.solved"})) { |
| |
# No grade for this submission, so skip |
| |
next; |
| |
} |
| |
|
| |
my $tries=0; |
| |
my $code=' '; |
| |
|
| |
$tries = $CacheData{$name.":$Version:$problem". |
| |
":resource.$part.tries"}; |
| |
$partData{$part.':tries'}=($tries) ? $tries : 0; |
| |
|
| |
my $val = $CacheData{$name.":$Version:$problem". |
| |
":resource.$part.solved"}; |
| |
if ($val eq 'correct_by_student') {$code = '*';} |
| |
elsif ($val eq 'correct_by_override') {$code = '+';} |
| |
elsif ($val eq 'incorrect_attempted') {$code = '.';} |
| |
elsif ($val eq 'incorrect_by_override'){$code = '-';} |
| |
elsif ($val eq 'excused') {$code = 'x';} |
| |
elsif ($val eq 'ungraded_attempted') {$code = '#';} |
| |
else {$code = ' ';} |
| |
$partData{$part.':code'}=$code; |
| |
} |
| |
} |
| |
|
| |
# All grades (except for versionless parts) are displayed as links |
| |
# to their submission record. Loop through all the parts for the |
| |
# current problem in the correct order and prepare the output links |
| |
$Str.='<a href="/adm/grades?symb='. |
| |
&Apache::lonnet::escape($problem). |
| |
'&student='.$sname.'&domain='.$sdom.'&command=submission">'; |
| |
foreach(split(/\:/,$CacheData{$sequence.':'.$problemID. |
| |
':parts'})) { |
| |
if($partData{$_.':code'} eq '*') { |
| |
$problemsCorrect++; |
| |
if (($partData{$_.':tries'}<10) && |
| |
($partData{$_.':tries'} ne '')) { |
| |
$partData{$_.':code'}=$partData{$_.':tries'}; |
| |
} |
| |
} elsif($partData{$_.':code'} eq '+') { |
| |
$problemsCorrect++; |
| |
} |
| |
|
| |
$Str .= $partData{$_.':code'}; |
| |
$characterCount++; |
| |
|
| |
if($partData{$_.':code'} ne 'x') { |
| |
$totalProblems++; |
| |
} |
| |
} |
| |
$Str.='</a>'; |
| |
} |
| |
|
| |
# Output the number of correct answers for the current sequence. |
| |
# This part takes up 6 character slots, but is formated right |
| |
# justified. |
| |
my $spacesNeeded=$CacheData{$sequence.':columnWidth'}-$characterCount; |
| |
$spacesNeeded -= 3; |
| |
$Str .= (' 'x$spacesNeeded); |
| |
|
| |
my $outputProblemsCorrect = sprintf( "%3d", $problemsCorrect ); |
| |
$Str .= '<font color="#007700">'.$outputProblemsCorrect.'</font>'; |
| |
$problemsSolved += $problemsCorrect; |
| |
$problemsCorrect=0; |
| |
|
| |
$Str .= $spacePadding; |
| |
} |
| |
|
| |
# Output the total correct problems over the total number of problems. |
| |
# I don't like this type of formatting, but it is a solution. Need |
| |
# a way to dynamically determine the space requirements. |
| |
my $outputProblemsSolved = sprintf( "%4d", $problemsSolved ); |
| |
my $outputTotalProblems = sprintf( "%4d", $totalProblems ); |
| |
$Str .= '<font color="#000088">'.$outputProblemsSolved. |
| |
' / '.$outputTotalProblems.'</font><br>'; |
| |
|
| |
untie(%CacheData); |
| |
return $Str; |
| |
} |
| |
|
| |
=pod |
| |
|
| |
=item &CreateTableHeadings() |
| |
|
| |
This function generates the column headings for the chart. |
| |
|
| |
=over 4 |
| |
|
| |
Inputs: $CacheData, $studentInformation, $headings, $spacePadding |
| |
|
| |
$CacheData: pointer to a hash tied to the cached data database |
| |
|
| |
$studentInformation: a pointer to an array containing the names of the data |
| |
held in a column and is used as part of a key into $CacheData |
| |
|
| |
$headings: The names of the headings for the student information |
| |
|
| |
$spacePadding: The spaces to go between columns |
| |
|
| |
Output: $Str |
| |
|
| |
$Str: A formatted string of the table column headings. |
| |
|
| |
=back |
| |
|
| |
=cut |
| |
|
| |
sub CreateTableHeadings { |
| |
my ($CacheData,$studentInformation,$headings,$spacePadding)=@_; |
| |
my $Str='<tr>'; |
| |
|
| |
for(my $index=0; $index<(scalar @$headings); $index++) { |
| |
if(!&ShouldShowColumn($CacheData, 'heading'.$index)) { |
| |
next; |
| |
} |
| |
|
| |
$Str .= '<td align="left"><pre>'; |
| |
my $data=$$headings[$index]; |
| |
$Str .= $data; |
| |
|
| |
my @dataLength=split(//,$data); |
| |
my $length=scalar @dataLength; |
| |
$Str .= (' 'x($CacheData->{$$studentInformation[$index].'Length'}- |
| |
$length)); |
| |
$Str .= $spacePadding; |
| |
$Str .= '</pre></td>'; |
| |
} |
| |
|
| |
foreach my $sequence (split(/\:/,$CacheData->{'orderedSequences'})) { |
| |
if(!&ShouldShowColumn($CacheData, 'sequence'.$sequence)) { |
| |
next; |
| |
} |
| |
|
| |
$Str .= '<td align="left"><pre>'; |
| |
my $name = $CacheData->{$sequence.':title'}; |
| |
$Str .= $name; |
| |
my @titleLength=split(//,$CacheData->{$sequence.':title'}); |
| |
my $leftover=$CacheData->{$sequence.':columnWidth'}- |
| |
(scalar @titleLength); |
| |
$Str .= (' 'x$leftover); |
| |
$Str .= $spacePadding; |
| |
$Str .= '</pre></td>'; |
| |
} |
| |
|
| |
$Str .= '<td><pre>Total Solved/Total Problems</pre></td>'; |
| |
$Str .= '</tr>'; |
| |
|
| |
return $Str; |
| |
} |
| |
|
| |
=pod |
| |
|
| |
=item &CreateColumnSelectionBox() |
| |
|
| |
If there are columns not being displayed then this selection box is created |
| |
with a list of those columns. When selections are made and the page |
| |
refreshed, the columns will be removed from this box and the column is |
| |
put back in the chart. If there is no columns to select, no row is added |
| |
to the interface table. |
| |
|
| |
=over 4 |
| |
Input: $CacheData, $headings |
| |
|
| |
|
| |
$CacheData: A pointer to a hash tied to the cached data |
| |
|
| |
$headings: An array of the names of the columns for the student information. |
| |
They are used for displaying which columns are missing. |
| |
|
| |
Output: $notThere |
| |
|
| |
$notThere: The string contains one row of a table. The first column has the |
| |
name of the selection box. The second contains the selection box |
| |
which has a size of four. |
| |
|
| |
=back |
| |
|
| |
=cut |
| |
|
| |
sub CreateColumnSelectionBox { |
| |
my ($CacheData,$headings)=@_; |
| |
|
| |
my $missing=0; |
| |
my $notThere='<tr><td align="right"><b>Select column to view:</b>'; |
| |
my $name; |
| |
$notThere .= '<td align="left">'; |
| |
$notThere .= '<select name="reselect" size="4" multiple="true">'."\n"; |
| |
|
| |
for(my $index=0; $index<(scalar @$headings); $index++) { |
| |
if(&ShouldShowColumn($CacheData, 'heading'.$index)) { |
| |
next; |
| |
} |
| |
$name = $headings->[$index]; |
| |
$notThere .= '<option value="heading'.$index.'">'; |
| |
$notThere .= $name.'</option>'."\n"; |
| |
$missing++; |
| |
} |
| |
|
| |
foreach my $sequence (split(/\:/,$CacheData->{'orderedSequences'})) { |
| |
if(&ShouldShowColumn($CacheData, 'sequence'.$sequence)) { |
| |
next; |
| |
} |
| |
$name = $CacheData->{$sequence.':title'}; |
| |
$notThere .= '<option value="sequence'.$sequence.'">'; |
| |
$notThere .= $name.'</option>'."\n"; |
| |
$missing++; |
| |
} |
| |
|
| |
if($missing) { |
| |
$notThere .= '</select>'; |
| |
} else { |
| |
$notThere='<tr><td>'; |
| |
} |
| |
|
| |
return $notThere.'</td></tr>'; |
| |
} |
| |
|
| |
=pod |
| |
|
| |
=item &CreateColumnSelectors() |
| |
|
| |
This function generates the checkboxes above the column headings. The |
| |
column will be removed if the checkbox is unchecked. |
| |
|
| |
=over 4 |
| |
|
| |
Input: $CacheData, $headings |
| |
|
| |
$CacheData: A pointer to a hash tied to the cached data |
| |
|
| |
$headings: An array of the names of the columns for the student |
| |
information. They are used to know what are the student information columns |
| |
|
| |
Output: $present |
| |
|
| |
$present: The string contains the first row of a table. Each column contains |
| |
a checkbox which is left justified. Currently left justification is used |
| |
for consistency of location over the column in which it presides. |
| |
|
| |
=back |
| |
|
| |
=cut |
| |
|
| |
sub CreateColumnSelectors { |
| |
my ($CacheData,$headings)=@_; |
| |
|
| |
my $found=0; |
| |
my ($name, $length, $position); |
| |
|
| |
my $present = '<tr>'; |
| |
for(my $index=0; $index<(scalar @$headings); $index++) { |
| |
if(!&ShouldShowColumn($CacheData, 'heading'.$index)) { |
| |
next; |
| |
} |
| |
$present .= '<td align="left">'; |
| |
$present .= '<input type="checkbox" checked="on" '; |
| |
$present .= 'name="heading'.$index.'" />'; |
| |
$present .= '</td>'; |
| |
$found++; |
| |
} |
| |
|
| |
foreach my $sequence (split(/\:/,$CacheData->{'orderedSequences'})) { |
| |
if(!&ShouldShowColumn($CacheData, 'sequence'.$sequence)) { |
| |
next; |
| |
} |
| |
$present .= '<td align="left">'; |
| |
$present .= '<input type="checkbox" checked="on" '; |
| |
$present .= 'name="sequence'.$sequence.'" />'; |
| |
$present .= '</td>'; |
| |
$found++; |
| |
} |
| |
|
| |
if(!$found) { |
| |
$present = ''; |
| |
} |
| |
|
| |
return $present.'<td></td></tr></form>'."\n";; |
| |
} |
| |
|
| |
=pod |
| |
|
| |
=item &CreateForm() |
| |
|
| |
The interface for this module consists primarily of the controls in this |
| |
function. The student status selection (active, expired, any) is set here. |
| |
The sort buttons: username, last name, and section are set here. The |
| |
other buttons are Recalculate Chart, Refresh Chart, and Reset Selections. |
| |
These controls are in a table to clean up the interface. |
| |
|
| |
=over 4 |
| |
|
| |
Input: $CacheData |
| |
|
| |
$CacheData is a hash pointer to tied database for cached data. |
| |
|
| |
Output: $Ptr |
| |
|
| |
$Ptr is a string containing all the html for the above mentioned buttons. |
| |
|
| |
=back |
| |
|
| |
=cut |
| |
|
| |
sub CreateForm { |
| |
my ($CacheData)=@_; |
| |
my $OpSel1=''; |
| |
my $OpSel2=''; |
| |
my $OpSel3=''; |
| |
my $Status = $CacheData->{'form.status'}; |
| |
if ( $Status eq 'Any' ) { $OpSel3='selected'; } |
| |
elsif ($Status eq 'Expired' ) { $OpSel2 = 'selected'; } |
| |
else { $OpSel1 = 'selected'; } |
| |
|
| |
my $Ptr .= '<form name="stat" method="post" action="/adm/chart" >'."\n"; |
| |
$Ptr .= '<tr><td align="right">'; |
| |
$Ptr .= '</td><td align="left">'; |
| |
$Ptr .= '<input type="submit" name="recalculate" '; |
| |
$Ptr .= 'value="Recalculate Chart"/>'."\n"; |
| |
$Ptr .= ' '; |
| |
$Ptr .= '<input type="submit" name="refresh" '; |
| |
$Ptr .= 'value="Refresh Chart"/>'."\n"; |
| |
$Ptr .= ' '; |
| |
$Ptr .= '<input type="submit" name="reset" '; |
| |
$Ptr .= 'value="Reset Selections"/></td>'."\n"; |
| |
$Ptr .= '</tr><tr><td align="right">'; |
| |
$Ptr .= '<b> Sort by: </b>'."\n"; |
| |
$Ptr .= '</td><td align="left">'; |
| |
$Ptr .= '<input type="submit" name="sort" value="User Name" />'."\n"; |
| |
$Ptr .= ' '; |
| |
$Ptr .= '<input type="submit" name="sort" value="Last Name" />'."\n"; |
| |
$Ptr .= ' '; |
| |
$Ptr .= '<input type="submit" name="sort" value="Section"/>'."\n"; |
| |
$Ptr .= '</td></tr><tr><td align="right">'; |
| |
$Ptr .= '<b> Student Status: </b>'."\n". |
| |
'</td><td align="left">'. |
| |
'<select name="status">'. |
| |
'<option '.$OpSel1.' >Active</option>'."\n". |
| |
'<option '.$OpSel2.' >Expired</option>'."\n". |
| |
'<option '.$OpSel3.' >Any</option> </select> '."\n"; |
| |
$Ptr .= '</td></tr>'; |
| |
|
| |
return $Ptr; |
| |
} |
| |
|
| |
=pod |
| |
|
| |
=item &CreateLegend() |
| |
|
| |
This function returns a formatted string containing the legend for the |
| |
chart. The legend describes the symbols used to represent grades for |
| |
problems. |
| |
|
| |
=cut |
| |
|
| |
sub CreateLegend { |
| |
my $Str = "<p><pre>". |
| |
"1..9: correct by student in 1..9 tries\n". |
| |
" *: correct by student in more than 9 tries\n". |
| |
" +: correct by override\n". |
| |
" -: incorrect by override\n". |
| |
" .: incorrect attempted\n". |
| |
" #: ungraded attempted\n". |
| |
" : not attempted\n". |
| |
" x: excused". |
| |
"</pre><p>"; |
| |
return $Str; |
| |
} |
| |
|
| |
=pod |
| |
|
| |
=item &StartDocument() |
| |
|
| |
Returns a string containing the header information for the chart: title, |
| |
logo, and course title. |
| |
|
| |
=cut |
| |
|
| |
sub StartDocument { |
| |
my $Str = ''; |
| |
$Str .= '<html>'; |
| |
$Str .= '<head><title>'; |
| |
$Str .= 'LON-CAPA Assessment Chart</title></head>'; |
| |
$Str .= '<body bgcolor="#FFFFFF">'; |
| |
$Str .= '<script>window.focus();</script>'; |
| |
$Str .= '<img align=right src=/adm/lonIcons/lonlogos.gif>'; |
| |
$Str .= '<h1>Assessment Chart</h1>'; |
| |
$Str .= '<h1>'.$ENV{'course.'.$ENV{'request.course.id'}.'.description'}; |
| |
$Str .= '</h1>'; |
| |
|
| |
return $Str; |
| |
} |
| |
|
| |
# ----- END FORMAT PRINT DATA ------------------------------------------ |
| |
|
| |
=pod |
| |
|
| |
=head1 DOWNLOAD INFORMATION |
| |
|
| |
This section contains all the files that get data from other servers |
| |
and/or itself. There is one function that has a call to get remote |
| |
information but isn't included here which is ProcessTopLevelMap. The |
| |
usage was small enough to be ignored, but that portion may be moved |
| |
here in the future. |
| |
|
| |
=cut |
| |
|
| |
# ----- DOWNLOAD INFORMATION ------------------------------------------- |
| |
|
| |
=pod |
| |
|
| |
=item &DownloadPrerequisiteData() |
| |
|
| |
Collects lastname, generation, middlename, firstname, PID, and section for each |
| |
student from their environment database. The list of students is built from |
| |
collecting a classlist for the course that is to be displayed. |
| |
|
| |
=over 4 |
| |
|
| |
Input: $courseID, $c |
| |
|
| |
$courseID: The id of the course |
| |
|
| |
$c: The connection class that can determine if the browser has aborted. It |
| |
is used to short circuit this function so that it doesn't continue to |
| |
get information when there is no need. |
| |
|
| |
Output: \%classlist |
| |
|
| |
\%classlist: A pointer to a hash containing the following data: |
| |
|
| |
-A list of student name:domain (as keys) (known below as $name) |
| |
|
| |
-A hash pointer for each student containing lastname, generation, firstname, |
| |
middlename, and PID : Key is $name.'studentInformation' |
| |
|
| |
-A hash pointer to each students section data : Key is $name.section |
| |
|
| |
=back |
| |
|
| |
=cut |
| |
|
| |
sub DownloadPrerequisiteData { |
| |
my ($courseID, $c)=@_; |
| |
my ($courseDomain,$courseNumber)=split(/\_/,$courseID); |
| |
|
| |
my %classlist=&Apache::lonnet::dump('classlist',$courseDomain, |
| |
$courseNumber); |
| |
my ($checkForError)=keys (%classlist); |
| |
if($checkForError =~ /^(con_lost|error|no_such_host)/i) { |
| |
return \%classlist; |
| |
} |
| |
|
| |
foreach my $name (keys(%classlist)) { |
| |
if($c->aborted()) { |
| |
$classlist{'error'}='aborted'; |
| |
return \%classlist; |
| |
} |
| |
|
| |
my ($studentName,$studentDomain) = split(/\:/,$name); |
| |
# 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()) { |
| |
$classlist{'error'}='aborted'; |
| |
return \%classlist; |
| |
} |
| |
|
| |
#Section |
| |
my %section=&Apache::lonnet::dump('roles',$studentDomain,$studentName); |
| |
$classlist{$name.':section'}=\%section; |
| |
} |
| |
|
| |
return \%classlist; |
| |
} |
| |
|
| |
=pod |
| |
|
| |
=item &DownloadStudentCourseInformation() |
| |
|
| |
Dump of all the course information for a single student. There is no |
| |
pruning of data, it is all stored in a hash and returned. |
| |
|
| |
=over 4 |
| |
|
| |
Input: $name, $courseID |
| |
|
| |
$name: student name:domain |
| |
|
| |
$courseID: The id of the course |
| |
|
| |
Output: \%courseData |
| |
|
| |
\%courseData: A hash pointer to the raw data from the student's course |
| |
database. |
| |
|
| |
=back |
| |
|
| |
=cut |
| |
|
| |
sub DownloadStudentCourseInformation { |
| |
my ($name,$courseID)=@_; |
| |
my ($studentName,$studentDomain) = split(/\:/,$name); |
| |
|
| |
# Download student course data |
| |
my %courseData=&Apache::lonnet::dump($courseID,$studentDomain, |
| |
$studentName); |
| |
return \%courseData; |
| |
} |
| |
|
| |
# ----- END DOWNLOAD INFORMATION --------------------------------------- |
| |
|
| |
=pod |
| |
|
| |
=head1 PROCESSING FUNCTIONS |
| |
|
| |
These functions process all the data for all the students. Also, they |
| |
are the only functions that access the cache database for writing. Thus |
| |
they are the only functions that cache data. The downloading and caching |
| |
were separated to reduce problems with stopping downloading then can't |
| |
tie hash to database later. |
| |
|
| |
=cut |
| |
|
| |
# ----- PROCESSING FUNCTIONS --------------------------------------- |
| |
|
| |
=pod |
| |
|
| |
=item &ProcessTopResourceMap() |
| |
|
| |
Trace through the "big hash" created in rat/lonuserstate.pm::loadmap. |
| |
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 |
| |
|
| |
Input: $ChartDB, $c |
| |
|
| |
$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: A string that contains an error message or "OK" if everything went |
| |
smoothly. |
| |
|
| |
=back |
| |
|
| |
=cut |
| |
|
| |
sub ProcessTopResourceMap { |
| |
my ($ChartDB,$c)=@_; |
| |
my %hash; |
| |
my $fn=$ENV{'request.course.fn'}; |
| |
if(-e "$fn.db") { |
| |
my $tieTries=0; |
| |
while($tieTries < 3) { |
| |
if(tie(%hash,'GDBM_File',"$fn.db",&GDBM_READER,0640)) { |
| |
last; |
| |
} |
| |
$tieTries++; |
| |
sleep 1; |
| |
} |
| |
if($tieTries >= 3) { |
| |
return 'Coursemap undefined.'; |
| |
} |
| |
} else { |
| |
return 'Can not open Coursemap.'; |
| |
} |
| |
|
| |
my %CacheData; |
| |
unless(tie(%CacheData,'GDBM_File',$ChartDB,&GDBM_WRCREAT,0640)) { |
| |
untie(%hash); |
| |
return 'Could not tie cache hash.'; |
| |
} |
| |
|
| |
# Initialize state machine. Set information pointing to top level map. |
| |
my (@sequences, @currentResource, @finishResource); |
| |
my ($currentSequence, $currentResourceID, $lastResourceID); |
| |
|
| |
$currentResourceID=$hash{'ids_/res/'.$ENV{'request.course.uri'}}; |
| |
push(@currentResource, $currentResourceID); |
| |
$lastResourceID=-1; |
| |
$currentSequence=-1; |
| |
my $topLevelSequenceNumber = $currentSequence; |
| |
|
| |
while(1) { |
| |
if($c->aborted()) { |
| |
last; |
| |
} |
| |
# HANDLE NEW SEQUENCE! |
| |
#if page || sequence |
| |
if(defined($hash{'map_pc_'.$hash{'src_'.$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($CacheData{'orderedSequences'})) { |
| |
$CacheData{'orderedSequences'}=$currentSequence; |
| |
} else { |
| |
$CacheData{'orderedSequences'}.=':'.$currentSequence; |
| |
} |
| |
|
| |
$lastResourceID=$hash{'map_finish_'. |
| |
$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; |
| } |
} |
| } split(/\,/,&Apache::lonnet::metadata($meta,'keys')); |
} |
| |
} |
| |
|
| |
# Handle gradable resources: exams, problems, etc |
| |
$currentResourceID=~/(\d+)\.(\d+)/; |
| |
my $partA=$1; |
| |
my $partB=$2; |
| |
if($hash{'src_'.$currentResourceID}=~ |
| |
/\.(problem|exam|quiz|assess|survey|form)$/ && |
| |
$partA eq $currentSequence) { |
| |
my $Problem = &Apache::lonnet::symbclean( |
| |
&Apache::lonnet::declutter($hash{'map_id_'.$partA}). |
| |
'___'.$partB.'___'. |
| |
&Apache::lonnet::declutter($hash{'src_'. |
| |
$currentResourceID})); |
| |
|
| |
$CacheData{$currentResourceID.':problem'}=$Problem; |
| |
if(!defined($CacheData{$currentSequence.':problems'})) { |
| |
$CacheData{$currentSequence.':problems'}=$currentResourceID; |
| |
} else { |
| |
$CacheData{$currentSequence.':problems'}.= |
| |
':'.$currentResourceID; |
| |
} |
| |
|
| |
# Get Parts for problem |
| |
my $meta=$hash{'src_'.$currentResourceID}; |
| |
foreach (split(/\,/,&Apache::lonnet::metadata($meta,'keys'))) { |
| |
if($_=~/^stores\_(\d+)\_tries$/) { |
| |
my $Part=&Apache::lonnet::metadata($meta,$_.'.part'); |
| |
if(!defined($CacheData{$currentSequence.':'. |
| |
$currentResourceID.':parts'})) { |
| |
$CacheData{$currentSequence.':'.$currentResourceID. |
| |
':parts'}=$Part; |
| |
} else { |
| |
$CacheData{$currentSequence.':'.$currentResourceID. |
| |
':parts'}.=':'.$Part; |
| |
} |
| |
} |
| |
} |
| |
} |
| |
|
| # foreach my $Key (%TempHash) { |
# if resource == finish resource, then it is the end of a sequence/page |
| # $r->print($Key.' = '.$TempHash{$Key}.'<br>'); |
if($currentResourceID eq $lastResourceID) { |
| # $r->rflush(); |
# pop off last resource of sequence |
| # } |
$currentResourceID=pop(@currentResource); |
| |
$lastResourceID=pop(@finishResource); |
| $r->print($PartNo.'<br>');$r->rflush(); |
|
| |
if(defined($CacheData{$currentSequence.':problems'})) { |
| my $Prob = &Apache::lonnet::declutter( $hash{'map_id_'.$1} ). |
# Capture sequence information here |
| '___'.$2.'___'. |
$CacheData{$currentSequence.':title'}= |
| &Apache::lonnet::declutter( $hash{'src_'.$ResId} ); |
$hash{'title_'.$currentResourceID}; |
| $Code=' '; |
|
| $Tries = 0; |
my $totalProblems=0; |
| $LatestVersion = $result{"version:$Prob"}; |
foreach my $currentProblem (split(/\:/, |
| |
$CacheData{$currentSequence. |
| #undef %TempHash; |
':problems'})) { |
| #my $PartNo = 0; |
foreach (split(/\:/,$CacheData{$currentSequence.':'. |
| |
$currentProblem. |
| if ( $LatestVersion ) { |
':parts'})) { |
| for ( my $Version=1; $Version<=$LatestVersion; $Version++ ) { |
$totalProblems++; |
| my $vkeys = $result{"$Version:keys:$Prob"}; |
|
| my @keys = split(/\:/,$vkeys); |
|
| foreach my $Key (@keys) { |
|
| if (($Key=~/\.(\w+)\.solved$/) && ($Key!~/^\d+\:/)) { |
|
| my $Part = $1; |
|
| #if ( $TempHash{"$Part"} eq '' ) { |
|
| # $TempHash{"$Part"} = $Part; |
|
| #$TempHash{$PartNo}=$Part; |
|
| #$TempHash{"$Part.Code"} = ' '; |
|
| #$PartNo++; |
|
| #} |
|
| $TempHash{"$Part.Tries"} = $result{"$Version:$Prob:resource.$Part.tries"}; |
|
| $Tries = $result{"$Version:$Prob:resource.$Part.tries"}; |
|
| my $Val = $result{"$Version:$Prob:$Key"}; |
|
| 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';} |
|
| $TempHash{"$Part.Code"} = $Code; |
|
| } |
|
| } |
|
| } |
|
| |
|
| for ( my $n = 0; $n < $PartNo; $n++ ) { |
|
| my $part = $TempHash{$n}; |
|
| if ($TempHash{$part.'.Code'} eq '*') { |
|
| $ProbNo++; |
|
| if ($TempHash{$part.'.Tries'}<10) { |
|
| $TempHash{$part.'.Code'}=$Tries; |
|
| } |
|
| } |
} |
| $Str .= $TempHash{$part.'.Code'}; |
} |
| |
my @titleLength=split(//,$CacheData{$currentSequence. |
| |
':title'}); |
| |
# $extra is 3 for problems correct and 3 for space |
| |
# between problems correct and problem output |
| |
my $extra = 6; |
| |
if(($totalProblems + $extra) > (scalar @titleLength)) { |
| |
$CacheData{$currentSequence.':columnWidth'}= |
| |
$totalProblems + $extra; |
| |
} else { |
| |
$CacheData{$currentSequence.':columnWidth'}= |
| |
(scalar @titleLength); |
| } |
} |
| } |
} else { |
| else {for(my $n=0; $n<$PartNo; $n++) {$Str.=' ';}} |
# Remove sequence from list, if it contains no problems to |
| } |
# display. |
| } |
$CacheData{'orderedSequences'}=~s/$currentSequence//; |
| my $PrTot = sprintf( "%5d", $PrTotal ); |
$CacheData{'orderedSequences'}=~s/::/:/g; |
| $Str .= ' '.'<font color="#000088">'.$PrTot.'</font> '; |
$CacheData{'orderedSequences'}=~s/^:|:$//g; |
| |
} |
| return $Str ; |
|
| |
$currentSequence=pop(@sequences); |
| |
if($currentSequence eq $topLevelSequenceNumber) { |
| |
last; |
| |
} |
| |
} |
| |
|
| |
# MOVE!!! |
| |
# move to next resource |
| |
unless(defined($hash{'to_'.$currentResourceID})) { |
| |
# big problem, need to handle. Next is probably wrong |
| |
last; |
| |
} |
| |
my @nextResources=(); |
| |
foreach (split(/\,/,$hash{'to_'.$currentResourceID})) { |
| |
push(@nextResources, $hash{'goesto_'.$_}); |
| |
} |
| |
push(@currentResource, @nextResources); |
| |
# Set the next resource to be processed |
| |
$currentResourceID=pop(@currentResource); |
| |
} |
| |
|
| |
unless (untie(%hash)) { |
| |
&Apache::lonnet::logthis("<font color=blue>WARNING: ". |
| |
"Could not untie coursemap $fn (browse)". |
| |
".</font>"); |
| |
} |
| |
|
| |
unless (untie(%CacheData)) { |
| |
&Apache::lonnet::logthis("<font color=blue>WARNING: ". |
| |
"Could not untie Cache Hash (browse)". |
| |
".</font>"); |
| |
} |
| |
|
| |
return 'OK'; |
| } |
} |
| |
|
| |
=pod |
| |
|
| |
=item &ProcessSection() |
| |
|
| |
Determine the section number for a student for the class. A student can have |
| |
multiple sections for the same class. The correct one is chosen. |
| |
|
| |
=over 4 |
| |
|
| |
Input: $sectionData, $courseid, $ActiveFlag |
| |
|
| |
$sectionData: A pointer to a hash containing all section data for this |
| |
student for the class |
| |
|
| |
$courseid: The course ID. |
| |
|
| |
$ActiveFlag: The student's active status (Active/Expired) |
| |
|
| |
Output: $oldsection, $cursection, or -1 |
| |
|
| |
$oldsection and $cursection and sections number that will be displayed in the |
| |
chart. |
| |
|
| |
-1 is returned if an error occurs. |
| |
|
| |
=back |
| |
|
| |
=cut |
| |
|
| |
sub ProcessSection { |
| |
my ($sectionData, $courseid,$ActiveFlag)=@_; |
| |
$courseid=~s/\_/\//g; |
| |
$courseid=~s/^(\w)/\/$1/; |
| |
|
| # ------------------------------------------------------------ Build page table |
my $cursection='-1'; |
| |
my $oldsection='-1'; |
| sub tracetable { |
my $status='Expired'; |
| my ($rid,$beenhere)=@_; |
my $section=''; |
| unless ($beenhere=~/\&$rid\&/) { |
foreach my $key (keys (%$sectionData)) { |
| $beenhere.=$rid.'&'; |
my $value = $sectionData->{$key}; |
| # new ... updating the map according to sequence and page |
if ($key=~/^$courseid(?:\/)*(\w+)*\_st$/) { |
| if (defined($hash{'is_map_'.$rid})) { |
$section=$1; |
| my $cmap=$hash{'map_type_'.$hash{'map_pc_'.$hash{'src_'.$rid}}}; |
if($key eq $courseid.'_st') { |
| if ( $cmap eq 'sequence' || $cmap eq 'page' ) { |
$section=''; |
| $cols[$#cols+1]=0; |
} |
| } |
my ($dummy,$end,$start)=split(/\_/,$value); |
| if ((defined($hash{'map_start_'.$hash{'src_'.$rid}})) && |
my $now=time; |
| (defined($hash{'map_finish_'.$hash{'src_'.$rid}}))) { |
my $notactive=0; |
| my $frid=$hash{'map_finish_'.$hash{'src_'.$rid}}; |
if ($start) { |
| |
if($now<$start) { |
| &tracetable($hash{'map_start_'.$hash{'src_'.$rid}}, |
$notactive=1; |
| '&'.$frid.'&'); |
} |
| |
} |
| if ($hash{'src_'.$frid}) { |
if($end) { |
| if ($hash{'src_'.$frid}=~ |
if ($now>$end) { |
| /\.(problem|exam|quiz|assess|survey|form)$/) { |
$notactive=1; |
| $cols[$#cols+1]=$frid; |
} |
| } |
} |
| } |
if($notactive == 0) { |
| |
$status='Active'; |
| } |
$cursection=$section; |
| } else { |
last; |
| if ($hash{'src_'.$rid}) { |
} |
| if ($hash{'src_'.$rid}=~ |
if($notactive == 1) { |
| /\.(problem|exam|quiz|assess|survey|form)$/) { |
$oldsection=$section; |
| $cols[$#cols+1]=$rid; |
} |
| } |
} |
| } |
} |
| } |
if($status eq $ActiveFlag) { |
| if (defined($hash{'to_'.$rid})) { |
if($cursection eq '-1') { |
| map { |
return $oldsection; |
| &tracetable($hash{'goesto_'.$_},$beenhere); |
} |
| } split(/\,/,$hash{'to_'.$rid}); |
return $cursection; |
| } |
|
| } |
} |
| |
if($ActiveFlag eq 'Any') { |
| |
if($cursection eq '-1') { |
| |
return $oldsection; |
| |
} |
| |
return $cursection; |
| |
} |
| |
return '-1'; |
| } |
} |
| |
|
| # ================================================================ Main Handler |
=pod |
| |
|
| sub handler { |
=item &ProcessStudentInformation() |
| $r=shift; |
|
| |
Takes data downloaded for a student and breaks it up into managable pieces and |
| |
stored in cache data. The username, domain, class related date, PID, |
| |
full name, and section are all processed here. |
| |
|
| |
=over 4 |
| |
|
| |
Input: $CacheData, $studentInformation, $section, $date, $name, $courseID |
| |
|
| |
$CacheData: A hash pointer to the cached data |
| |
|
| |
$studentInformation: Student information is what was requested in |
| |
&DownloadPrerequistedData(). See that function for what data is requested. |
| |
|
| |
$section: A hash pointer to class section related information. |
| |
|
| |
$date: A composite of the start and end date for this class for this |
| |
student. Format: end:start |
| |
|
| |
$name: the username:domain information |
| |
|
| |
$courseID: The course ID |
| |
|
| |
Output: None |
| |
|
| |
*NOTE: There is no return value, but if an error occurs a key is added to |
| |
the cache data with the value being the error message. The key is |
| |
username:domain:error. It will only exist if an error occurs. |
| |
|
| |
=back |
| |
|
| |
=cut |
| |
|
| |
sub ProcessStudentInformation { |
| |
my ($CacheData,$studentInformation,$section,$date,$name,$courseID)=@_; |
| |
my ($studentName,$studentDomain) = split(/\:/,$name); |
| |
|
| |
$CacheData->{$name.':username'}=$studentName; |
| |
$CacheData->{$name.':domain'}=$studentDomain; |
| |
$CacheData->{$name.':date'}=$date; |
| |
|
| |
my ($checkForError)=keys(%$studentInformation); |
| |
if($checkForError =~ /^(con_lost|error|no_such_host)/i) { |
| |
$CacheData->{$name.':error'}= |
| |
'Could not download student environment data.'; |
| |
$CacheData->{$name.':fullname'}=''; |
| |
$CacheData->{$name.':id'}=''; |
| |
} else { |
| |
$CacheData->{$name.':fullname'}=&ProcessFullName( |
| |
$studentInformation->{'lastname'}, |
| |
$studentInformation->{'generation'}, |
| |
$studentInformation->{'firstname'}, |
| |
$studentInformation->{'middlename'}); |
| |
$CacheData->{$name.':id'}=$studentInformation->{'id'}; |
| |
} |
| |
|
| |
# Get student's section number |
| |
my $sec=&ProcessSection($section, $courseID, $CacheData->{'form.status'}); |
| |
if($sec != -1) { |
| |
$CacheData->{$name.':section'}=$sec; |
| |
} else { |
| |
$CacheData->{$name.':section'}=''; |
| |
} |
| |
|
| |
return; |
| |
} |
| |
|
| |
=pod |
| |
|
| |
=item &ProcessClassList() |
| |
|
| |
Taking the class list dumped from &DownloadPrerequisiteData(), all the |
| |
students and their non-class information is processed using the |
| |
&ProcessStudentInformation() function. A date stamp is also recorded for |
| |
when the data was processed. |
| |
|
| |
=over 4 |
| |
|
| |
Input: $classlist, $courseID, $ChartDB, $c |
| |
|
| |
$classlist: The hash of data collected about a student from |
| |
&DownloadPrerequisteData(). The hash contains a list of students, a pointer |
| |
to a hash of student information for each student, and each student's section |
| |
number. |
| |
|
| |
$courseID: The course ID |
| |
|
| |
$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. |
| |
|
| |
=back |
| |
|
| |
=cut |
| |
|
| |
sub ProcessClassList { |
| |
my ($classlist,$courseID,$ChartDB,$c)=@_; |
| |
my @names=(); |
| |
|
| |
my %CacheData; |
| |
if(tie(%CacheData,'GDBM_File',$ChartDB,&GDBM_WRCREAT,0640)) { |
| |
foreach my $name (keys(%$classlist)) { |
| |
if($name =~ /\:section/ || $name =~ /\:studentInformation/ || |
| |
$name eq '') { |
| |
next; |
| |
} |
| |
if($c->aborted()) { |
| |
last; |
| |
} |
| |
push(@names,$name); |
| |
&ProcessStudentInformation( |
| |
\%CacheData, |
| |
$classlist->{$name.':studentInformation'}, |
| |
$classlist->{$name.':section'}, |
| |
$classlist->{$name}, |
| |
$name,$courseID); |
| |
} |
| |
|
| |
# Time of download |
| |
$CacheData{'time'}=localtime(); |
| |
untie(%CacheData); |
| |
} |
| |
|
| |
return @names; |
| |
} |
| |
|
| |
=pod |
| |
|
| |
=item &ProcessStudentData() |
| |
|
| |
Takes the course data downloaded for a student in |
| |
&DownloadStudentCourseInformation() 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 student's information has been downloaded and |
| |
can be reused from cached data. |
| |
|
| |
=over 4 |
| |
|
| |
Input: $courseData, $name, $ChartDB |
| |
|
| |
$courseData: A hash pointer that points to the course data downloaded for a |
| |
student. |
| |
|
| |
$name: username:domain |
| |
|
| if (&Apache::lonnet::allowed('vgr',$ENV{'request.course.id'})) { |
$ChartDB: The name of the cache database file which will allow the data to |
| # ------------------------------------------- Set document type for header only |
be written to the cache. |
| |
|
| if ($r->header_only) { |
Output: None |
| if ($ENV{'browser.mathml'}) { |
|
| $r->content_type('text/xml'); |
|
| } else { |
|
| $r->content_type('text/html'); |
|
| } |
|
| $r->send_http_header; |
|
| return OK; |
|
| } |
|
| |
|
| my $requrl=$r->uri; |
|
| # ----------------------------------------------------------------- Tie db file |
|
| if ($ENV{'request.course.fn'}) { |
|
| my $fn=$ENV{'request.course.fn'}; |
|
| if (-e "$fn.db") { |
|
| if (tie(%hash,'GDBM_File',"$fn.db",&GDBM_READER,0640)) { |
|
| # ------------------------------------------------------------------- Hash tied |
|
| |
|
| |
|
| # ------------------------------------------------------------------ Build page |
|
| |
|
| # ---------------------------------------------------------------- Send headers |
|
| |
|
| $r->content_type('text/html'); |
|
| $r->send_http_header; |
|
| $r->print( |
|
| '<html><head><title>LON-CAPA Assessment Chart</title></head>'); |
|
| |
|
| $r->print('<body bgcolor="#FFFFFF">'. |
|
| '<script>window.focus();</script>'. |
|
| '<img align=right src=/adm/lonIcons/lonlogos.gif>'. |
|
| '<h1>Assessment Chart</h1>'); |
|
| |
|
| # ---------------------------------------------------------------- Course title |
|
| |
|
| $r->print('<h1>'. |
|
| $ENV{'course.'.$ENV{'request.course.id'}.'.description'}.'</h1><h3>'. |
|
| localtime()."</h3><p><pre>1..9: correct by student in 1..9 tries\n". |
|
| " *: correct by student in more than 9 tries\n". |
|
| " +: correct by override\n". |
|
| " -: incorrect by override\n". |
|
| " .: incorrect attempted\n". |
|
| " : not attempted\n". |
|
| " x: excused</pre><p>"); |
|
| |
|
| # ------------------------------- This is going to take a while, produce output |
|
| |
|
| $r->rflush(); |
|
| |
|
| # ----------------------- Get first and last resource, see if there is anything |
|
| |
|
| |
|
| my $firstres=$hash{'map_start_/res/'.$ENV{'request.course.uri'}}; |
|
| my $lastres=$hash{'map_finish_/res/'.$ENV{'request.course.uri'}}; |
|
| if (($firstres) && ($lastres)) { |
|
| # ----------------------------------------------------------------- Render page |
|
| |
|
| my $cid=$ENV{'request.course.id'}; |
|
| my $chome=$ENV{'course.'.$cid.'.home'}; |
|
| my ($cdom,$cnum)=split(/\_/,$cid); |
|
| |
|
| # ---------------------------------------------- Read class list and row labels |
|
| |
|
| undef @rowlabels; |
|
| undef @students; |
|
| |
|
| my $classlst=&Apache::lonnet::reply |
|
| ('dump:'.$cdom.':'.$cnum.':classlist',$chome); |
|
| my $now=time; |
|
| unless ($classlst=~/^error\:/) { |
|
| map { |
|
| my ($name,$value)=split(/\=/,$_); |
|
| my ($end,$start)=split(/\:/,&Apache::lonnet::unescape($value)); |
|
| my $active=1; |
|
| if (($end) && ($now>$end)) { $active=0; } |
|
| if ($active) { |
|
| my $thisindex=$#students+1; |
|
| $name=&Apache::lonnet::unescape($name); |
|
| $students[$thisindex]=$name; |
|
| my ($sname,$sdom)=split(/\:/,$name); |
|
| my $ssec=&Apache::lonnet::usection($sdom,$sname,$cid); |
|
| if ($ssec==-1) { |
|
| $rowlabels[$thisindex]= |
|
| 'Data not available: '.$name; |
|
| } else { |
|
| my %reply=&Apache::lonnet::idrget($sdom,$sname); |
|
| my $reply=&Apache::lonnet::reply('get:'.$sdom.':'.$sname. |
|
| ':environment:lastname&generation&firstname&middlename', |
|
| &Apache::lonnet::homeserver($sname,$sdom)); |
|
| $rowlabels[$thisindex]= |
|
| sprintf('%3s',$ssec).' '.$reply{$sname}.' '; |
|
| my $i=0; |
|
| map { |
|
| $i++; |
|
| if ( $_ ne '') { |
|
| $rowlabels[$thisindex].=&Apache::lonnet::unescape($_).' '; |
|
| } |
|
| if ($i == 2) { |
|
| chop($rowlabels[$thisindex]); |
|
| $rowlabels[$thisindex].=', '; |
|
| } |
|
| } split(/\&/,$reply); |
|
| |
|
| |
*NOTE: There is no output, but an error message is stored away in the cache |
| |
data. This is checked in &FormatStudentData(). The key username:domain:error |
| |
will only exist if an error occured. The error is an error from |
| |
&DownloadStudentCourseInformation(). |
| |
|
| |
=back |
| |
|
| |
=cut |
| |
|
| |
sub ProcessStudentData { |
| |
my ($courseData, $name, $ChartDB)=@_; |
| |
|
| |
my %CacheData; |
| |
if(tie(%CacheData,'GDBM_File',$ChartDB,&GDBM_WRCREAT,0640)) { |
| |
my ($checkForError) = keys(%$courseData); |
| |
if($checkForError =~ /^(con_lost|error|no_such_host)/i) { |
| |
$CacheData{$name.':error'}='Could not download course data.'; |
| |
} else { |
| |
foreach my $key (keys (%$courseData)) { |
| |
$CacheData{$name.':'.$key}=$courseData->{$key}; |
| |
} |
| |
if(defined($CacheData{'NamesOfStudents'})) { |
| |
$CacheData{'NamesOfStudents'}.=':::'.$name; |
| |
} else { |
| |
$CacheData{'NamesOfStudents'}=$name; |
| |
} |
| |
} |
| |
untie(%CacheData); |
| |
} |
| |
|
| |
return; |
| |
} |
| |
|
| |
=pod |
| |
|
| |
=item &ProcessFormData() |
| |
|
| |
Cache form data and set default form data (sort, status, heading.$number, |
| |
sequence.$number, reselect, reset, recalculate, and refresh) |
| |
|
| |
=over 4 |
| |
|
| |
Input: $ChartDB, $isCached |
| |
|
| |
$ChartDB: The name of the database for cached data |
| |
|
| |
$isCached: Is there already data for this course cached. This is used in |
| |
conjunction with the absence of all form data to know to display all selection |
| |
types. |
| |
|
| |
Output: None |
| |
|
| |
=back |
| |
|
| |
=cut |
| |
|
| |
# For all data, if ENV data doesn't exist for it, default values is used. |
| |
sub ProcessFormData { |
| |
my ($ChartDB, $isCached)=@_; |
| |
my %CacheData; |
| |
|
| |
if(tie(%CacheData,'GDBM_File',$ChartDB,&GDBM_WRCREAT,0640)) { |
| |
# Ignore $ENV{'form.refresh'} |
| |
# Ignore $ENV{'form.recalculate'} |
| |
|
| |
if(defined($ENV{'form.sort'})) { |
| |
$CacheData{'form.sort'}=$ENV{'form.sort'}; |
| |
} elsif(!defined($CacheData{'form.sort'})) { |
| |
$CacheData{'form.sort'}='username'; |
| |
} |
| |
|
| |
if(defined($ENV{'form.status'})) { |
| |
$CacheData{'form.status'}=$ENV{'form.status'}; |
| |
} elsif(!defined($CacheData{'form.status'})) { |
| |
$CacheData{'form.status'}='Active'; |
| |
} |
| |
|
| |
# $found checks for any instances of form data in the ENV. If it is |
| |
# missing I assume the chrt button on the remote has been pressed. |
| |
my @headings=(); |
| |
my @sequences=(); |
| |
my $found=0; |
| |
foreach (keys(%ENV)) { |
| |
if(/form\.heading/) { |
| |
$found++; |
| |
push(@headings, $_); |
| |
} elsif(/form\.sequence/) { |
| |
$found++; |
| |
push(@sequences, $_); |
| |
} elsif(/form\./) { |
| |
$found++; |
| |
} |
| |
} |
| |
|
| |
if($found) { |
| |
$CacheData{'form.headings'}=join(":::",@headings); |
| |
$CacheData{'form.sequences'}=join(":::",@sequences); |
| |
} |
| |
|
| |
if(defined($ENV{'form.reselect'})) { |
| |
my @reselected = (ref($ENV{'form.reselect'}) ? |
| |
@{$ENV{'form.reselect'}} |
| |
: ($ENV{'form.reselect'})); |
| |
foreach (@reselected) { |
| |
if(/heading/) { |
| |
$CacheData{'form.headings'}.=":::".$_; |
| |
} elsif(/sequence/) { |
| |
$CacheData{'form.sequences'}.=":::".$_; |
| } |
} |
| } |
} |
| } sort split(/\&/,$classlst); |
} |
| |
|
| |
# !$found and !$isCached are how I determine if the chrt button |
| |
# on the remote was pressed and needs to reset all the selections |
| |
if(defined($ENV{'form.reset'}) || (!$found && !$isCached)) { |
| |
$CacheData{'form.reset'}='true'; |
| |
$CacheData{'form.status'}='Active'; |
| |
$CacheData{'form.sort'}='username'; |
| |
$CacheData{'form.headings'}='ALLHEADINGS'; |
| |
$CacheData{'form.sequences'}='ALLSEQUENCES'; |
| |
} else { |
| |
$CacheData{'form.reset'}='false'; |
| |
} |
| |
|
| |
untie(%CacheData); |
| |
} |
| |
|
| |
return; |
| |
} |
| |
|
| |
=pod |
| |
|
| |
=item &SpaceColumns() |
| |
|
| |
Determines the width of all the columns in the chart. It is based on |
| |
the max of the data for that column and its header. |
| |
|
| |
=over 4 |
| |
|
| |
Input: $students, $studentInformation, $headings, $ChartDB |
| |
|
| |
$students: An array pointer to a list of students (username:domain) |
| |
|
| |
$studentInformatin: The type of data for the student information. It is |
| |
used as part of the key in $CacheData. |
| |
|
| |
$headings: The name of the student information columns. |
| |
|
| |
$ChartDB: The name of the cache database which is opened for read/write. |
| |
|
| |
Output: None - All data stored in cache. |
| |
|
| |
=back |
| |
|
| |
=cut |
| |
|
| |
sub SpaceColumns { |
| |
my ($students,$studentInformation,$headings,$ChartDB)=@_; |
| |
|
| |
my %CacheData; |
| |
if(tie(%CacheData,'GDBM_File',$ChartDB,&GDBM_WRCREAT,0640)) { |
| |
# Initialize Lengths |
| |
for(my $index=0; $index<(scalar @$headings); $index++) { |
| |
my @titleLength=split(//,$$headings[$index]); |
| |
$CacheData{$$studentInformation[$index].'Length'}= |
| |
scalar @titleLength; |
| |
} |
| |
|
| |
foreach my $name (@$students) { |
| |
foreach (@$studentInformation) { |
| |
my @dataLength=split(//,$CacheData{$name.':'.$_}); |
| |
my $length=scalar @dataLength; |
| |
if($length > $CacheData{$_.'Length'}) { |
| |
$CacheData{$_.'Length'}=$length; |
| |
} |
| |
} |
| |
} |
| |
untie(%CacheData); |
| |
} |
| |
|
| |
return; |
| |
} |
| |
|
| |
# ----- END PROCESSING FUNCTIONS --------------------------------------- |
| |
|
| |
=pod |
| |
|
| |
=head1 HELPER FUNCTIONS |
| |
|
| |
These are just a couple of functions do various odd and end |
| |
jobs. |
| |
|
| |
=cut |
| |
|
| |
# ----- HELPER FUNCTIONS ----------------------------------------------- |
| |
|
| |
=pod |
| |
|
| |
=item &ProcessFullName() |
| |
|
| |
Takes lastname, generation, firstname, and middlename (or some partial |
| |
set of this data) and returns the full name version as a string. Format |
| |
is Lastname generation, firstname middlename or a subset of this. |
| |
|
| |
=cut |
| |
|
| |
sub ProcessFullName { |
| |
my ($lastname, $generation, $firstname, $middlename)=@_; |
| |
my $Str = ''; |
| |
|
| |
if($lastname ne '') { |
| |
$Str .= $lastname.' '; |
| |
if($generation ne '') { |
| |
$Str .= $generation; |
| |
} else { |
| |
chop($Str); |
| |
} |
| |
$Str .= ', '; |
| |
if($firstname ne '') { |
| |
$Str .= $firstname.' '; |
| |
} |
| |
if($middlename ne '') { |
| |
$Str .= $middlename; |
| |
} else { |
| |
chop($Str); |
| |
if($firstname eq '') { |
| |
chop($Str); |
| |
} |
| |
} |
| } else { |
} else { |
| $r->print('<h1>Could not access course data</h1>'); |
if($firstname ne '') { |
| |
$Str .= $firstname.' '; |
| |
} |
| |
if($middlename ne '') { |
| |
$Str .= $middlename.' '; |
| |
} |
| |
if($generation ne '') { |
| |
$Str .= $generation; |
| |
} else { |
| |
chop($Str); |
| |
} |
| } |
} |
| |
|
| my $allstudents=$#students+1; |
return $Str; |
| $r->print('<h3>'.$allstudents.' students</h3>'); |
} |
| $r->rflush(); |
|
| |
=pod |
| |
|
| |
=item &SortStudents() |
| |
|
| |
Determines which students to display and in which order. Which are |
| |
displayed are determined by their status(active/expired). The order |
| |
is determined by the sort button pressed (default to username). The |
| |
type of sorting is username, lastname, or section. |
| |
|
| |
=over 4 |
| |
|
| |
Input: $students, $CacheData |
| |
|
| |
$students: A array pointer to a list of students (username:domain) |
| |
|
| # --------------- Find all assessments and put them into some linear-like order |
$CacheData: A pointer to the hash tied to the cached data |
| |
|
| &tracetable($firstres,'&'.$lastres.'&'); |
Output: @order |
| |
|
| # ----------------------------------------------------------------- Start table |
@order: An ordered list of students (username:domain) |
| |
|
| $r->print('<p><pre>'); |
=back |
| my $index; |
|
| for ($index=0;$index<=$#students;$index++) { |
=cut |
| $r->print(&ExtractStudentData($index,$cid).'<br>'); |
|
| $r->rflush(); |
sub SortStudents { |
| } |
my ($students,$CacheData)=@_; |
| $r->print('</pre>'); |
|
| |
my @sorted1Students=(); |
| } else { |
foreach (@$students) { |
| $r->print('<h3>Undefined course sequence</h3>'); |
my ($end,$start)=split(/\:/,$CacheData->{$_.':date'}); |
| } |
my $active=1; |
| |
my $now=time; |
| $r->print('</body></html>'); |
my $Status=$CacheData->{'form.status'}; |
| |
$Status = ($Status) ? $Status : 'Active'; |
| # ------------------------------------------------------------- End render page |
if((($end) && $now > $end) && (($Status eq 'Active'))) { |
| } else { |
$active=0; |
| $r->content_type('text/html'); |
} |
| $r->send_http_header; |
if(($Status eq 'Expired') && ($end == 0 || $now < $end)) { |
| $r->print('<html><body>Coursemap undefined.</body></html>'); |
$active=0; |
| } |
} |
| # ------------------------------------------------------------------ Untie hash |
if($active) { |
| unless (untie(%hash)) { |
push(@sorted1Students, $_); |
| &Apache::lonnet::logthis("<font color=blue>WARNING: ". |
} |
| "Could not untie coursemap $fn (browse).</font>"); |
} |
| } |
|
| |
my $Pos = $CacheData->{'form.sort'}; |
| # -------------------------------------------------------------------- All done |
my %sortData; |
| return OK; |
if($Pos eq 'Last Name') { |
| # ----------------------------------------------- Errors, hash could no be tied |
for(my $index=0; $index<scalar @sorted1Students; $index++) { |
| } |
$sortData{$CacheData->{$sorted1Students[$index].':fullname'}}= |
| } else { |
$sorted1Students[$index]; |
| $ENV{'user.error.msg'}="$requrl:bre:0:0:Course not initialized"; |
} |
| return HTTP_NOT_ACCEPTABLE; |
} elsif($Pos eq 'Section') { |
| |
for(my $index=0; $index<scalar @sorted1Students; $index++) { |
| |
$sortData{$CacheData->{$sorted1Students[$index].':section'}. |
| |
$sorted1Students[$index]}=$sorted1Students[$index]; |
| |
} |
| |
} else { |
| |
# Sort by user name |
| |
for(my $index=0; $index<scalar @sorted1Students; $index++) { |
| |
$sortData{$sorted1Students[$index]}=$sorted1Students[$index]; |
| |
} |
| |
} |
| |
|
| |
my @order = (); |
| |
foreach my $key (sort(keys(%sortData))) { |
| |
push (@order,$sortData{$key}); |
| |
} |
| |
|
| |
return @order; |
| } |
} |
| } else { |
|
| $ENV{'user.error.msg'}= |
|
| $r->uri.":vgr:0:0:Cannot view grades for complete course"; |
|
| return HTTP_NOT_ACCEPTABLE; |
|
| |
|
| |
=pod |
| |
|
| |
=item &TestCacheData() |
| |
|
| |
Determine if the cache database can be accessed with a tie. It waits up to |
| |
ten seconds before returning failure. This function exists to help with |
| |
the problems with stopping the data download. When an abort occurs and the |
| |
user quickly presses a form button and httpd child is created. This |
| |
child needs to wait for the other to finish (hopefully within ten seconds). |
| |
|
| |
=over 4 |
| |
|
| |
Input: $ChartDB |
| |
|
| |
$ChartDB: The name of the cache database to be opened |
| |
|
| |
Output: -1, 0, 1 |
| |
|
| |
-1: Couldn't tie database |
| |
0: Use cached data |
| |
1: New cache database created, use that. |
| |
|
| |
=back |
| |
|
| |
=cut |
| |
|
| |
sub TestCacheData { |
| |
my ($ChartDB)=@_; |
| |
my $isCached=-1; |
| |
my %testData; |
| |
my $tieTries=0; |
| |
|
| |
if ((-e "$ChartDB") && (!defined($ENV{'form.recalculate'}))) { |
| |
$isCached = 1; |
| |
} else { |
| |
$isCached = 0; |
| |
} |
| |
|
| |
while($tieTries < 10) { |
| |
my $result=0; |
| |
if($isCached) { |
| |
$result=tie(%testData,'GDBM_File',$ChartDB,&GDBM_READER,0640); |
| |
} else { |
| |
$result=tie(%testData,'GDBM_File',$ChartDB,&GDBM_NEWDB,0640); |
| |
} |
| |
if($result) { |
| |
last; |
| |
} |
| |
$tieTries++; |
| |
sleep 1; |
| |
} |
| |
if($tieTries >= 10) { |
| |
return -1; |
| |
} |
| |
|
| |
untie(%testData); |
| |
|
| |
return $isCached; |
| |
} |
| |
|
| |
=pod |
| |
|
| |
=item &ShouldShowColumn() |
| |
|
| |
Determine if a specified column should be shown on the chart. |
| |
|
| |
=over 4 |
| |
|
| |
Input: $cache, $test |
| |
|
| |
$cache: A pointer to the hash tied to the cached data |
| |
|
| |
$test: The form name of the column (heading.$headingIndex) or |
| |
(sequence.$sequenceIndex) |
| |
|
| |
Output: 0 (false), 1 (true) |
| |
|
| |
=back |
| |
|
| |
=cut |
| |
|
| |
sub ShouldShowColumn { |
| |
my ($cache,$test)=@_; |
| |
|
| |
if($cache->{'form.reset'} eq 'true') { |
| |
return 1; |
| |
} |
| |
|
| |
my $headings=$cache->{'form.headings'}; |
| |
my $sequences=$cache->{'form.sequences'}; |
| |
if($headings eq 'ALLHEADINGS' || $sequences eq 'ALLSEQUENCES' || |
| |
$headings=~/$test/ || $sequences=~/$test/) { |
| |
return 1; |
| |
} |
| |
|
| |
return 0; |
| } |
} |
| |
|
| |
# ----- END HELPER FUNCTIONS -------------------------------------------- |
| |
|
| |
=pod |
| |
|
| |
=head1 Handler and main function(BuildChart) |
| |
|
| |
The handler does some initial error checking and then passes the torch to |
| |
BuildChart. BuildChart calls all the appropriate functions to get the |
| |
job done. These are the only two functions that use print ($r). All other |
| |
functions return strings to BuildChart to be printed. |
| |
|
| |
=cut |
| |
|
| |
=pod |
| |
|
| |
=item &BuildChart() |
| |
|
| |
The following is the process that BuildChart goes through to |
| |
create the html document. |
| |
|
| |
-Start the lonchart document |
| |
-Test for access to the CacheData |
| |
-Download class list information if not using cached data |
| |
-Sort students and print out table desciptive data |
| |
-Output student data |
| |
-If recalculating, store a list of students, but only if all |
| |
their data was downloaded. Leave off the others. |
| |
-End document |
| |
|
| |
=over 4 |
| |
|
| |
Input: $r |
| |
|
| |
$r: Used to print html |
| |
|
| |
Output: None |
| |
|
| |
=back |
| |
|
| |
=cut |
| |
|
| |
sub BuildChart { |
| |
my ($r)=@_; |
| |
my $c = $r->connection; |
| |
|
| |
# Start the lonchart document |
| |
$r->content_type('text/html'); |
| |
$r->send_http_header; |
| |
$r->print(&StartDocument()); |
| |
$r->rflush(); |
| |
|
| |
# Test for access to the CacheData |
| |
my $isCached=0; |
| |
my $cid=$ENV{'request.course.id'}; |
| |
my $ChartDB = "/home/httpd/perl/tmp/$ENV{'user.name'}". |
| |
"_$ENV{'user.domain'}_$cid\_chart.db"; |
| |
|
| |
$isCached=&TestCacheData($ChartDB); |
| |
if($isCached < 0) { |
| |
$r->print("Unable to tie hash to db file"); |
| |
$r->rflush(); |
| |
return; |
| |
} |
| |
&ProcessFormData($ChartDB, $isCached); |
| |
|
| |
# Download class list information if not using cached data |
| |
my %CacheData; |
| |
my @students=(); |
| |
my @studentInformation=('username','domain','section','id','fullname'); |
| |
my @headings=('User Name','Domain','Section','PID','Full Name'); |
| |
my $spacePadding=' '; |
| |
if(!$isCached) { |
| |
my $processTopResourceMapReturn=&ProcessTopResourceMap($ChartDB,$c); |
| |
if($processTopResourceMapReturn ne 'OK') { |
| |
$r->print($processTopResourceMapReturn); |
| |
return; |
| |
} |
| |
if($c->aborted()) { return; } |
| |
my $classlist=&DownloadPrerequisiteData($cid, $c); |
| |
my ($checkForError)=keys(%$classlist); |
| |
if($checkForError =~ /^(con_lost|error|no_such_host)/i || |
| |
defined($classlist->{'error'})) { |
| |
return; |
| |
} |
| |
if($c->aborted()) { return; } |
| |
@students=&ProcessClassList($classlist,$cid,$ChartDB,$c); |
| |
if($c->aborted()) { return; } |
| |
&SpaceColumns(\@students,\@studentInformation,\@headings, |
| |
$ChartDB); |
| |
if($c->aborted()) { return; } |
| |
} else { |
| |
if(!$c->aborted() && tie(%CacheData,'GDBM_File',$ChartDB, |
| |
&GDBM_READER,0640)) { |
| |
@students=split(/:::/,$CacheData{'NamesOfStudents'}); |
| |
} |
| |
} |
| |
|
| |
# Sort students and print out table desciptive data |
| |
my $downloadTime=0; |
| |
if(tie(%CacheData,'GDBM_File',$ChartDB,&GDBM_READER,0640)) { |
| |
if(!$c->aborted()) { @students=&SortStudents(\@students,\%CacheData); } |
| |
if(defined($CacheData{'time'})) { $downloadTime=$CacheData{'time'}; } |
| |
else { $downloadTime=localtime(); } |
| |
if(!$c->aborted()) { $r->print('<h3>'.$downloadTime.'</h3>'); } |
| |
if(!$c->aborted()) { $r->print('<h1>'.(scalar @students). |
| |
' students</h1>'); } |
| |
if(!$c->aborted()) { $r->rflush(); } |
| |
if(!$c->aborted()) { $r->print(&CreateLegend()); } |
| |
if(!$c->aborted()) { $r->print('<table border="0"><tbody>'); } |
| |
if(!$c->aborted()) { $r->print(&CreateForm(\%CacheData)); } |
| |
if(!$c->aborted()) { $r->print(&CreateColumnSelectionBox( |
| |
\%CacheData, |
| |
\@headings)); } |
| |
if(!$c->aborted()) { $r->print('</tbody></table>'); } |
| |
if(!$c->aborted()) { $r->print('<b>Note: Uncheck the boxes above a'); } |
| |
if(!$c->aborted()) { $r->print(' column to remove that column from'); } |
| |
if(!$c->aborted()) { $r->print(' the display.</b></pre>'); } |
| |
if(!$c->aborted()) { $r->print('<table border="0" cellpadding="0" '); } |
| |
if(!$c->aborted()) { $r->print('cellspacing="0"><tbody>'); } |
| |
if(!$c->aborted()) { $r->print(&CreateColumnSelectors( |
| |
\%CacheData, |
| |
\@headings)); } |
| |
if(!$c->aborted()) { $r->print(&CreateTableHeadings( |
| |
\%CacheData, |
| |
\@studentInformation, |
| |
\@headings, |
| |
$spacePadding)); } |
| |
if(!$c->aborted()) { $r->print('</tbody></table>'); } |
| |
if(!$c->aborted()) { $r->rflush(); } |
| |
untie(%CacheData); |
| |
} else { |
| |
$r->print("Init2: Unable to tie hash to db file"); |
| |
return; |
| |
} |
| |
|
| |
# Output student data |
| |
my @updateStudentList = (); |
| |
my $courseData; |
| |
$r->print('<pre>'); |
| |
foreach (@students) { |
| |
if($c->aborted()) { |
| |
last; |
| |
} |
| |
|
| |
if(!$isCached) { |
| |
$courseData=&DownloadStudentCourseInformation($_, $cid); |
| |
if($c->aborted()) { last; } |
| |
push(@updateStudentList, $_); |
| |
&ProcessStudentData($courseData, $_, $ChartDB); |
| |
} |
| |
$r->print(&FormatStudentData($_, \@studentInformation, |
| |
$spacePadding, $ChartDB)); |
| |
$r->rflush(); |
| |
} |
| |
|
| |
# If recalculating, store a list of students, but only if all their |
| |
# data was downloaded. Leave off the others. |
| |
if(!$isCached && tie(%CacheData,'GDBM_File',$ChartDB,&GDBM_WRCREAT,0640)) { |
| |
$CacheData{'NamesOfStudents'}=join(":::", @updateStudentList); |
| |
# $CacheData{'NamesOfStudents'}= |
| |
# &Apache::lonnet::arrayref2str(\@updateStudentList); |
| |
untie(%CacheData); |
| |
} |
| |
|
| |
# End document |
| |
$r->print('</pre></body></html>'); |
| |
$r->rflush(); |
| |
|
| |
return; |
| } |
} |
| 1; |
|
| __END__ |
|
| |
|
| |
# ================================================================ Main Handler |
| |
|
| |
=pod |
| |
|
| |
=item &handler() |
| |
|
| |
The handler checks for permission to access the course data and for |
| |
initial header problem. Then it passes the torch to the work horse |
| |
function BuildChart. |
| |
|
| |
=over 4 |
| |
|
| |
Input: $r |
| |
|
| |
$r: This is the object that is used to print. |
| |
|
| |
Output: A Value (OK or HTTP_NOT_ACCEPTABLE) |
| |
|
| |
=back |
| |
|
| |
=cut |
| |
|
| |
sub handler { |
| |
my $r=shift; |
| |
# $jr=$r; |
| |
unless(&Apache::lonnet::allowed('vgr',$ENV{'request.course.id'})) { |
| |
$ENV{'user.error.msg'}= |
| |
$r->uri.":vgr:0:0:Cannot view grades for complete course"; |
| |
return HTTP_NOT_ACCEPTABLE; |
| |
} |
| |
|
| |
# Set document type for header only |
| |
if ($r->header_only) { |
| |
if($ENV{'browser.mathml'}) { |
| |
$r->content_type('text/xml'); |
| |
} else { |
| |
$r->content_type('text/html'); |
| |
} |
| |
&Apache::loncommon::no_cache($r); |
| |
$r->send_http_header; |
| |
return OK; |
| |
} |
| |
|
| |
unless($ENV{'request.course.fn'}) { |
| |
my $requrl=$r->uri; |
| |
$ENV{'user.error.msg'}="$requrl:bre:0:0:Course not initialized"; |
| |
return HTTP_NOT_ACCEPTABLE; |
| |
} |
| |
|
| |
&BuildChart($r); |
| |
|
| |
return OK; |
| |
} |
| |
1; |
| |
__END__ |
![[BACK]](/icons/back.gif){kind=icon}
Return to lonchart.pm CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [LON-CAPA] / loncom / interface