[BACK]Return to lonchart.pm CVS log [TXT] [DIR] Up to [LON-CAPA] / loncom / interface

Diff for /loncom/interface/Attic/lonchart.pm between versions 1.41 and 1.57

version 1.41, 2002/06/03 19:28:17 version 1.57, 2002/07/08 15:03:25
Line 46 Line 46
 #  #
 ###  ###
   
   =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;
Line 55  use Apache::loncommon(); Line 108  use Apache::loncommon();
 use HTML::TokeParser;  use HTML::TokeParser;
 use GDBM_File;  use GDBM_File;
   
 # -------------------------------------------------------------- Module Globals  #my $jr; 
 my %hash;  
 my %CachData;  
 my @cols;  
 my @rowlabels;  
 my @students;  
 my @PreCol;  
 my $r;  
    
 # ------------------------------------------------------------- Find out status  
   
 sub ExtractStudentData {  
     my ($index,$coid)=@_;  
     my ($sname,$sdom) = split( /\:/, $students[$index] );  
     my %result=&Apache::lonnet::dump($coid,$sdom,$sname);  
     my $ResId;  
     my $Code;  
     my $Tries;  
     my $Wrongs;  
     my %TempHash;  
     my $Version;  
     my $ProbNo;  
     my $ProbSolved;  
     my $ProbTotal;  
     my $LatestVersion;                       
     my $Str=substr($students[$index].  
             '                                                        ',0,14).' ! '.  
             substr($rowlabels[$index].  
             '                                                        ',0,45).' ! ';  
   
     my($checkForError)=keys (%result);  =pod
     if($checkForError =~ /^(con_lost|error|no_such_host)/i) {  
  my $PrTot = sprintf( "%5d", $ProbTotal );  
  my $PrSvd = sprintf( "%5d", $ProbSolved );  
  $Str .= ' '.'<font color="#000088">'.$PrSvd.'  /'.$PrTot.'</font> ';  
  return $Str;  
     }  
   
     $ProbNo = 0;  
     $ProbTotal = 0;  
     $ProbSolved = 0;  
     my $IterationNo = 0;  
     foreach $ResId (@cols) {  
  if ($IterationNo == 0) {$IterationNo++; next;}  
  if (!$ResId) {   
     my $PrNo = sprintf( "%3d", $ProbNo );  
     $Str .= ' '.'<font color="#007700">'.$PrNo.'</font> ';  
     $ProbSolved += $ProbNo;  
     $ProbNo=0;  
     next;   
  }  
  $ResId=~/(\d+)\.(\d+)/;  
  my $meta=$hash{'src_'.$ResId};  
  my $PartNo = 0;  
  undef %TempHash;  
  foreach (split(/\,/,&Apache::lonnet::metadata($meta,'keys'))) {  
     if ($_=~/^stores\_(\d+)\_tries$/) {  
  my $Part=&Apache::lonnet::metadata($meta,$_.'.part');  
  if ( $TempHash{"$Part"} eq '' ) {   
     $TempHash{"$Part"} = $Part;  
     $TempHash{$PartNo}=$Part;  
     $TempHash{"$Part.Code"} = ' ';    
     $PartNo++;  
  }  
     }  
  }  
   
  my $Prob = &Apache::lonnet::symbclean(  =head1 FORMAT DATA FOR PRINTING
        &Apache::lonnet::declutter($hash{'map_id_'.$1} ).  
                        '___'.$2.'___'.  
                        &Apache::lonnet::declutter( $hash{'src_'.$ResId} ));  
  $Code=' ';  
  $Tries = 0;  
  $LatestVersion = $result{"version:$Prob"};  
   
  if ( $LatestVersion ) {  
     for ( my $Version=1; $Version<=$LatestVersion; $Version++ ) {  
  my $vkeys = $result{"$Version:keys:$Prob"};  
  my @keys = split(/\:/,$vkeys);    
   
  foreach my $Key (@keys) {    
     if (($Key=~/\.(\w+)\.solved$/) && ($Key!~/^\d+\:/)) {  
  my $Part = $1;  
  $Tries = $result{"$Version:$Prob:resource.$Part.tries"};  
  $TempHash{"$Part.Tries"}=($Tries) ? $Tries : 0;  
  my $Val = $result{"$Version:$Prob: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 = ' ';}  
   
  $TempHash{"$Part.Code"} = $Code;  =cut
     }  
  }  # ----- FORMAT PRINT DATA ----------------------------------------------
     }  
 # Actually append problem to output (all parts)  =pod
     $Str.='<a href="/adm/grades?symb='.  
                 &Apache::lonnet::escape($Prob).  =item &FormatStudentInformation()
   
   This function produces a formatted string of the student's information:
   username, domain, section, full name, and PID.
   
   =over 4
   
   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 $problemsCorrect = 0;
       my $totalProblems   = 0;
       my $problemsSolved  = 0;
       my $numberOfParts   = 0;
       foreach my $sequence (split(/\:/,$CacheData{'orderedSequences'})) {
           if(!&ShouldShowColumn(\%CacheData, 'sequence'.$sequence)) {
               next;
           }
   
    my $characterCount=0;
    foreach my $problemID (split(/\:/,$CacheData{$sequence.':problems'})) {
       my $problem = $CacheData{$problemID.':problem'};
       my $LatestVersion = $CacheData{$name.":version:$problem"};
   
               if(!$LatestVersion) {
                   foreach my $part (split(/\:/,$CacheData{$sequence.':'.
                                                           $problemID.
                                                           ':parts'})) {
                       $Str .= ' ';
                       $totalProblems++;
                       $characterCount++;
                   }
                   next;
               }
   
               my %partData=undef;
               #initialize data, displays skips correctly
               foreach my $part (split(/\:/,$CacheData{$sequence.':'.
                                                       $problemID.
                                                       ':parts'})) {
                   $partData{$part.':tries'}=0;
                   $partData{$part.':code'}=' ';
               }
       for(my $Version=1; $Version<=$LatestVersion; $Version++) {
                   foreach my $part (split(/\:/,$CacheData{$sequence.':'.
                                                           $problemID.
                                                           ':parts'})) {
   
                       if(!defined($CacheData{$name.":$Version:$problem".
                                                  ":resource.$part.solved"})) {
                           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;
                   }
               }
   
               $Str.='<a href="/adm/grades?symb='.
                   &Apache::lonnet::escape($problem).
                 '&student='.$sname.'&domain='.$sdom.'&command=submission">';                   '&student='.$sname.'&domain='.$sdom.'&command=submission">'; 
     for ( my $n = 0; $n < $PartNo; $n++ ) {                foreach(split(/\:/,$CacheData{$sequence.':'.$problemID.
  my $part = $TempHash{$n};                                            ':parts'})) {
  my $Code = $TempHash{"$part.Code"};                  if($partData{$_.':code'} eq '*') {
  if ( $Code eq '*') {                      $problemsCorrect++;
     $ProbNo++;                      if (($partData{$_.':tries'}<10) &&
     if (($TempHash{"$part.Tries"}<10) ||                          ($partData{$_.':tries'} ne '')) {
  ($TempHash{"$part.Tries"} eq '')) {                          $partData{$_.':code'}=$partData{$_.':tries'};
  $TempHash{"$part.Code"}=$TempHash{"$part.Tries"};                      }
     }                  } elsif($partData{$_.':code'} eq '+') {
  }                      $problemsCorrect++;
  elsif ( $Code eq '+' ) {$ProbNo++;}                  }
  $Str .= $TempHash{"$part.Code"};  
  if ( $Code ne 'x' ) {$ProbTotal++;}                  $Str .= $partData{$_.':code'};
     }                  $characterCount++;
     $Str.='</a>';  
  } else {                  if($partData{$_.':code'} ne 'x') {
     for(my $n=0; $n<$PartNo; $n++) {                      $totalProblems++;
  $Str.=' ';                  }
  $ProbTotal++;              }
     }              $Str.='</a>';
  }          }
   
           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;
     }      }
   
     my $PrTot = sprintf( "%5d", $ProbTotal );      my $outputProblemsSolved = sprintf( "%4d", $problemsSolved );
     my $PrSvd = sprintf( "%5d", $ProbSolved );      my $outputTotalProblems  = sprintf( "%4d", $totalProblems );
     $Str .= ' '.'<font color="#000088">'.$PrSvd.'  /'.$PrTot.'</font> ';      $Str .= '<font color="#000088">'.$outputProblemsSolved.
       ' / '.$outputTotalProblems.'</font><br>';
     return $Str ;  
       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
   
 # ------------------------------------------------------------ Build page table  sub CreateTableHeadings {
       my ($CacheData,$studentInformation,$headings,$spacePadding)=@_;
 sub tracetable {      my $Str='<tr>';
     my ($rid,$beenhere)=@_;  
     unless ($beenhere=~/\&$rid\&/) {      for(my $index=0; $index<(scalar @$headings); $index++) {
        $beenhere.=$rid.'&';            if(!&ShouldShowColumn($CacheData, 'heading'.$index)) {
 # new ... updating the map according to sequence and page              next;
        if (defined($hash{'is_map_'.$rid})) {          }
    my $cmap=$hash{'map_type_'.$hash{'map_pc_'.$hash{'src_'.$rid}}};  
            if ( $cmap eq 'sequence' || $cmap eq 'page' ) {           $Str .= '<td align="left"><pre>';
                $cols[$#cols+1]=0;    my $data=$$headings[$index];
            }   $Str .= $data;
            if ((defined($hash{'map_start_'.$hash{'src_'.$rid}})) &&  
                (defined($hash{'map_finish_'.$hash{'src_'.$rid}}))) {   my @dataLength=split(//,$data);
               my $frid=$hash{'map_finish_'.$hash{'src_'.$rid}};   my $length=scalar @dataLength;
    $Str .= (' 'x($CacheData->{$$studentInformation[$index].'Length'}-
                 &tracetable($hash{'map_start_'.$hash{'src_'.$rid}},                        $length));
                 '&'.$frid.'&');   $Str .= $spacePadding;
           $Str .= '</pre></td>';
               if ($hash{'src_'.$frid}) {  
                  if ($hash{'src_'.$frid}=~  
                                  /\.(problem|exam|quiz|assess|survey|form)$/) {  
      $cols[$#cols+1]=$frid;  
                  }  
       }  
   
    }  
        } else {  
           if ($hash{'src_'.$rid}) {  
              if ($hash{'src_'.$rid}=~  
                                  /\.(problem|exam|quiz|assess|survey|form)$/) {  
          $cols[$#cols+1]=$rid;  
              }  
           }  
        }  
        if (defined($hash{'to_'.$rid})) {  
           foreach (split(/\,/,$hash{'to_'.$rid})){  
               &tracetable($hash{'goesto_'.$_},$beenhere);  
           }  
        }  
     }      }
   
       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;
 }  }
   
 sub usection {  =pod
     my ($udom,$unam,$courseid,$ActiveFlag)=@_;  
     $courseid=~s/\_/\//g;  
     $courseid=~s/^(\w)/\/$1/;  
   
     my %result=&Apache::lonnet::dump('roles',$udom,$unam);  =item &CreateColumnSelectionBox()
   
     my($checkForError)=keys (%result);  If there are columns not being displayed then this selection box is created
     if($checkForError =~ /^(con_lost|error|no_such_host)/i) {  with a list of those columns.  When selections are made and the page 
  return -1;  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++;
     }      }
     my $cursection='-1';  
     my $oldsection='-1';      foreach my $sequence (split(/\:/,$CacheData->{'orderedSequences'})) {
     my $status='Expired';          if(&ShouldShowColumn($CacheData, 'sequence'.$sequence)) {
     foreach my $key (keys (%result)) {              next;
  my $value = $result{$key};  
         if ($key=~/^$courseid(?:\/)*(\w+)*\_st$/) {  
             my $section=$1;  
             if ($key eq $courseid.'_st') { $section=''; }  
     my ($dummy,$end,$start)=split(/\_/,$value);  
     my $now=time;  
     my $notactive=0;  
     if ($start) { if ($now<$start) { $notactive=1; } }  
     if ($end) { if ($now>$end) { $notactive=1; } }  
     if ($notactive == 0) { $status='Active';$cursection=$section;}  
     if ($notactive == 1) { $oldsection=$section;}  
         }          }
           $name = $CacheData->{$sequence.':title'};
           $notThere .= '<option value="sequence'.$sequence.'">';
           $notThere .= $name.'</option>'."\n";
           $missing++;
     }      }
     if ($status eq $ActiveFlag) {  
       if ($cursection eq '-1') { return $oldsection; }      if($missing) {
       return $cursection;          $notThere .= '</select>';
     }      } else {
     if ($ActiveFlag eq 'Any') {           $notThere='<tr><td>';
       if ($cursection eq '-1') { return $oldsection; }  
       return $cursection;  
     }      }
     return '-1';  
       return $notThere.'</td></tr>';
 }  }
   
 sub BuildChart {  =pod
 # ----------------------- Get first and last resource, see if there is anything  
     my $firstres=$hash{'map_start_/res/'.$ENV{'request.course.uri'}};  =item &CreateColumnSelectors()
     my $lastres=$hash{'map_finish_/res/'.$ENV{'request.course.uri'}};  
     if (($firstres) && ($lastres)) {  This function generates the checkboxes above the column headings.  The 
 # ----------------------------------------------------------------- Render page  column will be removed if the checkbox is unchecked.
  my $cid=$ENV{'request.course.id'};  
         my $chome=$ENV{'course.'.$cid.'.home'};  =over 4
         my ($cdom,$cnum)=split(/\_/,$cid);  
 # ---------------------------------------------- Read class list and row labels  Input: $CacheData, $headings
  my %classlist=&Apache::lonnet::dump('classlist',$cdom,$cnum);  
   $CacheData: A pointer to a hash tied to the cached data
  my($checkForError)=keys (%classlist);  
  if($checkForError =~ /^(con_lost|error|no_such_host)/i) {  $headings:  An array of the names of the columns for the student 
     $r->print('<h1>Could not access course data</h1>');  information.  They are used to know what are the student information columns
  } else {  
     my $now=time;  Output: $present
     foreach my $name (sort(keys(%classlist))) {  
  my $value=$classlist{$name};  $present: The string contains the first row of a table.  Each column contains
  my ($end,$start)=split(/\:/,$value);  a checkbox which is left justified.  Currently left justification is used
  my $active=1;  for consistency of location over the column in which it presides.
  my $Status=$ENV{'form.status'};  
  $Status = ($Status) ? $Status : 'Active';  =back
  if ( ( ($end) && $now > $end ) &&   
      ( ($Status eq 'Active') ) ) { $active=0; }  =cut
  if ( ($Status eq 'Expired') &&   
      ($end == 0 || $now < $end) ) { $active=0; }  sub CreateColumnSelectors {
  if ($active) {      my ($CacheData,$headings)=@_;
     my $thisindex=$#students+1;  
     $students[$thisindex]=$name;      my $found=0;
     my ($sname,$sdom)=split(/\:/,$name);      my ($name, $length, $position);
     $PreCol[$thisindex]=$sname.':';  
     my $ssec=&usection($sdom,$sname,$cid,$Status);  
     if ($ssec==-1) {  
  $rowlabels[$thisindex]=  
     'Data not available: '.$name;  
     } else {  
  my %reply=&Apache::lonnet::idrget($sdom,$sname);  
  my %name=&Apache::lonnet::get('environment',  
        ['lastname','generation'  
        ,'firstname'  
        ,'middlename'],  
        $sdom,$sname);  
  my $name=$name{lastname};  
  if ($name{generation}) {$name.=" $name{generation}";}  
  $name.=',';  
  if ($name{firstname}) {$name.=" $name{firstname}";}  
  if ($name{middlename}) {$name.=" $name{middlename}";}  
  if ($name eq ',') {$name='';}  
  #$ssec=(int($ssec)) ? int($ssec) : $ssec;  
  my $sec=sprintf('%3s',$ssec);  
  $rowlabels[$thisindex]=$sec.' '.$reply{$sname}.' ';  
  $PreCol[$thisindex] .= $name.':'.$sec;  
  $rowlabels[$thisindex].=$name.' ';  
     }  
  }  
     }  
  }  
   
  my $allstudents=$#students+1;      my $present = '<tr>';
  $r->print('<h3>'.$allstudents.' students</h3>');      for(my $index=0; $index<(scalar @$headings); $index++) {
  &CreateForm();          if(!&ShouldShowColumn($CacheData, 'heading'.$index)) {
  $r->rflush();              next;
   
 # --------------- Find all assessments and put them into some linear-like order  
  &tracetable($firstres,'&'.$lastres.'&');  
 # ----------------------------------------------------------------- Start table  
   
         $r->print('<p><pre>');  
   my $index;  
         for ($index=0;$index<=$#students;$index++) {  
     my $Str=&ExtractStudentData($index,$cid);  
     $r->print($Str.'<br>');  
             $r->rflush();  
     $CachData{$PreCol[$index]}=$Str;  
         }          }
         $r->print('</pre>');          $present .= '<td align="left">';
     } else {          $present .= '<input type="checkbox" checked="on" ';
  $r->print('<h3>Undefined course sequence</h3>');          $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 {  sub CreateForm {
       my ($CacheData)=@_;
     my $OpSel1='';      my $OpSel1='';
     my $OpSel2='';      my $OpSel2='';
     my $OpSel3='';      my $OpSel3='';
     my $Status = $ENV{'form.status'};      my $Status = $CacheData->{'form.status'};
     if ( $Status eq 'Any' ) { $OpSel3='selected'; }      if ( $Status eq 'Any' ) { $OpSel3='selected'; }
     elsif ($Status eq 'Expired' ) { $OpSel2 = 'selected'; }      elsif ($Status eq 'Expired' ) { $OpSel2 = 'selected'; }
     else { $OpSel1 = 'selected'; }      else { $OpSel1 = 'selected'; }
   
     my $Ptr = '<form name=stat method=post action="/adm/chart" >'."\n";      my $Ptr .= '<form name="stat" method="post" action="/adm/chart" >'."\n";
     $Ptr .= '<b> Sort by: &nbsp; </b>'."\n";      $Ptr .= '<tr><td align="right">';
       $Ptr .= '</td><td align="left">';
       $Ptr .= '<input type="submit" name="recalculate" ';
       $Ptr .= 'value="Recalculate Chart"/>'."\n";
       $Ptr .= '&nbsp;&nbsp;&nbsp;';
       $Ptr .= '<input type="submit" name="refresh" ';
       $Ptr .= 'value="Refresh Chart"/>'."\n";
     $Ptr .= '&nbsp;&nbsp;&nbsp;';      $Ptr .= '&nbsp;&nbsp;&nbsp;';
     $Ptr .= '<input type=submit name=sort value="User Name" />'."\n";      $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 .= '&nbsp;&nbsp;&nbsp;';      $Ptr .= '&nbsp;&nbsp;&nbsp;';
     $Ptr .= '<input type=submit name=sort value="Last Name" />'."\n";      $Ptr .= '<input type="submit" name="sort" value="Last Name" />'."\n";
     $Ptr .= '&nbsp;&nbsp;&nbsp;';      $Ptr .= '&nbsp;&nbsp;&nbsp;';
     $Ptr .= '<input type=submit name=sort value="Section"/>'."\n";      $Ptr .= '<input type="submit" name="sort" value="Section"/>'."\n";
     $Ptr .= '<br><br>';      $Ptr .= '</td></tr><tr><td align="right">';
     $Ptr .= '<b> Student Status: &nbsp; </b>'."\n".      $Ptr .= '<b> Student Status: &nbsp; </b>'."\n".
               '</td><td align="left">'.
             '<select name="status">'.               '<select name="status">'. 
             '<option '.$OpSel1.' >Active</option>'."\n".              '<option '.$OpSel1.' >Active</option>'."\n".
             '<option '.$OpSel2.' >Expired</option>'."\n".              '<option '.$OpSel2.' >Expired</option>'."\n".
     '<option '.$OpSel3.' >Any</option> </select> '."\n";      '<option '.$OpSel3.' >Any</option> </select> '."\n";
     $Ptr .= '&nbsp;&nbsp;&nbsp;';      $Ptr .= '</td></tr>';
     $Ptr .= '<input type=submit name=sort value="Recalculate Chart"/>'."\n";  
     $Ptr .= '</form>'."\n";      return $Ptr;
     $r->print( $Ptr );  
 }  }
   
 sub CacheChart {  =pod
     my %list = ();  
     my $count=0;  
   
     my $Pos = $ENV{'form.sort'};  =item &CreateLegend()
     if ( $Pos eq 'Last Name' ) {$Pos=1;}  
     elsif ( $Pos eq 'Section' ) {$Pos=2;}  
     else {$Pos=0;}  
   
     foreach my $key( keys %CachData) {   This function returns a formatted string containing the legend for the
  my @Temp=split(/\:/,$key);  chart.  The legend describes the symbols used to represent grades for
  my $Use = $Temp[$Pos];  problems.
  $list{$Use.$key}=$key;  
  $count++;  
     }  
   
     my @order = sort(keys(%list));  =cut
   
     $r->print('<h3>'.$count.' students</h3>');  sub CreateLegend {
     &CreateForm();      my $Str = "<p><pre>".
     $r->rflush();                "1..9: correct by student in 1..9 tries\n".
       
     $r->print('<p><pre>');  
     for ( my $n; $n < $count; $n++) {  
  $r->print($CachData{$list{$order[$n]}}.'<br>');  
     }  
     $r->print('</pre>');  
 }  
   
 sub Start {  
     undef %hash;  
     undef %CachData;  
     undef @students;  
     undef @cols;  
     undef @rowlabels;  
     undef @PreCol;  
   
     $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 student in more than 9 tries\n".
       "   +: correct by override\n".        "   +: correct by override\n".
               "   -: incorrect by override\n".                "   -: incorrect by override\n".
       "   .: incorrect attempted\n".        "   .: incorrect attempted\n".
       "   #: ungraded attempted\n".        "   #: ungraded attempted\n".
               "    : not attempted\n".                "    : not attempted\n".
       "   x: excused</pre><p>");         "   x: excused".
 # ------------------------------- This is going to take a while, produce output                "</pre><p>"; 
     $r->rflush();      return $Str;
   }
   
     my $cid=$ENV{'request.course.id'};  =pod
     my $ChartDB = "/home/httpd/perl/tmp/$ENV{'user.name'}".  
                   "_$ENV{'user.domain'}_$cid\_chart.db";  
   
     if ((-e "$ChartDB") && ($ENV{'form.sort'} ne 'Recalculate Chart')) {  =item &StartDocument()
  if (tie(%CachData,'GDBM_File',"$ChartDB",&GDBM_READER,0640)) {  
     &CacheChart();  Returns a string containing the header information for the chart: title,
  }  logo, and course title.
  else {  
     $r->print("Unable to tie hash to db file");  =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.';
     }      }
     else {  
  if (tie(%CachData,'GDBM_File',$ChartDB,&GDBM_WRCREAT,0640)) {      my (@sequences, @currentResource, @finishResource);
     foreach (keys %CachData) {delete $CachData{$_};}      my ($currentSequence, $currentResourceID, $lastResourceID);
     &BuildChart();  
       $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;
    }
       }
  }   }
  else {  
     $r->print("Unable to tie hash to db file");   # 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;
                       }
    }
       }
    }
   
    #if resource == finish resource
    if($currentResourceID eq $lastResourceID) {
       #pop off last resource of sequence
       $currentResourceID=pop(@currentResource);
       $lastResourceID=pop(@finishResource);
   
       if(defined($CacheData{$currentSequence.':problems'})) {
    # Capture sequence information here
    $CacheData{$currentSequence.':title'}=
       $hash{'title_'.$currentResourceID};
   
                   my $totalProblems=0;
                   foreach my $currentProblem (split(/\:/,
                                                  $CacheData{$currentSequence.
                                                  ':problems'})) {
                       foreach (split(/\:/,$CacheData{$currentSequence.':'.
                                                      $currentProblem.
                                                      ':parts'})) {
                           $totalProblems++;
                       }
                   }
    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 {
                   $CacheData{'orderedSequences'}=~s/$currentSequence//;
                   $CacheData{'orderedSequences'}=~s/::/:/g;
                   $CacheData{'orderedSequences'}=~s/^:|:$//g;
               }
   
       $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>"); 
     }      }
     untie(%CachData);  
       return 'OK';
 }  }
   
 # ================================================================ Main Handler  =pod
   
 sub handler {  =item &ProcessSection()
     $r=shift;  
     if (&Apache::lonnet::allowed('vgr',$ENV{'request.course.id'})) {  Determine the section number for a student for the class.  A student can have 
 # ------------------------------------------- Set document type for header only  multiple sections for the same class.  The correct one is chosen.
  if ($r->header_only) {  
     if ($ENV{'browser.mathml'}) {  =over 4
  $r->content_type('text/xml');  
     } else {  Input: $sectionData, $courseid, $ActiveFlag
  $r->content_type('text/html');  
   $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/;
   
       my $cursection='-1';
       my $oldsection='-1';
       my $status='Expired';
       my $section='';
       foreach my $key (keys (%$sectionData)) {
    my $value = $sectionData->{$key};
           if ($key=~/^$courseid(?:\/)*(\w+)*\_st$/) {
       $section=$1;
       if($key eq $courseid.'_st') {
    $section='';
     }      }
     &Apache::loncommon::no_cache($r);      my ($dummy,$end,$start)=split(/\_/,$value);
     $r->send_http_header;      my $now=time;
     return OK;      my $notactive=0;
  }      if ($start) {
    if($now<$start) {
  my $requrl=$r->uri;      $notactive=1;
 # ----------------------------------------------------------------- Tie db file   }
  if ($ENV{'request.course.fn'}) {      }
     my $fn=$ENV{'request.course.fn'};      if($end) {
     if (-e "$fn.db") {   if ($now>$end) {
  if (tie(%hash,'GDBM_File',"$fn.db",&GDBM_READER,0640)) {      $notactive=1;
 # ------------------------------------------------------------------- Hash tied  
 # ---------------------------------------------------------------- Send headers  
     $r->content_type('text/html');  
     $r->send_http_header;  
     &Start();  
     $r->print('</body></html>');                   
 # ------------------------------------------------------------- End render page  
  } else {  
     $r->content_type('text/html');  
     $r->send_http_header;  
     $r->print('<html><body>Coursemap undefined.</body></html>');  
  }   }
 # ------------------------------------------------------------------ Untie hash      }
  unless (untie(%hash)) {      if($notactive == 0) {
     &Apache::lonnet::logthis("<font color=blue>WARNING: ".   $status='Active';
      "Could not untie coursemap $fn (browse).</font>");    $cursection=$section;
    last;
       }
       if($notactive == 1) {
    $oldsection=$section;
       }
    }
       }
       if($status eq $ActiveFlag) {
    if($cursection eq '-1') {
       return $oldsection;
    }
    return $cursection;
       }
       if($ActiveFlag eq 'Any') {
    if($cursection eq '-1') {
       return $oldsection;
    }
    return $cursection;
       }
       return '-1';
   }
   
   =pod
   
   =item &ProcessStudentInformation()
   
   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
   
   $ChartDB:  The name of the cache database file which will allow the data to
   be written to the cache.
   
   Output: None
   
   *NOTE:  There is no output, but an error message is stored away in the cache 
   data.  This is checked in &FormatStudentData().  The key username:domain:error 
   will only exist if an error occured.  The error is an error from 
   &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
   
   sub ProcessFormData {
       my ($ChartDB, $isCached)=@_;
       my %CacheData;
   
       if(tie(%CacheData,'GDBM_File',$ChartDB,&GDBM_WRCREAT,0640)) {
           if(defined($ENV{'form.sort'})) {
               $CacheData{'form.sort'}=$ENV{'form.sort'};
           } elsif(!defined($CacheData{'form.sort'})) {
               $CacheData{'form.sort'}='username';
           }
   
           # Ignore $ENV{'form.refresh'}
           # Ignore $ENV{'form.recalculate'}
   
           if(defined($ENV{'form.status'})) {
               $CacheData{'form.status'}=$ENV{'form.status'};
           } elsif(!defined($CacheData{'form.status'})) {
               $CacheData{'form.status'}='Active';
           }
   
           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'}.=":::".$_;
                   }
               }
           }
   
           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.
   
 # -------------------------------------------------------------------- All done  =cut
  return OK;  
 # ----------------------------------------------- Errors, hash could no be tied  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 {
    if($firstname ne '') {
       $Str .= $firstname.' ';
    }
    if($middlename ne '') {
       $Str .= $middlename.' ';
    }
    if($generation ne '') {
       $Str .= $generation;
  } else {   } else {
     $ENV{'user.error.msg'}="$requrl:bre:0:0:Course not initialized";      chop($Str);
     return HTTP_NOT_ACCEPTABLE;    }
       }
   
       return $Str;
   }
   
   =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)
   
   $CacheData: A pointer to the hash tied to the cached data
   
   Output: @order
   
   @order: An ordered list of students (username:domain)
   
   =back
   
   =cut
   
   sub SortStudents {
       my ($students,$CacheData)=@_;
   
       my @sorted1Students=();
       foreach (@$students) {
           my ($end,$start)=split(/\:/,$CacheData->{$_.':date'});
           my $active=1;
           my $now=time;
           my $Status=$CacheData->{'form.status'};
           $Status = ($Status) ? $Status : 'Active';
           if((($end) && $now > $end) && (($Status eq 'Active'))) { 
               $active=0; 
           }
           if(($Status eq 'Expired') && ($end == 0 || $now < $end)) {
               $active=0;
           }
           if($active) {
               push(@sorted1Students, $_);
           }
       }
   
       my $Pos = $CacheData->{'form.sort'};
       my %sortData;
       if($Pos eq 'Last Name') {
    for(my $index=0; $index<scalar @sorted1Students; $index++) {
       $sortData{$CacheData->{$sorted1Students[$index].':fullname'}}=
    $sorted1Students[$index];
  }   }
       } 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;
   }
   
   =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 {      } 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;
   }
   
   # ================================================================ 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'}=   $ENV{'user.error.msg'}=
         $r->uri.":vgr:0:0:Cannot view grades for complete course";          $r->uri.":vgr:0:0:Cannot view grades for complete course";
  return HTTP_NOT_ACCEPTABLE;    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;  1;
 __END__  __END__
Removed from v.1.41  
changed lines
  Added in v.1.57

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