1: # The LearningOnline Network with CAPA
2: # Spreadsheet/Grades Display Handler
3: #
4: # 11/11,11/15,11/27,12/04,12/05,12/06,12/07,
5: # 12/08,12/09,12/11,12/12,12/15,12/16,12/18,12/19,12/30,
6: # 01/01/01,02/01 Gerd Kortemeyer
7:
8: package Apache::lonspreadsheet;
9:
10: use strict;
11: use Safe;
12: use Safe::Hole;
13: use Opcode;
14: use Apache::lonnet;
15: use Apache::Constants qw(:common :http);
16: use GDBM_File;
17: use HTML::TokeParser;
18:
19: #
20: # These cache hashes need to be independent of user, resource and course
21: # (user and course can/should be in the keys)
22: #
23: use vars qw(%spreadsheets %courserdatas %userrdatas %defaultsheets);
24:
25: #
26: # These global hashes are dependent on user, course and resource,
27: # and need to be initialized every time when a sheet is calculated
28: #
29: my %courseopt;
30: my %useropt;
31: my %parmhash;
32:
33: # Stuff that only the screen handler can know
34:
35: my $includedir;
36: my $tmpdir;
37:
38: # =============================================================================
39: # ===================================== Implements an instance of a spreadsheet
40:
41: sub initsheet {
42: my $safeeval = new Safe;
43: my $safehole = new Safe::Hole;
44: $safeeval->permit("entereval");
45: $safeeval->permit(":base_math");
46: $safeeval->permit("sort");
47: $safeeval->deny(":base_io");
48: $safehole->wrap(\&Apache::lonnet::EXT,$safeeval,'&EXT');
49: my $code=<<'ENDDEFS';
50: # ---------------------------------------------------- Inside of the safe space
51:
52: #
53: # f: formulas
54: # t: intermediate format (variable references expanded)
55: # v: output values
56: # c: preloaded constants (A-column)
57: # rl: row label
58:
59: %v=();
60: %t=();
61: %f=();
62: %c=();
63: %rl=();
64:
65: $maxrow=0;
66: $sheettype='';
67:
68: # filename/reference of the sheet
69:
70: $filename='';
71:
72: # user data
73: $uname='';
74: $uhome='';
75: $udom='';
76:
77: # course data
78:
79: $csec='';
80: $chome='';
81: $cnum='';
82: $cdom='';
83: $cid='';
84: $cfn='';
85:
86: # symb
87:
88: $usymb='';
89:
90: sub mask {
91: my ($lower,$upper)=@_;
92:
93: $lower=~/([A-Za-z]|\*)(\d+|\*)/;
94: my $la=$1;
95: my $ld=$2;
96:
97: $upper=~/([A-Za-z]|\*)(\d+|\*)/;
98: my $ua=$1;
99: my $ud=$2;
100: my $alpha='';
101: my $num='';
102:
103: if (($la eq '*') || ($ua eq '*')) {
104: $alpha='[A-Za-z]';
105: } else {
106: if (($la=~/[A-Z]/) && ($ua=~/[A-Z]/) ||
107: ($la=~/[a-z]/) && ($ua=~/[a-z]/)) {
108: $alpha='['.$la.'-'.$ua.']';
109: } else {
110: $alpha='['.$la.'-Za-'.$ua.']';
111: }
112: }
113:
114: if (($ld eq '*') || ($ud eq '*')) {
115: $num='\d+';
116: } else {
117: if (length($ld)!=length($ud)) {
118: $num.='(';
119: map {
120: $num.='['.$_.'-9]';
121: } ($ld=~m/\d/g);
122: if (length($ud)-length($ld)>1) {
123: $num.='|\d{'.(length($ld)+1).','.(length($ud)-1).'}';
124: }
125: $num.='|';
126: map {
127: $num.='[0-'.$_.']';
128: } ($ud=~m/\d/g);
129: $num.=')';
130: } else {
131: my @lda=($ld=~m/\d/g);
132: my @uda=($ud=~m/\d/g);
133: my $i; $j=0; $notdone=1;
134: for ($i=0;($i<=$#lda)&&($notdone);$i++) {
135: if ($lda[$i]==$uda[$i]) {
136: $num.=$lda[$i];
137: $j=$i;
138: } else {
139: $notdone=0;
140: }
141: }
142: if ($j<$#lda-1) {
143: $num.='('.$lda[$j+1];
144: for ($i=$j+2;$i<=$#lda;$i++) {
145: $num.='['.$lda[$i].'-9]';
146: }
147: if ($uda[$j+1]-$lda[$j+1]>1) {
148: $num.='|['.($lda[$j+1]+1).'-'.($uda[$j+1]-1).']\d{'.
149: ($#lda-$j-1).'}';
150: }
151: $num.='|'.$uda[$j+1];
152: for ($i=$j+2;$i<=$#uda;$i++) {
153: $num.='[0-'.$uda[$i].']';
154: }
155: $num.=')';
156: } else {
157: if ($lda[$#lda]!=$uda[$#uda]) {
158: $num.='['.$lda[$#lda].'-'.$uda[$#uda].']';
159: }
160: }
161: }
162: }
163: return '^'.$alpha.$num."\$";
164: }
165:
166: sub NUM {
167: my $mask=mask(@_);
168: my $num=0;
169: map {
170: $num++;
171: } grep /$mask/,keys %v;
172: return $num;
173: }
174:
175: sub BIN {
176: my ($low,$high,$lower,$upper)=@_;
177: my $mask=mask($lower,$upper);
178: my $num=0;
179: map {
180: if (($v{$_}>=$low) && ($v{$_}<=$high)) {
181: $num++;
182: }
183: } grep /$mask/,keys %v;
184: return $num;
185: }
186:
187:
188: sub SUM {
189: my $mask=mask(@_);
190: my $sum=0;
191: map {
192: $sum+=$v{$_};
193: } grep /$mask/,keys %v;
194: return $sum;
195: }
196:
197: sub MEAN {
198: my $mask=mask(@_);
199: my $sum=0; my $num=0;
200: map {
201: $sum+=$v{$_};
202: $num++;
203: } grep /$mask/,keys %v;
204: if ($num) {
205: return $sum/$num;
206: } else {
207: return undef;
208: }
209: }
210:
211: sub STDDEV {
212: my $mask=mask(@_);
213: my $sum=0; my $num=0;
214: map {
215: $sum+=$v{$_};
216: $num++;
217: } grep /$mask/,keys %v;
218: unless ($num>1) { return undef; }
219: my $mean=$sum/$num;
220: $sum=0;
221: map {
222: $sum+=($v{$_}-$mean)**2;
223: } grep /$mask/,keys %v;
224: return sqrt($sum/($num-1));
225: }
226:
227: sub PROD {
228: my $mask=mask(@_);
229: my $prod=1;
230: map {
231: $prod*=$v{$_};
232: } grep /$mask/,keys %v;
233: return $prod;
234: }
235:
236: sub MAX {
237: my $mask=mask(@_);
238: my $max='-';
239: map {
240: unless ($max) { $max=$v{$_}; }
241: if (($v{$_}>$max) || ($max eq '-')) { $max=$v{$_}; }
242: } grep /$mask/,keys %v;
243: return $max;
244: }
245:
246: sub MIN {
247: my $mask=mask(@_);
248: my $min='-';
249: map {
250: unless ($max) { $max=$v{$_}; }
251: if (($v{$_}<$min) || ($min eq '-')) { $min=$v{$_}; }
252: } grep /$mask/,keys %v;
253: return $min;
254: }
255:
256: sub SUMMAX {
257: my ($num,$lower,$upper)=@_;
258: my $mask=mask($lower,$upper);
259: my @inside=();
260: map {
261: $inside[$#inside+1]=$v{$_};
262: } grep /$mask/,keys %v;
263: @inside=sort(@inside);
264: my $sum=0; my $i;
265: for ($i=$#inside;(($i>$#inside-$num) && ($i>=0));$i--) {
266: $sum+=$inside[$i];
267: }
268: return $sum;
269: }
270:
271: sub SUMMIN {
272: my ($num,$lower,$upper)=@_;
273: my $mask=mask($lower,$upper);
274: my @inside=();
275: map {
276: $inside[$#inside+1]=$v{$_};
277: } grep /$mask/,keys %v;
278: @inside=sort(@inside);
279: my $sum=0; my $i;
280: for ($i=0;(($i<$num) && ($i<=$#inside));$i++) {
281: $sum+=$inside[$i];
282: }
283: return $sum;
284: }
285:
286: sub sett {
287: %t=();
288: my $pattern='';
289: if ($sheettype eq 'assesscalc') {
290: $pattern='A';
291: } else {
292: $pattern='[A-Z]';
293: }
294: map {
295: if ($_=~/template\_(\w)/) {
296: my $col=$1;
297: unless ($col=~/^$pattern/) {
298: map {
299: if ($_=~/A(\d+)/) {
300: my $trow=$1;
301: if ($trow) {
302: my $lb=$col.$trow;
303: $t{$lb}=$f{'template_'.$col};
304: $t{$lb}=~s/\#/$trow/g;
305: $t{$lb}=~s/\.\.+/\,/g;
306: $t{$lb}=~s/(^|[^\"\'])([A-Za-z]\d+)/$1\$v\{\'$2\'\}/g;
307: }
308: }
309: } keys %f;
310: }
311: }
312: } keys %f;
313: map {
314: if (($f{$_}) && ($_!~/template\_/)) {
315: if ($_=~/^$pattern/) {
316: unless ($f{$_}=~/^\!/) {
317: $t{$_}=$c{$_};
318: }
319: } else {
320: $t{$_}=$f{$_};
321: $t{$_}=~s/\.\.+/\,/g;
322: $t{$_}=~s/(^|[^\"\'])([A-Za-z]\d+)/$1\$v\{\'$2\'\}/g;
323: }
324: }
325: } keys %f;
326: $t{'A0'}=$f{'A0'};
327: $t{'A0'}=~s/\.\.+/\,/g;
328: $t{'A0'}=~s/(^|[^\"\'])([A-Za-z]\d+)/$1\$v\{\'$2\'\}/g;
329: }
330:
331: sub calc {
332: %v=();
333: &sett();
334: my $notfinished=1;
335: my $depth=0;
336: while ($notfinished) {
337: $notfinished=0;
338: map {
339: my $old=$v{$_};
340: $v{$_}=eval($t{$_});
341: if ($@) {
342: %v=();
343: return $@;
344: }
345: if ($v{$_} ne $old) { $notfinished=1; }
346: } keys %t;
347: $depth++;
348: if ($depth>100) {
349: %v=();
350: return 'Maximum calculation depth exceeded';
351: }
352: }
353: return '';
354: }
355:
356: sub templaterow {
357: my @cols=();
358: $cols[0]='<b><font size=+1>Template</font></b>';
359: map {
360: my $fm=$f{'template_'.$_};
361: $fm=~s/[\'\"]/\&\#34;/g;
362: $cols[$#cols+1]="'template_$_','$fm'".'___eq___'.$fm;
363: } ('A','B','C','D','E','F','G','H','I','J','K','L','M',
364: 'N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
365: 'a','b','c','d','e','f','g','h','i','j','k','l','m',
366: 'n','o','p','q','r','s','t','u','v','w','x','y','z');
367: return @cols;
368: }
369:
370: sub outrowassess {
371: my $n=shift;
372: my @cols=();
373: if ($n) {
374: $cols[0]=$rl{$f{'A'.$n}};
375: } else {
376: $cols[0]='<b><font size=+1>Export</font></b>';
377: }
378: map {
379: my $fm=$f{$_.$n};
380: $fm=~s/[\'\"]/\&\#34;/g;
381: $cols[$#cols+1]="'$_$n','$fm'".'___eq___'.$v{$_.$n};
382: } ('A','B','C','D','E','F','G','H','I','J','K','L','M',
383: 'N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
384: 'a','b','c','d','e','f','g','h','i','j','k','l','m',
385: 'n','o','p','q','r','s','t','u','v','w','x','y','z');
386: return @cols;
387: }
388:
389: sub outrow {
390: my $n=shift;
391: my @cols=();
392: if ($n) {
393: $cols[0]=$rl{$f{'A'.$n}};
394: } else {
395: $cols[0]='<b><font size=+1>Export</font></b>';
396: }
397: map {
398: my $fm=$f{$_.$n};
399: $fm=~s/[\'\"]/\&\#34;/g;
400: $cols[$#cols+1]="'$_$n','$fm'".'___eq___'.$v{$_.$n};
401: } ('A','B','C','D','E','F','G','H','I','J','K','L','M',
402: 'N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
403: 'a','b','c','d','e','f','g','h','i','j','k','l','m',
404: 'n','o','p','q','r','s','t','u','v','w','x','y','z');
405: return @cols;
406: }
407:
408: sub exportrowa {
409: my @exportarray=();
410: map {
411: $exportarray[$#exportarray+1]=$v{$_.'0'};
412: } ('A','B','C','D','E','F','G','H','I','J','K','L','M',
413: 'N','O','P','Q','R','S','T','U','V','W','X','Y','Z');
414: return @exportarray;
415: }
416:
417: # ------------------------------------------- End of "Inside of the safe space"
418: ENDDEFS
419: $safeeval->reval($code);
420: return $safeeval;
421: }
422:
423: # ------------------------------------------------ Add or change formula values
424:
425: sub setformulas {
426: my ($safeeval,@f)=@_;
427: $safeeval->reval('%f='."('".join("','",@f)."');");
428: }
429:
430: # ------------------------------------------------ Add or change formula values
431:
432: sub setconstants {
433: my ($safeeval,@c)=@_;
434: $safeeval->reval('%c='."('".join("','",@c)."');");
435: }
436:
437: # ------------------------------------------------ Add or change formula values
438:
439: sub setrowlabels {
440: my ($safeeval,@rl)=@_;
441: $safeeval->reval('%rl='."('".join("','",@rl)."');");
442: }
443:
444: # ------------------------------------------------------- Calculate spreadsheet
445:
446: sub calcsheet {
447: my $safeeval=shift;
448: $safeeval->reval('&calc();');
449: }
450:
451: # ------------------------------------------------------------------ Get values
452:
453: sub getvalues {
454: my $safeeval=shift;
455: return $safeeval->reval('%v');
456: }
457:
458: # ---------------------------------------------------------------- Get formulas
459:
460: sub getformulas {
461: my $safeeval=shift;
462: return $safeeval->reval('%f');
463: }
464:
465: # -------------------------------------------------------------------- Get type
466:
467: sub gettype {
468: my $safeeval=shift;
469: return $safeeval->reval('$sheettype');
470: }
471:
472: # ------------------------------------------------------------------ Set maxrow
473:
474: sub setmaxrow {
475: my ($safeeval,$row)=@_;
476: $safeeval->reval('$maxrow='.$row.';');
477: }
478:
479: # ------------------------------------------------------------------ Get maxrow
480:
481: sub getmaxrow {
482: my $safeeval=shift;
483: return $safeeval->reval('$maxrow');
484: }
485:
486: # ---------------------------------------------------------------- Set filename
487:
488: sub setfilename {
489: my ($safeeval,$fn)=@_;
490: $safeeval->reval('$filename="'.$fn.'";');
491: }
492:
493: # ---------------------------------------------------------------- Get filename
494:
495: sub getfilename {
496: my $safeeval=shift;
497: return $safeeval->reval('$filename');
498: }
499:
500: # --------------------------------------------------------------- Get course ID
501:
502: sub getcid {
503: my $safeeval=shift;
504: return $safeeval->reval('$cid');
505: }
506:
507: # --------------------------------------------------------- Get course filename
508:
509: sub getcfn {
510: my $safeeval=shift;
511: return $safeeval->reval('$cfn');
512: }
513:
514: # ----------------------------------------------------------- Get course number
515:
516: sub getcnum {
517: my $safeeval=shift;
518: return $safeeval->reval('$cnum');
519: }
520:
521: # ------------------------------------------------------------- Get course home
522:
523: sub getchome {
524: my $safeeval=shift;
525: return $safeeval->reval('$chome');
526: }
527:
528: # ----------------------------------------------------------- Get course domain
529:
530: sub getcdom {
531: my $safeeval=shift;
532: return $safeeval->reval('$cdom');
533: }
534:
535: # ---------------------------------------------------------- Get course section
536:
537: sub getcsec {
538: my $safeeval=shift;
539: return $safeeval->reval('$csec');
540: }
541:
542: # --------------------------------------------------------------- Get user name
543:
544: sub getuname {
545: my $safeeval=shift;
546: return $safeeval->reval('$uname');
547: }
548:
549: # ------------------------------------------------------------- Get user domain
550:
551: sub getudom {
552: my $safeeval=shift;
553: return $safeeval->reval('$udom');
554: }
555:
556: # --------------------------------------------------------------- Get user home
557:
558: sub getuhome {
559: my $safeeval=shift;
560: return $safeeval->reval('$uhome');
561: }
562:
563: # -------------------------------------------------------------------- Get symb
564:
565: sub getusymb {
566: my $safeeval=shift;
567: return $safeeval->reval('$usymb');
568: }
569:
570: # ------------------------------------------------------------- Export of A-row
571:
572: sub exportdata {
573: my $safeeval=shift;
574: return $safeeval->reval('&exportrowa()');
575: }
576:
577: # ========================================================== End of Spreadsheet
578: # =============================================================================
579:
580: #
581: # Procedures for screen output
582: #
583: # --------------------------------------------- Produce output row n from sheet
584:
585: sub rown {
586: my ($safeeval,$n)=@_;
587: my $defaultbg;
588: my $rowdata='';
589: unless ($n eq '-') {
590: $defaultbg=((($n-1)/5)==int(($n-1)/5))?'#E0E0':'#FFFF';
591: } else {
592: $defaultbg='#E0FF';
593: }
594: if ((($n-1)/25)==int(($n-1)/25)) {
595: my $what='Student';
596: if (&gettype($safeeval) eq 'assesscalc') {
597: $what='Item';
598: } elsif (&gettype($safeeval) eq 'studentcalc') {
599: $what='Assessment';
600: }
601: $rowdata.="</table>\n<br><table border=2>".
602: '<tr><td> <td>'.$what.'</td>';
603: map {
604: $rowdata.='<td>'.$_.'</td>';
605: } ('A','B','C','D','E','F','G','H','I','J','K','L','M',
606: 'N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
607: 'a','b','c','d','e','f','g','h','i','j','k','l','m',
608: 'n','o','p','q','r','s','t','u','v','w','x','y','z');
609: $rowdata.='</tr>';
610: }
611: $rowdata.="\n<tr><td><b><font size=+1>$n</font></b></td>";
612: my $showf=0;
613: my $proc;
614: my $maxred;
615: if (&gettype($safeeval) eq 'assesscalc') {
616: $proc='&outrowassess';
617: $maxred=1;
618: } else {
619: $proc='&outrow';
620: $maxred=26;
621: }
622: if ($n eq '-') { $proc='&templaterow'; $n=-1; }
623: map {
624: my $bgcolor=$defaultbg.((($showf-1)/5==int(($showf-1)/5))?'99':'DD');
625: my ($fm,$vl)=split(/\_\_\_eq\_\_\_/,$_);
626: if ($showf==0) { $vl=$_; }
627: if ($showf<=$maxred) { $bgcolor='#FFDDDD'; }
628: if (($n==0) && ($showf<=26)) { $bgcolor='#CCCCFF'; }
629: if (($showf>$maxred) || ((!$n) && ($showf>0))) {
630: if ($vl eq '') {
631: $vl='<font size=+2 color='.$bgcolor.'>#</font>';
632: }
633: $rowdata.=
634: '<td bgcolor='.$bgcolor.'><a href="javascript:celledit('.$fm.');">'.$vl.
635: '</a></td>';
636: } else {
637: $rowdata.='<td bgcolor='.$bgcolor.'> '.$vl.' </td>';
638: }
639: $showf++;
640: } $safeeval->reval($proc.'('.$n.')');
641: return $rowdata.'</tr>';
642: }
643:
644: # ------------------------------------------------------------- Print out sheet
645:
646: sub outsheet {
647: my ($r,$safeeval)=@_;
648: my $maxred;
649: my $realm;
650: if (&gettype($safeeval) eq 'assesscalc') {
651: $maxred=1;
652: $realm='Assessment';
653: } elsif (&gettype($safeeval) eq 'studentcalc') {
654: $maxred=26;
655: $realm='User';
656: } else {
657: $maxred=26;
658: $realm='Course';
659: }
660: my $maxyellow=52-$maxred;
661: my $tabledata=
662: '<table border=2><tr><th colspan=2 rowspan=2><font size=+2>'.
663: $realm.'</font></th>'.
664: '<td bgcolor=#FFDDDD colspan='.$maxred.
665: '><b><font size=+1>Import</font></b></td>'.
666: '<td colspan='.$maxyellow.
667: '><b><font size=+1>Calculations</font></b></td></tr><tr>';
668: my $showf=0;
669: map {
670: $showf++;
671: if ($showf<=$maxred) {
672: $tabledata.='<td bgcolor="#FFDDDD">';
673: } else {
674: $tabledata.='<td>';
675: }
676: $tabledata.="<b><font size=+1>$_</font></b></td>";
677: } ('A','B','C','D','E','F','G','H','I','J','K','L','M',
678: 'N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
679: 'a','b','c','d','e','f','g','h','i','j','k','l','m',
680: 'n','o','p','q','r','s','t','u','v','w','x','y','z');
681: $tabledata.='</tr>';
682: my $row;
683: my $maxrow=&getmaxrow($safeeval);
684: $tabledata.=&rown($safeeval,'-');
685: $r->print($tabledata);
686: for ($row=0;$row<=$maxrow;$row++) {
687: $r->print(&rown($safeeval,$row));
688: }
689: $r->print('</table>');
690: }
691:
692: #
693: # -------------------------------------- Read spreadsheet formulas for a course
694: #
695:
696: sub readsheet {
697: my ($safeeval,$fn)=@_;
698: my $stype=&gettype($safeeval);
699: my $cnum=&getcnum($safeeval);
700: my $cdom=&getcdom($safeeval);
701: my $chome=&getchome($safeeval);
702:
703: # --------- There is no filename. Look for defaults in course and global, cache
704:
705: unless($fn) {
706: unless ($fn=$defaultsheets{$cnum.'_'.$cdom.'_'.$stype}) {
707: $fn=&Apache::lonnet::reply('get:'.$cdom.':'.$cnum.
708: ':environment:spreadsheet_default_'.$stype,
709: $chome);
710: unless (($fn) && ($fn!~/^error\:/)) {
711: $fn='default_'.$stype;
712: }
713: $defaultsheets{$cnum.'_'.$cdom.'_'.$stype}=$fn;
714: }
715: }
716:
717: # ---------------------------------------------------------- fn now has a value
718:
719: &setfilename($safeeval,$fn);
720:
721: # ------------------------------------------------------ see if sheet is cached
722: my $fstring='';
723: if ($fstring=$spreadsheets{$cnum.'_'.$cdom.'_'.$stype.'_'.$fn}) {
724: &setformulas($safeeval,split(/\_\_\_\;\_\_\_/,$fstring));
725: } else {
726:
727: # ---------------------------------------------------- Not cached, need to read
728:
729: my %f=();
730:
731: if ($fn=~/^default\_/) {
732: my $sheetxml='';
733: {
734: my $fh;
735: if ($fh=Apache::File->new($includedir.
736: '/default.'.&gettype($safeeval))) {
737: $sheetxml=join('',<$fh>);
738: }
739: }
740: my $parser=HTML::TokeParser->new(\$sheetxml);
741: my $token;
742: while ($token=$parser->get_token) {
743: if ($token->[0] eq 'S') {
744: if ($token->[1] eq 'field') {
745: $f{$token->[2]->{'col'}.$token->[2]->{'row'}}=
746: $parser->get_text('/field');
747: }
748: if ($token->[1] eq 'template') {
749: $f{'template_'.$token->[2]->{'col'}}=
750: $parser->get_text('/template');
751: }
752: }
753: }
754: } else {
755: my $sheet='';
756: my $reply=&Apache::lonnet::reply('dump:'.$cdom.':'.$cnum.':'.$fn,
757: $chome);
758: unless ($reply=~/^error\:/) {
759: $sheet=$reply;
760: }
761: map {
762: my ($name,$value)=split(/\=/,$_);
763: $f{&Apache::lonnet::unescape($name)}=
764: &Apache::lonnet::unescape($value);
765: } split(/\&/,$sheet);
766: }
767: # --------------------------------------------------------------- Cache and set
768: $spreadsheets{$cnum.'_'.$cdom.'_'.$stype.'_'.$fn}=join('___;___',%f);
769: &setformulas($safeeval,%f);
770: }
771: }
772:
773: # -------------------------------------------------------- Make new spreadsheet
774:
775: sub makenewsheet {
776: my ($uname,$udom,$stype,$usymb)=@_;
777: my $safeeval=initsheet();
778: $safeeval->reval(
779: '$uname="'.$uname.
780: '";$udom="'.$udom.
781: '";$uhome="'.&Apache::lonnet::homeserver($uname,$udom).
782: '";$sheettype="'.$stype.
783: '";$usymb="'.$usymb.
784: '";$csec="'.&Apache::lonnet::usection($udom,$uname,
785: $ENV{'request.course.id'}).
786: '";$cid="'.$ENV{'request.course.id'}.
787: '";$cfn="'.$ENV{'request.course.fn'}.
788: '";$cnum="'.$ENV{'course.'.$ENV{'request.course.id'}.'.num'}.
789: '";$cdom="'.$ENV{'course.'.$ENV{'request.course.id'}.'.domain'}.
790: '";$chome="'.$ENV{'course.'.$ENV{'request.course.id'}.'.home'}.'";');
791: return $safeeval;
792: }
793:
794: # ------------------------------------------------------------ Save spreadsheet
795:
796: sub writesheet {
797: my ($safeeval,$makedef)=@_;
798: my $cid=&getcid($safeeval);
799: if (&Apache::lonnet::allowed('opa',$cid)) {
800: my %f=&getformulas($safeeval);
801: my $stype=&gettype($safeeval);
802: my $cnum=&getcnum($safeeval);
803: my $cdom=&getcdom($safeeval);
804: my $chome=&getchome($safeeval);
805: my $fn=&getfilename($safeeval);
806:
807: # ------------------------------------------------------------- Cache new sheet
808: $spreadsheets{$cnum.'_'.$cdom.'_'.$stype.'_'.$fn}=join('___;___',%f);
809: # ----------------------------------------------------------------- Write sheet
810: my $sheetdata='';
811: map {
812: $sheetdata.=&Apache::lonnet::escape($_).'='.
813: &Apache::lonnet::escape($f{$_}).'&';
814: } keys %f;
815: $sheetdata=~s/\&$//;
816: my $reply=&Apache::lonnet::reply('put:'.$cdom.':'.$cnum.':'.$fn.':'.
817: $sheetdata,$chome);
818: if ($reply eq 'ok') {
819: $reply=&Apache::lonnet::reply('put:'.$cdom.':'.$cnum.':'.
820: $stype.'_spreadsheets:'.
821: &Apache::lonnet::escape($fn).'='.$ENV{'user.name'},
822: $chome);
823: if ($reply eq 'ok') {
824: if ($makedef) {
825: return &Apache::lonnet::reply('put:'.$cdom.':'.$cnum.
826: ':environment:spreadsheet_default_'.$stype.'='.
827: &Apache::lonnet::escape($fn),
828: $chome);
829: } else {
830: return $reply;
831: }
832: } else {
833: return $reply;
834: }
835: } else {
836: return $reply;
837: }
838: }
839: return 'unauthorized';
840: }
841:
842: # ----------------------------------------------- Make a temp copy of the sheet
843: # "Modified workcopy" - interactive only
844: #
845:
846: sub tmpwrite {
847: my $safeeval=shift;
848: my $fn=$ENV{'user.name'}.'_'.
849: $ENV{'user.domain'}.'_spreadsheet_'.&getusymb($safeeval).'_'.
850: &getfilename($safeeval);
851: $fn=~s/\W/\_/g;
852: $fn=$tmpdir.$fn.'.tmp';
853: my $fh;
854: if ($fh=Apache::File->new('>'.$fn)) {
855: print $fh join("\n",&getformulas($safeeval));
856: }
857: }
858:
859: # ---------------------------------------------------------- Read the temp copy
860:
861: sub tmpread {
862: my ($safeeval,$nfield,$nform)=@_;
863: my $fn=$ENV{'user.name'}.'_'.
864: $ENV{'user.domain'}.'_spreadsheet_'.&getusymb($safeeval).'_'.
865: &getfilename($safeeval);
866: $fn=~s/\W/\_/g;
867: $fn=$tmpdir.$fn.'.tmp';
868: my $fh;
869: my %fo=();
870: if ($fh=Apache::File->new($fn)) {
871: my $name;
872: while ($name=<$fh>) {
873: chomp($name);
874: my $value=<$fh>;
875: chomp($value);
876: $fo{$name}=$value;
877: }
878: }
879: if ($nfield) { $fo{$nfield}=$nform; }
880: &setformulas($safeeval,%fo);
881: }
882:
883: # ================================================================== Parameters
884: # -------------------------------------------- Figure out a cascading parameter
885: #
886: # For this function to work
887: #
888: # * parmhash needs to be tied
889: # * courseopt and useropt need to be initialized for this user and course
890: #
891:
892: sub parmval {
893: my ($what,$safeeval)=@_;
894: my $cid=&getcid($safeeval);
895: my $csec=&getcsec($safeeval);
896: my $uname=&getuname($safeeval);
897: my $udom=&getudom($safeeval);
898: my $symb=&getusymb($safeeval);
899:
900: unless ($symb) { return ''; }
901: my $result='';
902:
903: my ($mapname,$id,$fn)=split(/\_\_\_/,$symb);
904: # ----------------------------------------------------- Cascading lookup scheme
905: my $rwhat=$what;
906: $what=~s/^parameter\_//;
907: $what=~s/\_/\./;
908:
909: my $symbparm=$symb.'.'.$what;
910: my $mapparm=$mapname.'___(all).'.$what;
911: my $usercourseprefix=$uname.'_'.$udom.'_'.$cid;
912:
913: my $seclevel=
914: $usercourseprefix.'.['.
915: $csec.'].'.$what;
916: my $seclevelr=
917: $usercourseprefix.'.['.
918: $csec.'].'.$symbparm;
919: my $seclevelm=
920: $usercourseprefix.'.['.
921: $csec.'].'.$mapparm;
922:
923: my $courselevel=
924: $usercourseprefix.'.'.$what;
925: my $courselevelr=
926: $usercourseprefix.'.'.$symbparm;
927: my $courselevelm=
928: $usercourseprefix.'.'.$mapparm;
929:
930: # ---------------------------------------------------------- fourth, check user
931:
932: if ($uname) {
933:
934: if ($useropt{$courselevelr}) { return $useropt{$courselevelr}; }
935:
936: if ($useropt{$courselevelm}) { return $useropt{$courselevelm}; }
937:
938: if ($useropt{$courselevel}) { return $useropt{$courselevel}; }
939:
940: }
941:
942: # --------------------------------------------------------- third, check course
943:
944: if ($csec) {
945:
946: if ($courseopt{$seclevelr}) { return $courseopt{$seclevelr}; }
947:
948: if ($courseopt{$seclevelm}) { return $courseopt{$seclevelm}; }
949:
950: if ($courseopt{$seclevel}) { return $courseopt{$seclevel}; }
951:
952: }
953:
954: if ($courseopt{$courselevelr}) { return $courseopt{$courselevelr}; }
955:
956: if ($courseopt{$courselevelm}) { return $courseopt{$courselevelm}; }
957:
958: if ($courseopt{$courselevel}) { return $courseopt{$courselevel}; }
959:
960: # ----------------------------------------------------- second, check map parms
961:
962: my $thisparm=$parmhash{$symbparm};
963: if ($thisparm) { return $thisparm; }
964:
965: # -------------------------------------------------------- first, check default
966:
967: return &Apache::lonnet::metadata($fn,$rwhat.'.default');
968:
969: }
970:
971: # ---------------------------------------------- Update rows for course listing
972:
973: sub updateclasssheet {
974: my $safeeval=shift;
975: my $cnum=&getcnum($safeeval);
976: my $cdom=&getcdom($safeeval);
977: my $cid=&getcid($safeeval);
978: my $chome=&getchome($safeeval);
979:
980: # ---------------------------------------------- Read class list and row labels
981:
982: my $classlst=&Apache::lonnet::reply
983: ('dump:'.$cdom.':'.$cnum.':classlist',$chome);
984: my %currentlist=();
985: my $now=time;
986: unless ($classlst=~/^error\:/) {
987: map {
988: my ($name,$value)=split(/\=/,$_);
989: my ($end,$start)=split(/\:/,&Apache::lonnet::unescape($value));
990: my $active=1;
991: if (($end) && ($now>$end)) { $active=0; }
992: if ($active) {
993: my $rowlabel='';
994: $name=&Apache::lonnet::unescape($name);
995: my ($sname,$sdom)=split(/\:/,$name);
996: my $ssec=&Apache::lonnet::usection($sdom,$sname,$cid);
997: if ($ssec==-1) {
998: $rowlabel='<font color=red>Data not available: '.$name.
999: '</font>';
1000: } else {
1001: my %reply=&Apache::lonnet::idrget($sdom,$sname);
1002: my $reply=&Apache::lonnet::reply('get:'.$sdom.':'.$sname.
1003: ':environment:firstname&middlename&lastname&generation',
1004: &Apache::lonnet::homeserver($sname,$sdom));
1005: $rowlabel=$ssec.' '.$reply{$sname}.'<br>';
1006: map {
1007: $rowlabel.=&Apache::lonnet::unescape($_).' ';
1008: } split(/\&/,$reply);
1009: }
1010: $currentlist{&Apache::lonnet::unescape($name)}=$rowlabel;
1011: }
1012: } split(/\&/,$classlst);
1013: #
1014: # -------------------- Find discrepancies between the course row table and this
1015: #
1016: my %f=&getformulas($safeeval);
1017: my $changed=0;
1018:
1019: my $maxrow=0;
1020: my %existing=();
1021:
1022: # ----------------------------------------------------------- Now obsolete rows
1023: map {
1024: if ($_=~/^A(\d+)/) {
1025: $maxrow=($1>$maxrow)?$1:$maxrow;
1026: $existing{$f{$_}}=1;
1027: unless ((defined($currentlist{$f{$_}})) || (!$1)) {
1028: $f{$_}='!!! Obsolete';
1029: $changed=1;
1030: }
1031: }
1032: } keys %f;
1033:
1034: # -------------------------------------------------------- New and unknown keys
1035:
1036: map {
1037: unless ($existing{$_}) {
1038: $changed=1;
1039: $maxrow++;
1040: $f{'A'.$maxrow}=$_;
1041: }
1042: } sort keys %currentlist;
1043:
1044: if ($changed) { &setformulas($safeeval,%f); }
1045:
1046: &setmaxrow($safeeval,$maxrow);
1047: &setrowlabels($safeeval,%currentlist);
1048:
1049: } else {
1050: return 'Could not access course data';
1051: }
1052: }
1053:
1054: # ----------------------------------- Update rows for student and assess sheets
1055:
1056: sub updatestudentassesssheet {
1057: my $safeeval=shift;
1058: my %bighash;
1059: # -------------------------------------------------------------------- Tie hash
1060: if (tie(%bighash,'GDBM_File',$ENV{'request.course.fn'}.'.db',
1061: &GDBM_READER,0640)) {
1062: # --------------------------------------------------------- Get all assessments
1063:
1064: my %allkeys=();
1065: my %allassess=();
1066:
1067: my $stype=&gettype($safeeval);
1068:
1069: map {
1070: if ($_=~/^src\_(\d+)\.(\d+)$/) {
1071: my $mapid=$1;
1072: my $resid=$2;
1073: my $id=$mapid.'.'.$resid;
1074: my $srcf=$bighash{$_};
1075: if ($srcf=~/\.(problem|exam|quiz|assess|survey|form)$/) {
1076: my $symb=
1077: &Apache::lonnet::declutter($bighash{'map_id_'.$mapid}).
1078: '___'.$resid.'___'.
1079: &Apache::lonnet::declutter($srcf);
1080: $allassess{$symb}=$bighash{'title_'.$id};
1081:
1082: if ($stype eq 'assesscalc') {
1083: map {
1084: if (($_=~/^stores\_(.*)/) || ($_=~/^parameter\_(.*)/)) {
1085: my $key=$_;
1086: my $display=
1087: &Apache::lonnet::metadata($srcf,$key.'.display');
1088: unless ($display) {
1089: $display=
1090: &Apache::lonnet::metadata($srcf,$key.'.name');
1091: }
1092: $allkeys{$key}=$display;
1093: }
1094: } split(/\,/,&Apache::lonnet::metadata($srcf,'keys'));
1095: }
1096: }
1097: }
1098: } keys %bighash;
1099: untie(%bighash);
1100:
1101: #
1102: # %allkeys has a list of storage and parameter displays by unikey
1103: # %allassess has a list of all resource displays by symb
1104: #
1105: # -------------------- Find discrepancies between the course row table and this
1106: #
1107: my %f=&getformulas($safeeval);
1108: my $changed=0;
1109:
1110: my %current=();
1111: if ($stype eq 'assesscalc') {
1112: %current=%allkeys;
1113: } elsif ($stype eq 'studentcalc') {
1114: %current=%allassess;
1115: }
1116:
1117: my $maxrow=0;
1118: my %existing=();
1119:
1120: # ----------------------------------------------------------- Now obsolete rows
1121: map {
1122: if ($_=~/^A(\d+)/) {
1123: $maxrow=($1>$maxrow)?$1:$maxrow;
1124: $existing{$f{$_}}=1;
1125: unless ((defined($current{$f{$_}})) || (!$1)) {
1126: $f{$_}='!!! Obsolete';
1127: $changed=1;
1128: }
1129: }
1130: } keys %f;
1131:
1132: # -------------------------------------------------------- New and unknown keys
1133:
1134: map {
1135: unless ($existing{$_}) {
1136: $changed=1;
1137: $maxrow++;
1138: $f{'A'.$maxrow}=$_;
1139: }
1140: } keys %current;
1141:
1142: if ($changed) { &setformulas($safeeval,%f); }
1143:
1144: &setmaxrow($safeeval,$maxrow);
1145: &setrowlabels($safeeval,%current);
1146:
1147: } else {
1148: return 'Could not access course data';
1149: }
1150: }
1151:
1152: # ------------------------------------------------ Load data for one assessment
1153:
1154: sub loadstudent {
1155: my $safeeval=shift;
1156: my %c=();
1157: my %f=&getformulas($safeeval);
1158: map {
1159: if ($_=~/^A(\d+)/) {
1160: my $row=$1;
1161: unless ($f{$_}=~/^\!/) {
1162: my @assessdata=&exportsheet(&getuname($safeeval),
1163: &getudom($safeeval),
1164: 'assesscalc',$f{$_});
1165: my $index=0;
1166: map {
1167: if ($assessdata[$index]) {
1168: $c{$_.$row}=$assessdata[$index];
1169: unless ($_ eq 'A') {
1170: $f{$_.$row}='import';
1171: }
1172: }
1173: $index++;
1174: } ('A','B','C','D','E','F','G','H','I','J','K','L','M',
1175: 'N','O','P','Q','R','S','T','U','V','W','X','Y','Z');
1176: }
1177: }
1178: } keys %f;
1179: &setformulas($safeeval,%f);
1180: &setconstants($safeeval,%c);
1181: }
1182:
1183: # --------------------------------------------------- Load data for one student
1184:
1185: sub loadcourse {
1186: my $safeeval=shift;
1187: my %c=();
1188: my %f=&getformulas($safeeval);
1189: map {
1190: if ($_=~/^A(\d+)/) {
1191: my $row=$1;
1192: unless (($f{$_}=~/^\!/)
1193:
1194: || ($row>200))
1195:
1196: {
1197: my @studentdata=&exportsheet(&getuname($safeeval),
1198: &getudom($safeeval),
1199: 'studentcalc');
1200: undef %userrdatas;
1201: my $index=0;
1202: map {
1203: if ($studentdata[$index]) {
1204: $c{$_.$row}=$studentdata[$index];
1205: unless ($_ eq 'A') {
1206: $f{$_.$row}='import';
1207: }
1208: }
1209: $index++;
1210: } ('A','B','C','D','E','F','G','H','I','J','K','L','M',
1211: 'N','O','P','Q','R','S','T','U','V','W','X','Y','Z');
1212: }
1213: }
1214: } keys %f;
1215: &setformulas($safeeval,%f);
1216: &setconstants($safeeval,%c);
1217: }
1218:
1219: # ------------------------------------------------ Load data for one assessment
1220:
1221: sub loadassessment {
1222: my $safeeval=shift;
1223:
1224: my $uhome=&getuhome($safeeval);
1225: my $uname=&getuname($safeeval);
1226: my $udom=&getudom($safeeval);
1227: my $symb=&getusymb($safeeval);
1228: my $cid=&getcid($safeeval);
1229: my $cnum=&getcnum($safeeval);
1230: my $cdom=&getcdom($safeeval);
1231: my $chome=&getchome($safeeval);
1232:
1233: my $namespace;
1234: unless ($namespace=$cid) { return ''; }
1235:
1236: # ----------------------------------------------------------- Get stored values
1237: my $answer=&Apache::lonnet::reply(
1238: "restore:$udom:$uname:".
1239: &Apache::lonnet::escape($namespace).":".
1240: &Apache::lonnet::escape($symb),$uhome);
1241: my %returnhash=();
1242: map {
1243: my ($name,$value)=split(/\=/,$_);
1244: $returnhash{&Apache::lonnet::unescape($name)}=
1245: &Apache::lonnet::unescape($value);
1246: } split(/\&/,$answer);
1247: my $version;
1248: for ($version=1;$version<=$returnhash{'version'};$version++) {
1249: map {
1250: $returnhash{$_}=$returnhash{$version.':'.$_};
1251: } split(/\:/,$returnhash{$version.':keys'});
1252: }
1253: # ----------------------------- returnhash now has all stores for this resource
1254:
1255: # ---------------------------- initialize coursedata and userdata for this user
1256: undef %courseopt;
1257: undef %useropt;
1258:
1259: my $userprefix=$uname.'_'.$udom.'_';
1260:
1261: unless ($uhome eq 'no_host') {
1262: # -------------------------------------------------------------- Get coursedata
1263: unless
1264: ((time-$courserdatas{$cid.'.last_cache'})<240) {
1265: my $reply=&Apache::lonnet::reply('dump:'.$cdom.':'.$cnum.
1266: ':resourcedata',$chome);
1267: if ($reply!~/^error\:/) {
1268: $courserdatas{$cid}=$reply;
1269: $courserdatas{$cid.'.last_cache'}=time;
1270: }
1271: }
1272: map {
1273: my ($name,$value)=split(/\=/,$_);
1274: $courseopt{$userprefix.&Apache::lonnet::unescape($name)}=
1275: &Apache::lonnet::unescape($value);
1276: } split(/\&/,$courserdatas{$ENV{'request.course.id'}});
1277: # --------------------------------------------------- Get userdata (if present)
1278: unless
1279: ((time-$userrdatas{$uname.'___'.$udom.'.last_cache'})<240) {
1280: my $reply=
1281: &Apache::lonnet::reply('dump:'.$udom.':'.$uname.':resourcedata',$uhome);
1282: if ($reply!~/^error\:/) {
1283: $userrdatas{$uname.'___'.$udom}=$reply;
1284: $userrdatas{$uname.'___'.$udom.'.last_cache'}=time;
1285: }
1286: }
1287: map {
1288: my ($name,$value)=split(/\=/,$_);
1289: $useropt{$userprefix.&Apache::lonnet::unescape($name)}=
1290: &Apache::lonnet::unescape($value);
1291: } split(/\&/,$userrdatas{$uname.'___'.$udom});
1292: }
1293:
1294: # ----------------- now courseopt, useropt initialized for this user and course
1295: # (used by parmval)
1296:
1297: my %c=();
1298:
1299: if (tie(%parmhash,'GDBM_File',
1300: &getcfn($safeeval).'_parms.db',&GDBM_READER,0640)) {
1301: my %f=&getformulas($safeeval);
1302: map {
1303: if ($_=~/^A/) {
1304: unless ($f{$_}=~/^\!/) {
1305: if ($f{$_}=~/^parameter/) {
1306: $c{$_}=&parmval($f{$_},$safeeval);
1307: } else {
1308: my $key=$f{$_};
1309: $key=~s/^stores\_/resource\./;
1310: $key=~s/\_/\./;
1311: $c{$_}=$returnhash{$key};
1312: }
1313: }
1314: }
1315: } keys %f;
1316: untie(%parmhash);
1317: }
1318: &setconstants($safeeval,%c);
1319: }
1320:
1321: # --------------------------------------------------------- Various form fields
1322:
1323: sub textfield {
1324: my ($title,$name,$value)=@_;
1325: return "\n<p><b>$title:</b><br>".
1326: '<input type=text name="'.$name.'" size=80 value="'.$value.'">';
1327: }
1328:
1329: sub hiddenfield {
1330: my ($name,$value)=@_;
1331: return "\n".'<input type=hidden name="'.$name.'" value="'.$value.'">';
1332: }
1333:
1334: sub selectbox {
1335: my ($title,$name,$value,%options)=@_;
1336: my $selout="\n<p><b>$title:</b><br>".'<select name="'.$name.'">';
1337: map {
1338: $selout.='<option value="'.$_.'"';
1339: if ($_ eq $value) { $selout.=' selected'; }
1340: $selout.='>'.$options{$_}.'</option>';
1341: } sort keys %options;
1342: return $selout.'</select>';
1343: }
1344:
1345: # =============================================== Update information in a sheet
1346: #
1347: # Add new users or assessments, etc.
1348: #
1349:
1350: sub updatesheet {
1351: my $safeeval=shift;
1352: my $stype=&gettype($safeeval);
1353: if ($stype eq 'classcalc') {
1354: return &updateclasssheet($safeeval);
1355: } else {
1356: return &updatestudentassesssheet($safeeval);
1357: }
1358: }
1359:
1360: # =================================================== Load the rows for a sheet
1361: #
1362: # Import the data for rows
1363: #
1364:
1365: sub loadrows() {
1366: my $safeeval=shift;
1367: my $stype=&gettype($safeeval);
1368: if ($stype eq 'classcalc') {
1369: &loadcourse($safeeval);
1370: } elsif ($stype eq 'studentcalc') {
1371: &loadstudent($safeeval);
1372: } else {
1373: &loadassessment($safeeval);
1374: }
1375: }
1376:
1377: # ============================================================== Export handler
1378: #
1379: # Non-interactive call from with program
1380: #
1381:
1382: sub exportsheet {
1383: my ($uname,$udom,$stype,$usymb,$fn)=@_;
1384: my $thissheet=&makenewsheet($uname,$udom,$stype,$usymb);
1385: &readsheet($thissheet,$fn);
1386: &updatesheet($thissheet);
1387: &loadrows($thissheet);
1388: &calcsheet($thissheet);
1389: my @returnthis=&exportdata($thissheet);
1390: undef $thissheet;
1391: return @returnthis;
1392: }
1393:
1394: # ================================================================ Main handler
1395: #
1396: # Interactive call to screen
1397: #
1398: #
1399:
1400:
1401: sub handler {
1402: my $r=shift;
1403:
1404: if ($r->header_only) {
1405: $r->content_type('text/html');
1406: $r->send_http_header;
1407: return OK;
1408: }
1409:
1410: # ---------------------------------------------------- Global directory configs
1411:
1412: $includedir=$r->dir_config('lonIncludes');
1413: $tmpdir=$r->dir_config('lonDaemons').'/tmp/';
1414:
1415: # ----------------------------------------------------- Needs to be in a course
1416:
1417: if ($ENV{'request.course.fn'}) {
1418:
1419: # --------------------------- Get query string for limited number of parameters
1420:
1421: map {
1422: my ($name, $value) = split(/=/,$_);
1423: $value =~ tr/+/ /;
1424: $value =~ s/%([a-fA-F0-9][a-fA-F0-9])/pack("C",hex($1))/eg;
1425: if (($name eq 'uname') || ($name eq 'udom') ||
1426: ($name eq 'usymb') || ($name eq 'ufn')) {
1427: unless ($ENV{'form.'.$name}) {
1428: $ENV{'form.'.$name}=$value;
1429: }
1430: }
1431: } (split(/&/,$ENV{'QUERY_STRING'}));
1432:
1433: # ------------------------------------------- Nothing there? Must be login user
1434:
1435: my $aname;
1436: my $adom;
1437:
1438: unless ($ENV{'form.uname'}) {
1439: $aname=$ENV{'user.name'};
1440: $adom=$ENV{'user.domain'};
1441: } else {
1442: $aname=$ENV{'form.uname'};
1443: $adom=$ENV{'form.udom'};
1444: }
1445:
1446: # ------------------------------------------------------------------- Open page
1447:
1448: $r->content_type('text/html');
1449: $r->header_out('Cache-control','no-cache');
1450: $r->header_out('Pragma','no-cache');
1451: $r->send_http_header;
1452:
1453: # --------------------------------------------------------------- Screen output
1454:
1455: $r->print('<html><head><title>LON-CAPA Spreadsheet</title>');
1456: $r->print(<<ENDSCRIPT);
1457: <script language="JavaScript">
1458:
1459: function celledit(cn,cf) {
1460: var cnf=prompt(cn,cf);
1461: if (cnf!=null) {
1462: document.sheet.unewfield.value=cn;
1463: document.sheet.unewformula.value=cnf;
1464: document.sheet.submit();
1465: }
1466: }
1467:
1468: </script>
1469: ENDSCRIPT
1470: $r->print('</head><body bgcolor="#FFFFFF">'.
1471: '<img align=right src=/adm/lonIcons/lonlogos.gif>'.
1472: '<h1>LON-CAPA Spreadsheet</h1>'.
1473: '<form action="'.$r->uri.'" name=sheet method=post>'.
1474: &hiddenfield('uname',$ENV{'form.uname'}).
1475: &hiddenfield('udom',$ENV{'form.udom'}).
1476: &hiddenfield('usymb',$ENV{'form.usymb'}).
1477: &hiddenfield('unewfield','').
1478: &hiddenfield('unewformula',''));
1479:
1480: # ---------------------- Make sure that this gets out, even if user hits "stop"
1481:
1482: $r->rflush();
1483:
1484: # ---------------------------------------- Read new sheet or modified worksheet
1485:
1486: $r->uri=~/\/(\w+)$/;
1487:
1488: my $asheet=&makenewsheet($aname,$adom,$1,$ENV{'form.usymb'});
1489:
1490: # ------------------------ If a new formula had been entered, go from work copy
1491:
1492: if ($ENV{'form.unewfield'}) {
1493: $r->print('<h2>Modified Workcopy</h2>');
1494: $ENV{'form.unewformula'}=~s/\'/\"/g;
1495: $r->print('<p>New formula: '.$ENV{'form.unewfield'}.'='.
1496: $ENV{'form.unewformula'}.'<p>');
1497: &setfilename($asheet,$ENV{'form.ufn'});
1498: &tmpread($asheet,
1499: $ENV{'form.unewfield'},$ENV{'form.unewformula'});
1500:
1501: } elsif ($ENV{'form.saveas'}) {
1502: &setfilename($asheet,$ENV{'form.ufn'});
1503: &tmpread($asheet);
1504: } else {
1505: &readsheet($asheet,$ENV{'form.ufn'});
1506: }
1507:
1508: # -------------------------------------------------- Print out user information
1509:
1510: unless (&gettype($asheet) eq 'classcalc') {
1511: $r->print('<p><b>User:</b> '.&getuname($asheet).
1512: '<br><b>Domain:</b> '.&getudom($asheet));
1513: if (&getcsec($asheet) eq '-1') {
1514: $r->print('<h3><font color=red>'.
1515: 'Not a student in this course</font></h3>');
1516: } else {
1517: $r->print('<br><b>Section/Group:</b> '.&getcsec($asheet));
1518: }
1519: }
1520:
1521: # ---------------------------------------------------------------- Course title
1522:
1523: $r->print('<h1>'.
1524: $ENV{'course.'.$ENV{'request.course.id'}.'.description'}.'</h1>');
1525:
1526:
1527: # ---------------------------------------------------- See if something to save
1528:
1529: if (&Apache::lonnet::allowed('opa',$ENV{'request.course.id'})) {
1530: my $fname='';
1531: if ($ENV{'form.saveas'} && ($fname=$ENV{'form.newfn'})) {
1532: $fname=~s/\W/\_/g;
1533: if ($fname eq 'default') { $fname='course_default'; }
1534: $fname.='_'.&gettype($asheet);
1535: &setfilename($asheet,$fname);
1536: $ENV{'form.ufn'}=$fname;
1537: $r->print('<p>Saving spreadsheet: '.
1538: &writesheet($asheet,$ENV{'form.makedefufn'}).'<p>');
1539: }
1540: }
1541:
1542: # ------------------------------------------------ Write the modified worksheet
1543:
1544: $r->print('<b>Current sheet:</b> '.&getfilename($asheet).'<p>');
1545:
1546: &tmpwrite($asheet);
1547:
1548: # ----------------------------------------------------------------- Save dialog
1549:
1550:
1551: if (&Apache::lonnet::allowed('opa',$ENV{'request.course.id'})) {
1552: my $fname=$ENV{'form.ufn'};
1553: $fname=~s/\_[^\_]+$//;
1554: if ($fname eq 'default') { $fname='course_default'; }
1555: $r->print('<input type=submit name=saveas value="Save as ...">'.
1556: '<input type=text size=20 name=newfn value="'.$fname.
1557: '"> (make default: <input type=checkbox name="makedefufn">)<p>');
1558: }
1559:
1560: $r->print(&hiddenfield('ufn',&getfilename($asheet)));
1561:
1562:
1563: # ----------------------------------------------------- Update sheet, load rows
1564:
1565: &updatesheet($asheet);
1566: &loadrows($asheet);
1567:
1568:
1569: my $calcoutput=&calcsheet($asheet);
1570: $r->print('<h3><font color=red>'.$calcoutput.'</h3></font>');
1571:
1572: &outsheet($r,$asheet);
1573: $r->print('</form></body></html>');
1574:
1575:
1576: # ------------------------------------------------------------------------ Done
1577: } else {
1578: # ----------------------------- Not in a course, or not allowed to modify parms
1579: $ENV{'user.error.msg'}=
1580: $r->uri.":opa:0:0:Cannot modify spreadsheet";
1581: return HTTP_NOT_ACCEPTABLE;
1582: }
1583: return OK;
1584:
1585: }
1586:
1587: 1;
1588: __END__
1589:
1590:
1591:
1592:
1593:
1594:
1595:
1596:
1597:
1598:
1599:
1600:
1601:
1602:
1603:
1604:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/back.gif){kind=icon}
Return to lonspreadsheet.pm CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [LON-CAPA] / loncom / interface