loncom/interface/lonnavmaps.pm - diff

Return to lonnavmaps.pm CVS log

Up to [LON-CAPA] / loncom / interface

Diff for /loncom/interface/lonnavmaps.pm between versions 1.220 and 1.224

version 1.220, 2003/08/07 14:29:43	version 1.224, 2003/09/08 19:53:09
Line 61 my $resObj = "Apache::lonnavmaps::resour	Line 61 my $resObj = "Apache::lonnavmaps::resour
# Keep these mappings in sync with lonquickgrades, which uses the colors	# Keep these mappings in sync with lonquickgrades, which uses the colors
# instead of the icons.	# instead of the icons.
my %statusIconMap =	my %statusIconMap =
( $resObj->NETWORK_FAILURE => '',	(
$resObj->NOTHING_SET => '',	$resObj->CLOSED => '',
$resObj->CORRECT => 'navmap.correct.gif',	$resObj->OPEN => 'navmap.open.gif',
$resObj->EXCUSED => 'navmap.correct.gif',	$resObj->CORRECT => 'navmap.correct.gif',
$resObj->PAST_DUE_NO_ANSWER => 'navmap.wrong.gif',	$resObj->INCORRECT => 'navmap.wrong.gif',
$resObj->PAST_DUE_ANSWER_LATER => 'navmap.wrong.gif',	$resObj->ATTEMPTED => 'navmap.ellipsis.gif',
$resObj->ANSWER_OPEN => 'navmap.wrong.gif',	$resObj->ERROR => ''
$resObj->OPEN_LATER => '',	);
$resObj->TRIES_LEFT => 'navmap.open.gif',
$resObj->INCORRECT => 'navmap.wrong.gif',
$resObj->OPEN => 'navmap.open.gif',
$resObj->ATTEMPTED => 'navmap.ellipsis.gif',
$resObj->ANSWER_SUBMITTED => 'navmap.ellipsis.gif' );

my %iconAltTags =	my %iconAltTags =
( 'navmap.correct.gif' => 'Correct',	( 'navmap.correct.gif' => 'Correct',
Line 129 sub real_handler {	Line 124 sub real_handler {
$r->send_http_header;	$r->send_http_header;

# Create the nav map	# Create the nav map
my $navmap = Apache::lonnavmaps::navmap->new(1, 1);	my $navmap = Apache::lonnavmaps::navmap->new();


if (!defined($navmap)) {	if (!defined($navmap)) {
Line 159 sub real_handler {	Line 154 sub real_handler {

$r->rflush();	$r->rflush();

# Now that we've displayed some stuff to the user, init the navmap
$navmap->init();

$r->rflush();

# 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 173 sub real_handler {	Line 163 sub real_handler {

# See if there's only one map in the top-level, if we don't	# See if there's only one map in the top-level, if we don't
# already have a filter... if so, automatically display it	# already have a filter... if so, automatically display it
	# (older code; should use retrieveResources)
if ($ENV{QUERY_STRING} !~ /filter/) {	if ($ENV{QUERY_STRING} !~ /filter/) {
my $iterator = $navmap->getIterator(undef, undef, undef, 0);	my $iterator = $navmap->getIterator(undef, undef, undef, 0);
my $depth = 1;	my $curRes;
$iterator->next();
my $curRes = $iterator->next();
my $sequenceCount = 0;	my $sequenceCount = 0;
my $sequenceId;	my $sequenceId;
while ($depth > 0) {	while ($curRes = $iterator->next()) {
if ($curRes == $iterator->BEGIN_MAP()) { $depth++; }
if ($curRes == $iterator->END_MAP()) { $depth--; }

if (ref($curRes) && $curRes->is_sequence()) {	if (ref($curRes) && $curRes->is_sequence()) {
$sequenceCount++;	$sequenceCount++;
$sequenceId = $curRes->map_pc();	$sequenceId = $curRes->map_pc();
}	}

$curRes = $iterator->next();
}	}

if ($sequenceCount == 1) {	if ($sequenceCount == 1) {
Line 207 sub real_handler {	Line 191 sub real_handler {
$jumpToFirstHomework = 1;	$jumpToFirstHomework = 1;
# Find the next homework problem that they can do.	# Find the next homework problem that they can do.
my $iterator = $navmap->getIterator(undef, undef, undef, 1);	my $iterator = $navmap->getIterator(undef, undef, undef, 1);
my $depth = 1;	my $curRes;
$iterator->next();
my $curRes = $iterator->next();
my $foundDoableProblem = 0;	my $foundDoableProblem = 0;
my $problemRes;	my $problemRes;

while ($depth > 0 && !$foundDoableProblem) {	while (($curRes = $iterator->next()) && !$foundDoableProblem) {
if ($curRes == $iterator->BEGIN_MAP()) { $depth++; }
if ($curRes == $iterator->END_MAP()) { $depth--; }

if (ref($curRes) && $curRes->is_problem()) {	if (ref($curRes) && $curRes->is_problem()) {
my $status = $curRes->status();	my $status = $curRes->status();
if ($curRes->completable()) {	if ($curRes->completable()) {
Line 234 sub real_handler {	Line 213 sub real_handler {
$ENV{'form.postsymb'} = $curRes->symb();	$ENV{'form.postsymb'} = $curRes->symb();
}	}
}	}
} continue {
$curRes = $iterator->next();
}	}

# If we found no problems, print a note to that effect.	# If we found no problems, print a note to that effect.
Line 1054 sub render_quick_status {	Line 1031 sub render_quick_status {

if ($resource->is_problem() &&	if ($resource->is_problem() &&
!$firstDisplayed) {	!$firstDisplayed) {
my $icon = $statusIconMap{$resource->status($part)};
	my $icon = $statusIconMap{$resource->simpleStatus($part)};
my $alt = $iconAltTags{$icon};	my $alt = $iconAltTags{$icon};
if ($icon) {	if ($icon) {
$result .= "<td width='30' valign='center' width='50' align='right'>$linkopen<img width='25' height='25' src='/adm/lonIcons/$icon' border='0' alt='$alt' />$linkclose</td>\n";	$result .= "<td width='30' valign='center' width='50' align='right'>$linkopen<img width='25' height='25' src='/adm/lonIcons/$icon' border='0' alt='$alt' />$linkclose</td>\n";
Line 1170 sub render {	Line 1148 sub render {
if (!$ENV{'form.folderManip'} && !defined($args->{'iterator'})) {	if (!$ENV{'form.folderManip'} && !defined($args->{'iterator'})) {
# Step 1: Check to see if we have a navmap	# Step 1: Check to see if we have a navmap
if (!defined($navmap)) {	if (!defined($navmap)) {
$navmap = Apache::lonnavmaps::navmap->new(1, 1);	$navmap = Apache::lonnavmaps::navmap->new();
$mustCloseNavMap = 1;	$mustCloseNavMap = 1;
}	}
$navmap->init();

# Step two: Locate what kind of here marker is necessary	# Step two: Locate what kind of here marker is necessary
# Determine where the "here" marker is and where the screen jumps to.	# Determine where the "here" marker is and where the screen jumps to.
Line 1191 sub render {	Line 1168 sub render {

# Step three: Ensure the folders are open	# Step three: Ensure the folders are open
my $mapIterator = $navmap->getIterator(undef, undef, undef, 1);	my $mapIterator = $navmap->getIterator(undef, undef, undef, 1);
my $depth = 1;	my $curRes;
$mapIterator->next(); # discard the first BEGIN_MAP
my $curRes = $mapIterator->next();
my $found = 0;	my $found = 0;

# We only need to do this if we need to open the maps to show the	# 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	# current position. This will change the counter so we can't count
# for the jump marker with this loop.	# for the jump marker with this loop.
while ($depth > 0 && !$found) {	while (($curRes = $mapIterator->next()) && !$found) {
if ($curRes == $mapIterator->BEGIN_MAP()) { $depth++; }
if ($curRes == $mapIterator->END_MAP()) { $depth--; }

if (ref($curRes) && $curRes->symb() eq $here) {	if (ref($curRes) && $curRes->symb() eq $here) {
my $mapStack = $mapIterator->getStack();	my $mapStack = $mapIterator->getStack();

Line 1216 sub render {	Line 1188 sub render {
}	}
$found = 1;	$found = 1;
}	}

$curRes = $mapIterator->next();
}	}
}	}

Line 1234 sub render {	Line 1204 sub render {

# Step 1: Check to see if we have a navmap	# Step 1: Check to see if we have a navmap
if (!defined($navmap)) {	if (!defined($navmap)) {
$navmap = Apache::lonnavmaps::navmap->new(1, 1);	$navmap = Apache::lonnavmaps::navmap->new();
$mustCloseNavMap = 1;	$mustCloseNavMap = 1;
}	}
# Paranoia: Make sure it's ready
$navmap->init();

# See if we're being passed a specific map	# See if we're being passed a specific map
if ($args->{'iterator_map'}) {	if ($args->{'iterator_map'}) {
Line 1257 sub render {	Line 1225 sub render {
# Note this does not take filtering or hidden into account... need	# Note this does not take filtering or hidden into account... need
# to be fixed?	# to be fixed?
my $mapIterator = $navmap->getIterator(undef, undef, $filterHash, 0);	my $mapIterator = $navmap->getIterator(undef, undef, $filterHash, 0);
my $depth = 1;	my $curRes;
$mapIterator->next();
my $curRes = $mapIterator->next();
my $foundJump = 0;	my $foundJump = 0;
my $counter = 0;	my $counter = 0;

while ($depth > 0 && !$foundJump) {	while (($curRes = $mapIterator->next()) && !$foundJump) {
if ($curRes == $mapIterator->BEGIN_MAP()) { $depth++; }
if ($curRes == $mapIterator->END_MAP()) { $depth--; }
if (ref($curRes)) { $counter++; }	if (ref($curRes)) { $counter++; }

if (ref($curRes) && $jump eq $curRes->symb()) {	if (ref($curRes) && $jump eq $curRes->symb()) {
Line 1276 sub render {	Line 1240 sub render {
$args->{'currentJumpIndex'} = $counter;	$args->{'currentJumpIndex'} = $counter;
$foundJump = 1;	$foundJump = 1;
}	}

$curRes = $mapIterator->next();
}	}

my $showParts = setDefault($args->{'showParts'}, 1);	my $showParts = setDefault($args->{'showParts'}, 1);
Line 1355 sub render {	Line 1317 sub render {
$it->{FIRST_RESOURCE},	$it->{FIRST_RESOURCE},
$it->{FINISH_RESOURCE},	$it->{FINISH_RESOURCE},
{}, undef, 1);	{}, undef, 1);
$depth = 0;	my $depth = 0;
$dfsit->next();	$dfsit->next();
my $curRes = $dfsit->next();	my $curRes = $dfsit->next();
while ($depth > -1) {	while ($depth > -1) {
Line 1387 sub render {	Line 1349 sub render {

my $displayedJumpMarker = 0;	my $displayedJumpMarker = 0;
# Set up iteration.	# Set up iteration.
$depth = 1;
$it->next(); # discard initial BEGIN_MAP
$curRes = $it->next();
my $now = time();	my $now = time();
my $in24Hours = $now + 24 * 60 * 60;	my $in24Hours = $now + 24 * 60 * 60;
my $rownum = 0;	my $rownum = 0;
Line 1397 sub render {	Line 1356 sub render {
# export "here" marker information	# export "here" marker information
$args->{'here'} = $here;	$args->{'here'} = $here;

while ($depth > 0) {	$args->{'indentLevel'} = -1; # first BEGIN_MAP takes this to 0
if ($curRes == $it->BEGIN_MAP()) { $depth++; }	while ($curRes = $it->next()) {
if ($curRes == $it->END_MAP()) { $depth--; }

# Maintain indentation level.	# Maintain indentation level.
if ($curRes == $it->BEGIN_MAP() \|\|	if ($curRes == $it->BEGIN_MAP() \|\|
$curRes == $it->BEGIN_BRANCH() ) {	$curRes == $it->BEGIN_BRANCH() ) {
Line 1553 sub render {	Line 1510 sub render {
$r->rflush();	$r->rflush();
}	}
} continue {	} continue {
$curRes = $it->next();

if ($r) {	if ($r) {
# If we have the connection, make sure the user is still connected	# If we have the connection, make sure the user is still connected
my $c = $r->connection;	my $c = $r->connection;
Line 1640 To create a navmap object, use the follo	Line 1595 To create a navmap object, use the follo

=over 4	=over 4

=item * B<Apache::lonnavmaps::navmap-E<gt>new>(	=item * B<Apache::lonnavmaps::navmap-E<gt>new>():
genCourseAndUserOptions, genMailDiscussStatus, getUserData):

Creates a new navmap object. genCourseAndUserOptions is a flag saying whether	Creates a new navmap object. Returns the navmap object if this is
the course options and user options hash should be generated. This is	successful, or B<undef> if not.
for when you are using the parameters of the resources that require
them; see documentation in resource object
documentation. genMailDiscussStatus causes the nav map to retreive
information about the email and discussion status of
resources. Returns the navmap object if this is successful, or
B<undef> if not. You must check for undef; errors will occur when you
try to use the other methods otherwise. getUserData, if true, will
retreive the user's performance data for various problems.

=back	=back

Once you have the $navmap object, call ->init() on it when you are ready
to use it. This allows you to check if the course map is defined (see
B<courseMapDefined> below) before engaging in potentially expensive
initialization routines for the genCourseAndUserOptions and
genMailDiscussStatus option.

When you are done with the $navmap object, you I<must> call	When you are done with the $navmap object, you I<must> call
$navmap->untieHashes(), or you'll prevent the current user from using that	$navmap->untieHashes(), or you'll prevent the current user from using that
course until the web server is restarted. (!)	course until the web server is restarted. (!)
Line 1685 sub new {	Line 1625 sub new {
my $class = ref($proto) \|\| $proto;	my $class = ref($proto) \|\| $proto;
my $self = {};	my $self = {};

$self->{GENERATE_COURSE_USER_OPT} = shift;
$self->{GENERATE_EMAIL_DISCUSS_STATUS} = shift;
$self->{GET_USER_DATA} = shift;

# Resource cache stores navmap resources as we reference them. We generate	# Resource cache stores navmap resources as we reference them. We generate
# them on-demand so we don't pay for creating resources unless we use them.	# them on-demand so we don't pay for creating resources unless we use them.
$self->{RESOURCE_CACHE} = {};	$self->{RESOURCE_CACHE} = {};
Line 1716 sub new {	Line 1652 sub new {

$self->{NAV_HASH} = \%navmaphash;	$self->{NAV_HASH} = \%navmaphash;
$self->{PARM_HASH} = \%parmhash;	$self->{PARM_HASH} = \%parmhash;
$self->{INITED} = 0;	$self->{PARM_CACHE} = {};

bless($self);	bless($self);

return $self;	return $self;
}	}

sub init {	sub generate_course_user_opt {
my $self = shift;	my $self = shift;
if ($self->{INITED}) { return; }	if ($self->{COURSE_USER_OPT_GENERATED}) { return; }

# If the course opt hash and the user opt hash should be generated,	my $uname=$ENV{'user.name'};
# generate them	my $udom=$ENV{'user.domain'};
if ($self->{GENERATE_COURSE_USER_OPT}) {	my $uhome=$ENV{'user.home'};
my $uname=$ENV{'user.name'};	my $cid=$ENV{'request.course.id'};
my $udom=$ENV{'user.domain'};	my $chome=$ENV{'course.'.$cid.'.home'};
my $uhome=$ENV{'user.home'};	my ($cdom,$cnum)=split(/\_/,$cid);
my $cid=$ENV{'request.course.id'};
my $chome=$ENV{'course.'.$cid.'.home'};	my $userprefix=$uname.'_'.$udom.'_';
my ($cdom,$cnum)=split(/\_/,$cid);
	my %courserdatas; my %useropt; my %courseopt; my %userrdatas;
my $userprefix=$uname.'_'.$udom.'_';	unless ($uhome eq 'no_host') {

my %courserdatas; my %useropt; my %courseopt; my %userrdatas;
unless ($uhome eq 'no_host') {
# ------------------------------------------------- Get coursedata (if present)	# ------------------------------------------------- Get coursedata (if present)
unless ((time-$courserdatas{$cid.'.last_cache'})<240) {	unless ((time-$courserdatas{$cid.'.last_cache'})<240) {
my $reply=&Apache::lonnet::reply('dump:'.$cdom.':'.$cnum.	my $reply=&Apache::lonnet::reply('dump:'.$cdom.':'.$cnum.
':resourcedata',$chome);	':resourcedata',$chome);
# Check for network failure	# Check for network failure
if ( $reply =~ /no.such.host/i \|\| $reply =~ /con_lost/i) {	if ( $reply =~ /no.such.host/i \|\| $reply =~ /con_lost/i) {
$self->{NETWORK_FAILURE} = 1;	$self->{NETWORK_FAILURE} = 1;
} elsif ($reply!~/^error\:/) {	} elsif ($reply!~/^error\:/) {
$courserdatas{$cid}=$reply;	$courserdatas{$cid}=$reply;
$courserdatas{$cid.'.last_cache'}=time;	$courserdatas{$cid.'.last_cache'}=time;
}	}
}	}
foreach (split(/\&/,$courserdatas{$cid})) {	foreach (split(/\&/,$courserdatas{$cid})) {
my ($name,$value)=split(/\=/,$_);	my ($name,$value)=split(/\=/,$_);
$courseopt{$userprefix.&Apache::lonnet::unescape($name)}=	$courseopt{$userprefix.&Apache::lonnet::unescape($name)}=
&Apache::lonnet::unescape($value);	&Apache::lonnet::unescape($value);
}	}
# --------------------------------------------------- Get userdata (if present)	# --------------------------------------------------- Get userdata (if present)
unless ((time-$userrdatas{$uname.'___'.$udom.'.last_cache'})<240) {	unless ((time-$userrdatas{$uname.'___'.$udom.'.last_cache'})<240) {
my $reply=&Apache::lonnet::reply('dump:'.$udom.':'.$uname.':resourcedata',$uhome);	my $reply=&Apache::lonnet::reply('dump:'.$udom.':'.$uname.':resourcedata',$uhome);
if ($reply!~/^error\:/) {	if ($reply!~/^error\:/) {
$userrdatas{$uname.'___'.$udom}=$reply;	$userrdatas{$uname.'___'.$udom}=$reply;
$userrdatas{$uname.'___'.$udom.'.last_cache'}=time;	$userrdatas{$uname.'___'.$udom.'.last_cache'}=time;
}	}
# check to see if network failed	# check to see if network failed
elsif ( $reply=~/no.such.host/i \|\| $reply=~/con.*lost/i )	elsif ( $reply=~/no.such.host/i \|\| $reply=~/con.*lost/i )
{	{
$self->{NETWORK_FAILURE} = 1;	$self->{NETWORK_FAILURE} = 1;
}	}
}	}
foreach (split(/\&/,$userrdatas{$uname.'___'.$udom})) {	foreach (split(/\&/,$userrdatas{$uname.'___'.$udom})) {
my ($name,$value)=split(/\=/,$_);	my ($name,$value)=split(/\=/,$_);
$useropt{$userprefix.&Apache::lonnet::unescape($name)}=	$useropt{$userprefix.&Apache::lonnet::unescape($name)}=
&Apache::lonnet::unescape($value);	&Apache::lonnet::unescape($value);
}	}
$self->{COURSE_OPT} = \%courseopt;	$self->{COURSE_OPT} = \%courseopt;
$self->{USER_OPT} = \%useropt;	$self->{USER_OPT} = \%useropt;
}
}

if ($self->{GENERATE_EMAIL_DISCUSS_STATUS}) {
my $cid=$ENV{'request.course.id'};
my ($cdom,$cnum)=split(/\_/,$cid);

my %emailstatus = &Apache::lonnet::dump('email_status');
my $logoutTime = $emailstatus{'logout'};
my $courseLeaveTime = $emailstatus{'logout_'.$ENV{'request.course.id'}};
$self->{LAST_CHECK} = (($courseLeaveTime > $logoutTime) ?
$courseLeaveTime : $logoutTime);
my %discussiontime = &Apache::lonnet::dump('discussiontimes',
$cdom, $cnum);
my %feedback=();
my %error=();
my $keys = &Apache::lonnet::reply('keys:'.
$ENV{'user.domain'}.':'.
$ENV{'user.name'}.':nohist_email',
$ENV{'user.home'});

foreach my $msgid (split(/\&/, $keys)) {
$msgid=&Apache::lonnet::unescape($msgid);
my $plain=&Apache::lonnet::unescape(&Apache::lonnet::unescape($msgid));
if ($plain=~/(Error\|Feedback) \[([^\]]+)\]/) {
my ($what,$url)=($1,$2);
my %status=
&Apache::lonnet::get('email_status',[$msgid]);
if ($status{$msgid}=~/^error\:/) {
$status{$msgid}='';
}

if (($status{$msgid} eq 'new') \|\|
(!$status{$msgid})) {
if ($what eq 'Error') {
$error{$url}.=','.$msgid;
} else {
$feedback{$url}.=','.$msgid;
}
}
}
}

$self->{FEEDBACK} = \%feedback;
$self->{ERROR_MSG} = \%error; # what is this? JB
$self->{DISCUSSION_TIME} = \%discussiontime;
$self->{EMAIL_STATUS} = \%emailstatus;

}	}

if ($self->{GET_USER_DATA}) {	$self->{COURSE_USER_OPT_GENERATED} = 1;
# Retreive performance data on problems
my %student_data = Apache::lonnet::currentdump($ENV{'request.course.id'},	return;
$ENV{'user.domain'},	}
$ENV{'user.name'});
$self->{STUDENT_DATA} = \%student_data;	sub generate_email_discuss_status {
	my $self = shift;
	if ($self->{EMAIL_DISCUSS_GENERATED}) { return; }

	my $cid=$ENV{'request.course.id'};
	my ($cdom,$cnum)=split(/\_/,$cid);

	my %emailstatus = &Apache::lonnet::dump('email_status');
	my $logoutTime = $emailstatus{'logout'};
	my $courseLeaveTime = $emailstatus{'logout_'.$ENV{'request.course.id'}};
	$self->{LAST_CHECK} = (($courseLeaveTime > $logoutTime) ?
	$courseLeaveTime : $logoutTime);
	my %discussiontime = &Apache::lonnet::dump('discussiontimes',
	$cdom, $cnum);
	my %feedback=();
	my %error=();
	my $keys = &Apache::lonnet::reply('keys:'.
	$ENV{'user.domain'}.':'.
	$ENV{'user.name'}.':nohist_email',
	$ENV{'user.home'});

	foreach my $msgid (split(/\&/, $keys)) {
	$msgid=&Apache::lonnet::unescape($msgid);
	my $plain=&Apache::lonnet::unescape(&Apache::lonnet::unescape($msgid));
	if ($plain=~/(Error\|Feedback) \[([^\]]+)\]/) {
	my ($what,$url)=($1,$2);
	my %status=
	&Apache::lonnet::get('email_status',[$msgid]);
	if ($status{$msgid}=~/^error\:/) {
	$status{$msgid}='';
	}

	if (($status{$msgid} eq 'new') \|\|
	(!$status{$msgid})) {
	if ($what eq 'Error') {
	$error{$url}.=','.$msgid;
	} else {
	$feedback{$url}.=','.$msgid;
	}
	}
	}
}	}

	$self->{FEEDBACK} = \%feedback;
	$self->{ERROR_MSG} = \%error; # what is this? JB
	$self->{DISCUSSION_TIME} = \%discussiontime;
	$self->{EMAIL_STATUS} = \%emailstatus;

	$self->{EMAIL_DISCUSS_GENERATED} = 1;
	}

$self->{PARM_CACHE} = {};	sub get_user_data {
$self->{INITED} = 1;	my $self = shift;
	if ($self->{RETRIEVED_USER_DATA}) { return; }

	# Retrieve performance data on problems
	my %student_data = Apache::lonnet::currentdump($ENV{'request.course.id'},
	$ENV{'user.domain'},
	$ENV{'user.name'});
	$self->{STUDENT_DATA} = \%student_data;

	$self->{RETRIEVED_USER_DATA} = 1;
}	}

# Internal function: Takes a key to look up in the nav hash and implements internal	# Internal function: Takes a key to look up in the nav hash and implements internal
Line 1885 sub untieHashes {	Line 1827 sub untieHashes {
sub hasDiscussion {	sub hasDiscussion {
my $self = shift;	my $self = shift;
my $symb = shift;	my $symb = shift;

	$self->generate_email_discuss_status();

if (!defined($self->{DISCUSSION_TIME})) { return 0; }	if (!defined($self->{DISCUSSION_TIME})) { return 0; }

#return defined($self->{DISCUSSION_TIME}->{$symb});	#return defined($self->{DISCUSSION_TIME}->{$symb});
Line 1899 sub getFeedback {	Line 1844 sub getFeedback {
my $self = shift;	my $self = shift;
my $symb = shift;	my $symb = shift;

	$self->generate_email_discuss_status();

if (!defined($self->{FEEDBACK})) { return ""; }	if (!defined($self->{FEEDBACK})) { return ""; }

return $self->{FEEDBACK}->{$symb};	return $self->{FEEDBACK}->{$symb};
Line 1908 sub getFeedback {	Line 1855 sub getFeedback {
sub getErrors {	sub getErrors {
my $self = shift;	my $self = shift;
my $src = shift;	my $src = shift;

	$self->generate_email_discuss_status();

if (!defined($self->{ERROR_MSG})) { return ""; }	if (!defined($self->{ERROR_MSG})) { return ""; }
return $self->{ERROR_MSG}->{$src};	return $self->{ERROR_MSG}->{$src};
}	}
Line 2021 sub parmval_real {	Line 1970 sub parmval_real {
my $self = shift;	my $self = shift;
my ($what,$symb,$recurse) = @_;	my ($what,$symb,$recurse) = @_;

	# Make sure the {USER_OPT} and {COURSE_OPT} hashes are populated
	$self->generate_course_user_opt();

my $cid=$ENV{'request.course.id'};	my $cid=$ENV{'request.course.id'};
my $csec=$ENV{'request.course.sec'};	my $csec=$ENV{'request.course.sec'};
my $uname=$ENV{'user.name'};	my $uname=$ENV{'user.name'};
Line 2195 sub retrieveResources {	Line 2147 sub retrieveResources {
my @resources = ();	my @resources = ();

# Run down the iterator and collect the resources.	# Run down the iterator and collect the resources.
my $depth = 1;	my $curRes;
$it->next();
my $curRes = $it->next();	while ($curRes = $it->next()) {

while ($depth > 0) {
if ($curRes == $it->BEGIN_MAP()) {
$depth++;
}
if ($curRes == $it->END_MAP()) {
$depth--;
}

if (ref($curRes)) {	if (ref($curRes)) {
if (!&$filterFunc($curRes)) {	if (!&$filterFunc($curRes)) {
next;	next;
Line 2219 sub retrieveResources {	Line 2162 sub retrieveResources {
}	}
}	}

} continue {
$curRes = $it->next();
}	}

return @resources;	return @resources;
Line 2296 new branch. The possible tokens are:	Line 2237 new branch. The possible tokens are:

=over 4	=over 4

	=item * B<END_ITERATOR>:

	The iterator has returned all that it's going to. Further calls to the
	iterator will just produce more of these. This is a "false" value, and
	is the only false value the iterator which will be returned, so it can
	be used as a loop sentinel.

=item * B<BEGIN_MAP>:	=item * B<BEGIN_MAP>:

A new map is being recursed into. This is returned I<after> the map	A new map is being recursed into. This is returned I<after> the map
Line 2326 consisting entirely of empty resources e	Line 2274 consisting entirely of empty resources e
ending resource, will cause a lot of BRANCH_STARTs and BRANCH_ENDs,	ending resource, will cause a lot of BRANCH_STARTs and BRANCH_ENDs,
but only one resource will be returned.	but only one resource will be returned.

	=head2 Normal Usage

	Normal usage of the iterator object is to do the following:

	my $it = $navmap->getIterator([your params here]);
	my $curRes;
	while ($curRes = $it->next()) {
	[your logic here]
	}

	Note that inside of the loop, it's frequently useful to check if
	"$curRes" is a reference or not with the reference function; only
	resource objects will be references, and any non-references will
	be the tokens described above.

	Also note there is some old code floating around that trys to track
	the depth of the iterator to see when it's done; do not copy that
	code. It is difficult to get right and harder to understand then
	this. They should be migrated to this new style.

=back	=back

=cut	=cut

# Here are the tokens for the iterator:	# Here are the tokens for the iterator:

	sub END_ITERATOR { return 0; }
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 BEGIN_BRANCH { return 3; } # beginning of a branch	sub BEGIN_BRANCH { return 3; } # beginning of a branch
Line 2417 sub new {	Line 2386 sub new {

# prime the recursion	# prime the recursion
$self->{$firstResourceName}->{DATA}->{$valName} = 0;	$self->{$firstResourceName}->{DATA}->{$valName} = 0;
my $depth = 0;	$iterator->next();
$iterator->next();
my $curRes = $iterator->next();	my $curRes = $iterator->next();
while ($depth > -1) {	my $depth = 1;
if ($curRes == $iterator->BEGIN_MAP()) { $depth++; }	while ($depth > 0) {
if ($curRes == $iterator->END_MAP()) { $depth--; }	if ($curRes == $iterator->BEGIN_MAP()) { $depth++; }
	if ($curRes == $iterator->END_MAP()) { $depth--; }

if (ref($curRes)) {	if (ref($curRes)) {
# If there's only one resource, this will save it	# If there's only one resource, this will save it
# we have to filter empty resources from consideration here,	# we have to filter empty resources from consideration here,
Line 2457 sub new {	Line 2426 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 2479 sub new {	Line 2448 sub new {
$self->{MAX_DEPTH} = $maxDepth;	$self->{MAX_DEPTH} = $maxDepth;
$self->{STACK} = [];	$self->{STACK} = [];
$self->{RECURSIVE_ITERATOR_FLAG} = 0;	$self->{RECURSIVE_ITERATOR_FLAG} = 0;
	$self->{FINISHED} = 0; # When true, the iterator has finished

for (my $i = 0; $i <= $self->{MAX_DEPTH}; $i++) {	for (my $i = 0; $i <= $self->{MAX_DEPTH}; $i++) {
push @{$self->{STACK}}, [];	push @{$self->{STACK}}, [];
Line 2496 sub new {	Line 2466 sub new {
sub next {	sub next {
my $self = shift;	my $self = shift;

	if ($self->{FINISHED}) {
	return END_ITERATOR();
	}

# If we want to return the top-level map object, and haven't yet,	# If we want to return the top-level map object, and haven't yet,
# do so.	# do so.
if ($self->{RETURN_0} && !$self->{HAVE_RETURNED_0}) {	if ($self->{RETURN_0} && !$self->{HAVE_RETURNED_0}) {
Line 2555 sub next {	Line 2529 sub next {
$self->{CURRENT_DEPTH}--;	$self->{CURRENT_DEPTH}--;
return END_BRANCH();	return END_BRANCH();
} else {	} else {
	$self->{FINISHED} = 1;
return END_MAP();	return END_MAP();
}	}
}	}
Line 3051 sub symb {	Line 3026 sub symb {
my $self=shift;	my $self=shift;
(my $first, my $second) = $self->{ID} =~ /(\d+).(\d+)/;	(my $first, my $second) = $self->{ID} =~ /(\d+).(\d+)/;
my $symbSrc = &Apache::lonnet::declutter($self->src());	my $symbSrc = &Apache::lonnet::declutter($self->src());
return &Apache::lonnet::declutter(	my $symb = &Apache::lonnet::declutter($self->navHash('map_id_'.$first))
$self->navHash('map_id_'.$first))
. '___' . $second . '___' . $symbSrc;	. '___' . $second . '___' . $symbSrc;
	return &Apache::lonnet::symbclean($symb);
}	}
sub title {	sub title {
my $self=shift;	my $self=shift;
Line 3299 sub answerdate {	Line 3274 sub answerdate {
}	}
sub awarded {	sub awarded {
my $self = shift; my $part = shift;	my $self = shift; my $part = shift;
	$self->{NAV_MAP}->get_user_data();
if (!defined($part)) { $part = '0'; }	if (!defined($part)) { $part = '0'; }
return $self->{NAV_MAP}->{STUDENT_DATA}->{$self->symb()}->{'resource.'.$part.'.awarded'};	return $self->{NAV_MAP}->{STUDENT_DATA}->{$self->symb()}->{'resource.'.$part.'.awarded'};
}	}
Line 3891 sub status {	Line 3867 sub status {
# dimension and 5 entries on the other, which we want to colorize,	# dimension and 5 entries on the other, which we want to colorize,
# plus network failure and "no date data at all".	# plus network failure and "no date data at all".

	#if ($self->{RESOURCE_ERROR}) { return NETWORK_FAILURE; }
if ($completionStatus == NETWORK_FAILURE) { return NETWORK_FAILURE; }	if ($completionStatus == NETWORK_FAILURE) { return NETWORK_FAILURE; }

my $suppressFeedback = lc($self->parmval("problemstatus", $part)) eq 'no';	my $suppressFeedback = lc($self->parmval("problemstatus", $part)) eq 'no';
Line 3937 sub status {	Line 3914 sub status {
if ($completionStatus == INCORRECT \|\| $completionStatus == INCORRECT_BY_OVERRIDE) {	if ($completionStatus == INCORRECT \|\| $completionStatus == INCORRECT_BY_OVERRIDE) {
# and there are TRIES LEFT:	# and there are TRIES LEFT:
if ($self->tries($part) < $self->maxtries($part) \|\| !$self->maxtries($part)) {	if ($self->tries($part) < $self->maxtries($part) \|\| !$self->maxtries($part)) {
return TRIES_LEFT;	return $suppressFeedback ? ANSWER_SUBMITTED : TRIES_LEFT;
}	}
return $suppressFeedback ? ANSWER_SUBMITTED : INCORRECT; # otherwise, return orange; student can't fix this	return $suppressFeedback ? ANSWER_SUBMITTED : INCORRECT; # otherwise, return orange; student can't fix this
}	}
Line 3946 sub status {	Line 3923 sub status {
return OPEN;	return OPEN;
}	}

	sub CLOSED { return 23; }
	sub ERROR { return 24; }

	=pod

	B<Simple Status>

	Convenience method B<simpleStatus> provides a "simple status" for the resource.
	"Simple status" corresponds to "which icon is shown on the
	Navmaps". There are six "simple" statuses:

	=over 4

	=item * B<CLOSED>: The problem is currently closed. (No icon shown.)

	=item * B<OPEN>: The problem is open and unattempted.

	=item * B<CORRECT>: The problem is correct for any reason.

	=item * B<INCORRECT>: The problem is incorrect and can still be
	completed successfully.

	=item * B<ATTEMPTED>: The problem has been attempted, but the student
	does not know if they are correct. (The ellipsis icon.)

	=item * B<ERROR>: There is an error retrieving information about this
	problem.

	=back

	=cut

	# This hash maps the composite status to this simple status, and
	# can be used directly, if you like
	my %compositeToSimple =
	(
	NETWORK_FAILURE() => ERROR,
	NOTHING_SET() => CLOSED,
	CORRECT() => CORRECT,
	EXCUSED() => CORRECT,
	PAST_DUE_NO_ANSWER() => INCORRECT,
	PAST_DUE_ANSWER_LATER() => INCORRECT,
	ANSWER_OPEN() => INCORRECT,
	OPEN_LATER() => CLOSED,
	TRIES_LEFT() => OPEN,
	INCORRECT() => INCORRECT,
	OPEN() => OPEN,
	ATTEMPTED() => ATTEMPTED,
	ANSWER_SUBMITTED() => ATTEMPTED
	);

	sub simpleStatus {
	my $self = shift;
	my $part = shift;
	my $status = $self->status($part);
	return $compositeToSimple{$status};
	}

=pod	=pod

B<Completable>	B<Completable>

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>

Removed from v.1.220
changed lines
	Added in v.1.224