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

version 1.20, 2000/12/30 17:13:54 version 1.93, 2002/07/04 17:51:32
Line 1 Line 1
   #
   # $Id$
   #
   # Copyright Michigan State University Board of Trustees
   #
   # This file is part of the LearningOnline Network with CAPA (LON-CAPA).
   #
   # LON-CAPA is free software; you can redistribute it and/or modify
   # it under the terms of the GNU General Public License as published by
   # the Free Software Foundation; either version 2 of the License, or
   # (at your option) any later version.
   #
   # LON-CAPA is distributed in the hope that it will be useful,
   # but WITHOUT ANY WARRANTY; without even the implied warranty of
   # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   # GNU General Public License for more details.
   #
   # You should have received a copy of the GNU General Public License
   # along with LON-CAPA; if not, write to the Free Software
   # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   #
   # /home/httpd/html/adm/gpl.txt
   #
   # http://www.lon-capa.org/
   #
 # 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,  # 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 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,10/20,11/05,11/28,12/27 Gerd Kortemeyer
   # 01/14/02 Matthew
   # 02/04/02 Matthew
   
 package Apache::lonspreadsheet;  # POD required stuff:
   
   =head1 NAME
   
   lonspreadsheet
   
   =head1 SYNOPSIS
   
   Spreadsheet interface to internal LON-CAPA data
   
   =head1 DESCRIPTION
   
   Lonspreadsheet provides course coordinators the ability to manage their
   students grades online.  The students are able to view their own grades, but
   not the grades of their peers.  The spreadsheet is highly customizable,
   offering the ability to use Perl code to manipulate data, as well as many
   built-in functions.
   
   
   =head2 Functions available to user of lonspreadsheet
   
   =over 4
   
   =cut
   
   package Apache::lonspreadsheet;
               
 use strict;  use strict;
 use Safe;  use Safe;
 use Safe::Hole;  use Safe::Hole;
Line 16  use GDBM_File; Line 73  use GDBM_File;
 use HTML::TokeParser;  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 105  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 131  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 91  sub mask { Line 194  sub mask {
     } else {      } else {
         if (length($ld)!=length($ud)) {          if (length($ld)!=length($ud)) {
            $num.='(';             $num.='(';
    map {     foreach ($ld=~m/\d/g) {
               $num.='['.$_.'-9]';                $num.='['.$_.'-9]';
            } ($ld=~m/\d/g);     }
            if (length($ud)-length($ld)>1) {             if (length($ud)-length($ld)>1) {
               $num.='|\d{'.(length($ld)+1).','.(length($ud)-1).'}';                $num.='|\d{'.(length($ld)+1).','.(length($ud)-1).'}';
    }     }
            $num.='|';             $num.='|';
            map {             foreach ($ud=~m/\d/g) {
                $num.='[0-'.$_.']';                 $num.='[0-'.$_.']';
            } ($ud=~m/\d/g);             }
            $num.=')';             $num.=')';
        } else {         } else {
            my @lda=($ld=~m/\d/g);             my @lda=($ld=~m/\d/g);
Line 138  sub mask { Line 241  sub mask {
     return '^'.$alpha.$num."\$";      return '^'.$alpha.$num."\$";
 }  }
   
   #-------------------------------------------------------
   
   =item UWCALC(hashname,modules,units,date) 
   
   returns the proportion of the module 
   weights not previously completed by the student.
   
   =over 4
   
   =item hashname 
   
   name of the hash the module dates have been inserted into
   
   =item modules 
   
   reference to a cell which contains a comma deliminated list of modules 
   covered by the assignment.
   
   =item units 
   
   reference to a cell which contains a comma deliminated list of module 
   weights with respect to the assignment
   
   =item date 
   
   reference to a cell which contains the date the assignment was completed.
   
   =back 
   
   =cut
   
   #-------------------------------------------------------
   sub UWCALC {
       my ($hashname,$modules,$units,$date) = @_;
       my @Modules = split(/,/,$modules);
       my @Units   = split(/,/,$units);
       my $total_weight;
       foreach (@Units) {
    $total_weight += $_;
       }
       my $usum=0;
       for (my $i=0; $i<=$#Modules; $i++) {
    if (&HASH($hashname,$Modules[$i]) eq $date) {
       $usum += $Units[$i];
    }
       }
       return $usum/$total_weight;
   }
   
   #-------------------------------------------------------
   
   =item CDLSUM(list) 
   
   returns the sum of the elements in a cell which contains
   a Comma Deliminate List of numerical values.
   'list' is a reference to a cell which contains a comma deliminated list.
   
   =cut
   
   #-------------------------------------------------------
   sub CDLSUM {
       my ($list)=@_;
       my $sum;
       foreach (split/,/,$list) {
    $sum += $_;
       }
       return $sum;
   }
   
   #-------------------------------------------------------
   
   =item CDLITEM(list,index) 
   
   returns the item at 'index' in a Comma Deliminated List.
   
   =over 4
   
   =item list
   
   reference to a cell which contains a comma deliminated list.
   
   =item index 
   
   the Perl index of the item requested (first element in list has
   an index of 0) 
   
   =back
   
   =cut
   
   #-------------------------------------------------------
   sub CDLITEM {
       my ($list,$index)=@_;
       my @Temp = split/,/,$list;
       return $Temp[$index];
   }
   
   #-------------------------------------------------------
   
   =item CDLHASH(name,key,value) 
   
   loads a comma deliminated list of keys into
   the hash 'name', all with a value of 'value'.
   
   =over 4
   
   =item name  
   
   name of the hash.
   
   =item key
   
   (a pointer to) a comma deliminated list of keys.
   
   =item value
   
   a single value to be entered for each key.
   
   =back
   
   =cut
   
   #-------------------------------------------------------
   sub CDLHASH {
       my ($name,$key,$value)=@_;
       my @Keys;
       my @Values;
       # Check to see if we have multiple $key values
       if ($key =~ /[A-z](\-[A-z])?\d+(\-\d+)?/) {
    my $keymask = &mask($key);
    # Assume the keys are addresses
    my @Temp = grep /$keymask/,keys(%v);
    @Keys = $v{@Temp};
       } else {
    $Keys[0]= $key;
       }
       my @Temp;
       foreach $key (@Keys) {
    @Temp = (@Temp, split/,/,$key);
       }
       @Keys = @Temp;
       if ($value =~ /[A-z](\-[A-z])?\d+(\-\d+)?/) {
    my $valmask = &mask($value);
    my @Temp = grep /$valmask/,keys(%v);
    @Values =$v{@Temp};
       } else {
    $Values[0]= $value;
       }
       $value = $Values[0];
       # Add values to hash
       for (my $i = 0; $i<=$#Keys; $i++) {
    my $key   = $Keys[$i];
    if (! exists ($hashes{$name}->{$key})) {
       $hashes{$name}->{$key}->[0]=$value;
    } else {
       my @Temp = sort(@{$hashes{$name}->{$key}},$value);
       $hashes{$name}->{$key} = \@Temp;
    }
       }
       return "hash '$name' updated";
   }
   
   #-------------------------------------------------------
   
   =item GETHASH(name,key,index) 
   
   returns the element in hash 'name' 
   reference by the key 'key', at index 'index' in the values list.
   
   =cut
   
   #-------------------------------------------------------
   sub GETHASH {
       my ($name,$key,$index)=@_;
       if (! defined($index)) {
    $index = 0;
       }
       if ($key =~ /^[A-z]\d+$/) {
    $key = $v{$key};
       }
       return $hashes{$name}->{$key}->[$index];
   }
   
   #-------------------------------------------------------
   
   =item CLEARHASH(name) 
   
   clears all the values from the hash 'name'
   
   =item CLEARHASH(name,key) 
   
   clears all the values from the hash 'name' associated with the given key.
   
   =cut
   
   #-------------------------------------------------------
   sub CLEARHASH {
       my ($name,$key)=@_;
       if (defined($key)) {
    if (exists($hashes{$name}->{$key})) {
       $hashes{$name}->{$key}=undef;
       return "hash '$name' key '$key' cleared";
    }
       } else {
    if (exists($hashes{$name})) {
       $hashes{$name}=undef;
       return "hash '$name' cleared";
    }
       }
       return "Error in clearing hash";
   }
   
   #-------------------------------------------------------
   
   =item HASH(name,key,value) 
   
   loads values into an internal hash.  If a key 
   already has a value associated with it, the values are sorted numerically.  
   
   =item HASH(name,key) 
   
   returns the 0th value in the hash 'name' associated with 'key'.
   
   =cut
   
   #-------------------------------------------------------
   sub HASH {
       my ($name,$key,$value)=@_;
       my @Keys;
       undef @Keys;
       my @Values;
       # Check to see if we have multiple $key values
       if ($key =~ /[A-z](\-[A-z])?\d+(\-\d+)?/) {
    my $keymask = &mask($key);
    # Assume the keys are addresses
    my @Temp = grep /$keymask/,keys(%v);
    @Keys = $v{@Temp};
       } else {
    $Keys[0]= $key;
       }
       # If $value is empty, return the first value associated 
       # with the first key.
       if (! $value) {
    return $hashes{$name}->{$Keys[0]}->[0];
       }
       # Check to see if we have multiple $value(s) 
       if ($value =~ /[A-z](\-[A-z])?\d+(\-\d+)?/) {
    my $valmask = &mask($value);
    my @Temp = grep /$valmask/,keys(%v);
    @Values =$v{@Temp};
       } else {
    $Values[0]= $value;
       }
       # Add values to hash
       for (my $i = 0; $i<=$#Keys; $i++) {
    my $key   = $Keys[$i];
    my $value = ($i<=$#Values ? $Values[$i] : $Values[0]);
    if (! exists ($hashes{$name}->{$key})) {
       $hashes{$name}->{$key}->[0]=$value;
    } else {
       my @Temp = sort(@{$hashes{$name}->{$key}},$value);
       $hashes{$name}->{$key} = \@Temp;
    }
       }
       return $Values[-1];
   }
   
   #-------------------------------------------------------
   
   =item NUM(range)
   
   returns the number of items in the range.
   
   =cut
   
   #-------------------------------------------------------
 sub NUM {  sub NUM {
     my $mask=mask(@_);      my $mask=mask(@_);
     my $num=0;      my $num= $#{@{grep(/$mask/,keys(%v))}}+1;
     map {  
         $num++;  
     } grep /$mask/,keys %v;  
     return $num;         return $num;   
 }  }
   
Line 151  sub BIN { Line 527  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;
     map {      foreach (grep /$mask/,keys(%v)) {
         if (($v{$_}>=$low) && ($v{$_}<=$high)) {          if (($v{$_}>=$low) && ($v{$_}<=$high)) {
             $num++;              $num++;
         }          }
     } grep /$mask/,keys %v;      }
     return $num;         return $num;   
 }  }
   
   
   #-------------------------------------------------------
   
   =item SUM(range)
   
   returns the sum of items in the range.
   
   =cut
   
   #-------------------------------------------------------
 sub SUM {  sub SUM {
     my $mask=mask(@_);      my $mask=mask(@_);
     my $sum=0;      my $sum=0;
     map {      foreach (grep /$mask/,keys(%v)) {
         $sum+=$v{$_};          $sum+=$v{$_};
     } grep /$mask/,keys %v;      }
     return $sum;         return $sum;   
 }  }
   
   #-------------------------------------------------------
   
   =item MEAN(range)
   
   compute the average of the items in the range.
   
   =cut
   
   #-------------------------------------------------------
 sub MEAN {  sub MEAN {
     my $mask=mask(@_);      my $mask=mask(@_);
     my $sum=0; my $num=0;      my $sum=0; my $num=0;
     map {      foreach (grep /$mask/,keys(%v)) {
         $sum+=$v{$_};          $sum+=$v{$_};
         $num++;          $num++;
     } grep /$mask/,keys %v;      }
     if ($num) {      if ($num) {
        return $sum/$num;         return $sum/$num;
     } else {      } else {
Line 183  sub MEAN { Line 577  sub MEAN {
     }         }   
 }  }
   
   #-------------------------------------------------------
   
   =item STDDEV(range)
   
   compute the standard deviation of the items in the range.
   
   =cut
   
   #-------------------------------------------------------
 sub STDDEV {  sub STDDEV {
     my $mask=mask(@_);      my $mask=mask(@_);
     my $sum=0; my $num=0;      my $sum=0; my $num=0;
     map {      foreach (grep /$mask/,keys(%v)) {
         $sum+=$v{$_};          $sum+=$v{$_};
         $num++;          $num++;
     } grep /$mask/,keys %v;      }
     unless ($num>1) { return undef; }      unless ($num>1) { return undef; }
     my $mean=$sum/$num;      my $mean=$sum/$num;
     $sum=0;      $sum=0;
     map {      foreach (grep /$mask/,keys(%v)) {
         $sum+=($v{$_}-$mean)**2;          $sum+=($v{$_}-$mean)**2;
     } grep /$mask/,keys %v;      }
     return sqrt($sum/($num-1));          return sqrt($sum/($num-1));    
 }  }
   
   #-------------------------------------------------------
   
   =item PROD(range)
   
   compute the product of the items in the range.
   
   =cut
   
   #-------------------------------------------------------
 sub PROD {  sub PROD {
     my $mask=mask(@_);      my $mask=mask(@_);
     my $prod=1;      my $prod=1;
     map {      foreach (grep /$mask/,keys(%v)) {
         $prod*=$v{$_};          $prod*=$v{$_};
     } grep /$mask/,keys %v;      }
     return $prod;         return $prod;   
 }  }
   
   #-------------------------------------------------------
   
   =item MAX(range)
   
   compute the maximum of the items in the range.
   
   =cut
   
   #-------------------------------------------------------
 sub MAX {  sub MAX {
     my $mask=mask(@_);      my $mask=mask(@_);
     my $max='-';      my $max='-';
     map {      foreach (grep /$mask/,keys(%v)) {
         unless ($max) { $max=$v{$_}; }          unless ($max) { $max=$v{$_}; }
         if (($v{$_}>$max) || ($max eq '-')) { $max=$v{$_}; }          if (($v{$_}>$max) || ($max eq '-')) { $max=$v{$_}; }
     } grep /$mask/,keys %v;      } 
     return $max;         return $max;   
 }  }
   
   #-------------------------------------------------------
   
   =item MIN(range)
   
   compute the minimum of the items in the range.
   
   =cut
   
   #-------------------------------------------------------
 sub MIN {  sub MIN {
     my $mask=mask(@_);      my $mask=mask(@_);
     my $min='-';      my $min='-';
     map {      foreach (grep /$mask/,keys(%v)) {
         unless ($max) { $max=$v{$_}; }          unless ($max) { $max=$v{$_}; }
         if (($v{$_}<$min) || ($min eq '-')) { $min=$v{$_}; }          if (($v{$_}<$min) || ($min eq '-')) { $min=$v{$_}; }
     } grep /$mask/,keys %v;      }
     return $min;         return $min;   
 }  }
   
   #-------------------------------------------------------
   
   =item SUMMAX(num,lower,upper)
   
   compute the sum of the largest 'num' items in the range from
   'lower' to 'upper'
   
   =cut
   
   #-------------------------------------------------------
 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=();
     map {      foreach (grep /$mask/,keys(%v)) {
  $inside[$#inside+1]=$v{$_};   push (@inside,$v{$_});
     } grep /$mask/,keys %v;      }
     @inside=sort(@inside);      @inside=sort(@inside);
     my $sum=0; my $i;      my $sum=0; my $i;
     for ($i=$#inside;(($i>$#inside-$num) && ($i>=0));$i--) {       for ($i=$#inside;(($i>$#inside-$num) && ($i>=0));$i--) { 
Line 243  sub SUMMAX { Line 683  sub SUMMAX {
     return $sum;         return $sum;   
 }  }
   
   #-------------------------------------------------------
   
   =item SUMMIN(num,lower,upper)
   
   compute the sum of the smallest 'num' items in the range from
   'lower' to 'upper'
   
   =cut
   
   #-------------------------------------------------------
 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=();
     map {      foreach (grep /$mask/,keys(%v)) {
  $inside[$#inside+1]=$v{$_};   $inside[$#inside+1]=$v{$_};
     } grep /$mask/,keys %v;      }
     @inside=sort(@inside);      @inside=sort(@inside);
     my $sum=0; my $i;      my $sum=0; my $i;
     for ($i=0;(($i<$num) && ($i<=$#inside));$i++) {       for ($i=0;(($i<$num) && ($i<=$#inside));$i++) { 
Line 258  sub SUMMIN { Line 708  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;
    foreach ( @vars ) {
               my $varname=$_;
               if ($varname=~/\D/) {
                  $formula=~s/$varname/'$c{\''.$varname.'\'}'/ge;
                  $varname=~s/$var/\(\\w\+\)/g;
          foreach (keys(%c)) {
     if ($_=~/$varname/) {
         $values{$1}=1;
                     }
                  }
       }
           }
           if ($func eq 'EXPANDSUM') {
               my $result='';
       foreach (keys(%values)) {
                   my $thissum=$formula;
                   $thissum=~s/$var/$_/g;
                   $result.=$thissum.'+';
               } 
               $result=~s/\+$//;
               return $result;
           } else {
       return 0;
           }
       } else {
           # it is not a function, so it is a parameter name
           # We should do the following:
           #    1. Take the list of parameter names
           #    2. look through the list for ones that match the parameter we want
           #    3. If there are no collisions, return the one that matches
           #    4. If there is a collision, return 'bad parameter name error'
           my $returnvalue = '';
           my @matches = ();
           $#matches = -1;
           study $expression;
           foreach $parameter (keys(%c)) {
               push @matches,$parameter if ($parameter =~ /$expression/);
           }
           if ($#matches == 0) {
               $returnvalue = '$c{\''.$matches[0].'\'}';
           } else {
               $returnvalue =  "'bad parameter name : $expression'";
           }
           return $returnvalue;
       }
   }
   
 sub sett {  sub sett {
     %t=();      %t=();
     my $pattern='';      my $pattern='';
Line 266  sub sett { Line 770  sub sett {
     } else {      } else {
         $pattern='[A-Z]';          $pattern='[A-Z]';
     }      }
     map {      foreach (keys(%f)) {
  if ($_=~/template\_(\w)/) {   if ($_=~/template\_(\w)/) {
   my $col=$1;    my $col=$1;
           unless ($col=~/^$pattern/) {            unless ($col=~/^$pattern/) {
             map {      foreach (keys(%f)) {
       if ($_=~/A(\d+)/) {        if ($_=~/A(\d+)/) {
  my $trow=$1;   my $trow=$1;
                 if ($trow) {                  if ($trow) {
                       # Get the name of this cell
     my $lb=$col.$trow;      my $lb=$col.$trow;
                       # Grab the template declaration
                     $t{$lb}=$f{'template_'.$col};                      $t{$lb}=$f{'template_'.$col};
                       # Replace '#' with the row number
                     $t{$lb}=~s/\#/$trow/g;                      $t{$lb}=~s/\#/$trow/g;
                       # Replace '....' with ','
                     $t{$lb}=~s/\.\.+/\,/g;                      $t{$lb}=~s/\.\.+/\,/g;
                       # Replace 'A0' with the value from 'A0'
                     $t{$lb}=~s/(^|[^\"\'])([A-Za-z]\d+)/$1\$v\{\'$2\'\}/g;                      $t{$lb}=~s/(^|[^\"\'])([A-Za-z]\d+)/$1\$v\{\'$2\'\}/g;
                       # Replace parameters
                       $t{$lb}=~s/(^|[^\"\'])\[([^\]]+)\]/$1.&expandnamed($2)/ge;
                 }                  }
       }        }
             } keys %f;      }
   }    }
       }        }
     } keys %f;      }
     map {      foreach (keys(%f)) {
  if (($f{$_}) && ($_!~/template\_/)) {   if (($f{$_}) && ($_!~/template\_/)) {
             if ($_=~/^$pattern/) {              my $matches=($_=~/^$pattern(\d+)/);
               if  (($matches) && ($1)) {
         unless ($f{$_}=~/^\!/) {          unless ($f{$_}=~/^\!/) {
     $t{$_}=$c{$_};      $t{$_}=$c{$_};
                 }                  }
Line 295  sub sett { Line 807  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;      }
       # For some reason 'A0' gets special treatment...  This seems superfluous
       # but I imagine it is here for a reason.
     $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 310  sub calc { Line 826  sub calc {
     my $depth=0;      my $depth=0;
     while ($notfinished) {      while ($notfinished) {
  $notfinished=0;   $notfinished=0;
         map {          foreach (keys(%t)) {
             my $old=$v{$_};              my $old=$v{$_};
             $v{$_}=eval($t{$_});              $v{$_}=eval($t{$_});
     if ($@) {      if ($@) {
Line 318  sub calc { Line 834  sub calc {
                 return $@;                  return $@;
             }              }
     if ($v{$_} ne $old) { $notfinished=1; }      if ($v{$_} ne $old) { $notfinished=1; }
         } keys %t;          }
         $depth++;          $depth++;
         if ($depth>100) {          if ($depth>100) {
     %v=();      %v=();
Line 328  sub calc { Line 844  sub calc {
     return '';      return '';
 }  }
   
   sub templaterow {
       my @cols=();
       $cols[0]='<b><font size=+1>Template</font></b>';
       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') {
           my $fm=$f{'template_'.$_};
           $fm=~s/[\'\"]/\&\#34;/g;
           $cols[$#cols+1]="'template_$_','$fm'".'___eq___'.$fm;
       }
       return @cols;
   }
   
 sub outrowassess {  sub outrowassess {
     my $n=shift;      my $n=shift;
     my @cols=();      my @cols=();
     if ($n) {      if ($n) {
        $cols[0]=$rl{$f{'A'.$n}};         my ($usy,$ufn)=split(/\_\_\&\&\&\_\_/,$f{'A'.$n});
         if ($rl{$usy}) {
          $cols[0]=$rl{$usy}.'<br>'.
                   '<select name="sel_'.$n.'" onChange="changesheet('.$n.
                   ')"><option name="default">Default</option>';
         } else { $cols[0]=''; }
          foreach (@os) {
              $cols[0].='<option name="'.$_.'"';
               if ($ufn eq $_) {
                  $cols[0].=' selected';
               }
               $cols[0].='>'.$_.'</option>';
          }
          $cols[0].='</select>';
     } else {      } else {
        $cols[0]='<b><font size=+1>Export</font></b>';         $cols[0]='<b><font size=+1>Export</font></b>';
     }      }
     map {      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') {
         my $fm=$f{$_.$n};          my $fm=$f{$_.$n};
         $fm=~s/[\'\"]/\&\#34;/g;          $fm=~s/[\'\"]/\&\#34;/g;
         $cols[$#cols+1]="'$_$n','$fm'".'___eq___'.$v{$_.$n};          push(@cols,"'$_$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;      return @cols;
 }  }
   
Line 351  sub outrow { Line 894  sub outrow {
     my $n=shift;      my $n=shift;
     my @cols=();      my @cols=();
     if ($n) {      if ($n) {
        $cols[0]=$rl{$f{'A'.$n}}.' stuff';         $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>';
     }      }
     map {      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') {
         my $fm=$f{$_.$n};          my $fm=$f{$_.$n};
         $fm=~s/[\'\"]/\&\#34;/g;          $fm=~s/[\'\"]/\&\#34;/g;
         $cols[$#cols+1]="'$_$n','$fm'".'___eq___'.$v{$_.$n};          $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;      return @cols;
 }  }
   
 sub exportrowa {  sub exportrowa {
     my $rowa='';      my @exportarray=();
     map {      foreach ('A','B','C','D','E','F','G','H','I','J','K','L','M',
  $rowa.=$v{$_.'0'}."___;___";       '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',   $exportarray[$#exportarray+1]=$v{$_.'0'};
        '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 385  ENDDEFS Line 927  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 421  sub getvalues { Line 970  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 437  sub gettype { Line 979  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 465  sub getfilename { Line 1008  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';
       }
       unless ($ENV{'form.showcsv'}) {
          $rowdata.="\n<tr><td><b><font size=+1>$n</font></b></td>";
       } else {
          $rowdata.="\n".'"'.$n.'"';
       }
     my $showf=0;      my $showf=0;
     my $proc;      my $proc;
     my $maxred;      my $maxred;
     if (&gettype($safeeval) eq 'assesscalc') {      my $sheettype=&gettype($safeeval);
       if ($sheettype eq 'studentcalc') {
         $proc='&outrowassess';          $proc='&outrowassess';
         $maxred=1;          $maxred=26;
     } else {      } else {
         $proc='&outrow';          $proc='&outrow';
       }
       if ($sheettype eq 'assesscalc') {
           $maxred=1;
       } else {
         $maxred=26;          $maxred=26;
     }      }
     map {      if ($n eq '-') { $proc='&templaterow'; $n=-1; $dataflag=1; }
       foreach ($safeeval->reval($proc.'('.$n.')')) {
        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=$_; }
         unless ($ENV{'form.showcsv'}) {
        if ($showf<=$maxred) { $bgcolor='#FFDDDD'; }         if ($showf<=$maxred) { $bgcolor='#FFDDDD'; }
        if (($n==0) && ($showf<=26)) { $bgcolor='#CCCCFF'; }          if (($n==0) && ($showf<=26)) { $bgcolor='#CCCCFF'; } 
        if (($showf>$maxred) || ((!$n) && ($showf>0))) {         if (($showf>$maxred) || ((!$n) && ($showf>0))) {
Line 508  sub rown { Line 1144  sub rown {
        } else {         } else {
            $rowdata.='<td bgcolor='.$bgcolor.'>&nbsp;'.$vl.'&nbsp;</td>';             $rowdata.='<td bgcolor='.$bgcolor.'>&nbsp;'.$vl.'&nbsp;</td>';
        }         }
         } else {
     $rowdata.=',"'.$vl.'"';
         }
        $showf++;         $showf++;
     } $safeeval->reval($proc.'('.$n.')');      }  # End of foreach($safeval...)
     return $rowdata.'</tr>';      if ($ENV{'form.showall'} || ($dataflag)) {
          return $rowdata.($ENV{'form.showcsv'}?'':'</tr>');
       } else {
          return '';
       }
 }  }
   
 # ------------------------------------------------------------- Print out sheet  # ------------------------------------------------------------- Print out sheet
   
 sub outsheet {  sub outsheet {
     my $safeeval=shift;      my ($r,$safeeval)=@_;
     my $maxred;      my $maxred;
     my $realm;      my $realm;
     if (&gettype($safeeval) eq 'assesscalc') {      if (&gettype($safeeval) eq 'assesscalc') {
Line 530  sub outsheet { Line 1173  sub outsheet {
         $realm='Course';          $realm='Course';
     }      }
     my $maxyellow=52-$maxred;      my $maxyellow=52-$maxred;
     my $tabledata='<table border=2><tr><th colspan=2 rowspan=2><font size=+2>'.      my $tabledata;
       unless ($ENV{'form.showcsv'}) {
          $tabledata=
           '<table border=2><tr><th colspan=2 rowspan=2><font size=+2>'.
                   $realm.'</font></th>'.                    $realm.'</font></th>'.
                   '<td bgcolor=#FFDDDD colspan='.$maxred.                    '<td bgcolor=#FFDDDD colspan='.$maxred.
                   '><b><font size=+1>Import</font></b></td>'.                    '><b><font size=+1>Import</font></b></td>'.
                   '<td colspan='.$maxyellow.                    '<td colspan='.$maxyellow.
   '><b><font size=+1>Calculations</font></b></td></tr><tr>';    '><b><font size=+1>Calculations</font></b></td></tr><tr>';
     my $showf=0;      my $showf=0;
     map {      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') {
         $showf++;          $showf++;
         if ($showf<=$maxred) {           if ($showf<=$maxred) { 
            $tabledata.='<td bgcolor="#FFDDDD">';              $tabledata.='<td bgcolor="#FFDDDD">'; 
Line 545  sub outsheet { Line 1194  sub outsheet {
            $tabledata.='<td>';             $tabledata.='<td>';
         }          }
         $tabledata.="<b><font size=+1>$_</font></b></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',      $tabledata.='</tr>'.&rown($safeeval,'-').&rown($safeeval,0);
        'a','b','c','d','e','f','g','h','i','j','k','l','m',     } else { $tabledata='<pre>'; }
        'n','o','p','q','r','s','t','u','v','w','x','y','z');  
     $tabledata.='</tr>';      $r->print($tabledata);
   
     my $row;      my $row;
     my $maxrow=&getmaxrow($safeeval);      my $maxrow=&getmaxrow($safeeval);
     for ($row=0;$row<=$maxrow;$row++) {  
         $tabledata.=&rown($safeeval,$row);      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)) && (!$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
   # 
   sub othersheets {
       my ($safeeval,$stype)=@_;
       #
       my $cnum=&getcnum($safeeval);
       my $cdom=&getcdom($safeeval);
       my $chome=&getchome($safeeval);
       #
       my @alternatives=();
       my %results=&Apache::lonnet::dump($stype.'_spreadsheets',$cdom,$cnum);
       my ($tmp) = keys(%results);
       unless ($tmp =~ /^(con_lost|error|no_such_host)/i) {
           @alternatives = sort (keys(%results));
     }      }
     $tabledata.='</table>';      return @alternatives; 
 }  }
   
   
   #
   # -------------------------------------- Parse a spreadsheet
   # 
   sub parse_sheet {
       # $sheetxml is a scalar reference or a scalar
       my ($sheetxml) = @_;
       if (! ref($sheetxml)) {
           my $tmp = $sheetxml;
           $sheetxml = \$tmp;
       }
       my %f;
       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');
               }
           }
       }
       return \%f;
   }
   
 # ------------------------------------- Read spreadsheet formulas from a course  #
   # -------------------------------------- Read spreadsheet formulas for a course
   #
   
 sub readsheet {  sub readsheet {
     my ($safeeval,$fn,$r)=@_;    my ($safeeval,$fn)=@_;
     my %f=();    my $stype=&gettype($safeeval);
     unless ($fn) {    my $cnum=&getcnum($safeeval);
  my $sheetxml='';    my $cdom=&getcdom($safeeval);
        {    my $chome=&getchome($safeeval);
          my $fh;  
          if ($fh=Apache::File->new($r->dir_config('lonIncludes').    if (! defined($fn)) {
                          '/default.'.&gettype($safeeval))) {        # There is no filename. Look for defaults in course and global, cache
                $sheetxml=join('',<$fh>);        unless ($fn=$defaultsheets{$cnum.'_'.$cdom.'_'.$stype}) {
             my %tmphash = &Apache::lonnet::get('environment',
                                                ['spreadsheet_default_'.$stype],
                                                $cdom,$cnum);
             my ($tmp) = keys(%tmphash);
             if ($tmp =~ /^(con_lost|error|no_such_host)/i) {
                 $fn = 'default_'.$stype;
             } else {
                 $fn = $tmphash{'spreadsheet_default_'.$stype};
             } 
             unless (($fn) && ($fn!~/^error\:/)) {
         $fn='default_'.$stype;
           }            }
        }            $defaultsheets{$cnum.'_'.$cdom.'_'.$stype}=$fn; 
        my $parser=HTML::TokeParser->new(\$sheetxml);        }
        my $token;    }
        while ($token=$parser->get_token) {  
           if ($token->[0] eq 'S') {  # ---------------------------------------------------------- fn now has a value
       if ($token->[1] eq 'field') {  
   $f{$token->[2]->{'col'}.$token->[2]->{'row'}}=    &setfilename($safeeval,$fn);
       $parser->get_text('/field');  
       }  # ------------------------------------------------------ see if sheet is cached
              if ($token->[1] eq 'template') {    my $fstring='';
                  $f{'template_'.$token->[2]->{'col'}}=    if ($fstring=$spreadsheets{$cnum.'_'.$cdom.'_'.$stype.'_'.$fn}) {
                      $parser->get_text('/template');        &setformulas($safeeval,split(/\_\_\_\;\_\_\_/,$fstring));
     } else {
   
   # ---------------------------------------------------- Not cached, need to read
   
        my %f=();
   
        if ($fn=~/^default\_/) {
            my $sheetxml='';
            my $fh;
            my $dfn=$fn;
            $dfn=~s/\_/\./g;
            if ($fh=Apache::File->new($includedir.'/'.$dfn)) {
                $sheetxml=join('',<$fh>);
            } else {
                $sheetxml='<field row="0" col="A">"Error"</field>';
            }
            %f=%{&parse_sheet(\$sheetxml)};
        } elsif($fn=~/\/*\.spreadsheet$/) {
            my $sheetxml=&Apache::lonnet::getfile
                (&Apache::lonnet::filelocation('',$fn));
            if ($sheetxml == -1) {
                $sheetxml='<field row="0" col="A">"Error loading spreadsheet '
                    .$fn.'"</field>';
            }
            %f=%{&parse_sheet(\$sheetxml)};
        } else {
            my $sheet='';
            my %tmphash = &Apache::lonnet::dump($fn,$cdom,$cnum);
            my ($tmp) = keys(%tmphash);
            unless ($tmp =~ /^(con_lost|error|no_such_host)/i) {
                foreach (keys(%tmphash)) {
                    $f{$_}=$tmphash{$_};
              }               }
           }           }
        }       }
        &setfilename($safeeval,'default_'.&gettype($safeeval));  # --------------------------------------------------------------- Cache and set
     } else {         $spreadsheets{$cnum.'_'.$cdom.'_'.$stype.'_'.$fn}=join('___;___',%f);  
        &setfilename($safeeval,$fn);         &setformulas($safeeval,%f);
        unless ($spreadsheets{$fn}) {  
           $spreadsheets{$fn}='';  
           my $reply=&Apache::lonnet::reply('dump:'.  
               $ENV{'course.'.$ENV{'request.course.id'}.'.domain'}.':'.  
               $ENV{'course.'.$ENV{'request.course.id'}.'.num'}.':'.$fn,  
               $ENV{'course.'.$ENV{'request.course.id'}.'.home'});  
           unless ($reply=~/^error\:/) {  
              $spreadsheets{$fn}=$reply;  
           }  
        }  
        map {  
            my ($name,$value)=split(/\=/,$_);  
            $f{&Apache::lonnet::unescape($name)}=  
       &Apache::lonnet::unescape($value);  
        } split(/\&/,$spreadsheets{$fn});  
     }      }
   }
   
     &setformulas($safeeval,%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=shift;    my ($safeeval,$makedef)=@_;
   if (&Apache::lonnet::allowed('opa',$ENV{'request.course.id'})) {    my $cid=&getcid($safeeval);
     if (&Apache::lonnet::allowed('opa',$cid)) {
     my %f=&getformulas($safeeval);      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='';      my $sheetdata='';
     map {      foreach (keys(%f)) {
        unless ($f{$_} eq 'import') {
        $sheetdata.=&Apache::lonnet::escape($_).'='.         $sheetdata.=&Apache::lonnet::escape($_).'='.
    &Apache::lonnet::escape($f{$_}).'&';     &Apache::lonnet::escape($f{$_}).'&';
     } keys %f;       }
       }
     $sheetdata=~s/\&$//;      $sheetdata=~s/\&$//;
     my $reply=&Apache::lonnet::reply('put:'.      my $reply=&Apache::lonnet::reply('put:'.$cdom.':'.$cnum.':'.$fn.':'.
               $ENV{'course.'.$ENV{'request.course.id'}.'.domain'}.':'.                $sheetdata,$chome);
               $ENV{'course.'.$ENV{'request.course.id'}.'.num'}.':'.      if ($reply eq 'ok') {
               &getfilename($safeeval).':'.            $reply=&Apache::lonnet::reply('put:'.$cdom.':'.$cnum.':'.
               $sheetdata,                $stype.'_spreadsheets:'.
               $ENV{'course.'.$ENV{'request.course.id'}.'.home'});                &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;
         }
     }
     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 648  sub tmpwrite { Line 1460  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;
     my %fo=();      my %fo=();
       my $countrows=0;
     if ($fh=Apache::File->new($fn)) {      if ($fh=Apache::File->new($fn)) {
         my $name;          my $name;
         while ($name=<$fh>) {          while ($name=<$fh>) {
Line 661  sub tmpread { Line 1476  sub tmpread {
             my $value=<$fh>;              my $value=<$fh>;
             chomp($value);              chomp($value);
             $fo{$name}=$value;              $fo{$name}=$value;
               if ($name=~/^A(\d+)$/) {
    if ($1>$countrows) {
       $countrows=$1;
                   }
               }
         }          }
     }      }
     $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          }
       } elsif ($nfield eq 'insertrow') {
 sub readmeta {          $countrows++;
     my $fn=shift;          if ($nform eq 'top') {
     unless ($fn=~/\.meta$/) { $fn.='meta'; }      $fo{'A'.$countrows}='AAAAA_'.$countrows;
     my $content;          } else {
     my %returnhash=();              $fo{'A'.$countrows}='zzzzz_'.$countrows;
     {          }
       my $fh=Apache::File->new($fn);      } else {
       $content=join('',<$fh>);         if ($nfield) { $fo{$nfield}=$nform; }
     }      }
    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 707  sub parmval { Line 1525  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 770  sub parmval { Line 1589  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\:/) {
           foreach (split(/\&/,$classlst)) {
               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) {
      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
        
           foreach (sort keys(%currentlist)) {
               unless ($existing{$_}) {
    $changed=1;
                   $maxrow++;
                   $f{'A'.$maxrow}=$_;
               }
           }
        
           if ($changed) { &setformulas($safeeval,%f); }
   
           &setmaxrow($safeeval,$maxrow);
           &setrowlabels($safeeval,%currentlist);
   
       } else {
           return 'Could not access course data';
       }
   }
   
 # ----------------------------------------------------------------- Update rows  # ----------------------------------- 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' => 
         my %allassess=();                       'Timestamp of Last Transaction<br>timestamp',
                        'subnumber' =>
                        'Number of Submissions<br>subnumber',
                        'tutornumber' =>
                        'Number of Tutor Responses<br>tutornumber',
                        'totalpoints' =>
                        'Total Points Granted<br>totalpoints');
   
           my $adduserstr='';
           if ((&getuname($safeeval) ne $ENV{'user.name'}) ||
               (&getudom($safeeval) ne $ENV{'user.domain'})) {
               $adduserstr='&uname='.&getuname($safeeval).
    '&udom='.&getudom($safeeval);
           }
   
         my $stype=&gettype($safeeval);          my %allassess=('_feedback' =>
                 '<a href="/adm/assesscalc?usymb=_feedback'.$adduserstr.
                          '">Feedback</a>',
                          '_evaluation' =>
                 '<a href="/adm/assesscalc?usymb=_evaluation'.$adduserstr.
                          '">Evaluation</a>',
                          '_tutoring' =>
                 '<a href="/adm/assesscalc?usymb=_tutoring'.$adduserstr.
                          '">Tutoring</a>',
                          '_discussion' =>
                 '<a href="/adm/assesscalc?usymb=_discussion'.$adduserstr.
                          '">Discussion</a>'
           );
   
         map {          foreach (keys(%bighash)) {
     if ($_=~/^src\_(\d+)\.(\d+)$/) {      if ($_=~/^src\_(\d+)\.(\d+)$/) {
        my $mapid=$1;         my $mapid=$1;
                my $resid=$2;                 my $resid=$2;
Line 797  sub updaterows { Line 1745  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 {       foreach (split(/\,/,
       &Apache::lonnet::metadata($srcf,'keys'))) {
                        if (($_=~/^stores\_(.*)/) || ($_=~/^parameter\_(.*)/)) {                         if (($_=~/^stores\_(.*)/) || ($_=~/^parameter\_(.*)/)) {
   my $key=$_;    my $key=$_;
                           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'));                     } # end of foreach
          }           }
       }        }
    }     }
         } keys %bighash;          } # end of foreach (keys(%bighash))
         untie(%bighash);          untie(%bighash);
           
 #  #
 # %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=();
   
 # ----------------------------------------------------------- Now obsolete rows  # ----------------------------------------------------------- Now obsolete rows
  map {   foreach (keys(%f)) {
     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;          }
   
 # -------------------------------------------------------- New and unknown keys  # -------------------------------------------------------- New and unknown keys
             
         map {          foreach (keys(%current)) {
             unless ($existing{$_}) {              unless ($existing{$_}) {
  $changed=1;   $changed=1;
                 $maxrow++;                  $maxrow++;
                 $f{'A'.$maxrow}=$_;                  $f{'A'.$maxrow}=$_;
             }              }
         } 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\:/) {
    foreach ( split(/\&/,$reply)) {
               my ($name,$value)=split(/\=/,$_);
               $cachedstores{&Apache::lonnet::unescape($name)}=
                     &Apache::lonnet::unescape($value);
    }
         }
       }
       my @assessdata=();
       foreach (keys(%f)) {
    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;
                 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') {
                     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++;
                 }
      }
           }
     }      }
       $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);
     map {      my $total=0;
       foreach (keys(%f)) {
    if ($_=~/^A(\d+)/) {
       unless ($f{$_}=~/^\!/) { $total++; }
           }
       }
       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();
       foreach (keys(%f)) {
  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 {               foreach ('A','B','C','D','E','F','G','H','I','J','K','L','M',
                   if ($assessdata[$index]) {                'N','O','P','Q','R','S','T','U','V','W','X','Y','Z') {
      $c{$_.$row}=$assessdata[$index];                    if ($studentdata[$index]) {
                      unless ($_ eq 'A') {        my $col=$_;
  $f{$_.$row}='import';       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',                }
                  'N','O','P','Q','R','S','T','U','V','W','X','Y','Z');  
    }     }
         }          }
     } keys %f;      }
     &setformulas($safeeval,%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++) {
              foreach (split(/\:/,$cachedstores{$scope.':keys:'.$symb})) {
                  $returnhash{$_}=$cachedstores{$scope.':'.$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=();      foreach (split(/\&/,$answer)) {
     map {  
  my ($name,$value)=split(/\=/,$_);   my ($name,$value)=split(/\=/,$_);
         $returnhash{&Apache::lonnet::unescape($name)}=          $returnhash{&Apache::lonnet::unescape($name)}=
                     &Apache::lonnet::unescape($value);                      &Apache::lonnet::unescape($value);
     } split(/\&/,$answer);      }
     my $version;      my $version;
     for ($version=1;$version<=$returnhash{'version'};$version++) {      for ($version=1;$version<=$returnhash{'version'};$version++) {
        map {         foreach (split(/\:/,$returnhash{$version.':keys'})) {
           $returnhash{$_}=$returnhash{$version.':'.$_};            $returnhash{$_}=$returnhash{$version.':'.$_};
        } split(/\:/,$returnhash{$version.':keys'});         } 
     }      }
      }
 # ----------------------------- 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
   
       my @oldkeys=keys %returnhash;
   
       foreach (@oldkeys) {
           my $name=$_;
           my $value=$returnhash{$_};
           delete $returnhash{$_};
           $name=~s/\_/\./g;
           $returnhash{$name}=$value;
       }
   
 # ---------------------------- 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 {        foreach (split(/\&/,$courserdatas{$cid})) {
          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'}});        }
 # --------------------------------------------------- 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 962  sub rowaassess { Line 2052  sub rowaassess {
      $userrdatas{$uname.'___'.$udom.'.last_cache'}=time;       $userrdatas{$uname.'___'.$udom.'.last_cache'}=time;
          }           }
       }        }
       map {        foreach (split(/\&/,$userrdatas{$uname.'___'.$udom})) {
          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});        }
    }      }
 # -- 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);
       
       foreach (split(/\,/,&Apache::lonnet::metadata($srcf,'keys'))) {
           $thisassess{$_}=1;
       } 
   #
   # 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 {      foreach (keys(%f))  {
  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;      }
       untie(%parmhash);
     &setconstants($safeeval,%c);     }
      &setconstants($safeeval,%c);
 }  }
   
 # --------------------------------------------------------- Various form fields  # --------------------------------------------------------- Various form fields
Line 1006  sub hiddenfield { Line 2119  sub hiddenfield {
 sub selectbox {  sub selectbox {
     my ($title,$name,$value,%options)=@_;      my ($title,$name,$value,%options)=@_;
     my $selout="\n<p><b>$title:</b><br>".'<select name="'.$name.'">';      my $selout="\n<p><b>$title:</b><br>".'<select name="'.$name.'">';
     map {      foreach (sort keys(%options)) {
         $selout.='<option value="'.$_.'"';          $selout.='<option value="'.$_.'"';
         if ($_ eq $value) { $selout.=' selected'; }          if ($_ eq $value) { $selout.=' selected'; }
         $selout.='>'.$options{$_}.'</option>';          $selout.='>'.$options{$_}.'</option>';
     } sort keys %options;      }
     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=();
   
    if (($usymb=~/^\_(\w+)/) && (!$fn)) {
       $fn='default_'.$1;
    }
   
   #
   # Check if cached
   #
   
    my $key=$uname.':'.$udom.':'.$stype.':'.$usymb;
    my $found='';
   
    if ($oldsheets{$key}) {
        foreach (split(/\_\_\_\&\_\_\_/,$oldsheets{$key})) {
            my ($name,$value)=split(/\_\_\_\=\_\_\_/,$_);
            if ($name eq $fn) {
        $found=$value;
            }
        }
    }
   
    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) {
           $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);
           }
       }
   }
   
   # ===================================================== 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\:/) {
    foreach ( split(/\&/,$reply)) {
               my ($name,$value)=split(/\=/,$_);
               $oldsheets{&Apache::lonnet::unescape($name)}
                         =&Apache::lonnet::unescape($value);
           }
       }
       $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
   
     map {      &Apache::loncommon::get_unprocessed_cgi($ENV{'QUERY_STRING'},
        my ($name, $value) = split(/=/,$_);                                              ['uname','udom','usymb','ufn']);
        $value =~ tr/+/ /;  
        $value =~ s/%([a-fA-F0-9][a-fA-F0-9])/pack("C",hex($1))/eg;      if (($ENV{'form.usymb'}=~/^\_(\w+)/) && (!$ENV{'form.ufn'})) {
        if (($name eq 'uname') || ($name eq 'udom') ||    $ENV{'form.ufn'}='default_'.$1;
            ($name eq 'usymb') || ($name eq 'ufn')) {      }
            unless ($ENV{'form.'.$name}) {  
               $ENV{'form.'.$name}=$value;  
    }  
        }  
     } (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 1069  sub handler { Line 2448  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">
   
     function celledit(cn,cf) {      function celledit(cn,cf) {
         var cnf=prompt(cn,cf);          var cnf=prompt(cn,cf);
  if (cnf!=null) {          if (cnf!=null) {
     document.sheet.unewfield.value=cn;              document.sheet.unewfield.value=cn;
             document.sheet.unewformula.value=cnf;              document.sheet.unewformula.value=cnf;
             document.sheet.submit();              document.sheet.submit();
         }          }
     }      }
   
       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>  </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('ufn',$ENV{'form.ufn'}).  
        &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+)$/;      $r->uri=~/\/(\w+)$/;
     &settype($sheetone,$1);  
       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,$ENV{'form.ufn'});          &setfilename($asheet,$ENV{'form.ufn'});
  &tmpread($sheetone,$r->dir_config('lonDaemons').'/tmp/',   &tmpread($asheet,
                  $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,$ENV{'form.ufn'},$r);          &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 {          if ($ENV{'form.usymb'}) {
        $r->print('<h3><font color=red>'.             $r->print('<br><b>Assessment:</b> <tt>'.$ENV{'form.usymb'}.'</tt>');
    '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>');
       }
       
   
   # ----------------------------------------------------------------- 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
   
       &expirationdates();
   
     if (&gettype($sheetone) eq 'assesscalc') {      undef %oldsheets;
  &rowaassess($sheetone,$ENV{'form.usymb'});      undef %loadedcaches;
     } elsif  (&gettype($sheetone) eq 'studentcalc') {  
  &rowazstudent($sheetone);      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>');
    }
     }      }
     my $calcoutput=&calcsheet($sheetone);  
     unless ($reroute) {  # ------------------------------------------------ Write the modified worksheet
        $r->print('<h3><font color=red>'.$calcoutput.'</h3></font>');  
      $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(&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.'.$ENV{'request.course.id'}.'.hideemptyrows'} eq 'yes') {
             $r->print(' checked');
             $ENV{'form.showall'}=1;
              }
          }
     }      }
       $r->print('>');
   
 # ------------------------------------------------------- Print or export sheet      if (&gettype($asheet) eq 'classcalc') {
    unless ($reroute) {            $r->print(
     $r->print(&outsheet($sheetone));     ' 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>');      $r->print('</form></body></html>');
   } else {  
      $r->print(&exportrow($sheetone));  
   }  
 # ------------------------------------------------------------------------ Done  # ------------------------------------------------------------------------ Done
   } else {    } else {
 # ----------------------------- Not in a course, or not allowed to modify parms  # ----------------------------- Not in a course, or not allowed to modify parms
Line 1171  ENDSCRIPT Line 2720  ENDSCRIPT
       return HTTP_NOT_ACCEPTABLE;         return HTTP_NOT_ACCEPTABLE; 
   }    }
     return OK;      return OK;
   
 }  }
   
 1;  1;
Line 1178  __END__ Line 2728  __END__
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   

Removed from v.1.20  
changed lines
  Added in v.1.93


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