Return to lonquickgrades.pm CVS log

Up to [LON-CAPA] / loncom / interface

Fix some wording, remove link to spreadsheet if we're viewing grades,
change "Sequence" to "Folder" which should make more sense to the
students, and just generally look nicer (fiddling with the whitespace).

# The LearningOnline Network with CAPA
# Quick Student Grades Display
#
# $Id:
#
# Copyright Michigan State University Board of Trustees
#
# This file is part of the LearningOnline Network with CAPA (LON-CAPA).
#
# LON-CAPA is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# LON-CAPA is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with LON-CAPA; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#
# /home/httpd/html/adm/gpl.txt
#
# http://www.lon-capa.org/
#
# Created Nov. 14, 2002 by Jeremy Bowers

package Apache::lonquickgrades;

use strict;
use Apache::Constants qw(:common :http);
use POSIX;

sub handler {
    my $r = shift;
    return real_handler($r);
}

sub real_handler {
    my $r = shift;

    &Apache::loncommon::get_unprocessed_cgi($ENV{QUERY_STRING});

    # Handle header-only request
    if ($r->header_only) {
        if ($ENV{'browser.mathml'}) {
            $r->content_type('text/xml');
        } else {
            $r->content_type('text/html');
        }
        $r->send_http_header;
        return OK;
    }

    # Send header, don't cache this page
    if ($ENV{'browser.mathml'}) {
        $r->content_type('text/xml');
    } else {
        $r->content_type('text/html');
    }
    &Apache::loncommon::no_cache($r);
    $r->send_http_header;

    my $showPoints = $ENV{'course.'.$ENV{'request.course.id'}.'.grading'} eq 'standard';

    # Create the nav map
    my $navmap = Apache::lonnavmaps::navmap->new(
                        $ENV{"request.course.fn"}.".db",
                        $ENV{"request.course.fn"}."_parms.db", 1, 0, 1);

    if (!defined($navmap)) {
        my $requrl = $r->uri;
        $ENV{'user.error.msg'} = "$requrl:bre:0:0:Navamp initialization failed.";
        return HTTP_NOT_ACCEPTABLE;
    }

    # Keep this hash in sync with %statusIconMap in lonnavmaps; they
    # should match color/icon
    my $res = $navmap->firstResource(); # temp resource to access constants
 
    # Header
    my $title = $showPoints ? "Quick Points Display" : "Quick Completed Problems Display";
    $r->print(&Apache::loncommon::bodytag($title, '', ''));

    if (!$showPoints) {
        $r->print(<<HEADER); 
<p>This screen shows how many problems (or problem parts) you have completed, and
how many you have not yet done. You can also look at <a href="/adm/studentcalc">a detailed
score sheet</a>.</p>
HEADER
    }

    $r->print("This may take a few moments to display.");

    $r->rflush();

    $navmap->init();

    # End navmap using boilerplate

    my $iterator = $navmap->getIterator(undef, undef, undef, 1);
    my $depth = 1;
    $iterator->next(); # ignore first BEGIN_MAP
    my $curRes = $iterator->next();
    
    # General overview of the following: Walk along the course resources.
    # For every problem in the resource, tell its parent maps how many
    # parts and how many parts correct it has. After that, each map will
    # have a count of the total parts underneath it, correct and otherwise.
    # After that, we will walk through the course again and read off
    # maps in order, with their data. 
    # (If in the future people decide not to be cumulative, only add
    #  the counts to the parent map.)
    # For convenience, "totalParts" is also "totalPoints" when we're looking
    #  at points; I can't come up with a variable name that makes sense
    #  equally for both cases.

    my $totalParts = 0; my $totalPossible = 0; my $totalRight = 0;
    my $now = time();
    my $topLevelParts = 0; my $topLevelRight = 0;

    # Pre-run: Count parts correct
    while ( $depth > 0 ) {
        if ($curRes == $iterator->BEGIN_MAP()) {$depth++;}
        if ($curRes == $iterator->END_MAP()) { $depth--; }

        if (ref($curRes) && $curRes->is_problem() && !$curRes->randomout)
        {
            # Get number of correct, incorrect parts
            my $parts = $curRes->parts();
            my $partsRight = 0;
	    my $partsCount = 0;
            my $stack = $iterator->getStack();
            
            for my $part (@{$parts}) {
		if ($showPoints) {
		    my $score = $curRes->weight($part) * $curRes->awarded($part);
		    $partsRight += $score;
		    $totalRight += $score;
		    $partsCount += $curRes->weight($part);

		    if ($curRes->opendate($part) < $now) {
			$totalPossible += $curRes->weight($part);
		    }
		    $totalParts += $curRes->weight($part);
		} else {
		    my $status = $curRes->getCompletionStatus($part);
		    my $thisright = 0;
		    $partsCount++;
		    if ($status == $curRes->CORRECT || 
			$status == $curRes->CORRECT_BY_OVERRIDE || 
			$status == $curRes->EXCUSED || 
			$status == $curRes->ANSWER_SUBMITTED) {
			$partsRight++;
			$totalRight++;
			$thisright = 1;
		    }
		    
		    my $dateStatus = $curRes->getDateStatus($part);
		    $totalParts++;
		    if ($curRes->opendate($part) < $now) {
			$totalPossible++;
		    }
		}
            }

            if ($depth == 1) { # in top-level only
		$topLevelParts += $partsCount;
		$topLevelRight += $partsRight;
	    }

            # Crawl down stack and record parts correct and total
            for my $res (@{$stack}) {
                if (ref($res) && $res->is_map()) {
                    if (!defined($res->{DATA}->{CHILD_PARTS})) {
                        $res->{DATA}->{CHILD_PARTS} = 0;
                        $res->{DATA}->{CHILD_CORRECT} = 0;
                    }
                    
                    $res->{DATA}->{CHILD_PARTS} += $partsCount;
                    $res->{DATA}->{CHILD_CORRECT} += $partsRight;
                }
            }
        }
        $curRes = $iterator->next();
    }

    $iterator = $navmap->getIterator(undef, undef, undef, 1);
    $depth = 1;
    $iterator->next(); # ignore first BEGIN_MAP
    $curRes = $iterator->next();

    my @start = (255, 255, 192);
    my @end   = (0, 192, 0);

    my $indentString = '&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;';

    # Second pass: Print the maps.
    $r->print('<table cellspacing="3" border="2"><tr><td align="center"><b>Folder</b></td>');
    $title = $showPoints ? "Points Scored" : "Done";
    $r->print("<td align='center'>$title / Total</td><tr>" . "\n\n");
    while ($depth > 0) {
        if ($curRes == $iterator->BEGIN_MAP()) {$depth++;}
        if ($curRes == $iterator->END_MAP()) { $depth--; }

        if (ref($curRes) && $curRes->is_map()) {
            my $title = $curRes->compTitle();
            
            my $correct = $curRes->{DATA}->{CHILD_CORRECT};
            my $total = $curRes->{DATA}->{CHILD_PARTS};

            if ($total > 0) {
                my $ratio;
                $ratio = $correct / $total;
                my $color = mixColors(\@start, \@end, $ratio);
                $r->print("<tr><td bgcolor='$color'>");
                
		my $thisIndent = '';
                for (my $i = 1; $i < $depth; $i++) { $thisIndent .= $indentString; }
                
                $r->print("$thisIndent$title</td>");
                $r->print("<td valign='top'>$thisIndent<nobr>$correct / $total</nobr></td></tr>\n");
            }
        }

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

    # If there were any problems at the top level, print an extra "catchall"
    if ($topLevelParts > 0) {
        my $ratio = $topLevelRight / $topLevelParts;
        my $color = mixColors(\@start, \@end, $ratio);
        $r->print("<tr><td bgcolor='$color'>");
        $r->print("Problems Not Contained In A Folder</td><td>");
        $r->print("$topLevelRight / $topLevelParts</td></tr>");
    }

    my $maxHelpLink = Apache::loncommon::help_open_topic("Quick_Grades_Possibly_Correct");

    $title = $showPoints ? "Points" : "Parts Done";

    $r->print("<tr><td colspan='2' align='right'>Total $title: <b>$totalRight</b><br>");
    $r->print("Max Possible To Date $maxHelpLink: <b>$totalPossible</b><br>");
    $title = $showPoints ? "Points" : "Parts";
    $r->print("Total $title In Course: <b>$totalParts</b></td></tr>\n\n");


    $r->print("</table></body></html>");

    $navmap->untieHashes();

    return OK;
}

# Pass this two refs to arrays for the start and end color, and a number
# from 0 to 1 for how much of the latter you want to mix in. It will
# return a string ready to show ("#FFC309");
sub mixColors {
    my $start = shift;
    my $end = shift;
    my $ratio = shift;
    
    my ($a,$b);
    my $final = "";
    $a = $start->[0]; $b = $end->[0];
    my $mix1 = POSIX::floor((1-$ratio)*$a + $ratio*$b);
    $a = $start->[1]; $b = $end->[1];
    my $mix2 = POSIX::floor((1-$ratio)*$a + $ratio*$b);
    $a = $start->[2]; $b = $end->[2];
    my $mix3 = POSIX::floor((1-$ratio)*$a + $ratio*$b);

    $final = sprintf "%02x%02x%02x", $mix1, $mix2, $mix3;
    return "#" . $final;
}

1;