File:  [LON-CAPA] / rat / lonuserstate.pm
Revision 1.42: download - view: text, annotated - select for diffs
Fri Sep 6 15:18:23 2002 UTC (21 years, 6 months ago) by www
Branches: MAIN
CVS tags: HEAD
"showdoc" needs to be URL-encode like all the other functionality in order to
properly register with the remote. Remote has now additional fields to store symb, but
nothing is done with them yet. Eventually, this should improve navigation and contents
display for resources showing up multiple times.

# The LearningOnline Network with CAPA
# Construct and maintain state and binary representation of course for user
#
# $Id: lonuserstate.pm,v 1.42 2002/09/06 15:18:23 www Exp $
#
# 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/
#
# (Server for RAT Maps
#
# (Edit Handler for RAT Maps
# (TeX Content Handler
#
# YEAR=2000
# 05/29/00,05/30 Gerd Kortemeyer)
# 7/1 Gerd Kortemeyer)
# 7/1,7/3,7/4,7/7,7/8,7/10 Gerd Kortemeyer)
#
# 7/15,7/17,7/18,8/1,8/2,8/4,8/5,8/21,8/22,8/23,8/30,
# 9/2,9/4,9/29,9/30,10/2,10/11,10/30,10/31,
# 11/1,11/2,11/14,11/16,11/22,12/28,
# YEAR=2001
# 07/05/01,08/30,08/31 Gerd Kortemeyer
# 12/16 Scott Harrison
#
###

package Apache::lonuserstate;

# ------------------------------------------------- modules used by this module
use strict;
use Apache::Constants qw(:common :http);
use Apache::File;
use HTML::TokeParser;
use Apache::lonnet();
use Apache::loncommon();
use GDBM_File;
use Apache::lonmsg;
use Safe;
use Safe::Hole;
use Opcode;

# ---------------------------------------------------- Globals for this package

my $pc;      # Package counter
my %hash;    # The big tied hash
my %parmhash;# The hash with the parameters
my @cond;    # Array with all of the conditions
my $errtext; # variable with all errors
my $retfurl; # variable with the very first URL in the course
my %randompick; # randomly picked resources
# --------------------------------------------------------- Loads map from disk

sub loadmap { 
    my $uri=shift;
    if ($hash{'map_pc_'.$uri}) { return OK; }

    $pc++;
    my $lpc=$pc;
    $hash{'map_pc_'.$uri}=$lpc;
    $hash{'map_id_'.$lpc}=$uri;

# Determine and check filename
    my $fn=&Apache::lonnet::filelocation('',$uri);

    my $ispage=($fn=~/\.page$/);

    unless (($fn=~/\.sequence$/) ||
            ($fn=~/\.page$/)) { 
       $errtext.="Invalid map: $fn\n";
       return OK; 
    }

    my $instr=&Apache::lonnet::getfile($fn);

    unless ($instr == -1) {

# Successfully got file, parse it

        my $parser = HTML::TokeParser->new(\$instr);
        my $token;

        my $linkpc=0;

        $fn=~/\.(\w+)$/;

        $hash{'map_type_'.$lpc}=$1;

        while ($token = $parser->get_token) {
	    if ($token->[0] eq 'S') {
                if ($token->[1] eq 'resource') {
# -------------------------------------------------------------------- Resource

                    my $rid=$lpc.'.'.$token->[2]->{'id'};

                    $hash{'kind_'.$rid}='res';
                    $hash{'title_'.$rid}=$token->[2]->{'title'};
                    my $turi=$token->[2]->{'src'};
                    unless ($ispage) {
                        $turi=~/\.(\w+)$/;
                        my $embstyle=&Apache::loncommon::fileembstyle($1);
                        if ($token->[2]->{'external'} eq 'true') { # external
                            $turi=~s/^http\:\/\//\/adm\/wrapper\/ext\//;
                        } elsif ($turi=~/^\/*uploaded\//) { # uploaded
			    if (($embstyle eq 'img') || ($embstyle eq 'emb')
                             || ($embstyle eq 'ssi')) {
                                $turi='/adm/wrapper'.$turi;
                            } elsif ($turi!~/\.(sequence|page)$/) {
				$turi='/adm/coursedocs/showdoc'.$turi;
                            }
                        } else { # normal internal resource
                           if (($embstyle eq 'img') || ($embstyle eq 'emb')
                          || ($turi=~/\/syllabus$/) || ($turi=~/\/aboutme$/)
                          || ($turi=~/\/navmaps$/)) {
			       $turi='/adm/wrapper'.$turi;
                           }
                        }
		    }
                    $hash{'src_'.$rid}=$turi;

                    if (defined($hash{'ids_'.$turi})) {
                        $hash{'ids_'.$turi}.=','.$rid;
                    } else {
                        $hash{'ids_'.$turi}=''.$rid;
                    }

                    if ($token->[2]->{'external'} eq 'true') {
                        $hash{'ext_'.$rid}='true:';
                    } else {
                        $hash{'ext_'.$rid}='false:';
                    }
                    if ($token->[2]->{'type'}) {
			$hash{'type_'.$rid}=$token->[2]->{'type'};
                        if ($token->[2]->{'type'} eq 'start') {
			    $hash{'map_start_'.$uri}="$rid";
                        }
                        if ($token->[2]->{'type'} eq 'finish') {
			    $hash{'map_finish_'.$uri}="$rid";
                        }
                    }  else {
                        $hash{'type_'.$rid}='normal';
                    }

                    if (($turi=~/\.sequence$/) ||
                        ($turi=~/\.page$/)) {
                        $hash{'is_map_'.$rid}=1;
                        &loadmap($turi);
                    } 
                    
                } elsif ($token->[1] eq 'condition') {
# ------------------------------------------------------------------- Condition

                    my $rid=$lpc.'.'.$token->[2]->{'id'};

                    $hash{'kind_'.$rid}='cond';
                    $cond[$#cond+1]=$token->[2]->{'value'};
                    $hash{'condid_'.$rid}=$#cond;
                    if ($token->[2]->{'type'}) {
                        $cond[$#cond].=':'.$token->[2]->{'type'};
                    }  else {
                        $cond[$#cond].=':normal';
                    }

                } elsif ($token->[1] eq 'link') {
# ----------------------------------------------------------------------- Links

                    $linkpc++;
                    my $linkid=$lpc.'.'.$linkpc;

                    my $goesto=$lpc.'.'.$token->[2]->{'to'};
                    my $comesfrom=$lpc.'.'.$token->[2]->{'from'};
                    my $undercond=0;

                    if ($token->[2]->{'condition'}) {
			$undercond=$lpc.'.'.$token->[2]->{'condition'};
                    }

                    $hash{'goesto_'.$linkid}=$goesto;
                    $hash{'comesfrom_'.$linkid}=$comesfrom;
                    $hash{'undercond_'.$linkid}=$undercond;

                    if (defined($hash{'to_'.$comesfrom})) {
                        $hash{'to_'.$comesfrom}.=','.$linkid;
                    } else {
                        $hash{'to_'.$comesfrom}=''.$linkid;
                    }
                    if (defined($hash{'from_'.$goesto})) {
                        $hash{'from_'.$goesto}.=','.$linkid;
                    } else {
                        $hash{'from_'.$goesto}=''.$linkid;
                    }
                } elsif ($token->[1] eq 'param') {
# ------------------------------------------------------------------- Parameter

                    my $referid=$lpc.'.'.$token->[2]->{'to'};
                    my $part=$token->[2]->{'part'};
                    unless ($part) { $part=0; }
                    my $newparam=
			&Apache::lonnet::escape($token->[2]->{'type'}).':'.
			&Apache::lonnet::escape($part.'.'.
                         $token->[2]->{'name'}).'='.
			&Apache::lonnet::escape($token->[2]->{'value'});
                    if (defined($hash{'param_'.$referid})) {
                        $hash{'param_'.$referid}.='&'.$newparam;
                    } else {
                        $hash{'param_'.$referid}=''.$newparam;
                    }
                    if ($token->[2]->{'name'} eq 'parameter_mapalias') {
			$hash{'mapalias_'.$token->[2]->{'value'}}=$referid;
                    }
                    if ($token->[2]->{'name'} eq 'parameter_randompick') {
			$randompick{$referid}=$token->[2]->{'value'};
                    }
                } 

            }
        }

    } else {
        $errtext.='Map not loaded: The file does not exist. ';
    }
}

# --------------------------------------------------------- Simplify expression

sub simplify {
   my $expression=shift;
# (8)=8
   $expression=~s/\((\d+)\)/$1/g;
# 8&8=8
   $expression=~s/(\D)(\d+)\&\2(\D)/$1$2$3/g;
# 8|8=8
   $expression=~s/(\D)(\d+)\|\2(\D)/$1$2$3/g;
# (5&3)&4=5&3&4
   $expression=~s/\((\d+)((?:\&\d+)+)\)\&(\d+\D)/$1$2\&$3/g;
# (((5&3)|(4&6)))=((5&3)|(4&6))
   $expression=~
       s/\((\(\(\d+(?:\&\d+)*\)(?:\|\(\d+(?:\&\d+)*\))+\))\)/$1/g;
# ((5&3)|(4&6))|(1&2)=(5&3)|(4&6)|(1&2)
   $expression=~
       s/\((\(\d+(?:\&\d+)*\))((?:\|\(\d+(?:\&\d+)*\))+)\)\|(\(\d+(?:\&\d+)*\))/\($1$2\|$3\)/g;
   return $expression;
}

# -------------------------------------------------------- Build condition hash

sub traceroute {
    my ($sofar,$rid,$beenhere)=@_;
    $sofar=simplify($sofar);
    unless ($beenhere=~/\&$rid\&/) {
       $beenhere.=$rid.'&';  
       if (($retfurl eq '') && ($hash{'src_'.$rid})) {
           my ($mapid,$resid)=split(/\./,$rid);
           $retfurl=$hash{'src_'.$rid}.
           (($hash{'src_'.$rid}=~/\?/)?'&':'?').'symb='.
           &Apache::lonnet::symbclean(
                           &Apache::lonnet::declutter($hash{'map_id_'.$mapid}).
                           '___'.$resid.'___'.
                           &Apache::lonnet::declutter($hash{'src_'.$rid}));
       }
       if (defined($hash{'conditions_'.$rid})) {
	   $hash{'conditions_'.$rid}=simplify(
           '('.$hash{'conditions_'.$rid}.')|('.$sofar.')');
       } else {
           $hash{'conditions_'.$rid}=$sofar;
       }
       if (defined($hash{'is_map_'.$rid})) {
           if (defined($hash{'map_start_'.$hash{'src_'.$rid}})) {
	       &traceroute($sofar,$hash{'map_start_'.$hash{'src_'.$rid}},'&');
               if (defined($hash{'map_finish_'.$hash{'src_'.$rid}})) {
		   $sofar=
                  $hash{'conditions_'.$hash{'map_finish_'.$hash{'src_'.$rid}}};
               }
           }
       }
       if (defined($hash{'to_'.$rid})) {
          foreach (split(/\,/,$hash{'to_'.$rid})) {
		my $further=$sofar;
                if ($hash{'undercond_'.$_}) {
		   if (defined($hash{'condid_'.$hash{'undercond_'.$_}})) {
  		       $further=simplify('('.$further.')&('.
                              $hash{'condid_'.$hash{'undercond_'.$_}}.')');
		   } else {
                       $errtext.='Undefined condition ID: '
                                 .$hash{'undercond_'.$_}.'. ';
                   }
                }
                &traceroute($further,$hash{'goesto_'.$_},$beenhere);
          }
       }
    }
}

# ------------------------------ Cascading conditions, quick access, parameters

sub accinit {
    my ($uri,$short,$fn)=@_;
    my %acchash=();
    my %captured=();
    my $condcounter=0;
    $acchash{'acc.cond.'.$short.'.0'}=0;
    foreach (keys %hash) {
       if ($_=~/^conditions/) {
	  my $expr=$hash{$_};
         foreach ($expr=~m/(\(\(\d+(?:\&\d+)+\)(?:\|\(\d+(?:\&\d+)+\))+\))/g) {
             my $sub=$_;
             my $orig=$_;
      $sub=~/\(\((\d+\&(:?\d+\&)*)(?:\d+\&*)+\)(?:\|\(\1(?:\d+\&*)+\))+\)/;
             my $factor=$1;
             $sub=~s/$factor//g;
             $sub=~s/^\(/\($factor\(/;
	     $sub.=')';
             $sub=simplify($sub);
             $orig=~s/(\W)/\\$1/g;
 	     $expr=~s/$orig/$sub/;
	  }
          $hash{$_}=$expr;
          unless (defined($captured{$expr})) {
	      $condcounter++;
              $captured{$expr}=$condcounter;
              $acchash{'acc.cond.'.$short.'.'.$condcounter}=$expr;
          } 
       } elsif ($_=~/^param_(\d+)\.(\d+)/) {
          my $prefix=&Apache::lonnet::declutter($hash{'map_id_'.$1}).
      '___'.$2.'___'.&Apache::lonnet::declutter($hash{'src_'.$1.'.'.$2});
          foreach (split(/\&/,$hash{$_})) {
	     my ($typename,$value)=split(/\=/,$_);
             my ($type,$name)=split(/\:/,$typename);
             $parmhash{$prefix.'.'.&Apache::lonnet::unescape($name)}=
                                   &Apache::lonnet::unescape($value);
	     $parmhash{$prefix.'.'.&Apache::lonnet::unescape($name).'.type'}=
                                   &Apache::lonnet::unescape($type);
          }
       }
    }
    foreach (keys %hash) {
	if ($_=~/^ids/) {
	  foreach (split(/\,/,$hash{$_})) {
	    my $resid=$_;
            my $uri=$hash{'src_'.$resid};
            $uri=~s/^\/adm\/wrapper//;
            my @uriparts=split(/\//,$uri);
            my $urifile=$uriparts[$#uriparts];
            $#uriparts--;
            my $uripath=join('/',@uriparts);
            $uripath=~s/^\/res\///;
           if ($uripath) {
            my $uricond='0';
            if (defined($hash{'conditions_'.$resid})) {
 		$uricond=$captured{$hash{'conditions_'.$resid}};
            }
            if (defined($acchash{'acc.res.'.$short.'.'.$uripath})) {
                if ($acchash{'acc.res.'.$short.'.'.$uripath}=~
                   /(\&$urifile\:[^\&]*)/) {
		    my $replace=$1;
                    my $regexp=$replace;
                    $regexp=~s/\|/\\\|/g;
                    $acchash{'acc.res.'.$short.'.'.$uripath}
                     =~s/$regexp/$replace\|$uricond/;
                } else {
		   $acchash{'acc.res.'.$short.'.'.$uripath}.=
                     $urifile.':'.$uricond.'&';
	        }
            } else {
                $acchash{'acc.res.'.$short.'.'.$uripath}=
                 '&'.$urifile.':'.$uricond.'&';
            }
           } 
         }
      }
    }
    $acchash{'acc.res.'.$short.'.'}='&:0&';
    my $courseuri=$uri;
    $courseuri=~s/^\/res\///;
    &Apache::lonnet::delenv('(acc\.|httpref\.)');
    &Apache::lonnet::appenv(%acchash,
                            "request.course.id"  => $short,
                            "request.course.fn"  => $fn,
                            "request.course.uri" => $courseuri); 
}

# ------------------------------------- Selectively delete from randompick maps

sub pickrandom {
    my $randomoutentry='';
    foreach my $rid (keys %randompick) {
        my $rndpick=$randompick{$rid};
        my $mpc=$hash{'map_pc_'.$hash{'src_'.$rid}};
# ------------------------------------------- put existing resources into array
        my @currentrids=();
        foreach (keys %hash) {
	    if ($_=~/^src_($mpc\.\d+)/) {
		if ($hash{'src_'.$1}) { push @currentrids, $1; }
            }
        }
        next if ($#currentrids<$rndpick);
# -------------------------------- randomly eliminate the ones that should stay
	srand(&Apache::lonnet::rndseed($rid)); # use rid instead of symb
        for (my $i=1;$i<=$rndpick;$i++) {
            while (1) {
		my $randomidx=int(rand($#currentrids+1));
                if ($currentrids[$randomidx]) {
		    $currentrids[$randomidx]='';
                    last;
                }
            }
        }
# -------------------------------------------------------- delete the leftovers
        for (my $k=0; $k<=$#currentrids; $k++) {
            if ($currentrids[$k]) {
		$hash{'randomout_'.$currentrids[$k]}=1;
                my ($mapid,$resid)=split(/\./,$currentrids[$k]);
                $randomoutentry.='&'.
                 &Apache::lonnet::symbclean(
		    &Apache::lonnet::declutter($hash{'map_id_'.$mapid}).
                    '___'.$resid.'___'.
		    &Apache::lonnet::declutter($hash{'src_'.$currentrids[$k]})
                 ).'&';
            }
        }
    }
    if ($randomoutentry) {
	&Apache::lonnet::appenv('acc.randomout' => $randomoutentry);
    }
}

# ---------------------------------------------------- Read map and all submaps

sub readmap {
   my $short=shift;
   $short=~s/^\///;
   my %cenv=&Apache::lonnet::coursedescription($short);
   my $fn=$cenv{'fn'};
   my $uri;
   $short=~s/\//\_/g;
   unless ($uri=$cenv{'url'}) { 
      &Apache::lonnet::logthis("<font color=blue>WARNING: ".
                       "Could not load course $short.</font>"); 
      return 'No course data available.';
   }
   @cond=('true:normal');
   unlink($fn.'.db');
   unlink($fn.'_symb.db');
   unlink($fn.'.state');
   unlink($fn.'parms.db');
   undef %randompick;
   $retfurl='';
   if ((tie(%hash,'GDBM_File',"$fn.db",&GDBM_WRCREAT(),0640)) &&
       (tie(%parmhash,'GDBM_File',$fn.'_parms.db',&GDBM_WRCREAT(),0640))) {
    %hash=();
    %parmhash=();
    $errtext='';
    $pc=0;
    my $furi=&Apache::lonnet::clutter($uri);
    $hash{'src_0.0'}=$furi;
    $hash{'title_0.0'}=&Apache::lonnet::metadata($uri,'title');
    $hash{'ids_'.$furi}='0.0';
    $hash{'is_map_0.0'}=1;
    loadmap($uri);
    if (defined($hash{'map_start_'.$uri})) {
        &traceroute('0',$hash{'map_start_'.$uri},'&');
        &accinit($uri,$short,$fn);
        &pickrandom();
    }
    unless ((untie(%hash)) && (untie(%parmhash))) {
      &Apache::lonnet::logthis("<font color=blue>WARNING: ".
                       "Could not untie coursemap $fn for $uri.</font>"); 
    }
    {
     my $cfh;
     if ($cfh=Apache::File->new(">$fn.state")) {
        print $cfh join("\n",@cond);
     } else {
      &Apache::lonnet::logthis("<font color=blue>WARNING: ".
                       "Could not write statemap $fn for $uri.</font>"); 
     }
    }  
   } else {
      &Apache::lonnet::logthis("<font color=blue>WARNING: ".
                       "Could not tie coursemap $fn for $uri.</font>"); 
   }
   &Apache::lonmsg::author_res_msg($ENV{'request.course.uri'},$errtext);
   return ($retfurl,$errtext);
}

# ------------------------------------------------------- Evaluate state string

sub evalstate {

    my $fn=$ENV{'request.course.fn'}.'.state';
    my $state='2';
    if (-e $fn) {
       my @conditions=();
       {
        my $fh=Apache::File->new($fn);
        @conditions=<$fh>;
       }  
       my $safeeval = new Safe;
       my $safehole = new Safe::Hole;
       $safeeval->permit("entereval");
       $safeeval->permit(":base_math");
       $safeeval->deny(":base_io");
       $safehole->wrap(\&Apache::lonnet::EXT,$safeeval,'&EXT');
       foreach (@conditions) {
	   my $line=$_;
           chomp($line);
	   my ($condition,$weight)=split(/\:/,$_);
           if ($safeeval->reval($condition)) {
	       if ($weight eq 'force') {
		   $state.='3';
               } else {
                   $state.='2';
               }
           } else {
               if ($weight eq 'stop') {
		   $state.='0';
               } else {
                   $state.='1';
               }
           }
       }
    }
    &Apache::lonnet::appenv('user.state.'.$ENV{'request.course.id'} => $state);
    return $state;
}

1;
__END__

=head1 NAME

Apache::lonuserstate - Construct and maintain state and binary representation
of course for user

=head1 SYNOPSIS

Invoked by lonroles.pm.

&Apache::lonuserstate::readmap($cdom.'/'.$cnum);

=head1 INTRODUCTION

This module constructs and maintains state and binary representation
of course for user.

This is part of the LearningOnline Network with CAPA project
described at http://www.lon-capa.org.

=head1 HANDLER SUBROUTINE

There is no handler subroutine.

=head1 OTHER SUBROUTINES

=over 4

=item *

loadmap() : Loads map from disk

=item *

simplify() : Simplify expression

=item *

traceroute() : Build condition hash

=item *

accinit() : Cascading conditions, quick access, parameters

=item *

readmap() : Read map and all submaps

=item *

evalstate() : Evaluate state string

=back

=cut

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