File:  [LON-CAPA] / rat / lonuserstate.pm
Revision 1.68: download - view: text, annotated - select for diffs
Fri Dec 12 16:38:53 2003 UTC (20 years, 3 months ago) by www
Branches: MAIN
CVS tags: version_1_0_99_2, HEAD
Bug #2453: pretty bad, fix should go into 1.1

Since the publisher does not longer change every URL into an absolute path,
and we are officially allowing relative sources in maps, we have to have
lonuserstate do a hreflocation of map source with respect to the map
location.

# The LearningOnline Network with CAPA
# Construct and maintain state and binary representation of course for user
#
# $Id: lonuserstate.pm,v 1.68 2003/12/12 16:38:53 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/
#
###

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
my %randompickseed; # optional seed for randomly picking resources

# ----------------------------------- Remove version from URL and store in hash

sub versiontrack {
    my $uri=shift;
    if ($uri=~/\.(\d+)\.\w+$/) {
	my $version=$1;
	$uri=~s/\.\d+\.(\w+)$/\.$1/;
        unless ($hash{'version_'.$uri}) {
	    $hash{'version_'.$uri}=$version;
	}
    }
    return $uri;
}

# -------------------------------------------------------------- Put in version

sub putinversion {
    my $uri=shift;
    if ($hash{'version_'.$uri}) {
	my $version=$hash{'version_'.$uri};
	if ($version eq 'mostrecent') { return $uri; }
	if ($version eq &Apache::lonnet::getversion(
			&Apache::lonnet::filelocation('',$uri))) 
	             { return $uri; }
	$uri=~s/\.(\w+)$/\.$version\.$1/;
    }
    return $uri;
}

# ----------------------------------------- Processing versions file for course

sub processversionfile {
    my %cenv=@_;
    my %versions=&Apache::lonnet::dump('resourceversions',
				       $cenv{'domain'},
				       $cenv{'num'});
    foreach (keys %versions) {
	if ($_=~/^error\:/) { return; }
	$hash{'version_'.$_}=$versions{$_};
    }
}

# --------------------------------------------------------- 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('',&putinversion($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 eq -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=&versiontrack($token->[2]->{'src'});
                    if ($token->[2]->{'version'}) {
			unless ($hash{'version_'.$turi}) {
			    $hash{'version_'.$turi}=$1;
			}
		    }
		    &Apache::lonnet::do_cache(\%Apache::lonnet::titlecache,
		       &Apache::lonnet::encode_symb($uri,$token->[2]->{'id'},
						    $turi),
					      $token->[2]->{'title'},'title');
                    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
			    my $mapdir=$uri;
			    $mapdir=~s/[^\/]+$//;
			    $turi=&Apache::lonnet::hreflocation($mapdir,$turi);
			    if (($embstyle eq 'img') || ($embstyle eq 'emb')) {
				$turi='/adm/wrapper'.$turi;
			    }
                        }
		    }

                    if (defined($hash{'ids_'.$turi})) {
                        $hash{'ids_'.$turi}.=','.$rid;
                    } else {
                        $hash{'ids_'.$turi}=''.$rid;
                    }
               
                    if
	        ($turi=~/\/(syllabus|aboutme|navmaps|smppg|bulletinboard)$/) {
			$turi.='?register=1';
		    }

                    $hash{'src_'.$rid}=$turi;

                    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 $name=$token->[2]->{'name'};
		    my $part;
		    if ($name=~/^parameter_(.*)_/) {
			$part=$1;
		    } else {
			$part=0;
		    }
		    $name=~s/^.*_([^_]*)$/$1/;
                    my $newparam=
			&Apache::lonnet::escape($token->[2]->{'type'}).':'.
			&Apache::lonnet::escape($part.'.'.$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'};
                    }
                    if ($token->[2]->{'name'} eq 'parameter_randompickseed') {
			$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})
        && ($hash{'src_'.$rid}!~/\.sequence$/)) {
           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//;
            $uri=&Apache::lonnet::declutter($uri);
            my @uriparts=split(/\//,$uri);
            my $urifile=$uriparts[$#uriparts];
            $#uriparts--;
            my $uripath=join('/',@uriparts);
           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}=~
                   /(\&\Q$urifile\E\:[^\&]*)/) {
		    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 (sort(keys(%hash))) {
	    if ($_=~/^src_($mpc\.\d+)/) {
		if ($hash{'src_'.$1}) { push @currentrids, $1; }
            }
        }
	# rids are number.number and we want to numercially sort on 
        # the second number
	@currentrids=sort {
	    my (undef,$aid)=split(/\./,$a);
	    my (undef,$bid)=split(/\./,$b);
	    $aid <=> $bid;
	} @currentrids;
        next if ($#currentrids<$rndpick);
# -------------------------------- randomly eliminate the ones that should stay
	my (undef,$id)=split(/\./,$rid);
        if ($randompickseed{$rid}) { $id=$randompickseed{$rid}; }
	my $rndseed=&Apache::lonnet::rndseed($id); # use id instead of symb
	&Apache::lonnet::setup_random_from_rndseed($rndseed);
	my @whichids=&Math::Random::random_permuted_index($#currentrids+1);
        for (my $i=1;$i<=$rndpick;$i++) { $currentrids[$whichids[$i]]=''; }
	#&Apache::lonnet::logthis("$id,$rndseed,".join(':',@whichids));
# -------------------------------------------------------- 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;
    &processversionfile(%cenv);
    my $furi=&Apache::lonnet::clutter($uri);
    $hash{'src_0.0'}=&versiontrack($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();
    }
# ------------------------------------------------------- Put versions into src
    foreach (keys %hash) {
	if ($_=~/^src\_/) {
	    $hash{$_}=&putinversion($hash{$_});
	}
    }
    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);
# ------------------------------------------------- Check for critical messages

    my @what=&Apache::lonnet::dump('critical',$ENV{'user.domain'},
                                              $ENV{'user.name'});
    if ($what[0]) {
	if (($what[0] ne 'con_lost') && ($what[0]!~/^error\:/)) {
	    $retfurl='/adm/email?critical=display';
        }
    }
   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>