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

Diff for /loncom/interface/Attic/lonspreadsheet.pm between versions 1.93 and 1.173

version 1.93, 2002/07/04 17:51:32 version 1.173, 2003/03/03 22:00:03
Line 26 Line 26
 # The LearningOnline Network with CAPA  # The LearningOnline Network with CAPA
 # Spreadsheet/Grades Display Handler  # Spreadsheet/Grades Display Handler
 #  #
 # 11/11,11/15,11/27,12/04,12/05,12/06,12/07,  
 # 12/08,12/09,12/11,12/12,12/15,12/16,12/18,12/19,12/30,  
 # 01/01/01,02/01,03/01,19/01,20/01,22/01,  
 # 03/05,03/08,03/10,03/12,03/13,03/15,03/17,  
 # 03/19,03/20,03/21,03/27,04/05,04/09,  
 # 07/09,07/14,07/21,09/01,09/10,9/11,9/12,9/13,9/14,9/17,  
 # 10/16,10/17,10/20,11/05,11/28,12/27 Gerd Kortemeyer  
 # 01/14/02 Matthew  
 # 02/04/02 Matthew  
   
 # POD required stuff:  # POD required stuff:
   
 =head1 NAME  =head1 NAME
Line 54  not the grades of their peers.  The spre Line 44  not the grades of their peers.  The spre
 offering the ability to use Perl code to manipulate data, as well as many  offering the ability to use Perl code to manipulate data, as well as many
 built-in functions.  built-in functions.
   
   
 =head2 Functions available to user of lonspreadsheet  =head2 Functions available to user of lonspreadsheet
   
 =over 4  =over 4
   
 =cut  =cut
   
   
 package Apache::lonspreadsheet;  package Apache::lonspreadsheet;
                           
 use strict;  use strict;
   use Apache::Constants qw(:common :http);
   use Apache::lonnet;
   use Apache::lonhtmlcommon;
   use HTML::Entities();
   
   # --------------------------------------------------------- Various form fields
   
   sub textfield {
       my ($title,$name,$value)=@_;
       return "\n<p><b>$title:</b><br>".
           '<input type=text name="'.$name.'" size=80 value="'.$value.'">';
   }
   
   sub hiddenfield {
       my ($name,$value)=@_;
       return "\n".'<input type=hidden name="'.$name.'" value="'.$value.'">';
   }
   
   sub selectbox {
       my ($title,$name,$value,%options)=@_;
       my $selout="\n<p><b>$title:</b><br>".'<select name="'.$name.'">';
       foreach (sort keys(%options)) {
           $selout.='<option value="'.$_.'"';
           if ($_ eq $value) { $selout.=' selected'; }
           $selout.='>'.$options{$_}.'</option>';
       }
       return $selout.'</select>';
   }
   
   my %oldsheets;
   my %loadedcaches;
   
   # ================================================================ Main handler
   #
   # Interactive call to screen
   #
   #
   sub handler {
       my $r=shift;
   
       my ($sheettype) = ($r->uri=~/\/(\w+)$/);
   
       if (! exists($ENV{'form.Status'})) {
           $ENV{'form.Status'} = 'Active';
       }
       if ( ! exists($ENV{'form.output'}) || 
                ($sheettype ne 'classcalc' && 
                 lc($ENV{'form.output'}) eq 'recursive excel')) {
           $ENV{'form.output'} = 'HTML';
       }
       #
       # Overload checking
       #
       # Check this server
       my $loaderror=&Apache::lonnet::overloaderror($r);
       if ($loaderror) { return $loaderror; }
       # Check the course homeserver
       $loaderror= &Apache::lonnet::overloaderror($r,
                         $ENV{'course.'.$ENV{'request.course.id'}.'.home'});
       if ($loaderror) { return $loaderror; } 
       #
       # HTML Header
       #
       if ($r->header_only) {
           $r->content_type('text/html');
           $r->send_http_header;
           return OK;
       }
       #
       # Roles Checking
       #
       # Needs to be in a course
       if (! $ENV{'request.course.fn'}) { 
           # Not in a course, or not allowed to modify parms
           $ENV{'user.error.msg'}=
               $r->uri.":opa:0:0:Cannot modify spreadsheet";
           return HTTP_NOT_ACCEPTABLE; 
       }
       #
       # Get query string for limited number of parameters
       #
       &Apache::loncommon::get_unprocessed_cgi
           ($ENV{'QUERY_STRING'},['uname','udom','usymb','ufn','mapid','resid']);
       #
       # Deal with restricted student permissions 
       #
       if ($ENV{'request.role'} =~ /^st\./) {
           delete $ENV{'form.unewfield'}   if (exists($ENV{'form.unewfield'}));
           delete $ENV{'form.unewformula'} if (exists($ENV{'form.unewformula'}));
       }
       #
       # Look for special assessment spreadsheets - '_feedback', etc.
       #
       if (($ENV{'form.usymb'}=~/^\_(\w+)/) && (!$ENV{'form.ufn'} || 
                                                $ENV{'form.ufn'} eq '' || 
                                                $ENV{'form.ufn'} eq 'default')) {
           $ENV{'form.ufn'}='default_'.$1;
       }
       if (!$ENV{'form.ufn'} || $ENV{'form.ufn'} eq 'default') {
           $ENV{'form.ufn'}='course_default_'.$sheettype;
       }
       #
       # Interactive loading of specific sheet?
       #
       if (($ENV{'form.load'}) && ($ENV{'form.loadthissheet'} ne 'Default')) {
           $ENV{'form.ufn'}=$ENV{'form.loadthissheet'};
       }
       #
       # Determine the user name and domain for the sheet.
       my $aname;
       my $adom;
       unless ($ENV{'form.uname'}) {
           $aname=$ENV{'user.name'};
           $adom=$ENV{'user.domain'};
       } else {
           $aname=$ENV{'form.uname'};
           $adom=$ENV{'form.udom'};
       }
       #
       # Open page, try to prevent browser cache.
       #
       $r->content_type('text/html');
       $r->header_out('Cache-control','no-cache');
       $r->header_out('Pragma','no-cache');
       $r->send_http_header;
       #
       # Header....
       #
       $r->print('<html><head><title>LON-CAPA Spreadsheet</title>');
       my $nothing = "''";
       if ($ENV{'browser.type'} eq 'explorer') {
           $nothing = "'javascript:void(0);'";
       }
   
       if ($ENV{'request.role'} !~ /^st\./) {
           $r->print(<<ENDSCRIPT);
   <script language="JavaScript">
   
       var editwin;
   
       function celledit(cellname,cellformula) {
           var edit_text = '';
           // cellformula may contain less-than and greater-than symbols, so
           // we need to escape them?  
           edit_text +='<html><head><title>Cell Edit Window</title></head><body>';
           edit_text += '<form name="editwinform">';
           edit_text += '<center><h3>Cell '+cellname+'</h3>';
           edit_text += '<textarea name="newformula" cols="40" rows="6"';
           edit_text += ' wrap="off" >'+cellformula+'</textarea>';
           edit_text += '</br>';
           edit_text += '<input type="button" name="accept" value="Accept"';
           edit_text += ' onClick=\\\'javascript:';
           edit_text += 'opener.document.sheet.unewfield.value=';
           edit_text +=     '"'+cellname+'";';
           edit_text += 'opener.document.sheet.unewformula.value=';
           edit_text +=     'document.editwinform.newformula.value;';
           edit_text += 'opener.document.sheet.submit();';
           edit_text += 'self.close()\\\' />';
           edit_text += '&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;';
           edit_text += '<input type="button" name="abort" ';
           edit_text +=     'value="Discard Changes"';
           edit_text += ' onClick="javascript:self.close()" />';
           edit_text += '</center></body></html>';
   
           if (editwin != null && !(editwin.closed) ) {
               editwin.close();
           }
   
           editwin = window.open($nothing,'CellEditWin','height=200,width=350,scrollbars=no,resizeable=yes,alwaysRaised=yes,dependent=yes',true);
           editwin.document.write(edit_text);
       }
   
       function changesheet(cn) {
    document.sheet.unewfield.value=cn;
           document.sheet.unewformula.value='changesheet';
           document.sheet.submit();
       }
   
       function insertrow(cn) {
    document.sheet.unewfield.value='insertrow';
           document.sheet.unewformula.value=cn;
           document.sheet.submit();
       }
   
   </script>
   ENDSCRIPT
       }
       $r->print('</head>'.&Apache::loncommon::bodytag('Grades Spreadsheet').
                 '<form action="'.$r->uri.'" name="sheet" method="post">');
       $r->print(&hiddenfield('uname',$ENV{'form.uname'}).
                 &hiddenfield('udom',$ENV{'form.udom'}).
                 &hiddenfield('usymb',$ENV{'form.usymb'}).
                 &hiddenfield('unewfield','').
                 &hiddenfield('unewformula',''));
       $r->rflush();
       #
       # Full recalc?
       #
       # Read new sheet or modified worksheet
       my $sheet=Apache::lonspreadsheet::Spreadsheet->new($aname,$adom,$sheettype,$ENV{'form.usymb'});
       if ($ENV{'form.forcerecalc'}) {
           $r->print('<h4>Completely Recalculating Sheet ...</h4>');
           $sheet->complete_recalc();
       }
       #
       # Global directory configs
       #
       $sheet->includedir($r->dir_config('lonIncludes'));
       #
       # Check user permissions
       if (($sheet->{'type'}  eq 'classcalc'       ) || 
           ($sheet->{'uname'} ne $ENV{'user.name'} ) ||
           ($sheet->{'udom'}  ne $ENV{'user.domain'})) {
           unless (&Apache::lonnet::allowed('vgr',$sheet->{'cid'})) {
               $r->print('<h1>Access Permission Denied</h1>'.
                         '</form></body></html>');
               return OK;
           }
       }
       # Print out user information
       $r->print('<h2>'.$sheet->{'coursedesc'}.'</h2>');
       if ($sheet->{'type'} ne 'classcalc') {
           $r->print('<h2>'.$sheet->gettitle().'</h2><p>');
       }
       if ($sheet->{'type'} eq 'assesscalc') {
           $r->print('<b>User:</b> '.$sheet->{'uname'}.
                     '<br /><b>Domain:</b> '.$sheet->{'udom'}.'<br />');
       }
       if ($sheet->{'type'} eq 'studentcalc' || 
           $sheet->{'type'} eq 'assesscalc') {
           $r->print('<b>Section/Group:</b>'.$sheet->{'csec'}.'</p>');
       } 
       #
       # If a new formula had been entered, go from work copy
       if ($ENV{'form.unewfield'}) {
           $r->print('<h2>Modified Workcopy</h2>');
           #$ENV{'form.unewformula'}=~s/\'/\"/g;
           $r->print('<p>Cell '.$ENV{'form.unewfield'}.' = <pre>');
           $r->print(&HTML::Entities::encode($ENV{'form.unewformula'}).
                     '</pre></p>');
           $sheet->{'filename'} = $ENV{'form.ufn'};
           $sheet->tmpread($ENV{'form.unewfield'},$ENV{'form.unewformula'});
       } elsif ($ENV{'form.saveas'}) {
           $sheet->{'filename'} = $ENV{'form.ufn'};
           $sheet->tmpread();
       } else {
           $sheet->readsheet($ENV{'form.ufn'});
       }
       # Additional options
       if ($sheet->{'type'} eq 'assesscalc') {
           $r->print('<p><font size=+2>'.
                     '<a href="/adm/studentcalc?'.
                     'uname='.$sheet->{'uname'}.
                     '&udom='.$sheet->{'udom'}.'">'.
                     'Level up: Student Sheet</a></font></p>');
       }
       if (($sheet->{'type'} eq 'studentcalc') && 
           (&Apache::lonnet::allowed('vgr',$sheet->{'cid'}))) {
           $r->print ('<p><font size=+2><a href="/adm/classcalc">'.
                      'Level up: Course Sheet</a></font></p>');
       }
       # Recalc button
       $r->print('<br />'.
                 '<input type="submit" name="forcerecalc" '.
                 'value="Completely Recalculate Sheet"></p>');
       # Save dialog
       if (&Apache::lonnet::allowed('opa',$ENV{'request.course.id'})) {
           my $fname=$ENV{'form.ufn'};
           $fname=~s/\_[^\_]+$//;
           if ($fname eq 'default') { $fname='course_default'; }
           $r->print('<input type=submit name=saveas value="Save as ...">'.
                     '<input type=text size=20 name=newfn value="'.$fname.'">'.
                     'make default: <input type=checkbox name="makedefufn"><p>');
       }
       $r->print(&hiddenfield('ufn',$sheet->{'filename'}));
       # Load dialog
       if (&Apache::lonnet::allowed('opa',$ENV{'request.course.id'})) {
           $r->print('<p><input type=submit name=load value="Load ...">'.
                     '<select name="loadthissheet">'.
                     '<option name="default">Default</option>');
           foreach ($sheet->othersheets()) {
               $r->print('<option name="'.$_.'"');
               if ($ENV{'form.ufn'} eq $_) {
                   $r->print(' selected');
               }
               $r->print('>'.$_.'</option>');
           } 
           $r->print('</select><p>');
           if ($sheet->{'type'} eq 'studentcalc') {
               $sheet->setothersheets($sheet->othersheets('assesscalc'));
           }
       }
       #
       # Set up caching mechanisms
       #
       &Apache::lonspreadsheet::Spreadsheet::load_spreadsheet_expirationdates();
       # Clear out old caches if we have not seen this class before.
       if (exists($oldsheets{'course'}) &&
           $oldsheets{'course'} ne $sheet->{'cid'}) {
           undef %oldsheets;
           undef %loadedcaches;
       }
       $oldsheets{'course'} = $sheet->{'cid'};
       #
       if ($sheet->{'type'} eq 'classcalc') {
           $r->print("Loading previously calculated student sheets ...\n");
           $r->rflush();
           &Apache::lonspreadsheet::Spreadsheet::cachedcsheets();
       } elsif ($sheet->{'type'} eq 'studentcalc') {
           $r->print("Loading previously calculated assessment sheets ...\n");
           $r->rflush();
           $sheet->cachedssheets();
       }
       # Update sheet, load rows
       $r->print("Loaded sheet(s), updating rows ...<br>\n");
       $r->rflush();
       #
       $sheet->updatesheet();
       $r->print("Updated rows, loading row data ...\n");
       $r->rflush();
       #
       $sheet->loadrows($r);
       $r->print("Loaded row data, calculating sheet ...<br>\n");
       $r->rflush();
       #
       my $calcoutput=$sheet->calcsheet();
       $r->print('<h3><font color=red>'.$calcoutput.'</h3></font>');
       # See if something to save
       if (&Apache::lonnet::allowed('opa',$ENV{'request.course.id'})) {
           my $fname='';
           if ($ENV{'form.saveas'} && ($fname=$ENV{'form.newfn'})) {
               $fname=~s/\W/\_/g;
               if ($fname eq 'default') { $fname='course_default'; }
               $fname.='_'.$sheet->{'type'};
               $sheet->{'filename'} = $fname;
               $ENV{'form.ufn'}=$fname;
               $r->print('<p>Saving spreadsheet: '.
                         $sheet->writesheet($ENV{'form.makedefufn'}).
                         '<p>');
           }
       }
       #
       # Write the modified worksheet
       $r->print('<b>Current sheet:</b> '.$sheet->{'filename'}.'</p>');
       $sheet->tmpwrite();
       if ($sheet->{'type'} eq 'assesscalc') {
           $r->print('<p>Show rows with empty A column: ');
       } else {
           $r->print('<p>Show empty rows: ');
       }
       #
       $r->print(&hiddenfield('userselhidden','true').
                 '<input type="checkbox" name="showall" onClick="submit()"');
       #
       if ($ENV{'form.showall'}) { 
           $r->print(' checked'); 
       } else {
           unless ($ENV{'form.userselhidden'}) {
               unless 
                   ($ENV{'course.'.$sheet->{'cid'}.'.hideemptyrows'} eq 'yes') {
                       $r->print(' checked');
                       $ENV{'form.showall'}=1;
                   }
           }
       }
       $r->print('>');
       #
       # output format select box 
       $r->print(' Output as <select name="output" size="1" onChange="submit()">'.
                 "\n");
       foreach my $mode (qw/HTML CSV Excel/) {
           $r->print('<option value="'.$mode.'"');
           if ($ENV{'form.output'} eq $mode) {
               $r->print(' selected ');
           } 
           $r->print('>'.$mode.'</option>'."\n");
       }
   #
   #    Mulit-sheet excel takes too long and does not work at all for large
   #    classes.  Future inclusion of this option may be possible with the
   #    Spreadsheet::WriteExcel::Big and speed improvements.
   #
   #    if ($sheet->{'type'} eq 'classcalc') {
   #        $r->print('<option value="recursive excel"');
   #        if ($ENV{'form.output'} eq 'recursive excel') {
   #            $r->print(' selected ');
   #        } 
   #        $r->print(">Multi-Sheet Excel</option>\n");
   #    }
       $r->print("</select>\n");
       #
       if ($sheet->{'type'} eq 'classcalc') {
           $r->print('&nbsp;Student Status: '.
                     &Apache::lonhtmlcommon::StatusOptions
                     ($ENV{'form.Status'},'sheet'));
       }
       #
       # Buttons to insert rows
   #    $r->print(<<ENDINSERTBUTTONS);
   #<br>
   #<input type='button' onClick='insertrow("top");' 
   #value='Insert Row Top'>
   #<input type='button' onClick='insertrow("bottom");' 
   #value='Insert Row Bottom'><br>
   #ENDINSERTBUTTONS
       # Print out sheet
       $sheet->outsheet($r);
       $r->print('</form></body></html>');
       #  Done
       return OK;
   }
   
   1;
   
   #############################################################
   #############################################################
   #############################################################
   
   package Apache::lonspreadsheet::Spreadsheet;
               
   use strict;
   use Apache::Constants qw(:common :http);
   use Apache::lonnet;
   use Apache::loncoursedata;
   use Apache::File();
 use Safe;  use Safe;
 use Safe::Hole;  use Safe::Hole;
 use Opcode;  use Opcode;
 use Apache::lonnet;  
 use Apache::Constants qw(:common :http);  
 use GDBM_File;  use GDBM_File;
   use HTML::Entities();
 use HTML::TokeParser;  use HTML::TokeParser;
   use Spreadsheet::WriteExcel;
   use Time::HiRes;
   
 #  #
 # Caches for previously calculated spreadsheets  # These global hashes are dependent on user, course and resource, 
   # and need to be initialized every time when a sheet is calculated
 #  #
   my %courseopt;
   my %useropt;
   my %parmhash;
   
 my %oldsheets;  #
 my %loadedcaches;  # Caches for coursewide information 
   #
   my %Section;
   
   #
   # Caches for previously calculated spreadsheets
   #
 my %expiredates;  my %expiredates;
   
 #  #
 # Cache for stores of an individual user  # Cache for stores of an individual user
 #  #
   
 my $cachedassess;  my $cachedassess;
 my %cachedstores;  my %cachedstores;
   
 #  #
 # These cache hashes need to be independent of user, resource and course  # Some hashes for stats on timing and performance
 # (user and course can/should be in the keys)  
 #  #
   my %starttimes;
   my %usedtimes;
   my %numbertimes;
   
   #
   # Directories
   #
   my $includedir;
   
   sub includedir {
       my $self = shift;
       $includedir = shift;
   }
   
 my %spreadsheets;  my %spreadsheets;
   #my %loadedcaches;
 my %courserdatas;  my %courserdatas;
 my %userrdatas;  my %userrdatas;
 my %defaultsheets;  my %defaultsheets;
 my %updatedata;  my %rowlabel_cache;
   #my %oldsheets;
   
   sub complete_recalc {
       my $self = shift;
       undef %spreadsheets;
       undef %courserdatas;
       undef %userrdatas;
       undef %defaultsheets;
       undef %rowlabel_cache;
   }
   
   sub get_sheet {
       my $self = shift;
       my $sheet_id = shift;
       my $formulas;
       # if we already have the file loaded and parsed, return the formulas
       if (exists($self->{'sheets'}->{$sheet_id})) {
           $formulas = $self->{'sheets'}->{$sheet_id};
           $self->debug('retrieved '.$sheet_id);
       } else {
           # load the file
           #     set $error and return undef if there is an error loading
           # parse it
           #     set $error and return undef if there is an error parsing
       }
       return $formulas;
   }
   
 #  #
 # These global hashes are dependent on user, course and resource,   # Load previously cached student spreadsheets for this course
 # and need to be initialized every time when a sheet is calculated  
 #  #
 my %courseopt;  sub load_spreadsheet_expirationdates {
 my %useropt;      undef %expiredates;
 my %parmhash;      my $cid=$ENV{'request.course.id'};
       my @tmp = &Apache::lonnet::dump('nohist_expirationdates',
                                       $ENV{'course.'.$cid.'.domain'},
                                       $ENV{'course.'.$cid.'.num'});
       if (lc($tmp[0]) !~ /^error/){
           %expiredates = @tmp;
       }
   }
   
 # Stuff that only the screen handler can know  # ===================================================== Calculated sheets cache
   #
   # Load previously cached student spreadsheets for this course
   #
   sub cachedcsheets {
       my $cid=$ENV{'request.course.id'};
       my @tmp = &Apache::lonnet::dump('nohist_calculatedsheets',
                                       $ENV{'course.'.$cid.'.domain'},
                                       $ENV{'course.'.$cid.'.num'});
       if ($tmp[0] !~ /^error/) {
           my %StupidTempHash = @tmp;
           while (my ($key,$value) = each %StupidTempHash) {
               $Apache::lonspreadsheet::oldsheets{$key} = $value;
           }
       }
   }
   
 my $includedir;  #
 my $tmpdir;  # Load previously cached assessment spreadsheets for this student
   #
   sub cachedssheets {
       my $self = shift;
       my ($uname,$udom) = @_;
       $uname = $uname || $self->{'uname'};
       $udom  = $udom  || $self->{'udom'};
       if (! exists($Apache::lonspreadsheet::loadedcaches{$uname.'_'.$udom})) {
           my @tmp = &Apache::lonnet::dump('nohist_calculatedsheets_'.
                                           $ENV{'request.course.id'},
                                           $self->{'udom'},
                                           $self->{'uname'});
           if ($tmp[0] !~ /^error/) {
               my %TempHash = @tmp;
               my $count = 0;
               while (my ($key,$value) = each %TempHash) {
                   $Apache::lonspreadsheet::oldsheets{$key} = $value;
                   $count++;
               }
               $Apache::lonspreadsheet::loadedcaches{$self->{'uname'}.'_'.$self->{'udom'}}=1;
           }
       }    
   }
   
 # =============================================================================  # ======================================================= Forced recalculation?
 # ===================================== Implements an instance of a spreadsheet  sub checkthis {
       my ($keyname,$time)=@_;
       if (! exists($expiredates{$keyname})) {
           return 0;
       } else {
           return ($time<$expiredates{$keyname});
       }
   }
   
 sub initsheet {  sub forcedrecalc {
     my $safeeval = new Safe(shift);      my ($uname,$udom,$stype,$usymb)=@_;
     my $safehole = new Safe::Hole;      my $key=$uname.':'.$udom.':'.$stype.':'.$usymb;
     $safeeval->permit("entereval");      my $time=$Apache::lonspreadsheet::oldsheets{$key.'.time'};
     $safeeval->permit(":base_math");      if ($ENV{'form.forcerecalc'}) { return 1; }
     $safeeval->permit("sort");      unless ($time) { return 1; }
     $safeeval->deny(":base_io");      if ($stype eq 'assesscalc') {
     $safehole->wrap(\&Apache::lonnet::EXT,$safeeval,'&EXT');          my $map=(split(/___/,$usymb))[0];
     my $code=<<'ENDDEFS';          if (&checkthis('::assesscalc:',$time) ||
 # ---------------------------------------------------- Inside of the safe space              &checkthis('::assesscalc:'.$map,$time) ||
               &checkthis('::assesscalc:'.$usymb,$time) ||
               &checkthis($uname.':'.$udom.':assesscalc:',$time) ||
               &checkthis($uname.':'.$udom.':assesscalc:'.$map,$time) ||
               &checkthis($uname.':'.$udom.':assesscalc:'.$usymb,$time)) {
               return 1;
           }
       } else {
           if (&checkthis('::studentcalc:',$time) || 
               &checkthis($uname.':'.$udom.':studentcalc:',$time)) {
       return 1;
           }
       }
       return 0; 
   }
   
 #  
 # f: formulas  
 # t: intermediate format (variable references expanded)  
 # v: output values  
 # c: preloaded constants (A-column)  
 # rl: row label  
 # os: other spreadsheets (for student spreadsheet only)  
   
 undef %v;   ##################################################
 undef %t;  ##################################################
 undef %f;  
 undef %c;  
 undef %rl;  
 undef @os;  
   
 $maxrow=0;  =pod
 $sheettype='';  
   
 # filename/reference of the sheet  =item &parmval()
   
 $filename='';  Determine the value of a parameter.
   
 # user data  Inputs: $what, the parameter needed, $symb, $uname, $udom, $csec 
 $uname='';  
 $uhome='';  
 $udom='';  
   
 # course data  Returns: The value of a parameter, or '' if none.
   
 $csec='';  This function cascades through the possible levels searching for a value for
 $chome='';  a parameter.  The levels are checked in the following order:
 $cnum='';  user, course (at section level and course level), map, and lonnet::metadata.
 $cdom='';  This function uses %parmhash, which must be tied prior to calling it.
 $cid='';  This function also requires %courseopt and %useropt to be initialized for
 $cfn='';  this user and course.
   
 # symb  =cut
   
   ##################################################
   ##################################################
   sub parmval {
       my ($what,$symb,$uname,$udom,$csec)=@_;
       return '' if (!$symb);
       #
       my $cid   = $ENV{'request.course.id'};
       my $result='';
       #
       my ($mapname,$id,$fn)=split(/\_\_\_/,$symb);
       # Cascading lookup scheme
       my $rwhat=$what;
       $what =~ s/^parameter\_//;
       $what =~ s/\_([^\_]+)$/\.$1/;
       #
       my $symbparm = $symb.'.'.$what;
       my $mapparm  = $mapname.'___(all).'.$what;
       my $usercourseprefix = $uname.'_'.$udom.'_'.$cid;
       #
       my $seclevel  = $usercourseprefix.'.['.$csec.'].'.$what;
       my $seclevelr = $usercourseprefix.'.['.$csec.'].'.$symbparm;
       my $seclevelm = $usercourseprefix.'.['.$csec.'].'.$mapparm;
       #
       my $courselevel  = $usercourseprefix.'.'.$what;
       my $courselevelr = $usercourseprefix.'.'.$symbparm;
       my $courselevelm = $usercourseprefix.'.'.$mapparm;
       # fourth, check user
       if (defined($uname)) {
           return $useropt{$courselevelr} if (defined($useropt{$courselevelr}));
           return $useropt{$courselevelm} if (defined($useropt{$courselevelm}));
           return $useropt{$courselevel}  if (defined($useropt{$courselevel}));
       }
       # third, check course
       if (defined($csec)) {
           return $courseopt{$seclevelr} if (defined($courseopt{$seclevelr}));
           return $courseopt{$seclevelm} if (defined($courseopt{$seclevelm}));
           return $courseopt{$seclevel}  if (defined($courseopt{$seclevel}));
       }
       #
       return $courseopt{$courselevelr} if (defined($courseopt{$courselevelr}));
       return $courseopt{$courselevelm} if (defined($courseopt{$courselevelm}));
       return $courseopt{$courselevel}  if (defined($courseopt{$courselevel}));
       # second, check map parms
       my $thisparm = $parmhash{$symbparm};
       return $thisparm if (defined($thisparm));
       # first, check default
       return &Apache::lonnet::metadata($fn,$rwhat.'.default');
   }
   
   #
   # new: Make a new spreadsheet
   #
   sub new {
       my $this = shift;
       my $class = ref($this) || $this;
       #
       my ($uname,$udom,$stype,$usymb)=@_;
       #
       my $self = {
           uname => $uname,
           udom  => $udom,
           type  => $stype,
           usymb => $usymb,
           errorlog => '',
           maxrow   => '',
           mapid => $ENV{'form.mapid'},
           resid => $ENV{'form.resid'},
           cid   => $ENV{'request.course.id'},
           csec  => $Section{$uname.':'.$udom},
           cnum  => $ENV{'course.'.$ENV{'request.course.id'}.'.num'},
           cdom  => $ENV{'course.'.$ENV{'request.course.id'}.'.domain'},
           chome => $ENV{'course.'.$ENV{'request.course.id'}.'.home'},
           coursefilename => $ENV{'request.course.fn'},
           coursedesc => $ENV{'course.'.$ENV{'request.course.id'}.'.description'},
           rows       => [],
           template_cells => [],
           };
       $self->{'uhome'} = &Apache::lonnet::homeserver($uname,$udom);
       #
       #
       $self->{'formulas'} = {};
       $self->{'constants'} = {};
       $self->{'othersheets'} = [];
       $self->{'rowlabel'} = {};
       #
       #
       $self->{'safe'} = &initsheet($self->{'type'});
       $self->{'root'} = $self->{'safe'}->root();
       #
       # Place some of the %$self  items into the safe space except the safe space
       # itself
       my $initstring = '';
       foreach (qw/uname udom type usymb cid csec coursefilename
                cnum cdom chome uhome/) {
           $initstring.= qq{\$$_="$self->{$_}";};
       }
       $self->{'safe'}->reval($initstring);
       bless($self,$class);
       return $self;
   }
   
   ##
   ## mask - used to reside in the safe space.  
   ##
   {
   
 $usymb='';  my %memoizer;
   
 sub mask {  sub mask {
     my ($lower,$upper)=@_;      my ($lower,$upper)=@_;
       my $key = $lower.'_'.$upper;
     $lower=~/([A-Za-z]|\*)(\d+|\*)/;      if (exists($memoizer{$key})) {
     my $la=$1;          return $memoizer{$key};
     my $ld=$2;      }
       $upper = $lower if (! defined($upper));
     $upper=~/([A-Za-z]|\*)(\d+|\*)/;      #
     my $ua=$1;      my ($la,$ld) = ($lower=~/([A-Za-z]|\*)(\d+|\*)/);
     my $ud=$2;      my ($ua,$ud) = ($upper=~/([A-Za-z]|\*)(\d+|\*)/);
       #
     my $alpha='';      my $alpha='';
     my $num='';      my $num='';
       #
     if (($la eq '*') || ($ua eq '*')) {      if (($la eq '*') || ($ua eq '*')) {
        $alpha='[A-Za-z]';          $alpha='[A-Za-z]';
     } else {      } else {
        if (($la=~/[A-Z]/) && ($ua=~/[A-Z]/) ||         if (($la=~/[A-Z]/) && ($ua=~/[A-Z]/) ||
            ($la=~/[a-z]/) && ($ua=~/[a-z]/)) {             ($la=~/[a-z]/) && ($ua=~/[a-z]/)) {
Line 188  sub mask { Line 809  sub mask {
           $alpha='['.$la.'-Za-'.$ua.']';            $alpha='['.$la.'-Za-'.$ua.']';
        }         }
     }         }   
   
     if (($ld eq '*') || ($ud eq '*')) {      if (($ld eq '*') || ($ud eq '*')) {
  $num='\d+';   $num='\d+';
     } else {      } else {
Line 208  sub mask { Line 828  sub mask {
        } else {         } else {
            my @lda=($ld=~m/\d/g);             my @lda=($ld=~m/\d/g);
            my @uda=($ud=~m/\d/g);             my @uda=($ud=~m/\d/g);
            my $i; $j=0; $notdone=1;             my $i; 
              my $j=0; 
              my $notdone=1;
            for ($i=0;($i<=$#lda)&&($notdone);$i++) {             for ($i=0;($i<=$#lda)&&($notdone);$i++) {
                if ($lda[$i]==$uda[$i]) {                 if ($lda[$i]==$uda[$i]) {
    $num.=$lda[$i];     $num.=$lda[$i];
Line 232  sub mask { Line 854  sub mask {
                }                 }
                $num.=')';                 $num.=')';
            } else {             } else {
                if ($lda[$#lda]!=$uda[$#uda]) {                 if ($lda[-1]!=$uda[-1]) {
                   $num.='['.$lda[$#lda].'-'.$uda[$#uda].']';                    $num.='['.$lda[-1].'-'.$uda[-1].']';
        }         }
            }             }
        }         }
     }      }
     return '^'.$alpha.$num."\$";      my $expression ='^'.$alpha.$num."\$";
       $memoizer{$key} = $expression;
       return $expression;
 }  }
   
   }
   
   sub add_hash_to_safe {
       my $self = shift;
       my $code = <<'END';
 #-------------------------------------------------------  #-------------------------------------------------------
   
 =item UWCALC(hashname,modules,units,date)   =item UWCALC(hashname,modules,units,date) 
Line 372  sub CDLHASH { Line 1001  sub CDLHASH {
     if ($key =~ /[A-z](\-[A-z])?\d+(\-\d+)?/) {      if ($key =~ /[A-z](\-[A-z])?\d+(\-\d+)?/) {
  my $keymask = &mask($key);   my $keymask = &mask($key);
  # Assume the keys are addresses   # Assume the keys are addresses
  my @Temp = grep /$keymask/,keys(%v);   my @Temp = grep /$keymask/,keys(%sheet_values);
  @Keys = $v{@Temp};   @Keys = $sheet_values{@Temp};
     } else {      } else {
  $Keys[0]= $key;   $Keys[0]= $key;
     }      }
Line 384  sub CDLHASH { Line 1013  sub CDLHASH {
     @Keys = @Temp;      @Keys = @Temp;
     if ($value =~ /[A-z](\-[A-z])?\d+(\-\d+)?/) {      if ($value =~ /[A-z](\-[A-z])?\d+(\-\d+)?/) {
  my $valmask = &mask($value);   my $valmask = &mask($value);
  my @Temp = grep /$valmask/,keys(%v);   my @Temp = grep /$valmask/,keys(%sheet_values);
  @Values =$v{@Temp};   @Values =$sheet_values{@Temp};
     } else {      } else {
  $Values[0]= $value;   $Values[0]= $value;
     }      }
Line 419  sub GETHASH { Line 1048  sub GETHASH {
  $index = 0;   $index = 0;
     }      }
     if ($key =~ /^[A-z]\d+$/) {      if ($key =~ /^[A-z]\d+$/) {
  $key = $v{$key};   $key = $sheet_values{$key};
     }      }
     return $hashes{$name}->{$key}->[$index];      return $hashes{$name}->{$key}->[$index];
 }  }
Line 476  sub HASH { Line 1105  sub HASH {
     if ($key =~ /[A-z](\-[A-z])?\d+(\-\d+)?/) {      if ($key =~ /[A-z](\-[A-z])?\d+(\-\d+)?/) {
  my $keymask = &mask($key);   my $keymask = &mask($key);
  # Assume the keys are addresses   # Assume the keys are addresses
  my @Temp = grep /$keymask/,keys(%v);   my @Temp = grep /$keymask/,keys(%sheet_values);
  @Keys = $v{@Temp};   @Keys = $sheet_values{@Temp};
     } else {      } else {
  $Keys[0]= $key;   $Keys[0]= $key;
     }      }
Line 489  sub HASH { Line 1118  sub HASH {
     # Check to see if we have multiple $value(s)       # Check to see if we have multiple $value(s) 
     if ($value =~ /[A-z](\-[A-z])?\d+(\-\d+)?/) {      if ($value =~ /[A-z](\-[A-z])?\d+(\-\d+)?/) {
  my $valmask = &mask($value);   my $valmask = &mask($value);
  my @Temp = grep /$valmask/,keys(%v);   my @Temp = grep /$valmask/,keys(%sheet_values);
  @Values =$v{@Temp};   @Values =$sheet_values{@Temp};
     } else {      } else {
  $Values[0]= $value;   $Values[0]= $value;
     }      }
Line 507  sub HASH { Line 1136  sub HASH {
     }      }
     return $Values[-1];      return $Values[-1];
 }  }
   END
       $self->{'safe'}->reval($code);
       return;
   }
   
   sub initsheet {
       my $safeeval = new Safe(shift);
       my $safehole = new Safe::Hole;
       $safeeval->permit("entereval");
       $safeeval->permit(":base_math");
       $safeeval->permit("sort");
       $safeeval->deny(":base_io");
       $safehole->wrap(\&Apache::lonnet::EXT,$safeeval,'&EXT');
       $safehole->wrap(\&mask,$safeeval,'&mask');
       $safeeval->share('$@');
       my $code=<<'ENDDEFS';
   # ---------------------------------------------------- Inside of the safe space
   #
   # f: formulas
   # t: intermediate format (variable references expanded)
   # v: output values
   # c: preloaded constants (A-column)
   # rl: row label
   # os: other spreadsheets (for student spreadsheet only)
   
   undef %sheet_values;   # Holds the (computed, final) values for the sheet
       # This is only written to by &calc, the spreadsheet computation routine.
       # It is read by many functions
   undef %t; # Holds the values of the spreadsheet temporarily. Set in &sett, 
       # which does the translation of strings like C5 into the value in C5.
       # Used in &calc - %t holds the values that are actually eval'd.
   undef %f;    # Holds the formulas for each cell.  This is the users
       # (spreadsheet authors) data for each cell.
   undef %c; # Holds the constants for a sheet.  In the assessment
       # sheets, this is the A column.  Used in &MINPARM, &MAXPARM, &expandnamed,
       # &sett, and &constants.  There is no &getconstants.
       # &constants is called by &loadstudent, &loadcourse, &load assessment,
   undef @os;  # Holds the names of other spreadsheets - this is used to specify
       # the spreadsheets that are available for the assessment sheet.
       # Set by &setothersheets.  &setothersheets is called by &handler.  A
       # related subroutine is &othersheets.
   $errorlog = '';
   
   $maxrow = 0;
   $type = '';
   
   # filename/reference of the sheet
   $filename = '';
   
   # user data
   $uname = '';
   $uhome = '';
   $udom  = '';
   
   # course data
   
   $csec = '';
   $chome= '';
   $cnum = '';
   $cdom = '';
   $cid  = '';
   $coursefilename  = '';
   
   # symb
   
   $usymb = '';
   
   # error messages
   $errormsg = '';
   
 #-------------------------------------------------------  #-------------------------------------------------------
   
Line 518  returns the number of items in the range Line 1216  returns the number of items in the range
   
 #-------------------------------------------------------  #-------------------------------------------------------
 sub NUM {  sub NUM {
     my $mask=mask(@_);      my $mask=&mask(@_);
     my $num= $#{@{grep(/$mask/,keys(%v))}}+1;      my $num= $#{@{grep(/$mask/,keys(%sheet_values))}}+1;
     return $num;         return $num;   
 }  }
   
 sub BIN {  sub BIN {
     my ($low,$high,$lower,$upper)=@_;      my ($low,$high,$lower,$upper)=@_;
     my $mask=mask($lower,$upper);      my $mask=&mask($lower,$upper);
     my $num=0;      my $num=0;
     foreach (grep /$mask/,keys(%v)) {      foreach (grep /$mask/,keys(%sheet_values)) {
         if (($v{$_}>=$low) && ($v{$_}<=$high)) {          if (($sheet_values{$_}>=$low) && ($sheet_values{$_}<=$high)) {
             $num++;              $num++;
         }          }
     }      }
Line 546  returns the sum of items in the range. Line 1244  returns the sum of items in the range.
   
 #-------------------------------------------------------  #-------------------------------------------------------
 sub SUM {  sub SUM {
     my $mask=mask(@_);      my $mask=&mask(@_);
     my $sum=0;      my $sum=0;
     foreach (grep /$mask/,keys(%v)) {      foreach (grep /$mask/,keys(%sheet_values)) {
         $sum+=$v{$_};          $sum+=$sheet_values{$_};
     }      }
     return $sum;         return $sum;   
 }  }
Line 564  compute the average of the items in the Line 1262  compute the average of the items in the
   
 #-------------------------------------------------------  #-------------------------------------------------------
 sub MEAN {  sub MEAN {
     my $mask=mask(@_);      my $mask=&mask(@_);
     my $sum=0; my $num=0;  #    $errorlog.='(mask = '.$mask.' )';
     foreach (grep /$mask/,keys(%v)) {      my $sum=0; 
         $sum+=$v{$_};      my $num=0;
       foreach (grep /$mask/,keys(%sheet_values)) {
           $sum+=$sheet_values{$_};
         $num++;          $num++;
     }      }
     if ($num) {      if ($num) {
Line 587  compute the standard deviation of the it Line 1287  compute the standard deviation of the it
   
 #-------------------------------------------------------  #-------------------------------------------------------
 sub STDDEV {  sub STDDEV {
     my $mask=mask(@_);      my $mask=&mask(@_);
   #    $errorlog.='(mask = '.$mask.' )';
     my $sum=0; my $num=0;      my $sum=0; my $num=0;
     foreach (grep /$mask/,keys(%v)) {      foreach (grep /$mask/,keys(%sheet_values)) {
         $sum+=$v{$_};          $sum+=$sheet_values{$_};
         $num++;          $num++;
     }      }
     unless ($num>1) { return undef; }      unless ($num>1) { return undef; }
     my $mean=$sum/$num;      my $mean=$sum/$num;
     $sum=0;      $sum=0;
     foreach (grep /$mask/,keys(%v)) {      foreach (grep /$mask/,keys(%sheet_values)) {
         $sum+=($v{$_}-$mean)**2;          $sum+=($sheet_values{$_}-$mean)**2;
     }      }
     return sqrt($sum/($num-1));          return sqrt($sum/($num-1));    
 }  }
Line 612  compute the product of the items in the Line 1313  compute the product of the items in the
   
 #-------------------------------------------------------  #-------------------------------------------------------
 sub PROD {  sub PROD {
     my $mask=mask(@_);      my $mask=&mask(@_);
     my $prod=1;      my $prod=1;
     foreach (grep /$mask/,keys(%v)) {      foreach (grep /$mask/,keys(%sheet_values)) {
         $prod*=$v{$_};          $prod*=$sheet_values{$_};
     }      }
     return $prod;         return $prod;   
 }  }
Line 630  compute the maximum of the items in the Line 1331  compute the maximum of the items in the
   
 #-------------------------------------------------------  #-------------------------------------------------------
 sub MAX {  sub MAX {
     my $mask=mask(@_);      my $mask=&mask(@_);
     my $max='-';      my $max='-';
     foreach (grep /$mask/,keys(%v)) {      foreach (grep /$mask/,keys(%sheet_values)) {
         unless ($max) { $max=$v{$_}; }          unless ($max) { $max=$sheet_values{$_}; }
         if (($v{$_}>$max) || ($max eq '-')) { $max=$v{$_}; }          if (($sheet_values{$_}>$max) || ($max eq '-')) { $max=$sheet_values{$_}; }
     }       } 
     return $max;         return $max;   
 }  }
Line 649  compute the minimum of the items in the Line 1350  compute the minimum of the items in the
   
 #-------------------------------------------------------  #-------------------------------------------------------
 sub MIN {  sub MIN {
     my $mask=mask(@_);      my $mask=&mask(@_);
     my $min='-';      my $min='-';
     foreach (grep /$mask/,keys(%v)) {      foreach (grep /$mask/,keys(%sheet_values)) {
         unless ($max) { $max=$v{$_}; }          unless ($max) { $max=$sheet_values{$_}; }
         if (($v{$_}<$min) || ($min eq '-')) { $min=$v{$_}; }          if (($sheet_values{$_}<$min) || ($min eq '-')) { 
               $min=$sheet_values{$_}; 
           }
     }      }
     return $min;         return $min;   
 }  }
Line 670  compute the sum of the largest 'num' ite Line 1373  compute the sum of the largest 'num' ite
 #-------------------------------------------------------  #-------------------------------------------------------
 sub SUMMAX {  sub SUMMAX {
     my ($num,$lower,$upper)=@_;      my ($num,$lower,$upper)=@_;
     my $mask=mask($lower,$upper);      my $mask=&mask($lower,$upper);
     my @inside=();      my @inside=();
     foreach (grep /$mask/,keys(%v)) {      foreach (grep /$mask/,keys(%sheet_values)) {
  push (@inside,$v{$_});   push (@inside,$sheet_values{$_});
     }      }
     @inside=sort(@inside);      @inside=sort(@inside);
     my $sum=0; my $i;      my $sum=0; my $i;
Line 695  compute the sum of the smallest 'num' it Line 1398  compute the sum of the smallest 'num' it
 #-------------------------------------------------------  #-------------------------------------------------------
 sub SUMMIN {  sub SUMMIN {
     my ($num,$lower,$upper)=@_;      my ($num,$lower,$upper)=@_;
     my $mask=mask($lower,$upper);      my $mask=&mask($lower,$upper);
     my @inside=();      my @inside=();
     foreach (grep /$mask/,keys(%v)) {      foreach (grep /$mask/,keys(%sheet_values)) {
  $inside[$#inside+1]=$v{$_};   $inside[$#inside+1]=$sheet_values{$_};
     }      }
     @inside=sort(@inside);      @inside=sort(@inside);
     my $sum=0; my $i;      my $sum=0; my $i;
Line 708  sub SUMMIN { Line 1411  sub SUMMIN {
     return $sum;         return $sum;   
 }  }
   
   #-------------------------------------------------------
   
   =item MINPARM(parametername)
   
   Returns the minimum value of the parameters matching the parametername.
   parametername should be a string such as 'duedate'.
   
   =cut
   
   #-------------------------------------------------------
   sub MINPARM {
       my ($expression) = @_;
       my $min = undef;
       study($expression);
       foreach $parameter (keys(%c)) {
           next if ($parameter !~ /$expression/);
           if ((! defined($min)) || ($min > $c{$parameter})) {
               $min = $c{$parameter} 
           }
       }
       return $min;
   }
   
   #-------------------------------------------------------
   
   =item MAXPARM(parametername)
   
   Returns the maximum value of the parameters matching the input parameter name.
   parametername should be a string such as 'duedate'.
   
   =cut
   
   #-------------------------------------------------------
   sub MAXPARM {
       my ($expression) = @_;
       my $max = undef;
       study($expression);
       foreach $parameter (keys(%c)) {
           next if ($parameter !~ /$expression/);
           if ((! defined($min)) || ($max < $c{$parameter})) {
               $max = $c{$parameter} 
           }
       }
       return $max;
   }
   
   sub calc {
   #    $errorlog .= "\%t has ".(keys(%t))." keys\n";
       %sheet_values = %t; # copy %t into %sheet_values.
   #    $errorlog .= "\%sheet_values has ".(keys(%sheet_values))." keys\n";
       my $notfinished=1;
       my $lastcalc='';
       my $depth=0;
       while ($notfinished) {
    $notfinished=0;
           while (my ($cell,$value) = each(%t)) {
               my $old=$sheet_values{$cell};
               $sheet_values{$cell}=eval $value;
       if ($@) {
    undef %sheet_values;
                   return $cell.': '.$@;
               }
       if ($sheet_values{$cell} ne $old) { 
                   $notfinished=1; 
                   $lastcalc=$cell; 
               }
           }
           $depth++;
           if ($depth>100) {
       undef %sheet_values;
               return $lastcalc.': Maximum calculation depth exceeded';
           }
       }
       return '';
   }
   
   # ------------------------------------------- End of "Inside of the safe space"
   ENDDEFS
       $safeeval->reval($code);
       return $safeeval;
   }
   
   
   #
   # expandnamed used to reside in the safe space
   #
 sub expandnamed {  sub expandnamed {
       my $self = shift;
     my $expression=shift;      my $expression=shift;
     if ($expression=~/^\&/) {      if ($expression=~/^\&/) {
  my ($func,$var,$formula)=($expression=~/^\&(\w+)\(([^\;]+)\;(.*)\)/);   my ($func,$var,$formula)=($expression=~/^\&(\w+)\(([^\;]+)\;(.*)\)/);
  my @vars=split(/\W+/,$formula);   my @vars=split(/\W+/,$formula);
         my %values=();          my %values=();
         undef %values;   foreach my $varname ( @vars ) {
  foreach ( @vars ) {  
             my $varname=$_;  
             if ($varname=~/\D/) {              if ($varname=~/\D/) {
                $formula=~s/$varname/'$c{\''.$varname.'\'}'/ge;                 $formula=~s/$varname/'$c{\''.$varname.'\'}'/ge;
                $varname=~s/$var/\(\\w\+\)/g;                 $varname=~s/$var/\(\\w\+\)/g;
        foreach (keys(%c)) {         foreach (keys(%{$self->{'constants'}})) {
   if ($_=~/$varname/) {    if ($_=~/$varname/) {
       $values{$1}=1;        $values{$1}=1;
                   }                    }
Line 750  sub expandnamed { Line 1538  sub expandnamed {
         my @matches = ();          my @matches = ();
         $#matches = -1;          $#matches = -1;
         study $expression;          study $expression;
         foreach $parameter (keys(%c)) {          my $parameter;
           foreach $parameter (keys(%{$self->{'constants'}})) {
             push @matches,$parameter if ($parameter =~ /$expression/);              push @matches,$parameter if ($parameter =~ /$expression/);
         }          }
         if ($#matches == 0) {          if (scalar(@matches) == 0) {
               $returnvalue = 'unmatched parameter: '.$parameter;
           } elsif (scalar(@matches) == 1) {
               # why do we not do this lookup here, instead of delaying it?
             $returnvalue = '$c{\''.$matches[0].'\'}';              $returnvalue = '$c{\''.$matches[0].'\'}';
           } elsif (scalar(@matches) > 0) {
               # more than one match.  Look for a concise one
               $returnvalue =  "'non-unique parameter name : $expression'";
               foreach (@matches) {
                   if (/^$expression$/) {
                       # why do we not do this lookup here?
                       $returnvalue = '$c{\''.$_.'\'}';
                   }
               }
         } else {          } else {
             $returnvalue =  "'bad parameter name : $expression'";              # There was a negative number of matches, which indicates 
               # something is wrong with reality.  Better warn the user.
               $returnvalue = 'bizzare parameter: '.$parameter;
         }          }
         return $returnvalue;          return $returnvalue;
     }      }
 }  }
   
   #
   # sett used to reside in the safe space
   #
 sub sett {  sub sett {
     %t=();      my $self = shift;
       my %t=();
     my $pattern='';      my $pattern='';
     if ($sheettype eq 'assesscalc') {      if ($self->{'type'} eq 'assesscalc') {
  $pattern='A';   $pattern='A';
     } else {      } else {
         $pattern='[A-Z]';          $pattern='[A-Z]';
     }      }
     foreach (keys(%f)) {      # Deal with the template row
  if ($_=~/template\_(\w)/) {      foreach my $col ($self->template_cells()) {
   my $col=$1;          next if ($col=~/^$pattern/);
           unless ($col=~/^$pattern/) {          foreach my $trow ($self->rows()) {
     foreach (keys(%f)) {              # Get the name of this cell
       if ($_=~/A(\d+)/) {              my $lb=$col.$trow;
  my $trow=$1;              # Grab the template declaration
                 if ($trow) {              $t{$lb}=$self->formula('template_'.$col);
                     # Get the name of this cell              # Replace '#' with the row number
     my $lb=$col.$trow;              $t{$lb}=~s/\#/$trow/g;
                     # Grab the template declaration              # Replace '....' with ','
                     $t{$lb}=$f{'template_'.$col};              $t{$lb}=~s/\.\.+/\,/g;
                     # Replace '#' with the row number              # Replace 'A0' with the value from 'A0'
                     $t{$lb}=~s/\#/$trow/g;              $t{$lb}=~s/(^|[^\"\'])([A-Za-z]\d+)/$1\$sheet_values\{\'$2\'\}/g;
                     # Replace '....' with ','              # Replace parameters
                     $t{$lb}=~s/\.\.+/\,/g;              $t{$lb}=~s/(^|[^\"\'])\[([^\]]+)\]/$1.$self->expandnamed($2)/ge;
                     # Replace 'A0' with the value from 'A0'          }
                     $t{$lb}=~s/(^|[^\"\'])([A-Za-z]\d+)/$1\$v\{\'$2\'\}/g;      }
                     # Replace parameters      # Deal with the normal cells
                     $t{$lb}=~s/(^|[^\"\'])\[([^\]]+)\]/$1.&expandnamed($2)/ge;      foreach ($self->formulas_keys()) {
                 }   next if ($_=~/template\_/);
       }          if  (($_=~/^$pattern(\d+)/) && ($1)) {
     }              if ($self->formula($_) !~ /^\!/) {
   }                  $t{$_}=$self->{'constants'}->{$_};
       }  
     }  
     foreach (keys(%f)) {  
  if (($f{$_}) && ($_!~/template\_/)) {  
             my $matches=($_=~/^$pattern(\d+)/);  
             if  (($matches) && ($1)) {  
         unless ($f{$_}=~/^\!/) {  
     $t{$_}=$c{$_};  
                 }  
             } else {  
        $t{$_}=$f{$_};  
                $t{$_}=~s/\.\.+/\,/g;  
                $t{$_}=~s/(^|[^\"\'])([A-Za-z]\d+)/$1\$v\{\'$2\'\}/g;  
                $t{$_}=~s/(^|[^\"\'])\[([^\]]+)\]/$1.&expandnamed($2)/ge;  
             }              }
           } else {
               $t{$_}=$self->formula($_);
               $t{$_}=~s/\.\.+/\,/g;
               $t{$_}=~s/(^|[^\"\'])([A-Za-z]\d+)/$1\$sheet_values\{\'$2\'\}/g;
               $t{$_}=~s/(^|[^\"\'])\[([^\]]+)\]/$1.$self->expandnamed($2)/ge;
           }
       }
       # For inserted lines, [B-Z] is also valid
       if ($self->{'type'} ne 'assesscalc') {
           foreach ($self->formulas_keys()) {
               next if ($_ !~ /[B-Z](\d+)/);
               next if ($self->formula('A'.$1) !~ /^[\~\-]/);
               $t{$_}=$self->formula($_);
               $t{$_}=~s/\.\.+/\,/g;
               $t{$_}=~s/(^|[^\"\'])([A-Za-z]\d+)/$1\$sheet_values\{\'$2\'\}/g;
               $t{$_}=~s/(^|[^\"\'])\[([^\]]+)\]/$1.$self->expandnamed($2)/ge;
         }          }
     }      }
     # For some reason 'A0' gets special treatment...  This seems superfluous      # For some reason 'A0' gets special treatment...  This seems superfluous
     # but I imagine it is here for a reason.      # but I imagine it is here for a reason.
     $t{'A0'}=$f{'A0'};      $t{'A0'}=$self->formula('A0');
     $t{'A0'}=~s/\.\.+/\,/g;      $t{'A0'}=~s/\.\.+/\,/g;
     $t{'A0'}=~s/(^|[^\"\'])([A-Za-z]\d+)/$1\$v\{\'$2\'\}/g;      $t{'A0'}=~s/(^|[^\"\'])([A-Za-z]\d+)/$1\$sheet_values\{\'$2\'\}/g;
     $t{'A0'}=~s/(^|[^\"\'])\[([^\]]+)\]/$1.&expandnamed($2)/ge;      $t{'A0'}=~s/(^|[^\"\'])\[([^\]]+)\]/$1.$self->expandnamed($2)/ge;
       # Put %t into the safe space
       %{$self->{'safe'}->varglob('t')}=%t;
 }  }
   
 sub calc {  
     %v=();  ###########################################
     &sett();  ###          Row output routines        ###
     my $notfinished=1;  ###########################################
     my $depth=0;  #
     while ($notfinished) {  # get_row: Produce output row n from sheet by calling the appropriate routine
  $notfinished=0;  #
         foreach (keys(%t)) {  sub get_row {
             my $old=$v{$_};      my $self = shift;
             $v{$_}=eval($t{$_});      my ($n) = @_;
     if ($@) {      my ($rowlabel,@rowdata);
  %v=();      if ($n eq '-') { 
                 return $@;          ($rowlabel,@rowdata) = $self->templaterow();
             }      } elsif ($self->{'type'} eq 'studentcalc') {
     if ($v{$_} ne $old) { $notfinished=1; }          ($rowlabel,@rowdata) = $self->outrowassess($n);
         }      } else {
         $depth++;          ($rowlabel,@rowdata) = $self->outrow($n);
         if ($depth>100) {  
     %v=();  
             return 'Maximum calculation depth exceeded';  
         }  
     }      }
     return '';      return ($rowlabel,@rowdata);
 }  }
   
 sub templaterow {  sub templaterow {
       my $self = shift;
     my @cols=();      my @cols=();
     $cols[0]='<b><font size=+1>Template</font></b>';      my $rowlabel = 'Template</td><td>&nbsp;';
     foreach ('A','B','C','D','E','F','G','H','I','J','K','L','M',      foreach my $n ('A','B','C','D','E','F','G','H','I','J','K','L','M',
      'N','O','P','Q','R','S','T','U','V','W','X','Y','Z',                     'N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
      'a','b','c','d','e','f','g','h','i','j','k','l','m',                     'a','b','c','d','e','f','g','h','i','j','k','l','m',
      'n','o','p','q','r','s','t','u','v','w','x','y','z') {                     'n','o','p','q','r','s','t','u','v','w','x','y','z') {
         my $fm=$f{'template_'.$_};          push(@cols,{ name    => 'template_'.$_,
         $fm=~s/[\'\"]/\&\#34;/g;                       formula => $self->formula('template_'.$n),
         $cols[$#cols+1]="'template_$_','$fm'".'___eq___'.$fm;                       value   => $self->value('template_'.$n) });
     }      }
     return @cols;      return ($rowlabel,@cols);
 }  }
   
 sub outrowassess {  sub outrowassess {
     my $n=shift;      my $self = shift;
       # $n is the current row number
       my ($n) = @_;
     my @cols=();      my @cols=();
       my $rowlabel='';
     if ($n) {      if ($n) {
        my ($usy,$ufn)=split(/\_\_\&\&\&\_\_/,$f{'A'.$n});          my ($usy,$ufn)=split(/__&&&\__/,$self->formula('A'.$n));
       if ($rl{$usy}) {          if (exists($self->{'rowlabel'}->{$usy})) {
        $cols[0]=$rl{$usy}.'<br>'.              # This is dumb, but we need the information when we output
                 '<select name="sel_'.$n.'" onChange="changesheet('.$n.              # the html version of the studentcalc spreadsheet for the
                 ')"><option name="default">Default</option>';              # links to the assesscalc sheets.
       } else { $cols[0]=''; }              $rowlabel = $self->{'rowlabel'}->{$usy}.':'.
        foreach (@os) {                  &Apache::lonnet::escape($ufn);
            $cols[0].='<option name="'.$_.'"';          } else { 
             if ($ufn eq $_) {              $rowlabel = '';
                $cols[0].=' selected';          }
             }      } elsif ($ENV{'request.role'} =~ /^st\./) {
             $cols[0].='>'.$_.'</option>';          $rowlabel = 'Summary</td><td>0';
        }  
        $cols[0].='</select>';  
     } else {      } else {
        $cols[0]='<b><font size=+1>Export</font></b>';          $rowlabel = 'Export</td><td>0';
     }      }
     foreach ('A','B','C','D','E','F','G','H','I','J','K','L','M',      foreach ('A','B','C','D','E','F','G','H','I','J','K','L','M',
      'N','O','P','Q','R','S','T','U','V','W','X','Y','Z',       'N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
      'a','b','c','d','e','f','g','h','i','j','k','l','m',       'a','b','c','d','e','f','g','h','i','j','k','l','m',
      'n','o','p','q','r','s','t','u','v','w','x','y','z') {       'n','o','p','q','r','s','t','u','v','w','x','y','z') {
         my $fm=$f{$_.$n};          push(@cols,{ name    => $_.$n,
         $fm=~s/[\'\"]/\&\#34;/g;                       formula => $self->formula($_.$n),
         push(@cols,"'$_$n','$fm'".'___eq___'.$v{$_.$n});                       value   => $self->value($_.$n)});
     }      }
     return @cols;      return ($rowlabel,@cols);
 }  }
   
 sub outrow {  sub outrow {
     my $n=shift;      my $self = shift;
       my ($n)=@_;
     my @cols=();      my @cols=();
       my $rowlabel;
     if ($n) {      if ($n) {
        $cols[0]=$rl{$f{'A'.$n}};          $rowlabel = $self->{'rowlabel'}->{$self->formula('A'.$n)};
     } else {      } else {
        $cols[0]='<b><font size=+1>Export</font></b>';          if ($self->{'type'} eq 'classcalc') {
               $rowlabel = 'Summary</td><td>0';
           } else {
               $rowlabel = 'Export</td><td>0';
           }
     }      }
     foreach ('A','B','C','D','E','F','G','H','I','J','K','L','M',      foreach ('A','B','C','D','E','F','G','H','I','J','K','L','M',
      'N','O','P','Q','R','S','T','U','V','W','X','Y','Z',       'N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
      'a','b','c','d','e','f','g','h','i','j','k','l','m',       'a','b','c','d','e','f','g','h','i','j','k','l','m',
      'n','o','p','q','r','s','t','u','v','w','x','y','z') {       'n','o','p','q','r','s','t','u','v','w','x','y','z') {
         my $fm=$f{$_.$n};          push(@cols,{ name    => $_.$n,
         $fm=~s/[\'\"]/\&\#34;/g;                       formula => $self->formula($_.$n),
         $cols[$#cols+1]="'$_$n','$fm'".'___eq___'.$v{$_.$n};                       value   => $self->value($_.$n)});
     }      }
     return @cols;      return ($rowlabel,@cols);
 }  
   
 sub exportrowa {  
     my @exportarray=();  
     foreach ('A','B','C','D','E','F','G','H','I','J','K','L','M',  
      'N','O','P','Q','R','S','T','U','V','W','X','Y','Z') {  
  $exportarray[$#exportarray+1]=$v{$_.'0'};  
     }   
     return @exportarray;  
 }  }
   
 # ------------------------------------------- End of "Inside of the safe space"  ########################################################
 ENDDEFS  ####         Spreadsheet calculation methods       #####
     $safeeval->reval($code);  ########################################################
     return $safeeval;  #
 }  # calcsheet: makes all the calls to compute the spreadsheet.
   #
 # ------------------------------------------------ Add or change formula values  
   
 sub setformulas {  
     my ($safeeval,%f)=@_;  
     %{$safeeval->varglob('f')}=%f;  
 }  
   
 # ------------------------------------------------ Add or change formula values  
   
 sub setconstants {  
     my ($safeeval,%c)=@_;  
     %{$safeeval->varglob('c')}=%c;  
 }  
   
 # --------------------------------------------- Set names of other spreadsheets  
   
 sub setothersheets {  
     my ($safeeval,@os)=@_;  
     @{$safeeval->varglob('os')}=@os;  
 }  
   
 # ------------------------------------------------ Add or change formula values  
   
 sub setrowlabels {  
     my ($safeeval,%rl)=@_;  
     %{$safeeval->varglob('rl')}=%rl;  
 }  
   
 # ------------------------------------------------------- Calculate spreadsheet  
   
 sub calcsheet {  sub calcsheet {
     my $safeeval=shift;      my $self = shift;
     $safeeval->reval('&calc();');      $self->sync_safe_space();
 }      $self->clear_errorlog();
       $self->sett();
 # ------------------------------------------------------------------ Get values      my $result =  $self->{'safe'}->reval('&calc();');
       %{$self->{'values'}} = %{$self->{'safe'}->varglob('sheet_values')};
 sub getvalues {  #    $self->logthis($self->get_errorlog());
     my $safeeval=shift;      return $result;
     return $safeeval->reval('%v');  }
 }  
   ##
 # ---------------------------------------------------------------- Get formulas  ## sync_safe_space:  Called by calcsheet to make sure all the data we 
   #  need to calculate is placed into the safe space
 sub getformulas {  ##
     my $safeeval=shift;  sub sync_safe_space {
     return %{$safeeval->varglob('f')};      my $self = shift;
 }      # Inside the safe space 'formulas' has a diabolical alter-ego named 'f'.
       %{$self->{'safe'}->varglob('f')}=%{$self->{'formulas'}};
 # -------------------------------------------------------------------- Get type      # 'constants' leads a peaceful hidden life of 'c'.
       %{$self->{'safe'}->varglob('c')}=%{$self->{'constants'}};
 sub gettype {      # 'othersheets' hides as 'os', a disguise few can penetrate.
     my $safeeval=shift;      @{$self->{'safe'}->varglob('os')}=@{$self->{'othersheets'}};
     return $safeeval->reval('$sheettype');  }
 }  
   ##
 # ------------------------------------------------------------------ Set maxrow  ## Retrieve the error log from the safe space (used for debugging)
   ##
 sub setmaxrow {  sub get_errorlog {
     my ($safeeval,$row)=@_;      my $self = shift;
     $safeeval->reval('$maxrow='.$row.';');      $self->{'errorlog'} = ${$self->{'safe'}->varglob('errorlog')};
 }      return $self->{'errorlog'};
   }
 # ------------------------------------------------------------------ Get maxrow  
   ##
 sub getmaxrow {  ## Clear the error log inside the safe space
     my $safeeval=shift;  ##
     return $safeeval->reval('$maxrow');  sub clear_errorlog {
 }      my $self = shift;
       ${$self->{'safe'}->varglob('errorlog')} = '';
 # ---------------------------------------------------------------- Set filename      $self->{'errorlog'} = '';
   
 sub setfilename {  
     my ($safeeval,$fn)=@_;  
     $safeeval->reval('$filename="'.$fn.'";');  
 }  
   
 # ---------------------------------------------------------------- Get filename  
   
 sub getfilename {  
     my $safeeval=shift;  
     return $safeeval->reval('$filename');  
 }  }
   
 # --------------------------------------------------------------- Get course ID  
   
 sub getcid {  ########################################################
     my $safeeval=shift;  #### Spreadsheet content retrieval/setting methods #####
     return $safeeval->reval('$cid');  ########################################################
 }  ##
   ## constants:  either set or get the constants
 # --------------------------------------------------------- Get course filename  ##
   ##
 sub getcfn {  sub constants {
     my $safeeval=shift;      my $self=shift;
     return $safeeval->reval('$cfn');      my ($constants) = @_;
 }      if (defined($constants)) {
           if (! ref($constants)) {
 # ----------------------------------------------------------- Get course number              my %tmp = @_;
               $constants = \%tmp;
 sub getcnum {          }
     my $safeeval=shift;          $self->{'constants'} = $constants;
     return $safeeval->reval('$cnum');          return;
 }      } else {
           return %{$self->{'constants'}};
 # ------------------------------------------------------------- Get course home      }
   
 sub getchome {  
     my $safeeval=shift;  
     return $safeeval->reval('$chome');  
 }  
   
 # ----------------------------------------------------------- Get course domain  
   
 sub getcdom {  
     my $safeeval=shift;  
     return $safeeval->reval('$cdom');  
 }  }
       
 # ---------------------------------------------------------- Get course section  ##
   ## formulas: either set or get the formulas
 sub getcsec {  ##
     my $safeeval=shift;  sub formulas {
     return $safeeval->reval('$csec');      my $self=shift;
       my ($formulas) = @_;
       if (defined($formulas)) {
           if (! ref($formulas)) {
               my %tmp = @_;
               $formulas = \%tmp;
           }
           $self->{'formulas'} = $formulas;
           $self->{'rows'} = [];
           $self->{'template_cells'} = [];
           return;
       } else {
           return %{$self->{'formulas'}};
       }
 }  }
   
 # --------------------------------------------------------------- Get user name  ##
   ## formulas_keys:  Return the keys to the formulas hash.
 sub getuname {  ##
     my $safeeval=shift;  sub formulas_keys {
     return $safeeval->reval('$uname');      my $self = shift;
       my @keys = keys(%{$self->{'formulas'}});
       return keys(%{$self->{'formulas'}});
   }
   
   ##
   ## formula:  Return the formula for a given cell in the spreadsheet
   ## returns '' if the cell does not have a formula or does not exist
   ##
   sub formula {
       my $self = shift;
       my $cell = shift;
       if (defined($cell) && exists($self->{'formulas'}->{$cell})) {
           return $self->{'formulas'}->{$cell};
       }
       return '';
 }  }
   
 # ------------------------------------------------------------- Get user domain  ##
   ## logthis: write the input to lonnet.log
 sub getudom {  ##
     my $safeeval=shift;  sub logthis {
     return $safeeval->reval('$udom');      my $self = shift;
       my $message = shift;
       &Apache::lonnet::logthis($self->{'type'}.':'.
                                $self->{'uname'}.':'.$self->{'udom'}.':'.
                                $message);
       return;
   }
   
   ##
   ## dump_formulas_to_log: makes lonnet.log huge...
   ##
   sub dump_formulas_to_log {
       my $self =shift;
       $self->logthis("Spreadsheet formulas");
       $self->logthis("--------------------------------------------------------");
       while (my ($cell, $formula) = each(%{$self->{'formulas'}})) {
           $self->logthis('    '.$cell.' = '.$formula);
       }
       $self->logthis("--------------------------------------------------------");}
   
   ##
   ## value: returns the computed value of a particular cell
   ##
   sub value {
       my $self = shift;
       my $cell = shift;
       if (defined($cell) && exists($self->{'values'}->{$cell})) {
           return $self->{'values'}->{$cell};
       }
       return '';
 }  }
   
 # --------------------------------------------------------------- Get user home  ##
   ## dump_values_to_log: makes lonnet.log huge...
 sub getuhome {  ##
     my $safeeval=shift;  sub dump_values_to_log {
     return $safeeval->reval('$uhome');      my $self =shift;
       $self->logthis("Spreadsheet Values");
       $self->logthis("--------------------------------------------------------");
       while (my ($cell, $value) = each(%{$self->{'values'}})) {
           $self->logthis('    '.$cell.' = '.$value);
       }
       $self->logthis("--------------------------------------------------------");}
   
   ##
   ## Yet another debugging function
   ##
   sub dump_hash_to_log {
       my $self= shift();
       my %tmp = @_;
       if (@_<2) {
           %tmp = %{$_[0]};
       }
       $self->logthis('---------------------------- (entries end with ":"');
       while (my ($key,$val) = each (%tmp)) {
           $self->logthis($key.' = '.$val.':');
       }
       $self->logthis('---------------------------- (entries end with ":"');
   }
   
   ################################
   ##      Helper functions      ##
   ################################
   ##
   ## rebuild_stats: rebuilds the rows and template_cells arrays
   ##
   sub rebuild_stats {
       my $self = shift;
       $self->{'rows'}=[];
       $self->{'template_cells'}=[];
       foreach my $cell($self->formulas_keys()) {
           push(@{$self->{'rows'}},$1) if ($cell =~ /^A(\d+)/ && $1 != 0);
           push(@{$self->{'template_cells'}},$1) if ($cell =~ /^template_(\w+)/);
       }
       return;
   }
   
   ##
   ## template_cells returns a list of the cells defined in the template row
   ##
   sub template_cells {
       my $self = shift;
       $self->rebuild_stats() if (!@{$self->{'template_cells'}});
       return @{$self->{'template_cells'}};
   }
   
   ##
   ## rows returns a list of the names of cells defined in the A column
   ##
   sub rows {
       my $self = shift;
       $self->rebuild_stats() if (!@{$self->{'rows'}});
       return @{$self->{'rows'}};
   }
   
   ##
   ## Sigh.... 
   ##
   sub setothersheets {
       my $self = shift;
       my @othersheets = @_;
       $self->{'othersheets'} = \@othersheets;
   }
   
   ##
   ## rowlabels: get or set the rowlabels hash from the spreadsheet.
   ##
   sub rowlabels {
       my $self = shift;
       my ($rowlabel) = @_;
       if (defined($rowlabel)) {
           if (! ref($rowlabel)) {
               my %tmp = @_;
               $rowlabel = \%tmp;
           }
           $self->{'rowlabel'}=$rowlabel;
           return;
       } else {
           return %{$self->{'rowlabel'}} if (defined($self->{'rowlabel'}));
       }
 }  }
   
 # -------------------------------------------------------------------- Get symb  ##
   ## gettitle: returns a title for the spreadsheet.
 sub getusymb {  ##
     my $safeeval=shift;  sub gettitle {
     return $safeeval->reval('$usymb');      my $self = shift;
       if ($self->{'type'} eq 'classcalc') {
           return $self->{'coursedesc'};
       } elsif ($self->{'type'} eq 'studentcalc') {
           return 'Grades for '.$self->{'uname'}.'@'.$self->{'udom'};
       } elsif ($self->{'type'} eq 'assesscalc') {
           if (($self->{'usymb'} eq '_feedback') ||
               ($self->{'usymb'} eq '_evaluation') ||
               ($self->{'usymb'} eq '_discussion') ||
               ($self->{'usymb'} eq '_tutoring')) {
               my $title = $self->{'usymb'};
               $title =~ s/^_//;
               $title = ucfirst($title);
               return $title;
           }
           return if (! defined($self->{'mapid'}) || 
                      $self->{'mapid'} !~ /^\d+$/);
           my $mapid = $self->{'mapid'};
           return if (! defined($self->{'resid'}) || 
                      $self->{'resid'} !~ /^\d+$/);
           my $resid = $self->{'resid'};
           my %course_db;
           tie(%course_db,'GDBM_File',$self->{'coursefilename'}.'.db',
               &GDBM_READER(),0640);
           return if (! tied(%course_db));
           my $key = 'title_'.$mapid.'.'.$resid;
           my $title = '';
           if (exists($course_db{$key})) {
               $title = $course_db{$key};
           } else {
               $title = $self->{'usymb'};
           }
           untie (%course_db);
           return $title;
       }
 }  }
   
 # ------------------------------------------------------------- Export of A-row  #
   # Export of A-row
   #
 sub exportdata {  sub exportdata {
     my $safeeval=shift;      my $self=shift;
     return $safeeval->reval('&exportrowa()');      my @exportarray=();
       foreach ('A','B','C','D','E','F','G','H','I','J','K','L','M',
        'N','O','P','Q','R','S','T','U','V','W','X','Y','Z') {
           push(@exportarray,$self->value($_.'0'));
       } 
       return @exportarray;
 }  }
   
   ##
 # ========================================================== End of Spreadsheet  ## update_student_sheet: experimental function
 # =============================================================================  ##
   sub update_student_sheet{
       my $self = shift;
       my ($r,$c) = @_;
       # Load in the studentcalc sheet
       $self->readsheet('default_studentcalc');
       # Determine the structure (contained assessments, etc) of the sheet
       $self->updatesheet();
       # Load in the cached sheets for this student
       $self->cachedssheets();
       # Load in the (possibly cached) data from the assessment sheets        
       $self->loadstudent($r,$c);
       # Compute the sheet
       $self->calcsheet();
   }
   
 #  #
 # Procedures for screen output  # sort_indicies: returns an ordered list of the rows of the spreadsheet
 #  #
 # --------------------------------------------- Produce output row n from sheet  sub sort_indicies {
       my $self = shift;
 sub rown {      my @sortidx=();
     my ($safeeval,$n)=@_;      #
     my $defaultbg;      if ($self->{'type'} eq 'classcalc') {
     my $rowdata='';          my @sortby=(undef);
     my $dataflag=0;          # Skip row 0
     unless ($n eq '-') {          for (my $row=1;$row<=$self->{'maxrow'};$row++) {
        $defaultbg=((($n-1)/5)==int(($n-1)/5))?'#E0E0':'#FFFF';              my (undef,$sname,$sdom,$fullname,$section,$id) = 
     } else {                  split(':',$self->{'rowlabel'}->{$self->formula('A'.$row)});
        $defaultbg='#E0FF';              push (@sortby, lc($fullname));
     }              push (@sortidx, $row);
     unless ($ENV{'form.showcsv'}) {          }
        $rowdata.="\n<tr><td><b><font size=+1>$n</font></b></td>";          @sortidx = sort { $sortby[$a] cmp $sortby[$b]; } @sortidx;
     } else {      } elsif ($self->{'type'} eq 'studentcalc') {
        $rowdata.="\n".'"'.$n.'"';          my @sortby1=(undef);
           my @sortby2=(undef);
           # Skip row 0
           for (my $row=1;$row<=$self->{'maxrow'};$row++) {
               my ($key,undef) = split(/__&&&\__/,$self->formula('A'.$row));
               my $rowlabel = $self->{'rowlabel'}->{$key};
               my (undef,$symb,$mapid,$resid,$title,$ufn) = 
                   split(':',$rowlabel);
               $ufn   = &Apache::lonnet::unescape($ufn);
               $symb  = &Apache::lonnet::unescape($symb);
               $title = &Apache::lonnet::unescape($title);
               my ($sequence) = ($symb =~ /\/([^\/]*\.sequence)/);
               if ($sequence eq '') {
                   $sequence = $symb;
               }
               push (@sortby1, $sequence);
               push (@sortby2, $title);
               push (@sortidx, $row);
           }
           @sortidx = sort { $sortby1[$a] cmp $sortby1[$b] || 
                                 $sortby2[$a] cmp $sortby2[$b] } @sortidx;
       } else {
           my @sortby=(undef);
           # Skip row 0
           $self->sync_safe_space();
           for (my $row=1;$row<=$self->{'maxrow'};$row++) {
               push (@sortby, $self->{'safe'}->reval('$f{"A'.$row.'"}'));
               push (@sortidx, $row);
           }
           @sortidx = sort { $sortby[$a] cmp $sortby[$b]; } @sortidx;
       }
       return @sortidx;
   }
   
   #############################################################
   ###                                                       ###
   ###              Spreadsheet Output Routines              ###
   ###                                                       ###
   #############################################################
   
   ############################################
   ##         HTML output routines           ##
   ############################################
   sub html_editable_cell {
       my ($cell,$bgcolor) = @_;
       my $result;
       my ($name,$formula,$value);
       if (defined($cell)) {
           $name    = $cell->{'name'};
           $formula = $cell->{'formula'};
           $value   = $cell->{'value'};
       }
       $name    = '' if (! defined($name));
       $formula = '' if (! defined($formula));
       if (! defined($value)) {
           $value = '<font color="'.$bgcolor.'">#</font>';
           if ($formula ne '') {
               $value = '<i>undefined value</i>';
           }
       } elsif ($value =~ /^\s*$/ ) {
           $value = '<font color="'.$bgcolor.'">#</font>';
       } else {
           $value = &HTML::Entities::encode($value) if ($value !~/&nbsp;/);
       }
       # Make the formula safe for outputting
       $formula =~ s/\'/\"/g;
       # The formula will be parsed by the browser *twice* before being 
       # displayed to the user for editing.
       $formula = &HTML::Entities::encode(&HTML::Entities::encode($formula));
       # Escape newlines so they make it into the edit window
       $formula =~ s/\n/\\n/gs;
       # Glue everything together
       $result .= "<a href=\"javascript:celledit(\'".
           $name."','".$formula."');\">".$value."</a>";
       return $result;
   }
   
   sub html_uneditable_cell {
       my ($cell,$bgcolor) = @_;
       my $value = (defined($cell) ? $cell->{'value'} : '');
       $value = &HTML::Entities::encode($value) if ($value !~/&nbsp;/);
       return '&nbsp;'.$value.'&nbsp;';
   }
   
   sub outsheet_html  {
       my $self = shift;
       my ($r) = @_;
       my ($num_uneditable,$realm,$row_type);
       my $requester_is_student = ($ENV{'request.role'} =~ /^st\./);
       if ($self->{'type'} eq 'assesscalc') {
           $num_uneditable = 1;
           $realm = 'Assessment';
           $row_type = 'Item';
       } elsif ($self->{'type'} eq 'studentcalc') {
           $num_uneditable = 26;
           $realm = 'User';
           $row_type = 'Assessment';
       } elsif ($self->{'type'} eq 'classcalc') {
           $num_uneditable = 26;
           $realm = 'Course';
           $row_type = 'Student';
       } else {
           return;  # error
       }
       ####################################
       # Print out header table
       ####################################
       my $num_left = 52-$num_uneditable;
       my $tabledata =<<"END";
   <table border="2">
   <tr>
     <th colspan="2" rowspan="2"><font size="+2">$realm</font></th>
     <td bgcolor="#FFDDDD" colspan="$num_uneditable">
         <b><font size="+1">Import</font></b></td>
     <td colspan="$num_left">
         <b><font size="+1">Calculations</font></b></td>
   </tr><tr>
   END
       my $label_num = 0;
       foreach (split(//,'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz')){
           if ($label_num<$num_uneditable) { 
               $tabledata.='<td bgcolor="#FFDDDD">';
           } else {
               $tabledata.='<td>';
           }
           $tabledata.="<b><font size=+1>$_</font></b></td>";
           $label_num++;
     }      }
     my $showf=0;      $tabledata.="</tr>\n";
     my $proc;      $r->print($tabledata);
     my $maxred;      ####################################
     my $sheettype=&gettype($safeeval);      # Print out template row
     if ($sheettype eq 'studentcalc') {      ####################################
         $proc='&outrowassess';      my ($num_cols_output,$row_html,$rowlabel,@rowdata);
         $maxred=26;      
     } else {      if (! $requester_is_student) {
         $proc='&outrow';          ($rowlabel,@rowdata) = $self->get_row('-');
           $row_html = '<tr><td>'.$self->format_html_rowlabel($rowlabel).'</td>';
           $num_cols_output = 0;
           foreach my $cell (@rowdata) {
               if ($requester_is_student || 
                   $num_cols_output++ < $num_uneditable) {
                   $row_html .= '<td bgcolor="#FFDDDD">';
                   $row_html .= &html_uneditable_cell($cell,'#FFDDDD');
               } else {
                   $row_html .= '<td bgcolor="#EOFFDD">';
                   $row_html .= &html_editable_cell($cell,'#E0FFDD');
               }
               $row_html .= '</td>';
           }
           $row_html.= "</tr>\n";
           $r->print($row_html);
     }      }
     if ($sheettype eq 'assesscalc') {      ####################################
         $maxred=1;      # Print out summary/export row
     } else {      ####################################
         $maxred=26;      ($rowlabel,@rowdata) = $self->get_row('0');
       $row_html = '<tr><td>'.$self->format_html_rowlabel($rowlabel).'</td>';
       $num_cols_output = 0;
       foreach my $cell (@rowdata) {
           if ($num_cols_output++ < 26 && ! $requester_is_student) {
               $row_html .= '<td bgcolor="#CCCCFF">';
               $row_html .= &html_editable_cell($cell,'#CCCCFF');
           } else {
               $row_html .= '<td bgcolor="#DDCCFF">';
               $row_html .= &html_uneditable_cell($cell,'#CCCCFF');
           }
           $row_html .= '</td>';
     }      }
     if ($n eq '-') { $proc='&templaterow'; $n=-1; $dataflag=1; }      $row_html.= "</tr>\n";
     foreach ($safeeval->reval($proc.'('.$n.')')) {      $r->print($row_html);
        my $bgcolor=$defaultbg.((($showf-1)/5==int(($showf-1)/5))?'99':'DD');      $r->print('</table>');
        my ($fm,$vl)=split(/\_\_\_eq\_\_\_/,$_);      ####################################
        if ((($vl ne '') || ($vl eq '0')) &&      # Prepare to output rows
            (($showf==1) || ($sheettype ne 'studentcalc'))) { $dataflag=1; }      ####################################
        if ($showf==0) { $vl=$_; }      my @Rows = $self->sort_indicies();
       unless ($ENV{'form.showcsv'}) {      #
        if ($showf<=$maxred) { $bgcolor='#FFDDDD'; }      # Loop through the rows and output them one at a time
        if (($n==0) && ($showf<=26)) { $bgcolor='#CCCCFF'; }       my $rows_output=0;
        if (($showf>$maxred) || ((!$n) && ($showf>0))) {      foreach my $rownum (@Rows) {
    if ($vl eq '') {          my ($rowlabel,@rowdata) = $self->get_row($rownum);
        $vl='<font size=+2 color='.$bgcolor.'>&#35;</font>';          next if ($rowlabel =~ /^\s*$/);
            }          next if (($self->{'type'} eq 'assesscalc') && 
            $rowdata.=                   (! $ENV{'form.showall'})                &&
        '<td bgcolor='.$bgcolor.'><a href="javascript:celledit('.$fm.');">'.$vl.                   ($rowdata[0]->{'value'} =~ /^\s*$/));
        '</a></td>';          if (! $ENV{'form.showall'} &&
        } else {              $self->{'type'} =~ /^(studentcalc|classcalc)$/) {
            $rowdata.='<td bgcolor='.$bgcolor.'>&nbsp;'.$vl.'&nbsp;</td>';              my $row_is_empty = 1;
        }              foreach my $cell (@rowdata) {
       } else {                  if ($cell->{'value'} !~  /^\s*$/) {
   $rowdata.=',"'.$vl.'"';                      $row_is_empty = 0;
       }                      last;
        $showf++;                  }
     }  # End of foreach($safeval...)              }
     if ($ENV{'form.showall'} || ($dataflag)) {              next if ($row_is_empty);
        return $rowdata.($ENV{'form.showcsv'}?'':'</tr>');          }
     } else {          #
        return '';          my $defaultbg='#E0FF';
           #
           my $row_html ="\n".'<tr><td><b><font size=+1>'.$rownum.
               '</font></b></td>';
           #
           if ($self->{'type'} eq 'classcalc') {
               $row_html.='<td>'.$self->format_html_rowlabel($rowlabel).'</td>';
               # Output links for each student?
               # Nope, that is already done for us in format_html_rowlabel 
               # (for now)
           } elsif ($self->{'type'} eq 'studentcalc') {
               my $ufn = (split(/:/,$rowlabel))[5];
               $row_html.='<td>'.$self->format_html_rowlabel($rowlabel);
               $row_html.= '<br>'.
                   '<select name="sel_'.$rownum.'" '.
                       'onChange="changesheet('.$rownum.')">'.
                           '<option name="default">Default</option>';
               foreach (@{$self->{'othersheets'}}) {
                   $row_html.='<option name="'.$_.'"';
                   if ($ufn eq $_) {
                       $row_html.=' selected';
                   }
                   $row_html.='>'.$_.'</option>';
               }
               $row_html.='</select></td>';
           } elsif ($self->{'type'} eq 'assesscalc') {
               $row_html.='<td>'.$self->format_html_rowlabel($rowlabel).'</td>';
           }
           #
           my $shown_cells = 0;
           foreach my $cell (@rowdata) {
               my $value    = $cell->{'value'};
               my $formula  = $cell->{'formula'};
               my $cellname = $cell->{'name'};
               #
               my $bgcolor;
               if ($shown_cells && ($shown_cells/5 == int($shown_cells/5))) {
                   $bgcolor = $defaultbg.'99';
               } else {
                   $bgcolor = $defaultbg.'DD';
               }
               $bgcolor='#FFDDDD' if ($shown_cells < $num_uneditable);
               #
               $row_html.='<td bgcolor='.$bgcolor.'>';
               if ($requester_is_student || $shown_cells < $num_uneditable) {
                   $row_html .= &html_uneditable_cell($cell,$bgcolor);
               } else {
                   $row_html .= &html_editable_cell($cell,$bgcolor);
               }
               $row_html.='</td>';
               $shown_cells++;
           }
           if ($row_html) {
               if ($rows_output % 25 == 0) {
                   $r->print("</table>\n<br>\n");
                   $r->rflush();
                   $r->print('<table border=2>'.
                             '<tr><td>&nbsp;<td>'.$row_type.'</td>'.
                             '<td>'.
                             join('</td><td>',
                                  (split(//,'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.
                                         'abcdefghijklmnopqrstuvwxyz'))).
                             "</td></tr>\n");
               }
               $rows_output++;
               $r->print($row_html);
           }
     }      }
       #
       $r->print('</table>');
       #
       # Debugging code (be sure to uncomment errorlog code in safe space):
       #
       # $r->print("\n<pre>");
       # $r->print(&geterrorlog($self));
       # $r->print("\n</pre>");
       return 1;
 }  }
   
 # ------------------------------------------------------------- Print out sheet  ############################################
   ##         csv output routines            ##
   ############################################
   sub outsheet_csv   {
       my $self = shift;
       my ($r) = @_;
       my $csvdata = '';
       my @Values;
       ####################################
       # Prepare to output rows
       ####################################
       my @Rows = $self->sort_indicies();
       #
       # Loop through the rows and output them one at a time
       my $rows_output=0;
       foreach my $rownum (@Rows) {
           my ($rowlabel,@rowdata) = $self->get_row($rownum);
           next if ($rowlabel =~ /^\s*$/);
           push (@Values,$self->format_csv_rowlabel($rowlabel));
           foreach my $cell (@rowdata) {
               push (@Values,'"'.$cell->{'value'}.'"');
           }
           $csvdata.= join(',',@Values)."\n";
           @Values = ();
       }
       #
       # Write the CSV data to a file and serve up a link
       #
       my $filename = '/prtspool/'.
           $ENV{'user.name'}.'_'.$ENV{'user.domain'}.'_'.
           time.'_'.rand(1000000000).'.csv';
       my $file;
       unless ($file = Apache::File->new('>'.'/home/httpd'.$filename)) {
           $r->log_error("Couldn't open $filename for output $!");
           $r->print("Problems occured in writing the csv file.  ".
                     "This error has been logged.  ".
                     "Please alert your LON-CAPA administrator.");
           $r->print("<pre>\n".$csvdata."</pre>\n");
           return 0;
       }
       print $file $csvdata;
       close($file);
       $r->print('<br /><br />'.
                 '<a href="'.$filename.'">Your CSV spreadsheet.</a>'."\n");
       #
       return 1;
   }
   
 sub outsheet {  ############################################
     my ($r,$safeeval)=@_;  ##        Excel output routines           ##
     my $maxred;  ############################################
     my $realm;  sub outsheet_recursive_excel {
     if (&gettype($safeeval) eq 'assesscalc') {      my $self = shift;
         $maxred=1;      my ($r) = @_;
         $realm='Assessment';      my $c = $r->connection;
     } elsif (&gettype($safeeval) eq 'studentcalc') {      return undef if ($self->{'type'} ne 'classcalc');
         $maxred=26;      my ($workbook,$filename) = $self->create_excel_spreadsheet($r);
         $realm='User';      return undef if (! defined($workbook));
     } else {      #
         $maxred=26;      # Create main worksheet
         $realm='Course';      my $main_worksheet = $workbook->addworksheet('main');
     }      #
     my $maxyellow=52-$maxred;      # Figure out who the students are
     my $tabledata;      my %f=$self->formulas();
     unless ($ENV{'form.showcsv'}) {      my $count = 0;
        $tabledata=      $r->print(<<END);
         '<table border=2><tr><th colspan=2 rowspan=2><font size=+2>'.  <p>
                   $realm.'</font></th>'.  Compiling Excel Workbook with a worksheet for each student.
                   '<td bgcolor=#FFDDDD colspan='.$maxred.  </p><p>
                   '><b><font size=+1>Import</font></b></td>'.  This operation may take longer than a complete recalculation of the
                   '<td colspan='.$maxyellow.  spreadsheet. 
   '><b><font size=+1>Calculations</font></b></td></tr><tr>';  </p><p>
     my $showf=0;  To abort this operation, hit the stop button on your browser.
     foreach ('A','B','C','D','E','F','G','H','I','J','K','L','M',  </p><p>
      'N','O','P','Q','R','S','T','U','V','W','X','Y','Z',  A link to the spreadsheet will be available at the end of this process.
      'a','b','c','d','e','f','g','h','i','j','k','l','m',  </p>
      'n','o','p','q','r','s','t','u','v','w','x','y','z') {  <p>
         $showf++;  END
         if ($showf<=$maxred) {       $r->rflush();
            $tabledata.='<td bgcolor="#FFDDDD">';       my $starttime = time;
         } else {      foreach my $rownum ($self->sort_indicies()) {
            $tabledata.='<td>';          $count++;
           my ($sname,$sdom) = split(':',$f{'A'.$rownum});
           my $student_excel_worksheet=$workbook->addworksheet($sname.'@'.$sdom);
           # Create a new spreadsheet
           my $studentsheet = &Apache::lonspreadsheet::Spreadsheet->new
                                      ($sname,$sdom,'studentcalc',undef);
           # Read in the spreadsheet definition
           $studentsheet->update_student_sheet($r,$c);
           # Stuff the sheet into excel
           $studentsheet->export_sheet_as_excel($student_excel_worksheet);
           my $totaltime = int((time - $starttime) / $count * $self->{'maxrow'});
           my $timeleft = int((time - $starttime) / $count * ($self->{'maxrow'} - $count));
           if ($count % 5 == 0) {
               $r->print($count.' students completed.'.
                         '  Time remaining: '.$timeleft.' sec. '.
                         '  Estimated total time: '.$totaltime." sec <br />\n");
               $r->rflush();
         }          }
         $tabledata.="<b><font size=+1>$_</font></b></td>";          if(defined($c) && ($c->aborted())) {
               last;
           }
       }
       #
       if(! $c->aborted() ) {
           $r->print('All students spreadsheets completed!<br />');
           $r->rflush();
           #
           # &export_sheet_as_excel fills $worksheet with the data from $sheet
           $self->export_sheet_as_excel($main_worksheet);
           #
           $workbook->close();
           # Okay, the spreadsheet is taken care of, so give the user a link.
           $r->print('<br /><br />'.
                     '<a href="'.$filename.'">Your Excel spreadsheet.</a>'."\n");
       } else {
           $workbook->close();  # Not sure how necessary this is.
           #unlink('/home/httpd'.$filename); # No need to keep this around?
       }
       return 1;
   }
   
   sub outsheet_excel {
       my $self = shift;
       my ($r) = @_;
       my ($workbook,$filename) = $self->create_excel_spreadsheet($r);
       return undef if (! defined($workbook));
       my $sheetname;
       if ($self->{'type'} eq 'classcalc') {
           $sheetname = 'Main';
       } elsif ($self->{'type'} eq 'studentcalc') {
           $sheetname = $self->{'uname'}.'@'.$self->{'udom'};
       } elsif ($self->{'type'} eq 'assesscalc') {
           $sheetname = $self->{'uname'}.'@'.$self->{'udom'}.' assessment';
       }
       my $worksheet = $workbook->addworksheet($sheetname);
       #
       # &export_sheet_as_excel fills $worksheet with the data from $sheet
       $self->export_sheet_as_excel($worksheet);
       #
       $workbook->close();
       # Okay, the spreadsheet is taken care of, so give the user a link.
       $r->print('<br /><br />'.
                 '<a href="'.$filename.'">Your Excel spreadsheet.</a>'."\n");
       return 1;
   }
   
   sub create_excel_spreadsheet {
       my $self = shift;
       my ($r) = @_;
       my $filename = '/prtspool/'.
           $ENV{'user.name'}.'_'.$ENV{'user.domain'}.'_'.
           time.'_'.rand(1000000000).'.xls';
       my $workbook  = Spreadsheet::WriteExcel->new('/home/httpd'.$filename);
       if (! defined($workbook)) {
           $r->log_error("Error creating excel spreadsheet $filename: $!");
           $r->print("Problems creating new Excel file.  ".
                     "This error has been logged.  ".
                     "Please alert your LON-CAPA administrator");
           return undef;
     }      }
     $tabledata.='</tr>'.&rown($safeeval,'-').&rown($safeeval,0);      #
    } else { $tabledata='<pre>'; }      # The excel spreadsheet stores temporary data in files, then put them
       # together.  If needed we should be able to disable this (memory only).
       # The temporary directory must be specified before calling 'addworksheet'.
       # File::Temp is used to determine the temporary directory.
       $workbook->set_tempdir('/home/httpd/perl/tmp');
       #
       # Determine the name to give the worksheet
       return ($workbook,$filename);
   }
   
     $r->print($tabledata);  sub export_sheet_as_excel {
       my $self = shift;
       my $worksheet = shift;
       #
       my $rows_output = 0;
       my $cols_output = 0;
       ####################################
       #    Write an identifying row      #
       ####################################
       my @Headerinfo = ($self->{'coursedesc'});
       my $title = $self->gettitle();
       $cols_output = 0;    
       if (defined($title)) {
           $worksheet->write($rows_output++,$cols_output++,$title);
       }
       ####################################
       #   Write the summary/export row   #
       ####################################
       my ($rowlabel,@rowdata) = &get_row($self,'0');
       my $label = &format_excel_rowlabel($self,$rowlabel);
       $cols_output = 0;
       $worksheet->write($rows_output,$cols_output++,$label);
       foreach my $cell (@rowdata) {
           $worksheet->write($rows_output,$cols_output++,$cell->{'value'});
       }
       $rows_output+= 2;   # Skip a row, just for fun
       ####################################
       # Prepare to output rows
       ####################################
       my @Rows = &sort_indicies($self);
       #
       # Loop through the rows and output them one at a time
       foreach my $rownum (@Rows) {
           my ($rowlabel,@rowdata) = &get_row($self,$rownum);
           next if ($rowlabel =~ /^[\s]*$/);
           $cols_output = 0;
           my $label = &format_excel_rowlabel($self,$rowlabel);
           if ( ! $ENV{'form.showall'} &&
                $self->{'type'} =~ /^(studentcalc|classcalc)$/) {
               my $row_is_empty = 1;
               foreach my $cell (@rowdata) {
                   if ($cell->{'value'} !~  /^\s*$/) {
                       $row_is_empty = 0;
                       last;
                   }
               }
               next if ($row_is_empty);
           }
           $worksheet->write($rows_output,$cols_output++,$rownum);
           $worksheet->write($rows_output,$cols_output++,$label);
           if (ref($label)) {
               $cols_output = (scalar(@$label));
           }
           foreach my $cell (@rowdata) {
               $worksheet->write($rows_output,$cols_output++,$cell->{'value'});
           }
           $rows_output++;
       }
       return;
   }
   
     my $row;  ############################################
     my $maxrow=&getmaxrow($safeeval);  ##          XML output routines           ##
   ############################################
   sub outsheet_xml   {
       my $self = shift;
       my ($r) = @_;
       ## Someday XML
       ## Will be rendered for the user
       ## But not on this day
   }
   
     my @sortby=();  ##
     my @sortidx=();  ## Outsheet - calls other outsheet_* functions
     for ($row=1;$row<=$maxrow;$row++) {  ##
        $sortby[$row-1]=$safeeval->reval('$f{"A'.$row.'"}');  sub outsheet {
        $sortidx[$row-1]=$row-1;      my $self = shift;
     }      my ($r)=@_;
     @sortidx=sort { $sortby[$a] cmp $sortby[$b]; } @sortidx;      if (! exists($ENV{'form.output'})) {
           $ENV{'form.output'} = 'HTML';
         my $what='Student';      }
         if (&gettype($safeeval) eq 'assesscalc') {      if (lc($ENV{'form.output'}) eq 'csv') {
     $what='Item';          $self->outsheet_csv($r);
  } elsif (&gettype($safeeval) eq 'studentcalc') {      } elsif (lc($ENV{'form.output'}) eq 'excel') {
             $what='Assessment';          $self->outsheet_excel($r);
         }      } elsif (lc($ENV{'form.output'}) eq 'recursive excel') {
           $self->outsheet_recursive_excel($r);
     my $n=0;  #    } elsif (lc($ENV{'form.output'}) eq 'xml' ) {
     for ($row=0;$row<$maxrow;$row++) {  #        $self->outsheet_xml($r);
      my $thisrow=&rown($safeeval,$sortidx[$row]+1);      } else {
      if ($thisrow) {          $self->outsheet_html($r);
        if (($n/25==int($n/25)) && (!$ENV{'form.showcsv'})) {  
  $r->print("</table>\n<br>\n");  
         $r->rflush();  
         $r->print('<table border=2><tr><td>&nbsp;<td>'.$what.'</td>');  
         foreach ('A','B','C','D','E','F','G','H','I','J','K','L','M',  
  'N','O','P','Q','R','S','T','U','V','W','X','Y','Z',  
  'a','b','c','d','e','f','g','h','i','j','k','l','m',  
  'n','o','p','q','r','s','t','u','v','w','x','y','z') {  
            $r->print('<td>'.$_.'</td>');  
         }  
         $r->print('</tr>');  
        }  
        $n++;  
        $r->print($thisrow);  
       }  
     }      }
     $r->print($ENV{'form.showcsv'}?'</pre>':'</table>');  
 }  }
   
 #  #
 # ----------------------------------------------- Read list of available sheets  # othersheets: Returns the list of other spreadsheets available 
 #   #
 sub othersheets {  sub othersheets {
     my ($safeeval,$stype)=@_;      my $self = shift;
       my ($stype)=@_;
       $stype = $self->{'type'} if (! defined($stype));
     #      #
     my $cnum=&getcnum($safeeval);      my $cnum  = $self->{'cnum'};
     my $cdom=&getcdom($safeeval);      my $cdom  = $self->{'cdom'};
     my $chome=&getchome($safeeval);      my $chome = $self->{'chome'};
     #      #
     my @alternatives=();      my @alternatives=();
     my %results=&Apache::lonnet::dump($stype.'_spreadsheets',$cdom,$cnum);      my %results=&Apache::lonnet::dump($stype.'_spreadsheets',$cdom,$cnum);
Line 1260  sub othersheets { Line 2617  sub othersheets {
     return @alternatives;       return @alternatives; 
 }  }
   
   
 #  #
 # -------------------------------------- Parse a spreadsheet  # Parse a spreadsheet
 #   # 
 sub parse_sheet {  sub parse_sheet {
     # $sheetxml is a scalar reference or a scalar      # $sheetxml is a scalar reference or a scalar
Line 1289  sub parse_sheet { Line 2645  sub parse_sheet {
     return \%f;      return \%f;
 }  }
   
 #  
 # -------------------------------------- Read spreadsheet formulas for a course  
 #  
   
 sub readsheet {  sub readsheet {
   my ($safeeval,$fn)=@_;      my $self = shift;
   my $stype=&gettype($safeeval);      my ($fn)=@_;
   my $cnum=&getcnum($safeeval);      #
   my $cdom=&getcdom($safeeval);      my $stype = $self->{'type'};
   my $chome=&getchome($safeeval);      my $cnum  = $self->{'cnum'};
       my $cdom  = $self->{'cdom'};
   if (! defined($fn)) {      my $chome = $self->{'chome'};
       # There is no filename. Look for defaults in course and global, cache      #
       unless ($fn=$defaultsheets{$cnum.'_'.$cdom.'_'.$stype}) {      if (! defined($fn)) {
           my %tmphash = &Apache::lonnet::get('environment',          # There is no filename. Look for defaults in course and global, cache
                                              ['spreadsheet_default_'.$stype],          unless ($fn=$defaultsheets{$cnum.'_'.$cdom.'_'.$stype}) {
                                              $cdom,$cnum);              my %tmphash = &Apache::lonnet::get('environment',
           my ($tmp) = keys(%tmphash);                                                 ['spreadsheet_default_'.$stype],
           if ($tmp =~ /^(con_lost|error|no_such_host)/i) {                                                 $cdom,$cnum);
               $fn = 'default_'.$stype;              my ($tmp) = keys(%tmphash);
           } else {              if ($tmp =~ /^(con_lost|error|no_such_host)/i) {
               $fn = $tmphash{'spreadsheet_default_'.$stype};                  $fn = 'default_'.$stype;
           }               } else {
           unless (($fn) && ($fn!~/^error\:/)) {                  $fn = $tmphash{'spreadsheet_default_'.$stype};
       $fn='default_'.$stype;              } 
           }              unless (($fn) && ($fn!~/^error\:/)) {
           $defaultsheets{$cnum.'_'.$cdom.'_'.$stype}=$fn;                   $fn='default_'.$stype;
       }              }
   }              $defaultsheets{$cnum.'_'.$cdom.'_'.$stype}=$fn; 
           }
 # ---------------------------------------------------------- fn now has a value      }
       # $fn now has a value
   &setfilename($safeeval,$fn);      $self->{'filename'} = $fn;
       # see if sheet is cached
 # ------------------------------------------------------ see if sheet is cached      if (exists($spreadsheets{$cnum.'_'.$cdom.'_'.$stype.'_'.$fn})) {
   my $fstring='';          
   if ($fstring=$spreadsheets{$cnum.'_'.$cdom.'_'.$stype.'_'.$fn}) {          my %tmp = split(/___;___/,
       &setformulas($safeeval,split(/\_\_\_\;\_\_\_/,$fstring));                          $spreadsheets{$cnum.'_'.$cdom.'_'.$stype.'_'.$fn});
   } else {          $self->formulas(\%tmp);
       } else {
 # ---------------------------------------------------- Not cached, need to read          # Not cached, need to read
           my %f=();
      my %f=();          if ($fn=~/^default\_/) {
               my $sheetxml='';
      if ($fn=~/^default\_/) {              my $fh;
          my $sheetxml='';              my $dfn=$fn;
          my $fh;              $dfn=~s/\_/\./g;
          my $dfn=$fn;              if ($fh=Apache::File->new($includedir.'/'.$dfn)) {
          $dfn=~s/\_/\./g;                  $sheetxml=join('',<$fh>);
          if ($fh=Apache::File->new($includedir.'/'.$dfn)) {              } else {
              $sheetxml=join('',<$fh>);                  # $sheetxml='<field row="0" col="A">"Error"</field>';
          } else {                  $sheetxml='<field row="0" col="A"></field>';
              $sheetxml='<field row="0" col="A">"Error"</field>';              }
          }              %f=%{&parse_sheet(\$sheetxml)};
          %f=%{&parse_sheet(\$sheetxml)};          } elsif($fn=~/\/*\.spreadsheet$/) {
      } elsif($fn=~/\/*\.spreadsheet$/) {              my $sheetxml=&Apache::lonnet::getfile
          my $sheetxml=&Apache::lonnet::getfile                  (&Apache::lonnet::filelocation('',$fn));
              (&Apache::lonnet::filelocation('',$fn));              if ($sheetxml == -1) {
          if ($sheetxml == -1) {                  $sheetxml='<field row="0" col="A">"Error loading spreadsheet '
              $sheetxml='<field row="0" col="A">"Error loading spreadsheet '                      .$fn.'"</field>';
                  .$fn.'"</field>';              }
          }              %f=%{&parse_sheet(\$sheetxml)};
          %f=%{&parse_sheet(\$sheetxml)};          } else {
      } else {              my %tmphash = &Apache::lonnet::dump($fn,$cdom,$cnum);
          my $sheet='';              my ($tmp) = keys(%tmphash);
          my %tmphash = &Apache::lonnet::dump($fn,$cdom,$cnum);              if ($tmp !~ /^(con_lost|error|no_such_host)/i) {
          my ($tmp) = keys(%tmphash);                  foreach (keys(%tmphash)) {
          unless ($tmp =~ /^(con_lost|error|no_such_host)/i) {                      $f{$_}=$tmphash{$_};
              foreach (keys(%tmphash)) {                  }
                  $f{$_}=$tmphash{$_};              } else {
              }                  # Unable to grab the specified spreadsheet,
          }                  # so we get the default ones instead.
      }                  $fn = 'default_'.$stype;
 # --------------------------------------------------------------- Cache and set                  $self->{'filename'} = $fn;
        $spreadsheets{$cnum.'_'.$cdom.'_'.$stype.'_'.$fn}=join('___;___',%f);                    my $dfn = $fn;
        &setformulas($safeeval,%f);                  $dfn =~ s/\_/\./g;
                   my $sheetxml;
                   if (my $fh=Apache::File->new($includedir.'/'.$dfn)) {
                       $sheetxml = join('',<$fh>);
                   } else {
                       $sheetxml='<field row="0" col="A">'.
                           '"Unable to load spreadsheet"</field>';
                   }
                   %f=%{&parse_sheet(\$sheetxml)};
               }
           }
           # Cache and set
           $spreadsheets{$cnum.'_'.$cdom.'_'.$stype.'_'.$fn}=join('___;___',%f);  
           $self->formulas(\%f);
     }      }
 }  
   
 # -------------------------------------------------------- Make new spreadsheet  
   
 sub makenewsheet {  
     my ($uname,$udom,$stype,$usymb)=@_;  
     my $safeeval=initsheet($stype);  
     $safeeval->reval(  
        '$uname="'.$uname.  
       '";$udom="'.$udom.  
       '";$uhome="'.&Apache::lonnet::homeserver($uname,$udom).  
       '";$sheettype="'.$stype.  
       '";$usymb="'.$usymb.  
       '";$csec="'.&Apache::lonnet::usection($udom,$uname,  
                                             $ENV{'request.course.id'}).  
       '";$cid="'.$ENV{'request.course.id'}.  
       '";$cfn="'.$ENV{'request.course.fn'}.  
       '";$cnum="'.$ENV{'course.'.$ENV{'request.course.id'}.'.num'}.  
       '";$cdom="'.$ENV{'course.'.$ENV{'request.course.id'}.'.domain'}.  
       '";$chome="'.$ENV{'course.'.$ENV{'request.course.id'}.'.home'}.'";');  
     return $safeeval;  
 }  }
   
 # ------------------------------------------------------------ Save spreadsheet  # ------------------------------------------------------------ Save spreadsheet
   
 sub writesheet {  sub writesheet {
   my ($safeeval,$makedef)=@_;      my $self = shift;
   my $cid=&getcid($safeeval);      my ($makedef)=@_;
   if (&Apache::lonnet::allowed('opa',$cid)) {      my $cid=$self->{'cid'};
     my %f=&getformulas($safeeval);      if (&Apache::lonnet::allowed('opa',$cid)) {
     my $stype=&gettype($safeeval);          my %f=$self->formulas();
     my $cnum=&getcnum($safeeval);          my $stype= $self->{'type'};
     my $cdom=&getcdom($safeeval);          my $cnum = $self->{'cnum'};
     my $chome=&getchome($safeeval);          my $cdom = $self->{'cdom'};
     my $fn=&getfilename($safeeval);          my $chome= $self->{'chome'};
           my $fn   = $self->{'filename'};
 # ------------------------------------------------------------- Cache new sheet          # Cache new sheet
     $spreadsheets{$cnum.'_'.$cdom.'_'.$stype.'_'.$fn}=join('___;___',%f);              $spreadsheets{$cnum.'_'.$cdom.'_'.$stype.'_'.$fn}=join('___;___',%f);
 # ----------------------------------------------------------------- Write sheet          # Write sheet
     my $sheetdata='';          foreach (keys(%f)) {
     foreach (keys(%f)) {              delete($f{$_}) if ($f{$_} eq 'import');
      unless ($f{$_} eq 'import') {          }
        $sheetdata.=&Apache::lonnet::escape($_).'='.          my $reply = &Apache::lonnet::put($fn,\%f,$cdom,$cnum);
    &Apache::lonnet::escape($f{$_}).'&';          if ($reply eq 'ok') {
      }              $reply = &Apache::lonnet::put($stype.'_spreadsheets',
     }                              {$fn => $ENV{'user.name'}.'@'.$ENV{'user.domain'}},
     $sheetdata=~s/\&$//;                                            $cdom,$cnum);
     my $reply=&Apache::lonnet::reply('put:'.$cdom.':'.$cnum.':'.$fn.':'.              if ($reply eq 'ok') {
               $sheetdata,$chome);                  if ($makedef) { 
     if ($reply eq 'ok') {                      $reply = &Apache::lonnet::put('environment',
           $reply=&Apache::lonnet::reply('put:'.$cdom.':'.$cnum.':'.                                      {'spreadsheet_default_'.$stype => $fn },
               $stype.'_spreadsheets:'.                                                    $cdom,$cnum);
               &Apache::lonnet::escape($fn).'='.$ENV{'user.name'}.'@'.                      if ($reply eq 'ok' && 
                                                $ENV{'user.domain'},                          ($self->{'type'} eq 'studentcalc' ||
               $chome);                           $self->{'type'} eq 'assesscalc')) {
           if ($reply eq 'ok') {                          # Expire the spreadsheets of the other students.
               if ($makedef) {                           &Apache::lonnet::expirespread('','','studentcalc','');
                 return &Apache::lonnet::reply('put:'.$cdom.':'.$cnum.                      }
                                 ':environment:spreadsheet_default_'.$stype.'='.                      return $reply;
                                 &Apache::lonnet::escape($fn),                  } 
                                 $chome);                  return $reply;
       } else {              } 
   return $reply;              return $reply;
          }          } 
    } else {          return $reply;
        return $reply;      }
            }      return 'unauthorized';
       } else {  
   return $reply;  
       }  
   }  
   return 'unauthorized';  
 }  }
   
 # ----------------------------------------------- Make a temp copy of the sheet  # ----------------------------------------------- Make a temp copy of the sheet
 # "Modified workcopy" - interactive only  # "Modified workcopy" - interactive only
 #  #
   
 sub tmpwrite {  sub tmpwrite {
     my $safeeval=shift;      my $self = shift;
     my $fn=$ENV{'user.name'}.'_'.      my $fn=$ENV{'user.name'}.'_'.
            $ENV{'user.domain'}.'_spreadsheet_'.&getusymb($safeeval).'_'.          $ENV{'user.domain'}.'_spreadsheet_'.$self->{'usymb'}.'_'.
            &getfilename($safeeval);             $self->{'filename'};
     $fn=~s/\W/\_/g;      $fn=~s/\W/\_/g;
     $fn=$tmpdir.$fn.'.tmp';      $fn=$Apache::lonnet::tmpdir.$fn.'.tmp';
     my $fh;      my $fh;
     if ($fh=Apache::File->new('>'.$fn)) {      if ($fh=Apache::File->new('>'.$fn)) {
  print $fh join("\n",&getformulas($safeeval));          my %f = $self->formulas();
           while( my ($cell,$formula) = each(%f)) {
               print $fh &Apache::lonnet::escape($cell)."=".&Apache::lonnet::escape($formula)."\n";
           }
     }      }
 }  }
   
 # ---------------------------------------------------------- Read the temp copy  
   
   # ---------------------------------------------------------- Read the temp copy
 sub tmpread {  sub tmpread {
     my ($safeeval,$nfield,$nform)=@_;      my $self = shift;
       my ($nfield,$nform)=@_;
     my $fn=$ENV{'user.name'}.'_'.      my $fn=$ENV{'user.name'}.'_'.
            $ENV{'user.domain'}.'_spreadsheet_'.&getusymb($safeeval).'_'.             $ENV{'user.domain'}.'_spreadsheet_'.$self->{'usymb'}.'_'.
            &getfilename($safeeval);             $self->{'filename'};
     $fn=~s/\W/\_/g;      $fn=~s/\W/\_/g;
     $fn=$tmpdir.$fn.'.tmp';      $fn=$Apache::lonnet::tmpdir.$fn.'.tmp';
     my $fh;      my $fh;
     my %fo=();      my %fo=();
     my $countrows=0;      my $countrows=0;
     if ($fh=Apache::File->new($fn)) {      if ($fh=Apache::File->new($fn)) {
         my $name;          while (<$fh>) {
         while ($name=<$fh>) {      chomp;
     chomp($name);              my ($cell,$formula) = split(/=/);
             my $value=<$fh>;              $cell    = &Apache::lonnet::unescape($cell);
             chomp($value);              $formula = &Apache::lonnet::unescape($formula);
             $fo{$name}=$value;              $fo{$cell} = $formula;
             if ($name=~/^A(\d+)$/) {  
  if ($1>$countrows) {  
     $countrows=$1;  
                 }  
             }  
         }          }
     }      }
     if ($nform eq 'changesheet') {      if ($nform eq 'changesheet') {
         $fo{'A'.$nfield}=(split(/\_\_\&\&\&\_\_/,$fo{'A'.$nfield}))[0];          $fo{'A'.$nfield}=(split(/__&&&\__/,$fo{'A'.$nfield}))[0];
         unless ($ENV{'form.sel_'.$nfield} eq 'Default') {          unless ($ENV{'form.sel_'.$nfield} eq 'Default') {
     $fo{'A'.$nfield}.='__&&&__'.$ENV{'form.sel_'.$nfield};      $fo{'A'.$nfield}.='__&&&__'.$ENV{'form.sel_'.$nfield};
         }          }
     } elsif ($nfield eq 'insertrow') {  
         $countrows++;  
         if ($nform eq 'top') {  
     $fo{'A'.$countrows}='AAAAA_'.$countrows;  
         } else {  
             $fo{'A'.$countrows}='zzzzz_'.$countrows;  
         }  
     } else {      } else {
        if ($nfield) { $fo{$nfield}=$nform; }         if ($nfield) { $fo{$nfield}=$nform; }
     }      }
     &setformulas($safeeval,%fo);      $self->formulas(\%fo);
 }  }
   
 # ================================================================== Parameters  ##################################################################
 # -------------------------------------------- Figure out a cascading parameter  ##                  Row label formatting routines               ##
 #  ##################################################################
 # For this function to work  sub format_html_rowlabel {
 #      my $self = shift;
 # * parmhash needs to be tied      my $rowlabel = shift;
 # * courseopt and useropt need to be initialized for this user and course      return '' if ($rowlabel eq '');
 #      my ($type,$labeldata) = split(':',$rowlabel,2);
       my $result = '';
 sub parmval {      if ($type eq 'symb') {
     my ($what,$safeeval)=@_;          my ($symb,$mapid,$resid,$title,$ufn) = split(':',$labeldata);
     my $cid=&getcid($safeeval);          $ufn   = 'default' if (!defined($ufn) || $ufn eq '');
     my $csec=&getcsec($safeeval);          $ufn   = &Apache::lonnet::unescape($ufn);
     my $uname=&getuname($safeeval);          $symb  = &Apache::lonnet::unescape($symb);
     my $udom=&getudom($safeeval);          $title = &Apache::lonnet::unescape($title);
     my $symb=&getusymb($safeeval);          $result = '<a href="/adm/assesscalc?usymb='.$symb.
               '&uname='.$self->{'uname'}.'&udom='.$self->{'udom'}.
     unless ($symb) { return ''; }                  '&ufn='.$ufn.
     my $result='';                      '&mapid='.$mapid.'&resid='.$resid.'">'.$title.'</a>';
       } elsif ($type eq 'student') {
     my ($mapname,$id,$fn)=split(/\_\_\_/,$symb);          my ($sname,$sdom,$fullname,$section,$id) = split(':',$labeldata);
 # ----------------------------------------------------- Cascading lookup scheme          if ($fullname =~ /^\s*$/) {
        my $rwhat=$what;              $fullname = $sname.'@'.$sdom;
        $what=~s/^parameter\_//;          }
        $what=~s/\_([^\_]+)$/\.$1/;          $result ='<a href="/adm/studentcalc?uname='.$sname.
               '&udom='.$sdom.'">';
        my $symbparm=$symb.'.'.$what;          $result.=$section.'&nbsp;'.$id."&nbsp;".$fullname.'</a>';
        my $mapparm=$mapname.'___(all).'.$what;      } elsif ($type eq 'parameter') {
        my $usercourseprefix=$uname.'_'.$udom.'_'.$cid;          $result = $labeldata;
       } else {
        my $seclevel=          $result = '<b><font size=+1>'.$rowlabel.'</font></b>';
             $usercourseprefix.'.['.      }
  $csec.'].'.$what;      return $result;
        my $seclevelr=  }
             $usercourseprefix.'.['.  
  $csec.'].'.$symbparm;  sub format_csv_rowlabel {
        my $seclevelm=      my $self = shift;
             $usercourseprefix.'.['.      my $rowlabel = shift;
  $csec.'].'.$mapparm;      return '' if ($rowlabel eq '');
       my ($type,$labeldata) = split(':',$rowlabel,2);
        my $courselevel=      my $result = '';
             $usercourseprefix.'.'.$what;      if ($type eq 'symb') {
        my $courselevelr=          my ($symb,$mapid,$resid,$title,$ufn) = split(':',$labeldata);
             $usercourseprefix.'.'.$symbparm;          $ufn   = &Apache::lonnet::unescape($ufn);
        my $courselevelm=          $symb  = &Apache::lonnet::unescape($symb);
             $usercourseprefix.'.'.$mapparm;          $title = &Apache::lonnet::unescape($title);
           $result = $title;
 # ---------------------------------------------------------- fourth, check user      } elsif ($type eq 'student') {
                 my ($sname,$sdom,$fullname,$section,$id) = split(':',$labeldata);
       if ($uname) {           $result = join('","',($sname,$sdom,$fullname,$section,$id));
       } elsif ($type eq 'parameter') {
        if ($useropt{$courselevelr}) { return $useropt{$courselevelr}; }          $labeldata =~ s/<br>/ /g;
           $result = $labeldata;
        if ($useropt{$courselevelm}) { return $useropt{$courselevelm}; }      } else {
           $result = $rowlabel;
        if ($useropt{$courselevel}) { return $useropt{$courselevel}; }      }
       return '"'.$result.'"';
       }  }
   
 # --------------------------------------------------------- third, check course  sub format_excel_rowlabel {
            my $self = shift;
        if ($csec) {      my $rowlabel = shift;
        return '' if ($rowlabel eq '');
         if ($courseopt{$seclevelr}) { return $courseopt{$seclevelr}; }      my ($type,$labeldata) = split(':',$rowlabel,2);
       my $result = '';
         if ($courseopt{$seclevelm}) { return $courseopt{$seclevelm}; }        if ($type eq 'symb') {
           my ($symb,$mapid,$resid,$title,$ufn) = split(':',$labeldata);
         if ($courseopt{$seclevel}) { return $courseopt{$seclevel}; }          $ufn   = &Apache::lonnet::unescape($ufn);
             $symb  = &Apache::lonnet::unescape($symb);
       }          $title = &Apache::lonnet::unescape($title);
           $result = $title;
        if ($courseopt{$courselevelr}) { return $courseopt{$courselevelr}; }      } elsif ($type eq 'student') {
           my ($sname,$sdom,$fullname,$section,$id) = split(':',$labeldata);
        if ($courseopt{$courselevelm}) { return $courseopt{$courselevelm}; }          $section = '' if (! defined($section));
           $id      = '' if (! defined($id));
        if ($courseopt{$courselevel}) { return $courseopt{$courselevel}; }          my @Data = ($sname,$sdom,$fullname,$section,$id);
           $result = \@Data;
 # ----------------------------------------------------- second, check map parms      } elsif ($type eq 'parameter') {
           $labeldata =~ s/<br>/ /g;
        my $thisparm=$parmhash{$symbparm};          $result = $labeldata;
        if ($thisparm) { return $thisparm; }      } else {
           $result = $rowlabel;
 # -------------------------------------------------------- first, check default      }
       return $result;
        return &Apache::lonnet::metadata($fn,$rwhat.'.default');  
           
 }  }
   
 # ---------------------------------------------- Update rows for course listing  # ---------------------------------------------- Update rows for course listing
   
 sub updateclasssheet {  sub updateclasssheet {
     my $safeeval=shift;      my $self = shift;
     my $cnum=&getcnum($safeeval);      my $cnum  =$self->{'cnum'};
     my $cdom=&getcdom($safeeval);      my $cdom  =$self->{'cdom'};
     my $cid=&getcid($safeeval);      my $cid   =$self->{'cid'};
     my $chome=&getchome($safeeval);      my $chome =$self->{'chome'};
       #
 # ---------------------------------------------- Read class list and row labels      %Section = ();
       #
     my $classlst=&Apache::lonnet::reply      # Read class list and row labels
                                  ('dump:'.$cdom.':'.$cnum.':classlist',$chome);      my $classlist = &Apache::loncoursedata::get_classlist();
       if (! defined($classlist)) {
           return 'Could not access course classlist';
       } 
       #
     my %currentlist=();      my %currentlist=();
     my $now=time;      foreach my $student (keys(%$classlist)) {
     unless ($classlst=~/^error\:/) {          my ($studentDomain,$studentName,$end,$start,$id,$studentSection,
         foreach (split(/\&/,$classlst)) {              $fullname,$status)   =   @{$classlist->{$student}};
             my ($name,$value)=split(/\=/,$_);          $Section{$studentName.':'.$studentDomain} = $studentSection;
             my ($end,$start)=split(/\:/,&Apache::lonnet::unescape($value));          if ($ENV{'form.Status'} eq $status || $ENV{'form.Status'} eq 'Any') {
             my $active=1;              $currentlist{$student}=join(':',('student',$studentName,
             if (($end) && ($now>$end)) { $active=0; }                                               $studentDomain,$fullname,
             if ($active) {                                               $studentSection,$id));
                 my $rowlabel='';  
                 $name=&Apache::lonnet::unescape($name);  
                 my ($sname,$sdom)=split(/\:/,$name);  
                 my $ssec=&Apache::lonnet::usection($sdom,$sname,$cid);  
                 if ($ssec==-1) {  
    unless ($ENV{'form.showcsv'}) {  
                     $rowlabel='<font color=red>Data not available: '.$name.  
       '</font>';  
    } else {  
        $rowlabel='ERROR","'.$name.  
                                  '","Data not available","","","';  
                    }  
                 } else {  
                     my %reply=&Apache::lonnet::idrget($sdom,$sname);  
                     my $reply=&Apache::lonnet::reply('get:'.$sdom.':'.$sname.  
       ':environment:firstname&middlename&lastname&generation',  
                       &Apache::lonnet::homeserver($sname,$sdom));  
    unless ($ENV{'form.showcsv'}) {  
                     $rowlabel='<a href="/adm/studentcalc?uname='.$sname.  
                               '&udom='.$sdom.'">'.  
                               $ssec.'&nbsp;'.$reply{$sname}.'<br>';  
                     foreach ( split(/\&/,$reply)) {  
                         $rowlabel.=&Apache::lonnet::unescape($_).' ';  
                     }  
                     $rowlabel.='</a>';  
    } else {  
     $rowlabel=$ssec.'","'.$reply{$sname}.'"';  
                     my $ncount=0;  
                     foreach (split(/\&/,$reply)) {  
                         $rowlabel.=',"'.&Apache::lonnet::unescape($_).'"';  
                         $ncount++;  
                     }  
                     unless ($ncount==4) { $rowlabel.=',""'; }  
                     $rowlabel=~s/\"$//;  
    }  
                 }  
  $currentlist{&Apache::lonnet::unescape($name)}=$rowlabel;  
             }  
         } # end of foreach (split(/\&/,$classlst))  
 #  
 # -------------------- Find discrepancies between the course row table and this  
 #  
         my %f=&getformulas($safeeval);  
         my $changed=0;  
   
         my $maxrow=0;  
         my %existing=();  
   
 # ----------------------------------------------------------- Now obsolete rows  
  foreach (keys(%f)) {  
     if ($_=~/^A(\d+)/) {  
                 $maxrow=($1>$maxrow)?$1:$maxrow;  
                 $existing{$f{$_}}=1;  
  unless ((defined($currentlist{$f{$_}})) || (!$1)) {  
    $f{$_}='!!! Obsolete';  
                    $changed=1;  
                 }  
             }  
         }          }
       }
 # -------------------------------------------------------- New and unknown keys      #
            # Find discrepancies between the course row table and this
         foreach (sort keys(%currentlist)) {      #
             unless ($existing{$_}) {      my %f=$self->formulas();
  $changed=1;      my $changed=0;
                 $maxrow++;      #
                 $f{'A'.$maxrow}=$_;      $self->{'maxrow'}=0;
             }      my %existing=();
       #
       # Now obsolete rows
       foreach my $rownum ($self->rows()) {
           my $cell = 'A'.$rownum;
           if ($rownum > $self->{'maxrow'}) {
               $self->{'maxrow'}= $rownum;
           }
           $existing{$f{$cell}}=1;
           if (! defined($currentlist{$f{$cell}}) && ($f{$cell}=~/^(~~~|---)/)) {
               $f{$cell}='!!! Obsolete';
               $changed=1;
         }          }
        
         if ($changed) { &setformulas($safeeval,%f); }  
   
         &setmaxrow($safeeval,$maxrow);  
         &setrowlabels($safeeval,%currentlist);  
   
     } else {  
         return 'Could not access course data';  
     }      }
       #
       # New and unknown keys
       foreach my $student (sort keys(%currentlist)) {
           next if ($existing{$student});
           $changed=1;
           $self->{'maxrow'}++;
           $f{'A'.$self->{'maxrow'}}=$student;
       }
       $self->formulas(\%f) if ($changed);
       #
       $self->rowlabels(\%currentlist);
 }  }
   
 # ----------------------------------- Update rows for student and assess sheets  # ----------------------------------- Update rows for student and assess sheets
   sub get_student_rowlabels {
 sub updatestudentassesssheet {      my $self = shift;
     my $safeeval=shift;      #
     my %bighash;      my %course_db;
     my $stype=&gettype($safeeval);      #
     my %current=();      my $stype = $self->{'type'};
     unless ($updatedata{$ENV{'request.course.fn'}.'_'.$stype}) {      my $uname = $self->{'uname'};
 # -------------------------------------------------------------------- Tie hash      my $udom  = $self->{'udom'};
       if (tie(%bighash,'GDBM_File',$ENV{'request.course.fn'}.'.db',      #
                        &GDBM_READER,0640)) {      $self->{'rowlabel'} = {};
 # --------------------------------------------------------- Get all assessments      #
       my $identifier =$self->{'coursefilename'}.'_'.$stype;
  my %allkeys=('timestamp' =>       if  (exists($rowlabel_cache{$identifier})) {
                      'Timestamp of Last Transaction<br>timestamp',          my %tmp = split(/___;___/,$rowlabel_cache{$identifier});
                      'subnumber' =>          $self->rowlabels(\%tmp);
                      'Number of Submissions<br>subnumber',      } else {
                      'tutornumber' =>          # Get the data and store it in the cache
                      'Number of Tutor Responses<br>tutornumber',          # Tie hash
                      'totalpoints' =>          tie(%course_db,'GDBM_File',$self->{'coursefilename'}.'.db',
                      'Total Points Granted<br>totalpoints');              &GDBM_READER(),0640);
           if (! tied(%course_db)) {
         my $adduserstr='';              return 'Could not access course data';
         if ((&getuname($safeeval) ne $ENV{'user.name'}) ||          }
             (&getudom($safeeval) ne $ENV{'user.domain'})) {          #
             $adduserstr='&uname='.&getuname($safeeval).          my %assesslist = ();
  '&udom='.&getudom($safeeval);          foreach ('Feedback','Evaluation','Tutoring','Discussion') {
         }              my $symb = '_'.lc($_);
               $assesslist{$symb} = join(':',('symb',$symb,0,0,
         my %allassess=('_feedback' =>                                             &Apache::lonnet::escape($_)));
               '<a href="/adm/assesscalc?usymb=_feedback'.$adduserstr.          }
                        '">Feedback</a>',          #
                        '_evaluation' =>          while (my ($key,$srcf) = each(%course_db)) {
               '<a href="/adm/assesscalc?usymb=_evaluation'.$adduserstr.              next if ($key !~ /^src_(\d+)\.(\d+)$/);
                        '">Evaluation</a>',              my $mapid = $1;
                        '_tutoring' =>              my $resid = $2;
               '<a href="/adm/assesscalc?usymb=_tutoring'.$adduserstr.              my $id   = $mapid.'.'.$resid;
                        '">Tutoring</a>',              if ($srcf=~/\.(problem|exam|quiz|assess|survey|form)$/) {
                        '_discussion' =>                  my $symb=
               '<a href="/adm/assesscalc?usymb=_discussion'.$adduserstr.                      &Apache::lonnet::declutter($course_db{'map_id_'.$mapid}).
                        '">Discussion</a>'                          '___'.$resid.'___'.&Apache::lonnet::declutter($srcf);
         );                  $assesslist{$symb} ='symb:'.&Apache::lonnet::escape($symb).':'
                       .$mapid.':'.$resid.':'.
         foreach (keys(%bighash)) {                          &Apache::lonnet::escape($course_db{'title_'.$id});
     if ($_=~/^src\_(\d+)\.(\d+)$/) {              }
        my $mapid=$1;  
                my $resid=$2;  
                my $id=$mapid.'.'.$resid;  
                my $srcf=$bighash{$_};  
                if ($srcf=~/\.(problem|exam|quiz|assess|survey|form)$/) {  
                  my $symb=  
                      &Apache::lonnet::declutter($bighash{'map_id_'.$mapid}).  
     '___'.$resid.'___'.  
     &Apache::lonnet::declutter($srcf);  
  $allassess{$symb}=  
             '<a href="/adm/assesscalc?usymb='.$symb.$adduserstr.'">'.  
                      $bighash{'title_'.$id}.'</a>';  
                  if ($stype eq 'assesscalc') {  
      foreach (split(/\,/,  
     &Apache::lonnet::metadata($srcf,'keys'))) {  
                        if (($_=~/^stores\_(.*)/) || ($_=~/^parameter\_(.*)/)) {  
   my $key=$_;  
                           my $display=  
       &Apache::lonnet::metadata($srcf,$key.'.display');  
                           unless ($display) {  
                               $display.=  
          &Apache::lonnet::metadata($srcf,$key.'.name');  
                           }  
                           $display.='<br>'.$key;  
                           $allkeys{$key}=$display;  
        }  
                    } # end of foreach  
          }  
       }  
    }  
         } # end of foreach (keys(%bighash))  
         untie(%bighash);  
       
 #  
 # %allkeys has a list of storage and parameter displays by unikey  
 # %allassess has a list of all resource displays by symb  
 #  
   
         if ($stype eq 'assesscalc') {  
     %current=%allkeys;  
         } elsif ($stype eq 'studentcalc') {  
             %current=%allassess;  
         }          }
         $updatedata{$ENV{'request.course.fn'}.'_'.$stype}=          untie(%course_db);
     join('___;___',%current);          # Store away the data
     } else {          $self->{'rowlabel'} = \%assesslist;
         return 'Could not access course data';          $rowlabel_cache{$identifier}=join('___;___',%{$self->{'rowlabel'}});
     }  
 # ------------------------------------------------------ Get current from cache  
     } else {  
         %current=split(/\_\_\_\;\_\_\_/,  
        $updatedata{$ENV{'request.course.fn'}.'_'.$stype});  
     }      }
 # -------------------- Find discrepancies between the course row table and this      
 #  }
         my %f=&getformulas($safeeval);  
         my $changed=0;  
   
         my $maxrow=0;  
         my %existing=();  
   
 # ----------------------------------------------------------- Now obsolete rows  sub get_assess_rowlabels {
  foreach (keys(%f)) {      my $self = shift;
     if ($_=~/^A(\d+)/) {      #
                 $maxrow=($1>$maxrow)?$1:$maxrow;      my %course_db;
                 my ($usy,$ufn)=split(/\_\_\&\&\&\_\_/,$f{$_});      #
                 $existing{$usy}=1;      my $stype = $self->{'type'};
  unless ((defined($current{$usy})) || (!$1)) {      my $uname = $self->{'uname'};
    $f{$_}='!!! Obsolete';      my $udom  = $self->{'udom'};
                    $changed=1;      my $usymb = $self->{'usymb'};
         } elsif ($ufn) {      #
     $current{$usy}      $self->rowlabels({});
                        =~s/assesscalc\?usymb\=/assesscalc\?ufn\=$ufn\&usymb\=/;      my $identifier =$self->{'coursefilename'}.'_'.$stype.'_'.$usymb;
                 }      #
       if (exists($rowlabel_cache{$identifier})) {
           my %tmp = split('___;___',$rowlabel_cache{$identifier});
           $self->rowlabels(\%tmp);
       } else {
           # Get the data and store it in the cache
           # Tie hash
           tie(%course_db,'GDBM_File',$self->{'coursefilename'}.'.db',
               &GDBM_READER(),0640);
           if (! tied(%course_db)) {
               return 'Could not access course data';
           }
           #
           my %parameter_labels=
               ('timestamp' => 
                    'parameter:Timestamp of Last Transaction<br>timestamp',
                'subnumber' =>
                    'parameter:Number of Submissions<br>subnumber',
                'tutornumber' =>
                    'parameter:Number of Tutor Responses<br>tutornumber',
                'totalpoints' =>
                    'parameter:Total Points Granted<br>totalpoints');
           while (my ($key,$srcf) = each(%course_db)) {
               next if ($key !~ /^src_(\d+)\.(\d+)$/);
               my $mapid = $1;
               my $resid = $2;
               my $id   = $mapid.'.'.$resid;
               if ($srcf=~/\.(problem|exam|quiz|assess|survey|form)$/) {
                   # Loop through the metadata for this key
                   my @Metadata = split(/,/,
                                        &Apache::lonnet::metadata($srcf,'keys'));
                   foreach my $key (@Metadata) {
                       next if ($key !~ /^(stores|parameter)_/);
                       my $display=
                           &Apache::lonnet::metadata($srcf,$key.'.display');
                       unless ($display) {
                           $display.=
                               &Apache::lonnet::metadata($srcf,$key.'.name');
                       }
                       $display.='<br>'.$key;
                       $parameter_labels{$key}='parameter:'.$display;
                   } # end of foreach
             }              }
         }          }
           untie(%course_db);
           # Store away the results
           $self->rowlabels(\%parameter_labels);
           $rowlabel_cache{$identifier}=join('___;___',%parameter_labels);
       }
   }
   
 # -------------------------------------------------------- New and unknown keys  sub updatestudentassesssheet {
            my $self = shift;
         foreach (keys(%current)) {      if ($self->{'type'} eq 'studentcalc') {
             unless ($existing{$_}) {          $self->get_student_rowlabels();
  $changed=1;      } else {
                 $maxrow++;          $self->get_assess_rowlabels();
                 $f{'A'.$maxrow}=$_;      }
             }      # Determine if any of the information has changed
       my %f=$self->formulas();
       my $changed=0;
       $self->{'maxrow'} = 0;
       my %existing=();
       # Now obsolete rows
       foreach my $rownum ($self->rows()) {
           my $cell = 'A'.$rownum;
           my $formula = $f{$cell};
           $self->{'maxrow'} = $rownum if ($rownum > $self->{'maxrow'});
           my ($usy,$ufn)=split(/__&&&\__/,$formula);
           $existing{$usy}=1;
           if ( ! exists($self->{'rowlabel'}->{$usy})  ||
                ! defined($self->{'rowlabel'}->{$usy}) ||
                ($formula =~ /^(~~~|---)/) ||
                ($formula =~ /^\s*$/)) {
               $f{$cell}='!!! Obsolete';
               $changed=1;
           }
       }
       # New and unknown keys
       my %keys_hates_me = $self->rowlabels();
       foreach (keys(%keys_hates_me)) {
           unless ($existing{$_}) {
               $changed=1;
               $self->{'maxrow'}++;
               $f{'A'.$self->{'maxrow'}}=$_;
         }          }
           }
         if ($changed) { &setformulas($safeeval,%f); }      $self->formulas(\%f) if ($changed);
   #    $self->dump_formulas_to_log();    
         &setmaxrow($safeeval,$maxrow);  
         &setrowlabels($safeeval,%current);  
    
         undef %current;  
         undef %existing;  
 }  }
   
 # ------------------------------------------------ Load data for one assessment  # ------------------------------------------------ Load data for one assessment
   sub loadstudent{
 sub loadstudent {      my $self = shift;
     my $safeeval=shift;      my ($r,$c)=@_;
     my %c=();      my %constants = ();
     my %f=&getformulas($safeeval);      my %formulas  = $self->formulas();
     $cachedassess=&getuname($safeeval).':'.&getudom($safeeval);      $cachedassess = $self->{'uname'}.':'.$self->{'udom'};
     %cachedstores=();      # Get ALL the student preformance data
     {      my @tmp = &Apache::loncoursedata::get_current_state($self->{'uname'},
       my $reply=&Apache::lonnet::reply('dump:'.&getudom($safeeval).':'.                                                          $self->{'udom'},
                                                &getuname($safeeval).':'.                                                          undef,
                                                &getcid($safeeval),                                                          $self->{'cid'});
                                                &getuhome($safeeval));      if ((scalar @tmp > 0) && ($tmp[0] !~ /^error:/)) {
       unless ($reply=~/^error\:/) {          %cachedstores = @tmp;
  foreach ( split(/\&/,$reply)) {      }
             my ($name,$value)=split(/\=/,$_);      undef @tmp;
             $cachedstores{&Apache::lonnet::unescape($name)}=      # debugging code
                   &Apache::lonnet::unescape($value);      # $self->dump_hash_to_log(\%cachedstores);
  }      #
       }  
     }  
     my @assessdata=();      my @assessdata=();
     foreach (keys(%f)) {      foreach my $row ($self->rows()) {
  if ($_=~/^A(\d+)/) {          my $cell = 'A'.$row;
    my $row=$1;          my $value = $formulas{$cell};
            unless (($f{$_}=~/^\!/) || ($row==0)) {          if(defined($c) && ($c->aborted())) {
       my ($usy,$ufn)=split(/\_\_\&\&\&\_\_/,$f{$_});              last;
       @assessdata=&exportsheet(&getuname($safeeval),          }
                                        &getudom($safeeval),          next if ($value =~ /^[!~-]/);
                                        'assesscalc',$usy,$ufn);          my ($usy,$ufn)=split(/__&&&\__/,$value);
               my $index=0;          @assessdata=$self->exportsheet($self->{'uname'},
               foreach ('A','B','C','D','E','F','G','H','I','J','K','L','M',                                          $self->{'udom'},
                'N','O','P','Q','R','S','T','U','V','W','X','Y','Z') {                                          'assesscalc',$usy,$ufn,$r);
                   if ($assessdata[$index]) {          my $index=0;
      my $col=$_;          foreach my $col ('A','B','C','D','E','F','G','H','I','J','K','L','M',
      if ($assessdata[$index]=~/\D/) {                           'N','O','P','Q','R','S','T','U','V','W','X','Y','Z') {
                          $c{$col.$row}="'".$assessdata[$index]."'";              if (defined($assessdata[$index])) {
       } else {                  if ($assessdata[$index]=~/\D/) {
          $c{$col.$row}=$assessdata[$index];                      $constants{$col.$row}="'".$assessdata[$index]."'";
      }                  } else {
                      unless ($col eq 'A') {                       $constants{$col.$row}=$assessdata[$index];
  $f{$col.$row}='import';                  }
                      }                  $formulas{$col.$row}='import' if ($col ne 'A');
   }              }
                   $index++;              $index++;
               }  
    }  
         }          }
     }      }
     $cachedassess='';      $cachedassess='';
     undef %cachedstores;      undef %cachedstores;
     &setformulas($safeeval,%f);      $self->formulas(\%formulas);
     &setconstants($safeeval,%c);      $self->constants(\%constants);
 }  }
   
 # --------------------------------------------------- Load data for one student  # --------------------------------------------------- Load Course Sheet
   #
 sub loadcourse {  sub loadcourse {
     my ($safeeval,$r)=@_;      my $self = shift;
     my %c=();      my ($r,$c)=@_;
     my %f=&getformulas($safeeval);      #
       my %constants=();
       my %formulas=$self->formulas();
       #
     my $total=0;      my $total=0;
     foreach (keys(%f)) {      foreach ($self->rows()) {
  if ($_=~/^A(\d+)/) {          $total++ if ($formulas{'A'.$_} !~ /^[!~-]/);
     unless ($f{$_}=~/^\!/) { $total++; }      }
         }  
     }      my %prog_state=&Apache::lonhtmlcommon::Create_PrgWin($r,
     my $now=0;        'Spreadsheet Status','Spreadsheet Calculation Progress', $total);
     my $since=time;      &Apache::lonhtmlcommon::Update_PrgWin($r,\%prog_state,
     $r->print(<<ENDPOP);    'Processing Course Assessment Data');
 <script>  
     popwin=open('','popwin','width=400,height=100');      # It would be nice to load in the classlist and assessment info at this 
     popwin.document.writeln('<html><body bgcolor="#FFFFFF">'+      # point, before attacking the student spreadsheets.
       '<h3>Spreadsheet Calculation Progress</h3>'+      foreach my $row ($self->rows()) {
       '<form name=popremain>'+          if(defined($c) && ($c->aborted())) {
       '<input type=text size=35 name=remaining value=Starting></form>'+              last;
       '</body></html>');          }
     popwin.document.close();          my $cell = 'A'.$row;
 </script>          next if ($formulas{$cell}=~/^[\!\~\-]/);
 ENDPOP          my ($sname,$sdom) = split(':',$formulas{$cell});
     $r->rflush();          my $started = time;
     foreach (keys(%f)) {          my @studentdata=$self->exportsheet($sname,$sdom,'studentcalc',
  if ($_=~/^A(\d+)/) {                                       undef,undef,$r);
    my $row=$1;          undef %userrdatas;
            unless (($f{$_}=~/^\!/)  || ($row==0)) {   &Apache::lonhtmlcommon::Increment_PrgWin($r,\%prog_state,
       my @studentdata=&exportsheet(split(/\:/,$f{$_}),   'last student');
                                            'studentcalc');          my $index=0;
               undef %userrdatas;          foreach ('A','B','C','D','E','F','G','H','I','J','K','L','M',
               $now++;                   'N','O','P','Q','R','S','T','U','V','W','X','Y','Z') {
               $r->print('<script>popwin.document.popremain.remaining.value="'.              if (defined($studentdata[$index])) {
                   $now.'/'.$total.': '.int((time-$since)/$now*($total-$now)).                  my $col=$_;
                         ' secs remaining";</script>');                  if ($studentdata[$index]=~/\D/) {
               $r->rflush();                       $constants{$col.$row}="'".$studentdata[$index]."'";
                   } else {
               my $index=0;                      $constants{$col.$row}=$studentdata[$index];
              foreach ('A','B','C','D','E','F','G','H','I','J','K','L','M',                  }
               'N','O','P','Q','R','S','T','U','V','W','X','Y','Z') {                  unless ($col eq 'A') { 
                   if ($studentdata[$index]) {                      $formulas{$col.$row}='import';
      my $col=$_;                  }
      if ($studentdata[$index]=~/\D/) {              } 
                          $c{$col.$row}="'".$studentdata[$index]."'";              $index++;
       } else {  
          $c{$col.$row}=$studentdata[$index];  
      }  
                      unless ($col eq 'A') {   
  $f{$col.$row}='import';  
                      }  
   }  
                   $index++;  
               }  
    }  
         }          }
     }      }
     &setformulas($safeeval,%f);      $self->formulas(\%formulas);
     &setconstants($safeeval,%c);      $self->constants(\%constants);
     $r->print('<script>popwin.close()</script>');      &Apache::lonhtmlcommon::Close_PrgWin($r,\%prog_state);
     $r->rflush();   
 }  }
   
 # ------------------------------------------------ Load data for one assessment  # ------------------------------------------------ Load data for one assessment
   #
 sub loadassessment {  sub loadassessment {
     my $safeeval=shift;      my $self = shift;
       my ($r,$c)=@_;
   
     my $uhome=&getuhome($safeeval);      my $uhome = $self->{'uhome'};
     my $uname=&getuname($safeeval);      my $uname = $self->{'uname'};
     my $udom=&getudom($safeeval);      my $udom  = $self->{'udom'};
     my $symb=&getusymb($safeeval);      my $symb  = $self->{'usymb'};
     my $cid=&getcid($safeeval);      my $cid   = $self->{'cid'};
     my $cnum=&getcnum($safeeval);      my $cnum  = $self->{'cnum'};
     my $cdom=&getcdom($safeeval);      my $cdom  = $self->{'cdom'};
     my $chome=&getchome($safeeval);      my $chome = $self->{'chome'};
       my $csec  = $self->{'csec'};
   
     my $namespace;      my $namespace;
     unless ($namespace=$cid) { return ''; }      unless ($namespace=$cid) { return ''; }
       # Get stored values
 # ----------------------------------------------------------- Get stored values      my %returnhash=();
       if ($cachedassess eq $uname.':'.$udom) {
    my %returnhash=();          #
           # get data out of the dumped stores
    if ($cachedassess eq $uname.':'.$udom) {          # 
 #          if (exists($cachedstores{$symb})) {
 # get data out of the dumped stores              %returnhash = %{$cachedstores{$symb}};
 #           } else {
               %returnhash = ();
        my $version=$cachedstores{'version:'.$symb};          }
        my $scope;      } else {
        for ($scope=1;$scope<=$version;$scope++) {          #
            foreach (split(/\:/,$cachedstores{$scope.':keys:'.$symb})) {          # restore individual
                $returnhash{$_}=$cachedstores{$scope.':'.$symb.':'.$_};          #
            }           %returnhash = &Apache::lonnet::restore($symb,$namespace,$udom,$uname);
        }  
   
    } else {  
 #  
 # restore individual  
 #  
   
     my $answer=&Apache::lonnet::reply(  
        "restore:$udom:$uname:".  
        &Apache::lonnet::escape($namespace).":".  
        &Apache::lonnet::escape($symb),$uhome);  
     foreach (split(/\&/,$answer)) {  
  my ($name,$value)=split(/\=/,$_);  
         $returnhash{&Apache::lonnet::unescape($name)}=  
                     &Apache::lonnet::unescape($value);  
     }  
     my $version;  
     for ($version=1;$version<=$returnhash{'version'};$version++) {  
        foreach (split(/\:/,$returnhash{$version.':keys'})) {  
           $returnhash{$_}=$returnhash{$version.':'.$_};  
        }   
     }      }
    }      #
 # ----------------------------- returnhash now has all stores for this resource      # returnhash now has all stores for this resource
       # convert all "_" to "." to be able to use libraries, multiparts, etc
 # --------- convert all "_" to "." to be able to use libraries, multiparts, etc      #
       # This is dumb.  It is also necessary :(
     my @oldkeys=keys %returnhash;      my @oldkeys=keys %returnhash;
       #
     foreach (@oldkeys) {      foreach my $name (@oldkeys) {
         my $name=$_;          my $value=$returnhash{$name};
         my $value=$returnhash{$_};          delete $returnhash{$name};
         delete $returnhash{$_};  
         $name=~s/\_/\./g;          $name=~s/\_/\./g;
         $returnhash{$name}=$value;          $returnhash{$name}=$value;
     }      }
       # initialize coursedata and userdata for this user
 # ---------------------------- initialize coursedata and userdata for this user  
     undef %courseopt;      undef %courseopt;
     undef %useropt;      undef %useropt;
   
     my $userprefix=$uname.'_'.$udom.'_';      my $userprefix=$uname.'_'.$udom.'_';
   
     unless ($uhome eq 'no_host') {       unless ($uhome eq 'no_host') { 
 # -------------------------------------------------------------- Get coursedata          # Get coursedata
       unless          unless ((time-$courserdatas{$cid.'.last_cache'})<240) {
         ((time-$courserdatas{$cid.'.last_cache'})<240) {              my %Tmp = &Apache::lonnet::dump('resourcedata',$cdom,$cnum);
          my $reply=&Apache::lonnet::reply('dump:'.$cdom.':'.$cnum.              $courserdatas{$cid}=\%Tmp;
               ':resourcedata',$chome);  
          if ($reply!~/^error\:/) {  
             $courserdatas{$cid}=$reply;  
             $courserdatas{$cid.'.last_cache'}=time;              $courserdatas{$cid.'.last_cache'}=time;
          }          }
       }          while (my ($name,$value) = each(%{$courserdatas{$cid}})) {
       foreach (split(/\&/,$courserdatas{$cid})) {              $courseopt{$userprefix.$name}=$value;
          my ($name,$value)=split(/\=/,$_);          }
          $courseopt{$userprefix.&Apache::lonnet::unescape($name)}=          # Get userdata (if present)
                     &Apache::lonnet::unescape($value);            unless ((time-$userrdatas{$uname.'@'.$udom.'.last_cache'})<240) {
       }              my %Tmp = &Apache::lonnet::dump('resourcedata',$udom,$uname);
 # --------------------------------------------------- Get userdata (if present)              $userrdatas{$cid} = \%Tmp;
       unless              # Most of the time the user does not have a 'resourcedata.db' 
         ((time-$userrdatas{$uname.'___'.$udom.'.last_cache'})<240) {              # file.  We need to cache that we got nothing instead of bothering
          my $reply=              # with requesting it every time.
        &Apache::lonnet::reply('dump:'.$udom.':'.$uname.':resourcedata',$uhome);              $userrdatas{$uname.'@'.$udom.'.last_cache'}=time;
          if ($reply!~/^error\:/) {          }
      $userrdatas{$uname.'___'.$udom}=$reply;          while (my ($name,$value) = each(%{$userrdatas{$cid}})) {
      $userrdatas{$uname.'___'.$udom.'.last_cache'}=time;              $useropt{$userprefix.$name}=$value;
          }          }
       }  
       foreach (split(/\&/,$userrdatas{$uname.'___'.$udom})) {  
          my ($name,$value)=split(/\=/,$_);  
          $useropt{$userprefix.&Apache::lonnet::unescape($name)}=  
           &Apache::lonnet::unescape($value);  
       }  
     }      }
 # ----------------- now courseopt, useropt initialized for this user and course      # now courseopt, useropt initialized for this user and course
 # (used by parmval)      # (used by parmval)
       #
 #      # Load keys for this assessment only
 # Load keys for this assessment only      #
 #  
     my %thisassess=();      my %thisassess=();
     my ($symap,$syid,$srcf)=split(/\_\_\_/,$symb);      my ($symap,$syid,$srcf)=split(/\_\_\_/,$symb);
       
     foreach (split(/\,/,&Apache::lonnet::metadata($srcf,'keys'))) {      foreach (split(/\,/,&Apache::lonnet::metadata($srcf,'keys'))) {
         $thisassess{$_}=1;          $thisassess{$_}=1;
     }       } 
 #      #
 # Load parameters      # Load parameters
 #      #
    my %c=();      my %c=();
       if (tie(%parmhash,'GDBM_File',
    if (tie(%parmhash,'GDBM_File',              $self->{'coursefilename'}.'_parms.db',&GDBM_READER(),0640)) {
            &getcfn($safeeval).'_parms.db',&GDBM_READER,0640)) {          my %f=$self->formulas();
     my %f=&getformulas($safeeval);          foreach my $row ($self->rows())  {
     foreach (keys(%f))  {              my $cell = 'A'.$row;
  if ($_=~/^A/) {              my $formula = $self->formula($cell);
             unless ($f{$_}=~/^\!/) {              next if ($formula =~/^[\!\~\-]/);
         if ($f{$_}=~/^parameter/) {              if ($formula =~ /^parameter/) {
  if ($thisassess{$f{$_}}) {                  if (defined($thisassess{$formula})) {
                   my $val=&parmval($f{$_},$safeeval);                      my $val   = &parmval($formula,$symb,$uname,$udom,$csec);
                   $c{$_}=$val;                      $c{$cell}    = $val;
                   $c{$f{$_}}=$val;                      $c{$formula} = $val;
         }                  }
        } else {              } else {
   my $key=$f{$_};                  my $ckey=$formula;
                   my $ckey=$key;                  $formula=~s/^stores\_/resource\./;
                   $key=~s/^stores\_/resource\./;                  $formula=~s/\_/\./g;
                   $key=~s/\_/\./g;                  $c{$cell}=$returnhash{$formula};
            $c{$_}=$returnhash{$key};                  $c{$ckey}=$returnhash{$formula};
                   $c{$ckey}=$returnhash{$key};              }
        }  
    }  
         }          }
           untie(%parmhash);
     }      }
     untie(%parmhash);      $self->constants(\%c);
    }  
    &setconstants($safeeval,%c);  
 }  }
   
 # --------------------------------------------------------- Various form fields  
   
 sub textfield {  
     my ($title,$name,$value)=@_;  
     return "\n<p><b>$title:</b><br>".  
            '<input type=text name="'.$name.'" size=80 value="'.$value.'">';  
 }  
   
 sub hiddenfield {  
     my ($name,$value)=@_;  
     return "\n".'<input type=hidden name="'.$name.'" value="'.$value.'">';  
 }  
   
 sub selectbox {  
     my ($title,$name,$value,%options)=@_;  
     my $selout="\n<p><b>$title:</b><br>".'<select name="'.$name.'">';  
     foreach (sort keys(%options)) {  
         $selout.='<option value="'.$_.'"';  
         if ($_ eq $value) { $selout.=' selected'; }  
         $selout.='>'.$options{$_}.'</option>';  
     }  
     return $selout.'</select>';  
 }  
   
 # =============================================== Update information in a sheet  # =============================================== Update information in a sheet
 #  #
 # Add new users or assessments, etc.  # Add new users or assessments, etc.
 #  #
   
 sub updatesheet {  sub updatesheet {
     my $safeeval=shift;      my $self = shift;
     my $stype=&gettype($safeeval);      if ($self->{'type'} eq 'classcalc') {
     if ($stype eq 'classcalc') {          return $self->updateclasssheet();
  return &updateclasssheet($safeeval);  
     } else {      } else {
         return &updatestudentassesssheet($safeeval);          return $self->updatestudentassesssheet();
     }      }
 }  }
   
Line 2146  sub updatesheet { Line 3376  sub updatesheet {
 #  #
 # Import the data for rows  # Import the data for rows
 #  #
   
 sub loadrows {  sub loadrows {
     my ($safeeval,$r)=@_;      my $self = shift;
     my $stype=&gettype($safeeval);      my ($r)=@_;
     if ($stype eq 'classcalc') {      my $c = $r->connection;
  &loadcourse($safeeval,$r);      if ($self->{'type'} eq 'classcalc') {
     } elsif ($stype eq 'studentcalc') {          $self->loadcourse($r,$c);
         &loadstudent($safeeval);      } elsif ($self->{'type'} eq 'studentcalc') {
     } else {          $self->loadstudent($r,$c);
         &loadassessment($safeeval);  
     }  
 }  
   
 # ======================================================= Forced recalculation?  
   
 sub checkthis {  
     my ($keyname,$time)=@_;  
     return ($time<$expiredates{$keyname});  
 }  
 sub forcedrecalc {  
     my ($uname,$udom,$stype,$usymb)=@_;  
     my $key=$uname.':'.$udom.':'.$stype.':'.$usymb;  
     my $time=$oldsheets{$key.'.time'};  
     if ($ENV{'form.forcerecalc'}) { return 1; }  
     unless ($time) { return 1; }  
     if ($stype eq 'assesscalc') {  
         my $map=(split(/\_\_\_/,$usymb))[0];  
         if (&checkthis('::assesscalc:',$time) ||  
             &checkthis('::assesscalc:'.$map,$time) ||  
             &checkthis('::assesscalc:'.$usymb,$time) ||  
             &checkthis($uname.':'.$udom.':assesscalc:',$time) ||  
             &checkthis($uname.':'.$udom.':assesscalc:'.$map,$time) ||  
             &checkthis($uname.':'.$udom.':assesscalc:'.$usymb,$time)) {  
             return 1;  
         }   
     } else {      } else {
         if (&checkthis('::studentcalc:',$time) ||           $self->loadassessment($r,$c);
             &checkthis($uname.':'.$udom.':studentcalc:',$time)) {  
     return 1;  
         }  
     }      }
     return 0;   
 }  }
   
 # ============================================================== Export handler  # ============================================================== Export handler
   # exportsheet
   # returns the export row for a spreadsheet.
 #  #
 # Non-interactive call from with program  
 #  
   
 sub exportsheet {  sub exportsheet {
  my ($uname,$udom,$stype,$usymb,$fn)=@_;      my $self = shift;
  my @exportarr=();      my ($uname,$udom,$stype,$usymb,$fn,$r)=@_;
       my $flag = 0;
  if (($usymb=~/^\_(\w+)/) && (!$fn)) {      $uname = $uname || $self->{'uname'};
     $fn='default_'.$1;      $udom  = $udom  || $self->{'udom'};
  }      $stype = $stype || $self->{'type'};
       my @exportarr=();
 #      # This handles the assessment sheets for '_feedback', etc
 # Check if cached      if (defined($usymb) && ($usymb=~/^\_(\w+)/) && 
 #          (!defined($fn) || $fn eq '')) {
           $fn='default_'.$1;
  my $key=$uname.':'.$udom.':'.$stype.':'.$usymb;      }
  my $found='';      #
       # Check if cached
  if ($oldsheets{$key}) {      #
      foreach (split(/\_\_\_\&\_\_\_/,$oldsheets{$key})) {      my $key=$uname.':'.$udom.':'.$stype.':'.$usymb;
          my ($name,$value)=split(/\_\_\_\=\_\_\_/,$_);      my $found='';
          if ($name eq $fn) {      if ($Apache::lonspreadsheet::oldsheets{$key}) {
      $found=$value;          foreach (split(/___&\___/,$Apache::lonspreadsheet::oldsheets{$key})) {
          }              my ($name,$value)=split(/___=___/,$_);
      }  
  }  
   
  unless ($found) {  
      &cachedssheets($uname,$udom,&Apache::lonnet::homeserver($uname,$udom));  
      if ($oldsheets{$key}) {  
  foreach (split(/\_\_\_\&\_\_\_/,$oldsheets{$key})) {  
             my ($name,$value)=split(/\_\_\_\=\_\_\_/,$_);  
             if ($name eq $fn) {              if ($name eq $fn) {
         $found=$value;                  $found=$value;
             }              }
         }   
      }  
  }  
 #  
 # Check if still valid  
 #  
  if ($found) {  
      if (&forcedrecalc($uname,$udom,$stype,$usymb)) {  
  $found='';  
      }  
  }  
    
  if ($found) {  
 #  
 # Return what was cached  
 #  
      @exportarr=split(/\_\_\_\;\_\_\_/,$found);  
   
  } else {  
 #  
 # Not cached  
 #          
   
     my $thissheet=&makenewsheet($uname,$udom,$stype,$usymb);  
     &readsheet($thissheet,$fn);  
     &updatesheet($thissheet);  
     &loadrows($thissheet);  
     &calcsheet($thissheet);   
     @exportarr=&exportdata($thissheet);  
 #  
 # Store now  
 #  
     my $cid=$ENV{'request.course.id'};   
     my $current='';  
     if ($stype eq 'studentcalc') {  
        $current=&Apache::lonnet::reply('get:'.  
                                      $ENV{'course.'.$cid.'.domain'}.':'.  
                                      $ENV{'course.'.$cid.'.num'}.  
      ':nohist_calculatedsheets:'.  
                                      &Apache::lonnet::escape($key),  
                                      $ENV{'course.'.$cid.'.home'});  
     } else {  
        $current=&Apache::lonnet::reply('get:'.  
                                      &getudom($thissheet).':'.  
                                      &getuname($thissheet).  
      ':nohist_calculatedsheets_'.  
                                      $ENV{'request.course.id'}.':'.  
                                      &Apache::lonnet::escape($key),  
                                      &getuhome($thissheet));  
   
     }  
     my %currentlystored=();  
     unless ($current=~/^error\:/) {  
        foreach (split(/\_\_\_\&\_\_\_/,&Apache::lonnet::unescape($current))) {  
            my ($name,$value)=split(/\_\_\_\=\_\_\_/,$_);  
            $currentlystored{$name}=$value;  
        }  
     }  
     $currentlystored{$fn}=join('___;___',@exportarr);  
   
     my $newstore='';  
     foreach (keys(%currentlystored)) {  
         if ($newstore) { $newstore.='___&___'; }  
         $newstore.=$_.'___=___'.$currentlystored{$_};  
     }  
     my $now=time;  
     if ($stype eq 'studentcalc') {  
        &Apache::lonnet::reply('put:'.  
                          $ENV{'course.'.$cid.'.domain'}.':'.  
                          $ENV{'course.'.$cid.'.num'}.  
  ':nohist_calculatedsheets:'.  
                          &Apache::lonnet::escape($key).'='.  
  &Apache::lonnet::escape($newstore).'&'.  
                          &Apache::lonnet::escape($key).'.time='.$now,  
                          $ENV{'course.'.$cid.'.home'});  
    } else {  
        &Apache::lonnet::reply('put:'.  
                          &getudom($thissheet).':'.  
                          &getuname($thissheet).  
  ':nohist_calculatedsheets_'.  
                          $ENV{'request.course.id'}.':'.  
                          &Apache::lonnet::escape($key).'='.  
  &Apache::lonnet::escape($newstore).'&'.  
                          &Apache::lonnet::escape($key).'.time='.$now,  
                          &getuhome($thissheet));  
    }  
  }  
  return @exportarr;  
 }  
 # ============================================================ Expiration Dates  
 #  
 # Load previously cached student spreadsheets for this course  
 #  
   
 sub expirationdates {  
     undef %expiredates;  
     my $cid=$ENV{'request.course.id'};  
     my $reply=&Apache::lonnet::reply('dump:'.  
      $ENV{'course.'.$cid.'.domain'}.':'.  
                                      $ENV{'course.'.$cid.'.num'}.  
      ':nohist_expirationdates',  
                                      $ENV{'course.'.$cid.'.home'});  
     unless ($reply=~/^error\:/) {  
  foreach (split(/\&/,$reply)) {  
             my ($name,$value)=split(/\=/,$_);  
             $expiredates{&Apache::lonnet::unescape($name)}  
                         =&Apache::lonnet::unescape($value);  
         }  
     }  
 }  
   
 # ===================================================== Calculated sheets cache  
 #  
 # Load previously cached student spreadsheets for this course  
 #  
   
 sub cachedcsheets {  
     my $cid=$ENV{'request.course.id'};  
     my $reply=&Apache::lonnet::reply('dump:'.  
      $ENV{'course.'.$cid.'.domain'}.':'.  
                                      $ENV{'course.'.$cid.'.num'}.  
      ':nohist_calculatedsheets',  
                                      $ENV{'course.'.$cid.'.home'});  
     unless ($reply=~/^error\:/) {  
  foreach ( split(/\&/,$reply)) {  
             my ($name,$value)=split(/\=/,$_);  
             $oldsheets{&Apache::lonnet::unescape($name)}  
                       =&Apache::lonnet::unescape($value);  
         }          }
     }      }
 }      unless ($found) {
           &cachedssheets($self,$uname,$udom);
 # ===================================================== Calculated sheets cache          if ($Apache::lonspreadsheet::oldsheets{$key}) {
 #              foreach (split(/___&\___/,$Apache::lonspreadsheet::oldsheets{$key})) {
 # Load previously cached assessment spreadsheets for this student                  my ($name,$value)=split(/___=___/,$_);
 #                  if ($name eq $fn) {
                       $found=$value;
 sub cachedssheets {                  }
   my ($sname,$sdom,$shome)=@_;              } 
   unless (($loadedcaches{$sname.'_'.$sdom}) || ($shome eq 'no_host')) {  
     my $cid=$ENV{'request.course.id'};  
     my $reply=&Apache::lonnet::reply('dump:'.$sdom.':'.$sname.  
              ':nohist_calculatedsheets_'.  
                                       $ENV{'request.course.id'},  
                                      $shome);  
     unless ($reply=~/^error\:/) {  
  foreach ( split(/\&/,$reply)) {  
             my ($name,$value)=split(/\=/,$_);  
             $oldsheets{&Apache::lonnet::unescape($name)}  
                       =&Apache::lonnet::unescape($value);  
         }          }
     }      }
     $loadedcaches{$sname.'_'.$sdom}=1;      #
   }      # Check if still valid
 }      #
       if ($found) {
 # ===================================================== Calculated sheets cache          if (&forcedrecalc($uname,$udom,$stype,$usymb)) {
 #              $found='';
 # Load previously cached assessment spreadsheets for this student  
 #  
   
 # ================================================================ Main handler  
 #  
 # Interactive call to screen  
 #  
 #  
   
   
 sub handler {  
     my $r=shift;  
   
     if ($r->header_only) {  
       $r->content_type('text/html');  
       $r->send_http_header;  
       return OK;  
     }  
   
 # ---------------------------------------------------- Global directory configs  
   
 $includedir=$r->dir_config('lonIncludes');  
 $tmpdir=$r->dir_config('lonDaemons').'/tmp/';  
   
 # ----------------------------------------------------- Needs to be in a course  
   
   if ($ENV{'request.course.fn'}) {   
   
 # --------------------------- Get query string for limited number of parameters  
   
     &Apache::loncommon::get_unprocessed_cgi($ENV{'QUERY_STRING'},  
                                             ['uname','udom','usymb','ufn']);  
   
     if (($ENV{'form.usymb'}=~/^\_(\w+)/) && (!$ENV{'form.ufn'})) {  
  $ENV{'form.ufn'}='default_'.$1;  
     }  
   
 # -------------------------------------- Interactive loading of specific sheet?  
     if (($ENV{'form.load'}) && ($ENV{'form.loadthissheet'} ne 'Default')) {  
  $ENV{'form.ufn'}=$ENV{'form.loadthissheet'};  
     }  
 # ------------------------------------------- Nothing there? Must be login user  
   
     my $aname;  
     my $adom;  
   
     unless ($ENV{'form.uname'}) {  
  $aname=$ENV{'user.name'};  
         $adom=$ENV{'user.domain'};  
     } else {  
         $aname=$ENV{'form.uname'};  
         $adom=$ENV{'form.udom'};  
     }  
   
 # ------------------------------------------------------------------- Open page  
   
     $r->content_type('text/html');  
     $r->header_out('Cache-control','no-cache');  
     $r->header_out('Pragma','no-cache');  
     $r->send_http_header;  
   
 # --------------------------------------------------------------- Screen output  
   
     $r->print('<html><head><title>LON-CAPA Spreadsheet</title>');  
     $r->print(<<ENDSCRIPT);  
 <script language="JavaScript">  
   
     function celledit(cn,cf) {  
         var cnf=prompt(cn,cf);  
         if (cnf!=null) {  
             document.sheet.unewfield.value=cn;  
             document.sheet.unewformula.value=cnf;  
             document.sheet.submit();  
         }          }
     }      }
       if ($found) {
     function changesheet(cn) {          #
  document.sheet.unewfield.value=cn;          # Return what was cached
         document.sheet.unewformula.value='changesheet';          #
         document.sheet.submit();          @exportarr=split(/___;___/,$found);
     }          return @exportarr;
   
     function insertrow(cn) {  
  document.sheet.unewfield.value='insertrow';  
         document.sheet.unewformula.value=cn;  
         document.sheet.submit();  
     }      }
       #
 </script>      # Not cached
 ENDSCRIPT      #
     $r->print('</head><body bgcolor="#FFFFFF">'.      my $newsheet = Apache::lonspreadsheet::Spreadsheet->new($uname,$udom,
        '<img align=right src=/adm/lonIcons/lonlogos.gif>'.                                                           $stype,$usymb);
        '<h1>LON-CAPA Spreadsheet</h1>'.      $newsheet->readsheet($fn);
        '<form action="'.$r->uri.'" name=sheet method=post>'.      $newsheet->updatesheet();
        &hiddenfield('uname',$ENV{'form.uname'}).      $newsheet->loadrows($r);
        &hiddenfield('udom',$ENV{'form.udom'}).      $newsheet->calcsheet(); 
        &hiddenfield('usymb',$ENV{'form.usymb'}).      @exportarr=$newsheet->exportdata();
        &hiddenfield('unewfield','').      ##
        &hiddenfield('unewformula',''));      ## Store now
       ##
 # ---------------------- Make sure that this gets out, even if user hits "stop"      #
       # load in the old value
     $r->rflush();      #
       my %currentlystored=();
 # ---------------------------------------------------------------- Full recalc?      if ($stype eq 'studentcalc') {
           my @tmp = &Apache::lonnet::get('nohist_calculatedsheets',
                                          [$key],
     if ($ENV{'form.forcerecalc'}) {                                         $self->{'cdom'},$self->{'cnum'});
  $r->print('<h4>Completely Recalculating Sheet ...</h4>');          if ($tmp[0]!~/^error/) {
         undef %spreadsheets;              # We only got one key, so we will access it directly.
         undef %courserdatas;              foreach (split('___&___',$tmp[1])) {
         undef %userrdatas;                  my ($key,$value) = split('___=___',$_);
         undef %defaultsheets;                  $key = '' if (! defined($key));
         undef %updatedata;                  $currentlystored{$key} = $value;
    }              }
    
 # ---------------------------------------- Read new sheet or modified worksheet  
   
     $r->uri=~/\/(\w+)$/;  
   
     my $asheet=&makenewsheet($aname,$adom,$1,$ENV{'form.usymb'});  
   
 # ------------------------ If a new formula had been entered, go from work copy  
   
     if ($ENV{'form.unewfield'}) {  
         $r->print('<h2>Modified Workcopy</h2>');  
         $ENV{'form.unewformula'}=~s/\'/\"/g;  
         $r->print('<p>New formula: '.$ENV{'form.unewfield'}.'='.  
                   $ENV{'form.unewformula'}.'<p>');  
         &setfilename($asheet,$ENV{'form.ufn'});  
  &tmpread($asheet,  
                  $ENV{'form.unewfield'},$ENV{'form.unewformula'});  
   
      } elsif ($ENV{'form.saveas'}) {  
         &setfilename($asheet,$ENV{'form.ufn'});  
  &tmpread($asheet);  
     } else {  
         &readsheet($asheet,$ENV{'form.ufn'});  
     }  
   
 # -------------------------------------------------- Print out user information  
   
     unless (&gettype($asheet) eq 'classcalc') {  
         $r->print('<p><b>User:</b> '.&getuname($asheet).  
                   '<br><b>Domain:</b> '.&getudom($asheet));  
         if (&getcsec($asheet) eq '-1') {  
            $r->print('<h3><font color=red>'.  
                      'Not a student in this course</font></h3>');  
         } else {  
            $r->print('<br><b>Section/Group:</b> '.&getcsec($asheet));  
         }  
         if ($ENV{'form.usymb'}) {  
            $r->print('<br><b>Assessment:</b> <tt>'.$ENV{'form.usymb'}.'</tt>');  
         }  
     }  
   
 # ---------------------------------------------------------------- Course title  
   
     $r->print('<h1>'.  
             $ENV{'course.'.$ENV{'request.course.id'}.'.description'}.  
              '</h1><h3>'.localtime().'</h3>');  
   
 # ---------------------------------------------------- See if user can see this  
   
     if ((&gettype($asheet) eq 'classcalc') ||   
         (&getuname($asheet) ne $ENV{'user.name'}) ||  
         (&getudom($asheet) ne $ENV{'user.domain'})) {  
         unless (&Apache::lonnet::allowed('vgr',&getcid($asheet))) {  
     $r->print(  
            '<h1>Access Permission Denied</h1></form></body></html>');  
             return OK;  
         }          }
     }      } else {
           my @tmp = &Apache::lonnet::get('nohist_calculatedsheets_'.
 # ---------------------------------------------------------- Additional options                                         $self->{'cid'},[$key],
                                          $self->{'udom'},$self->{'uname'});
     $r->print(          if ($tmp[0]!~/^error/) {
  '<input type=submit name=forcerecalc value="Completely Recalculate Sheet"><p>'              # We only got one key, so we will access it directly.
  );              foreach (split('___&___',$tmp[1])) {
     if (&gettype($asheet) eq 'assesscalc') {                  my ($key,$value) = split('___=___',$_);
        $r->print ('<p><font size=+2><a href="/adm/studentcalc?uname='.                  $key = '' if (! defined($key));
                                                &getuname($asheet).                  $currentlystored{$key} = $value;
                                                '&udom='.&getudom($asheet).  
                   '">Level up: Student Sheet</a></font><p>');  
     }  
       
     if ((&gettype($asheet) eq 'studentcalc') &&   
         (&Apache::lonnet::allowed('vgr',&getcid($asheet)))) {  
        $r->print (  
                    '<p><font size=+2><a href="/adm/classcalc">'.  
                    'Level up: Course Sheet</a></font><p>');  
     }  
       
   
 # ----------------------------------------------------------------- Save dialog  
   
   
     if (&Apache::lonnet::allowed('opa',$ENV{'request.course.id'})) {  
         my $fname=$ENV{'form.ufn'};  
         $fname=~s/\_[^\_]+$//;  
         if ($fname eq 'default') { $fname='course_default'; }  
         $r->print('<input type=submit name=saveas value="Save as ...">'.  
               '<input type=text size=20 name=newfn value="'.$fname.  
               '"> (make default: <input type=checkbox name="makedefufn">)<p>');  
     }  
   
     $r->print(&hiddenfield('ufn',&getfilename($asheet)));  
   
 # ----------------------------------------------------------------- Load dialog  
     if (&Apache::lonnet::allowed('opa',$ENV{'request.course.id'})) {  
  $r->print('<p><input type=submit name=load value="Load ...">'.  
                   '<select name="loadthissheet">'.  
                   '<option name="default">Default</option>');  
         foreach (&othersheets($asheet,&gettype($asheet))) {  
     $r->print('<option name="'.$_.'"');  
             if ($ENV{'form.ufn'} eq $_) {  
                $r->print(' selected');  
             }              }
             $r->print('>'.$_.'</option>');  
         }   
         $r->print('</select><p>');  
         if (&gettype($asheet) eq 'studentcalc') {  
     &setothersheets($asheet,&othersheets($asheet,'assesscalc'));  
         }          }
     }      }
       #
 # --------------------------------------------------------------- Cached sheets      # Add the new line
       #
     &expirationdates();      $currentlystored{$fn}=join('___;___',@exportarr);
       #
     undef %oldsheets;      # Stick everything back together
     undef %loadedcaches;      #
       my $newstore='';
     if (&gettype($asheet) eq 'classcalc') {      foreach (keys(%currentlystored)) {
         $r->print("Loading previously calculated student sheets ...<br>\n");          if ($newstore) { $newstore.='___&___'; }
         $r->rflush();          $newstore.=$_.'___=___'.$currentlystored{$_};
         &cachedcsheets();  
     } elsif (&gettype($asheet) eq 'studentcalc') {  
         $r->print("Loading previously calculated assessment sheets ...<br>\n");  
         $r->rflush();  
         &cachedssheets(&getuname($asheet),&getudom($asheet),  
                        &getuhome($asheet));  
     }  
   
 # ----------------------------------------------------- Update sheet, load rows  
   
     $r->print("Loaded sheet(s), updating rows ...<br>\n");  
     $r->rflush();  
   
     &updatesheet($asheet);  
   
     $r->print("Updated rows, loading row data ...<br>\n");  
     $r->rflush();  
   
     &loadrows($asheet,$r);  
   
     $r->print("Loaded row data, calculating sheet ...<br>\n");  
     $r->rflush();  
   
     my $calcoutput=&calcsheet($asheet);  
     $r->print('<h3><font color=red>'.$calcoutput.'</h3></font>');  
   
 # ---------------------------------------------------- See if something to save  
   
     if (&Apache::lonnet::allowed('opa',$ENV{'request.course.id'})) {  
         my $fname='';  
  if ($ENV{'form.saveas'} && ($fname=$ENV{'form.newfn'})) {  
             $fname=~s/\W/\_/g;  
             if ($fname eq 'default') { $fname='course_default'; }  
             $fname.='_'.&gettype($asheet);  
             &setfilename($asheet,$fname);  
             $ENV{'form.ufn'}=$fname;  
     $r->print('<p>Saving spreadsheet: '.  
                          &writesheet($asheet,$ENV{'form.makedefufn'}).'<p>');  
  }  
     }      }
       my $now=time;
 # ------------------------------------------------ Write the modified worksheet      #
       # Store away the new value
    $r->print('<b>Current sheet:</b> '.&getfilename($asheet).'<p>');      #
       my $timekey = $key.'.time';
    &tmpwrite($asheet);      if ($stype eq 'studentcalc') {
           my $result = &Apache::lonnet::put('nohist_calculatedsheets',
     if (&gettype($asheet) eq 'studentcalc') {                                            { $key     => $newstore,
  $r->print('<br>Show rows with empty A column: ');                                              $timekey => $now },
     } else {                                            $self->{'cdom'},
         $r->print('<br>Show empty rows: ');                                            $self->{'cnum'});
     }       } else {
           my $result = &Apache::lonnet::put('nohist_calculatedsheets_'.$self->{'cid'},
     $r->print(&hiddenfield('userselhidden','true').                                            { $key     => $newstore,
              '<input type=checkbox name=showall onClick="submit()"');                                              $timekey => $now },
                                             $self->{'udom'},
     if ($ENV{'form.showall'}) {                                             $self->{'uname'});
        $r->print(' checked');   
     } else {  
  unless ($ENV{'form.userselhidden'}) {  
            unless   
  ($ENV{'course.'.$ENV{'request.course.id'}.'.hideemptyrows'} eq 'yes') {  
           $r->print(' checked');  
           $ENV{'form.showall'}=1;  
            }  
        }  
     }      }
     $r->print('>');      return @exportarr;
   
     if (&gettype($asheet) eq 'classcalc') {  
        $r->print(  
    ' Output CSV format: <input type=checkbox name=showcsv onClick="submit()"');  
        if ($ENV{'form.showcsv'}) { $r->print(' checked'); }  
        $r->print('>');  
     }  
   
 # ------------------------------------------------------------------ Insertrows  
   
    $r->print(<<ENDINSERTBUTTONS);  
 <br>  
 <input type='button' onClick='insertrow("top");'   
 value='Insert Row Top'>  
 <input type='button' onClick='insertrow("bottom");'   
 value='Insert Row Bottom'><br>  
 ENDINSERTBUTTONS  
   
 # ------------------------------------------------------------- Print out sheet  
   
     &outsheet($r,$asheet);  
     $r->print('</form></body></html>');  
   
 # ------------------------------------------------------------------------ Done  
   } else {  
 # ----------------------------- Not in a course, or not allowed to modify parms  
       $ENV{'user.error.msg'}=  
         $r->uri.":opa:0:0:Cannot modify spreadsheet";  
       return HTTP_NOT_ACCEPTABLE;   
   }  
     return OK;  
   
 }  }
   
 1;  1;
 __END__  
   
   
   __END__
   
   
Removed from v.1.93  
changed lines
  Added in v.1.173

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