version 1.3, 2004/02/13 18:34:40
|
version 1.8, 2004/03/16 16:30:31
|
Line 59 use Apache::lonlocal;
|
Line 59 use Apache::lonlocal;
|
use HTML::Entities(); |
use HTML::Entities(); |
use Time::Local(); |
use Time::Local(); |
use Spreadsheet::WriteExcel(); |
use Spreadsheet::WriteExcel(); |
|
use GDBM_File; |
|
use Storable qw(freeze thaw); |
|
|
#################################################### |
#################################################### |
#################################################### |
#################################################### |
Line 145 sub ProblemSelector {
|
Line 147 sub ProblemSelector {
|
$resptype.'</td><td>'. |
$resptype.'</td><td>'. |
'<a href="'.$res->{'src'}.'">'.$title.'</a> '; |
'<a href="'.$res->{'src'}.'">'.$title.'</a> '; |
# '<a href="'.$res->{'src'}.'">'.$resptype.' '.$res->{'title'}.'</a> '; |
# '<a href="'.$res->{'src'}.'">'.$resptype.' '.$res->{'title'}.'</a> '; |
if ($partdata->{'option'} > 1) { |
if (scalar(@{$partdata->{'ResponseIds'}}) > 1) { |
$seq_str .= &mt('response').' '.$respid; |
$seq_str .= &mt('response').' '.$respid; |
} |
} |
$seq_str .= "</td></tr>\n"; |
$seq_str .= "</td></tr>\n"; |
Line 337 sub get_prev_curr_next {
|
Line 339 sub get_prev_curr_next {
|
return ($prev,$curr,$next); |
return ($prev,$curr,$next); |
} |
} |
|
|
|
|
|
##################################################### |
|
##################################################### |
|
|
|
=pod |
|
|
|
=item analyze_problem_as_student |
|
|
|
Analyzes a homework problem for a student and returns the correct answer |
|
for the student. Attempts to put together an answer for problem types |
|
that do not natively support it. |
|
|
|
Inputs: $resource: a resource object |
|
$sname, $sdom, $partid, $respid |
|
|
|
Returns: $answer |
|
|
|
If $partid and $respid are specified, $answer is simply a scalar containing |
|
the correct answer for the response. |
|
|
|
If $partid or $respid are undefined, $answer will be a hash reference with |
|
keys $partid.'.'.$respid.'.answer'. |
|
|
|
=cut |
|
|
|
##################################################### |
|
##################################################### |
|
sub analyze_problem_as_student { |
|
my ($resource,$sname,$sdom,$partid,$respid) = @_; |
|
my $returnvalue; |
|
my $url = $resource->{'src'}; |
|
my $symb = $resource->{'symb'}; |
|
my $answer = &get_from_answer_cache($sname,$sdom,$symb,$partid,$respid); |
|
if (defined($answer)) { |
|
return($answer); |
|
} |
|
my $courseid = $ENV{'request.course.id'}; |
|
my $Answ=&Apache::lonnet::ssi($url,('grade_target' => 'analyze', |
|
'grade_domain' => $sdom, |
|
'grade_username' => $sname, |
|
'grade_symb' => $symb, |
|
'grade_courseid' => $courseid)); |
|
(my $garbage,$Answ)=split(/_HASH_REF__/,$Answ,2); |
|
my %Answer=&Apache::lonnet::str2hash($Answ); |
|
# |
|
undef($answer); |
|
foreach my $partid (@{$resource->{'parts'}}) { |
|
my $partdata = $resource->{'partdata'}->{$partid}; |
|
foreach my $respid (@{$partdata->{'ResponseIds'}}) { |
|
my $prefix = $partid.'.'.$respid; |
|
my $key = $prefix.'.answer'; |
|
$answer->{$partid}->{$respid} = &get_answer($prefix,$key,%Answer); |
|
} |
|
} |
|
&store_answer($sname,$sdom,$symb,undef,undef,$answer); |
|
if (! defined($partid)) { |
|
$returnvalue = $answer; |
|
} elsif (! defined($respid)) { |
|
$returnvalue = $answer->{$partid}; |
|
} else { |
|
$returnvalue = $answer->{$partid}->{$respid}; |
|
} |
|
return $returnvalue; |
|
} |
|
|
|
sub get_answer { |
|
my ($prefix,$key,%Answer) = @_; |
|
my $returnvalue; |
|
if (exists($Answer{$key})) { |
|
my $student_answer = $Answer{$key}->[0]; |
|
if (! defined($student_answer)) { |
|
$student_answer = $Answer{$key}->[1]; |
|
} |
|
$returnvalue = $student_answer; |
|
} else { |
|
if (exists($Answer{$prefix.'.shown'})) { |
|
# The response has foils |
|
my %values; |
|
while (my ($k,$v) = each(%Answer)) { |
|
next if ($k !~ /^$prefix\.foil\.(value|area)\.(.*)$/); |
|
my $foilname = $2; |
|
$values{$foilname}=$v; |
|
} |
|
foreach my $foil (@{$Answer{$prefix.'.shown'}}) { |
|
if (ref($values{$foil}) eq 'ARRAY') { |
|
$returnvalue.=&HTML::Entities::encode($foil).'='. |
|
join(',',map {&HTML::Entities::encode($_)} @{$values{$foil}}).'&'; |
|
} else { |
|
$returnvalue.=&HTML::Entities::encode($foil).'='. |
|
&HTML::Entities::encode($values{$foil}).'&'; |
|
} |
|
} |
|
$returnvalue =~ s/ /\%20/g; |
|
chop ($returnvalue); |
|
} |
|
} |
|
return $returnvalue; |
|
} |
|
|
|
|
|
##################################################### |
|
##################################################### |
|
|
|
=pod |
|
|
|
=item Caching routines |
|
|
|
=over 4 |
|
|
|
=item &load_answer_cache($symb) |
|
|
|
Loads the cache for the given symb into memory from disk. |
|
Requires the cache filename be set. |
|
Only should be called by &ensure_proper_cache. |
|
|
|
=cut |
|
|
|
##################################################### |
|
##################################################### |
|
{ |
|
my $cache_filename = undef; |
|
my $current_symb = undef; |
|
my %cache; |
|
|
|
sub load_answer_cache { |
|
my ($symb) = @_; |
|
return if (! defined($cache_filename)); |
|
if (! defined($current_symb) || $current_symb ne $symb) { |
|
undef(%cache); |
|
my $storedstring; |
|
my %cache_db; |
|
if (tie(%cache_db,'GDBM_File',$cache_filename,&GDBM_READER(),0640)) { |
|
$storedstring = $cache_db{&Apache::lonnet::escape($symb)}; |
|
untie(%cache_db); |
|
} |
|
if (defined($storedstring)) { |
|
%cache = %{thaw($storedstring)}; |
|
} |
|
} |
|
return; |
|
} |
|
|
|
##################################################### |
|
##################################################### |
|
|
|
=pod |
|
|
|
=item &get_from_answer_cache($sname,$sdom,$symb,$partid,$respid) |
|
|
|
Returns the appropriate data from the cache, or undef if no data exists. |
|
If $respid is undefined, a hash ref containing the answers for the given |
|
$partid is returned. If $partid is undefined, a hash ref containing answers |
|
for all of the parts is returned. |
|
|
|
=cut |
|
|
|
##################################################### |
|
##################################################### |
|
sub get_from_answer_cache { |
|
my ($sname,$sdom,$symb,$partid,$respid) = @_; |
|
&ensure_proper_cache($symb); |
|
my $returnvalue; |
|
if (exists($cache{$sname.':'.$sdom}) && |
|
ref($cache{$sname.':'.$sdom}) eq 'HASH') { |
|
if (defined($partid) && |
|
exists($cache{$sname.':'.$sdom}->{$partid})) { |
|
if (defined($respid) && |
|
exists($cache{$sname.':'.$sdom}->{$partid}->{$respid})) { |
|
$returnvalue = $cache{$sname.':'.$sdom}->{$partid}->{$respid}; |
|
} else { |
|
$returnvalue = $cache{$sname.':'.$sdom}->{$partid}; |
|
} |
|
} else { |
|
$returnvalue = $cache{$sname.':'.$sdom}; |
|
} |
|
} else { |
|
$returnvalue = undef; |
|
} |
|
return $returnvalue; |
|
} |
|
|
|
##################################################### |
|
##################################################### |
|
|
|
=pod |
|
|
|
=item &write_answer_cache($symb) |
|
|
|
Writes the in memory cache to disk so that it can be read in with |
|
&load_answer_cache($symb). |
|
|
|
=cut |
|
|
|
##################################################### |
|
##################################################### |
|
sub write_answer_cache { |
|
return if (! defined($current_symb) || ! defined($cache_filename)); |
|
my %cache_db; |
|
my $key = &Apache::lonnet::escape($current_symb); |
|
if (tie(%cache_db,'GDBM_File',$cache_filename,&GDBM_WRCREAT(),0640)) { |
|
my $storestring = freeze(\%cache); |
|
$cache_db{$key}=$storestring; |
|
$cache_db{$key.'.time'}=time; |
|
untie(%cache_db); |
|
} |
|
undef(%cache); |
|
undef($current_symb); |
|
undef($cache_filename); |
|
return; |
|
} |
|
|
|
##################################################### |
|
##################################################### |
|
|
|
=pod |
|
|
|
=item &ensure_proper_cache($symb) |
|
|
|
Called to make sure we have the proper cache set up. This is called |
|
prior to every answer lookup. |
|
|
|
=cut |
|
|
|
##################################################### |
|
##################################################### |
|
sub ensure_proper_cache { |
|
my ($symb) = @_; |
|
my $cid = $ENV{'request.course.id'}; |
|
my $new_filename = '/home/httpd/perl/tmp/'. |
|
'problemanalsysis_'.$cid.'answer_cache.db'; |
|
if (! defined($cache_filename) || |
|
$cache_filename ne $new_filename || |
|
! defined($current_symb) || |
|
$current_symb ne $symb) { |
|
$cache_filename = $new_filename; |
|
# Notice: $current_symb is not set to $symb until after the cache is |
|
# loaded. This is what tells &load_answer_cache to load in a new |
|
# symb cache. |
|
&load_answer_cache($symb); |
|
$current_symb = $symb; |
|
} |
|
} |
|
|
|
##################################################### |
|
##################################################### |
|
|
|
=pod |
|
|
|
=item &store_answer($sname,$sdom,$symb,$partid,$respid,$dataset) |
|
|
|
Stores the answer data in the in memory cache. |
|
|
|
=cut |
|
|
|
##################################################### |
|
##################################################### |
|
sub store_answer { |
|
my ($sname,$sdom,$symb,$partid,$respid,$dataset) = @_; |
|
return if ($symb ne $current_symb); |
|
if (defined($partid)) { |
|
if (defined($respid)) { |
|
$cache{$sname.':'.$sdom}->{$partid}->{$respid} = $dataset; |
|
} else { |
|
$cache{$sname.':'.$sdom}->{$partid} = $dataset; |
|
} |
|
} else { |
|
$cache{$sname.':'.$sdom}=$dataset; |
|
} |
|
return; |
|
} |
|
|
|
} |
|
##################################################### |
|
##################################################### |
|
|
|
=pod |
|
|
|
=back |
|
|
|
=cut |
|
|
|
##################################################### |
|
##################################################### |
|
|
|
## |
|
## The following is copied from datecalc1.pl, part of the |
|
## Spreadsheet::WriteExcel CPAN module. |
|
## |
|
## |
|
###################################################################### |
|
# |
|
# Demonstration of writing date/time cells to Excel spreadsheets, |
|
# using UNIX/Perl time as source of date/time. |
|
# |
|
# Copyright 2000, Andrew Benham, adsb@bigfoot.com |
|
# |
|
###################################################################### |
|
# |
|
# UNIX/Perl time is the time since the Epoch (00:00:00 GMT, 1 Jan 1970) |
|
# measured in seconds. |
|
# |
|
# An Excel file can use exactly one of two different date/time systems. |
|
# In these systems, a floating point number represents the number of days |
|
# (and fractional parts of the day) since a start point. The floating point |
|
# number is referred to as a 'serial'. |
|
# The two systems ('1900' and '1904') use different starting points: |
|
# '1900'; '1.00' is 1 Jan 1900 BUT 1900 is erroneously regarded as |
|
# a leap year - see: |
|
# http://support.microsoft.com/support/kb/articles/Q181/3/70.asp |
|
# for the excuse^H^H^H^H^H^Hreason. |
|
# '1904'; '1.00' is 2 Jan 1904. |
|
# |
|
# The '1904' system is the default for Apple Macs. Windows versions of |
|
# Excel have the option to use the '1904' system. |
|
# |
|
# Note that Visual Basic's "DateSerial" function does NOT erroneously |
|
# regard 1900 as a leap year, and thus its serials do not agree with |
|
# the 1900 serials of Excel for dates before 1 Mar 1900. |
|
# |
|
# Note that StarOffice (at least at version 5.2) does NOT erroneously |
|
# regard 1900 as a leap year, and thus its serials do not agree with |
|
# the 1900 serials of Excel for dates before 1 Mar 1900. |
|
# |
|
###################################################################### |
|
# |
|
# Calculation description |
|
# ======================= |
|
# |
|
# 1900 system |
|
# ----------- |
|
# Unix time is '0' at 00:00:00 GMT 1 Jan 1970, i.e. 70 years after 1 Jan 1900. |
|
# Of those 70 years, 17 (1904,08,12,16,20,24,28,32,36,40,44,48,52,56,60,64,68) |
|
# were leap years with an extra day. |
|
# Thus there were 17 + 70*365 days = 25567 days between 1 Jan 1900 and |
|
# 1 Jan 1970. |
|
# In the 1900 system, '1' is 1 Jan 1900, but as 1900 was not a leap year |
|
# 1 Jan 1900 should really be '2', so 1 Jan 1970 is '25569'. |
|
# |
|
# 1904 system |
|
# ----------- |
|
# Unix time is '0' at 00:00:00 GMT 1 Jan 1970, i.e. 66 years after 1 Jan 1904. |
|
# Of those 66 years, 17 (1904,08,12,16,20,24,28,32,36,40,44,48,52,56,60,64,68) |
|
# were leap years with an extra day. |
|
# Thus there were 17 + 66*365 days = 24107 days between 1 Jan 1904 and |
|
# 1 Jan 1970. |
|
# In the 1904 system, 2 Jan 1904 being '1', 1 Jan 1970 is '24107'. |
|
# |
|
###################################################################### |
|
# |
|
# Copyright (c) 2000, Andrew Benham. |
|
# This program is free software. It may be used, redistributed and/or |
|
# modified under the same terms as Perl itself. |
|
# |
|
# Andrew Benham, adsb@bigfoot.com |
|
# London, United Kingdom |
|
# 11 Nov 2000 |
|
# |
|
###################################################################### |
|
#----------------------------------------------------------- |
|
# calc_serial() |
|
# |
|
# Called with (up to) 2 parameters. |
|
# 1. Unix timestamp. If omitted, uses current time. |
|
# 2. GMT flag. Set to '1' to return serial in GMT. |
|
# If omitted, returns serial in appropriate timezone. |
|
# |
|
# Returns date/time serial according to $DATE_SYSTEM selected |
|
#----------------------------------------------------------- |
|
sub calc_serial { |
|
# Use 1900 date system on all platforms other than Apple Mac (for which |
|
# use 1904 date system). |
|
my $DATE_SYSTEM = ($^O eq 'MacOS') ? 1 : 0; |
|
my $time = (defined $_[0]) ? $_[0] : time(); |
|
my $gmtflag = (defined $_[1]) ? $_[1] : 0; |
|
# |
|
# Divide timestamp by number of seconds in a day. |
|
# This gives a date serial with '0' on 1 Jan 1970. |
|
my $serial = $time / 86400; |
|
# |
|
# Adjust the date serial by the offset appropriate to the |
|
# currently selected system (1900/1904). |
|
if ($DATE_SYSTEM == 0) { # use 1900 system |
|
$serial += 25569; |
|
} else { # use 1904 system |
|
$serial += 24107; |
|
} |
|
# |
|
unless ($gmtflag) { |
|
# Now have a 'raw' serial with the right offset. But this |
|
# gives a serial in GMT, which is false unless the timezone |
|
# is GMT. We need to adjust the serial by the appropriate |
|
# timezone offset. |
|
# Calculate the appropriate timezone offset by seeing what |
|
# the differences between localtime and gmtime for the given |
|
# time are. |
|
# |
|
my @gmtime = gmtime($time); |
|
my @ltime = localtime($time); |
|
# |
|
# For the first 7 elements of the two arrays, adjust the |
|
# date serial where the elements differ. |
|
for (0 .. 6) { |
|
my $diff = $ltime[$_] - $gmtime[$_]; |
|
if ($diff) { |
|
$serial += _adjustment($diff,$_); |
|
} |
|
} |
|
} |
|
# |
|
# Perpetuate the error that 1900 was a leap year by decrementing |
|
# the serial if we're using the 1900 system and the date is prior to |
|
# 1 Mar 1900. This has the effect of making serial value '60' |
|
# 29 Feb 1900. |
|
# |
|
# This fix only has any effect if UNIX/Perl time on the platform |
|
# can represent 1900. Many can't. |
|
# |
|
unless ($DATE_SYSTEM) { |
|
$serial-- if ($serial < 61); # '61' is 1 Mar 1900 |
|
} |
|
return $serial; |
|
} |
|
|
|
sub _adjustment { |
|
# Based on the difference in the localtime/gmtime array elements |
|
# number, return the adjustment required to the serial. |
|
# |
|
# We only look at some elements of the localtime/gmtime arrays: |
|
# seconds unlikely to be different as all known timezones |
|
# have an offset of integral multiples of 15 minutes, |
|
# but it's easy to do. |
|
# minutes will be different for timezone offsets which are |
|
# not an exact number of hours. |
|
# hours very likely to be different. |
|
# weekday will differ when localtime/gmtime difference |
|
# straddles midnight. |
|
# |
|
# Assume that difference between localtime and gmtime is less than |
|
# 5 days, then don't have to do maths for day of month, month number, |
|
# year number, etc... |
|
# |
|
my ($delta,$element) = @_; |
|
my $adjust = 0; |
|
# |
|
if ($element == 0) { # Seconds |
|
$adjust = $delta/86400; # 60 * 60 * 24 |
|
} elsif ($element == 1) { # Minutes |
|
$adjust = $delta/1440; # 60 * 24 |
|
} elsif ($element == 2) { # Hours |
|
$adjust = $delta/24; # 24 |
|
} elsif ($element == 6) { # Day of week number |
|
# Catch difference straddling Sat/Sun in either direction |
|
$delta += 7 if ($delta < -4); |
|
$delta -= 7 if ($delta > 4); |
|
# |
|
$adjust = $delta; |
|
} |
|
return $adjust; |
|
} |
|
|
|
########################################################### |
|
########################################################### |
|
|
|
=pod |
|
|
|
=item get_problem_data |
|
|
|
Returns a data structure describing the problem. |
|
|
|
Inputs: $url |
|
|
|
Returns: %Partdata |
|
|
|
=cut |
|
|
|
## note: we must force each foil and option to not begin or end with |
|
## spaces as they are stored without such data. |
|
## |
|
########################################################### |
|
########################################################### |
|
sub get_problem_data { |
|
my ($url) = @_; |
|
my $Answ=&Apache::lonnet::ssi($url,('grade_target' => 'analyze')); |
|
(my $garbage,$Answ)=split(/_HASH_REF__/,$Answ,2); |
|
my %Answer; |
|
%Answer=&Apache::lonnet::str2hash($Answ); |
|
my %Partdata; |
|
foreach my $part (@{$Answer{'parts'}}) { |
|
while (my($key,$value) = each(%Answer)) { |
|
# |
|
# Logging code: |
|
if (0) { |
|
&Apache::lonnet::logthis($part.' got key "'.$key.'"'); |
|
if (ref($value) eq 'ARRAY') { |
|
&Apache::lonnet::logthis(' @'.join(',',@$value)); |
|
} else { |
|
&Apache::lonnet::logthis(' '.$value); |
|
} |
|
} |
|
# End of logging code |
|
next if ($key !~ /^$part/); |
|
$key =~ s/^$part\.//; |
|
if (ref($value) eq 'ARRAY') { |
|
if ($key eq 'options') { |
|
$Partdata{$part}->{'_Options'}=$value; |
|
} elsif ($key eq 'concepts') { |
|
$Partdata{$part}->{'_Concepts'}=$value; |
|
} elsif ($key =~ /^concept\.(.*)$/) { |
|
my $concept = $1; |
|
foreach my $foil (@$value) { |
|
$Partdata{$part}->{'_Foils'}->{$foil}->{'_Concept'}= |
|
$concept; |
|
} |
|
} elsif ($key =~ /^(incorrect|answer|ans_low|ans_high)$/) { |
|
$Partdata{$part}->{$key}=$value; |
|
} |
|
} else { |
|
if ($key=~ /^foil\.text\.(.*)$/) { |
|
my $foil = $1; |
|
$Partdata{$part}->{'_Foils'}->{$foil}->{'name'}=$foil; |
|
$value =~ s/(\s*$|^\s*)//g; |
|
$Partdata{$part}->{'_Foils'}->{$foil}->{'text'}=$value; |
|
} elsif ($key =~ /^foil\.value\.(.*)$/) { |
|
my $foil = $1; |
|
$Partdata{$part}->{'_Foils'}->{$foil}->{'value'}=$value; |
|
} |
|
} |
|
} |
|
} |
|
return %Partdata; |
|
} |
|
|
|
#################################################### |
|
#################################################### |
|
|
|
=pod |
|
|
|
=item &limit_by_time() |
|
|
|
=cut |
|
|
|
#################################################### |
|
#################################################### |
|
sub limit_by_time_form { |
|
my $Starttime_form = ''; |
|
my $starttime = &Apache::lonhtmlcommon::get_date_from_form |
|
('limitby_startdate'); |
|
my $endtime = &Apache::lonhtmlcommon::get_date_from_form |
|
('limitby_enddate'); |
|
if (! defined($endtime)) { |
|
$endtime = time; |
|
} |
|
if (! defined($starttime)) { |
|
$starttime = $endtime - 60*60*24*7; |
|
} |
|
my $state; |
|
if (&limit_by_time()) { |
|
$state = ''; |
|
} else { |
|
$state = 'disabled'; |
|
} |
|
my $startdateform = &Apache::lonhtmlcommon::date_setter |
|
('Statistics','limitby_startdate',$starttime,undef,undef,$state); |
|
my $enddateform = &Apache::lonhtmlcommon::date_setter |
|
('Statistics','limitby_enddate',$endtime,undef,undef,$state); |
|
my $Str; |
|
$Str .= '<script language="Javascript" >'; |
|
$Str .= 'function toggle_limitby_activity(state) {'; |
|
$Str .= ' if (state) {'; |
|
$Str .= ' limitby_startdate_enable();'; |
|
$Str .= ' limitby_enddate_enable();'; |
|
$Str .= ' } else {'; |
|
$Str .= ' limitby_startdate_disable();'; |
|
$Str .= ' limitby_enddate_disable();'; |
|
$Str .= ' }'; |
|
$Str .= '}'; |
|
$Str .= '</script>'; |
|
$Str .= '<fieldset>'; |
|
my $timecheckbox = '<input type="checkbox" name="limit_by_time" '; |
|
if (&limit_by_time()) { |
|
$timecheckbox .= ' checked '; |
|
} |
|
$timecheckbox .= 'OnChange="javascript:toggle_limitby_activity(this.checked);" '; |
|
$timecheckbox .= ' />'; |
|
$Str .= '<legend>'.&mt('[_1] Limit by time',$timecheckbox).'</legend>'; |
|
$Str .= &mt('Start Time: [_1]',$startdateform).'<br />'; |
|
$Str .= &mt(' End Time: [_1]',$enddateform).'<br />'; |
|
$Str .= '</fieldset>'; |
|
return $Str; |
|
} |
|
|
|
sub limit_by_time { |
|
if (exists($ENV{'form.limit_by_time'}) && |
|
$ENV{'form.limit_by_time'} ne '' ) { |
|
return 1; |
|
} else { |
|
return 0; |
|
} |
|
} |
|
|
|
sub get_time_limits { |
|
my $starttime = &Apache::lonhtmlcommon::get_date_from_form |
|
('limitby_startdate'); |
|
my $endtime = &Apache::lonhtmlcommon::get_date_from_form |
|
('limitby_enddate'); |
|
return ($starttime,$endtime); |
|
} |
|
|
#################################################### |
#################################################### |
#################################################### |
#################################################### |
|
|