version 1.106, 2002/11/14 21:36:23
|
version 1.124, 2003/01/10 18:45:30
|
Line 48 use POSIX qw (floor strftime);
|
Line 48 use POSIX qw (floor strftime);
|
|
|
sub handler { |
sub handler { |
my $r = shift; |
my $r = shift; |
|
real_handler($r); |
|
} |
|
|
|
sub real_handler { |
|
my $r = shift; |
|
|
&Apache::loncommon::get_unprocessed_cgi($ENV{QUERY_STRING}); |
&Apache::loncommon::get_unprocessed_cgi($ENV{QUERY_STRING}); |
|
|
Line 83 sub handler {
|
Line 88 sub handler {
|
return HTTP_NOT_ACCEPTABLE; |
return HTTP_NOT_ACCEPTABLE; |
} |
} |
|
|
|
$r->print("<html><head>\n"); |
|
$r->print("<title>Navigate Course Contents</title></head>"); |
|
|
# Header |
# Header |
$r->print(&Apache::loncommon::bodytag('Navigate Course Map','', |
$r->print(&Apache::loncommon::bodytag('Navigate Course Contents','', |
'')); |
'')); |
$r->print('<script>window.focus();</script>'); |
$r->print('<script>window.focus();</script>'); |
|
|
|
$r->rflush(); |
|
|
|
# Now that we've displayed some stuff to the user, init the navmap |
|
$navmap->init(); |
|
|
$r->print('<table border="0" cellpadding="2" cellspacing="0">'); |
$r->print('<table border="0" cellpadding="2" cellspacing="0">'); |
my $date=localtime; |
my $date=localtime; |
$r->print('<tr><td align="right" valign="bottom">Key: </td>'); |
$r->print('<tr><td align="right" valign="bottom">Key: </td>'); |
Line 113 sub handler {
|
Line 126 sub handler {
|
$condition = 1; |
$condition = 1; |
} |
} |
|
|
|
# Determine where the "here" marker is and where the screen jumps to. |
|
my $SYMB = 1; my $URL = 2; my $NOTHING = 3; # symbolic constants |
|
my $hereType; # the type of marker, $SYMB, $URL, or $NOTHING |
|
my $here; # the actual URL or SYMB for the here marker |
|
my $jumpType; # The type of the thing we have a jump for, $SYMB or $URL |
|
my $jump; # the SYMB/URL of the resource we need to jump to |
|
|
|
if ( $ENV{'form.alreadyHere'} ) { # we came from a user's manipulation of the nav page |
|
# If this is a click on a folder or something, we want to preserve the "here" |
|
# from the querystring, and get the new "jump" marker |
|
$hereType = $ENV{'form.hereType'}; |
|
$here = $ENV{'form.here'}; |
|
$jumpType = $ENV{'form.jumpType'} || $NOTHING; |
|
$jump = $ENV{'form.jump'}; |
|
} else { # the user is visiting the nav map from the remote |
|
# We're coming from the remote. We have either a url, a symb, or nothing, |
|
# and we need to figure out what. |
|
# Preference: Symb |
|
|
|
if ($ENV{'form.symb'}) { |
|
$hereType = $jumpType = $SYMB; |
|
$here = $jump = $ENV{'form.symb'}; |
|
} elsif ($ENV{'form.postdata'}) { |
|
# couldn't find a symb, is there a URL? |
|
my $currenturl = $ENV{'form.postdata'}; |
|
$currenturl=~s/^http\:\/\///; |
|
$currenturl=~s/^[^\/]+//; |
|
|
|
$hereType = $jumpType = $URL; |
|
$here = $jump = $currenturl; |
|
} else { |
|
# Nothing |
|
$hereType = $jumpType = $NOTHING; |
|
} |
|
} |
|
|
|
|
|
# alreadyHere allows us to only open the maps necessary to view |
|
# the current location once, while at the same time remembering |
|
# the current location. Without that check, the user would never |
|
# be able to close those maps; the user would close it, and the |
|
# currenturl scan would re-open it. |
|
my $queryAdd = "&alreadyHere=1"; |
|
|
if ($condition) { |
if ($condition) { |
$r->print('<a href="navmaps?condition=0&filter=">Close All Folders</a>'); |
$r->print("<a href=\"navmaps?condition=0&filter=&$queryAdd" . |
|
"&hereType=$hereType&here=" . Apache::lonnet::escape($here) . |
|
"\">Close All Folders</a>"); |
} else { |
} else { |
$r->print('<a href="navmaps?condition=1&filter=">Open All Folders</a>'); |
$r->print("<a href=\"navmaps?condition=1&filter=&$queryAdd" . |
|
"&hereType=$hereType&here=" . Apache::lonnet::escape($here) . |
|
"\">Open All Folders</a>"); |
} |
} |
|
|
$r->print('<br> '); |
$r->print('<br> '); |
$r->rflush(); |
$r->rflush(); |
|
|
# Now that we've displayed some stuff to the user, init the navmap |
|
$navmap->init(); |
|
|
|
# Check that it's defined |
# Check that it's defined |
if (!($navmap->courseMapDefined())) { |
if (!($navmap->courseMapDefined())) { |
$r->print('<font size="+2" color="red">Coursemap undefined.</font>' . |
$r->print('<font size="+2" color="red">Coursemap undefined.</font>' . |
Line 143 sub handler {
|
Line 201 sub handler {
|
my %colormap = |
my %colormap = |
( $res->NETWORK_FAILURE => '', |
( $res->NETWORK_FAILURE => '', |
$res->CORRECT => '', |
$res->CORRECT => '', |
$res->EXCUSED => '#BBBBFF', |
$res->EXCUSED => '#3333FF', |
$res->PAST_DUE_ANSWER_LATER => '', |
$res->PAST_DUE_ANSWER_LATER => '', |
$res->PAST_DUE_NO_ANSWER => '', |
$res->PAST_DUE_NO_ANSWER => '', |
$res->ANSWER_OPEN => '#CCFFCC', |
$res->ANSWER_OPEN => '#006600', |
$res->OPEN_LATER => '', |
$res->OPEN_LATER => '', |
$res->TRIES_LEFT => '', |
$res->TRIES_LEFT => '', |
$res->INCORRECT => '', |
$res->INCORRECT => '', |
Line 156 sub handler {
|
Line 214 sub handler {
|
# is not yet done and due in less then 24 hours |
# is not yet done and due in less then 24 hours |
my $hurryUpColor = "#FF0000"; |
my $hurryUpColor = "#FF0000"; |
|
|
|
# Keep these mappings in sync with lonquickgrades, which uses the colors |
|
# instead of the icons. |
my %statusIconMap = |
my %statusIconMap = |
( $res->NETWORK_FAILURE => '', |
( $res->NETWORK_FAILURE => '', |
$res->NOTHING_SET => '', |
$res->NOTHING_SET => '', |
Line 191 sub handler {
|
Line 251 sub handler {
|
# Is this a new-style course? If so, we want to suppress showing the top-level |
# Is this a new-style course? If so, we want to suppress showing the top-level |
# maps in their own folders, in favor of "inlining" them. |
# maps in their own folders, in favor of "inlining" them. |
my $topResource = $navmap->getById("0.0"); |
my $topResource = $navmap->getById("0.0"); |
my $inlineTopLevelMaps = $topResource->src() =~ m|^/uploaded/.*default\.sequence$|; |
|
|
|
my $currenturl = $ENV{'form.postdata'}; |
|
$currenturl=~s/^http\:\/\///; |
|
$currenturl=~s/^[^\/]+//; |
|
|
|
# alreadyHere allows us to only open the maps necessary to view |
|
# the current location once, while at the same time remembering |
|
# the current location. Without that check, the user would never |
|
# be able to close those maps; the user would close it, and the |
|
# currenturl scan would re-open it. |
|
my $queryAdd = "postdata=" . &Apache::lonnet::escape($currenturl) . |
|
"&alreadyHere=1"; |
|
|
|
# Begin the HTML table |
# Begin the HTML table |
# four cols: resource + indent, chat+feedback, icon, text string |
# four cols: resource + indent, chat+feedback, icon, text string |
Line 215 sub handler {
|
Line 262 sub handler {
|
# Here's a simple example of the iterator. |
# Here's a simple example of the iterator. |
# Preprocess the map: Look for current URL, force inlined maps to display |
# Preprocess the map: Look for current URL, force inlined maps to display |
|
|
my $mapIterator = $navmap->getIterator(undef, undef, \%filterHash, 1); |
my $mapIterator = $navmap->getIterator(undef, undef, undef, 1); |
my $found = 0; |
my $found = 0; |
my $depth = 1; |
my $depth = 1; |
my $currentUrlIndex = 0; # keeps track of when the current resource is found, |
my $currentJumpIndex = 0; # keeps track of when the current resource is found, |
# so we can back up a few and put the anchor above the |
# so we can back up a few and put the anchor above the |
# current resource |
# current resource |
my $currentUrlDelta = 5; # change this to change how many resources are displayed |
my $currentJumpDelta = 2; # change this to change how many resources are displayed |
# before the current resource when using #current |
# before the current resource when using #current |
$mapIterator->next(); # discard the first BEGIN_MAP |
$mapIterator->next(); # discard the first BEGIN_MAP |
my $curRes = $mapIterator->next(); |
my $curRes = $mapIterator->next(); |
my $counter = 0; |
my $counter = 0; |
|
my $foundJump = ($jumpType == $NOTHING); # look for jump point if we have one |
while ($depth > 0) { |
my $looped = 0; |
|
|
|
# We only need to do this if we need to open the maps to show the |
|
# current position. This will change the counter so we can't count |
|
# for the jump marker with this loop. |
|
while ($depth > 0 && !$ENV{'form.alreadyHere'}) { |
if ($curRes == $mapIterator->BEGIN_MAP()) { $depth++; } |
if ($curRes == $mapIterator->BEGIN_MAP()) { $depth++; } |
if ($curRes == $mapIterator->END_MAP()) { $depth--; } |
if ($curRes == $mapIterator->END_MAP()) { $depth--; } |
|
|
if (ref($curRes)) { $counter++; } |
if (ref($curRes) && !$ENV{'form.alreadyHere'} && |
|
($hereType == $SYMB && $curRes->symb() eq $here) || |
my $mapStack = $mapIterator->getStack(); |
(ref($curRes) && $hereType == $URL && $curRes->src() eq $here)) { |
if ($currenturl && !$ENV{'form.alreadyHere'} && ref($curRes) && |
my $mapStack = $mapIterator->getStack(); |
$curRes->src() eq $currenturl) { |
|
# If this is the correct resource, be sure to |
|
# show it by making sure the containing maps |
|
# are open. |
|
|
|
# This is why we have to use the main iterator instead of the |
|
# potentially faster DFS: The count has to be the same, so |
|
# the order has to be the same, which DFS won't give us. |
|
$currentUrlIndex = $counter; |
|
|
|
# Ensure the parent maps are open |
# Ensure the parent maps are open |
for my $map (@{$mapStack}) { |
for my $map (@{$mapStack}) { |
Line 255 sub handler {
|
Line 298 sub handler {
|
} |
} |
$ENV{'form.alreadyHere'} = 1; |
$ENV{'form.alreadyHere'} = 1; |
} |
} |
|
$looped = 1; |
# Preprocessing: If we're inlining nav maps into the top-level display, |
|
# make sure we show this map! |
$curRes = $mapIterator->next(); |
if ($inlineTopLevelMaps && ref($curRes) && $curRes->is_map && |
} |
scalar(@{$mapStack}) == 1) { |
|
if ($condition) { |
$mapIterator = $navmap->getIterator(undef, undef, \%filterHash, 0); |
undef $filterHash{$curRes->map_pc()}; |
$depth = 1; |
} else { |
$mapIterator->next(); |
$filterHash{$curRes->map_pc()} = 1; |
$curRes = $mapIterator->next(); |
} |
|
|
while ($depth > 0 && !$foundJump) { |
|
if ($curRes == $mapIterator->BEGIN_MAP()) { $depth++; } |
|
if ($curRes == $mapIterator->END_MAP()) { $depth--; } |
|
if (ref($curRes)) { $counter++; } |
|
|
|
if (ref($curRes) && |
|
(($jumpType == $SYMB && $curRes->symb() eq $jump) || |
|
($jumpType == $URL && $curRes->src() eq $jump))) { |
|
# If this is the correct resource, be sure to |
|
# show it by making sure the containing maps |
|
# are open. |
|
|
|
# This is why we have to use the main iterator instead of the |
|
# potentially faster DFS: The count has to be the same, so |
|
# the order has to be the same, which DFS won't give us. |
|
$currentJumpIndex = $counter; |
|
$foundJump = 1; |
} |
} |
|
|
$curRes = $mapIterator->next(); |
$curRes = $mapIterator->next(); |
Line 278 sub handler {
|
Line 338 sub handler {
|
my $now = time(); |
my $now = time(); |
my $in24Hours = $now + 24 * 60 * 60; |
my $in24Hours = $now + 24 * 60 * 60; |
my $displayedHereMarker = 0; |
my $displayedHereMarker = 0; |
|
my $displayedJumpMarker = 0; |
|
|
# We know the first thing is a BEGIN_MAP (see "$self->{STARTED}" |
# We know the first thing is a BEGIN_MAP (see "$self->{STARTED}" |
# code in iterator->next), so ignore the first one |
# code in iterator->next), so ignore the first one |
Line 285 sub handler {
|
Line 346 sub handler {
|
$condition); |
$condition); |
$mapIterator->next(); |
$mapIterator->next(); |
$curRes = $mapIterator->next(); |
$curRes = $mapIterator->next(); |
my $deltadepth = 0; |
|
$depth = 1; |
$depth = 1; |
|
|
my @backgroundColors = ("#FFFFFF", "#F6F6F6"); |
my @backgroundColors = ("#FFFFFF", "#F6F6F6"); |
Line 293 sub handler {
|
Line 353 sub handler {
|
|
|
$counter = 0; |
$counter = 0; |
|
|
# Print the 'current' anchor here if it would fall off the top |
|
if ($currentUrlIndex - $currentUrlDelta < 0) { |
|
$r->print('<a name="current" />'); |
|
} |
|
|
|
while ($depth > 0) { |
while ($depth > 0) { |
# If this is an inlined map, cancel the shift to the right, |
|
# which has the effect of making the map look inlined |
|
if ($inlineTopLevelMaps && scalar(@{$mapIterator->getStack()}) == 1 && |
|
ref($curRes) && $curRes->is_map()) { |
|
$deltadepth = -1; |
|
$curRes = $mapIterator->next(); |
|
next; |
|
} |
|
|
|
if ($curRes == $mapIterator->BEGIN_MAP() || |
if ($curRes == $mapIterator->BEGIN_MAP() || |
$curRes == $mapIterator->BEGIN_BRANCH()) { |
$curRes == $mapIterator->BEGIN_BRANCH()) { |
$indentLevel++; |
$indentLevel++; |
Line 324 sub handler {
|
Line 370 sub handler {
|
|
|
if (ref($curRes)) { $counter++; } |
if (ref($curRes)) { $counter++; } |
|
|
if ($depth == 1) { $deltadepth = 0; } # we're done shifting, because we're |
|
# out of the inlined map |
|
|
|
# Is this resource being ignored because it is in a random-out |
# Is this resource being ignored because it is in a random-out |
# map and it was not selected? |
# map and it was not selected? |
if (ref($curRes) && !advancedUser() && $curRes->randomout()) { |
if (ref($curRes) && !advancedUser() && $curRes->randomout()) { |
Line 334 sub handler {
|
Line 377 sub handler {
|
next; # if yes, then just ignore this resource |
next; # if yes, then just ignore this resource |
} |
} |
|
|
if (ref($curRes) && $curRes->src()) { |
if (ref($curRes)) { |
|
|
|
my $deltalevel = $isNewBranch? 1 : 0; # reserves space for branch icon |
|
|
|
if ($indentLevel - $deltalevel < 0) { |
|
# If this would be at a negative depth (top-level maps in |
|
# new-style courses, we want to suppress their title display) |
|
# then ignore it. |
|
$curRes = $mapIterator->next(); |
|
next; |
|
} |
|
|
# Step one: Decide which parts to show |
# Step one: Decide which parts to show |
my @parts = @{$curRes->parts()}; |
my @parts = @{$curRes->parts()}; |
Line 421 sub handler {
|
Line 474 sub handler {
|
# For each part we intend to display... |
# For each part we intend to display... |
foreach my $part (@parts) { |
foreach my $part (@parts) { |
|
|
my $deltalevel = 0; # for inserting the branch icon |
|
my $nonLinkedText = ""; # unlinked stuff after title |
my $nonLinkedText = ""; # unlinked stuff after title |
|
|
my $stack = $mapIterator->getStack(); |
my $stack = $mapIterator->getStack(); |
Line 436 sub handler {
|
Line 488 sub handler {
|
'"'; |
'"'; |
|
|
my $title = $curRes->compTitle(); |
my $title = $curRes->compTitle(); |
|
if ($src=~/^\/uploaded\//) { |
|
$nonLinkedText=$title; |
|
$title=''; |
|
} |
my $partLabel = ""; |
my $partLabel = ""; |
my $newBranchText = ""; |
my $newBranchText = ""; |
|
|
Line 443 sub handler {
|
Line 499 sub handler {
|
if ($isNewBranch) { |
if ($isNewBranch) { |
$newBranchText = "<img src=\"/adm/lonIcons/branch.gif\" border=\"0\">"; |
$newBranchText = "<img src=\"/adm/lonIcons/branch.gif\" border=\"0\">"; |
$isNewBranch = 0; |
$isNewBranch = 0; |
$deltalevel = 1; # reserves space for the branch icon |
|
} |
} |
|
|
# links to open and close the folders |
# links to open and close the folders |
Line 471 sub handler {
|
Line 526 sub handler {
|
$linkopen .= ($nowOpen xor $condition) ? |
$linkopen .= ($nowOpen xor $condition) ? |
addToFilter(\%filterHash, $mapId) : |
addToFilter(\%filterHash, $mapId) : |
removeFromFilter(\%filterHash, $mapId); |
removeFromFilter(\%filterHash, $mapId); |
$linkopen .= "&condition=$condition&$queryAdd\">"; |
$linkopen .= "&condition=$condition&$queryAdd" . |
|
"&hereType=$hereType&here=" . |
|
Apache::lonnet::escape($here) . "&jumpType=$SYMB&" . |
|
"jump=" . Apache::lonnet::escape($curRes->symb()) ."\">"; |
$linkclose = "</a>"; |
$linkclose = "</a>"; |
|
|
} |
} |
Line 479 sub handler {
|
Line 537 sub handler {
|
my $colorizer = ""; |
my $colorizer = ""; |
my $color; |
my $color; |
if ($curRes->is_problem()) { |
if ($curRes->is_problem()) { |
my $status = $curRes->status($part); |
$color = $colormap{$curRes->status}; |
$color = $colormap{$status}; |
|
|
|
# Special case in the navmaps: If in less then |
if (dueInLessThen24Hours($curRes, $part) || |
# 24 hours, give it a bit of urgency |
lastTry($curRes, $part)) { |
if (($status == $curRes->OPEN() || $status == $curRes->ATTEMPTED() || |
|
$status == $curRes->TRIES_LEFT()) |
|
&& $curRes->duedate() && |
|
$curRes->duedate() < time()+(24*60*60) && |
|
$curRes->duedate() > time()) { |
|
$color = $hurryUpColor; |
|
} |
|
# Special case: If this is the last try, and there is |
|
# more then one available, and it's not due yet, give a bit of urgency |
|
my $tries = $curRes->tries($part); |
|
my $maxtries = $curRes->maxtries($part); |
|
if ($tries && $maxtries && $maxtries > 1 && |
|
$maxtries - $tries == 1 && $curRes->duedate() && |
|
$curRes->duedate() > time()) { |
|
$color = $hurryUpColor; |
$color = $hurryUpColor; |
} |
} |
|
|
if ($color ne "") { |
if ($color ne "") { |
$colorizer = "bgcolor=\"$color\""; |
$colorizer = "bgcolor=\"$color\""; |
} |
} |
Line 513 sub handler {
|
Line 557 sub handler {
|
my $backgroundColor = $backgroundColors[$rowNum % scalar(@backgroundColors)]; |
my $backgroundColor = $backgroundColors[$rowNum % scalar(@backgroundColors)]; |
|
|
# FIRST COL: The resource indentation, branch icon, name, and anchor |
# FIRST COL: The resource indentation, branch icon, name, and anchor |
$r->print(" <tr bgcolor=\"$backgroundColor\"><td align=\"left\" valign=\"center\" width=\"60%\">\n"); |
$r->print(" <tr bgcolor=\"$backgroundColor\"><td align=\"left\" valign=\"center\">\n"); |
|
|
# Print the anchor if necessary |
# Print the anchor if necessary |
if ($counter == $currentUrlIndex - $currentUrlDelta) { |
if ($counter == $currentJumpIndex - $currentJumpDelta ) { |
$r->print('<a name="current" />'); |
$r->print('<a name="curloc" />'); |
|
$displayedJumpMarker = 1; |
} |
} |
|
|
# print indentation |
# print indentation |
for (my $i = 0; $i < $indentLevel - $deltalevel + $deltadepth; $i++) { |
for (my $i = 0; $i < $indentLevel - $deltalevel; $i++) { |
$r->print($indentString); |
$r->print($indentString); |
} |
} |
|
|
$r->print(" ${newBranchText}${linkopen}$icon${linkclose}\n"); |
$r->print(" ${newBranchText}${linkopen}$icon${linkclose}\n"); |
#$r->print($curRes->awarded($part)); |
|
|
|
my $curMarkerBegin = ""; |
my $curMarkerBegin = ""; |
my $curMarkerEnd = ""; |
my $curMarkerEnd = ""; |
|
|
# Is this the current resource? |
# Is this the current resource? |
if ($curRes->src() eq $currenturl && !$displayedHereMarker) { |
if (!$displayedHereMarker && |
$curMarkerBegin = '<a name="curloc" /><font color="red" size="+2">> </font>'; |
(($hereType == $SYMB && $curRes->symb eq $here) || |
|
($hereType == $URL && $curRes->src eq $here))) { |
|
$curMarkerBegin = '<font color="red" size="+2">> </font>'; |
$curMarkerEnd = '<font color="red" size="+2"> <</font>'; |
$curMarkerEnd = '<font color="red" size="+2"> <</font>'; |
$displayedHereMarker = 1; |
$displayedHereMarker = 1; |
} |
} |
Line 548 sub handler {
|
Line 594 sub handler {
|
|
|
$r->print(" $curMarkerBegin<a href=\"$link\">$title$partLabel</a> $curMarkerEnd $nonLinkedText"); |
$r->print(" $curMarkerBegin<a href=\"$link\">$title$partLabel</a> $curMarkerEnd $nonLinkedText"); |
|
|
if ($curRes->{RESOURCE_ERROR}) { |
#if ($curRes->{RESOURCE_ERROR}) { |
$r->print(&Apache::loncommon::help_open_topic ("Navmap_Host_Down", |
# $r->print(&Apache::loncommon::help_open_topic ("Navmap_Host_Down", |
'<font size="-1">Host down</font>')); |
# '<font size="-1">Host down</font>')); |
} |
# } |
|
|
|
$r->print("</td>\n"); |
|
|
# SECOND COL: Is there text, feedback, errors?? |
# SECOND COL: Is there text, feedback, errors?? |
my $discussionHTML = ""; my $feedbackHTML = ""; |
my $discussionHTML = ""; my $feedbackHTML = ""; my $errorHTML = ""; |
|
|
if ($curRes->hasDiscussion()) { |
if ($curRes->hasDiscussion()) { |
$discussionHTML = $linkopen . |
$discussionHTML = $linkopen . |
Line 574 sub handler {
|
Line 622 sub handler {
|
} |
} |
} |
} |
|
|
$r->print("<td width=\"75\" align=\"left\" valign=\"center\">$discussionHTML$feedbackHTML </td>"); |
if ($curRes->getErrors()) { |
|
my $errors = $curRes->getErrors(); |
|
foreach (split(/,/, $errors)) { |
|
if ($_) { |
|
$errorHTML .= ' <a href="/adm/email?display=' |
|
. &Apache::lonnet::escape($_) . '">' |
|
. '<img src="/adm/lonMisc/bomb.gif" ' |
|
. 'border="0" /></a>'; |
|
} |
|
} |
|
} |
|
|
|
$r->print("<td width=\"75\" align=\"left\" valign=\"center\">$discussionHTML$feedbackHTML$errorHTML </td>"); |
|
|
# Is this the first displayed part of a multi-part problem |
# Is this the first displayed part of a multi-part problem |
# that has not been condensed, so we should suppress these two |
# that has not been condensed, so we should suppress these two |
Line 611 sub handler {
|
Line 671 sub handler {
|
} |
} |
|
|
$r->print(" </td></tr>\n"); |
$r->print(" </td></tr>\n"); |
|
|
|
if (!($counter % 20)) { $r->rflush(); } |
|
if ($counter == 2) { $r->rflush(); } |
} |
} |
} |
} |
$curRes = $mapIterator->next(); |
$curRes = $mapIterator->next(); |
} |
} |
|
|
$r->print("</table></body></html>"); |
$r->print("</table>"); |
|
|
|
# Print out the part that jumps to #curloc if it exists |
|
if ($displayedJumpMarker) { |
|
$r->print('<script>location += "#curloc";</script>'); |
|
} |
|
|
|
$r->print("</body></html>"); |
|
|
$navmap->untieHashes(); |
$navmap->untieHashes(); |
|
|
Line 728 sub getDescription {
|
Line 798 sub getDescription {
|
} |
} |
} |
} |
|
|
|
# Convenience function, so others can use it: Is the problem due in less then |
|
# 24 hours, and still can be done? |
|
|
|
sub dueInLessThen24Hours { |
|
my $res = shift; |
|
my $part = shift; |
|
my $status = $res->status($part); |
|
|
|
return ($status == $res->OPEN() || $status == $res->ATTEMPTED() || |
|
$status == $res->TRIES_LEFT()) && |
|
$res->duedate() && $res->duedate() < time()+(24*60*60) && |
|
$res->duedate() > time(); |
|
} |
|
|
|
# Convenience function, so others can use it: Is there only one try remaining for the |
|
# part, with more then one try to begin with, not due yet and still can be done? |
|
sub lastTry { |
|
my $res = shift; |
|
my $part = shift; |
|
|
|
my $tries = $res->tries($part); |
|
my $maxtries = $res->maxtries($part); |
|
return $tries && $maxtries && $maxtries > 1 && |
|
$maxtries - $tries == 1 && $res->duedate() && |
|
$res->duedate() > time(); |
|
} |
|
|
# This puts a human-readable name on the ENV variable. |
# This puts a human-readable name on the ENV variable. |
sub advancedUser { |
sub advancedUser { |
return $ENV{'user.adv'}; |
return $ENV{'user.adv'}; |
Line 893 sub new {
|
Line 990 sub new {
|
&GDBM_READER(), 0640))) { |
&GDBM_READER(), 0640))) { |
return undef; |
return undef; |
} |
} |
$self->{NAV_HASH} = \%navmaphash; |
|
|
|
my %parmhash; |
my %parmhash; |
if (!(tie(%parmhash, 'GDBM_File', $self->{PARM_HASH_FILE}, |
if (!(tie(%parmhash, 'GDBM_File', $self->{PARM_HASH_FILE}, |
Line 902 sub new {
|
Line 998 sub new {
|
untie $self->{PARM_HASH}; |
untie $self->{PARM_HASH}; |
return undef; |
return undef; |
} |
} |
|
|
|
$self->{NAV_HASH} = \%navmaphash; |
$self->{PARM_HASH} = \%parmhash; |
$self->{PARM_HASH} = \%parmhash; |
$self->{HASH_TIED} = 1; |
|
|
|
bless($self); |
bless($self); |
|
$self->untieHashes(); |
|
|
return $self; |
return $self; |
} |
} |
Line 976 sub init {
|
Line 1074 sub init {
|
my %emailstatus = &Apache::lonnet::dump('email_status'); |
my %emailstatus = &Apache::lonnet::dump('email_status'); |
my $logoutTime = $emailstatus{'logout'}; |
my $logoutTime = $emailstatus{'logout'}; |
my $courseLeaveTime = $emailstatus{'logout_'.$ENV{'request.course.id'}}; |
my $courseLeaveTime = $emailstatus{'logout_'.$ENV{'request.course.id'}}; |
$self->{LAST_CHECK} = ($courseLeaveTime > $logoutTime ? |
$self->{LAST_CHECK} = ($courseLeaveTime < $logoutTime ? |
$courseLeaveTime : $logoutTime); |
$courseLeaveTime : $logoutTime); |
my %discussiontime = &Apache::lonnet::dump('discussiontimes', |
my %discussiontime = &Apache::lonnet::dump('discussiontimes', |
$cdom, $cnum); |
$cdom, $cnum); |
Line 1019 sub init {
|
Line 1117 sub init {
|
$self->{PARM_CACHE} = {}; |
$self->{PARM_CACHE} = {}; |
} |
} |
|
|
|
# Internal function: Takes a key to look up in the nav hash and implements internal |
|
# memory caching of that key. |
|
sub navhash { |
|
my $self = shift; my $key = shift; |
|
return $self->{NAV_HASH}->{$key}; |
|
} |
|
|
# Checks to see if coursemap is defined, matching test in old lonnavmaps |
# Checks to see if coursemap is defined, matching test in old lonnavmaps |
sub courseMapDefined { |
sub courseMapDefined { |
my $self = shift; |
my $self = shift; |
my $uri = &Apache::lonnet::clutter($ENV{'request.course.uri'}); |
my $uri = &Apache::lonnet::clutter($ENV{'request.course.uri'}); |
|
|
my $firstres = $self->{NAV_HASH}->{"map_start_$uri"}; |
my $firstres = $self->navhash("map_start_$uri"); |
my $lastres = $self->{NAV_HASH}->{"map_finish_$uri"}; |
my $lastres = $self->navhash("map_finish_$uri"); |
return $firstres && $lastres; |
return $firstres && $lastres; |
} |
} |
|
|
Line 1050 sub DESTROY {
|
Line 1155 sub DESTROY {
|
$self->untieHashes(); |
$self->untieHashes(); |
} |
} |
|
|
# Private function: Does the given resource (as a symb string) have |
# Does the given resource (as a symb string) have |
# current discussion? Returns 0 if chat/mail data not extracted. |
# current discussion? Returns 0 if chat/mail data not extracted. |
sub hasDiscussion { |
sub hasDiscussion { |
my $self = shift; |
my $self = shift; |
my $symb = shift; |
my $symb = shift; |
if (!defined($self->{DISCUSSION_TIME})) { return 0; } |
if (!defined($self->{DISCUSSION_TIME})) { return 0; } |
|
|
|
#return defined($self->{DISCUSSION_TIME}->{$symb}); |
return $self->{DISCUSSION_TIME}->{$symb} > |
return $self->{DISCUSSION_TIME}->{$symb} > |
$self->{LAST_CHECK}; |
$self->{LAST_CHECK}; |
} |
} |
|
|
# Private function: Does the given resource (as a symb string) have |
# Does the given resource (as a symb string) have |
# current feedback? Returns the string in the feedback hash, which |
# current feedback? Returns the string in the feedback hash, which |
# will be false if it does not exist. |
# will be false if it does not exist. |
sub getFeedback { |
sub getFeedback { |
Line 1073 sub getFeedback {
|
Line 1179 sub getFeedback {
|
return $self->{FEEDBACK}->{$symb}; |
return $self->{FEEDBACK}->{$symb}; |
} |
} |
|
|
|
sub getErrors { |
|
my $self = shift; |
|
my $src = shift; |
|
|
|
if (!defined($self->{ERROR_MSG})) { return ""; } |
|
return $self->{ERROR_MSG}->{$src}; |
|
} |
|
|
=pod |
=pod |
|
|
=item * B<getById>(id): Based on the ID of the resource (1.1, 3.2, etc.), get a resource object for that resource. This method, or other methods that use it (as in the resource object) is the only proper way to obtain a resource object. |
=item * B<getById>(id): Based on the ID of the resource (1.1, 3.2, etc.), get a resource object for that resource. This method, or other methods that use it (as in the resource object) is the only proper way to obtain a resource object. |
Line 1105 sub getById {
|
Line 1219 sub getById {
|
|
|
sub firstResource { |
sub firstResource { |
my $self = shift; |
my $self = shift; |
my $firstResource = $self->{NAV_HASH}->{'map_start_' . |
my $firstResource = $self->navhash('map_start_' . |
&Apache::lonnet::clutter($ENV{'request.course.uri'})}; |
&Apache::lonnet::clutter($ENV{'request.course.uri'})); |
return $self->getById($firstResource); |
return $self->getById($firstResource); |
} |
} |
|
|
Line 1118 sub firstResource {
|
Line 1232 sub firstResource {
|
|
|
sub finishResource { |
sub finishResource { |
my $self = shift; |
my $self = shift; |
my $firstResource = $self->{NAV_HASH}->{'map_finish_' . |
my $firstResource = $self->navhash('map_finish_' . |
&Apache::lonnet::clutter($ENV{'request.course.uri'})}; |
&Apache::lonnet::clutter($ENV{'request.course.uri'})); |
return $self->getById($firstResource); |
return $self->getById($firstResource); |
} |
} |
|
|
Line 1246 getIterator behaves as follows:
|
Line 1360 getIterator behaves as follows:
|
|
|
=over 4 |
=over 4 |
|
|
=item * B<getIterator>(firstResource, finishResource, filterHash, condition): All parameters are optional. firstResource is a resource reference corresponding to where the iterator should start. It defaults to navmap->firstResource() for the corresponding nav map. finishResource corresponds to where you want the iterator to end, defaulting to navmap->finishResource(). filterHash is a hash used as a set containing strings representing the resource IDs, defaulting to empty. Condition is a 1 or 0 that sets what to do with the filter hash: If a 0, then only resource that exist IN the filterHash will be recursed on. If it is a 1, only resources NOT in the filterHash will be recursed on. Defaults to 0. |
=item * B<getIterator>(firstResource, finishResource, filterHash, condition, forceTop): All parameters are optional. firstResource is a resource reference corresponding to where the iterator should start. It defaults to navmap->firstResource() for the corresponding nav map. finishResource corresponds to where you want the iterator to end, defaulting to navmap->finishResource(). filterHash is a hash used as a set containing strings representing the resource IDs, defaulting to empty. Condition is a 1 or 0 that sets what to do with the filter hash: If a 0, then only resource that exist IN the filterHash will be recursed on. If it is a 1, only resources NOT in the filterHash will be recursed on. Defaults to 0. forceTop is a boolean value. If it is false (default), the iterator will only return the first level of map that is not just a single, 'redirecting' map. If true, the iterator will return all information, starting with the top-level map, regardless of content. |
|
|
Thus, by default, only top-level resources will be shown. Change the condition to a 1 without changing the hash, and all resources will be shown. Changing the condition to 1 and including some values in the hash will allow you to selectively suppress parts of the navmap, while leaving it on 0 and adding things to the hash will allow you to selectively add parts of the nav map. See the handler code for examples. |
Thus, by default, only top-level resources will be shown. Change the condition to a 1 without changing the hash, and all resources will be shown. Changing the condition to 1 and including some values in the hash will allow you to selectively suppress parts of the navmap, while leaving it on 0 and adding things to the hash will allow you to selectively add parts of the nav map. See the handler code for examples. |
|
|
Line 1266 The iterator will return either a refere
|
Line 1380 The iterator will return either a refere
|
|
|
The tokens are retreivable via methods on the iterator object, i.e., $iterator->END_MAP. |
The tokens are retreivable via methods on the iterator object, i.e., $iterator->END_MAP. |
|
|
|
Maps can contain empty resources. The iterator will automatically skip over such resources, but will still treat the structure correctly. Thus, a complicated map with several branches, but consisting entirely of empty resources except for one beginning or ending resource, will cause a lot of BRANCH_STARTs and BRANCH_ENDs, but only one resource will be returned. |
|
|
=back |
=back |
|
|
=cut |
=cut |
Line 1284 sub min {
|
Line 1400 sub min {
|
if ($a < $b) { return $a; } else { return $b; } |
if ($a < $b) { return $a; } else { return $b; } |
} |
} |
|
|
|
# In the CVS repository, documentation of this algorithm is included |
|
# in /doc/lonnavdocs, as a PDF and .tex source. Markers like **1** |
|
# will reference the same location in the text as the part of the |
|
# algorithm is running through. |
|
|
sub new { |
sub new { |
# magic invocation to create a class instance |
# magic invocation to create a class instance |
my $proto = shift; |
my $proto = shift; |
Line 1311 sub new {
|
Line 1432 sub new {
|
if (!defined($self->{ALREADY_SEEN})) { $self->{ALREADY_SEEN} = {} }; |
if (!defined($self->{ALREADY_SEEN})) { $self->{ALREADY_SEEN} = {} }; |
$self->{CONDITION} = shift; |
$self->{CONDITION} = shift; |
|
|
|
# Do we want to automatically follow "redirection" maps? |
|
$self->{FORCE_TOP} = shift; |
|
|
# Now, we need to pre-process the map, by walking forward and backward |
# Now, we need to pre-process the map, by walking forward and backward |
# over the parts of the map we're going to look at. |
# over the parts of the map we're going to look at. |
|
|
Line 1326 sub new {
|
Line 1450 sub new {
|
|
|
my $maxDepth = 0; # tracks max depth |
my $maxDepth = 0; # tracks max depth |
|
|
|
# If there is only one resource in this map, and it's a map, we |
|
# want to remember that, so the user can ask for the first map |
|
# that isn't just a redirector. |
|
my $resource; my $resourceCount = 0; |
|
|
|
# **1** |
|
|
foreach my $pass (@iterations) { |
foreach my $pass (@iterations) { |
my $direction = $pass->[0]; |
my $direction = $pass->[0]; |
my $valName = $pass->[1]; |
my $valName = $pass->[1]; |
Line 1347 sub new {
|
Line 1478 sub new {
|
if ($curRes == $iterator->END_MAP()) { $depth--; } |
if ($curRes == $iterator->END_MAP()) { $depth--; } |
|
|
if (ref($curRes)) { |
if (ref($curRes)) { |
|
# If there's only one resource, this will save it |
|
# we have to filter empty resources from consideration here, |
|
# or even "empty", redirecting maps have two (start & finish) |
|
# or three (start, finish, plus redirector) |
|
if($direction == FORWARD && $curRes->src()) { |
|
$resource = $curRes; $resourceCount++; |
|
} |
my $resultingVal = $curRes->{DATA}->{$valName}; |
my $resultingVal = $curRes->{DATA}->{$valName}; |
my $nextResources = $curRes->$nextResourceMethod(); |
my $nextResources = $curRes->$nextResourceMethod(); |
my $resourceCount = scalar(@{$nextResources}); |
my $nextCount = scalar(@{$nextResources}); |
|
|
if ($resourceCount == 1) { |
if ($nextCount == 1) { # **3** |
my $current = $nextResources->[0]->{DATA}->{$valName} || 999999999; |
my $current = $nextResources->[0]->{DATA}->{$valName} || 999999999; |
$nextResources->[0]->{DATA}->{$valName} = min($resultingVal, $current); |
$nextResources->[0]->{DATA}->{$valName} = min($resultingVal, $current); |
} |
} |
|
|
if ($resourceCount > 1) { |
if ($nextCount > 1) { # **4** |
foreach my $res (@{$nextResources}) { |
foreach my $res (@{$nextResources}) { |
my $current = $res->{DATA}->{$valName} || 999999999; |
my $current = $res->{DATA}->{$valName} || 999999999; |
$res->{DATA}->{$valName} = min($current, $resultingVal + 1); |
$res->{DATA}->{$valName} = min($current, $resultingVal + 1); |
Line 1364 sub new {
|
Line 1502 sub new {
|
} |
} |
} |
} |
|
|
# Assign the final val |
# Assign the final val (**2**) |
if (ref($curRes) && $direction == BACKWARD()) { |
if (ref($curRes) && $direction == BACKWARD()) { |
my $finalDepth = min($curRes->{DATA}->{TOP_DOWN_VAL}, |
my $finalDepth = min($curRes->{DATA}->{TOP_DOWN_VAL}, |
$curRes->{DATA}->{BOT_UP_VAL}); |
$curRes->{DATA}->{BOT_UP_VAL}); |
Line 1376 sub new {
|
Line 1514 sub new {
|
} |
} |
} |
} |
|
|
|
# Check: Was this only one resource, a map? |
|
if ($resourceCount == 1 && $resource->is_map() && !$self->{FORCE_TOP}) { |
|
my $firstResource = $resource->map_start(); |
|
my $finishResource = $resource->map_finish(); |
|
return |
|
Apache::lonnavmaps::iterator->new($self->{NAV_MAP}, $firstResource, |
|
$finishResource, $self->{FILTER}, |
|
$self->{ALREADY_SEEN}, |
|
$self->{CONDITION}, 0); |
|
|
|
} |
|
|
# Set up some bookkeeping information. |
# Set up some bookkeeping information. |
$self->{CURRENT_DEPTH} = 0; |
$self->{CURRENT_DEPTH} = 0; |
$self->{MAX_DEPTH} = $maxDepth; |
$self->{MAX_DEPTH} = $maxDepth; |
Line 1386 sub new {
|
Line 1536 sub new {
|
push @{$self->{STACK}}, []; |
push @{$self->{STACK}}, []; |
} |
} |
|
|
# Prime the recursion w/ the first resource |
# Prime the recursion w/ the first resource **5** |
push @{$self->{STACK}->[0]}, $self->{FIRST_RESOURCE}; |
push @{$self->{STACK}->[0]}, $self->{FIRST_RESOURCE}; |
$self->{ALREADY_SEEN}->{$self->{FIRST_RESOURCE}->{ID}} = 1; |
$self->{ALREADY_SEEN}->{$self->{FIRST_RESOURCE}->{ID}} = 1; |
|
|
Line 1435 sub next {
|
Line 1585 sub next {
|
my $newDepth; |
my $newDepth; |
my $here; |
my $here; |
while ( $i >= 0 && !$found ) { |
while ( $i >= 0 && !$found ) { |
if ( scalar(@{$self->{STACK}->[$i]}) > 0 ) { |
if ( scalar(@{$self->{STACK}->[$i]}) > 0 ) { # **6** |
$here = pop @{$self->{STACK}->[$i]}; |
$here = pop @{$self->{STACK}->[$i]}; # **7** |
$found = 1; |
$found = 1; |
$newDepth = $i; |
$newDepth = $i; |
} |
} |
Line 1456 sub next {
|
Line 1606 sub next {
|
|
|
# If this is not a resource, it must be an END_BRANCH marker we want |
# If this is not a resource, it must be an END_BRANCH marker we want |
# to return directly. |
# to return directly. |
if (!ref($here)) { |
if (!ref($here)) { # **8** |
if ($here == END_BRANCH()) { # paranoia, in case of later extension |
if ($here == END_BRANCH()) { # paranoia, in case of later extension |
$self->{CURRENT_DEPTH}--; |
$self->{CURRENT_DEPTH}--; |
return $here; |
return $here; |
Line 1503 sub next {
|
Line 1653 sub next {
|
# BC branch and gets to C, it will see F as the only next resource, but it's |
# BC branch and gets to C, it will see F as the only next resource, but it's |
# one level lower. Thus, this is the end of the branch, since there are no |
# one level lower. Thus, this is the end of the branch, since there are no |
# more resources added to this level or above. |
# more resources added to this level or above. |
|
# We don't do this if the examined resource is the finish resource, |
|
# because the condition given above is true, but the "END_MAP" will |
|
# take care of things and we should already be at depth 0. |
my $isEndOfBranch = $maxDepthAdded < $self->{CURRENT_DEPTH}; |
my $isEndOfBranch = $maxDepthAdded < $self->{CURRENT_DEPTH}; |
if ($isEndOfBranch) { |
if ($isEndOfBranch && $here != $self->{FINISH_RESOURCE}) { # **9** |
push @{$self->{STACK}->[$self->{CURRENT_DEPTH}]}, END_BRANCH(); |
push @{$self->{STACK}->[$self->{CURRENT_DEPTH}]}, END_BRANCH(); |
} |
} |
|
|
Line 1522 sub next {
|
Line 1675 sub next {
|
$self->{ALREADY_SEEN}, $self->{CONDITION}); |
$self->{ALREADY_SEEN}, $self->{CONDITION}); |
} |
} |
|
|
|
# If this is a blank resource, don't actually return it. |
|
# Should you ever find you need it, make sure to add an option to the code |
|
# that you can use; other things depend on this behavior. |
|
if (!$self->{HERE}->src()) { |
|
return $self->next(); |
|
} |
|
|
return $self->{HERE}; |
return $self->{HERE}; |
|
|
} |
} |
Line 1568 package Apache::lonnavmaps::DFSiterator;
|
Line 1728 package Apache::lonnavmaps::DFSiterator;
|
# but this might as well be left seperate, since it is possible some other |
# but this might as well be left seperate, since it is possible some other |
# use might be found for it. - Jeremy |
# use might be found for it. - Jeremy |
|
|
|
# Unlike the main iterator, this DOES return all resources, even blank ones. |
|
# The main iterator needs them to correctly preprocess the map. |
|
|
sub BEGIN_MAP { return 1; } # begining of a new map |
sub BEGIN_MAP { return 1; } # begining of a new map |
sub END_MAP { return 2; } # end of the map |
sub END_MAP { return 2; } # end of the map |
sub FORWARD { return 1; } # go forward |
sub FORWARD { return 1; } # go forward |
Line 1768 sub navHash {
|
Line 1931 sub navHash {
|
my $self = shift; |
my $self = shift; |
my $param = shift; |
my $param = shift; |
my $id = shift; |
my $id = shift; |
return $self->{NAV_MAP}->{NAV_HASH}->{$param . ($id?$self->{ID}:"")}; |
return $self->{NAV_MAP}->navhash($param . ($id?$self->{ID}:"")); |
} |
} |
|
|
=pod |
=pod |
Line 1998 sub answerdate {
|
Line 2161 sub answerdate {
|
} |
} |
return $self->parmval("answerdate", $part); |
return $self->parmval("answerdate", $part); |
} |
} |
sub awarded { |
sub awarded { my $self = shift; return $self->queryRestoreHash('awarded', shift); } |
(my $self, my $part) = @_; |
|
return $self->parmval("awarded", $part); |
|
} |
|
sub duedate { |
sub duedate { |
(my $self, my $part) = @_; |
(my $self, my $part) = @_; |
return $self->parmval("duedate", $part); |
return $self->parmval("duedate", $part); |
Line 2026 sub tol {
|
Line 2186 sub tol {
|
(my $self, my $part) = @_; |
(my $self, my $part) = @_; |
return $self->parmval("tol", $part); |
return $self->parmval("tol", $part); |
} |
} |
sub tries { |
sub tries { |
my $self = shift; |
my $self = shift; |
my $part = shift; |
my $tries = $self->queryRestoreHash('tries', shift); |
$part = '0' if (!defined($part)); |
if (!defined($tries)) { return '0';} |
|
|
# Make sure return hash is loaded, should error check |
|
$self->getReturnHash(); |
|
|
|
my $tries = $self->{RETURN_HASH}->{'resource.'.$part.'.tries'}; |
|
if (!defined($tries)) {return '0';} |
|
return $tries; |
return $tries; |
} |
} |
sub type { |
sub type { |
(my $self, my $part) = @_; |
(my $self, my $part) = @_; |
return $self->parmval("type", $part); |
return $self->parmval("type", $part); |
} |
} |
sub weight { |
sub weight { |
(my $self, my $part) = @_; |
my $self = shift; my $part = shift; |
return $self->parmval("weight", $part); |
return $self->parmval("weight", $part); |
} |
} |
|
|
Line 2098 sub hasDiscussion {
|
Line 2252 sub hasDiscussion {
|
|
|
sub getFeedback { |
sub getFeedback { |
my $self = shift; |
my $self = shift; |
return $self->{NAV_MAP}->getFeedback($self->src()); |
my $source = $self->src(); |
|
if ($source !~ /^\/res\//) { $source = substr $source, 5; } |
|
return $self->{NAV_MAP}->getFeedback($source); |
|
} |
|
|
|
sub getErrors { |
|
my $self = shift; |
|
my $source = $self->src(); |
|
if ($source =~ /^\/res\//) { $source = substr $source, 5; } |
|
return $self->{NAV_MAP}->getErrors($source); |
} |
} |
|
|
=pod |
=pod |
Line 2305 sub ATTEMPTED { return 16; }
|
Line 2468 sub ATTEMPTED { return 16; }
|
|
|
sub getCompletionStatus { |
sub getCompletionStatus { |
my $self = shift; |
my $self = shift; |
my $part = shift; |
|
$part = "0" if (!defined($part)); |
|
return $self->NETWORK_FAILURE if ($self->{NAV_MAP}->{NETWORK_FAILURE}); |
return $self->NETWORK_FAILURE if ($self->{NAV_MAP}->{NETWORK_FAILURE}); |
|
|
# Make sure return hash exists |
my $status = $self->queryRestoreHash('solved', shift); |
$self->getReturnHash(); |
|
|
|
my $status = $self->{RETURN_HASH}->{'resource.'.$part.'.solved'}; |
|
|
|
# Left as seperate if statements in case we ever do more with this |
# Left as seperate if statements in case we ever do more with this |
if ($status eq 'correct_by_student') {return $self->CORRECT;} |
if ($status eq 'correct_by_student') {return $self->CORRECT;} |
Line 2324 sub getCompletionStatus {
|
Line 2482 sub getCompletionStatus {
|
return $self->NOT_ATTEMPTED; |
return $self->NOT_ATTEMPTED; |
} |
} |
|
|
|
sub queryRestoreHash { |
|
my $self = shift; |
|
my $hashentry = shift; |
|
my $part = shift; |
|
$part = "0" if (!defined($part)); |
|
return $self->NETWORK_FAILURE if ($self->{NAV_MAP}->{NETWORK_FAILURE}); |
|
|
|
$self->getReturnHash(); |
|
|
|
return $self->{RETURN_HASH}->{'resource.'.$part.'.'.$hashentry}; |
|
} |
|
|
=pod |
=pod |
|
|
B<Composite Status> |
B<Composite Status> |
Line 2449 sub getNext {
|
Line 2619 sub getNext {
|
|
|
# Don't remember it if the student doesn't have browse priviledges |
# Don't remember it if the student doesn't have browse priviledges |
# future note: this may properly belong in the client of the resource |
# future note: this may properly belong in the client of the resource |
my $browsePriv = &Apache::lonnet::allowed('bre', $self->src); |
my $browsePriv = $self->{BROWSE_PRIV}; |
|
if (!defined($browsePriv)) { |
|
$browsePriv = &Apache::lonnet::allowed('bre', $self->src); |
|
$self->{BROWSE_PRIV} = $browsePriv; |
|
} |
if (!($browsePriv ne '2' && $browsePriv ne 'F')) { |
if (!($browsePriv ne '2' && $browsePriv ne 'F')) { |
push @branches, $next; |
push @branches, $next; |
} |
} |
Line 2468 sub getPrevious {
|
Line 2642 sub getPrevious {
|
|
|
# Don't remember it if the student doesn't have browse priviledges |
# Don't remember it if the student doesn't have browse priviledges |
# future note: this may properly belong in the client of the resource |
# future note: this may properly belong in the client of the resource |
my $browsePriv = &Apache::lonnet::allowed('bre', $self->src); |
my $browsePriv = $self->{BROWSE_PRIV}; |
|
if (!defined($browsePriv)) { |
|
$browsePriv = &Apache::lonnet::allowed('bre', $self->src); |
|
$self->{BROWSE_PRIV} = $browsePriv; |
|
} |
if (!($browsePriv ne '2' && $browsePriv ne 'F')) { |
if (!($browsePriv ne '2' && $browsePriv ne 'F')) { |
push @branches, $prev; |
push @branches, $prev; |
} |
} |