[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.17 and 1.70

version 1.17, 2000/12/18 13:45:40 version 1.70, 2001/10/17 21:11:22
Line 2 Line 2
 # Spreadsheet/Grades Display Handler  # Spreadsheet/Grades Display Handler
 #  #
 # 11/11,11/15,11/27,12/04,12/05,12/06,12/07,  # 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 Gerd Kortemeyer  # 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 Gerd Kortemeyer
   
 package Apache::lonspreadsheet;  package Apache::lonspreadsheet;
               
 use strict;  use strict;
 use Safe;  use Safe;
 use Safe::Hole;  use Safe::Hole;
 use Opcode;  use Opcode;
 use Apache::lonnet;  use Apache::lonnet;
 use Apache::Constants qw(:common :http);  use Apache::Constants qw(:common :http);
 use HTML::TokeParser;  
 use GDBM_File;  use GDBM_File;
   use HTML::TokeParser;
   
   #
   # Caches for previously calculated spreadsheets
   #
   
   my %oldsheets;
   my %loadedcaches;
   my %expiredates;
   
   #
   # Cache for stores of an individual user
   #
   
   my $cachedassess;
   my %cachedstores;
   
 #  #
 # These cache hashes need to be independent of user, resource and course  # These cache hashes need to be independent of user, resource and course
 # (user and course are in the keys)  # (user and course can/should be in the keys)
 #  #
 use vars qw(%spreadsheets %courserdatas %userrdatas);  
   my %spreadsheets;
   my %courserdatas;
   my %userrdatas;
   my %defaultsheets;
   my %updatedata;
   
 #  #
 # These global hashes are dependent on user, course and resource,   # These global hashes are dependent on user, course and resource, 
 # and need to be initialized every time when a sheet is calculated  # and need to be initialized every time when a sheet is calculated
Line 27  use vars qw(%spreadsheets %courserdatas Line 53  use vars qw(%spreadsheets %courserdatas
 my %courseopt;  my %courseopt;
 my %useropt;  my %useropt;
 my %parmhash;  my %parmhash;
 my $csec;  
 my $uname;  # Stuff that only the screen handler can know
 my $udom;  
   my $includedir;
   my $tmpdir;
   
 # =============================================================================  # =============================================================================
 # ===================================== Implements an instance of a spreadsheet  # ===================================== Implements an instance of a spreadsheet
   
 sub initsheet {  sub initsheet {
     my $safeeval = new Safe;      my $safeeval = new Safe(shift);
     my $safehole = new Safe::Hole;      my $safehole = new Safe::Hole;
     $safeeval->permit("entereval");      $safeeval->permit("entereval");
     $safeeval->permit(":base_math");      $safeeval->permit(":base_math");
Line 51  sub initsheet { Line 79  sub initsheet {
 # v: output values  # v: output values
 # c: preloaded constants (A-column)  # c: preloaded constants (A-column)
 # rl: row label  # rl: row label
   # os: other spreadsheets (for student spreadsheet only)
   
 %v=();   undef %v; 
 %t=();  undef %t;
 %f=();  undef %f;
 %c=();  undef %c;
 %rl=();  undef %rl;
   undef @os;
   
 $maxrow=0;  $maxrow=0;
 $sheettype='';  $sheettype='';
   
   # filename/reference of the sheet
   
 $filename='';  $filename='';
   
   # user data
   $uname='';
   $uhome='';
   $udom='';
   
   # course data
   
   $csec='';
   $chome='';
   $cnum='';
   $cdom='';
   $cid='';
   $cfn='';
   
   # symb
   
   $usymb='';
   
 sub mask {  sub mask {
     my ($lower,$upper)=@_;      my ($lower,$upper)=@_;
   
Line 258  sub SUMMIN { Line 309  sub SUMMIN {
     return $sum;         return $sum;   
 }  }
   
   sub expandnamed {
       my $expression=shift;
       if ($expression=~/^\&/) {
    my ($func,$var,$formula)=($expression=~/^\&(\w+)\(([^\;]+)\;(.*)\)/);
    my @vars=split(/\W+/,$formula);
           my %values=();
           undef %values;
           map {
               my $varname=$_;
               if ($varname=~/\D/) {
                  $formula=~s/$varname/'$c{\''.$varname.'\'}'/ge;
                  $varname=~s/$var/\(\\w\+\)/g;
          map {
     if ($_=~/$varname/) {
         $values{$1}=1;
                     }
                  } keys %c;
       }
           } @vars;
           if ($func eq 'EXPANDSUM') {
               my $result='';
       map {
                   my $thissum=$formula;
                   $thissum=~s/$var/$_/g;
                   $result.=$thissum.'+';
               } keys %values;
               $result=~s/\+$//;
               return $result;
           } else {
       return 0;
           }
       } else {
           return '$c{\''.$expression.'\'}';
       }
   }
   
 sub sett {  sub sett {
     %t=();      %t=();
     my $pattern='';      my $pattern='';
Line 267  sub sett { Line 354  sub sett {
         $pattern='[A-Z]';          $pattern='[A-Z]';
     }      }
     map {      map {
  if ($f{$_}) {   if ($_=~/template\_(\w)/) {
             if ($_=~/^$pattern/) {    my $col=$1;
             unless ($col=~/^$pattern/) {
               map {
         if ($_=~/A(\d+)/) {
    my $trow=$1;
                   if ($trow) {
       my $lb=$col.$trow;
                       $t{$lb}=$f{'template_'.$col};
                       $t{$lb}=~s/\#/$trow/g;
                       $t{$lb}=~s/\.\.+/\,/g;
                       $t{$lb}=~s/(^|[^\"\'])([A-Za-z]\d+)/$1\$v\{\'$2\'\}/g;
                       $t{$lb}=~s/(^|[^\"\'])\[([^\]]+)\]/$1.&expandnamed($2)/ge;
                   }
         }
               } keys %f;
     }
         }
       } keys %f;
       map {
    if (($f{$_}) && ($_!~/template\_/)) {
               my $matches=($_=~/^$pattern(\d+)/);
               if  (($matches) && ($1)) {
         unless ($f{$_}=~/^\!/) {          unless ($f{$_}=~/^\!/) {
     $t{$_}=$c{$_};      $t{$_}=$c{$_};
                 }                  }
Line 276  sub sett { Line 384  sub sett {
        $t{$_}=$f{$_};         $t{$_}=$f{$_};
                $t{$_}=~s/\.\.+/\,/g;                 $t{$_}=~s/\.\.+/\,/g;
                $t{$_}=~s/(^|[^\"\'])([A-Za-z]\d+)/$1\$v\{\'$2\'\}/g;                 $t{$_}=~s/(^|[^\"\'])([A-Za-z]\d+)/$1\$v\{\'$2\'\}/g;
                  $t{$_}=~s/(^|[^\"\'])\[([^\]]+)\]/$1.&expandnamed($2)/ge;
             }              }
         }          }
     } keys %f;      } keys %f;
     $t{'A0'}=$f{'A0'};      $t{'A0'}=$f{'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\$v\{\'$2\'\}/g;
       $t{'A0'}=~s/(^|[^\"\'])\[([^\]]+)\]/$1.&expandnamed($2)/ge;
 }  }
   
 sub calc {  sub calc {
Line 309  sub calc { Line 419  sub calc {
     return '';      return '';
 }  }
   
   sub templaterow {
       my @cols=();
       $cols[0]='<b><font size=+1>Template</font></b>';
       map {
           my $fm=$f{'template_'.$_};
           $fm=~s/[\'\"]/\&\#34;/g;
           $cols[$#cols+1]="'template_$_','$fm'".'___eq___'.$fm;
       } ('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');
       return @cols;
   }
   
 sub outrowassess {  sub outrowassess {
     my $n=shift;      my $n=shift;
     my @cols=();      my @cols=();
     if ($n) {      if ($n) {
          my ($usy,$ufn)=split(/\_\_\&\&\&\_\_/,$f{'A'.$n});
          $cols[0]=$rl{$usy}.'<br>'.
                   '<select name="sel_'.$n.'" onChange="changesheet('.$n.
                   ')"><option name="default">Default</option>';
          map {
              $cols[0].='<option name="'.$_.'"';
               if ($ufn eq $_) {
                  $cols[0].=' selected';
               }
               $cols[0].='>'.$_.'</option>';
          } @os;
          $cols[0].='</select>';
       } else {
          $cols[0]='<b><font size=+1>Export</font></b>';
       }
       map {
           my $fm=$f{$_.$n};
           $fm=~s/[\'\"]/\&\#34;/g;
           $cols[$#cols+1]="'$_$n','$fm'".'___eq___'.$v{$_.$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',
          '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');
       return @cols;
   }
   
   sub outrow {
       my $n=shift;
       my @cols=();
       if ($n) {
        $cols[0]=$rl{$f{'A'.$n}};         $cols[0]=$rl{$f{'A'.$n}};
     } else {      } else {
        $cols[0]='<b><font size=+1>Export</font></b>';         $cols[0]='<b><font size=+1>Export</font></b>';
Line 329  sub outrowassess { Line 483  sub outrowassess {
 }  }
   
 sub exportrowa {  sub exportrowa {
     my $rowa='';      my @exportarray=();
     map {      map {
  $rowa.=$v{$_.'0'}."','";   $exportarray[$#exportarray+1]=$v{$_.'0'};
     } ('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');
     $rowa=~s/\'\,\'$//;      return @exportarray;
     return $rowa;  
 }  }
   
 # ------------------------------------------- End of "Inside of the safe space"  # ------------------------------------------- End of "Inside of the safe space"
Line 347  ENDDEFS Line 500  ENDDEFS
 # ------------------------------------------------ Add or change formula values  # ------------------------------------------------ Add or change formula values
   
 sub setformulas {  sub setformulas {
     my ($safeeval,@f)=@_;      my ($safeeval,%f)=@_;
     $safeeval->reval('%f='."('".join("','",@f)."');");      %{$safeeval->varglob('f')}=%f;
 }  }
   
 # ------------------------------------------------ Add or change formula values  # ------------------------------------------------ Add or change formula values
   
 sub setconstants {  sub setconstants {
     my ($safeeval,@c)=@_;      my ($safeeval,%c)=@_;
     $safeeval->reval('%c='."('".join("','",@c)."');");      %{$safeeval->varglob('c')}=%c;
   }
   
   # --------------------------------------------- Set names of other spreadsheets
   
   sub setothersheets {
       my ($safeeval,@os)=@_;
       @{$safeeval->varglob('os')}=@os;
 }  }
   
 # ------------------------------------------------ Add or change formula values  # ------------------------------------------------ Add or change formula values
   
 sub setrowlabels {  sub setrowlabels {
     my ($safeeval,@rl)=@_;      my ($safeeval,%rl)=@_;
     $safeeval->reval('%rl='."('".join("','",@rl)."');");      %{$safeeval->varglob('rl')}=%rl;
 }  }
   
 # ------------------------------------------------------- Calculate spreadsheet  # ------------------------------------------------------- Calculate spreadsheet
Line 383  sub getvalues { Line 543  sub getvalues {
   
 sub getformulas {  sub getformulas {
     my $safeeval=shift;      my $safeeval=shift;
     return $safeeval->reval('%f');      return %{$safeeval->varglob('f')};
 }  
   
 # -------------------------------------------------------------------- Set type  
   
 sub settype {  
     my ($safeeval,$type)=@_;  
     $safeeval->reval('$sheettype="'.$type.'";');  
 }  }
   
 # -------------------------------------------------------------------- Get type  # -------------------------------------------------------------------- Get type
Line 399  sub gettype { Line 552  sub gettype {
     my $safeeval=shift;      my $safeeval=shift;
     return $safeeval->reval('$sheettype');      return $safeeval->reval('$sheettype');
 }  }
   
 # ------------------------------------------------------------------ Set maxrow  # ------------------------------------------------------------------ Set maxrow
   
 sub setmaxrow {  sub setmaxrow {
Line 427  sub getfilename { Line 581  sub getfilename {
     return $safeeval->reval('$filename');      return $safeeval->reval('$filename');
 }  }
   
   # --------------------------------------------------------------- Get course ID
   
   sub getcid {
       my $safeeval=shift;
       return $safeeval->reval('$cid');
   }
   
   # --------------------------------------------------------- Get course filename
   
   sub getcfn {
       my $safeeval=shift;
       return $safeeval->reval('$cfn');
   }
   
   # ----------------------------------------------------------- Get course number
   
   sub getcnum {
       my $safeeval=shift;
       return $safeeval->reval('$cnum');
   }
   
   # ------------------------------------------------------------- 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
   
   sub getcsec {
       my $safeeval=shift;
       return $safeeval->reval('$csec');
   }
   
   # --------------------------------------------------------------- Get user name
   
   sub getuname {
       my $safeeval=shift;
       return $safeeval->reval('$uname');
   }
   
   # ------------------------------------------------------------- Get user domain
   
   sub getudom {
       my $safeeval=shift;
       return $safeeval->reval('$udom');
   }
   
   # --------------------------------------------------------------- Get user home
   
   sub getuhome {
       my $safeeval=shift;
       return $safeeval->reval('$uhome');
   }
   
   # -------------------------------------------------------------------- Get symb
   
   sub getusymb {
       my $safeeval=shift;
       return $safeeval->reval('$usymb');
   }
   
 # ------------------------------------------------------------- Export of A-row  # ------------------------------------------------------------- Export of A-row
   
 sub exportrow {  sub exportdata {
     my $safeeval=shift;      my $safeeval=shift;
     return $safeeval->reval('&exportrowa()');      return $safeeval->reval('&exportrowa()');
 }  }
   
   
 # ========================================================== End of Spreadsheet  # ========================================================== End of Spreadsheet
 # =============================================================================  # =============================================================================
   
   #
   # Procedures for screen output
   #
 # --------------------------------------------- Produce output row n from sheet  # --------------------------------------------- Produce output row n from sheet
   
 sub rown {  sub rown {
     my ($safeeval,$n)=@_;      my ($safeeval,$n)=@_;
     my $defaultbg=((($n-1)/5)==int(($n-1)/5))?'#E0E0':'#FFFF';      my $defaultbg;
     my $rowdata="\n<tr><td><b><font size=+1>$n</font></b></td>";      my $rowdata='';
       my $dataflag=0;
       unless ($n eq '-') {
          $defaultbg=((($n-1)/5)==int(($n-1)/5))?'#E0E0':'#FFFF';
       } else {
          $defaultbg='#E0FF';
       }
       $rowdata.="\n<tr><td><b><font size=+1>$n</font></b></td>";
     my $showf=0;      my $showf=0;
     my $proc;      my $proc;
     if (&gettype($safeeval) eq 'assesscalc') {      my $maxred;
       my $sheettype=&gettype($safeeval);
       if ($sheettype eq 'studentcalc') {
         $proc='&outrowassess';          $proc='&outrowassess';
           $maxred=26;
     } else {      } else {
         $proc='&outrow';          $proc='&outrow';
     }      }
       if ($sheettype eq 'assesscalc') {
           $maxred=1;
       } else {
           $maxred=26;
       }
       if ($n eq '-') { $proc='&templaterow'; $n=-1; $dataflag=1; }
     map {      map {
        my $bgcolor=$defaultbg.((($showf-1)/5==int(($showf-1)/5))?'99':'DD');         my $bgcolor=$defaultbg.((($showf-1)/5==int(($showf-1)/5))?'99':'DD');
        my ($fm,$vl)=split(/\_\_\_eq\_\_\_/,$_);         my ($fm,$vl)=split(/\_\_\_eq\_\_\_/,$_);
          if ((($vl ne '') || ($vl eq '0')) &&
              (($showf==1) || ($sheettype ne 'studentcalc'))) { $dataflag=1; }
        if ($showf==0) { $vl=$_; }         if ($showf==0) { $vl=$_; }
        if ($showf<=1) { $bgcolor='#FFDDDD'; }         if ($showf<=$maxred) { $bgcolor='#FFDDDD'; }
        if (($n==0) && ($showf<=26)) { $bgcolor='#CCCCFF'; }          if (($n==0) && ($showf<=26)) { $bgcolor='#CCCCFF'; } 
        if (($showf>1) || ((!$n) && ($showf>0))) {         if (($showf>$maxred) || ((!$n) && ($showf>0))) {
    if ($vl eq '') {     if ($vl eq '') {
        $vl='<font size=+2 color='.$bgcolor.'>&#35;</font>';         $vl='<font size=+2 color='.$bgcolor.'>&#35;</font>';
            }             }
Line 469  sub rown { Line 714  sub rown {
        }         }
        $showf++;         $showf++;
     } $safeeval->reval($proc.'('.$n.')');      } $safeeval->reval($proc.'('.$n.')');
     return $rowdata.'</tr>';      if ($ENV{'form.showall'} || ($dataflag)) {
          return $rowdata.'</tr>';
       } else {
          return '';
       }
 }  }
   
 # ------------------------------------------------------------- Print out sheet  # ------------------------------------------------------------- Print out sheet
   
 sub outsheet {  sub outsheet {
     my $safeeval=shift;      my ($r,$safeeval)=@_;
     my $tabledata='<table border=2><tr><td colspan=2>&nbsp;</td>'.      my $maxred;
                   '<td bgcolor=#FFDDDD><b>A Import</b></td>';      my $realm;
       if (&gettype($safeeval) eq 'assesscalc') {
           $maxred=1;
           $realm='Assessment';
       } elsif (&gettype($safeeval) eq 'studentcalc') {
           $maxred=26;
           $realm='User';
       } else {
           $maxred=26;
           $realm='Course';
       }
       my $maxyellow=52-$maxred;
       my $tabledata=
           '<table border=2><tr><th colspan=2 rowspan=2><font size=+2>'.
                     $realm.'</font></th>'.
                     '<td bgcolor=#FFDDDD colspan='.$maxred.
                     '><b><font size=+1>Import</font></b></td>'.
                     '<td colspan='.$maxyellow.
     '><b><font size=+1>Calculations</font></b></td></tr><tr>';
       my $showf=0;
     map {      map {
         $tabledata.="<td><b><font size=+1>$_</font></b></td>";          $showf++;
     } ('B','C','D','E','F','G','H','I','J','K','L','M',          if ($showf<=$maxred) { 
              $tabledata.='<td bgcolor="#FFDDDD">'; 
           } else {
              $tabledata.='<td>';
           }
           $tabledata.="<b><font size=+1>$_</font></b></td>";
       } ('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');
     $tabledata.='</tr>';      $tabledata.='</tr>';
     my $row;      my $row;
     my $maxrow=&getmaxrow($safeeval);      my $maxrow=&getmaxrow($safeeval);
     for ($row=0;$row<=$maxrow;$row++) {      $tabledata.=&rown($safeeval,'-').&rown($safeeval,0);
         $tabledata.=&rown($safeeval,$row);      $r->print($tabledata);
   
       my @sortby=();
       my @sortidx=();
       for ($row=1;$row<=$maxrow;$row++) {
          $sortby[$row-1]=$safeeval->reval('$f{"A'.$row.'"}');
          $sortidx[$row-1]=$row-1;
       }
       @sortidx=sort { $sortby[$a] cmp $sortby[$b]; } @sortidx;
   
           my $what='Student';
           if (&gettype($safeeval) eq 'assesscalc') {
       $what='Item';
    } elsif (&gettype($safeeval) eq 'studentcalc') {
               $what='Assessment';
           }
   
       my $n=0;
       for ($row=0;$row<$maxrow;$row++) {
        my $thisrow=&rown($safeeval,$sortidx[$row]+1);
        if ($thisrow) {
          if ($n/25==int($n/25)) {
    $r->print("</table>\n<br>\n");
           $r->rflush();
           $r->print('<table border=2><tr><td>&nbsp;<td>'.$what.'</td>');
           map {
              $r->print('<td>'.$_.'</td>');
           } ('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('</tr>');
          }
          $n++;
          $r->print($thisrow);
         }
     }      }
     $tabledata.='</table>';      $r->print('</table>');
 }  }
   
   #
   # ----------------------------------------------- Read list of available sheets
   # 
   
   sub othersheets {
       my ($safeeval,$stype)=@_;
   
       my $cnum=&getcnum($safeeval);
       my $cdom=&getcdom($safeeval);
       my $chome=&getchome($safeeval);
   
       my @alternatives=();
       my $result=&Apache::lonnet::reply('dump:'.$cdom.':'.$cnum.':'.
                                         $stype.'_spreadsheets',$chome);
       if ($result!~/^error\:/) {
    map {
               $alternatives[$#alternatives+1]=
               &Apache::lonnet::unescape((split(/\=/,$_))[0]);
           } split(/\&/,$result);
       } 
       return @alternatives; 
   }
   
 # --------------------------------------- Read spreadsheet formulas from a file  #
   # -------------------------------------- Read spreadsheet formulas for a course
   #
   
 sub readsheet {  sub readsheet {
     my ($safeeval,$fn)=@_;    my ($safeeval,$fn)=@_;
     &setfilename($safeeval,$fn);    my $stype=&gettype($safeeval);
     $fn=~/\.(\w+)/;    my $cnum=&getcnum($safeeval);
     &settype($safeeval,$1);    my $cdom=&getcdom($safeeval);
     my %f=();    my $chome=&getchome($safeeval);
     unless ($spreadsheets{$fn}) {  
        $spreadsheets{$fn}='';  # --------- There is no filename. Look for defaults in course and global, cache
   
     unless($fn) {
         unless ($fn=$defaultsheets{$cnum.'_'.$cdom.'_'.$stype}) {
            $fn=&Apache::lonnet::reply('get:'.$cdom.':'.$cnum.
                                       ':environment:spreadsheet_default_'.$stype,
                                       $chome);
            unless (($fn) && ($fn!~/^error\:/)) {
        $fn='default_'.$stype;
            }
            $defaultsheets{$cnum.'_'.$cdom.'_'.$stype}=$fn; 
         }
     }
   
   # ---------------------------------------------------------- fn now has a value
   
     &setfilename($safeeval,$fn);
   
   # ------------------------------------------------------ see if sheet is cached
     my $fstring='';
     if ($fstring=$spreadsheets{$cnum.'_'.$cdom.'_'.$stype.'_'.$fn}) {
         &setformulas($safeeval,split(/\_\_\_\;\_\_\_/,$fstring));
     } else {
   
   # ---------------------------------------------------- Not cached, need to read
   
        my %f=();
   
        if ($fn=~/^default\_/) {
    my $sheetxml='';
        {         {
          my $fh;           my $fh;
          if ($fh=Apache::File->new($fn)) {           if ($fh=Apache::File->new($includedir.
             $spreadsheets{$fn}=join('',<$fh>);                           '/default.'.&gettype($safeeval))) {
          }                 $sheetxml=join('',<$fh>);
             }
        }         }
           my $parser=HTML::TokeParser->new(\$sheetxml);
           my $token;
           while ($token=$parser->get_token) {
             if ($token->[0] eq 'S') {
         if ($token->[1] eq 'field') {
     $f{$token->[2]->{'col'}.$token->[2]->{'row'}}=
         $parser->get_text('/field');
         }
                if ($token->[1] eq 'template') {
                    $f{'template_'.$token->[2]->{'col'}}=
                        $parser->get_text('/template');
                }
             }
           }
         } else {
             my $sheet='';
             my $reply=&Apache::lonnet::reply('dump:'.$cdom.':'.$cnum.':'.$fn,
                                            $chome);
             unless ($reply=~/^error\:/) {
                $sheet=$reply;
     }
             map {
                my ($name,$value)=split(/\=/,$_);
                $f{&Apache::lonnet::unescape($name)}=
           &Apache::lonnet::unescape($value);
             } split(/\&/,$sheet);
          }
   # --------------------------------------------------------------- Cache and set
          $spreadsheets{$cnum.'_'.$cdom.'_'.$stype.'_'.$fn}=join('___;___',%f);  
          &setformulas($safeeval,%f);
     }      }
     {  }
       my $parser=HTML::TokeParser->new(\$spreadsheets{$fn});  
       my $token;  # -------------------------------------------------------- Make new spreadsheet
       while ($token=$parser->get_token) {  
          if ($token->[0] eq 'S') {  sub makenewsheet {
      if ($token->[1] eq 'field') {      my ($uname,$udom,$stype,$usymb)=@_;
  $f{$token->[2]->{'col'}.$token->[2]->{'row'}}=      my $safeeval=initsheet($stype);
      $parser->get_text('/field');      $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
   
   sub writesheet {
     my ($safeeval,$makedef)=@_;
     my $cid=&getcid($safeeval);
     if (&Apache::lonnet::allowed('opa',$cid)) {
       my %f=&getformulas($safeeval);
       my $stype=&gettype($safeeval);
       my $cnum=&getcnum($safeeval);
       my $cdom=&getcdom($safeeval);
       my $chome=&getchome($safeeval);
       my $fn=&getfilename($safeeval);
   
   # ------------------------------------------------------------- Cache new sheet
       $spreadsheets{$cnum.'_'.$cdom.'_'.$stype.'_'.$fn}=join('___;___',%f);    
   # ----------------------------------------------------------------- Write sheet
       my $sheetdata='';
       map {
        unless ($f{$_} eq 'import') {
          $sheetdata.=&Apache::lonnet::escape($_).'='.
      &Apache::lonnet::escape($f{$_}).'&';
        }
       } keys %f;
       $sheetdata=~s/\&$//;
       my $reply=&Apache::lonnet::reply('put:'.$cdom.':'.$cnum.':'.$fn.':'.
                 $sheetdata,$chome);
       if ($reply eq 'ok') {
             $reply=&Apache::lonnet::reply('put:'.$cdom.':'.$cnum.':'.
                 $stype.'_spreadsheets:'.
                 &Apache::lonnet::escape($fn).'='.$ENV{'user.name'}.'@'.
                                                  $ENV{'user.domain'},
                 $chome);
             if ($reply eq 'ok') {
                 if ($makedef) { 
                   return &Apache::lonnet::reply('put:'.$cdom.':'.$cnum.
                                   ':environment:spreadsheet_default_'.$stype.'='.
                                   &Apache::lonnet::escape($fn),
                                   $chome);
         } else {
     return $reply;
            }
      } else {
          return $reply;
              }
         } else {
     return $reply;
       }        }
     }    }
     &setformulas($safeeval,%f);    return 'unauthorized';
 }  }
   
 # ----------------------------------------------- Make a temp copy of the sheet  # ----------------------------------------------- Make a temp copy of the sheet
   # "Modified workcopy" - interactive only
   #
   
 sub tmpwrite {  sub tmpwrite {
     my ($safeeval,$tmpdir,$symb)=@_;      my $safeeval=shift;
     my $fn=$uname.'_'.$udom.'_spreadsheet_'.&getfilename($safeeval);      my $fn=$ENV{'user.name'}.'_'.
              $ENV{'user.domain'}.'_spreadsheet_'.&getusymb($safeeval).'_'.
              &getfilename($safeeval);
     $fn=~s/\W/\_/g;      $fn=~s/\W/\_/g;
     $fn=$tmpdir.$fn.'.tmp';      $fn=$tmpdir.$fn.'.tmp';
     my $fh;      my $fh;
Line 543  sub tmpwrite { Line 998  sub tmpwrite {
 # ---------------------------------------------------------- Read the temp copy  # ---------------------------------------------------------- Read the temp copy
   
 sub tmpread {  sub tmpread {
     my ($safeeval,$tmpdir,$symb,$nfield,$nform)=@_;      my ($safeeval,$nfield,$nform)=@_;
     my $fn=$uname.'_'.$udom.'_spreadsheet_'.&getfilename($safeeval);      my $fn=$ENV{'user.name'}.'_'.
              $ENV{'user.domain'}.'_spreadsheet_'.&getusymb($safeeval).'_'.
              &getfilename($safeeval);
     $fn=~s/\W/\_/g;      $fn=~s/\W/\_/g;
     $fn=$tmpdir.$fn.'.tmp';      $fn=$tmpdir.$fn.'.tmp';
     my $fh;      my $fh;
Line 558  sub tmpread { Line 1015  sub tmpread {
             $fo{$name}=$value;              $fo{$name}=$value;
         }          }
     }      }
     $fo{$nfield}=$nform;      if ($nform eq 'changesheet') {
     &setformulas($safeeval,%fo);          $fo{'A'.$nfield}=(split(/\_\_\&\&\&\_\_/,$fo{'A'.$nfield}))[0];
 }          unless ($ENV{'form.sel_'.$nfield} eq 'Default') {
       $fo{'A'.$nfield}.='__&&&__'.$ENV{'form.sel_'.$nfield};
 # --------------------------------------------------------------- Read metadata          }
       } else {
 sub readmeta {         if ($nfield) { $fo{$nfield}=$nform; }
     my $fn=shift;  
     unless ($fn=~/\.meta$/) { $fn.='meta'; }  
     my $content;  
     my %returnhash=();  
     {  
       my $fh=Apache::File->new($fn);  
       $content=join('',<$fh>);  
     }      }
    my $parser=HTML::TokeParser->new(\$content);      &setformulas($safeeval,%fo);
    my $token;  
    while ($token=$parser->get_token) {  
       if ($token->[0] eq 'S') {  
          my $entry=$token->[1];  
          if (($entry eq 'stores') || ($entry eq 'parameter')) {  
              my $unikey=$entry;  
              $unikey.='_'.$token->[2]->{'part'};   
              $unikey.='_'.$token->[2]->{'name'};   
              $returnhash{$unikey}=$token->[2]->{'display'};  
          }  
      }  
   }  
     return %returnhash;  
 }  }
   
 # ================================================================== Parameters  # ================================================================== Parameters
 # -------------------------------------------- Figure out a cascading parameter  # -------------------------------------------- Figure out a cascading parameter
   #
   # For this function to work
   #
   # * parmhash needs to be tied
   # * courseopt and useropt need to be initialized for this user and course
   #
   
 sub parmval {  sub parmval {
     my ($what,$symb)=@_;      my ($what,$safeeval)=@_;
       my $cid=&getcid($safeeval);
       my $csec=&getcsec($safeeval);
       my $uname=&getuname($safeeval);
       my $udom=&getudom($safeeval);
       my $symb=&getusymb($safeeval);
   
     unless ($symb) { return ''; }      unless ($symb) { return ''; }
     my $result='';      my $result='';
Line 602  sub parmval { Line 1050  sub parmval {
 # ----------------------------------------------------- Cascading lookup scheme  # ----------------------------------------------------- Cascading lookup scheme
        my $rwhat=$what;         my $rwhat=$what;
        $what=~s/^parameter\_//;         $what=~s/^parameter\_//;
        $what=~s/\_/\./;         $what=~s/\_([^\_]+)$/\.$1/;
   
        my $symbparm=$symb.'.'.$what;         my $symbparm=$symb.'.'.$what;
        my $mapparm=$mapname.'___(all).'.$what;         my $mapparm=$mapname.'___(all).'.$what;
          my $usercourseprefix=$uname.'_'.$udom.'_'.$cid;
   
        my $seclevel=         my $seclevel=
             $ENV{'request.course.id'}.'.['.              $usercourseprefix.'.['.
  $csec.'].'.$what;   $csec.'].'.$what;
        my $seclevelr=         my $seclevelr=
             $ENV{'request.course.id'}.'.['.              $usercourseprefix.'.['.
  $csec.'].'.$symbparm;   $csec.'].'.$symbparm;
        my $seclevelm=         my $seclevelm=
             $ENV{'request.course.id'}.'.['.              $usercourseprefix.'.['.
  $csec.'].'.$mapparm;   $csec.'].'.$mapparm;
   
        my $courselevel=         my $courselevel=
             $ENV{'request.course.id'}.'.'.$what;              $usercourseprefix.'.'.$what;
        my $courselevelr=         my $courselevelr=
             $ENV{'request.course.id'}.'.'.$symbparm;              $usercourseprefix.'.'.$symbparm;
        my $courselevelm=         my $courselevelm=
             $ENV{'request.course.id'}.'.'.$mapparm;              $usercourseprefix.'.'.$mapparm;
   
 # ---------------------------------------------------------- fourth, check user  # ---------------------------------------------------------- fourth, check user
               
Line 665  sub parmval { Line 1114  sub parmval {
                   
 }  }
   
   # ---------------------------------------------- Update rows for course listing
   
   sub updateclasssheet {
       my $safeeval=shift;
       my $cnum=&getcnum($safeeval);
       my $cdom=&getcdom($safeeval);
       my $cid=&getcid($safeeval);
       my $chome=&getchome($safeeval);
   
   # ---------------------------------------------- Read class list and row labels
   
       my $classlst=&Apache::lonnet::reply
                                    ('dump:'.$cdom.':'.$cnum.':classlist',$chome);
       my %currentlist=();
       my $now=time;
       unless ($classlst=~/^error\:/) {
           map {
               my ($name,$value)=split(/\=/,$_);
               my ($end,$start)=split(/\:/,&Apache::lonnet::unescape($value));
               my $active=1;
               if (($end) && ($now>$end)) { $active=0; }
               if ($active) {
                   my $rowlabel='';
                   $name=&Apache::lonnet::unescape($name);
                   my ($sname,$sdom)=split(/\:/,$name);
                   my $ssec=&Apache::lonnet::usection($sdom,$sname,$cid);
                   if ($ssec==-1) {
                       $rowlabel='<font color=red>Data not available: '.$name.
         '</font>';
                   } 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));
                       $rowlabel='<a href="/adm/studentcalc?uname='.$sname.
                                 '&udom='.$sdom.'">'.
                                 $ssec.'&nbsp;'.$reply{$sname}.'<br>';
                       map {
                           $rowlabel.=&Apache::lonnet::unescape($_).' ';
                       } split(/\&/,$reply);
                       $rowlabel.='</a>';
                   }
    $currentlist{&Apache::lonnet::unescape($name)}=$rowlabel;
               }
           } 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
    map {
       if ($_=~/^A(\d+)/) {
                   $maxrow=($1>$maxrow)?$1:$maxrow;
                   $existing{$f{$_}}=1;
    unless ((defined($currentlist{$f{$_}})) || (!$1)) {
      $f{$_}='!!! Obsolete';
                      $changed=1;
                   }
               }
           } keys %f;
   
   # -------------------------------------------------------- New and unknown keys
        
           map {
               unless ($existing{$_}) {
    $changed=1;
                   $maxrow++;
                   $f{'A'.$maxrow}=$_;
               }
           } sort keys %currentlist;        
        
           if ($changed) { &setformulas($safeeval,%f); }
   
 # ----------------------------------------------------------------- Update rows          &setmaxrow($safeeval,$maxrow);
           &setrowlabels($safeeval,%currentlist);
   
       } else {
           return 'Could not access course data';
       }
   }
   
   # ----------------------------------- Update rows for student and assess sheets
   
 sub updaterows {  sub updatestudentassesssheet {
     my $safeeval=shift;      my $safeeval=shift;
     my %bighash;      my %bighash;
       my $stype=&gettype($safeeval);
       my %current=();
       unless ($updatedata{$ENV{'request.course.fn'}.'_'.$stype}) {
 # -------------------------------------------------------------------- Tie hash  # -------------------------------------------------------------------- Tie hash
       if (tie(%bighash,'GDBM_File',$ENV{'request.course.fn'}.'.db',        if (tie(%bighash,'GDBM_File',$ENV{'request.course.fn'}.'.db',
                        &GDBM_READER,0640)) {                         &GDBM_READER,0640)) {
 # --------------------------------------------------------- Get all assessments  # --------------------------------------------------------- Get all assessments
   
  my %allkeys=();   my %allkeys=('timestamp' => 
                        'Timestamp of Last Transaction<br>timestamp');
         my %allassess=();          my %allassess=();
   
         my $stype=&gettype($safeeval);          my $adduserstr='';
           if ((&getuname($safeeval) ne $ENV{'user.name'}) ||
               (&getudom($safeeval) ne $ENV{'user.domain'})) {
               $adduserstr='&uname='.&getuname($safeeval).
    '&udom='.&getudom($safeeval);
           }
   
         map {          map {
     if ($_=~/^src\_(\d+)\.(\d+)$/) {      if ($_=~/^src\_(\d+)\.(\d+)$/) {
Line 692  sub updaterows { Line 1235  sub updaterows {
                      &Apache::lonnet::declutter($bighash{'map_id_'.$mapid}).                       &Apache::lonnet::declutter($bighash{'map_id_'.$mapid}).
     '___'.$resid.'___'.      '___'.$resid.'___'.
     &Apache::lonnet::declutter($srcf);      &Apache::lonnet::declutter($srcf);
  $allassess{$symb}=$bighash{'title_'.$id};   $allassess{$symb}=
               '<a href="/adm/assesscalc?usymb='.$symb.$adduserstr.'">'.
                        $bighash{'title_'.$id}.'</a>';
                  if ($stype eq 'assesscalc') {                   if ($stype eq 'assesscalc') {
                    map {                     map {
                        if (($_=~/^stores\_(.*)/) || ($_=~/^parameter\_(.*)/)) {                         if (($_=~/^stores\_(.*)/) || ($_=~/^parameter\_(.*)/)) {
Line 701  sub updaterows { Line 1245  sub updaterows {
                           my $display=                            my $display=
       &Apache::lonnet::metadata($srcf,$key.'.display');        &Apache::lonnet::metadata($srcf,$key.'.display');
                           unless ($display) {                            unless ($display) {
                               $display=                                $display.=
          &Apache::lonnet::metadata($srcf,$key.'.name');           &Apache::lonnet::metadata($srcf,$key.'.name');
                           }                            }
                             $display.='<br>'.$key;
                           $allkeys{$key}=$display;                            $allkeys{$key}=$display;
        }         }
                    } split(/\,/,&Apache::lonnet::metadata($srcf,'keys'));                     } split(/\,/,&Apache::lonnet::metadata($srcf,'keys'));
Line 717  sub updaterows { Line 1262  sub updaterows {
 # %allkeys has a list of storage and parameter displays by unikey  # %allkeys has a list of storage and parameter displays by unikey
 # %allassess has a list of all resource displays by symb  # %allassess has a list of all resource displays by symb
 #  #
 # -------------------- Find discrepancies between the course row table and this  
 #  
         my %f=&getformulas($safeeval);  
         my $changed=0;  
   
         my %current=();  
         if ($stype eq 'assesscalc') {          if ($stype eq 'assesscalc') {
     %current=%allkeys;      %current=%allkeys;
         } elsif ($stype eq 'studentcalc') {          } elsif ($stype eq 'studentcalc') {
             %current=%allassess;              %current=%allassess;
         }          }
           $updatedata{$ENV{'request.course.fn'}.'_'.$stype}=
       join('___;___',%current);
       } else {
           return 'Could not access course data';
       }
   # ------------------------------------------------------ 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 $maxrow=0;
         my %existing=();          my %existing=();
Line 736  sub updaterows { Line 1290  sub updaterows {
  map {   map {
     if ($_=~/^A(\d+)/) {      if ($_=~/^A(\d+)/) {
                 $maxrow=($1>$maxrow)?$1:$maxrow;                  $maxrow=($1>$maxrow)?$1:$maxrow;
                 $existing{$f{$_}}=1;                  my ($usy,$ufn)=split(/\_\_\&\&\&\_\_/,$f{$_});
  unless ((defined($current{$f{$_}})) || (!$1)) {                  $existing{$usy}=1;
    unless ((defined($current{$usy})) || (!$1)) {
    $f{$_}='!!! Obsolete';     $f{$_}='!!! Obsolete';
                    $changed=1;                     $changed=1;
           } elsif ($ufn) {
       $current{$usy}
                          =~s/assesscalc\?usymb\=/assesscalc\?ufn\=$ufn\&usymb\=/;
                 }                  }
             }              }
         } keys %f;          } keys %f;
Line 753  sub updaterows { Line 1311  sub updaterows {
                 $f{'A'.$maxrow}=$_;                  $f{'A'.$maxrow}=$_;
             }              }
         } keys %current;                  } keys %current;        
            
         if ($changed) { &setformulas($safeeval,%f); }          if ($changed) { &setformulas($safeeval,%f); }
   
         &setmaxrow($safeeval,$maxrow);          &setmaxrow($safeeval,$maxrow);
         &setrowlabels($safeeval,%current);          &setrowlabels($safeeval,%current);
    
           undef %current;
           undef %existing;
   }
   
     } else {  # ------------------------------------------------ Load data for one assessment
         return 'Could not access course data';  
   sub loadstudent {
       my $safeeval=shift;
       my %c=();
       my %f=&getformulas($safeeval);
       $cachedassess=&getuname($safeeval).':'.&getudom($safeeval);
       %cachedstores=();
       {
         my $reply=&Apache::lonnet::reply('dump:'.&getudom($safeeval).':'.
                                                  &getuname($safeeval).':'.
                                                  &getcid($safeeval),
                                                  &getuhome($safeeval));
         unless ($reply=~/^error\:/) {
            map {
               my ($name,$value)=split(/\=/,$_);
               $cachedstores{&Apache::lonnet::unescape($name)}=
                     &Apache::lonnet::unescape($value);
            } split(/\&/,$reply);
         }
     }      }
       my @assessdata=();
       map {
    if ($_=~/^A(\d+)/) {
      my $row=$1;
              unless (($f{$_}=~/^\!/) || ($row==0)) {
         my ($usy,$ufn)=split(/\_\_\&\&\&\_\_/,$f{$_});
         @assessdata=&exportsheet(&getuname($safeeval),
                                          &getudom($safeeval),
                                          'assesscalc',$usy,$ufn);
                 my $index=0;
                 map {
                     if ($assessdata[$index]) {
        my $col=$_;
        if ($assessdata[$index]=~/\D/) {
                            $c{$col.$row}="'".$assessdata[$index]."'";
         } else {
            $c{$col.$row}=$assessdata[$index];
        }
                        unless ($col eq 'A') { 
    $f{$col.$row}='import';
                        }
     }
                     $index++;
                 } ('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');
      }
           }
       } keys %f;
       $cachedassess='';
       undef %cachedstores;
       &setformulas($safeeval,%f);
       &setconstants($safeeval,%c);
 }  }
   
 # --------------------------------------------------- Load data for one student  # --------------------------------------------------- Load data for one student
   
 sub rowazstudent {  sub loadcourse {
     my $safeeval=shift;      my ($safeeval,$r)=@_;
     my %c=();      my %c=();
     my %f=&getformulas($safeeval);      my %f=&getformulas($safeeval);
       my $total=0;
       map {
    if ($_=~/^A(\d+)/) {
       unless ($f{$_}=~/^\!/) { $total++; }
           }
       } keys %f;
       my $now=0;
       my $since=time;
       $r->print(<<ENDPOP);
   <script>
       popwin=open('','popwin','width=400,height=100');
       popwin.document.writeln('<html><body bgcolor="#FFFFFF">'+
         '<h3>Spreadsheet Calculation Progress</h3>'+
         '<form name=popremain>'+
         '<input type=text size=35 name=remaining value=Starting></form>'+
         '</body></html>');
       popwin.document.close();
   </script>
   ENDPOP
       $r->rflush();
     map {      map {
  if ($_=~/^A(\d+)/) {   if ($_=~/^A(\d+)/) {
    my $row=$1;     my $row=$1;
            unless ($f{$_}=~/^\!/) {             unless (($f{$_}=~/^\!/)  || ($row==0)) {
               my @assessdata=split(/\,/,        my @studentdata=&exportsheet(split(/\:/,$f{$_}),
                              &Apache::lonnet::ssi(                                             'studentcalc');
         '/res/msu/korte/junk.assesscalc',('utarget' => 'export',                undef %userrdatas;
                                           'uname'   => $uname,                $now++;
                                           'udom'    => $udom,                $r->print('<script>popwin.document.popremain.remaining.value="'.
                   'usymb'   => $f{$_})));                    $now.'/'.$total.': '.int((time-$since)/$now*($total-$now)).
                           ' secs remaining";</script>');
                 $r->rflush(); 
   
               my $index=0;                my $index=0;
               map {                map {
   $c{$_.$row}=$assessdata[$index];                    if ($studentdata[$index]) {
   print $_.':'.$c{$_.$row}.'<br>';       my $col=$_;
        if ($studentdata[$index]=~/\D/) {
                            $c{$col.$row}="'".$studentdata[$index]."'";
         } else {
            $c{$col.$row}=$studentdata[$index];
        }
                        unless ($col eq 'A') { 
    $f{$col.$row}='import';
                        }
     }
                   $index++;                    $index++;
               } ('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');
                 
    }     }
         }          }
     } keys %f;      } keys %f;
       &setformulas($safeeval,%f);
     &setconstants($safeeval,%c);      &setconstants($safeeval,%c);
       $r->print('<script>popwin.close()</script>');
       $r->rflush(); 
 }  }
   
 # ------------------------------------------------ Load data for one assessment  # ------------------------------------------------ Load data for one assessment
   
 sub rowaassess {  sub loadassessment {
     my ($safeeval,$symb)=@_;      my $safeeval=shift;
     my $uhome=&Apache::lonnet::homeserver($uname,$udom);  
       my $uhome=&getuhome($safeeval);
       my $uname=&getuname($safeeval);
       my $udom=&getudom($safeeval);
       my $symb=&getusymb($safeeval);
       my $cid=&getcid($safeeval);
       my $cnum=&getcnum($safeeval);
       my $cdom=&getcdom($safeeval);
       my $chome=&getchome($safeeval);
   
     my $namespace;      my $namespace;
     unless ($namespace=$ENV{'request.course.id'}) { return ''; }      unless ($namespace=$cid) { return ''; }
   
 # ----------------------------------------------------------- Get stored values  # ----------------------------------------------------------- Get stored values
   
      my %returnhash=();
   
      if ($cachedassess eq $uname.':'.$udom) {
   #
   # get data out of the dumped stores
   # 
   
          my $version=$cachedstores{'version:'.$symb};
          my $scope;
          for ($scope=1;$scope<=$version;$scope++) {
              map {
                  $returnhash{$_}=$cachedstores{$scope.':'.$symb.':'.$_};
              } split(/\:/,$cachedstores{$scope.':keys:'.$symb}); 
          }
   
      } else {
   #
   # restore individual
   #
   
     my $answer=&Apache::lonnet::reply(      my $answer=&Apache::lonnet::reply(
        "restore:$udom:$uname:".         "restore:$udom:$uname:".
        &Apache::lonnet::escape($namespace).":".         &Apache::lonnet::escape($namespace).":".
        &Apache::lonnet::escape($symb),$uhome);         &Apache::lonnet::escape($symb),$uhome);
     my %returnhash=();  
     map {      map {
  my ($name,$value)=split(/\=/,$_);   my ($name,$value)=split(/\=/,$_);
         $returnhash{&Apache::lonnet::unescape($name)}=          $returnhash{&Apache::lonnet::unescape($name)}=
Line 820  sub rowaassess { Line 1494  sub rowaassess {
           $returnhash{$_}=$returnhash{$version.':'.$_};            $returnhash{$_}=$returnhash{$version.':'.$_};
        } split(/\:/,$returnhash{$version.':keys'});         } split(/\:/,$returnhash{$version.':keys'});
     }      }
      }
 # ----------------------------- returnhash now has all stores for this resource  # ----------------------------- returnhash now has all stores for this resource
   
 # ---------------------------- initialize coursedata and userdata for this user  # ---------------------------- initialize coursedata and userdata for this user
     %courseopt=();      undef %courseopt;
     %useropt=();      undef %useropt;
     my $uhome=&Apache::lonnet::homeserver($uname,$udom);  
       my $userprefix=$uname.'_'.$udom.'_';
   
     unless ($uhome eq 'no_host') {       unless ($uhome eq 'no_host') { 
 # -------------------------------------------------------------- Get coursedata  # -------------------------------------------------------------- Get coursedata
       unless        unless
         ((time-$courserdatas{$ENV{'request.course.id'}.'.last_cache'})<120) {          ((time-$courserdatas{$cid.'.last_cache'})<240) {
          my $reply=&Apache::lonnet::reply('dump:'.           my $reply=&Apache::lonnet::reply('dump:'.$cdom.':'.$cnum.
               $ENV{'course.'.$ENV{'request.course.id'}.'.domain'}.':'.                ':resourcedata',$chome);
               $ENV{'course.'.$ENV{'request.course.id'}.'.num'}.':resourcedata',  
               $ENV{'course.'.$ENV{'request.course.id'}.'.home'});  
          if ($reply!~/^error\:/) {           if ($reply!~/^error\:/) {
             $courserdatas{$ENV{'request.course.id'}}=$reply;              $courserdatas{$cid}=$reply;
             $courserdatas{$ENV{'request.course.id'}.'.last_cache'}=time;              $courserdatas{$cid.'.last_cache'}=time;
          }           }
       }        }
       map {        map {
          my ($name,$value)=split(/\=/,$_);           my ($name,$value)=split(/\=/,$_);
          $courseopt{&Apache::lonnet::unescape($name)}=           $courseopt{$userprefix.&Apache::lonnet::unescape($name)}=
                     &Apache::lonnet::unescape($value);                        &Apache::lonnet::unescape($value);  
       } split(/\&/,$courserdatas{$ENV{'request.course.id'}});        } split(/\&/,$courserdatas{$cid});
 # --------------------------------------------------- Get userdata (if present)  # --------------------------------------------------- Get userdata (if present)
       unless        unless
         ((time-$userrdatas{$uname.'___'.$udom.'.last_cache'})<120) {          ((time-$userrdatas{$uname.'___'.$udom.'.last_cache'})<240) {
          my $reply=           my $reply=
        &Apache::lonnet::reply('dump:'.$udom.':'.$uname.':resourcedata',$uhome);         &Apache::lonnet::reply('dump:'.$udom.':'.$uname.':resourcedata',$uhome);
          if ($reply!~/^error\:/) {           if ($reply!~/^error\:/) {
Line 856  sub rowaassess { Line 1531  sub rowaassess {
       }        }
       map {        map {
          my ($name,$value)=split(/\=/,$_);           my ($name,$value)=split(/\=/,$_);
          $useropt{&Apache::lonnet::unescape($name)}=           $useropt{$userprefix.&Apache::lonnet::unescape($name)}=
           &Apache::lonnet::unescape($value);            &Apache::lonnet::unescape($value);
       } split(/\&/,$userrdatas{$uname.'___'.$udom});        } split(/\&/,$userrdatas{$uname.'___'.$udom});
    }      }
 # -- now courseopt, useropt initialized for this user and course (used parmval)  # ----------------- now courseopt, useropt initialized for this user and course
   # (used by parmval)
   
     my %c=();  #
   # Load keys for this assessment only
   #
       my %thisassess=();
       my ($symap,$syid,$srcf)=split(/\_\_\_/,$symb);
       
       map {
           $thisassess{$_}=1;
       } split(/\,/,&Apache::lonnet::metadata($srcf,'keys'));
   #
   # Load parameters
   #
      my %c=();
   
      if (tie(%parmhash,'GDBM_File',
              &getcfn($safeeval).'_parms.db',&GDBM_READER,0640)) {
     my %f=&getformulas($safeeval);      my %f=&getformulas($safeeval);
     map {      map {
  if ($_=~/^A/) {   if ($_=~/^A/) {
             unless ($f{$_}=~/^\!/) {              unless ($f{$_}=~/^\!/) {
         if ($f{$_}=~/^parameter/) {          if ($f{$_}=~/^parameter/) {
           $c{$_}=&parmval($f{$_},$symb);   if ($thisassess{$f{$_}}) {
                     my $val=&parmval($f{$_},$safeeval);
                     $c{$_}=$val;
                     $c{$f{$_}}=$val;
           }
        } else {         } else {
   my $key=$f{$_};    my $key=$f{$_};
                     my $ckey=$key;
                   $key=~s/^stores\_/resource\./;                    $key=~s/^stores\_/resource\./;
                   $key=~s/\_/\./;                    $key=~s/\_/\./g;
            $c{$_}=$returnhash{$key};             $c{$_}=$returnhash{$key};
                     $c{$ckey}=$returnhash{$key};
        }         }
    }     }
         }          }
     } keys %f;      } keys %f;
       untie(%parmhash);
     &setconstants($safeeval,%c);     }
      &setconstants($safeeval,%c);
 }  }
   
 # --------------------------------------------------------- Various form fields  # --------------------------------------------------------- Various form fields
Line 906  sub selectbox { Line 1604  sub selectbox {
     return $selout.'</select>';      return $selout.'</select>';
 }  }
   
   # =============================================== Update information in a sheet
   #
   # Add new users or assessments, etc.
   #
   
   sub updatesheet {
       my $safeeval=shift;
       my $stype=&gettype($safeeval);
       if ($stype eq 'classcalc') {
    return &updateclasssheet($safeeval);
       } else {
           return &updatestudentassesssheet($safeeval);
       }
   }
   
   # =================================================== Load the rows for a sheet
   #
   # Import the data for rows
   #
   
   sub loadrows {
       my ($safeeval,$r)=@_;
       my $stype=&gettype($safeeval);
       if ($stype eq 'classcalc') {
    &loadcourse($safeeval,$r);
       } elsif ($stype eq 'studentcalc') {
           &loadstudent($safeeval);
       } else {
           &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 {
           if (&checkthis('::studentcalc:',$time) || 
               &checkthis($uname.':'.$udom.':studentcalc:',$time)) {
       return 1;
           }
       }
       return 0; 
   }
   
   # ============================================================== Export handler
   #
   # Non-interactive call from with program
   #
   
   sub exportsheet {
    my ($uname,$udom,$stype,$usymb,$fn)=@_;
    my @exportarr=();
   #
   # Check if cached
   #
   
    my $key=$uname.':'.$udom.':'.$stype.':'.$usymb;
    my $found='';
   
    if ($oldsheets{$key}) {
        map {
            my ($name,$value)=split(/\_\_\_\=\_\_\_/,$_);
            if ($name eq $fn) {
        $found=$value;
            }
        } split(/\_\_\_\&\_\_\_/,$oldsheets{$key});
    }
   
    unless ($found) {
        &cachedssheets($uname,$udom,&Apache::lonnet::homeserver($uname,$udom));
        if ($oldsheets{$key}) {
           map {
               my ($name,$value)=split(/\_\_\_\=\_\_\_/,$_);
               if ($name eq $fn) {
           $found=$value;
               }
           } split(/\_\_\_\&\_\_\_/,$oldsheets{$key});
        }
    }
   #
   # 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\:/) {
          map {
              my ($name,$value)=split(/\_\_\_\=\_\_\_/,$_);
              $currentlystored{$name}=$value;
          } split(/\_\_\_\&\_\_\_/,&Apache::lonnet::unescape($current));
       }
       $currentlystored{$fn}=join('___;___',@exportarr);
   
       my $newstore='';
       map {
           if ($newstore) { $newstore.='___&___'; }
           $newstore.=$_.'___=___'.$currentlystored{$_};
       } keys %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\:/) {
    map {
               my ($name,$value)=split(/\=/,$_);
               $expiredates{&Apache::lonnet::unescape($name)}
                           =&Apache::lonnet::unescape($value);
           } split(/\&/,$reply);
       }
   }
   
   # ===================================================== 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\:/) {
    map {
               my ($name,$value)=split(/\=/,$_);
               $oldsheets{&Apache::lonnet::unescape($name)}
                         =&Apache::lonnet::unescape($value);
           } split(/\&/,$reply);
       }
   }
   
   # ===================================================== Calculated sheets cache
   #
   # Load previously cached assessment spreadsheets for this student
   #
   
   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\:/) {
    map {
               my ($name,$value)=split(/\=/,$_);
               $oldsheets{&Apache::lonnet::unescape($name)}
                         =&Apache::lonnet::unescape($value);
           } split(/\&/,$reply);
       }
       $loadedcaches{$sname.'_'.$sdom}=1;
     }
   }
   
   # ===================================================== Calculated sheets cache
   #
   # Load previously cached assessment spreadsheets for this student
   #
   
 # ================================================================ Main handler  # ================================================================ Main handler
   #
   # Interactive call to screen
   #
   #
   
   
 sub handler {  sub handler {
     my $r=shift;      my $r=shift;
   
     $uname='';      if ($r->header_only) {
     $udom='';  
     $csec='';  
   
    if ($r->header_only) {  
       $r->content_type('text/html');        $r->content_type('text/html');
       $r->send_http_header;        $r->send_http_header;
       return OK;        return OK;
    }      }
   
   # ---------------------------------------------------- Global directory configs
   
   $includedir=$r->dir_config('lonIncludes');
   $tmpdir=$r->dir_config('lonDaemons').'/tmp/';
   
 # ----------------------------------------------------- Needs to be in a course  # ----------------------------------------------------- Needs to be in a course
   
   if (($ENV{'request.course.fn'}) ||     if ($ENV{'request.course.fn'}) { 
       ($ENV{'request.state'} eq 'construct')) {   
   
 # --------------------------- Get query string for limited number of parameters  # --------------------------- Get query string for limited number of parameters
   
Line 932  sub handler { Line 1891  sub handler {
        my ($name, $value) = split(/=/,$_);         my ($name, $value) = split(/=/,$_);
        $value =~ tr/+/ /;         $value =~ tr/+/ /;
        $value =~ s/%([a-fA-F0-9][a-fA-F0-9])/pack("C",hex($1))/eg;         $value =~ s/%([a-fA-F0-9][a-fA-F0-9])/pack("C",hex($1))/eg;
        if (($name eq 'uname') || ($name eq 'udom') || ($name eq 'usymb')) {         if (($name eq 'uname') || ($name eq 'udom') || 
              ($name eq 'usymb') || ($name eq 'ufn')) {
            unless ($ENV{'form.'.$name}) {             unless ($ENV{'form.'.$name}) {
               $ENV{'form.'.$name}=$value;                $ENV{'form.'.$name}=$value;
    }     }
        }         }
     } (split(/&/,$ENV{'QUERY_STRING'}));      } (split(/&/,$ENV{'QUERY_STRING'}));
   
   # -------------------------------------- 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  # ------------------------------------------- Nothing there? Must be login user
   
       my $aname;
       my $adom;
   
     unless ($ENV{'form.uname'}) {      unless ($ENV{'form.uname'}) {
  $uname=$ENV{'user.name'};   $aname=$ENV{'user.name'};
         $udom=$ENV{'user.domain'};          $adom=$ENV{'user.domain'};
     } else {      } else {
         $uname=$ENV{'form.uname'};          $aname=$ENV{'form.uname'};
         $udom=$ENV{'form.udom'};          $adom=$ENV{'form.udom'};
     }      }
 # ----------------------------------------------------------- Change of target?  
   
     my $reroute=($ENV{'form.utarget'} eq 'export');  
   
 # ------------------------------------------------------------------- Open page  # ------------------------------------------------------------------- Open page
   
Line 961  sub handler { Line 1925  sub handler {
   
 # --------------------------------------------------------------- Screen output  # --------------------------------------------------------------- Screen output
   
   unless ($reroute) {  
     $r->print('<html><head><title>LON-CAPA Spreadsheet</title>');      $r->print('<html><head><title>LON-CAPA Spreadsheet</title>');
     $r->print(<<ENDSCRIPT);      $r->print(<<ENDSCRIPT);
 <script language="JavaScript">  <script language="JavaScript">
Line 975  sub handler { Line 1938  sub handler {
         }          }
     }      }
   
       function changesheet(cn) {
    document.sheet.unewfield.value=cn;
           document.sheet.unewformula.value='changesheet';
           document.sheet.submit();
       }
   
 </script>  </script>
 ENDSCRIPT  ENDSCRIPT
     $r->print('</head><body bgcolor="#FFFFFF">'.      $r->print('</head><body bgcolor="#FFFFFF">'.
          '<img align=right src=/adm/lonIcons/lonlogos.gif>'.
          '<h1>LON-CAPA Spreadsheet</h1>'.
        '<form action="'.$r->uri.'" name=sheet method=post>'.         '<form action="'.$r->uri.'" name=sheet method=post>'.
        &hiddenfield('uname',$ENV{'form.uname'}).         &hiddenfield('uname',$ENV{'form.uname'}).
        &hiddenfield('udom',$ENV{'form.udom'}).         &hiddenfield('udom',$ENV{'form.udom'}).
        &hiddenfield('usymb',$ENV{'form.usymb'}).         &hiddenfield('usymb',$ENV{'form.usymb'}).
        &hiddenfield('unewfield','').         &hiddenfield('unewfield','').
        &hiddenfield('unewformula',''));         &hiddenfield('unewformula',''));
   }  
   
   # ---------------------- Make sure that this gets out, even if user hits "stop"
   
       $r->rflush();
   
   # ---------------------------------------------------------------- Full recalc?
   
   
       if ($ENV{'form.forcerecalc'}) {
    $r->print('<h4>Completely Recalculating Sheet ...</h4>');
           undef %spreadsheets;
           undef %courserdatas;
           undef %userrdatas;
           undef %defaultsheets;
           undef %updatedata;
      }
    
 # ---------------------------------------- Read new sheet or modified worksheet  # ---------------------------------------- Read new sheet or modified worksheet
   
     my $sheetone=initsheet();      $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'}) {      if ($ENV{'form.unewfield'}) {
         $r->print('<h2>Modified Workcopy</h2>');          $r->print('<h2>Modified Workcopy</h2>');
         $ENV{'form.unewformula'}=~s/\'/\"/g;          $ENV{'form.unewformula'}=~s/\'/\"/g;
         $r->print('New formula: '.$ENV{'form.unewfield'}.'='.          $r->print('<p>New formula: '.$ENV{'form.unewfield'}.'='.
                   $ENV{'form.unewformula'}.'<br>');                    $ENV{'form.unewformula'}.'<p>');
         &setfilename($sheetone,$r->filename);          &setfilename($asheet,$ENV{'form.ufn'});
         $r->filename=~/\.(\w+)/;   &tmpread($asheet,
         &settype($sheetone,$1);  
  &tmpread($sheetone,$r->dir_config('lonDaemons').'/tmp/',  
                  $ENV{'form.usymb'},  
                  $ENV{'form.unewfield'},$ENV{'form.unewformula'});                   $ENV{'form.unewfield'},$ENV{'form.unewformula'});
   
        } elsif ($ENV{'form.saveas'}) {
           &setfilename($asheet,$ENV{'form.ufn'});
    &tmpread($asheet);
     } else {      } else {
         &readsheet($sheetone,$r->filename);          &readsheet($asheet,$ENV{'form.ufn'});
     }      }
   
 # --------------------------------------------- See if all import rows uptodate  # -------------------------------------------------- Print out user information
   
     if (tie(%parmhash,'GDBM_File',      unless (&gettype($asheet) eq 'classcalc') {
        $ENV{'request.course.fn'}.'_parms.db',&GDBM_READER,0640)) {          $r->print('<p><b>User:</b> '.&getuname($asheet).
        $csec=&Apache::lonnet::usection($udom,$uname,$ENV{'request.course.id'});                    '<br><b>Domain:</b> '.&getudom($asheet));
        if ($csec eq '-1') {          if (&getcsec($asheet) eq '-1') {
           $r->print('<h3><font color=red>'.             $r->print('<h3><font color=red>'.
    "User '$uname' at domain '$udom' not a student in this course</font></h3>");                       'Not a student in this course</font></h3>');
        }          } else {
        &updaterows($sheetone);             $r->print('<br><b>Section/Group:</b> '.&getcsec($asheet));
        untie(%parmhash);          }
    } else {      }
        $r->print('<h3><font color=red>'.  
    'Could not initialize import fields (not in a course)</font></h3>');  
    }  
   
 # ------------------------------------------------ Write the modified worksheet  # ---------------------------------------------------------------- Course title
   
    &tmpwrite($sheetone,$r->dir_config('lonDaemons').'/tmp/',      $r->print('<h1>'.
               $ENV{'form.usymb'});              $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;
           }
       }
   
   # ---------------------------------------------------------- Additional options
   
 # ----------------------------------------------------- Print user, course, etc      $r->print(
    unless ($reroute) {   '<input type=submit name=forcerecalc value="Completely Recalculate Sheet"><p>'
     $r->print("<b>User '$uname' at domain '$udom' for '".   );
               $ENV{'course.'.$ENV{'request.course.id'}.'.description'}."'");      if (&gettype($asheet) eq 'assesscalc') {
     if ($csec) {         $r->print ('<p><font size=+2><a href="/adm/studentcalc?uname='.
        $r->print(", group/section '$csec'");                                                 &getuname($asheet).
                                                  '&udom='.&getudom($asheet).
                     '">Level up: Student Sheet</a></font><p>');
     }      }
     $r->print("</b>\n");      
    }      if ((&gettype($asheet) eq 'studentcalc') && 
 # -------------------------------------------------------- Import and calculate          (&Apache::lonnet::allowed('vgr',&getcid($asheet)))) {
          $r->print (
                      '<p><font size=+2><a href="/adm/classcalc">'.
                      'Level up: Course Sheet</a></font><p>');
       }
       
   
     if (&gettype($sheetone) eq 'assesscalc') {  # ----------------------------------------------------------------- Save dialog
  &rowaassess($sheetone,$ENV{'form.usymb'});  
     } elsif  (&gettype($sheetone) eq 'studentcalc') {  
  &rowazstudent($sheetone);  
     }  
     &calcsheet($sheetone);  
   
 # ------------------------------------------------------- Print or export sheet  
    unless ($reroute) {     
     $r->print(&outsheet($sheetone));  
   
     $r->print('</form></body></html>');  
   } else {  
       $r->print(&exportrow($sheetone));  
   }  
 # ------------------------------------------------------------------------ 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;      if (&Apache::lonnet::allowed('opa',$ENV{'request.course.id'})) {
 __END__          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>');
           map {
       $r->print('<option name="'.$_.'"');
               if ($ENV{'form.ufn'} eq $_) {
                  $r->print(' selected');
               }
               $r->print('>'.$_.'</option>');
           } &othersheets($asheet,&gettype($asheet));
           $r->print('</select><p>');
           if (&gettype($asheet) eq 'studentcalc') {
       &setothersheets($asheet,&othersheets($asheet,'assesscalc'));
           }
       }
   
   # --------------------------------------------------------------- Cached sheets
   
       &expirationdates();
   
       undef %oldsheets;
       undef %loadedcaches;
   
       if (&gettype($asheet) eq 'classcalc') {
           $r->print("Loading previously calculated student sheets ...<br>\n");
           $r->rflush();
           &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>');
    }
       }
   
   # ------------------------------------------------ Write the modified worksheet
   
      $r->print('<b>Current sheet:</b> '.&getfilename($asheet).'<p>');
   
      &tmpwrite($asheet);
   
       if (&gettype($asheet) eq 'studentcalc') {
    $r->print('<br>Show rows with empty A column: ');
       } else {
           $r->print('<br>Show empty rows: ');
       } 
       $r->print('<input type=checkbox name=showall onClick="submit()"');
       if ($ENV{'form.showall'}) { $r->print(' checked'); }
       $r->print('>');
       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('>');
       }
   # ------------------------------------------------------------- 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;
   __END__
Removed from v.1.17  
changed lines
  Added in v.1.70

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