|
version 1.395, 2006/12/24 22:13:19
|
version 1.400, 2007/08/29 00:55:37
|
|
Line 38 use Apache::lonnet;
|
Line 38 use Apache::lonnet;
|
| use POSIX qw (floor strftime); |
use POSIX qw (floor strftime); |
| use Data::Dumper; # for debugging, not always |
use Data::Dumper; # for debugging, not always |
| use Time::HiRes qw( gettimeofday tv_interval ); |
use Time::HiRes qw( gettimeofday tv_interval ); |
| use lib '/home/httpd/lib/perl/'; |
|
| use LONCAPA; |
use LONCAPA; |
| |
|
| # symbolic constants |
# symbolic constants |
|
Line 86 my %colormap =
|
Line 85 my %colormap =
|
| $resObj->PARTIALLY_CORRECT => '#006600' |
$resObj->PARTIALLY_CORRECT => '#006600' |
| ); |
); |
| # And a special case in the nav map; what to do when the assignment |
# And a special case in the nav map; what to do when the assignment |
| # is not yet done and due in less then 24 hours |
# is not yet done and due in less than 24 hours |
| my $hurryUpColor = "#FF0000"; |
my $hurryUpColor = "#FF0000"; |
| |
|
| sub close { |
sub close { |
|
Line 239 sub getDescription {
|
Line 238 sub getDescription {
|
| } |
} |
| } |
} |
| |
|
| # 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 than |
| # 24 hours, and still can be done? |
# 24 hours, and still can be done? |
| |
|
| sub dueInLessThan24Hours { |
sub dueInLessThan24Hours { |
|
Line 254 sub dueInLessThan24Hours {
|
Line 253 sub dueInLessThan24Hours {
|
| } |
} |
| |
|
| # Convenience function, so others can use it: Is there only one try remaining for the |
# 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? |
# part, with more than one try to begin with, not due yet and still can be done? |
| sub lastTry { |
sub lastTry { |
| my $res = shift; |
my $res = shift; |
| my $part = shift; |
my $part = shift; |
|
Line 323 sub timeToHumanString {
|
Line 322 sub timeToHumanString {
|
| my $tense = $inPast ? " ago" : ""; |
my $tense = $inPast ? " ago" : ""; |
| my $prefix = $inPast ? "" : "in "; |
my $prefix = $inPast ? "" : "in "; |
| |
|
| # Less then a minute |
# Less than a minute |
| if ( $delta < $minute ) { |
if ( $delta < $minute ) { |
| if ($delta == 1) { return "${prefix}1 second$tense"; } |
if ($delta == 1) { return "${prefix}1 second$tense"; } |
| return "$prefix$delta seconds$tense"; |
return "$prefix$delta seconds$tense"; |
| } |
} |
| |
|
| # Less then an hour |
# Less than an hour |
| if ( $delta < $hour ) { |
if ( $delta < $hour ) { |
| # If so, use minutes |
# If so, use minutes |
| my $minutes = floor($delta / 60); |
my $minutes = floor($delta / 60); |
|
Line 337 sub timeToHumanString {
|
Line 336 sub timeToHumanString {
|
| return "$prefix$minutes minutes$tense"; |
return "$prefix$minutes minutes$tense"; |
| } |
} |
| |
|
| # Is it less then 24 hours away? If so, |
# Is it less than 24 hours away? If so, |
| # display hours + minutes |
# display hours + minutes |
| if ( $delta < $hour * 24) { |
if ( $delta < $hour * 24) { |
| my $hours = floor($delta / $hour); |
my $hours = floor($delta / $hour); |
|
Line 363 sub timeToHumanString {
|
Line 362 sub timeToHumanString {
|
| return $timeStr.&Apache::lonlocal::gettimezone($time); |
return $timeStr.&Apache::lonlocal::gettimezone($time); |
| } |
} |
| |
|
| # Less then 5 days away, display day of the week and |
# Less than 5 days away, display day of the week and |
| # HH:MM |
# HH:MM |
| |
|
| if ( $delta < $day * 5 ) { |
if ( $delta < $day * 5 ) { |
|
Line 428 to compute due to the amount of data tha
|
Line 427 to compute due to the amount of data tha
|
| processed. |
processed. |
| |
|
| Apache::lonnavmaps provides an object model for manipulating this |
Apache::lonnavmaps provides an object model for manipulating this |
| information in a higher-level fashion then directly manipulating |
information in a higher-level fashion than directly manipulating |
| the hash. It also provides access to several auxilary functions |
the hash. It also provides access to several auxilary functions |
| that aren't necessarily stored in the Big Hash, but are a per- |
that aren't necessarily stored in the Big Hash, but are a per- |
| resource sort of value, like whether there is any feedback on |
resource sort of value, like whether there is any feedback on |
|
Line 474 Apache::lonnavmaps::render({}).
|
Line 473 Apache::lonnavmaps::render({}).
|
| =head2 Overview of Columns |
=head2 Overview of Columns |
| |
|
| The renderer will build an HTML table for the navmap and return |
The renderer will build an HTML table for the navmap and return |
| it. The table is consists of several columns, and a row for each |
it. The table consists of several columns, and a row for each |
| resource (or possibly each part). You tell the renderer how many |
resource (or possibly each part). You tell the renderer how many |
| columns to create and what to place in each column, optionally using |
columns to create and what to place in each column, optionally using |
| one or more of the prepared columns, and the renderer will assemble |
one or more of the prepared columns, and the renderer will assemble |
|
Line 992 sub render_long_status {
|
Line 991 sub render_long_status {
|
| if ($color) {$result .= "</b></font>"; } |
if ($color) {$result .= "</b></font>"; } |
| } |
} |
| if ($resource->is_map() && advancedUser() && $resource->randompick()) { |
if ($resource->is_map() && advancedUser() && $resource->randompick()) { |
| $result .= '(randomly select ' . $resource->randompick() .')'; |
$result .= &mt('(randomly select [_1])', $resource->randompick()); |
| |
} |
| |
if ($resource->is_map() && &advancedUser() && $resource->randomorder()) { |
| |
$result .= &mt('(randomly ordered)'); |
| } |
} |
| |
|
| # Debugging code |
# Debugging code |
|
Line 1802 See iterator documentation below.
|
Line 1804 See iterator documentation below.
|
| use strict; |
use strict; |
| use GDBM_File; |
use GDBM_File; |
| use Apache::lonnet; |
use Apache::lonnet; |
| |
use LONCAPA; |
| |
|
| sub new { |
sub new { |
| # magic invocation to create a class instance |
# magic invocation to create a class instance |
|
Line 1916 sub generate_email_discuss_status {
|
Line 1919 sub generate_email_discuss_status {
|
| if ((!$emailstatus{$msgid}) || ($emailstatus{$msgid} eq 'new')) { |
if ((!$emailstatus{$msgid}) || ($emailstatus{$msgid} eq 'new')) { |
| my ($sendtime,$shortsubj,$fromname,$fromdomain,$status,$fromcid, |
my ($sendtime,$shortsubj,$fromname,$fromdomain,$status,$fromcid, |
| $symb,$error) = &Apache::lonmsg::unpackmsgid($msgid); |
$symb,$error) = &Apache::lonmsg::unpackmsgid($msgid); |
| |
&Apache::lonenc::check_decrypt(\$symb); |
| |
if (($fromcid ne '') && ($fromcid ne $cid)) { |
| |
next; |
| |
} |
| if (defined($symb)) { |
if (defined($symb)) { |
| if (defined($error) && $error == 1) { |
if (defined($error) && $error == 1) { |
| $error{$symb}.=','.$msgid; |
$error{$symb}.=','.$msgid; |
|
Line 2053 sub discussion_info {
|
Line 2060 sub discussion_info {
|
| |
|
| my $ressymb = $self->wrap_symb($symb); |
my $ressymb = $self->wrap_symb($symb); |
| # keys used to store bulletinboard postings use 'unwrapped' symb. |
# keys used to store bulletinboard postings use 'unwrapped' symb. |
| my $discsymb = $self->unwrap_symb($ressymb); |
my $discsymb = &escape($self->unwrap_symb($ressymb)); |
| my $version = $self->{DISCUSSION_DATA}{'version:'.$discsymb}; |
my $version = $self->{DISCUSSION_DATA}{'version:'.$discsymb}; |
| if (!$version) { return; } |
if (!$version) { return; } |
| |
|
|
Line 2193 the given map. This is one of the proper
|
Line 2200 the given map. This is one of the proper
|
| |
|
| # The strategy here is to cache the resource objects, and only construct them |
# The strategy here is to cache the resource objects, and only construct them |
| # as we use them. The real point is to prevent reading any more from the tied |
# as we use them. The real point is to prevent reading any more from the tied |
| # hash then we have to, which should hopefully alleviate speed problems. |
# hash than we have to, which should hopefully alleviate speed problems. |
| |
|
| sub getById { |
sub getById { |
| my $self = shift; |
my $self = shift; |
|
Line 2267 sub finishResource {
|
Line 2274 sub finishResource {
|
| # the actual lookup; parmval caches the results. |
# the actual lookup; parmval caches the results. |
| sub parmval { |
sub parmval { |
| my $self = shift; |
my $self = shift; |
| my ($what,$symb)=@_; |
my ($what,$symb,$recurse)=@_; |
| my $hashkey = $what."|||".$symb; |
my $hashkey = $what."|||".$symb; |
| |
|
| if (defined($self->{PARM_CACHE}->{$hashkey})) { |
if (defined($self->{PARM_CACHE}->{$hashkey})) { |
| return $self->{PARM_CACHE}->{$hashkey}; |
return $self->{PARM_CACHE}->{$hashkey}; |
| } |
} |
| |
|
| my $result = $self->parmval_real($what, $symb); |
my $result = $self->parmval_real($what, $symb, $recurse); |
| $self->{PARM_CACHE}->{$hashkey} = $result; |
$self->{PARM_CACHE}->{$hashkey} = $result; |
| return $result; |
return $result; |
| } |
} |
|
Line 2384 sub parmval_real {
|
Line 2391 sub parmval_real {
|
| if (defined($partgeneral)) { return $partgeneral; } |
if (defined($partgeneral)) { return $partgeneral; } |
| } |
} |
| if ($recurse) { return undef; } |
if ($recurse) { return undef; } |
| my $pack_def=&Apache::lonnet::packages_tab_default($fn,'resource.'.$what); |
my $pack_def=&Apache::lonnet::packages_tab_default($fn,'resource.'.$rwhat); |
| if (defined($pack_def)) { return $pack_def; } |
if (defined($pack_def)) { return $pack_def; } |
| return ''; |
return ''; |
| } |
} |
|
Line 2394 sub parmval_real {
|
Line 2401 sub parmval_real {
|
| =item * B<getResourceByUrl>(url,multiple): |
=item * B<getResourceByUrl>(url,multiple): |
| |
|
| Retrieves a resource object by URL of the resource, unless the optional |
Retrieves a resource object by URL of the resource, unless the optional |
| multiple parameter is included in wahich caes an array of resource |
multiple parameter is included in which case an array of resource |
| objects is returned. If passed a resource object, it will simply return |
objects is returned. If passed a resource object, it will simply return |
| it, so it is safe to use this method in code like |
it, so it is safe to use this method in code like |
| "$res = $navmap->getResourceByUrl($res)" |
"$res = $navmap->getResourceByUrl($res)" |
|
Line 2429 all matching resources.
|
Line 2436 all matching resources.
|
| |
|
| =item * B<hasResource>(map, filterFunc, recursive, showall): |
=item * B<hasResource>(map, filterFunc, recursive, showall): |
| |
|
| Convience method for |
Convenience method for |
| |
|
| scalar(retrieveResources($map, $filterFunc, $recursive, 1, $showall)) > 0 |
scalar(retrieveResources($map, $filterFunc, $recursive, 1, $showall)) > 0 |
| |
|
|
Line 2507 sub retrieveResources {
|
Line 2514 sub retrieveResources {
|
| |
|
| my @resources = (); |
my @resources = (); |
| |
|
| |
if (&$filterFunc($map)) { |
| |
push(@resources, $map); |
| |
} |
| |
|
| # Run down the iterator and collect the resources. |
# Run down the iterator and collect the resources. |
| my $curRes; |
my $curRes; |
| |
|
|
Line 2516 sub retrieveResources {
|
Line 2527 sub retrieveResources {
|
| next; |
next; |
| } |
} |
| |
|
| push @resources, $curRes; |
push(@resources, $curRes); |
| |
|
| if ($bailout) { |
if ($bailout) { |
| return @resources; |
return @resources; |
|
Line 2663 be the tokens described above.
|
Line 2674 be the tokens described above.
|
| |
|
| Also note there is some old code floating around that trys to track |
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 |
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 |
code. It is difficult to get right and harder to understand than |
| this. They should be migrated to this new style. |
this. They should be migrated to this new style. |
| |
|
| =cut |
=cut |
|
Line 2948 sub next {
|
Line 2959 sub next {
|
| } |
} |
| |
|
| # Is this the end of a branch? If so, all of the resources examined above |
# Is this the end of a branch? If so, all of the resources examined above |
| # led to lower levels then the one we are currently at, so we push a END_BRANCH |
# led to lower levels than the one we are currently at, so we push a END_BRANCH |
| # marker onto the stack so we don't forget. |
# marker onto the stack so we don't forget. |
| # Example: For the usual A(BC)(DE)F case, when the iterator goes down the |
# Example: For the usual A(BC)(DE)F case, when the iterator goes down the |
| # 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 |
|
Line 3284 X<symb> X<resource, symb>
|
Line 3295 X<symb> X<resource, symb>
|
| All resources also have B<symb>s, which uniquely identify a resource |
All resources also have B<symb>s, which uniquely identify a resource |
| in a course. Many internal LON-CAPA functions expect a symb. A symb |
in a course. Many internal LON-CAPA functions expect a symb. A symb |
| carries along with it the URL of the resource, and the map it appears |
carries along with it the URL of the resource, and the map it appears |
| in. Symbs are much larger then resource IDs. |
in. Symbs are much larger than resource IDs. |
| |
|
| =cut |
=cut |
| |
|
|
Line 3360 false.
|
Line 3371 false.
|
| |
|
| =item * B<randompick>: |
=item * B<randompick>: |
| |
|
| Returns true for a map if the randompick feature is being used on the |
Returns the number of randomly picked items for a map if the randompick |
| map. (?) |
feature is being used on the map. |
| |
|
| |
=item * B<randomorder>: |
| |
|
| |
Returns true for a map if the randomorder feature is being used on the |
| |
map. |
| |
|
| =item * B<src>: |
=item * B<src>: |
| |
|
|
Line 3393 sub randompick {
|
Line 3409 sub randompick {
|
| my $self = shift; |
my $self = shift; |
| return $self->parmval('randompick'); |
return $self->parmval('randompick'); |
| } |
} |
| |
sub randomorder { |
| |
my $self = shift; |
| |
return ($self->parmval('randomorder') =~ /^yes$/i); |
| |
} |
| sub link { |
sub link { |
| my $self=shift; |
my $self=shift; |
| if ($self->encrypted()) { return &Apache::lonenc::encrypted($self->src); } |
if ($self->encrypted()) { return &Apache::lonenc::encrypted($self->src); } |
|
Line 3469 sub compTitle {
|
Line 3489 sub compTitle {
|
| } |
} |
| return $title; |
return $title; |
| } |
} |
| |
|
| =pod |
=pod |
| |
|
| B<Predicate Testing the Resource> |
B<Predicate Testing the Resource> |
|
Line 3661 sub map_type {
|
Line 3682 sub map_type {
|
| |
|
| # These functions will be responsible for returning the CORRECT |
# These functions will be responsible for returning the CORRECT |
| # VALUE for the parameter, no matter what. So while they may look |
# VALUE for the parameter, no matter what. So while they may look |
| # like direct calls to parmval, they can be more then that. |
# like direct calls to parmval, they can be more than that. |
| # So, for instance, the duedate function should use the "duedatetype" |
# So, for instance, the duedate function should use the "duedatetype" |
| # information, rather then the resource object user. |
# information, rather than the resource object user. |
| |
|
| =pod |
=pod |
| |
|
|
Line 3777 sub duedate {
|
Line 3798 sub duedate {
|
| } |
} |
| sub handgrade { |
sub handgrade { |
| (my $self, my $part) = @_; |
(my $self, my $part) = @_; |
| |
my @response_ids = $self->responseIds($part); |
| |
if (@response_ids) { |
| |
foreach my $response_id (@response_ids) { |
| |
if (lc($self->parmval("handgrade",$part.'_'.$response_id)) |
| |
eq 'yes') { |
| |
return 'yes'; |
| |
} |
| |
} |
| |
} |
| return $self->parmval("handgrade", $part); |
return $self->parmval("handgrade", $part); |
| } |
} |
| sub maxtries { |
sub maxtries { |
![[BACK]](/icons/back.gif){kind=icon}
Return to lonnavmaps.pm CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [LON-CAPA] / loncom / interface