version 1.184, 2003/05/05 17:44:03
|
version 1.190, 2003/05/14 20:16:56
|
Line 71 my %statusIconMap =
|
Line 71 my %statusIconMap =
|
$resObj->TRIES_LEFT => 'navmap.open.gif', |
$resObj->TRIES_LEFT => 'navmap.open.gif', |
$resObj->INCORRECT => 'navmap.wrong.gif', |
$resObj->INCORRECT => 'navmap.wrong.gif', |
$resObj->OPEN => 'navmap.open.gif', |
$resObj->OPEN => 'navmap.open.gif', |
$resObj->ATTEMPTED => 'navmap.open.gif' ); |
$resObj->ATTEMPTED => 'navmap.open.gif', |
|
$resObj->ANSWER_SUBMITTED => '' ); |
|
|
my %iconAltTags = |
my %iconAltTags = |
( 'navmap.correct.gif' => 'Correct', |
( 'navmap.correct.gif' => 'Correct', |
Line 365 sub getDescription {
|
Line 366 sub getDescription {
|
return "No due date $triesString"; |
return "No due date $triesString"; |
} |
} |
} |
} |
|
if ($status == $res->ANSWER_SUBMITTED) { |
|
return 'Answer submitted'; |
|
} |
} |
} |
|
|
# Convenience function, so others can use it: Is the problem due in less then |
# Convenience function, so others can use it: Is the problem due in less then |
Line 733 returns a true or false value. If true,
|
Line 737 returns a true or false value. If true,
|
false, it is simply skipped in the display. By default, all resources |
false, it is simply skipped in the display. By default, all resources |
are shown. |
are shown. |
|
|
|
=item * B<suppressEmptySequences>: |
|
|
|
If you're using a filter function, and displaying sequences to orient |
|
the user, then frequently some sequences will be empty. Setting this to |
|
true will cause those sequences not to display, so as not to confuse the |
|
user into thinking that if the sequence is there there should be things |
|
under it. |
|
|
=item * B<suppressNavmaps>: |
=item * B<suppressNavmaps>: |
|
|
If true, will not display Navigate Content resources. Default to |
If true, will not display Navigate Content resources. Default to |
Line 1219 sub render {
|
Line 1231 sub render {
|
$args->{'indentString'} = setDefault($args->{'indentString'}, "<img src='/adm/lonIcons/whitespace1.gif' width='25' height='1' alt='' border='0' />"); |
$args->{'indentString'} = setDefault($args->{'indentString'}, "<img src='/adm/lonIcons/whitespace1.gif' width='25' height='1' alt='' border='0' />"); |
$args->{'displayedHereMarker'} = 0; |
$args->{'displayedHereMarker'} = 0; |
|
|
|
# If we're suppressing empty sequences, look for them here. Use DFS for speed, |
|
# since structure actually doesn't matter, except what map has what resources. |
|
if ($args->{'suppressEmptySequences'}) { |
|
my $dfsit = Apache::lonnavmaps::DFSiterator->new($navmap, |
|
$it->{FIRST_RESOURCE}, |
|
$it->{FINISH_RESOURCE}, |
|
{}, undef, 1); |
|
$depth = 0; |
|
$dfsit->next(); |
|
my $curRes = $dfsit->next(); |
|
while ($depth > -1) { |
|
if ($curRes == $dfsit->BEGIN_MAP()) { $depth++; } |
|
if ($curRes == $dfsit->END_MAP()) { $depth--; } |
|
|
|
if (ref($curRes)) { |
|
# Parallel pre-processing: Do sequences have non-filtered-out children? |
|
if ($curRes->is_sequence()) { |
|
$curRes->{DATA}->{HAS_VISIBLE_CHILDREN} = 0; |
|
# Sequences themselves do not count as visible children, |
|
# unless those sequences also have visible children. |
|
# This means if a sequence appears, there's a "promise" |
|
# that there's something under it if you open it, somewhere. |
|
} else { |
|
# Not a sequence: if it's filtered, ignore it, otherwise |
|
# rise up the stack and mark the sequences as having children |
|
if (&$filterFunc($curRes)) { |
|
for my $sequence (@{$dfsit->getStack()}) { |
|
$sequence->{DATA}->{HAS_VISIBLE_CHILDREN} = 1; |
|
} |
|
} |
|
} |
|
} |
|
} continue { |
|
$curRes = $dfsit->next(); |
|
} |
|
} |
|
|
my $displayedJumpMarker = 0; |
my $displayedJumpMarker = 0; |
# Set up iteration. |
# Set up iteration. |
$depth = 1; |
$depth = 1; |
Line 1262 sub render {
|
Line 1311 sub render {
|
next; |
next; |
} |
} |
|
|
|
# If this is an empty sequence and we're filtering them, continue on |
|
if ($curRes->is_sequence() && $args->{'suppressEmptySequences'} && |
|
!$curRes->{DATA}->{HAS_VISIBLE_CHILDREN}) { |
|
next; |
|
} |
|
|
# If we're suppressing navmaps and this is a navmap, continue on |
# If we're suppressing navmaps and this is a navmap, continue on |
if ($suppressNavmap && $curRes->src() =~ /^\/adm\/navmaps/) { |
if ($suppressNavmap && $curRes->src() =~ /^\/adm\/navmaps/) { |
next; |
next; |
Line 2190 sub new {
|
Line 2245 sub new {
|
|
|
$curRes->{DATA}->{DISPLAY_DEPTH} = $finalDepth; |
$curRes->{DATA}->{DISPLAY_DEPTH} = $finalDepth; |
if ($finalDepth > $maxDepth) {$maxDepth = $finalDepth;} |
if ($finalDepth > $maxDepth) {$maxDepth = $finalDepth;} |
} |
} |
|
} continue { |
$curRes = $iterator->next(); |
$curRes = $iterator->next(); |
} |
} |
} |
} |
Line 2567 sub next {
|
Line 2623 sub next {
|
return $self->{HERE}; |
return $self->{HERE}; |
} |
} |
|
|
|
# Identical to the full iterator methods of the same name. Hate to copy/paste |
|
# but I also hate to "inherit" either iterator from the other. |
|
|
|
sub getStack { |
|
my $self=shift; |
|
|
|
my @stack; |
|
|
|
$self->populateStack(\@stack); |
|
|
|
return \@stack; |
|
} |
|
|
|
# Private method: Calls the iterators recursively to populate the stack. |
|
sub populateStack { |
|
my $self=shift; |
|
my $stack = shift; |
|
|
|
push @$stack, $self->{HERE} if ($self->{HERE}); |
|
|
|
if ($self->{RECURSIVE_ITERATOR_FLAG}) { |
|
$self->{RECURSIVE_ITERATOR}->populateStack($stack); |
|
} |
|
} |
|
|
1; |
1; |
|
|
package Apache::lonnavmaps::resource; |
package Apache::lonnavmaps::resource; |
Line 2590 You will probably never need to instanti
|
Line 2671 You will probably never need to instanti
|
Apache::lonnavmaps::navmap, and use the "start" method to obtain the |
Apache::lonnavmaps::navmap, and use the "start" method to obtain the |
starting resource. |
starting resource. |
|
|
|
Resource objects respect the parameter_hiddenparts, which suppresses |
|
various parts according to the wishes of the map author. As of this |
|
writing, there is no way to override this parameter, and suppressed |
|
parts will never be returned, nor will their response types or ids be |
|
stored. |
|
|
=head2 Public Members |
=head2 Public Members |
|
|
resource objects have a hash called DATA ($resourceRef->{DATA}) that |
resource objects have a hash called DATA ($resourceRef->{DATA}) that |
Line 2799 sub is_sequence {
|
Line 2886 sub is_sequence {
|
sub parmval { |
sub parmval { |
my $self = shift; |
my $self = shift; |
my $what = shift; |
my $what = shift; |
my $part = shift || "0"; |
my $part = shift; |
|
if (!defined($part)) { |
|
$part = '0'; |
|
} |
return $self->{NAV_MAP}->parmval($part.'.'.$what, $self->symb()); |
return $self->{NAV_MAP}->parmval($part.'.'.$what, $self->symb()); |
} |
} |
|
|
Line 2973 sub opendate {
|
Line 3063 sub opendate {
|
} |
} |
return $self->parmval("opendate"); |
return $self->parmval("opendate"); |
} |
} |
|
sub problemstatus { |
|
(my $self, my $part) = @_; |
|
return $self->parmval("problemstatus", $part); |
|
} |
sub sig { |
sub sig { |
(my $self, my $part) = @_; |
(my $self, my $part) = @_; |
return $self->parmval("sig", $part); |
return $self->parmval("sig", $part); |
Line 3086 number of parts in the problem, not incl
|
Line 3180 number of parts in the problem, not incl
|
B<parts> may return an array with fewer parts in it then countParts |
B<parts> may return an array with fewer parts in it then countParts |
might lead you to believe. |
might lead you to believe. |
|
|
|
=item * B<responseType>($part): |
|
|
|
Returns the response type of the part, without the word "response" on the |
|
end. Example return values: 'string', 'essay', 'numeric', etc. |
|
|
|
=item * B<responseId>($part): |
|
|
|
Retreives the response ID for the given part, which may be an empty string. |
|
|
=back |
=back |
|
|
=cut |
=cut |
Line 3115 sub countParts {
|
Line 3218 sub countParts {
|
return scalar(@{$parts}) + $delta; |
return scalar(@{$parts}) + $delta; |
} |
} |
|
|
sub partType { |
sub responseType { |
my $self = shift; |
my $self = shift; |
my $part = shift; |
my $part = shift; |
|
|
$self->extractParts(); |
$self->extractParts(); |
return $self->{PART_TYPE}->{$part}; |
return $self->{RESPONSE_TYPE}->{$part}; |
|
} |
|
|
|
sub responseId { |
|
my $self = shift; |
|
my $part = shift; |
|
|
|
$self->extractParts(); |
|
return $self->{RESPONSE_IDS}->{$part}; |
} |
} |
|
|
# Private function: Extracts the parts information, both part names and |
# Private function: Extracts the parts information, both part names and |
# part types, and saves it |
# part types, and saves it. |
sub extractParts { |
sub extractParts { |
my $self = shift; |
my $self = shift; |
|
|
Line 3163 sub extractParts {
|
Line 3274 sub extractParts {
|
|
|
my @sortedParts = sort keys %parts; |
my @sortedParts = sort keys %parts; |
$self->{PARTS} = \@sortedParts; |
$self->{PARTS} = \@sortedParts; |
|
|
|
my %responseIdHash; |
|
my %responseTypeHash; |
|
|
|
|
|
# Init the responseIdHash |
|
foreach (@{$self->{PARTS}}) { |
|
$responseIdHash{$_} = []; |
|
} |
|
|
|
# Now, the unfortunate thing about this is that parts, part name, and |
|
# response if are delimited by underscores, but both the part |
|
# name and response id can themselves have underscores in them. |
|
# So we have to use our knowlege of part names to figure out |
|
# where the part names begin and end, and even then, it is possible |
|
# to construct ambiguous situations. |
|
foreach (split /,/, $metadata) { |
|
if ($_ =~ /^([a-zA-Z]+)response_(.*)/) { |
|
my $responseType = $1; |
|
my $partStuff = $2; |
|
my $partIdSoFar = ''; |
|
my @partChunks = split /_/, $partStuff; |
|
my $i = 0; |
|
|
|
for ($i = 0; $i < scalar(@partChunks); $i++) { |
|
if ($partIdSoFar) { $partIdSoFar .= '_'; } |
|
$partIdSoFar .= $partChunks[$i]; |
|
if ($parts{$partIdSoFar}) { |
|
my @otherChunks = @partChunks[$i+1..$#partChunks]; |
|
my $responseId = join('_', @otherChunks); |
|
push @{$responseIdHash{$partIdSoFar}}, $responseId; |
|
$responseTypeHash{$partIdSoFar} = $responseType; |
|
last; |
|
} |
|
} |
|
} |
|
} |
|
|
|
$self->{RESPONSE_IDS} = \%responseIdHash; |
|
$self->{RESPONSE_TYPES} = \%responseTypeHash; |
} |
} |
|
|
return; |
return; |
Line 3366 sub queryRestoreHash {
|
Line 3517 sub queryRestoreHash {
|
my $self = shift; |
my $self = shift; |
my $hashentry = shift; |
my $hashentry = shift; |
my $part = shift; |
my $part = shift; |
$part = "0" if (!defined($part)); |
$part = "0" if (!defined($part) || $part eq ''); |
return $self->NETWORK_FAILURE if ($self->{NAV_MAP}->{NETWORK_FAILURE}); |
return $self->NETWORK_FAILURE if ($self->{NAV_MAP}->{NETWORK_FAILURE}); |
|
|
$self->getReturnHash(); |
$self->getReturnHash(); |
Line 3384 combine the two status tidbits into one
|
Line 3535 combine the two status tidbits into one
|
represent the status of the resource as a whole. The precise logic is |
represent the status of the resource as a whole. The precise logic is |
documented in the comments of the status method. The following results |
documented in the comments of the status method. The following results |
may be returned, all available as methods on the resource object |
may be returned, all available as methods on the resource object |
($res->NETWORK_FAILURE): |
($res->NETWORK_FAILURE): In addition to the return values that match |
|
the date or completion status, this function can return "ANSWER_SUBMITTED" |
|
if that problemstatus parameter value is set to No, suppressing the |
|
incorrect/correct feedback. |
|
|
=over 4 |
=over 4 |
|
|
Line 3443 The item is open and not yet tried.
|
Line 3597 The item is open and not yet tried.
|
|
|
The problem has been attempted. |
The problem has been attempted. |
|
|
|
=item * B<ANSWER_SUBMITTED>: |
|
|
|
An answer has been submitted, but the student should not see it. |
|
|
=back |
=back |
|
|
=cut |
=cut |
|
|
sub TRIES_LEFT { return 10; } |
sub TRIES_LEFT { return 20; } |
|
sub ANSWER_SUBMITTED { return 21; } |
|
|
sub status { |
sub status { |
my $self = shift; |
my $self = shift; |
Line 3462 sub status {
|
Line 3621 sub status {
|
|
|
if ($completionStatus == NETWORK_FAILURE) { return NETWORK_FAILURE; } |
if ($completionStatus == NETWORK_FAILURE) { return NETWORK_FAILURE; } |
|
|
|
my $suppressFeedback = lc($self->parmval("problemstatus", $part)) eq 'no'; |
|
|
# There are a few whole rows we can dispose of: |
# There are a few whole rows we can dispose of: |
if ($completionStatus == CORRECT || |
if ($completionStatus == CORRECT || |
$completionStatus == CORRECT_BY_OVERRIDE ) { |
$completionStatus == CORRECT_BY_OVERRIDE ) { |
return CORRECT; |
return $suppressFeedback? ANSWER_SUBMITTED : CORRECT; |
} |
} |
|
|
if ($completionStatus == ATTEMPTED) { |
if ($completionStatus == ATTEMPTED) { |
Line 3506 sub status {
|
Line 3667 sub status {
|
if ($self->tries($part) < $self->maxtries($part) || !$self->maxtries($part)) { |
if ($self->tries($part) < $self->maxtries($part) || !$self->maxtries($part)) { |
return TRIES_LEFT; |
return TRIES_LEFT; |
} |
} |
return INCORRECT; # otherwise, return orange; student can't fix this |
return $suppressFeedback ? ANSWER_SUBMITTED : INCORRECT; # otherwise, return orange; student can't fix this |
} |
} |
|
|
# Otherwise, it's untried and open |
# Otherwise, it's untried and open |