1: #
2: # $Id: Spreadsheet.pm,v 1.32 2003/12/08 19:43:03 matthew Exp $
3: #
4: # Copyright Michigan State University Board of Trustees
5: #
6: # This file is part of the LearningOnline Network with CAPA (LON-CAPA).
7: #
8: # LON-CAPA is free software; you can redistribute it and/or modify
9: # it under the terms of the GNU General Public License as published by
10: # the Free Software Foundation; either version 2 of the License, or
11: # (at your option) any later version.
12: #
13: # LON-CAPA is distributed in the hope that it will be useful,
14: # but WITHOUT ANY WARRANTY; without even the implied warranty of
15: # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16: # GNU General Public License for more details.
17: #
18: # You should have received a copy of the GNU General Public License
19: # along with LON-CAPA; if not, write to the Free Software
20: # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21: #
22: # /home/httpd/html/adm/gpl.txt
23: #
24: # http://www.lon-capa.org/
25: #
26: # The LearningOnline Network with CAPA
27: # Spreadsheet/Grades Display Handler
28: #
29: # POD required stuff:
30:
31: =head1 NAME
32:
33: Spreadsheet
34:
35: =head1 SYNOPSIS
36:
37: =head1 DESCRIPTION
38:
39: =over 4
40:
41: =cut
42:
43: ###################################################
44: ###################################################
45: ### Spreadsheet ###
46: ###################################################
47: ###################################################
48: package Apache::Spreadsheet;
49:
50: use strict;
51: #use warnings FATAL=>'all';
52: #no warnings 'uninitialized';
53: use Apache::Constants qw(:common :http);
54: use Apache::lonnet;
55: use Safe;
56: use Safe::Hole;
57: use Opcode;
58: use HTML::Entities();
59: use HTML::TokeParser;
60: use Spreadsheet::WriteExcel;
61: use Time::HiRes;
62: use Apache::lonlocal;
63:
64: ##
65: ## Package Variables
66: ##
67: my %expiredates;
68:
69: my @UC_Columns = split(//,'ABCDEFGHIJKLMNOPQRSTUVWXYZ');
70: my @LC_Columns = split(//,'abcdefghijklmnopqrstuvwxyz');
71:
72: ######################################################
73:
74: =pod
75:
76: =item &new
77:
78: Returns a new spreadsheet object.
79:
80: =cut
81:
82: ######################################################
83: sub new {
84: my $this = shift;
85: my $class = ref($this) || $this;
86: my ($stype) = ($class =~ /Apache::(.*)$/);
87: #
88: my ($name,$domain,$filename,$usymb)=@_;
89: #
90: my $self = {
91: name => $name,
92: domain => $domain,
93: type => $stype,
94: symb => $usymb,
95: errorlog => '',
96: maxrow => 0,
97: cid => $ENV{'request.course.id'},
98: cnum => $ENV{'course.'.$ENV{'request.course.id'}.'.num'},
99: cdom => $ENV{'course.'.$ENV{'request.course.id'}.'.domain'},
100: chome => $ENV{'course.'.$ENV{'request.course.id'}.'.home'},
101: coursedesc => $ENV{'course.'.$ENV{'request.course.id'}.'.description'},
102: coursefilename => $ENV{'request.course.fn'},
103: #
104: # Flags
105: temporary => 0, # true if this sheet has been modified but not saved
106: new_rows => 0, # true if this sheet has new rows
107: #
108: # blackout is used to determine if any data needs to be hidden from the
109: # student.
110: blackout => 0,
111: #
112: # Data storage
113: formulas => {},
114: constants => {},
115: rows => [],
116: row_source => {},
117: othersheets => [],
118: };
119: #
120: $self->{'uhome'} = &Apache::lonnet::homeserver($name,$domain);
121: #
122: bless($self,$class);
123: #
124: # Load in the spreadsheet definition
125: $self->filename($filename);
126: if (exists($ENV{'form.workcopy'}) &&
127: $self->{'type'} eq $ENV{'form.workcopy'}) {
128: $self->load_tmp();
129: } else {
130: $self->load();
131: }
132: return $self;
133: }
134:
135: ######################################################
136:
137: =pod
138:
139: =item &filename
140:
141: get or set the filename for a spreadsheet.
142:
143: =cut
144:
145: ######################################################
146: sub filename {
147: my $self = shift();
148: if (@_) {
149: my ($newfilename) = @_;
150: if (! defined($newfilename) || $newfilename eq 'Default' ||
151: $newfilename !~ /\w/ || $newfilename eq '') {
152: my $key = 'course.'.$self->{'cid'}.'.spreadsheet_default_'.
153: $self->{'type'};
154: if (exists($ENV{$key}) && $ENV{$key} ne '') {
155: $newfilename = $ENV{$key};
156: } else {
157: $newfilename = 'default_'.$self->{'type'};
158: }
159: }
160: if ($newfilename !~ /\w/ || $newfilename =~ /^\W*$/) {
161: $newfilename = 'default_'.$self->{'type'};
162: }
163: if ($newfilename !~ /^default\.$self->{'type'}$/ ) {
164: if ($newfilename !~ /_$self->{'type'}$/) {
165: $newfilename =~ s/[\s_]*$//;
166: $newfilename .= '_'.$self->{'type'};
167: }
168: }
169: $self->{'filename'} = $newfilename;
170: return;
171: }
172: return $self->{'filename'};
173: }
174:
175: ######################################################
176:
177: =pod
178:
179: =item &make_default()
180:
181: Make the current spreadsheet file the default for the course. Expires all the
182: default spreadsheets.......!
183:
184: =cut
185:
186: ######################################################
187: sub make_default {
188: my $self = shift();
189: my $result = &Apache::lonnet::put('environment',
190: {'spreadsheet_default_'.$self->{'type'} => $self->filename()},
191: $self->{'cdom'},$self->{'cnum'});
192: return $result if ($result ne 'ok');
193: my $symb = $self->{'symb'};
194: $symb = '' if (! defined($symb));
195: &Apache::lonnet::expirespread('','',$self->{'type'},$symb);
196: }
197:
198: ######################################################
199:
200: =pod
201:
202: =item &is_default()
203:
204: Returns 1 if the current spreadsheet is the default as specified in the
205: course environment. Returns 0 otherwise.
206:
207: =cut
208:
209: ######################################################
210: sub is_default {
211: my $self = shift;
212: # Check to find out if we are the default spreadsheet (filenames match)
213: my $default_filename = '';
214: my %tmphash = &Apache::lonnet::get('environment',
215: ['spreadsheet_default_'.
216: $self->{'type'}],
217: $self->{'cdom'},
218: $self->{'cnum'});
219: my ($tmp) = keys(%tmphash);
220: if ($tmp !~ /^(con_lost|error|no_such_host)/i) {
221: $default_filename = $tmphash{'spreadsheet_default_'.$self->{'type'}};
222: }
223: if ($default_filename =~ /^\s*$/) {
224: $default_filename = 'default_'.$self->{'type'};
225: }
226: return 1 if ($self->filename() eq $default_filename);
227: return 0;
228: }
229:
230: sub initialize {
231: # This method is here to remind you that it will be overridden by
232: # the descendents of the spreadsheet class.
233: }
234:
235: sub clear_package {
236: # This method is here to remind you that it will be overridden by
237: # the descendents of the spreadsheet class.
238: }
239:
240: sub cleanup {
241: my $self = shift();
242: $self->clear_package();
243: }
244:
245: sub initialize_spreadsheet_package {
246: &load_spreadsheet_expirationdates();
247: &clear_spreadsheet_definition_cache();
248: }
249:
250: sub load_spreadsheet_expirationdates {
251: undef %expiredates;
252: my $cid=$ENV{'request.course.id'};
253: my @tmp = &Apache::lonnet::dump('nohist_expirationdates',
254: $ENV{'course.'.$cid.'.domain'},
255: $ENV{'course.'.$cid.'.num'});
256: if (lc($tmp[0]) !~ /^error/){
257: %expiredates = @tmp;
258: }
259: }
260:
261: sub check_expiration_time {
262: my $self = shift;
263: my ($time)=@_;
264: return 0 if (! defined($time));
265: my ($key1,$key2,$key3,$key4,$key5);
266: # Description of keys
267: #
268: # key1: all sheets of this type have expired
269: # key2: all sheets of this type for this student
270: # key3: all sheets of this type in this map for this student
271: # key4: this assessment sheet for this student
272: # key5: this assessment sheet for all students
273: $key1 = '::'.$self->{'type'}.':';
274: $key2 = $self->{'name'}.':'.$self->{'domain'}.':'.$self->{'type'}.':';
275: $key3 = $key2.$self->{'container'} if (defined($self->{'container'}));
276: $key4 = $key2.$self->{'symb'} if (defined($self->{'symb'}));
277: $key5 = $key1.$self->{'symb'} if (defined($self->{'symb'}));
278: my $returnvalue = 1; # default to okay
279: foreach my $key ($key1,$key2,$key3,$key4,$key5) {
280: next if (! defined($key));
281: if (exists($expiredates{$key}) && $expiredates{$key} > $time) {
282: $returnvalue = 0; # need to recompute
283: }
284: }
285: return $returnvalue;
286: }
287:
288: ######################################################
289:
290: =pod
291:
292: =item &initialize_safe_space
293:
294: Returns the safe space required by a Spreadsheet object.
295:
296: =head 2 Safe Space Functions
297:
298: =over 4
299:
300: =cut
301:
302: ######################################################
303: {
304:
305: my $safeeval;
306:
307: sub initialize_safe_space {
308: my $self = shift;
309: if (! defined($safeeval)) {
310: $safeeval = new Safe(shift);
311: my $safehole = new Safe::Hole;
312: $safeeval->permit("entereval");
313: $safeeval->permit(":base_math");
314: $safeeval->permit("sort");
315: $safeeval->deny(":base_io");
316: $safehole->wrap(\&Apache::lonnet::EXT,$safeeval,'&EXT');
317: $safehole->wrap(\&mask,$safeeval,'&mask');
318: $safeeval->share('$@');
319: my $code=<<'ENDDEFS';
320: # ---------------------------------------------------- Inside of the safe space
321: #
322: # f: formulas
323: # t: intermediate format (variable references expanded)
324: # v: output values
325: # c: preloaded constants (A-column)
326: # rl: row label
327: # os: other spreadsheets (for student spreadsheet only)
328: undef %sheet_values; # Holds the (computed, final) values for the sheet
329: # This is only written to by &calc, the spreadsheet computation routine.
330: # It is read by many functions
331: undef %t; # Holds the values of the spreadsheet temporarily. Set in &sett,
332: # which does the translation of strings like C5 into the value in C5.
333: # Used in &calc - %t holds the values that are actually eval'd.
334: undef %f; # Holds the formulas for each cell. This is the users
335: # (spreadsheet authors) data for each cell.
336: undef %c; # Holds the constants for a sheet. In the assessment
337: # sheets, this is the A column. Used in &MINPARM, &MAXPARM, &expandnamed,
338: # &sett, and &constants. There is no &getconstants.
339: # &constants is called by &loadstudent, &loadcourse, &load assessment,
340: undef @os; # Holds the names of other spreadsheets - this is used to specify
341: # the spreadsheets that are available for the assessment sheet.
342: # Set by &setothersheets. &setothersheets is called by &handler. A
343: # related subroutine is &othersheets.
344: $errorlog = '';
345: #
346: $maxrow = 0;
347: $type = '';
348: #
349: # filename/reference of the sheet
350: $filename = '';
351: #
352: # user data
353: $name = '';
354: $uhome = '';
355: $domain = '';
356: #
357: # course data
358: $csec = '';
359: $chome= '';
360: $cnum = '';
361: $cdom = '';
362: $cid = '';
363: $coursefilename = '';
364: #
365: # symb
366: $usymb = '';
367: #
368: # error messages
369: $errormsg = '';
370: #
371: #-------------------------------------------------------
372:
373: =pod
374:
375: =item NUM(range)
376:
377: returns the number of items in the range.
378:
379: =cut
380:
381: #-------------------------------------------------------
382: sub NUM {
383: my $mask=&mask(@_);
384: my $num= $#{@{grep(eval("/$mask/"),keys(%sheet_values))}}+1;
385: return $num;
386: }
387:
388: #-------------------------------------------------------
389:
390: =pod
391:
392: =item BIN(low,high,lower,upper)
393:
394: =cut
395:
396: #-------------------------------------------------------
397: sub BIN {
398: my ($low,$high,$lower,$upper)=@_;
399: my $mask=&mask($lower,$upper);
400: my $num=0;
401: foreach (grep eval("/$mask/"),keys(%sheet_values)) {
402: if (($sheet_values{$_}>=$low) && ($sheet_values{$_}<=$high)) {
403: $num++;
404: }
405: }
406: return $num;
407: }
408:
409: #-------------------------------------------------------
410:
411: =pod
412:
413: =item SUM(range)
414:
415: returns the sum of items in the range.
416:
417: =cut
418:
419: #-------------------------------------------------------
420: sub SUM {
421: my $mask=&mask(@_);
422: my $sum=0;
423: foreach (grep eval("/$mask/"),keys(%sheet_values)) {
424: $sum+=$sheet_values{$_};
425: }
426: return $sum;
427: }
428:
429: #-------------------------------------------------------
430:
431: =pod
432:
433: =item MEAN(range)
434:
435: compute the average of the items in the range.
436:
437: =cut
438:
439: #-------------------------------------------------------
440: sub MEAN {
441: my $mask=&mask(@_);
442: my $sum=0;
443: my $num=0;
444: foreach (grep eval("/$mask/"),keys(%sheet_values)) {
445: $sum+=$sheet_values{$_};
446: $num++;
447: }
448: if ($num) {
449: return $sum/$num;
450: } else {
451: return undef;
452: }
453: }
454:
455: #-------------------------------------------------------
456:
457: =pod
458:
459: =item STDDEV(range)
460:
461: compute the standard deviation of the items in the range.
462:
463: =cut
464:
465: #-------------------------------------------------------
466: sub STDDEV {
467: my $mask=&mask(@_);
468: my $sum=0; my $num=0;
469: foreach (grep eval("/$mask/"),keys(%sheet_values)) {
470: $sum+=$sheet_values{$_};
471: $num++;
472: }
473: unless ($num>1) { return undef; }
474: my $mean=$sum/$num;
475: $sum=0;
476: foreach (grep eval("/$mask/"),keys(%sheet_values)) {
477: $sum+=($sheet_values{$_}-$mean)**2;
478: }
479: return sqrt($sum/($num-1));
480: }
481:
482: #-------------------------------------------------------
483:
484: =pod
485:
486: =item PROD(range)
487:
488: compute the product of the items in the range.
489:
490: =cut
491:
492: #-------------------------------------------------------
493: sub PROD {
494: my $mask=&mask(@_);
495: my $prod=1;
496: foreach (grep eval("/$mask/"),keys(%sheet_values)) {
497: $prod*=$sheet_values{$_};
498: }
499: return $prod;
500: }
501:
502: #-------------------------------------------------------
503:
504: =pod
505:
506: =item MAX(range)
507:
508: compute the maximum of the items in the range.
509:
510: =cut
511:
512: #-------------------------------------------------------
513: sub MAX {
514: my $mask=&mask(@_);
515: my $max='-';
516: foreach (grep eval("/$mask/"),keys(%sheet_values)) {
517: unless ($max) { $max=$sheet_values{$_}; }
518: if (($sheet_values{$_}>$max) || ($max eq '-')) {
519: $max=$sheet_values{$_};
520: }
521: }
522: return $max;
523: }
524:
525: #-------------------------------------------------------
526:
527: =pod
528:
529: =item MIN(range)
530:
531: compute the minimum of the items in the range.
532:
533: =cut
534:
535: #-------------------------------------------------------
536: sub MIN {
537: my $mask=&mask(@_);
538: my $min='-';
539: foreach (grep eval("/$mask/"),keys(%sheet_values)) {
540: unless ($max) { $max=$sheet_values{$_}; }
541: if (($sheet_values{$_}<$min) || ($min eq '-')) {
542: $min=$sheet_values{$_};
543: }
544: }
545: return $min;
546: }
547:
548: #-------------------------------------------------------
549:
550: =pod
551:
552: =item SUMMAX(num,lower,upper)
553:
554: compute the sum of the largest 'num' items in the range from
555: 'lower' to 'upper'
556:
557: =cut
558:
559: #-------------------------------------------------------
560: sub SUMMAX {
561: my ($num,$lower,$upper)=@_;
562: my $mask=&mask($lower,$upper);
563: my @inside=();
564: foreach (grep eval("/$mask/"),keys(%sheet_values)) {
565: push (@inside,$sheet_values{$_});
566: }
567: @inside=sort(@inside);
568: my $sum=0; my $i;
569: for ($i=$#inside;(($i>$#inside-$num) && ($i>=0));$i--) {
570: $sum+=$inside[$i];
571: }
572: return $sum;
573: }
574:
575: #-------------------------------------------------------
576:
577: =pod
578:
579: =item SUMMIN(num,lower,upper)
580:
581: compute the sum of the smallest 'num' items in the range from
582: 'lower' to 'upper'
583:
584: =cut
585:
586: #-------------------------------------------------------
587: sub SUMMIN {
588: my ($num,$lower,$upper)=@_;
589: my $mask=&mask($lower,$upper);
590: my @inside=();
591: foreach (grep eval("/$mask/"),keys(%sheet_values)) {
592: $inside[$#inside+1]=$sheet_values{$_};
593: }
594: @inside=sort(@inside);
595: my $sum=0; my $i;
596: for ($i=0;(($i<$num) && ($i<=$#inside));$i++) {
597: $sum+=$inside[$i];
598: }
599: return $sum;
600: }
601:
602: #-------------------------------------------------------
603:
604: =pod
605:
606: =item MINPARM(parametername)
607:
608: Returns the minimum value of the parameters matching the parametername.
609: parametername should be a string such as 'duedate'.
610:
611: =cut
612:
613: #-------------------------------------------------------
614: sub MINPARM {
615: my ($expression) = @_;
616: my $min = undef;
617: study($expression);
618: foreach $parameter (keys(%c)) {
619: next if ($parameter !~ /$expression/);
620: if ((! defined($min)) || ($min > $c{$parameter})) {
621: $min = $c{$parameter}
622: }
623: }
624: return $min;
625: }
626:
627: #-------------------------------------------------------
628:
629: =pod
630:
631: =item MAXPARM(parametername)
632:
633: Returns the maximum value of the parameters matching the input parameter name.
634: parametername should be a string such as 'duedate'.
635:
636: =cut
637:
638: #-------------------------------------------------------
639: sub MAXPARM {
640: my ($expression) = @_;
641: my $max = undef;
642: study($expression);
643: foreach $parameter (keys(%c)) {
644: next if ($parameter !~ /$expression/);
645: if ((! defined($min)) || ($max < $c{$parameter})) {
646: $max = $c{$parameter}
647: }
648: }
649: return $max;
650: }
651:
652:
653: sub calc {
654: %sheet_values = %t;
655: my $notfinished = 1;
656: my $lastcalc = '';
657: my $depth = 0;
658: while ($notfinished) {
659: $notfinished=0;
660: while (my ($cell,$value) = each(%t)) {
661: my $old=$sheet_values{$cell};
662: $sheet_values{$cell}=eval $value;
663: # $errorlog .= $cell.' = '.$old.'->'.$sheet_values{$cell}."\n";
664: if ($@) {
665: undef %sheet_values;
666: return $cell.': '.$@;
667: }
668: if ($sheet_values{$cell} ne $old) {
669: $notfinished=1;
670: $lastcalc=$cell;
671: }
672: }
673: # $errorlog.="------------------------------------------------";
674:
675: $depth++;
676: if ($depth>100) {
677: undef %sheet_values;
678: return $lastcalc.': Maximum calculation depth exceeded';
679: }
680: }
681: return 'okay';
682: }
683:
684: # ------------------------------------------- End of "Inside of the safe space"
685: ENDDEFS
686: $safeeval->reval($code);
687: }
688: $self->{'safe'} = $safeeval;
689: $self->{'root'} = $self->{'safe'}->root();
690: #
691: # Place some of the %$self items into the safe space except the safe space
692: # itself
693: my $initstring = '';
694: foreach (qw/name domain type usymb cid csec coursefilename
695: cnum cdom chome uhome/) {
696: $initstring.= qq{\$$_="$self->{$_}";};
697: }
698: $self->{'safe'}->reval($initstring);
699: return $self;
700: }
701:
702: }
703:
704: ######################################################
705:
706: =pod
707:
708: =back
709:
710: =cut
711:
712: ######################################################
713:
714:
715: ######################################################
716:
717: =pod
718:
719: =item &mask($lower,$upper)
720:
721: Inputs: $lower and $upper, cell names ("X12" or "a150") or globs ("X*").
722:
723: Returns: Regular expression matching spreadsheet cells that are within
724: the rectangle defined by $lower and $upper. Due to the nature of the
725: regular expression this result must be used inside an eval().
726:
727: =cut
728:
729: ######################################################
730: {
731:
732: my %memoizer;
733:
734: sub mask {
735: my ($lower,$upper)=@_;
736: my $key = $lower.'_'.$upper;
737: if (exists($memoizer{$key})) {
738: return $memoizer{$key};
739: }
740: $upper = $lower if (! defined($upper));
741: #
742: my ($la,$ld) = ($lower=~/([A-z]|\*)(\d+|\*)/);
743: my ($ua,$ud) = ($upper=~/([A-z]|\*)(\d+|\*)/);
744: #
745: my $alpha='';
746: my $num='';
747: #
748: # Do not put parenthases around $alpha.
749: # $num depends on the value in $1.
750: if (($la eq '*') || ($ua eq '*')) {
751: $alpha='[A-z]';
752: } else {
753: if ($la gt $ua) {
754: my $tmp = $ua;
755: $ua = $la;
756: $la = $ua;
757: }
758: $alpha=qq/[$la-$ua]/;
759: }
760: if ($ld ne '*' && $ud ne '*') {
761: # Make sure $ld <= $ud
762: if ($ld > $ud) {
763: my $tmp = $ud;
764: $ud = $ld;
765: $ld = $tmp;
766: }
767: # Here we make a regular expression using some advanced regexp
768: # abilities.
769: # (\d+) will match the digits of the cell name and dump them in
770: # to $1
771: # (?(?{ ... code ...} pattern_if_true | pattern_if_false)) will
772: # choose pattern_if_true if { ... code ... } is true and
773: # pattern_if_false if { ... code ... } is false.
774: # In this case, pattern_if_true is empty. pattern_if_false is
775: # 'donotmatch' and will not match our cells because none of
776: # them end with donotmatch.
777: # Unfortunately, the use of this type of regular expression
778: # requires that each match be wrapped in an eval(). Search for
779: # $mask in this module for examples
780: $num = '(\d+)(?(?{$1>= '.$ld.' && $1<='.$ud.'})|donotmatch)';
781: } else {
782: $num = '(\d+)';
783: }
784: my $expression = '^'.$alpha.$num.'$';
785: $memoizer{$key} = $expression;
786: return $expression;
787: }
788:
789: #
790: # Debugging routine
791: sub dump_memoized_values {
792: while (my ($key,$value) = each(%memoizer)) {
793: &Apache::lonnet::logthis('memoizer: '.$key.' = '.$value);
794: }
795: return;
796: }
797:
798: }
799:
800: ##
801: ## sub add_hash_to_safe {} # spreadsheet, would like to destroy
802: ##
803:
804: #
805: # expandnamed used to reside in the safe space
806: #
807: sub expandnamed {
808: my $self = shift;
809: my $expression=shift;
810: if ($expression=~/^\&/) {
811: my ($func,$var,$formula)=($expression=~/^\&(\w+)\(([^\;]+)\;(.*)\)/);
812: my @vars=split(/\W+/,$formula);
813: my %values=();
814: foreach my $varname ( @vars ) {
815: if ($varname=~/^(parameter|stores|timestamp)/) {
816: $formula=~s/$varname/'$c{\''.$varname.'\'}'/ge;
817: $varname=~s/$var/\([\\w:\\- ]\+\)/g;
818: foreach (keys(%{$self->{'constants'}})) {
819: if ($_=~/$varname/) {
820: $values{$1}=1;
821: }
822: }
823: }
824: }
825: if ($func eq 'EXPANDSUM') {
826: my $result='';
827: foreach (keys(%values)) {
828: my $thissum=$formula;
829: $thissum=~s/$var/$_/g;
830: $result.=$thissum.'+';
831: }
832: $result=~s/\+$//;
833: return $result;
834: } else {
835: return 0;
836: }
837: } else {
838: # it is not a function, so it is a parameter name
839: # We should do the following:
840: # 1. Take the list of parameter names
841: # 2. look through the list for ones that match the parameter we want
842: # 3. If there are no collisions, return the one that matches
843: # 4. If there is a collision, return 'bad parameter name error'
844: my $returnvalue = '';
845: my @matches = ();
846: my @values = ();
847: $#matches = -1;
848: study $expression;
849: while (my($parameter,$value) = each(%{$self->{'constants'}})) {
850: next if ($parameter !~ /$expression/);
851: push(@matches,$parameter);
852: push(@values,$value);
853: }
854: if (scalar(@matches) == 0) {
855: $returnvalue = '""';#'"unmatched parameter: '.$parameter.'"';
856: } elsif (scalar(@matches) == 1) {
857: # why do we not do this lookup here, instead of delaying it?
858: $returnvalue = $values[0];
859: } elsif (scalar(@matches) > 0) {
860: # more than one match. Look for a concise one
861: $returnvalue = "'non-unique parameter name : $expression'";
862: for (my $i=0; $i<=$#matches;$i++) {
863: if ($matches[$i] =~ /^$expression$/) {
864: # why do we not do this lookup here?
865: $returnvalue = $values[$i];
866: }
867: }
868: } else {
869: # There was a negative number of matches, which indicates
870: # something is wrong with reality. Better warn the user.
871: $returnvalue = '"bizzare parameter: '.$expression.'"';
872: }
873: return $returnvalue;
874: }
875: }
876:
877: sub sett {
878: my $self = shift;
879: my %t=();
880: #
881: # Deal with the template row
882: foreach my $col ($self->template_cells()) {
883: next if ($col=~/^[A-Z]/);
884: foreach my $row ($self->rows()) {
885: # Get the name of this cell
886: my $cell=$col.$row;
887: # Grab the template declaration
888: $t{$cell}=$self->formula('template_'.$col);
889: # Replace '#' with the row number
890: $t{$cell}=~s/\#/$row/g;
891: # Replace '....' with ','
892: $t{$cell}=~s/\.\.+/\,/g;
893: # Replace 'A0' with the value from 'A0'
894: $t{$cell}=~s/(^|[^\"\'])([A-Za-z]\d+)/$1\$sheet_values\{\'$2\'\}/g;
895: # Replace parameters
896: $t{$cell}=~s/(^|[^\"\'])\[([^\]]+)\]/$1.$self->expandnamed($2)/ge;
897: }
898: }
899: #
900: # Deal with the normal cells
901: while (my($cell,$formula) = each(%{$self->{'formulas'}})) {
902: next if ($_=~/^template\_/);
903: my ($col,$row) = ($cell =~ /^([A-z])(\d+)$/);
904: if ($row eq '0') {
905: $t{$cell}=$formula;
906: $t{$cell}=~s/\.\.+/\,/g;
907: $t{$cell}=~s/(^|[^\"\'])([A-Za-z]\d+)/$1\$sheet_values\{\'$2\'\}/g;
908: $t{$cell}=~s/(^|[^\"\'])\[([^\]]+)\]/$1.$self->expandnamed($2)/ge;
909: } elsif ( $col =~ /^[A-Z]$/ ) {
910: if ($formula !~ /^\!/ && exists($self->{'constants'}->{$cell})) {
911: my $data = $self->{'constants'}->{$cell};
912: $t{$cell} = $data;
913: }
914: } else { # $row > 1 and $col =~ /[a-z]
915: $t{$cell}=$formula;
916: $t{$cell}=~s/\.\.+/\,/g;
917: $t{$cell}=~s/(^|[^\"\'])([A-Za-z]\d+)/$1\$sheet_values\{\'$2\'\}/g;
918: $t{$cell}=~s/(^|[^\"\'])\[([^\]]+)\]/$1.$self->expandnamed($2)/ge;
919: }
920: }
921: %{$self->{'safe'}->varglob('t')}=%t;
922: }
923:
924: ##
925: ## sync_safe_space: Called by calcsheet to make sure all the data we
926: # need to calculate is placed into the safe space
927: ##
928: sub sync_safe_space {
929: my $self = shift;
930: # Inside the safe space 'formulas' has a diabolical alter-ego named 'f'.
931: %{$self->{'safe'}->varglob('f')}=%{$self->{'formulas'}};
932: # 'constants' leads a peaceful hidden life of 'c'.
933: %{$self->{'safe'}->varglob('c')}=%{$self->{'constants'}};
934: # 'othersheets' hides as 'os', a disguise few can penetrate.
935: @{$self->{'safe'}->varglob('os')}=@{$self->{'othersheets'}};
936: }
937:
938: ##
939: ## Retrieve the error log from the safe space (used for debugging)
940: ##
941: sub get_errorlog {
942: my $self = shift;
943: $self->{'errorlog'} = $ { $self->{'safe'}->varglob('errorlog') };
944: return $self->{'errorlog'};
945: }
946:
947: ##
948: ## Clear the error log inside the safe space
949: ##
950: sub clear_errorlog {
951: my $self = shift;
952: $ {$self->{'safe'}->varglob('errorlog')} = '';
953: $self->{'errorlog'} = '';
954: }
955:
956: ##
957: ## constants: either set or get the constants
958: ##
959: sub constants {
960: my $self=shift;
961: my ($constants) = @_;
962: if (defined($constants)) {
963: if (! ref($constants)) {
964: my %tmp = @_;
965: $constants = \%tmp;
966: }
967: $self->{'constants'} = $constants;
968: return;
969: } else {
970: return %{$self->{'constants'}};
971: }
972: }
973:
974: ##
975: ## formulas: either set or get the formulas
976: ##
977: sub formulas {
978: my $self=shift;
979: my ($formulas) = @_;
980: if (defined($formulas)) {
981: if (! ref($formulas)) {
982: my %tmp = @_;
983: $formulas = \%tmp;
984: }
985: $self->{'formulas'} = $formulas;
986: $self->{'rows'} = [];
987: $self->{'template_cells'} = [];
988: return;
989: } else {
990: return %{$self->{'formulas'}};
991: }
992: }
993:
994: sub set_formula {
995: my $self = shift;
996: my ($cell,$formula) = @_;
997: $self->{'formulas'}->{$cell}=$formula;
998: return;
999: }
1000:
1001: ##
1002: ## formulas_keys: Return the keys to the formulas hash.
1003: ##
1004: sub formulas_keys {
1005: my $self = shift;
1006: my @keys = keys(%{$self->{'formulas'}});
1007: return keys(%{$self->{'formulas'}});
1008: }
1009:
1010: ##
1011: ## formula: Return the formula for a given cell in the spreadsheet
1012: ## returns '' if the cell does not have a formula or does not exist
1013: ##
1014: sub formula {
1015: my $self = shift;
1016: my $cell = shift;
1017: if (defined($cell) && exists($self->{'formulas'}->{$cell})) {
1018: return $self->{'formulas'}->{$cell};
1019: }
1020: return '';
1021: }
1022:
1023: ##
1024: ## logthis: write the input to lonnet.log
1025: ##
1026: sub logthis {
1027: my $self = shift;
1028: my $message = shift;
1029: &Apache::lonnet::logthis($self->{'type'}.':'.
1030: $self->{'name'}.':'.$self->{'domain'}.':'.
1031: $message);
1032: return;
1033: }
1034:
1035: ##
1036: ## dump_formulas_to_log: makes lonnet.log huge...
1037: ##
1038: sub dump_formulas_to_log {
1039: my $self =shift;
1040: $self->logthis("Spreadsheet formulas");
1041: $self->logthis("--------------------------------------------------------");
1042: while (my ($cell, $formula) = each(%{$self->{'formulas'}})) {
1043: $self->logthis(' '.$cell.' = '.$formula);
1044: }
1045: $self->logthis("--------------------------------------------------------");}
1046:
1047: ##
1048: ## value: returns the computed value of a particular cell
1049: ##
1050: sub value {
1051: my $self = shift;
1052: my $cell = shift;
1053: if (defined($cell) && exists($self->{'values'}->{$cell})) {
1054: return $self->{'values'}->{$cell};
1055: }
1056: return '';
1057: }
1058:
1059: ##
1060: ## dump_values_to_log: makes lonnet.log huge...
1061: ##
1062: sub dump_values_to_log {
1063: my $self =shift;
1064: $self->logthis("Spreadsheet Values");
1065: $self->logthis("------------------------------------------------------");
1066: while (my ($cell, $value) = each(%{$self->{'values'}})) {
1067: $self->logthis(' '.$cell.' = '.$value);
1068: }
1069: $self->logthis("------------------------------------------------------");
1070: }
1071:
1072: ##
1073: ## Yet another debugging function
1074: ##
1075: sub dump_hash_to_log {
1076: my $self= shift();
1077: my %tmp = @_;
1078: if (@_<2) {
1079: %tmp = %{$_[0]};
1080: }
1081: $self->logthis('---------------------------- (begin hash dump)');
1082: while (my ($key,$val) = each (%tmp)) {
1083: $self->logthis(' '.$key.' = '.$val.':');
1084: }
1085: $self->logthis('---------------------------- (finished hash dump)');
1086: }
1087:
1088: ##
1089: ## rebuild_stats: rebuilds the rows and template_cells arrays
1090: ##
1091: sub rebuild_stats {
1092: my $self = shift;
1093: $self->{'rows'}=[];
1094: $self->{'template_cells'}=[];
1095: while (my ($cell,$formula) = each(%{$self->{'formulas'}})) {
1096: push(@{$self->{'rows'}},$1) if ($cell =~ /^A(\d+)/ && $1 != 0);
1097: push(@{$self->{'template_cells'}},$1) if ($cell =~ /^template_(\w+)/);
1098: }
1099: return;
1100: }
1101:
1102: ##
1103: ## template_cells returns a list of the cells defined in the template row
1104: ##
1105: sub template_cells {
1106: my $self = shift;
1107: $self->rebuild_stats() if (! defined($self->{'template_cells'}) ||
1108: ! @{$self->{'template_cells'}});
1109: return @{$self->{'template_cells'}};
1110: }
1111:
1112: ##
1113: ## Sigh....
1114: ##
1115: sub setothersheets {
1116: my $self = shift;
1117: my @othersheets = @_;
1118: $self->{'othersheets'} = \@othersheets;
1119: }
1120:
1121: ##
1122: ## rows returns a list of the names of cells defined in the A column
1123: ##
1124: sub rows {
1125: my $self = shift;
1126: $self->rebuild_stats() if (!@{$self->{'rows'}});
1127: return @{$self->{'rows'}};
1128: }
1129:
1130: #
1131: # calcsheet: makes all the calls to compute the spreadsheet.
1132: #
1133: sub calcsheet {
1134: my $self = shift;
1135: $self->sync_safe_space();
1136: $self->clear_errorlog();
1137: $self->sett();
1138: my $result = $self->{'safe'}->reval('&calc();');
1139: # $self->logthis($self->get_errorlog());
1140: %{$self->{'values'}} = %{$self->{'safe'}->varglob('sheet_values')};
1141: # $self->logthis($self->get_errorlog());
1142: if ($result ne 'okay') {
1143: $self->set_calcerror($result);
1144: }
1145: return $result;
1146: }
1147:
1148: sub set_badcalc {
1149: my $self = shift();
1150: $self->{'badcalc'} =1;
1151: return;
1152: }
1153:
1154: sub badcalc {
1155: my $self = shift;
1156: if (exists($self->{'badcalc'}) && $self->{'badcalc'}) {
1157: return 1;
1158: } else {
1159: return 0;
1160: }
1161: }
1162:
1163: sub set_calcerror {
1164: my $self = shift;
1165: if (@_) {
1166: $self->set_badcalc();
1167: if (exists($self->{'calcerror'})) {
1168: $self->{'calcerror'}.="\n".$_[0];
1169: } else {
1170: $self->{'calcerror'}.=$_[0];
1171: }
1172: }
1173: }
1174:
1175: sub calcerror {
1176: my $self = shift;
1177: if ($self->badcalc()) {
1178: if (exists($self->{'calcerror'})) {
1179: return $self->{'calcerror'};
1180: }
1181: }
1182: return;
1183: }
1184:
1185: ###########################################################
1186: ##
1187: ## Output Helpers
1188: ##
1189: ###########################################################
1190: sub display {
1191: my $self = shift;
1192: my ($r) = @_;
1193: my $outputmode = 'html';
1194: foreach ($self->output_options()) {
1195: if ($ENV{'form.output_format'} eq $_->{'value'}) {
1196: $outputmode = $_->{'value'};
1197: last;
1198: }
1199: }
1200: if ($outputmode eq 'html') {
1201: $self->compute($r);
1202: $self->outsheet_html($r);
1203: } elsif ($outputmode eq 'htmlclasslist') {
1204: # No computation neccessary... This is kludgy
1205: $self->outsheet_htmlclasslist($r);
1206: } elsif ($outputmode eq 'excel') {
1207: $self->compute($r);
1208: $self->outsheet_excel($r);
1209: } elsif ($outputmode eq 'csv') {
1210: $self->compute($r);
1211: $self->outsheet_csv($r);
1212: }
1213: $self->cleanup();
1214: return;
1215: }
1216:
1217: ############################################
1218: ## HTML output routines ##
1219: ############################################
1220: sub html_report_error {
1221: my $self = shift();
1222: my $Str = '';
1223: if ($self->badcalc()) {
1224: $Str = '<h3 style="color:red">'.
1225: &mt('An error occurred while calculating this spreadsheet').
1226: "</h3>\n".
1227: '<pre>'.$self->calcerror()."</pre>\n";
1228: }
1229: return $Str;
1230: }
1231:
1232: sub html_export_row {
1233: my $self = shift();
1234: my ($color) = @_;
1235: $color = '#CCCCFF' if (! defined($color));
1236: my $allowed = &Apache::lonnet::allowed('mgr',$ENV{'request.course.id'});
1237: my $row_html;
1238: my @rowdata = $self->get_row(0);
1239: foreach my $cell (@rowdata) {
1240: if ($cell->{'name'} =~ /^[A-Z]/) {
1241: $row_html .= '<td bgcolor="'.$color.'">'.
1242: &html_editable_cell($cell,$color,$allowed).'</td>';
1243: } else {
1244: $row_html .= '<td bgcolor="#DDCCFF">'.
1245: &html_editable_cell($cell,'#DDCCFF',$allowed).'</td>';
1246: }
1247: }
1248: return $row_html;
1249: }
1250:
1251: sub html_template_row {
1252: my $self = shift();
1253: my $allowed = &Apache::lonnet::allowed('mgr',$ENV{'request.course.id'});
1254: my ($num_uneditable,$importcolor) = @_;
1255: my $row_html;
1256: my @rowdata = $self->get_template_row();
1257: my $count = 0;
1258: for (my $i = 0; $i<=$#rowdata; $i++) {
1259: my $cell = $rowdata[$i];
1260: if ($i < $num_uneditable) {
1261: $row_html .= '<td bgcolor="'.$importcolor.'">'.
1262: &html_uneditable_cell($cell,'#FFDDDD',$allowed).'</td>';
1263: } else {
1264: $row_html .= '<td bgcolor="#EOFFDD">'.
1265: &html_editable_cell($cell,'#EOFFDD',$allowed).'</td>';
1266: }
1267: }
1268: return $row_html;
1269: }
1270:
1271: sub html_editable_cell {
1272: my ($cell,$bgcolor,$allowed) = @_;
1273: my $result;
1274: my ($name,$formula,$value);
1275: if (defined($cell)) {
1276: $name = $cell->{'name'};
1277: $formula = $cell->{'formula'};
1278: $value = $cell->{'value'};
1279: }
1280: $name = '' if (! defined($name));
1281: $formula = '' if (! defined($formula));
1282: if (! defined($value)) {
1283: $value = '<font color="'.$bgcolor.'">#</font>';
1284: if ($formula ne '') {
1285: $value = '<i>undefined value</i>';
1286: }
1287: } elsif ($value =~ /^\s*$/ ) {
1288: $value = '<font color="'.$bgcolor.'">#</font>';
1289: } else {
1290: $value = &HTML::Entities::encode($value) if ($value !~/ /);
1291: }
1292: return $value if (! $allowed);
1293: #
1294: # The formula will be parsed by the browser twice before being
1295: # displayed to the user for editing.
1296: #
1297: # The encoding string "^A-blah" is placed in []'s inside a regexp, so
1298: # we specify the characters we want left alone by putting a '^' in front.
1299: $formula = &HTML::Entities::encode($formula,'^A-z0-9 !#$%-;=?~');
1300: # HTML::Entities::encode does not catch everything - we need '\' encoded
1301: $formula =~ s/\\/&\#092/g;
1302: # Escape it again - this time the only encodable character is '&'
1303: $formula =~ s/\&/\&/g;
1304: # Glue everything together
1305: $result .= "<a href=\"javascript:celledit(\'".
1306: $name."','".$formula."');\">".$value."</a>";
1307: return $result;
1308: }
1309:
1310: sub html_uneditable_cell {
1311: my ($cell,$bgcolor) = @_;
1312: my $value = (defined($cell) ? $cell->{'value'} : '');
1313: $value = &HTML::Entities::encode($value) if ($value !~/ /);
1314: return ' '.$value.' ';
1315: }
1316:
1317: sub html_row {
1318: my $self = shift();
1319: my ($num_uneditable,$row,$exportcolor,$importcolor) = @_;
1320: my $allowed = &Apache::lonnet::allowed('mgr',$ENV{'request.course.id'});
1321: my @rowdata = $self->get_row($row);
1322: my $num_cols_output = 0;
1323: my $row_html;
1324: my $color = $importcolor;
1325: if ($row == 0) {
1326: $color = $exportcolor;
1327: }
1328: $color = '#FFDDDD' if (! defined($color));
1329: foreach my $cell (@rowdata) {
1330: if ($num_cols_output++ < $num_uneditable) {
1331: $row_html .= '<td bgcolor="'.$color.'">';
1332: $row_html .= &html_uneditable_cell($cell,'#FFDDDD');
1333: } else {
1334: $row_html .= '<td bgcolor="#EOFFDD">';
1335: $row_html .= &html_editable_cell($cell,'#E0FFDD',$allowed);
1336: }
1337: $row_html .= '</td>';
1338: }
1339: return $row_html;
1340: }
1341:
1342: sub html_header {
1343: my $self = shift;
1344: return '' if (! $ENV{'request.role.adv'});
1345: return "<table>\n".
1346: '<tr><th align="center">'.&mt('Output Format').'</th></tr>'."\n".
1347: '<tr><td>'.$self->output_selector()."</td></tr>\n".
1348: "</table>\n";
1349: }
1350:
1351: ##
1352: ## Default output types are HTML, Excel, and CSV
1353: sub output_options {
1354: my $self = shift();
1355: return ({value => 'html',
1356: description => 'HTML'},
1357: {value => 'excel',
1358: description => 'Excel'},
1359: {value => 'csv',
1360: description => 'Comma Separated Values'},);
1361: }
1362:
1363: sub output_selector {
1364: my $self = shift();
1365: my $output_selector = '<select name="output_format" size="3">'."\n";
1366: my $default = 'html';
1367: if (exists($ENV{'form.output_format'})) {
1368: $default = $ENV{'form.output_format'}
1369: } else {
1370: $ENV{'form.output_format'} = $default;
1371: }
1372: foreach ($self->output_options()) {
1373: $output_selector.='<option value="'.$_->{'value'}.'"';
1374: if ($_->{'value'} eq $default) {
1375: $output_selector .= ' selected';
1376: }
1377: $output_selector .= ">".&mt($_->{'description'})."</option>\n";
1378: }
1379: $output_selector .= "</select>\n";
1380: return $output_selector;
1381: }
1382:
1383: ################################################
1384: ## Excel output routines ##
1385: ################################################
1386: sub excel_output_row {
1387: my $self = shift;
1388: my ($worksheet,$rownum,$rows_output,@prepend) = @_;
1389: my $cols_output = 0;
1390: #
1391: my @rowdata = $self->get_row($rownum);
1392: foreach my $cell (@prepend,@rowdata) {
1393: my $value = $cell;
1394: $value = $cell->{'value'} if (ref($value));
1395: $value =~ s/\ / /gi;
1396: $worksheet->write($rows_output,$cols_output++,$value);
1397: }
1398: return;
1399: }
1400:
1401: sub create_excel_spreadsheet {
1402: my $self = shift;
1403: my ($r) = @_;
1404: my $filename = '/prtspool/'.
1405: $ENV{'user.name'}.'_'.$ENV{'user.domain'}.'_'.
1406: time.'_'.rand(1000000000).'.xls';
1407: my $workbook = Spreadsheet::WriteExcel->new('/home/httpd'.$filename);
1408: if (! defined($workbook)) {
1409: $r->log_error("Error creating excel spreadsheet $filename: $!");
1410: $r->print(&mt("Problems creating new Excel file. ".
1411: "This error has been logged. ".
1412: "Please alert your LON-CAPA administrator"));
1413: return undef;
1414: }
1415: #
1416: # The excel spreadsheet stores temporary data in files, then put them
1417: # together. If needed we should be able to disable this (memory only).
1418: # The temporary directory must be specified before calling 'addworksheet'.
1419: # File::Temp is used to determine the temporary directory.
1420: $workbook->set_tempdir('/home/httpd/perl/tmp');
1421: #
1422: # Determine the name to give the worksheet
1423: return ($workbook,$filename);
1424: }
1425:
1426: #
1427: # This routine is just a stub
1428: sub outsheet_htmlclasslist {
1429: my $self = shift;
1430: my ($r) = @_;
1431: $r->print('<h2>'.&mt("This output is not supported").'</h2>');
1432: $r->rflush();
1433: return;
1434: }
1435:
1436: sub outsheet_excel {
1437: my $self = shift;
1438: my ($r) = @_;
1439: my $connection = $r->connection();
1440: #
1441: $r->print($self->html_report_error());
1442: $r->rflush();
1443: #
1444: $r->print("<h2>".&mt('Preparing Excel Spreadsheet')."</h2>");
1445: #
1446: # Create excel worksheet
1447: my ($workbook,$filename) = $self->create_excel_spreadsheet($r);
1448: return if (! defined($workbook));
1449: #
1450: # Create main worksheet
1451: my $worksheet = $workbook->addworksheet('main');
1452: my $rows_output = 0;
1453: my $cols_output = 0;
1454: #
1455: # Write excel header
1456: foreach my $value ($self->get_title()) {
1457: $cols_output = 0;
1458: $worksheet->write($rows_output++,$cols_output,$value);
1459: }
1460: $rows_output++; # skip a line
1461: #
1462: # Write summary/export row
1463: $cols_output = 0;
1464: $self->excel_output_row($worksheet,0,$rows_output++,'Summary');
1465: $rows_output++; # skip a line
1466: #
1467: $self->excel_rows($connection,$worksheet,$cols_output,$rows_output);
1468: #
1469: #
1470: # Close the excel file
1471: $workbook->close();
1472: #
1473: # Write a link to allow them to download it
1474: $r->print('<br />'.
1475: '<a href="'.$filename.'">Your Excel spreadsheet.</a>'."\n");
1476: return;
1477: }
1478:
1479: #################################
1480: ## CSV output routines ##
1481: #################################
1482: sub outsheet_csv {
1483: my $self = shift;
1484: my ($r) = @_;
1485: my $connection = $r->connection();
1486: #
1487: $r->print($self->html_report_error());
1488: $r->rflush();
1489: #
1490: my $csvdata = '';
1491: my @Values;
1492: #
1493: # Open the csv file
1494: my $filename = '/prtspool/'.
1495: $ENV{'user.name'}.'_'.$ENV{'user.domain'}.'_'.
1496: time.'_'.rand(1000000000).'.csv';
1497: my $file;
1498: unless ($file = Apache::File->new('>'.'/home/httpd'.$filename)) {
1499: $r->log_error("Couldn't open $filename for output $!");
1500: $r->print(&mt("Problems occured in writing the csv file. ".
1501: "This error has been logged. ".
1502: "Please alert your LON-CAPA administrator."));
1503: $r->print("<pre>\n".$csvdata."</pre>\n");
1504: return 0;
1505: }
1506: #
1507: # Output the title information
1508: foreach my $value ($self->get_title()) {
1509: print $file "'".&Apache::loncommon::csv_translate($value)."'\n";
1510: }
1511: #
1512: # Output the body of the spreadsheet
1513: $self->csv_rows($connection,$file);
1514: #
1515: # Close the csv file
1516: close($file);
1517: $r->print('<br /><br />'.
1518: '<a href="'.$filename.'">'.&mt('Your CSV spreadsheet.').'</a>'."\n");
1519: #
1520: return 1;
1521: }
1522:
1523: sub csv_output_row {
1524: my $self = shift;
1525: my ($filehandle,$rownum,@prepend) = @_;
1526: #
1527: my @rowdata = ();
1528: if (defined($rownum)) {
1529: @rowdata = $self->get_row($rownum);
1530: }
1531: my @output = ();
1532: foreach my $cell (@prepend,@rowdata) {
1533: my $value = $cell;
1534: $value = $cell->{'value'} if (ref($value));
1535: $value =~ s/\ / /gi;
1536: $value = "'".$value."'";
1537: push (@output,$value);
1538: }
1539: print $filehandle join(',',@output )."\n";
1540: return;
1541: }
1542:
1543: ############################################
1544: ## XML output routines ##
1545: ############################################
1546: sub outsheet_xml {
1547: my $self = shift;
1548: my ($r) = @_;
1549: ## Someday XML
1550: ## Will be rendered for the user
1551: ## But not on this day
1552: my $Str = '<spreadsheet type="'.$self->{'type'}.'">'."\n";
1553: while (my ($cell,$formula) = each(%{$self->{'formulas'}})) {
1554: if ($cell =~ /^template_(\d+)/) {
1555: my $col = $1;
1556: $Str .= '<template col="'.$col.'">'.$formula.'</template>'."\n";
1557: } else {
1558: my ($row,$col) = ($cell =~ /^([A-z])(\d+)/);
1559: next if (! defined($row) || ! defined($col));
1560: $Str .= '<field row="'.$row.'" col="'.$col.'" >'.$formula.'</cell>'
1561: ."\n";
1562: }
1563: }
1564: $Str.="</spreadsheet>";
1565: return $Str;
1566: }
1567:
1568: ############################################
1569: ### Filesystem routines ###
1570: ############################################
1571: sub parse_sheet {
1572: # $sheetxml is a scalar reference or a scalar
1573: my ($sheetxml) = @_;
1574: if (! ref($sheetxml)) {
1575: my $tmp = $sheetxml;
1576: $sheetxml = \$tmp;
1577: }
1578: my %formulas;
1579: my %sources;
1580: my $parser=HTML::TokeParser->new($sheetxml);
1581: my $token;
1582: while ($token=$parser->get_token) {
1583: if ($token->[0] eq 'S') {
1584: if ($token->[1] eq 'field') {
1585: my $cell = $token->[2]->{'col'}.$token->[2]->{'row'};
1586: my $source = $token->[2]->{'source'};
1587: my $formula = $parser->get_text('/field');
1588: $formulas{$cell} = $formula;
1589: $sources{$cell} = $source if (defined($source));
1590: $parser->get_text('/field');
1591: }
1592: if ($token->[1] eq 'template') {
1593: $formulas{'template_'.$token->[2]->{'col'}}=
1594: $parser->get_text('/template');
1595: }
1596: }
1597: }
1598: return (\%formulas,\%sources);
1599: }
1600:
1601: {
1602:
1603: my %spreadsheets;
1604:
1605: sub clear_spreadsheet_definition_cache {
1606: undef(%spreadsheets);
1607: }
1608:
1609: sub load_system_default_sheet {
1610: my $self = shift;
1611: my $includedir = $Apache::lonnet::perlvar{'lonIncludes'};
1612: # load in the default defined spreadsheet
1613: my $sheetxml='';
1614: my $fh;
1615: if ($fh=Apache::File->new($includedir.'/default_'.$self->{'type'})) {
1616: $sheetxml=join('',<$fh>);
1617: $fh->close();
1618: } else {
1619: # $sheetxml='<field row="0" col="A">"Error"</field>';
1620: $sheetxml='<field row="0" col="A"></field>';
1621: }
1622: $self->filename('default_');
1623: my ($formulas,undef) = &parse_sheet(\$sheetxml);
1624: return $formulas;
1625: }
1626:
1627: sub load {
1628: my $self = shift;
1629: #
1630: my $stype = $self->{'type'};
1631: my $cnum = $self->{'cnum'};
1632: my $cdom = $self->{'cdom'};
1633: my $chome = $self->{'chome'};
1634: #
1635: my $filename = $self->filename();
1636: my $cachekey = join('_',($cnum,$cdom,$stype,$filename));
1637: #
1638: # see if sheet is cached
1639: my ($formulas);
1640: if (exists($spreadsheets{$cachekey})) {
1641: $formulas = $spreadsheets{$cachekey}->{'formulas'};
1642: } else {
1643: # Not cached, need to read
1644: if (! defined($filename)) {
1645: $formulas = $self->load_system_default_sheet();
1646: } elsif($self->filename() =~ /^\/res\/.*\.spreadsheet$/) {
1647: # Load a spreadsheet definition file
1648: my $sheetxml=&Apache::lonnet::getfile
1649: (&Apache::lonnet::filelocation('',$filename));
1650: if ($sheetxml == -1) {
1651: $sheetxml='<field row="0" col="A">"Error loading spreadsheet '
1652: .$self->filename().'"</field>';
1653: }
1654: ($formulas,undef) = &parse_sheet(\$sheetxml);
1655: # Get just the filename and set the sheets filename
1656: my ($newfilename) = ($filename =~ /\/([^\/]*)\.spreadsheet$/);
1657: if ($self->is_default()) {
1658: $self->filename($newfilename);
1659: $self->make_default();
1660: } else {
1661: $self->filename($newfilename);
1662: }
1663: } else {
1664: # Load the spreadsheet definition file from the save file
1665: my %tmphash = &Apache::lonnet::dump($filename,$cdom,$cnum);
1666: my ($tmp) = keys(%tmphash);
1667: if ($tmp !~ /^(con_lost|error|no_such_host)/i) {
1668: while (my ($cell,$formula) = each(%tmphash)) {
1669: $formulas->{$cell}=$formula;
1670: }
1671: } else {
1672: $formulas = $self->load_system_default_sheet();
1673: }
1674: }
1675: $filename=$self->filename(); # filename may have changed
1676: $cachekey = join('_',($cnum,$cdom,$stype,$filename));
1677: %{$spreadsheets{$cachekey}->{'formulas'}} = %{$formulas};
1678: }
1679: $self->formulas($formulas);
1680: $self->set_row_sources();
1681: $self->set_row_numbers();
1682: }
1683:
1684: sub set_row_sources {
1685: my $self = shift;
1686: while (my ($cell,$value) = each(%{$self->{'formulas'}})) {
1687: next if ($cell !~ /^A(\d+)/ || $1 < 1);
1688: my $row = $1;
1689: $self->{'row_source'}->{$row} = $value;
1690: }
1691: return;
1692: }
1693:
1694: sub set_row_numbers {
1695: my $self = shift;
1696: while (my ($cell,$value) = each(%{$self->{'formulas'}})) {
1697: next if ($cell !~ /^A(\d+)$/);
1698: next if (! defined($value));
1699: $self->{'row_numbers'}->{$value} = $1;
1700: $self->{'maxrow'} = $1 if ($1 > $self->{'maxrow'});
1701: }
1702: }
1703:
1704: ##
1705: ## exportrow is *not* used to get the export row from a computed sub-sheet.
1706: ##
1707: sub exportrow {
1708: my $self = shift;
1709: if (exists($self->{'badcalc'}) && $self->{'badcalc'}) {
1710: return ();
1711: }
1712: my @exportarray;
1713: foreach my $column (@UC_Columns) {
1714: push(@exportarray,$self->value($column.'0'));
1715: }
1716: return @exportarray;
1717: }
1718:
1719: sub save {
1720: my $self = shift;
1721: my ($makedef)=@_;
1722: my $cid=$self->{'cid'};
1723: # If we are saving it, it must not be temporary
1724: $self->temporary(0);
1725: if (&Apache::lonnet::allowed('opa',$cid)) {
1726: my %f=$self->formulas();
1727: my $stype = $self->{'type'};
1728: my $cnum = $self->{'cnum'};
1729: my $cdom = $self->{'cdom'};
1730: my $chome = $self->{'chome'};
1731: my $filename = $self->{'filename'};
1732: my $cachekey = join('_',($cnum,$cdom,$stype,$filename));
1733: # Cache new sheet
1734: %{$spreadsheets{$cachekey}->{'formulas'}}=%f;
1735: # Write sheet
1736: foreach (keys(%f)) {
1737: delete($f{$_}) if ($f{$_} eq 'import');
1738: }
1739: my $reply = &Apache::lonnet::put($filename,\%f,$cdom,$cnum);
1740: return $reply if ($reply ne 'ok');
1741: $reply = &Apache::lonnet::put($stype.'_spreadsheets',
1742: {$filename => $ENV{'user.name'}.'@'.$ENV{'user.domain'}},
1743: $cdom,$cnum);
1744: return $reply if ($reply ne 'ok');
1745: if ($makedef) {
1746: $reply = &Apache::lonnet::put('environment',
1747: {'spreadsheet_default_'.$stype => $filename },
1748: $cdom,$cnum);
1749: return $reply if ($reply ne 'ok');
1750: }
1751: if ($self->is_default()) {
1752: if ($self->{'type'} eq 'studentcalc') {
1753: &Apache::lonnet::expirespread('','','studentcalc','');
1754: } elsif ($self->{'type'} eq 'assesscalc') {
1755: &Apache::lonnet::expirespread('','','assesscalc','');
1756: &Apache::lonnet::expirespread('','','studentcalc','');
1757: }
1758: }
1759: return $reply;
1760: }
1761: return 'unauthorized';
1762: }
1763:
1764: } # end of scope for %spreadsheets
1765:
1766: sub save_tmp {
1767: my $self = shift;
1768: my $filename=$ENV{'user.name'}.'_'.
1769: $ENV{'user.domain'}.'_spreadsheet_'.$self->{'symb'}.'_'.
1770: $self->{'filename'};
1771: $filename=~s/\W/\_/g;
1772: $filename=$Apache::lonnet::tmpdir.$filename.'.tmp';
1773: $self->temporary(1);
1774: my $fh;
1775: if ($fh=Apache::File->new('>'.$filename)) {
1776: my %f = $self->formulas();
1777: while( my ($cell,$formula) = each(%f)) {
1778: next if ($formula eq 'import');
1779: print $fh &Apache::lonnet::escape($cell)."=".
1780: &Apache::lonnet::escape($formula)."\n";
1781: }
1782: $fh->close();
1783: }
1784: }
1785:
1786: sub load_tmp {
1787: my $self = shift;
1788: my $filename=$ENV{'user.name'}.'_'.
1789: $ENV{'user.domain'}.'_spreadsheet_'.$self->{'symb'}.'_'.
1790: $self->{'filename'};
1791: $filename=~s/\W/\_/g;
1792: $filename=$Apache::lonnet::tmpdir.$filename.'.tmp';
1793: my %formulas = ();
1794: if (my $spreadsheet_file = Apache::File->new($filename)) {
1795: while (<$spreadsheet_file>) {
1796: chomp;
1797: my ($cell,$formula) = split(/=/);
1798: $cell = &Apache::lonnet::unescape($cell);
1799: $formula = &Apache::lonnet::unescape($formula);
1800: $formulas{$cell} = $formula;
1801: }
1802: $spreadsheet_file->close();
1803: }
1804: # flag the sheet as temporary
1805: $self->temporary(1);
1806: $self->formulas(\%formulas);
1807: $self->set_row_sources();
1808: $self->set_row_numbers();
1809: return;
1810: }
1811:
1812: sub temporary {
1813: my $self=shift;
1814: if (@_) {
1815: ($self->{'temporary'})= @_;
1816: }
1817: return $self->{'temporary'};
1818: }
1819:
1820: sub modify_cell {
1821: # studentcalc overrides this
1822: my $self = shift;
1823: my ($cell,$formula) = @_;
1824: if ($cell =~ /([A-z])\-/) {
1825: $cell = 'template_'.$1;
1826: } elsif ($cell !~ /^([A-z](\d+)|template_[A-z])$/) {
1827: return;
1828: }
1829: $self->set_formula($cell,$formula);
1830: $self->rebuild_stats();
1831: return;
1832: }
1833:
1834: ###########################################
1835: # othersheets: Returns the list of other spreadsheets available
1836: ###########################################
1837: sub othersheets {
1838: my $self = shift();
1839: my ($stype) = @_;
1840: $stype = $self->{'type'} if (! defined($stype) || $stype !~ /calc$/);
1841: #
1842: my @alternatives=();
1843: my %results=&Apache::lonnet::dump($stype.'_spreadsheets',
1844: $self->{'cdom'}, $self->{'cnum'});
1845: my ($tmp) = keys(%results);
1846: if ($tmp =~ /^(con_lost|error|no_such_host)/i ) {
1847: @alternatives = (&mt('Default'));
1848: } else {
1849: @alternatives = (&mt('Default'), sort (keys(%results)));
1850: }
1851: return @alternatives;
1852: }
1853:
1854: sub blackout {
1855: my $self = shift;
1856: $self->{'blackout'} = $_[0] if (@_);
1857: return $self->{'blackout'};
1858: }
1859:
1860: sub get_row {
1861: my $self = shift;
1862: my ($n)=@_;
1863: my @cols=();
1864: foreach my $col (@UC_Columns,@LC_Columns) {
1865: my $cell = $col.$n;
1866: push(@cols,{ name => $cell,
1867: formula => $self->formula($cell),
1868: value => $self->value($cell)});
1869: }
1870: return @cols;
1871: }
1872:
1873: sub get_template_row {
1874: my $self = shift;
1875: my @cols=();
1876: foreach my $col (@UC_Columns,@LC_Columns) {
1877: my $cell = 'template_'.$col;
1878: push(@cols,{ name => $cell,
1879: formula => $self->formula($cell),
1880: value => $self->formula($cell) });
1881: }
1882: return @cols;
1883: }
1884:
1885: sub need_to_save {
1886: my $self = shift;
1887: if ($self->{'new_rows'} && ! $self->temporary()) {
1888: return 1;
1889: }
1890: return 0;
1891: }
1892:
1893: sub get_row_number_from_key {
1894: my $self = shift;
1895: my ($key) = @_;
1896: if (! exists($self->{'row_numbers'}->{$key}) ||
1897: ! defined($self->{'row_numbers'}->{$key})) {
1898: # I used to set $f here to the new value, but the key passed for lookup
1899: # may not be the key we need to save
1900: $self->{'maxrow'}++;
1901: $self->{'row_numbers'}->{$key} = $self->{'maxrow'};
1902: # $self->logthis('added row '.$self->{'row_numbers'}->{$key}.
1903: # ' for '.$key);
1904: $self->{'new_rows'} = 1;
1905: }
1906: return $self->{'row_numbers'}->{$key};
1907: }
1908:
1909: 1;
1910:
1911: __END__
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/back.gif){kind=icon}
Return to Spreadsheet.pm CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [LON-CAPA] / loncom / interface / spreadsheet