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.353 and 1.416

-version 1.353, 2005/12/05 19:30:22
+version 1.416, 2008/11/18 20:18:37
  Line 27
  #
  ###
+ =pod
+ =head1 NAME
+ Apache::lonnavmaps.pm
+ =head1 SYNOPSIS
+ Handles navigational maps.
+ The main handler generates the navigational listing for the course,
+ the other objects export this information in a usable fashion for
+ other modules.
+ This is part of the LearningOnline Network with CAPA project
+ described at http://www.lon-capa.org.
+ =head1 OVERVIEW
+ X<lonnavmaps, overview> When a user enters a course, LON-CAPA examines the
+ course structure and caches it in what is often referred to as the
+ "big hash" X<big hash>. You can see it if you are logged into
+ LON-CAPA, in a course, by going to /adm/test. (You may need to
+ tweak the /home/httpd/lonTabs/htpasswd file to view it.) The
+ content of the hash will be under the heading "Big Hash".
+ Big Hash contains, among other things, how resources are related
+ to each other (next/previous), what resources are maps, which
+ resources are being chosen to not show to the student (for random
+ selection), and a lot of other things that can take a lot of time
+ to compute due to the amount of data that needs to be collected and
+ processed.
+ Apache::lonnavmaps provides an object model for manipulating this
+ information in a higher-level fashion than directly manipulating
+ the hash. It also provides access to several auxilary functions
+ that aren't necessarily stored in the Big Hash, but are a per-
+ resource sort of value, like whether there is any feedback on
+ a given resource.
+ Apache::lonnavmaps also abstracts away branching, and someday,
+ conditions, for the times where you don't really care about those
+ things.
+ Apache::lonnavmaps also provides fairly powerful routines for
+ rendering navmaps, and last but not least, provides the navmaps
+ view for when the user clicks the NAV button.
+ B<Note>: Apache::lonnavmaps I<only> works for the "currently
+ logged in user"; if you want things like "due dates for another
+ student" lonnavmaps can not directly retrieve information like
+ that. You need the EXT function. This module can still help,
+ because many things, such as the course structure, are constant
+ between users, and Apache::lonnavmaps can help by providing
+ symbs for the EXT call.
+ The rest of this file will cover the provided rendering routines,
+ which can often be used without fiddling with the navmap object at
+ all, then documents the Apache::lonnavmaps::navmap object, which
+ is the key to accessing the Big Hash information, covers the use
+ of the Iterator (which provides the logic for traversing the
+ somewhat-complicated Big Hash data structure), documents the
+ Apache::lonnavmaps::Resource objects that are returned by
+ =head1 Subroutine: render
+ The navmap renderer package provides a sophisticated rendering of the
+ standard navigation maps interface into HTML. The provided nav map
+ handler is actually just a glorified call to this.
+ Because of the large number of parameters this function accepts,
+ instead of passing it arguments as is normal, pass it in an anonymous
+ hash with the desired options.
+ The package provides a function called 'render', called as
+ Apache::lonnavmaps::render({}).
+ =head2 Overview of Columns
+ The renderer will build an HTML table for the navmap and return
+ it. The table consists of several columns, and a row for each
+ resource (or possibly each part). You tell the renderer how many
+ columns to create and what to place in each column, optionally using
+ one or more of the prepared columns, and the renderer will assemble
+ the table.
+ Any additional generally useful column types should be placed in the
+ renderer code here, so anybody can use it anywhere else. Any code
+ specific to the current application (such as the addition of <input>
+ elements in a column) should be placed in the code of the thing using
+ the renderer.
+ At the core of the renderer is the array reference COLS (see Example
+ section below for how to pass this correctly). The COLS array will
+ consist of entries of one of two types of things: Either an integer
+ representing one of the pre-packaged column types, or a sub reference
+ that takes a resource reference, a part number, and a reference to the
+ argument hash passed to the renderer, and returns a string that will
+ be inserted into the HTML representation as it.
+ All other parameters are ways of either changing how the columns
+ are printing, or which rows are shown.
+ The pre-packaged column names are refered to by constants in the
+ Apache::lonnavmaps namespace. The following currently exist:
+ =over 4
+ =item * B<Apache::lonnavmaps::resource>:
+ The general info about the resource: Link, icon for the type, etc. The
+ first column in the standard nav map display. This column provides the
+ indentation effect seen in the B<NAV> screen. This column also accepts
+ the following parameters in the renderer hash:
+ =over 4
+ =item * B<resource_nolink>: default false
+ If true, the resource will not be linked. By default, all non-folder
+ resources are linked.
+ =item * B<resource_part_count>: default true
+ If true, the resource will show a part count B<if> the full
+ part list is not displayed. (See "condense_parts" later.) If false,
+ the resource will never show a part count.
+ =item * B<resource_no_folder_link>:
+ If true, the resource's folder will not be clickable to open or close
+ it. Default is false. True implies printCloseAll is false, since you
+ can't close or open folders when this is on anyhow.
+ =back
+ =item * B<Apache::lonnavmaps::communication_status>:
+ Whether there is discussion on the resource, email for the user, or
+ (lumped in here) perl errors in the execution of the problem. This is
+ the second column in the main nav map.
+ =item * B<Apache::lonnavmaps::quick_status>:
+ An icon for the status of a problem, with five possible states:
+ Correct, incorrect, open, awaiting grading (for a problem where the
+ computer's grade is suppressed, or the computer can't grade, like
+ essay problem), or none (not open yet, not a problem). The
+ third column of the standard navmap.
+ =item * B<Apache::lonnavmaps::long_status>:
+ A text readout of the details of the current status of the problem,
+ such as "Due in 22 hours". The fourth column of the standard navmap.
+ =item * B<Apache::lonnavmaps::part_status_summary>:
+ A text readout summarizing the status of the problem. If it is a
+ single part problem, will display "Correct", "Incorrect",
+ "Not yet open", "Open", "Attempted", or "Error". If there are
+ multiple parts, this will output a string that in HTML will show a
+ status of how many parts are in each status, in color coding, trying
+ to match the colors of the icons within reason.
+ Note this only makes sense if you are I<not> showing parts. If
+ C<showParts> is true (see below), this column will not output
+ anything.
+ =back
+ If you add any others please be sure to document them here.
+ An example of a column renderer that will show the ID number of a
+ resource, along with the part name if any:
+  sub {
+   my ($resource, $part, $params) = @_;
+   if ($part) { return '<td>' . $resource->{ID} . ' ' . $part . '</td>'; }
+   return '<td>' . $resource->{ID} . '</td>';
+  }
+ Note these functions are responsible for the TD tags, which allow them
+ to override vertical and horizontal alignment, etc.
+ =head2 Parameters
+ Minimally, you should be
+ able to get away with just using 'cols' (to specify the columns
+ shown), 'url' (necessary for the folders to link to the current screen
+ correctly), and possibly 'queryString' if your app calls for it. In
+ that case, maintaining the state of the folders will be done
+ automatically.
+ =over 4
+ =item * B<iterator>: default: constructs one from %env
+ A reference to a fresh ::iterator to use from the navmaps. The
+ rendering will reflect the options passed to the iterator, so you can
+ use that to just render a certain part of the course, if you like. If
+ one is not passed, the renderer will attempt to construct one from
+ env{'form.filter'} and env{'form.condition'} information, plus the
+ 'iterator_map' parameter if any.
+ =item * B<iterator_map>: default: not used
+ If you are letting the renderer do the iterator handling, you can
+ instruct the renderer to render only a particular map by passing it
+ the source of the map you want to process, like
+ '/res/103/jerf/navmap.course.sequence'.
+ =item * B<include_top_level_map>: default: false
+ If you need to include the top level map (meaning the course) in the
+ rendered output set this to true
+ =item * B<navmap>: default: constructs one from %env
+ A reference to a navmap, used only if an iterator is not passed in. If
+ this is necessary to make an iterator but it is not passed in, a new
+ one will be constructed based on env info. This is useful to do basic
+ error checking before passing it off to render.
+ =item * B<r>: default: must be passed in
+ The standard Apache response object. This must be passed to the
+ renderer or the course hash will be locked.
+ =item * B<cols>: default: empty (useless)
+ An array reference
+ =item * B<showParts>:default true
+ A flag. If true, a line for the resource itself, and a line
+ for each part will be displayed. If not, only one line for each
+ resource will be displayed.
+ =item * B<condenseParts>: default true
+ A flag. If true, if all parts of the problem have the same
+ status and that status is Nothing Set, Correct, or Network Failure,
+ then only one line will be displayed for that resource anyhow. If no,
+ all parts will always be displayed. If showParts is 0, this is
+ ignored.
+ =item * B<jumpCount>: default: determined from %env
+ A string identifying the URL to place the anchor 'curloc' at.
+ It is the responsibility of the renderer user to
+ ensure that the #curloc is in the URL. By default, determined through
+ the use of the env{} 'jump' information, and should normally "just
+ work" correctly.
+ =item * B<here>: default: empty string
+ A Symb identifying where to place the 'here' marker. The empty
+ string means no marker.
+ =item * B<indentString>: default: 25 pixel whitespace image
+ A string identifying the indentation string to use.
+ =item * B<queryString>: default: empty
+ A string which will be prepended to the query string used when the
+ folders are opened or closed. You can use this to pass
+ application-specific values.
+ =item * B<url>: default: none
+ The url the folders will link to, which should be the current
+ page. Required if the resource info column is shown, and you
+ are allowing the user to open and close folders.
+ =item * B<currentJumpIndex>: default: no jumping
+ Describes the currently-open row number to cause the browser to jump
+ to, because the user just opened that folder. By default, pulled from
+ the Jump information in the env{'form.*'}.
+ =item * B<printKey>: default: false
+ If true, print the key that appears on the top of the standard
+ navmaps.
+ =item * B<printCloseAll>: default: true
+ If true, print the "Close all folders" or "open all folders"
+ links.
+ =item * B<filterFunc>: default: sub {return 1;} (accept everything)
+ A function that takes the resource object as its only parameter and
+ returns a true or false value. If true, the resource is displayed. If
+ false, it is simply skipped in the display.
+ =item * B<suppressEmptySequences>: default: false
+ 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; for example, see the "Show Uncompleted Homework" view on the
+ B<NAV> screen.
+ =item * B<suppressNavmaps>: default: false
+ If true, will not display Navigate Content resources.
+ =back
+ =head2 Additional Info
+ In addition to the parameters you can pass to the renderer, which will
+ be passed through unchange to the column renderers, the renderer will
+ generate the following information which your renderer may find
+ useful:
+ =over 4
+ =item * B<counter>:
+ Contains the number of rows printed. Useful after calling the render
+ function, as you can detect whether anything was printed at all.
+ =item * B<isNewBranch>:
+ Useful for renderers: If this resource is currently the first resource
+ of a new branch, this will be true. The Resource column (leftmost in the
+ navmaps screen) uses this to display the "new branch" icon
+ =back
+ =cut
+ =head1 SUBROUTINES
+ =over
+ =item update()
+ =item addToFilter()
+ Convenience functions: Returns a string that adds or subtracts
+ the second argument from the first hash, appropriate for the
+ query string that determines which folders to recurse on
+ =item removeFromFilter()
+ =item getLinkForResource()
+ Convenience function: Given a stack returned from getStack on the iterator,
+ return the correct src() value.
+ =item getDescription()
+ Convenience function: This separates the logic of how to create
+ the problem text strings ("Due: DATE", "Open: DATE", "Not yet assigned",
+ etc.) into a separate function. It takes a resource object as the
+ first parameter, and the part number of the resource as the second.
+ It's basically a big switch statement on the status of the resource.
+ =item dueInLessThan24Hours()
+ Convenience function, so others can use it: Is the problem due in less than 24 hours, and still can be done?
+ =item lastTry()
+ Convenience function, so others can use it: Is there only one try remaining for the
+ part, with more than one try to begin with, not due yet and still can be done?
+ =item advancedUser()
+ This puts a human-readable name on the env variable.
+ =item timeToHumanString()
+ timeToHumanString takes a time number and converts it to a
+ human-readable representation, meant to be used in the following
+ manner:
+ =over 4
+ =item * print "Due $timestring"
+ =item * print "Open $timestring"
+ =item * print "Answer available $timestring"
+ =back
+ Very, very, very, VERY English-only... goodness help a localizer on
+ this func...
+ =item
+ =item
+ =item
+ =item
+ =item
+ =item
+ =item
+ =item
+ =item
+ =item
+ =item
+ =item
+ =item
+ =back
+ =cut
  package Apache::lonnavmaps;
  use strict;
  use GDBM_File;
- use Apache::Constants qw(:common :http);
  use Apache::loncommon();
- use Apache::lonmenu();
  use Apache::lonenc();
  use Apache::lonlocal;
  use Apache::lonnet;
  use POSIX qw (floor strftime);
- use Data::Dumper; # for debugging, not always
  use Time::HiRes qw( gettimeofday tv_interval );
+ use LONCAPA;
+ use DateTime();
  # symbolic constants
  sub SYMB { return 1; }
- Line 57  my %statusIconMap =
+ Line 484  my %statusIconMap =
       $resObj->CLOSED       => '',
       $resObj->OPEN         => 'navmap.open.gif',
       $resObj->CORRECT      => 'navmap.correct.gif',
-      $resObj->PARTIALLY_CORRECT      => 'navmap.ellipsis.gif',
+      $resObj->PARTIALLY_CORRECT      => 'navmap.partial.gif',
       $resObj->INCORRECT    => 'navmap.wrong.gif',
       $resObj->ATTEMPTED    => 'navmap.ellipsis.gif',
       $resObj->ERROR        => ''
- Line 86  my %colormap =
+ Line 513  my %colormap =
        $resObj->PARTIALLY_CORRECT      => '#006600'
        );
  # 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";
- sub launch_win {
-     my ($mode,$script,$toplinkitems,$firsttime)=@_;
-     my $result;
-     if ($script ne 'no') {
- 	$result.='<script type="text/javascript">';
-     }
-     if ($firsttime) {
- 	$result.='function launch_navmapwin() {
-                  newWindow=open(\'/adm/navmaps?launchExternalRoles\',\'loncapanav\',\'width=400,height=600,scrollbars=1\');
-                }';
-     } else {
- 	$result.='function launch_navmapwin() {
-                  newWindow=open(\'/adm/navmaps?launchExternal\',\'loncapanav\',\'width=400,height=600,scrollbars=1\');
-                }';
-     }
-     if ($mode eq 'now') {
- 	$result.="\nlaunch_navmapwin();\n";
-     }
-     if ($script ne 'no') {
- 	$result.='</script>';
-     }
-     if ($mode eq 'link') {
- 	&add_linkitem($toplinkitems,'launchnav','launch_navmapwin()',
- 		      "Launch navigation window");
-     }
-     return $result;
- }
  sub close {
      if ($env{'environment.remotenavmap'} ne 'on') { return ''; }
      return(<<ENDCLOSE);
- Line 145  this.document.navform.submit();
+ Line 544  this.document.navform.submit();
  ENDUPDATE
  }
- sub handler {
-     my $r = shift;
-     real_handler($r);
- }
- sub real_handler {
-     my $r = shift;
-     #my $t0=[&gettimeofday()];
-     # Handle header-only request
-     if ($r->header_only) {
-         if ($env{'browser.mathml'}) {
-             &Apache::loncommon::content_type($r,'text/xml');
-         } else {
-             &Apache::loncommon::content_type($r,'text/html');
-         }
-         $r->send_http_header;
-         return OK;
-     }
-     # Send header, don't cache this page
-     if ($env{'browser.mathml'}) {
-         &Apache::loncommon::content_type($r,'text/xml');
-     } else {
-         &Apache::loncommon::content_type($r,'text/html');
-     }
-     &Apache::loncommon::no_cache($r);
-     my %toplinkitems=();
-     &add_linkitem(\%toplinkitems,'blank','',"Select Action");
-     if ($ENV{QUERY_STRING} eq 'collapseExternal') {
- 	&Apache::lonnet::put('environment',{'remotenavmap' => 'off'});
- 	&Apache::lonnet::appenv('environment.remotenavmap' => 'off');
- 	my $menu=&Apache::lonmenu::reopenmenu();
- 	my $navstatus=&Apache::lonmenu::get_nav_status();
- 	if ($menu) {
- 	    $menu=(<<MENU)
-              swmenu=$menu
-              swmenu.clearTimeout(swmenu.menucltim);
- 	     $navstatus
- MENU
-         } else {
- 	    my $nothing = &Apache::lonhtmlcommon::javascript_nothing();
- 	    my $mainwindow='window.open('.$nothing.',"loncapaclient","",false);';
- 	    $menu=(<<MENU)
-              swmenu=$mainwindow
- 	     $navstatus
- MENU
- 	}
-         $r->send_http_header;
- 	my $html=&Apache::lonxml::xmlbegin();
- 	$r->print(<<"ENDSUBM");
- 	$html
-         <head>
- 	  <script type="text/javascript">
-  	    function submitthis() {
- 		    $menu
- 		    self.close();
- 	    }
-   	  </script>
-         </head>
- 	<body bgcolor="#FFFFFF" onLoad="submitthis()"></body>
-         </html>
- ENDSUBM
-         return OK;
-     }
-     if ($ENV{QUERY_STRING} =~ /^launchExternal/) {
- 	&Apache::lonnet::put('environment',{'remotenavmap' => 'on'});
- 	&Apache::lonnet::appenv('environment.remotenavmap' => 'on');
-  	my $menu=&Apache::lonmenu::reopenmenu();
- 	my $navstatus=&Apache::lonmenu::get_nav_status();
- 	if ($menu) {
- 	    $r->print(<<MENU);
-              <script type="text/javascript">
-              swmenu=$menu
-              swmenu.clearTimeout(swmenu.menucltim);
- 	     $navstatus
-              </script>
- MENU
-         }
-    }
-     if ($ENV{QUERY_STRING} eq 'turningOffExternal') {
- 	$env{'environment.remotenavmap'}='off';
-     }
-     # Create the nav map
-     my $navmap = Apache::lonnavmaps::navmap->new();
-     if (!defined($navmap)) {
-         my $requrl = $r->uri;
-         $env{'user.error.msg'} = "$requrl:bre:0:0:Course not initialized";
-         return HTTP_NOT_ACCEPTABLE;
-     }
-     $r->send_http_header;
-     my $html=&Apache::lonxml::xmlbegin();
-     $r->print("$html<head>\n");
-     $r->print("<title>".&mt('Navigate Course Contents')."</title>");
- # ------------------------------------------------------------ Get query string
-     &Apache::loncommon::get_unprocessed_cgi($ENV{'QUERY_STRING'},['register','sort','showOnlyHomework','postsymb']);
- # ----------------------------------------------------- Force menu registration
-     my $addentries='';
-     my $more_unload;
-     my $body_only='';
-     if ($env{'environment.remotenavmap'} eq 'on') {
- 	$r->print('<script type="text/javascript">
-                       function collapse() {
-                          this.document.location="/adm/navmaps?collapseExternal";
-                       }
-                    </script>');
- # FIXME need to be smarter to only catch window close events
- #	$more_unload="collapse()"
- 	$body_only=1;
-     }
-     if ($env{'form.register'}) {
- 	$addentries=' onLoad="'.&Apache::lonmenu::loadevents().
- 	    '" onUnload="'.&Apache::lonmenu::unloadevents().';'.
- 	    $more_unload.'"';
- 	$r->print(&Apache::lonmenu::registerurl(1));
-     } else {
- 	$addentries=' onUnload="'.$more_unload.'"';
-     }
-     # Header
-     $r->print('</head>'.
-               &Apache::loncommon::bodytag('Navigate Course Contents','',
- 					  $addentries,$body_only,'',
- 					  $env{'form.register'}));
-     $r->print('<script>window.focus();</script>');
-     $r->rflush();
-     # Check that it's defined
-     if (!($navmap->courseMapDefined())) {
- 	$r->print(&Apache::loncommon::help_open_menu('','Navigation Screen','Navigation_Screen','',undef,'RAT'));
-         $r->print('<font size="+2" color="red">Coursemap undefined.</font>' .
-                   '</body></html>');
-         return OK;
-     }
-     # See if there's only one map in the top-level, if we don't
-     # already have a filter... if so, automatically display it
-     # (older code; should use retrieveResources)
-     if ($ENV{QUERY_STRING} !~ /filter/) {
-         my $iterator = $navmap->getIterator(undef, undef, undef, 0);
-         my $curRes;
-         my $sequenceCount = 0;
-         my $sequenceId;
-         while ($curRes = $iterator->next()) {
-             if (ref($curRes) && $curRes->is_sequence()) {
-                 $sequenceCount++;
-                 $sequenceId = $curRes->map_pc();
-             }
-         }
-         if ($sequenceCount == 1) {
-             # The automatic iterator creation in the render call
-             # will pick this up. We know the condition because
-             # the defined($env{'form.filter'}) also ensures this
-             # is a fresh call.
-             $env{'form.filter'} = "$sequenceId";
-         }
-     }
-     if ($ENV{QUERY_STRING} eq 'launchExternal') {
- 	$r->print('
-           <form name="returnwin" action="/adm/flip?postdata=navlaunch%3a"
-                 method="post" target="loncapaclient">
-           </form>');
- 	$r->print('
-           <script type="text/javascript">
-               this.document.returnwin.submit();
-           </script>');
-     }
-     if ($env{'environment.remotenavmap'} ne 'on') {
- 	$r->print(&launch_win('link','yes',\%toplinkitems));
-     }
-     if ($env{'environment.remotenavmap'} eq 'on') {
- 	&add_linkitem(\%toplinkitems,'closenav','collapse()',
- 		      "Close navigation window");
-     }
-     my $jumpToFirstHomework = 0;
-     # Check to see if the student is jumping to next open, do-able problem
-     if ($ENV{QUERY_STRING} =~ /^jumpToFirstHomework/) {
-         $jumpToFirstHomework = 1;
-         # Find the next homework problem that they can do.
-         my $iterator = $navmap->getIterator(undef, undef, undef, 1);
-         my $curRes;
-         my $foundDoableProblem = 0;
-         my $problemRes;
-         while (($curRes = $iterator->next()) && !$foundDoableProblem) {
-             if (ref($curRes) && $curRes->is_problem()) {
-                 my $status = $curRes->status();
-                 if ($curRes->completable()) {
-                     $problemRes = $curRes;
-                     $foundDoableProblem = 1;
-                     # Pop open all previous maps
-                     my $stack = $iterator->getStack();
-                     pop @$stack; # last resource in the stack is the problem
-                                  # itself, which we don't need in the map stack
-                     my @mapPcs = map {$_->map_pc()} @$stack;
-                     $env{'form.filter'} = join(',', @mapPcs);
-                     # Mark as both "here" and "jump"
-                     $env{'form.postsymb'} = $curRes->symb();
-                 }
-             }
-         }
-         # If we found no problems, print a note to that effect.
-         if (!$foundDoableProblem) {
-             $r->print("<font size='+2'>All homework assignments have been completed.</font><br /><br />");
-         }
-     } else {
- 	&add_linkitem(\%toplinkitems,'firsthomework',
- 		      'location.href="navmaps?jumpToFirstHomework"',
- 		      "Show Me My First Homework Problem");
-     }
-     my $suppressEmptySequences = 0;
-     my $filterFunc = undef;
-     my $resource_no_folder_link = 0;
-     # Display only due homework.
-     my $showOnlyHomework = 0;
-     if ($env{'form.showOnlyHomework'} eq "1") {
-         $showOnlyHomework = 1;
-         $suppressEmptySequences = 1;
-         $filterFunc = sub { my $res = shift;
-                             return $res->completable() || $res->is_map();
-                         };
- 	&add_linkitem(\%toplinkitems,'everything',
- 		     'location.href="navmaps?sort='.$env{'form.sort'}.'"',
- 		      "Show Everything");
-         $r->print("<p><font size='+2'>".&mt("Uncompleted Homework")."</font></p>");
-         $env{'form.filter'} = '';
-         $env{'form.condition'} = 1;
- 	$resource_no_folder_link = 1;
-     } else {
- 	&add_linkitem(\%toplinkitems,'uncompleted',
- 		      'location.href="navmaps?sort='.$env{'form.sort'}.
- 		          '&showOnlyHomework=1"',
- 		      "Show Only Uncompleted Homework");
-     }
-     my %selected=($env{'form.sort'} => 'selected=on');
-     my $sort_html=("<form>
-                  <nobr>
-                     <input type=\"hidden\" name=\"showOnlyHomework\" value=\"".$env{'form.showOnlyHomework'}."\" />
-                     <input type=\"submit\" value=\"".&mt('Sort by:')."\" />
-                     <select name=\"sort\">
-                        <option value=\"default\" $selected{'default'}>".&mt('Default')."</option>
-                        <option value=\"title\"   $selected{'title'}  >".&mt('Title')."</option>
-                        <option value=\"duedate\" $selected{'duedate'}>".&mt('Duedate')."</option>
-                        <option value=\"discussion\" $selected{'discussion'}>".&mt('Has New Discussion')."</option>
-                     </select>
-                  </nobr>
-                </form>");
-     # renderer call
-     my $renderArgs = { 'cols' => [0,1,2,3],
- 		       'sort' => $env{'form.sort'},
-                        'url' => '/adm/navmaps',
-                        'navmap' => $navmap,
-                        'suppressNavmap' => 1,
-                        'suppressEmptySequences' => $suppressEmptySequences,
-                        'filterFunc' => $filterFunc,
- 		       'resource_no_folder_link' => $resource_no_folder_link,
- 		       'sort_html'=> $sort_html,
-                        'r' => $r,
-                        'caller' => 'navmapsdisplay',
-                        'linkitems' => \%toplinkitems};
-     my $render = render($renderArgs);
-     # If no resources were printed, print a reassuring message so the
-     # user knows there was no error.
-     if ($renderArgs->{'counter'} == 0) {
-         if ($showOnlyHomework) {
-             $r->print("<p><font size='+1'>".&mt("All homework is currently completed").".</font></p>");
-         } else { # both jumpToFirstHomework and normal use the same: course must be empty
-             $r->print("<p><font size='+1'>This course is empty.</font></p>");
-         }
-     }
-     #my $td=&tv_interval($t0);
-     #$r->print("<br />$td");
-     $r->print("</body></html>");
-     $r->rflush();
-     return OK;
- }
  # Convenience functions: Returns a string that adds or subtracts
  # the second argument from the first hash, appropriate for the
  # query string that determines which folders to recurse on
- Line 472  sub getLinkForResource {
+ Line 576  sub getLinkForResource {
          if (defined($res)) {
  	    my $anchor;
  	    if ($res->is_page()) {
- 		foreach (@$stack) { if (defined($_)) { $anchor = $_; }  }
+ 		foreach my $item (@$stack) { if (defined($item)) { $anchor = $item; }  }
- 		$anchor=&Apache::lonnet::escape($anchor->shown_symb());
+ 		$anchor=&escape($anchor->shown_symb());
  		return ($res->link(),$res->shown_symb(),$anchor);
  	    }
              # in case folder was skipped over as "only sequence"
  	    my ($map,$id,$src)=&Apache::lonnet::decode_symb($res->symb());
  	    if ($map=~/\.page$/) {
  		my $url=&Apache::lonnet::clutter($map);
- 		$anchor=&Apache::lonnet::escape($src->shown_symb());
+ 		$anchor=&escape($src->shown_symb());
  		return ($url,$res->shown_symb(),$anchor);
  	    }
          }
- Line 490  sub getLinkForResource {
+ Line 594  sub getLinkForResource {
      # (when we first recurse on a map, it puts an undefined resource
      # on the bottom because $self->{HERE} isn't defined yet, and we
      # want the src for the map anyhow)
-     foreach (@$stack) {
+     foreach my $item (@$stack) {
-         if (defined($_)) { $res = $_; }
+         if (defined($item)) { $res = $item; }
      }
-     return ($res->link(),$res->shown_symb());
+     if ($res) {
+ 	return ($res->link(),$res->shown_symb());
+     }
+     return;
  }
  # Convenience function: This separates the logic of how to create
- Line 508  sub getDescription {
+ Line 615  sub getDescription {
      my $part = shift;
      my $status = $res->status($part);
+     my $open = $res->opendate($part);
+     my $due = $res->duedate($part);
+     my $answer = $res->answerdate($part);
      if ($status == $res->NETWORK_FAILURE) {
          return &mt("Having technical difficulties; please check status later");
      }
- Line 515  sub getDescription {
+ Line 626  sub getDescription {
          return &mt("Not currently assigned.");
      }
      if ($status == $res->OPEN_LATER) {
-         return "Open " . timeToHumanString($res->opendate($part),'start');
+         return &mt("Open ") .timeToHumanString($open,'start');
      }
      if ($status == $res->OPEN) {
-         if ($res->duedate($part)) {
+         if ($due) {
-             return &mt("Due")."  " .timeToHumanString($res->duedate($part),'end');
+ 	    if ($res->is_practice()) {
+ 		return &mt("Closes ")."  " .timeToHumanString($due,'start');
+ 	    } else {
+ 		return &mt("Due")."  " .timeToHumanString($due,'end');
+ 	    }
          } else {
              return &mt("Open, no due date");
          }
      }
      if ($status == $res->PAST_DUE_ANSWER_LATER) {
-         return &mt("Answer open")." " . timeToHumanString($res->answerdate($part),'start');
+         return &mt("Answer open")." " .timeToHumanString($answer,'start');
      }
      if ($status == $res->PAST_DUE_NO_ANSWER) {
-         return &mt("Was due")." " . timeToHumanString($res->duedate($part),'end');
+ 	if ($res->is_practice()) {
+ 	    return &mt("Closed")." " . timeToHumanString($due,'start');
+ 	} else {
+ 	    return &mt("Was due")." " . timeToHumanString($due,'end');
+ 	}
      }
-     if ($status == $res->ANSWER_OPEN || $status == $res->PARTIALLY_CORRECT) {
+     if (($status == $res->ANSWER_OPEN || $status == $res->PARTIALLY_CORRECT)
+ 	&& $res->handgrade($part) ne 'yes') {
          return &mt("Answer available");
      }
      if ($status == $res->EXCUSED) {
- Line 544  sub getDescription {
+ Line 664  sub getDescription {
          my $maxtries = $res->maxtries($part);
          my $triesString = "";
          if ($tries && $maxtries) {
-             $triesString = "<font size=\"-1\"><i>($tries of $maxtries tries used)</i></font>";
+             $triesString = '<font size="-1"><i>('.&mt('[_1] of [_2] tries used',$tries,$maxtries).')</i></font>';
              if ($maxtries > 1 && $maxtries - $tries == 1) {
                  $triesString = "<b>$triesString</b>";
              }
          }
-         if ($res->duedate($part)) {
+         if ($due) {
-             return &mt("Due")." " . timeToHumanString($res->duedate($part),'end') .
+             return &mt("Due")." " . timeToHumanString($due,'end') .
                  " $triesString";
          } else {
              return &mt("No due date")." $triesString";
- Line 561  sub getDescription {
+ Line 681  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?
  sub dueInLessThan24Hours {
- Line 576  sub dueInLessThan24Hours {
+ Line 696  sub dueInLessThan24Hours {
  }
  # 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 {
      my $res = shift;
      my $part = shift;
- Line 617  sub timeToHumanString {
+ Line 737  sub timeToHumanString {
      }
      my $now = time();
-     my @time = localtime($time);
-     my @now = localtime($now);
      # Positive = future
      my $delta = $time - $now;
- Line 645  sub timeToHumanString {
+ Line 762  sub timeToHumanString {
          my $tense = $inPast ? " ago" : "";
          my $prefix = $inPast ? "" : "in ";
-         # Less then a minute
+         # Less than a minute
          if ( $delta < $minute ) {
              if ($delta == 1) { return "${prefix}1 second$tense"; }
              return "$prefix$delta seconds$tense";
          }
-         # Less then an hour
+         # Less than an hour
          if ( $delta < $hour ) {
              # If so, use minutes
              my $minutes = floor($delta / 60);
- Line 659  sub timeToHumanString {
+ Line 776  sub timeToHumanString {
              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
          if ( $delta < $hour * 24) {
              my $hours = floor($delta / $hour);
- Line 678  sub timeToHumanString {
+ Line 795  sub timeToHumanString {
              return "$prefix$hourString$minuteString$tense";
          }
+ 	my $dt = DateTime->from_epoch(epoch => $time)
+ 	                 ->set_time_zone(&Apache::lonlocal::gettimezone());
  	# If there's a caller supplied format, use it.
- 	if($format ne '') {
+ 	if ($format ne '') {
- 	    my $timeStr = strftime($format, localtime($time));
+ 	    my $timeStr = $dt->strftime($format);
- 	    return $timeStr.&Apache::lonlocal::gettimezone();
+ 	    return $timeStr.' ('.$dt->time_zone_short_name().')';
  	}
-         # Less then 5 days away, display day of the week and
+         # Less than 5 days away, display day of the week and
          # HH:MM
          if ( $delta < $day * 5 ) {
-             my $timeStr = strftime("%A, %b %e at %I:%M %P", localtime($time));
+             my $timeStr = $dt->strftime("%A, %b %e at %I:%M %P (%Z)");
              $timeStr =~ s/12:00 am/00:00/;
              $timeStr =~ s/12:00 pm/noon/;
              return ($inPast ? "last " : "this ") .
-                 $timeStr.&Apache::lonlocal::gettimezone();
+                 $timeStr;
          }
  	my $conjunction='on';
- Line 703  sub timeToHumanString {
+ Line 823  sub timeToHumanString {
  	    $conjunction='by';
  	}
          # Is it this year?
-         if ( $time[5] == $now[5]) {
+ 	my $dt_now = DateTime->from_epoch(epoch => $now)
+ 	                     ->set_time_zone(&Apache::lonlocal::gettimezone());
+         if ( $dt->year() == $dt_now->year()) {
              # Return on Month Day, HH:MM meridian
-             my $timeStr = strftime("$conjunction %A, %b %e at %I:%M %P", localtime($time));
+             my $timeStr = $dt->strftime("$conjunction %A, %b %e at %I:%M %P (%Z)");
              $timeStr =~ s/12:00 am/00:00/;
              $timeStr =~ s/12:00 pm/noon/;
-             return $timeStr.&Apache::lonlocal::gettimezone();
+             return $timeStr;
          }
          # Not this year, so show the year
-         my $timeStr = strftime("$conjunction %A, %b %e %Y at %I:%M %P", localtime($time));
+         my $timeStr =
+ 	    $dt->strftime("$conjunction %A, %b %e %Y at %I:%M %P (%Z)");
          $timeStr =~ s/12:00 am/00:00/;
          $timeStr =~ s/12:00 pm/noon/;
-         return $timeStr.&Apache::lonlocal::gettimezone();
+         return $timeStr;
      }
  }
- =pod
- =head1 NAME
- Apache::lonnavmap - Subroutines to handle and render the navigation
-     maps
- =head1 SYNOPSIS
- The main handler generates the navigational listing for the course,
- the other objects export this information in a usable fashion for
- other modules.
- =head1 OVERVIEW
- X<lonnavmaps, overview> When a user enters a course, LON-CAPA examines the
- course structure and caches it in what is often referred to as the
- "big hash" X<big hash>. You can see it if you are logged into
- LON-CAPA, in a course, by going to /adm/test. (You may need to
- tweak the /home/httpd/lonTabs/htpasswd file to view it.) The
- content of the hash will be under the heading "Big Hash".
- Big Hash contains, among other things, how resources are related
- to each other (next/previous), what resources are maps, which
- resources are being chosen to not show to the student (for random
- selection), and a lot of other things that can take a lot of time
- to compute due to the amount of data that needs to be collected and
- processed.
- Apache::lonnavmaps provides an object model for manipulating this
- information in a higher-level fashion then directly manipulating
- the hash. It also provides access to several auxilary functions
- that aren't necessarily stored in the Big Hash, but are a per-
- resource sort of value, like whether there is any feedback on
- a given resource.
- Apache::lonnavmaps also abstracts away branching, and someday,
- conditions, for the times where you don't really care about those
- things.
- Apache::lonnavmaps also provides fairly powerful routines for
- rendering navmaps, and last but not least, provides the navmaps
- view for when the user clicks the NAV button.
- B<Note>: Apache::lonnavmaps I<only> works for the "currently
- logged in user"; if you want things like "due dates for another
- student" lonnavmaps can not directly retrieve information like
- that. You need the EXT function. This module can still help,
- because many things, such as the course structure, are constant
- between users, and Apache::lonnavmaps can help by providing
- symbs for the EXT call.
- The rest of this file will cover the provided rendering routines,
- which can often be used without fiddling with the navmap object at
- all, then documents the Apache::lonnavmaps::navmap object, which
- is the key to accessing the Big Hash information, covers the use
- of the Iterator (which provides the logic for traversing the
- somewhat-complicated Big Hash data structure), documents the
- Apache::lonnavmaps::Resource objects that are returned by
- =head1 Subroutine: render
- The navmap renderer package provides a sophisticated rendering of the
- standard navigation maps interface into HTML. The provided nav map
- handler is actually just a glorified call to this.
- Because of the large number of parameters this function accepts,
- instead of passing it arguments as is normal, pass it in an anonymous
- hash with the desired options.
- The package provides a function called 'render', called as
- Apache::lonnavmaps::render({}).
- =head2 Overview of Columns
- 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
- resource (or possibly each part). You tell the renderer how many
- columns to create and what to place in each column, optionally using
- one or more of the prepared columns, and the renderer will assemble
- the table.
- Any additional generally useful column types should be placed in the
- renderer code here, so anybody can use it anywhere else. Any code
- specific to the current application (such as the addition of <input>
- elements in a column) should be placed in the code of the thing using
- the renderer.
- At the core of the renderer is the array reference COLS (see Example
- section below for how to pass this correctly). The COLS array will
- consist of entries of one of two types of things: Either an integer
- representing one of the pre-packaged column types, or a sub reference
- that takes a resource reference, a part number, and a reference to the
- argument hash passed to the renderer, and returns a string that will
- be inserted into the HTML representation as it.
- All other parameters are ways of either changing how the columns
- are printing, or which rows are shown.
- The pre-packaged column names are refered to by constants in the
- Apache::lonnavmaps namespace. The following currently exist:
- =over 4
- =item * B<Apache::lonnavmaps::resource>:
- The general info about the resource: Link, icon for the type, etc. The
- first column in the standard nav map display. This column provides the
- indentation effect seen in the B<NAV> screen. This column also accepts
- the following parameters in the renderer hash:
- =over 4
- =item * B<resource_nolink>: default false
- If true, the resource will not be linked. By default, all non-folder
- resources are linked.
- =item * B<resource_part_count>: default true
- If true, the resource will show a part count B<if> the full
- part list is not displayed. (See "condense_parts" later.) If false,
- the resource will never show a part count.
- =item * B<resource_no_folder_link>:
- If true, the resource's folder will not be clickable to open or close
- it. Default is false. True implies printCloseAll is false, since you
- can't close or open folders when this is on anyhow.
- =back
- =item * B<Apache::lonnavmaps::communication_status>:
- Whether there is discussion on the resource, email for the user, or
- (lumped in here) perl errors in the execution of the problem. This is
- the second column in the main nav map.
- =item * B<Apache::lonnavmaps::quick_status>:
- An icon for the status of a problem, with five possible states:
- Correct, incorrect, open, awaiting grading (for a problem where the
- computer's grade is suppressed, or the computer can't grade, like
- essay problem), or none (not open yet, not a problem). The
- third column of the standard navmap.
- =item * B<Apache::lonnavmaps::long_status>:
- A text readout of the details of the current status of the problem,
- such as "Due in 22 hours". The fourth column of the standard navmap.
- =item * B<Apache::lonnavmaps::part_status_summary>:
- A text readout summarizing the status of the problem. If it is a
- single part problem, will display "Correct", "Incorrect",
- "Not yet open", "Open", "Attempted", or "Error". If there are
- multiple parts, this will output a string that in HTML will show a
- status of how many parts are in each status, in color coding, trying
- to match the colors of the icons within reason.
- Note this only makes sense if you are I<not> showing parts. If
- C<showParts> is true (see below), this column will not output
- anything.
- =back
- If you add any others please be sure to document them here.
- An example of a column renderer that will show the ID number of a
- resource, along with the part name if any:
-  sub {
-   my ($resource, $part, $params) = @_;
-   if ($part) { return '<td>' . $resource->{ID} . ' ' . $part . '</td>'; }
-   return '<td>' . $resource->{ID} . '</td>';
-  }
- Note these functions are responsible for the TD tags, which allow them
- to override vertical and horizontal alignment, etc.
- =head2 Parameters
- Minimally, you should be
- able to get away with just using 'cols' (to specify the columns
- shown), 'url' (necessary for the folders to link to the current screen
- correctly), and possibly 'queryString' if your app calls for it. In
- that case, maintaining the state of the folders will be done
- automatically.
- =over 4
- =item * B<iterator>: default: constructs one from %env
- A reference to a fresh ::iterator to use from the navmaps. The
- rendering will reflect the options passed to the iterator, so you can
- use that to just render a certain part of the course, if you like. If
- one is not passed, the renderer will attempt to construct one from
- env{'form.filter'} and env{'form.condition'} information, plus the
- 'iterator_map' parameter if any.
- =item * B<iterator_map>: default: not used
- If you are letting the renderer do the iterator handling, you can
- instruct the renderer to render only a particular map by passing it
- the source of the map you want to process, like
- '/res/103/jerf/navmap.course.sequence'.
- =item * B<navmap>: default: constructs one from %env
- A reference to a navmap, used only if an iterator is not passed in. If
- this is necessary to make an iterator but it is not passed in, a new
- one will be constructed based on env info. This is useful to do basic
- error checking before passing it off to render.
- =item * B<r>: default: must be passed in
- The standard Apache response object. This must be passed to the
- renderer or the course hash will be locked.
- =item * B<cols>: default: empty (useless)
- An array reference
- =item * B<showParts>:default true
- A flag. If true, a line for the resource itself, and a line
- for each part will be displayed. If not, only one line for each
- resource will be displayed.
- =item * B<condenseParts>: default true
- A flag. If true, if all parts of the problem have the same
- status and that status is Nothing Set, Correct, or Network Failure,
- then only one line will be displayed for that resource anyhow. If no,
- all parts will always be displayed. If showParts is 0, this is
- ignored.
- =item * B<jumpCount>: default: determined from %env
- A string identifying the URL to place the anchor 'curloc' at.
- It is the responsibility of the renderer user to
- ensure that the #curloc is in the URL. By default, determined through
- the use of the env{} 'jump' information, and should normally "just
- work" correctly.
- =item * B<here>: default: empty string
- A Symb identifying where to place the 'here' marker. The empty
- string means no marker.
- =item * B<indentString>: default: 25 pixel whitespace image
- A string identifying the indentation string to use.
- =item * B<queryString>: default: empty
- A string which will be prepended to the query string used when the
- folders are opened or closed. You can use this to pass
- application-specific values.
- =item * B<url>: default: none
- The url the folders will link to, which should be the current
- page. Required if the resource info column is shown, and you
- are allowing the user to open and close folders.
- =item * B<currentJumpIndex>: default: no jumping
- Describes the currently-open row number to cause the browser to jump
- to, because the user just opened that folder. By default, pulled from
- the Jump information in the env{'form.*'}.
- =item * B<printKey>: default: false
- If true, print the key that appears on the top of the standard
- navmaps.
- =item * B<printCloseAll>: default: true
- If true, print the "Close all folders" or "open all folders"
- links.
- =item * B<filterFunc>: default: sub {return 1;} (accept everything)
- A function that takes the resource object as its only parameter and
- returns a true or false value. If true, the resource is displayed. If
- false, it is simply skipped in the display.
- =item * B<suppressEmptySequences>: default: false
- 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; for example, see the "Show Uncompleted Homework" view on the
- B<NAV> screen.
- =item * B<suppressNavmaps>: default: false
- If true, will not display Navigate Content resources.
- =back
- =head2 Additional Info
- In addition to the parameters you can pass to the renderer, which will
- be passed through unchange to the column renderers, the renderer will
- generate the following information which your renderer may find
- useful:
- =over 4
- =item * B<counter>:
- Contains the number of rows printed. Useful after calling the render
- function, as you can detect whether anything was printed at all.
- =item * B<isNewBranch>:
- Useful for renderers: If this resource is currently the first resource
- of a new branch, this will be true. The Resource column (leftmost in the
- navmaps screen) uses this to display the "new branch" icon
- =back
- =cut
  sub resource { return 0; }
  sub communication_status { return 1; }
  sub quick_status { return 2; }
- Line 1094  sub render_resource {
+ Line 890  sub render_resource {
      if ($resource->is_problem()) {
          if ($part eq '0' || $params->{'condensed'}) {
-             $icon ='<img src="'.$location.'/problem.gif" alt="&nbsp;&nbsp;" border="0" />';
+ 	    $icon = '<img src="'.$location.'/';
+ 	    if ($resource->is_task()) {
+ 		$icon .= 'task.gif" alt="'.&mt('Task');
+ 	    } else {
+ 		$icon .= 'problem.gif" alt="'.&mt('Problem');
+ 	    }
+ 	    $icon .='" border="0" />';
          } else {
              $icon = $params->{'indentString'};
          }
- Line 1111  sub render_resource {
+ Line 913  sub render_resource {
          }
  	my $folderType = $resource->is_sequence() ? 'folder' : 'page';
+         my $title=$resource->title;
+         $title=~s/\"/\&quot;/g;
          if (!$params->{'resource_no_folder_link'}) {
              $icon = "navmap.$folderType." . ($nowOpen ? 'closed' : 'open') . '.gif';
- 	    $icon = "<img src='$location/$icon' alt='".
+ 	    $icon = "<img src='$location/$icon' alt=\"".
- 		($nowOpen ? 'Open Folder' : 'Close Folder')."' border='0' />";
+ 		($nowOpen ? &mt('Open Folder') : &mt('Close Folder')).' '.$title."\" border='0' />";
              $linkopen = "<a href=\"" . $params->{'url'} . '?' .
-                 $params->{'queryString'} . '&filter=';
+                 $params->{'queryString'} . '&amp;filter=';
              $linkopen .= ($nowOpen xor $it->{CONDITION}) ?
                  addToFilter($filter, $mapId) :
                  removeFromFilter($filter, $mapId);
-             $linkopen .= "&condition=" . $it->{CONDITION} . '&hereType='
+             $linkopen .= "&amp;condition=" . $it->{CONDITION} . '&amp;hereType='
-                 . $params->{'hereType'} . '&here=' .
+                 . $params->{'hereType'} . '&amp;here=' .
-                 &Apache::lonnet::escape($params->{'here'}) .
+                 &escape($params->{'here'}) .
-                 '&jump=' .
+                 '&amp;jump=' .
-                 &Apache::lonnet::escape($resource->symb()) .
+                 &escape($resource->symb()) .
-                 "&folderManip=1\">";
+                 "&amp;folderManip=1\">";
          } else {
              # Don't allow users to manipulate folder
              $icon = "navmap.$folderType." . ($nowOpen ? 'closed' : 'open') .
                  '.nomanip.gif';
-             $icon = "<img src='$location/$icon' alt='".
+             $icon = "<img src='$location/$icon' alt=\"".
- 		($nowOpen ? 'Open Folder' : 'Close Folder')."' border='0' />";
+ 		($nowOpen ? &mt('Open Folder') : &mt('Close Folder')).' '.$title."\" border='0' />";
              $linkopen = "";
              $linkclose = "";
- Line 1142  sub render_resource {
+ Line 945  sub render_resource {
      }
      if ($resource->randomout()) {
-         $nonLinkedText .= ' <i>(hidden)</i> ';
+         $nonLinkedText .= ' <i>('.&mt('hidden').')</i> ';
      }
      if (!$resource->condval()) {
-         $nonLinkedText .= ' <i>(conditionally hidden)</i> ';
+         $nonLinkedText .= ' <i>('.&mt('conditionally hidden').')</i> ';
      }
+     if (($resource->is_practice()) && ($resource->is_raw_problem())) {
+         $nonLinkedText .=' <font color="green"><b>'.&mt('not graded').'</b></font>';
+     }
      # We're done preparing and finally ready to start the rendering
-     my $result = "<td align='left' valign='center'>";
+     my $result = "<td align='left' valign='middle'>";
      my $indentLevel = $params->{'indentLevel'};
      if ($newBranchText) { $indentLevel--; }
- Line 1177  sub render_resource {
+ Line 983  sub render_resource {
      if ($resource->is_problem() && $part ne '0' &&
          !$params->{'condensed'}) {
  	my $displaypart=$resource->part_display($part);
-         $partLabel = " (Part: $displaypart)";
+         $partLabel = " (".&mt('Part: [_1]', $displaypart).")";
- 	if ($link!~/\#/) { $link.='#'.&Apache::lonnet::escape($part); }
+ 	if ($link!~/\#/) { $link.='#'.&escape($part); }
          $title = "";
      }
      if ($params->{'condensed'} && $resource->countParts() > 1) {
-         $nonLinkedText .= ' (' . $resource->countParts() . ' parts)';
+         $nonLinkedText .= ' ('.&mt('[_1] parts', $resource->countParts()).')';
      }
      my $target;
- Line 1213  sub render_communication_status {
+ Line 1019  sub render_communication_status {
      my $location=&Apache::loncommon::lonhttpdurl("/adm/lonMisc");
      if ($resource->hasDiscussion()) {
          $discussionHTML = $linkopen .
-             '<img border="0" src="'.$location.'/chat.gif" />' .
+             '<img alt="'.&mt('New Discussion').'" border="0" src="'.$location.'/chat.gif" />' .
              $linkclose;
      }
      if ($resource->getFeedback()) {
          my $feedback = $resource->getFeedback();
-         foreach (split(/\,/, $feedback)) {
+         foreach my $msgid (split(/\,/, $feedback)) {
-             if ($_) {
+             if ($msgid) {
                  $feedbackHTML .= '&nbsp;<a '.$target.' href="/adm/email?display='
-                     . &Apache::lonnet::escape($_) . '">'
+                     . &escape($msgid) . '">'
-                     . '<img src="'.$location.'/feedback.gif" '
+                     . '<img alt="'.&mt('New Email').'" src="'.$location.'/feedback.gif" '
                      . 'border="0" /></a>';
              }
          }
- Line 1232  sub render_communication_status {
+ Line 1038  sub render_communication_status {
      if ($resource->getErrors()) {
          my $errors = $resource->getErrors();
          my $errorcount = 0;
-         foreach (split(/,/, $errors)) {
+         foreach my $msgid (split(/,/, $errors)) {
              last if ($errorcount>=10); # Only output 10 bombs maximum
-             if ($_) {
+             if ($msgid) {
                  $errorcount++;
                  $errorHTML .= '&nbsp;<a '.$target.' href="/adm/email?display='
-                     . &Apache::lonnet::escape($_) . '">'
+                     . &escape($msgid) . '">'
-                     . '<img src="'.$location.'/bomb.gif" '
+                     . '<img alt="'.&mt('New Error').'" src="'.$location.'/bomb.gif" '
                      . 'border="0" /></a>';
              }
          }
- Line 1248  sub render_communication_status {
+ Line 1054  sub render_communication_status {
  	$discussionHTML = $feedbackHTML = $errorHTML = '';
      }
-     return "<td width=\"75\" align=\"left\" valign=\"center\">$discussionHTML$feedbackHTML$errorHTML&nbsp;</td>";
+     return "<td width=\"75\" align=\"left\" valign=\"middle\">$discussionHTML$feedbackHTML$errorHTML&nbsp;</td>";
  }
  sub render_quick_status {
- Line 1273  sub render_quick_status {
+ Line 1079  sub render_quick_status {
          if ($icon) {
  	    my $location=
  		&Apache::loncommon::lonhttpdurl("/adm/lonIcons/$icon");
-             $result .= "<td width='30' valign='center' width='50' align='right'>$linkopen<img width='25' height='25' src='$location' border='0' alt='$alt' />$linkclose</td>\n";
+             $result .= "<td valign='middle' width='50' align='right'>$linkopen<img width='25' height='25' src='$location' border='0' alt='$alt' />$linkclose</td>\n";
          } else {
              $result .= "<td width='30'>&nbsp;</td>\n";
          }
- Line 1285  sub render_quick_status {
+ Line 1091  sub render_quick_status {
  }
  sub render_long_status {
      my ($resource, $part, $params) = @_;
-     my $result = "<td align='right' valign='center'>\n";
+     my $result = "<td align='right' valign='middle'>\n";
      my $firstDisplayed = !$params->{'condensed'} &&
          $params->{'multipart'} && $part eq "0";
      my $color;
-     if ($resource->is_problem()) {
+     if ($resource->is_problem() || $resource->is_practice()) {
          $color = $colormap{$resource->status};
          if (dueInLessThan24Hours($resource, $part) ||
- Line 1300  sub render_long_status {
+ Line 1106  sub render_long_status {
      }
      if ($resource->kind() eq "res" &&
-         $resource->is_problem() &&
+         ($resource->is_problem() || $resource->is_practice()) &&
          !$firstDisplayed) {
          if ($color) {$result .= "<font color=\"$color\"><b>"; }
          $result .= getDescription($resource, $part);
          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
- Line 1342  my %statusStrings =
+ Line 1151  my %statusStrings =
       );
  my @statuses = ($resObj->CORRECT, $resObj->ATTEMPTED, $resObj->INCORRECT, $resObj->OPEN, $resObj->CLOSED, $resObj->ERROR);
- use Data::Dumper;
  sub render_parts_summary_status {
      my ($resource, $part, $params) = @_;
      if (!$resource->is_problem() && !$resource->contains_problem) { return '<td></td>'; }
- Line 1441  sub render {
+ Line 1249  sub render {
      # marker
      my $filterHash = {};
      # Figure out what we're not displaying
-     foreach (split(/\,/, $env{"form.filter"})) {
+     foreach my $item (split(/\,/, $env{"form.filter"})) {
-         if ($_) {
+         if ($item) {
-             $filterHash->{$_} = "1";
+             $filterHash->{$item} = "1";
          }
      }
- Line 1471  sub render {
+ Line 1279  sub render {
              $navmap = Apache::lonnavmaps::navmap->new();
  	    if (!defined($navmap)) {
  		# no londer in course
- 		return '<font color="red">No course selected</font><br />
+ 		return '<span class="LC_error">'.&mt('No course selected').'</span><br />
-                         <a href="/adm/roles">Select a course</a><br />';
+                         <a href="/adm/roles">'.&mt('Select a course').'</a><br />';
  	    }
  	}
- Line 1549  sub render {
+ Line 1357  sub render {
              $args->{'iterator'} = $it = $navmap->getIterator($firstResource, $finishResource, $filterHash, $condition);
          } else {
-             $args->{'iterator'} = $it = $navmap->getIterator(undef, undef, $filterHash, $condition);
+             $args->{'iterator'} = $it = $navmap->getIterator(undef, undef, $filterHash, $condition,undef,$args->{'include_top_level_map'});
          }
      }
- Line 1586  sub render {
+ Line 1394  sub render {
      # Print key?
      if ($printKey) {
          $result .= '<table border="0" cellpadding="2" cellspacing="0">';
-         my $date=localtime;
          $result.='<tr><td align="right" valign="bottom">Key:&nbsp;&nbsp;</td>';
  	my $location=&Apache::loncommon::lonhttpdurl("/adm/lonMisc");
          if ($navmap->{LAST_CHECK}) {
- Line 1609  sub render {
+ Line 1416  sub render {
      if ($printCloseAll && !$args->{'resource_no_folder_link'}) {
  	my ($link,$text);
          if ($condition) {
- 	    $link='"navmaps?condition=0&filter=&'.$queryString.
+ 	    $link='"navmaps?condition=0&amp;filter=&amp;'.$queryString.
- 		'&here='.&Apache::lonnet::escape($here).'"';
+ 		'&here='.&escape($here).'"';
- 	    $text='Close All Folders';
+ 	    $text='Close all folders';
          } else {
- 	    $link='"navmaps?condition=1&filter=&'.$queryString.
+ 	    $link='"navmaps?condition=1&amp;filter=&amp;'.$queryString.
- 		'&here='.&Apache::lonnet::escape($here).'"';
+ 		'&here='.&escape($here).'"';
- 	    $text='Open All Folders';
+ 	    $text='Open all folders';
          }
  	if ($args->{'caller'} eq 'navmapsdisplay') {
  	    &add_linkitem($args->{'linkitems'},'changefolder',
- Line 1660  END
+ Line 1467  END
      if ($args->{'caller'} eq 'navmapsdisplay') {
          $result .= '<table><tr><td>'.
-                    &Apache::loncommon::help_open_menu('','Navigation Screen','Navigation_Screen','',undef,'RAT').'</td>';
+                    &Apache::loncommon::help_open_menu('Navigation Screen','Navigation_Screen',undef,'RAT').'</td>';
  	if ($env{'environment.remotenavmap'} ne 'on') {
  	    $result .= '<td>&nbsp;</td>';
          } else {
- Line 1925  END
+ Line 1732  END
  	    my $srcHasQuestion = $src =~ /\?/;
  	    $args->{"resourceLink"} = $src.
  		($srcHasQuestion?'&':'?') .
- 		'symb=' . &Apache::lonnet::escape($symb).$anchor;
+ 		'symb=' . &escape($symb).$anchor;
  	}
          # Now, we've decided what parts to show. Loop through them and
          # show them.
- Line 2065  In order of increasing complexity and po
+ Line 1872  In order of increasing complexity and po
  =over 4
- =item * C<$navmap-E<gt>getByX>, where X is B<Id>, B<Symb>, B<Url> or B<MapPc>. This provides
+ =item * C<$navmap-E<gt>getByX>, where X is B<Id>, B<Symb> or B<MapPc> and getResourceByUrl. This provides
      various ways to obtain resource objects, based on various identifiers.
      Use this when you want to request information about one object or
      a handful of resources you already know the identities of, from some
      other source. For more about Ids, Symbs, and MapPcs, see the
      Resource documentation. Note that Url should be a B<last resort>,
-     not your first choice; it only works when there is only one
+     not your first choice; it only really works when there is only one
      instance of the resource in the course, which only applies to
-     maps, and even that may change in the future.
+     maps, and even that may change in the future (see the B<getResourceByUrl>
+     documentation for more details.)
  =item * C<my @resources = $navmap-E<gt>retrieveResources(args)>. This
      retrieves resources matching some criterion and returns them
- Line 2116  See iterator documentation below.
+ Line 1924  See iterator documentation below.
  use strict;
  use GDBM_File;
  use Apache::lonnet;
+ use LONCAPA;
  sub new {
      # magic invocation to create a class instance
- Line 2215  sub generate_email_discuss_status {
+ Line 2024  sub generate_email_discuss_status {
      my %lastread = &Apache::lonnet::dump('nohist_'.$cid.'_discuss',
                                          $env{'user.domain'},$env{'user.name'},'lastread');
      my %lastreadtime = ();
-     foreach (keys %lastread) {
+     foreach my $key (keys %lastread) {
-         my $key = $_;
+         my $shortkey = $key;
-         $key =~ s/_lastread$//;
+         $shortkey =~ s/_lastread$//;
-         $lastreadtime{$key} = $lastread{$_};
+         $lastreadtime{$shortkey} = $lastread{$key};
      }
      my %feedback=();
- Line 2228  sub generate_email_discuss_status {
+ Line 2037  sub generate_email_discuss_status {
      foreach my $msgid (@keys) {
  	if ((!$emailstatus{$msgid}) || ($emailstatus{$msgid} eq 'new')) {
- 	    my $plain=
+             my ($sendtime,$shortsubj,$fromname,$fromdomain,$status,$fromcid,
- 		&Apache::lonnet::unescape(&Apache::lonnet::unescape($msgid));
+                 $symb,$error) = &Apache::lonmsg::unpackmsgid($msgid);
- 	    if ($plain=~/ \[([^\]]+)\]\:/) {
+             &Apache::lonenc::check_decrypt(\$symb);
- 		my $url=$1;
+             if (($fromcid ne '') && ($fromcid ne $cid)) {
- 		if ($plain=~/\:Error \[/) {
+                 next;
- 		    $error{$url}.=','.$msgid;
+             }
- 		} else {
+             if (defined($symb)) {
- 		    $feedback{$url}.=','.$msgid;
+                 if (defined($error) && $error == 1) {
- 		}
+                     $error{$symb}.=','.$msgid;
- 	    }
+                 } else {
+                     $feedback{$symb}.=','.$msgid;
+                 }
+             } else {
+                 my $plain=
+                     &LONCAPA::unescape(&LONCAPA::unescape($msgid));
+                 if ($plain=~/ \[([^\]]+)\]\:/) {
+                     my $url=$1;
+                     if ($plain=~/\:Error \[/) {
+                         $error{$url}.=','.$msgid;
+                     } else {
+                         $feedback{$url}.=','.$msgid;
+                     }
+                 }
+             }
  	}
      }
-     #url's of resources that have feedbacks
+     #symbs of resources that have feedbacks (will be urls pre-2.3)
      $self->{FEEDBACK} = \%feedback;
-     #or errors
+     #or errors (will be urls pre 2.3)
      $self->{ERROR_MSG} = \%error;
      $self->{DISCUSSION_TIME} = \%discussiontime;
      $self->{EMAIL_STATUS} = \%emailstatus;
- Line 2265  sub get_user_data {
+ Line 2088  sub get_user_data {
      $self->{RETRIEVED_USER_DATA} = 1;
  }
+ sub get_discussion_data {
+     my $self = shift;
+     if ($self->{RETRIEVED_DISCUSSION_DATA}) {
+ 	return $self->{DISCUSSION_DATA};
+     }
+     $self->generate_email_discuss_status();
+     my $cid=$env{'request.course.id'};
+     my $cdom=$env{'course.'.$cid.'.domain'};
+     my $cnum=$env{'course.'.$cid.'.num'};
+     # Retrieve discussion data for resources in course
+     my %discussion_data = &Apache::lonnet::dumpstore($cid,$cdom,$cnum);
+     $self->{DISCUSSION_DATA} = \%discussion_data;
+     $self->{RETRIEVED_DISCUSSION_DATA} = 1;
+     return $self->{DISCUSSION_DATA};
+ }
  # Internal function: Takes a key to look up in the nav hash and implements internal
  # memory caching of that key.
  sub navhash {
- Line 2320  sub hasDiscussion {
+ Line 2164  sub hasDiscussion {
      }
  }
+ sub last_post_time {
+     my $self = shift;
+     my $symb = shift;
+     my $ressymb = $self->wrap_symb($symb);
+     return $self->{DISCUSSION_TIME}->{$ressymb};
+ }
+ sub discussion_info {
+     my $self = shift;
+     my $symb = shift;
+     my $filter = shift;
+     $self->get_discussion_data();
+     my $ressymb = $self->wrap_symb($symb);
+     # keys used to store bulletinboard postings use 'unwrapped' symb.
+     my $discsymb = &escape($self->unwrap_symb($ressymb));
+     my $version = $self->{DISCUSSION_DATA}{'version:'.$discsymb};
+     if (!$version) { return; }
+     my $prevread = $self->{LAST_READ}{$ressymb};
+     my $count = 0;
+     my $hiddenflag = 0;
+     my $deletedflag = 0;
+     my ($hidden,$deleted,%info);
+     for (my $id=$version; $id>0; $id--) {
+ 	my $vkeys=$self->{DISCUSSION_DATA}{$id.':keys:'.$discsymb};
+ 	my @keys=split(/:/,$vkeys);
+ 	if (grep(/^hidden$/ ,@keys)) {
+ 	    if (!$hiddenflag) {
+ 		$hidden = $self->{DISCUSSION_DATA}{$id.':'.$discsymb.':hidden'};
+ 		$hiddenflag = 1;
+ 	    }
+ 	} elsif (grep(/^deleted$/,@keys)) {
+ 	    if (!$deletedflag) {
+ 		$deleted = $self->{DISCUSSION_DATA}{$id.':'.$discsymb.':deleted'};
+ 		$deletedflag = 1;
+ 	    }
+ 	} else {
+ 	    if (($hidden !~/\.$id\./) && ($deleted !~/\.$id\./)) {
+                 if ($filter eq 'unread') {
+ 		    if ($prevread >= $self->{DISCUSSION_DATA}{$id.':'.$discsymb.':timestamp'}) {
+                         next;
+                     }
+                 }
+ 		$count++;
+ 		$info{$count}{'subject'} =
+ 		    $self->{DISCUSSION_DATA}{$id.':'.$discsymb.':subject'};
+                 $info{$count}{'id'} = $id;
+                 $info{$count}{'timestamp'} = $self->{DISCUSSION_DATA}{$id.':'.$discsymb.':timestamp'};
+             }
+ 	}
+     }
+     if (wantarray) {
+ 	return ($count,%info);
+     }
+     return $count;
+ }
  sub wrap_symb {
      my $self = shift;
      my $symb = shift;
-     if ($symb =~ m-___(adm/\w+/\w+/)(\d+)(/bulletinboard)$-) {
+     if ($symb =~ m-___(adm/[^/]+/[^/]+/)(\d+)(/bulletinboard)$-) {
          unless ($symb =~ m|adm/wrapper/adm|) {
              $symb = 'bulletin___'.$2.'___adm/wrapper/'.$1.$2.$3;
          }
- Line 2331  sub wrap_symb {
+ Line 2236  sub wrap_symb {
      return $symb;
  }
+ sub unwrap_symb {
+     my $self = shift;
+     my $ressymb = shift;
+     my $discsymb = $ressymb;
+     if ($ressymb =~ m-^(bulletin___\d+___)adm/wrapper/(adm/[^/]+/[^/]+/\d+/bulletinboard)$-) {
+          $discsymb = $1.$2;
+     }
+     return $discsymb;
+ }
  # Private method: Does the given resource (as a symb string) have
  # current feedback? Returns the string in the feedback hash, which
  # will be false if it does not exist.
- Line 2338  sub wrap_symb {
+ Line 2253  sub wrap_symb {
  sub getFeedback {
      my $self = shift;
      my $symb = shift;
+     my $source = shift;
      $self->generate_email_discuss_status();
      if (!defined($self->{FEEDBACK})) { return ""; }
-     return $self->{FEEDBACK}->{$symb};
+     my $feedback;
+     if ($self->{FEEDBACK}->{$symb}) {
+         $feedback = $self->{FEEDBACK}->{$symb};
+         if ($self->{FEEDBACK}->{$source}) {
+             $feedback .= ','.$self->{FEEDBACK}->{$source};
+         }
+     } else {
+         if ($self->{FEEDBACK}->{$source}) {
+             $feedback = $self->{FEEDBACK}->{$source};
+         }
+     }
+     return $feedback;
  }
  # Private method: Get the errors for that resource (by source).
  sub getErrors {
      my $self = shift;
+     my $symb = shift;
      my $src = shift;
      $self->generate_email_discuss_status();
      if (!defined($self->{ERROR_MSG})) { return ""; }
-     return $self->{ERROR_MSG}->{$src};
+     my $errors;
+     if ($self->{ERROR_MSG}->{$symb}) {
+         $errors = $self->{ERROR_MSG}->{$symb};
+         if ($self->{ERROR_MSG}->{$src}) {
+             $errors .= ','.$self->{ERROR_MSG}->{$src};
+         }
+     } else {
+         if ($self->{ERROR_MSG}->{$src}) {
+             $errors = $self->{ERROR_MSG}->{$src};
+         }
+     }
+     return $errors;
  }
  =pod
- Line 2380  the given map. This is one of the proper
+ Line 2320  the given map. This is one of the proper
  # 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
- # hash then we have to, which should hopefully alleviate speed problems.
+ # hash than we have to, which should hopefully alleviate speed problems.
  sub getById {
      my $self = shift;
- Line 2454  sub finishResource {
+ Line 2394  sub finishResource {
  # the actual lookup; parmval caches the results.
  sub parmval {
      my $self = shift;
-     my ($what,$symb)=@_;
+     my ($what,$symb,$recurse)=@_;
      my $hashkey = $what."|||".$symb;
      if (defined($self->{PARM_CACHE}->{$hashkey})) {
-         return $self->{PARM_CACHE}->{$hashkey};
+         if (ref($self->{PARM_CACHE}->{$hashkey}) eq 'ARRAY') {
+             if (defined($self->{PARM_CACHE}->{$hashkey}->[0])) {
+                 if (wantarray) {
+                     return @{$self->{PARM_CACHE}->{$hashkey}};
+                 } else {
+                     return $self->{PARM_CACHE}->{$hashkey}->[0];
+                 }
+             }
+         } else {
+             return $self->{PARM_CACHE}->{$hashkey};
+         }
      }
+     my $result = $self->parmval_real($what, $symb, $recurse);
-     my $result = $self->parmval_real($what, $symb);
      $self->{PARM_CACHE}->{$hashkey} = $result;
-     return $result;
+     if (wantarray) {
+         return @{$result};
+     }
+     return $result->[0];
  }
  sub parmval_real {
- Line 2484  sub parmval_real {
+ Line 2436  sub parmval_real {
      my $uname=$env{'user.name'};
      my $udom=$env{'user.domain'};
-     unless ($symb) { return ''; }
+     unless ($symb) { return ['']; }
      my $result='';
      my ($mapname,$id,$fn)=&Apache::lonnet::decode_symb($symb);
+     $mapname = &Apache::lonnet::deversion($mapname);
  # ----------------------------------------------------- Cascading lookup scheme
      my $rwhat=$what;
      $what=~s/^parameter\_//;
- Line 2516  sub parmval_real {
+ Line 2468  sub parmval_real {
  # ---------------------------------------------------------- first, check user
      if ($uname and defined($useropt)) {
-         if (defined($$useropt{$courselevelr})) { return $$useropt{$courselevelr}; }
+         if (defined($$useropt{$courselevelr})) { return [$$useropt{$courselevelr},'resource']; }
-         if (defined($$useropt{$courselevelm})) { return $$useropt{$courselevelm}; }
+         if (defined($$useropt{$courselevelm})) { return [$$useropt{$courselevelm},'map']; }
-         if (defined($$useropt{$courselevel})) { return $$useropt{$courselevel}; }
+         if (defined($$useropt{$courselevel})) { return [$$useropt{$courselevel},'course']; }
      }
  # ------------------------------------------------------- second, check course
      if ($cgroup ne '' and defined($courseopt)) {
-         if (defined($$courseopt{$grplevelr})) { return $$courseopt{$grplevelr}; }
+         if (defined($$courseopt{$grplevelr})) { return [$$courseopt{$grplevelr},'resource']; }
-         if (defined($$courseopt{$grplevelm})) { return $$courseopt{$grplevelm}; }
+         if (defined($$courseopt{$grplevelm})) { return [$$courseopt{$grplevelm},'map']; }
-         if (defined($$courseopt{$grplevel})) { return $$courseopt{$grplevel}; }
+         if (defined($$courseopt{$grplevel})) { return [$$courseopt{$grplevel},'course']; }
      }
      if ($csec and defined($courseopt)) {
-         if (defined($$courseopt{$seclevelr})) { return $$courseopt{$seclevelr}; }
+         if (defined($$courseopt{$seclevelr})) { return [$$courseopt{$seclevelr},'resource']; }
-         if (defined($$courseopt{$seclevelm})) { return $$courseopt{$seclevelm}; }
+         if (defined($$courseopt{$seclevelm})) { return [$$courseopt{$seclevelm},'map']; }
-         if (defined($$courseopt{$seclevel})) { return $$courseopt{$seclevel}; }
+         if (defined($$courseopt{$seclevel})) { return [$$courseopt{$seclevel},'course']; }
      }
      if (defined($courseopt)) {
-         if (defined($$courseopt{$courselevelr})) { return $$courseopt{$courselevelr}; }
+         if (defined($$courseopt{$courselevelr})) { return [$$courseopt{$courselevelr},'resource']; }
      }
  # ----------------------------------------------------- third, check map parms
      my $thisparm=$$parmhash{$symbparm};
-     if (defined($thisparm)) { return $thisparm; }
+     if (defined($thisparm)) { return [$thisparm,'map']; }
  # ----------------------------------------------------- fourth , check default
      my $meta_rwhat=$rwhat;
      $meta_rwhat=~s/\./_/g;
      my $default=&Apache::lonnet::metadata($fn,$meta_rwhat);
-     if (defined($default)) { return $default}
+     if (defined($default)) { return [$default,'resource']}
      $default=&Apache::lonnet::metadata($fn,'parameter_'.$meta_rwhat);
-     if (defined($default)) { return $default}
+     if (defined($default)) { return [$default,'resource']}
  # --------------------------------------------------- fifth, check more course
      if (defined($courseopt)) {
-         if (defined($$courseopt{$courselevelm})) { return $$courseopt{$courselevelm}; }
+         if (defined($$courseopt{$courselevelm})) { return [$$courseopt{$courselevelm},'map']; }
-         if (defined($$courseopt{$courselevel})) { return $$courseopt{$courselevel}; }
+         if (defined($$courseopt{$courselevel})) {
+            my $ret = [$$courseopt{$courselevel},'course'];
+            return $ret;
+        }
      }
  # --------------------------------------------------- sixth , cascade up parts
      my ($space,@qualifier)=split(/\./,$rwhat);
- Line 2567  sub parmval_real {
+ Line 2520  sub parmval_real {
  	my $id=pop(@parts);
  	my $part=join('_',@parts);
  	if ($part eq '') { $part='0'; }
- 	my $partgeneral=$self->parmval($part.".$qualifier",$symb,1);
+        my @partgeneral=$self->parmval($part.".$qualifier",$symb,1);
- 	if (defined($partgeneral)) { return $partgeneral; }
+        if (defined($partgeneral[0])) { return \@partgeneral; }
      }
-     if ($recurse) { return undef; }
+     if ($recurse) { return []; }
-     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,'resource']; }
-     return '';
+     return [''];
  }
  =pod
- Line 2581  sub parmval_real {
+ Line 2534  sub parmval_real {
  =item * B<getResourceByUrl>(url,multiple):
  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
  it, so it is safe to use this method in code like
  "$res = $navmap->getResourceByUrl($res)"
- Line 2616  all matching resources.
+ Line 2569  all matching resources.
  =item * B<hasResource>(map, filterFunc, recursive, showall):
- Convience method for
+ Convenience method for
   scalar(retrieveResources($map, $filterFunc, $recursive, 1, $showall)) > 0
- Line 2694  sub retrieveResources {
+ Line 2647  sub retrieveResources {
      my @resources = ();
+     if (&$filterFunc($map)) {
+ 	push(@resources, $map);
+     }
      # Run down the iterator and collect the resources.
      my $curRes;
- Line 2703  sub retrieveResources {
+ Line 2660  sub retrieveResources {
                  next;
              }
-             push @resources, $curRes;
+             push(@resources, $curRes);
              if ($bailout) {
                  return @resources;
- Line 2734  sub usedVersion {
+ Line 2691  sub usedVersion {
 ;
  package Apache::lonnavmaps::iterator;
- use WeakRef;
+ use Scalar::Util qw(weaken);
  use Apache::lonnet;
  =pod
- Line 2850  be the tokens described above.
+ Line 2807  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
+ code. It is difficult to get right and harder to understand than
  this. They should be migrated to this new style.
  =cut
- Line 3034  sub next {
+ Line 2991  sub next {
          $self->{HAVE_RETURNED_0} = 1;
          return $self->{NAV_MAP}->getById('0.0');
      }
+     if ($self->{RETURN_0} && !$self->{HAVE_RETURNED_0_BEGIN_MAP}) {
+ 	$self->{HAVE_RETURNED_0_BEGIN_MAP} = 1;
+ 	return $self->BEGIN_MAP();
+     }
      if ($self->{RECURSIVE_ITERATOR_FLAG}) {
          # grab the next from the recursive iterator
- Line 3135  sub next {
+ Line 3096  sub next {
      }
      # 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.
      # 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
- Line 3215  sub populateStack {
+ Line 3176  sub populateStack {
 ;
  package Apache::lonnavmaps::DFSiterator;
- use WeakRef;
+ use Scalar::Util qw(weaken);
  use Apache::lonnet;
  # Not documented in the perldoc: This is a simple iterator that just walks
- Line 3344  sub next {
+ Line 3305  sub next {
      # filter the next possibilities to remove things we've
      # already seen.
-     foreach (@$nextUnfiltered) {
+     foreach my $item (@$nextUnfiltered) {
-         if (!defined($self->{ALREADY_SEEN}->{$_->{ID}})) {
+         if (!defined($self->{ALREADY_SEEN}->{$item->{ID}})) {
-             push @$next, $_;
+             push @$next, $item;
          }
      }
- Line 3399  sub populateStack {
+ Line 3360  sub populateStack {
 ;
  package Apache::lonnavmaps::resource;
- use WeakRef;
+ use Scalar::Util qw(weaken);
  use Apache::lonnet;
  =pod
- Line 3471  X<symb> X<resource, symb>
+ Line 3432  X<symb> X<resource, symb>
  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
  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
- Line 3547  false.
+ Line 3508  false.
  =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>:
- Line 3578  sub kind { my $self=shift; return $self-
+ Line 3544  sub kind { my $self=shift; return $self-
  sub randomout { my $self=shift; return $self->navHash("randomout_", 1); }
  sub randompick {
      my $self = shift;
-     return $self->{NAV_MAP}->{PARM_HASH}->{$self->symb .
+     my $randompick = $self->parmval('randompick');
-                                                '.0.parameter_randompick'};
+     return $randompick;
+ }
+ sub randomorder {
+     my $self = shift;
+     my $randomorder = $self->parmval('randomorder');
+     return ($randomorder =~ /^yes$/i);
  }
  sub link {
      my $self=shift;
- Line 3637  sub condition {
+ Line 3608  sub condition {
  }
  sub condval {
      my $self=shift;
-     my $uri=&Apache::lonnet::deversion(&Apache::lonnet::declutter($self->src()));
+     my ($pathname,$filename) =
-     my ($pathname,$filename)=($uri=~m|(.*)/([^/]*)|);
+ 	&Apache::lonnet::split_uri_for_cond($self->src());
-     $pathname=~s/^adm\/wrapper\///;
      my $match=($env{'acc.res.'.$env{'request.course.id'}.'.'.$pathname}=~
  	       /\&\Q$filename\E\:([\d\|]+)\&/);
- Line 3658  sub compTitle {
+ Line 3628  sub compTitle {
      }
      return $title;
  }
  =pod
  B<Predicate Testing the Resource>
- Line 3698  sub retrieveResources {
+ Line 3669  sub retrieveResources {
     return $self->{NAV_MAP}->retrieveResources(@_);
  }
+ sub is_exam {
+     my ($self,$part) = @_;
+     my $type = $self->parmval('type',$part);
+     if ($type eq 'exam') {
+         return 1;
+     }
+     if ($self->src() =~ /\.(exam)$/) {
+         return 1;
+     }
+     return 0;
+ }
  sub is_html {
      my $self=shift;
      my $src = $self->src();
- Line 3710  sub is_page {
+ Line 3692  sub is_page {
      return $self->navHash("is_map_", 1) &&
  	$self->navHash("map_type_" . $self->map_pc()) eq 'page';
  }
+ sub is_practice {
+     my $self=shift;
+     my ($part) = @_;
+     my $type = $self->parmval('type',$part);
+     if ($type eq 'practice') {
+         return 1;
+     }
+     return 0;
+ }
  sub is_problem {
      my $self=shift;
      my $src = $self->src();
-     return ($src =~ /\.(problem|exam|quiz|assess|survey|form|library|task)$/)
+     if ($src =~ /\.(problem|exam|quiz|assess|survey|form|library|task)$/) {
+ 	return !($self->is_practice());
+     }
+     return 0;
+ }
+ sub is_raw_problem {
+     my $self=shift;
+     my $src = $self->src();
+     if ($src =~ /\.(problem|exam|quiz|assess|survey|form|library|task)$/) {
+         return 1;
+     }
+     return 0;
  }
  sub contains_problem {
      my $self=shift;
      if ($self->is_page()) {
- Line 3723  sub contains_problem {
+ Line 3726  sub contains_problem {
      }
      return 0;
  }
+ sub map_contains_problem {
+     my $self=shift;
+     if ($self->is_map()) {
+ 	my $has_problem=
+ 	    $self->hasResource($self,sub { $_[0]->is_problem() },1);
+ 	return $has_problem;
+     }
+     return 0;
+ }
  sub is_sequence {
      my $self=shift;
-     my $src = $self->src();
      return $self->navHash("is_map_", 1) &&
  	$self->navHash("map_type_" . $self->map_pc()) eq 'sequence';
  }
  sub is_survey {
      my $self = shift();
      my $part = shift();
-     if ($self->parmval('type',$part) eq 'survey') {
+     my $type = $self->parmval('type',$part);
+     if ($type eq 'survey') {
          return 1;
      }
      if ($self->src() =~ /\.(survey)$/) {
- Line 3740  sub is_survey {
+ Line 3752  sub is_survey {
      }
      return 0;
  }
+ sub is_task {
+     my $self=shift;
+     my $src = $self->src();
+     return ($src =~ /\.(task)$/)
+ }
  sub is_empty_sequence {
      my $self=shift;
- Line 3795  Returns a string with the type of the ma
+ Line 3812  Returns a string with the type of the ma
  sub map_finish {
      my $self = shift;
      my $src = $self->src();
-     $src = Apache::lonnet::clutter($src);
+     $src = &Apache::lonnet::clutter($src);
      my $res = $self->navHash("map_finish_$src", 0);
      $res = $self->{NAV_MAP}->getById($res);
      return $res;
- Line 3808  sub map_pc {
+ Line 3825  sub map_pc {
  sub map_start {
      my $self = shift;
      my $src = $self->src();
-     $src = Apache::lonnet::clutter($src);
+     $src = &Apache::lonnet::clutter($src);
      my $res = $self->navHash("map_start_$src", 0);
      $res = $self->{NAV_MAP}->getById($res);
      return $res;
- Line 3825  sub map_type {
+ Line 3842  sub map_type {
  # These functions will be responsible for returning the CORRECT
  # 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"
- # information, rather then the resource object user.
+ # information, rather than the resource object user.
  =pod
- Line 3903  Get the weight for the problem.
+ Line 3920  Get the weight for the problem.
  sub acc {
      (my $self, my $part) = @_;
-     return $self->parmval("acc", $part);
+     my $acc = $self->parmval("acc", $part);
+     return $acc;
  }
  sub answerdate {
      (my $self, my $part) = @_;
      # Handle intervals
-     if ($self->parmval("answerdate.type", $part) eq 'date_interval') {
+     my $answerdatetype = $self->parmval("answerdate.type", $part);
-         return $self->duedate($part) +
+     my $answerdate = $self->parmval("answerdate", $part);
-             $self->parmval("answerdate", $part);
+     my $duedate = $self->parmval("duedate", $part);
+     if ($answerdatetype eq 'date_interval') {
+         $answerdate = $duedate + $answerdate;
      }
-     return $self->parmval("answerdate", $part);
+     return $answerdate;
  }
  sub awarded {
      my $self = shift; my $part = shift;
- Line 3920  sub awarded {
+ Line 3940  sub awarded {
      if (!defined($part)) { $part = '0'; }
      return $self->{NAV_MAP}->{STUDENT_DATA}->{$self->symb()}->{'resource.'.$part.'.awarded'};
  }
+ # this should work exactly like the copy in lonhomework.pm
  sub duedate {
      (my $self, my $part) = @_;
-     my $interval=$self->parmval("interval", $part);
+     my $date;
-     if ($interval) {
+     my @interval=$self->parmval("interval", $part);
- 	my $first_access=&Apache::lonnet::get_first_access('map',$self->symb);
+     my $due_date=$self->parmval("duedate", $part);
- 	if ($first_access) { return ($first_access+$interval); }
+     if ($interval[0] =~ /\d+/) {
+        my $first_access=&Apache::lonnet::get_first_access($interval[1],
+                                                           $self->symb);
+ 	if (defined($first_access)) {
+            my $interval = $first_access+$interval[0];
+ 	    $date = (!$due_date || $interval < $due_date) ? $interval
+                                                           : $due_date;
+ 	} else {
+ 	    $date = $due_date;
+ 	}
+     } else {
+ 	$date = $due_date;
      }
-     return $self->parmval("duedate", $part);
+     return $date;
  }
  sub handgrade {
      (my $self, my $part) = @_;
-     return $self->parmval("handgrade", $part);
+     my @response_ids = $self->responseIds($part);
+     if (@response_ids) {
+ 	foreach my $response_id (@response_ids) {
+             my $handgrade = $self->parmval("handgrade",$part.'_'.$response_id);
+ 	    if (lc($handgrade) eq 'yes') {
+ 		return 'yes';
+ 	    }
+ 	}
+     }
+     my $handgrade = $self->parmval("handgrade", $part);
+     return $handgrade;
  }
  sub maxtries {
      (my $self, my $part) = @_;
-     return $self->parmval("maxtries", $part);
+     my $maxtries = $self->parmval("maxtries", $part);
+     return $maxtries;
  }
  sub opendate {
      (my $self, my $part) = @_;
-     if ($self->parmval("opendate.type", $part) eq 'date_interval') {
+     my $opendatetype = $self->parmval("opendate.type", $part);
-         return $self->duedate($part) -
+     my $opendate = $self->parmval("opendate", $part);
-             $self->parmval("opendate", $part);
+     if ($opendatetype eq 'date_interval') {
+         my $duedate = $self->duedate($part);
+         $opendate = $duedate - $opendate;
      }
-     return $self->parmval("opendate");
+     return $opendate;
  }
  sub problemstatus {
      (my $self, my $part) = @_;
-     return lc $self->parmval("problemstatus", $part);
+     my $problemstatus = $self->parmval("problemstatus", $part);
+     return lc($problemstatus);
  }
  sub sig {
      (my $self, my $part) = @_;
-     return $self->parmval("sig", $part);
+     my $sig = $self->parmval("sig", $part);
+     return $sig;
  }
  sub tol {
      (my $self, my $part) = @_;
-     return $self->parmval("tol", $part);
+     my $tol = $self->parmval("tol", $part);
+     return $tol;
  }
  sub tries {
      my $self = shift;
      my $tries = $self->queryRestoreHash('tries', shift);
      if (!defined($tries)) { return '0';}
- Line 3965  sub tries {
+ Line 4013  sub tries {
  }
  sub type {
      (my $self, my $part) = @_;
-     return $self->parmval("type", $part);
+     my $type = $self->parmval("type", $part);
+     return $type;
  }
  sub weight {
      my $self = shift; my $part = shift;
      if (!defined($part)) { $part = '0'; }
-     return &Apache::lonnet::EXT('resource.'.$part.'.weight',
+     my $weight = &Apache::lonnet::EXT('resource.'.$part.'.weight',
- 				$self->symb(), $env{'user.domain'},
+                                 $self->symb(), $env{'user.domain'},
- 				$env{'user.name'},
+                                 $env{'user.name'},
- 				$env{'request.course.sec'});
+                                 $env{'request.course.sec'});
+     return $weight;
  }
  sub part_display {
      my $self= shift(); my $partID = shift();
- Line 4024  Returns a false value if there has been
+ Line 4074  Returns a false value if there has been
  logged in, true if there has. Always returns false if the discussion
  data was not extracted when the nav map was constructed.
+ =item * B<last_post_time>:
+ Returns a false value if there hasn't been discussion otherwise returns
+ unix timestamp of last time a discussion posting (or edit) was made.
+ =item * B<discussion_info>:
+ optional argument is a filter (currently can be 'unread');
+ returns in scalar context the count of the number of discussion postings.
+ returns in list context both the count of postings and a hash ref
+ containing information about the postings (subject, id, timestamp) in a hash.
+ Default is to return counts for all postings.  However if called with a second argument set to 'unread', will return information about only unread postings.
  =item * B<getFeedback>:
  Gets the feedback for the resource and returns the raw feedback string
- Line 4031  for the resource, or the null string if
+ Line 4096  for the resource, or the null string if
  email data was not extracted when the nav map was constructed. Usually
  used like this:
-  for (split(/\,/, $res->getFeedback())) {
+  for my $url (split(/\,/, $res->getFeedback())) {
-     my $link = &Apache::lonnet::escape($_);
+     my $link = &escape($url);
      ...
  and use the link as appropriate.
- Line 4044  sub hasDiscussion {
+ Line 4109  sub hasDiscussion {
      return $self->{NAV_MAP}->hasDiscussion($self->symb());
  }
+ sub last_post_time {
+     my $self = shift;
+     return $self->{NAV_MAP}->last_post_time($self->symb());
+ }
+ sub discussion_info {
+     my ($self,$filter) = @_;
+     return $self->{NAV_MAP}->discussion_info($self->symb(),$filter);
+ }
  sub getFeedback {
      my $self = shift;
      my $source = $self->src();
+     my $symb = $self->symb();
      if ($source =~ /^\/res\//) { $source = substr $source, 5; }
-     return $self->{NAV_MAP}->getFeedback($source);
+     return $self->{NAV_MAP}->getFeedback($symb,$source);
  }
  sub getErrors {
      my $self = shift;
      my $source = $self->src();
+     my $symb = $self->symb();
      if ($source =~ /^\/res\//) { $source = substr $source, 5; }
-     return $self->{NAV_MAP}->getErrors($source);
+     return $self->{NAV_MAP}->getErrors($symb,$source);
  }
  =pod
- Line 4141  sub countResponses {
+ Line 4218  sub countResponses {
  sub responseTypes {
      my $self = shift;
      my %responses;
-     foreach my $part ($self->parts()) {
+     foreach my $part (@{$self->parts()}) {
          foreach my $responsetype ($self->responseType($part)) {
              $responses{$responsetype}++ if (defined($responsetype));
          }
- Line 4216  sub extractParts {
+ Line 4293  sub extractParts {
  		$self->{PART_TYPE} = {};
  		return;
  	    }
- 	    foreach (split(/\,/,$metadata)) {
+ 	    foreach my $entry (split(/\,/,$metadata)) {
- 		if ($_ =~ /^(?:part|Task)_(.*)$/) {
+ 		if ($entry =~ /^(?:part|Task)_(.*)$/) {
  		    my $part = $1;
  		    # This floods the logs if it blows up
  		    if (defined($parts{$part})) {
- Line 4242  sub extractParts {
+ Line 4319  sub extractParts {
          # Init the responseIdHash
-         foreach (@{$self->{PARTS}}) {
+         foreach my $part (@{$self->{PARTS}}) {
-             $responseIdHash{$_} = [];
+             $responseIdHash{$part} = [];
          }
          # Now, the unfortunate thing about this is that parts, part name, and
- Line 4252  sub extractParts {
+ Line 4329  sub extractParts {
          # 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) {
+         foreach my $data (split /,/, $metadata) {
-             if ($_ =~ /^([a-zA-Z]+)response_(.*)/) {
+             if ($data =~ /^([a-zA-Z]+)response_(.*)/
+ 		|| $data =~ /^(Task)_(.*)/) {
                  my $responseType = $1;
                  my $partStuff = $2;
                  my $partIdSoFar = '';
- Line 4265  sub extractParts {
+ Line 4343  sub extractParts {
                      if ($parts{$partIdSoFar}) {
                          my @otherChunks = @partChunks[$i+1..$#partChunks];
                          my $responseId = join('_', @otherChunks);
-                         push @{$responseIdHash{$partIdSoFar}}, $responseId;
+ 			if ($self->is_task()) {
-                         push @{$responseTypeHash{$partIdSoFar}}, $responseType;
+ 			    push(@{$responseIdHash{$partIdSoFar}},
+ 				 $partIdSoFar);
+ 			} else {
+ 			    push(@{$responseIdHash{$partIdSoFar}},
+ 				 $responseId);
+ 			}
+                         push(@{$responseTypeHash{$partIdSoFar}},
+ 			     $responseType);
                      }
                  }
              }
- Line 4315  the completion information.
+ Line 4400  the completion information.
  Idiomatic usage of these two methods would probably look something
  like
-  foreach ($resource->parts()) {
+  foreach my $part ($resource->parts()) {
-     my $dateStatus = $resource->getDateStatus($_);
+     my $dateStatus = $resource->getDateStatus($part);
-     my $completionStatus = $resource->getCompletionStatus($_);
+     my $completionStatus = $resource->getCompletionStatus($part);
      or
-     my $status = $resource->status($_);
+     my $status = $resource->status($part);
      ... use it here ...
   }
- Line 4612  sub status {
+ Line 4697  sub status {
      #if ($self->{RESOURCE_ERROR}) { return NETWORK_FAILURE; }
      if ($completionStatus == NETWORK_FAILURE) { return NETWORK_FAILURE; }
-     my $suppressFeedback = $self->problemstatus($part) eq 'no';
+     my $suppressFeedback = 0;
+     if (($self->problemstatus($part) eq 'no') ||
+         ($self->problemstatus($part) eq 'no_feedback_ever')) {
+         $suppressFeedback = 1;
+     }
      # If there's an answer date and we're past it, don't
      # suppress the feedback; student should know
      if ($self->duedate($part) && $self->duedate($part) < time() &&

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

Removed from v.1.353
changed lines
	Added in v.1.416