[BACK]Return to lonpageflip.pm CVS log [TXT] [DIR] Up to [LON-CAPA] / rat

Diff for /rat/lonpageflip.pm between versions 1.32 and 1.87

version 1.32, 2002/12/02 14:39:02 version 1.87, 2015/03/14 21:56:13
Line 26 Line 26
 #  #
 # http://www.lon-capa.org/  # http://www.lon-capa.org/
 #  #
 # (Page Handler  
 #  
 # (TeX Content Handler  
 #  
 # 05/29/00,05/30 Gerd Kortemeyer)  
 # 08/30,08/31,09/06,09/14,09/15,09/16,09/19,09/20,09/21,09/23,  
 # 10/02 Gerd Kortemeyer)  
 #  
 # 10/03,10/05,10/06,10/07,10/09,10/10,10/11,10/16,10/17,  
 # 11/14,11/16,  
 # 10/01/01,05/01,05/28,07/05 Gerd Kortemeyer  
   
 package Apache::lonpageflip;  package Apache::lonpageflip;
   
 use strict;  use strict;
   use LONCAPA;
 use Apache::Constants qw(:common :http REDIRECT);  use Apache::Constants qw(:common :http REDIRECT);
 use Apache::lonnet();  use Apache::lonnet;
   use Apache::loncommon();
   use Apache::lonuserstate;
   use Apache::lonlocal;
 use HTML::TokeParser;  use HTML::TokeParser;
 use GDBM_File;  use GDBM_File;
   
Line 50  use GDBM_File; Line 45  use GDBM_File;
       
 my %hash;  my %hash;
   
   sub cleanup {
       if (tied(%hash)){
    &Apache::lonnet::logthis('Cleanup pageflip: hash');
           unless (untie(%hash)) {
       &Apache::lonnet::logthis('Failed cleanup pageflip: hash');
           }
       }
       return OK;
   }
   
 sub addrid {  sub addrid {
     my ($current,$new,$condid)=@_;      my ($current,$new,$condid)=@_;
     unless ($condid) { $condid=0; }      unless ($condid) { $condid=0; }
Line 65  sub addrid { Line 70  sub addrid {
   
 sub fullmove {  sub fullmove {
     my ($rid,$mapurl,$direction)=@_;      my ($rid,$mapurl,$direction)=@_;
     if (tie(%hash,'GDBM_File',$ENV{'request.course.fn'}.'.db',      if (tie(%hash,'GDBM_File',$env{'request.course.fn'}.'.db',
                         &GDBM_READER(),0640)) {                          &GDBM_READER(),0640)) {
  ($rid,$mapurl)=&move($rid,$mapurl,$direction);   ($rid,$mapurl)=&move($rid,$mapurl,$direction);
         untie(%hash);          untie(%hash);
Line 73  sub fullmove { Line 78  sub fullmove {
     return($rid,$mapurl);      return($rid,$mapurl);
 }  }
   
   sub hash_src {
       my ($id)=@_;
       my ($mapid,$resid)=split(/\./,$id);
       my $symb=&Apache::lonnet::encode_symb($hash{'map_id_'.$mapid},
     $resid,$hash{'src_'.$id});
       if ($hash{'encrypted_'.$id}) {
    return (&Apache::lonenc::encrypted($hash{'src_'.$id}),
    &Apache::lonenc::encrypted($symb));
       }
       return ($hash{'src_'.$id},$symb);
   }
   
 sub move {  sub move {
       my ($next,$endupmap,$direction) = @_;
       my $safecount=0;
       my $allowed=0;
       do {
    ($next,$endupmap)=&get_next_possible_move($next,$endupmap,$direction);
   
    my $url = $hash{'src_'.$next};
    my ($mapid,$resid)=split(/\./,$next);
    my $symb = &Apache::lonnet::encode_symb($hash{'map_id_'.$mapid},
    $resid,$url);
    if ($url eq '' || $symb eq '') {
       $allowed = 0;
    } else {
       my $priv = &Apache::lonnet::allowed('bre',$url,$symb);
       $allowed = (($priv eq 'F') || ($priv eq '2'));
    }
    $safecount++;
       } while (   ($next)
        && ($next!~/\,/)
        && (
       (!$hash{'src_'.$next})
    || (
           (!$env{'request.role.adv'})
        &&  $hash{'randomout_'.$next}
       )
    || (!$allowed)
    )
        && ($safecount<10000));
   
       return ($next,$endupmap);
   }
   
   sub get_next_possible_move {
     my ($rid,$mapurl,$direction)=@_;      my ($rid,$mapurl,$direction)=@_;
     my $startoutrid=$rid;      my $startoutrid=$rid;
   
Line 83  sub move { Line 133  sub move {
               my $posnext='';                my $posnext='';
               if ($direction eq 'forward') {                if ($direction eq 'forward') {
 # --------------------------------------------------------------------- Forward  # --------------------------------------------------------------------- Forward
                   if ($hash{'type_'.$rid} eq 'finish') {                    while ($hash{'type_'.$rid} eq 'finish') {
              $rid=$hash{'ids_'.&Apache::lonnet::clutter($mapurl)};                $rid=$hash{'ids_'.$hash{'map_id_'.(split(/\./,$rid))[0]}};
                   }                    }
                   map {    foreach my $id (split(/\,/,$hash{'to_'.$rid})) {
                       my $thiscond=       my $condition= $hash{'conditions_'.$hash{'goesto_'.$id}};
       &Apache::lonnet::directcondval($hash{'condid_'.$hash{'undercond_'.$_}});       my $rescond  = &Apache::lonnet::docondval($condition);
                       if ($thiscond>=$mincond) {       my $linkcond = &Apache::lonnet::directcondval($hash{'condid_'.$hash{'undercond_'.$id}});
        my $thiscond = ($rescond<$linkcond)?$rescond:$linkcond;
        if ($thiscond>=$mincond) {
           if ($posnext) {            if ($posnext) {
              $posnext.=','.$_.':'.$thiscond;               $posnext.=','.$id.':'.$thiscond;
                           } else {                            } else {
                              $posnext=$_.':'.$thiscond;                               $posnext=$id.':'.$thiscond;
           }            }
                           if ($thiscond>$mincond) { $mincond=$thiscond; }                            if ($thiscond>$mincond) { $mincond=$thiscond; }
               }                }
                   } split(/\,/,$hash{'to_'.$rid});                    } 
                   map {    foreach my $id (split(/\,/,$posnext))  {
                       my ($linkid,$condval)=split(/\:/,$_);                        my ($linkid,$condval)=split(/\:/,$id);
                       if ($condval>=$mincond) {                        if ($condval>=$mincond) {
           $next=&addrid($next,$hash{'goesto_'.$linkid},            $next=&addrid($next,$hash{'goesto_'.$linkid},
                                 $hash{'condid_'.$hash{'undercond_'.$linkid}});                                  $hash{'condid_'.$hash{'undercond_'.$linkid}});
                       }                        }
                   } split(/\,/,$posnext);                    }
                   if ($hash{'is_map_'.$next}) {                    if ($hash{'is_map_'.$next}) {
 # This jumps to the beginning of a new map (going down level)  # This jumps to the beginning of a new map (going down level)
                       if (                        if (
       $hash{'map_type_'.$hash{'map_pc_'.$hash{'src_'.$next}}} eq 'sequence') {        $hash{'map_type_'.$hash{'map_pc_'.$hash{'src_'.$next}}} eq 'sequence') {
   $mapurl=$hash{'src_'.$next};    $mapurl=$hash{'src_'.$next};
   $next=$hash{'map_start_'.$hash{'src_'.$next}};    $next=$hash{'map_start_'.$hash{'src_'.$next}};
                        } elsif (
   # This jumps back up from an empty sequence, to a page up one level
                            $hash{'map_type_'.$hash{'map_pc_'.$hash{'src_'.$next}}} eq 'page') {
                            $mapurl=$hash{'map_id_'.(split(/\./,$next))[0]};
                      }                       }
                   } elsif                     } elsif 
                     ((split(/\./,$startoutrid))[0]!=(split(/\./,$next))[0]) {                      ((split(/\./,$startoutrid))[0]!=(split(/\./,$next))[0]) {
 # This comes up from a map (coming up one level);  # This comes up from a map (coming up one level);
       $mapurl=$hash{'map_id_'.(split(/\./,$next))[0]};        $mapurl=$hash{'map_id_'.(split(/\./,$next))[0]};
                   }    }
               } elsif ($direction eq 'back') {                } elsif ($direction eq 'back') {
 # ------------------------------------------------------------------- Backwards  # ------------------------------------------------------------------- Backwards
                   if ($hash{'type_'.$rid} eq 'start') {                   while ($hash{'type_'.$rid} eq 'start') {
              $rid=$hash{'ids_'.&Apache::lonnet::clutter($mapurl)};               $rid=$hash{'ids_'.$hash{'map_id_'.(split(/\./,$rid))[0]}};
                   }   }
                   map {   foreach my $id (split(/\,/,$hash{'from_'.$rid})) {
                       my $thiscond=       my $condition= $hash{'conditions_'.$hash{'comesfrom_'.$id}};
       &Apache::lonnet::directcondval($hash{'condid_'.$hash{'undercond_'.$_}});       my $rescond  = &Apache::lonnet::docondval($condition);
                       if ($thiscond>=$mincond) {       my $linkcond = &Apache::lonnet::directcondval($hash{'condid_'.$hash{'undercond_'.$id}});
           if ($posnext) {       my $thiscond = ($rescond<$linkcond)?$rescond:$linkcond;
              $posnext.=','.$_.':'.$thiscond;       if ($thiscond>=$mincond) {
                           } else {   if ($posnext) {
                              $posnext=$_.':'.$thiscond;               $posnext.=','.$id.':'.$thiscond;
           }   } else {
                           if ($thiscond>$mincond) { $mincond=$thiscond; }                               $posnext=$id.':'.$thiscond;
               }   }
                   } split(/\,/,$hash{'from_'.$rid});   if ($thiscond>$mincond) { $mincond=$thiscond; }
                   map {       }
                       my ($linkid,$condval)=split(/\:/,$_);   } 
                       if ($condval>=$mincond) {   foreach my $id (split(/\,/,$posnext)) {
           $next=&addrid($next,$hash{'comesfrom_'.$linkid},       my ($linkid,$condval)=split(/\:/,$id);
                                 $hash{'condid_'.$hash{'undercond_'.$linkid}});       if ($condval>=$mincond) {
                       }   $next=&addrid($next,$hash{'comesfrom_'.$linkid},
                   } split(/\,/,$posnext);         $hash{'condid_'.$hash{'undercond_'.$linkid}});
        }
    }
                   if ($hash{'is_map_'.$next}) {                    if ($hash{'is_map_'.$next}) {
 # This jumps to the end of a new map (going down one level)  # This jumps to the end of a new map (going down one level)
                       if (                        if (
       $hash{'map_type_'.$hash{'map_pc_'.$hash{'src_'.$next}}} eq 'sequence') {        $hash{'map_type_'.$hash{'map_pc_'.$hash{'src_'.$next}}} eq 'sequence') {
   $mapurl=$hash{'src_'.$next};    $mapurl=$hash{'src_'.$next};
   $next=$hash{'map_finish_'.$hash{'src_'.$next}};    $next=$hash{'map_finish_'.$hash{'src_'.$next}};
                      }                        } elsif (
         $hash{'map_type_'.$hash{'map_pc_'.$hash{'src_'.$next}}} eq 'page') {
   # This jumps back up from an empty sequence, to a page up one level
                             $mapurl=$hash{'map_id_'.(split(/\./,$next))[0]};
                         }
                   } elsif                     } elsif 
                     ((split(/\./,$startoutrid))[0]!=(split(/\./,$next))[0]) {                      ((split(/\./,$startoutrid))[0]!=(split(/\./,$next))[0]) {
 # This comes back up from a map (going up one level);  # This comes back up from a map (going up one level);
Line 157  sub move { Line 219  sub move {
               return ($next,$mapurl);                return ($next,$mapurl);
 }  }
   
   sub first_accessible_resource {
       my $furl;
       if (tie(%hash,'GDBM_File',$env{'request.course.fn'}.'.db',
       &GDBM_READER(),0640)) {
    $furl=$hash{'first_url'};
    my %args;
    my ($url,$args) = split(/\?/,$furl);
    foreach my $pair (split(/\&/,$args)) {
       my ($name,$value) = split(/=/,$pair);
       $args{&unescape($name)} = &unescape($value);
    }
           if (!&Apache::lonnet::allowed('bre',$url,$args{'symb'})) {
   # Wow, we cannot see this ... move forward to the next one that we can see
       my ($newrid,$newmap)=&move($hash{'first_rid'},$hash{'first_mapurl'},'forward');
   # Build the new URL
       my ($newmapid,$newresid)=split(/\./,$newrid);
       my $symb=&Apache::lonnet::encode_symb($newmap,$newresid,$hash{'src_'.$newrid});
       $furl=&add_get_param($hash{'src_'.$newrid},{ 'symb' => $symb });
       if ($hash{'encrypted_'.$newrid}) {
    $furl=&Apache::lonenc::encrypted($furl);
       }
    }
    untie(%hash);
    return $furl;
       } else {
    return '/adm/navmaps';
       }
   }
   
 # ================================================================ Main Handler  # ================================================================ Main Handler
   
 sub handler {  sub handler {
Line 165  sub handler { Line 256  sub handler {
 # ------------------------------------------- Set document type for header only  # ------------------------------------------- Set document type for header only
   
   if ($r->header_only) {    if ($r->header_only) {
      $r->content_type('text/html');        &Apache::loncommon::content_type($r,'text/html');
      $r->send_http_header;        $r->send_http_header;
      return OK;        return OK;
   }    }
   
   my %cachehash=();     my %cachehash=(); 
   my $multichoice=0;    my $multichoice=0;
   my %multichoicehash=();    my %multichoicehash=();
   my $redirecturl='';    my ($redirecturl,$redirectsymb);
   my $next='';    my $next='';
   my @possibilities=();    my @possibilities=();
   if (($ENV{'form.postdata'})&&($ENV{'request.course.fn'})) {     &Apache::loncommon::get_unprocessed_cgi($ENV{'QUERY_STRING'},['postdata']);
       $ENV{'form.postdata'}=~/(\w+)\:(.*)/;    if (($env{'form.postdata'})&&($env{'request.course.fn'})) {
         $env{'form.postdata'}=~/(\w+)\:(.*)/;
   
         if ($env{'request.course.id'}) {
             # Check if course needs to be re-initialized
             my $loncaparev = $r->dir_config('lonVersion');
             my ($result,@reinit) = &Apache::loncommon::needs_coursereinit($loncaparev);
             if ($result eq 'switch') {
                 &Apache::loncommon::content_type($r,'text/html');
                 $r->send_http_header;
                 $r->print(&Apache::loncommon::check_release_result(@reinit));
                 return OK;
             } elsif ($result eq 'update') {
                 my $cnum = $env{'course.'.$env{'request.course.id'}.'.num'};
                 my $cdom = $env{'course.'.$env{'request.course.id'}.'.domain'};
                 my ($furl,$ferr) = &Apache::lonuserstate::readmap("$cdom/$cnum");
                 if ($ferr) {
                     my $requrl = $r->uri;
                     $env{'user.error.msg'}="$requrl:bre:0:0:Course not initialized";
                     $env{'user.reinit'} = 1;
                     return HTTP_NOT_ACCEPTABLE;
                 }
             }
         }
   
       my $direction=$1;        my $direction=$1;
       my $currenturl=$2;        my $currenturl=$2;
         if ($currenturl=~m|^/enc/|) {
     $currenturl=&Apache::lonenc::unencrypted($currenturl);
         }
         $currenturl=~s/\.\d+\.(\w+)$/\.$1/;
         if ($direction eq 'firstres') {
     my $furl=&first_accessible_resource();
     &Apache::loncommon::content_type($r,'text/html');
     $r->header_out(Location => 
    &Apache::lonnet::absolute_url().$furl);
        
     return REDIRECT;
         }
       if ($direction eq 'return') {        if ($direction eq 'return') {
 # -------------------------------------------------------- Return to last known  # -------------------------------------------------------- Return to last known
          my $last;           my $last;
          if (tie(%hash,'GDBM_File',$ENV{'request.course.fn'}.'_symb.db',           if (tie(%hash,'GDBM_File',$env{'request.course.fn'}.'_symb.db',
                     &GDBM_READER(),0640)) {                      &GDBM_READER(),0640)) {
      $last=$hash{'last_known'};       $last=$hash{'last_known'};
              untie(%hash);               untie(%hash);
          }           }
          my $newloc;           my $newloc;
          if ($last) {           if (($last) && (tie(%hash,'GDBM_File',$env{'request.course.fn'}.'.db',
             $newloc=&Apache::lonnet::clutter((split(/\_\_\_/,$last))[1]);                          &GDBM_READER(),0640))) {
               my ($murl,$id,$fn)=&Apache::lonnet::decode_symb($last);
       $id=$hash{'map_pc_'.&Apache::lonnet::clutter($murl)}.'.'.$id;
       $newloc=$hash{'src_'.$id};
       if ($newloc) {
    if ($hash{'encrypted_'.$id}) { $newloc=&Apache::lonenc::encrypted($newloc); }
         
       } else {
    $newloc='/adm/navmaps';
       }
               untie %hash;
          } else {           } else {
     $newloc='/adm/noidea.html';      $newloc='/adm/navmaps';
          }             }  
  $r->content_type('text/html');       &Apache::loncommon::content_type($r,'text/html');
          $r->header_out(Location =>        $r->header_out(Location => 
  'http://'.$ENV{'HTTP_HOST'}.$newloc);      &Apache::lonnet::absolute_url().$newloc);
                                       
          return REDIRECT;       return REDIRECT;
       }        }
       $currenturl=~s/^http\:\/\///;        $currenturl=~s/^https?\:\/\///;
       $currenturl=~s/^[^\/]+//;        $currenturl=~s/^[^\/]+//;
       unless ($currenturl=~/^\/(res|adm\/wrapper|public|adm\/coursedocs)\//) {  #
   # Is the current URL on the map? If not, start with last known URL
   #
         unless (&Apache::lonnet::is_on_map($currenturl)) {
  my $last;   my $last;
          if (tie(%hash,'GDBM_File',$ENV{'request.course.fn'}.'_symb.db',           if (tie(%hash,'GDBM_File',$env{'request.course.fn'}.'_symb.db',
                     &GDBM_READER(),0640)) {                      &GDBM_READER(),0640)) {
      $last=$hash{'last_known'};       $last=$hash{'last_known'};
              untie(%hash);               untie(%hash);
          }           }
          if ($last) {           if ($last) {
      $currenturl=&Apache::lonnet::clutter((split(/\_\_\_/,$last))[1]);       $currenturl=&Apache::lonnet::clutter((&Apache::lonnet::decode_symb($last))[2]);
  } else {   } else {
      $r->content_type('text/html');   &Apache::loncommon::content_type($r,'text/html');
              $r->header_out(Location =>    $r->header_out(Location => 
                                'http://'.$ENV{'HTTP_HOST'}.'/adm/noidea.html');   &Apache::lonnet::absolute_url().
              return REDIRECT;   '/adm/noidea.html');
    return REDIRECT;
          }           }
       }        }
 # ------------------------------------------- Do we have any idea where we are?  # ------------------------------------------- Do we have any idea where we are?
       my $position;        my $position;
       if ($position=Apache::lonnet::symbread($currenturl)) {        if ($position=Apache::lonnet::symbread($currenturl)) {
 # ------------------------------------------------------------------------- Yes  # ------------------------------------------------------------------------- Yes
   my ($startoutmap,$mapnum,$thisurl)=split(/\_\_\_/,$position);    my ($startoutmap,$mapnum,$thisurl)=&Apache::lonnet::decode_symb($position);
           $cachehash{$startoutmap}{$thisurl}=$mapnum;            $cachehash{$startoutmap}{$thisurl}=[$thisurl,$mapnum];
           $cachehash{$startoutmap}{'last_known'}=            $cachehash{$startoutmap}{'last_known'}=
                                        &Apache::lonnet::declutter($currenturl);                               [&Apache::lonnet::declutter($currenturl),$mapnum];
   
 # ============================================================ Tie the big hash  # ============================================================ Tie the big hash
           if (tie(%hash,'GDBM_File',$ENV{'request.course.fn'}.'.db',            if (tie(%hash,'GDBM_File',$env{'request.course.fn'}.'.db',
                         &GDBM_READER(),0640)) {                          &GDBM_READER(),0640)) {
               my $rid=$hash{'map_pc_'.&Apache::lonnet::clutter($startoutmap)}.                my $rid=$hash{'map_pc_'.&Apache::lonnet::clutter($startoutmap)}.
                       '.'.$mapnum;                        '.'.$mapnum;
Line 237  sub handler { Line 378  sub handler {
               my $endupmap;                my $endupmap;
               ($next,$endupmap)=&move($rid,$startoutmap,$direction);                ($next,$endupmap)=&move($rid,$startoutmap,$direction);
 # -------------------------------------- Do we have one and only one empty URL?  # -------------------------------------- Do we have one and only one empty URL?
               my $safecount=0;  
               while (($next) && ($next!~/\,/) &&   
                      ((!$hash{'src_'.$next}) || ($hash{'randomout_'.$next}))  
                      && ($safecount<10000)) {  
                   ($next,$endupmap)=&move($next,$endupmap,$direction);  
                   $safecount++;  
               }  
 # We are now at at least one non-empty URL  # We are now at at least one non-empty URL
 # ----------------------------------------------------- Check out possibilities  # ----------------------------------------------------- Check out possibilities
               if ($next) {                if ($next) {
                   @possibilities=split(/\,/,$next);                    @possibilities=split(/\,/,$next);
                   if ($#possibilities==0) {                    if ($#possibilities==0) {
 # ---------------------------------------------- Only one possibility, redirect  # ---------------------------------------------- Only one possibility, redirect
               $redirecturl=$hash{'src_'.$next};                ($redirecturl,$redirectsymb)=&hash_src($next);
                       $cachehash{$endupmap}                        $cachehash{$endupmap}{$redirecturl}=
                                 {&Apache::lonnet::declutter($redirecturl)}    [$redirecturl,(split(/\./,$next))[1]];
                                  =(split(/\./,$next))[1];  
                   } else {                    } else {
 # ------------------------ There are multiple possibilities for a next resource  # ------------------------ There are multiple possibilities for a next resource
                       $multichoice=1;                        $multichoice=1;
                       map {        foreach my $id (@possibilities) {
   $multichoicehash{'src_'.$_}=$hash{'src_'.$_};    $multichoicehash{'src_'.$id}=$hash{'src_'.$id};
                           $multichoicehash{'title_'.$_}=$hash{'title_'.$_};                            $multichoicehash{'title_'.$id}=$hash{'title_'.$id};
                           $multichoicehash{'type_'.$_}=$hash{'type_'.$_};                            $multichoicehash{'type_'.$id}=$hash{'type_'.$id};
                           (my $first, my $second) = $_ =~ /(\d+).(\d+)/;                            (my $first, my $second) = $id =~ /(\d+).(\d+)/;
                           my $symbSrc = Apache::lonnet::declutter($hash{'src_'.$_});                            my $symbSrc = Apache::lonnet::declutter($hash{'src_'.$id});
                           $multichoicehash{'symb_'.$_} =                             $multichoicehash{'symb_'.$id} = 
                               Apache::lonnet::declutter($hash{'map_id_'.$first}.'___'.                                Apache::lonnet::declutter($hash{'map_id_'.$first}.'___'.
                                                         $second.'___'.$symbSrc);                                                          $second.'___'.$symbSrc);
                                                                                                                     
                           my ($choicemap,$choiceres)=split(/\./,$_);                            my ($choicemap,$choiceres)=split(/\./,$id);
                           $cachehash    my $map=&Apache::lonnet::declutter($hash{'src_'.$choicemap});
  {&Apache::lonnet::declutter($hash{'src_'.$choicemap})}    my $url=$multichoicehash{'src_'.$id};
                          {&Apache::lonnet::declutter(                            $cachehash{$map}{$url}=[$url,$choiceres];
       $multichoicehash                        }
                                                          {'src_'.$_}  
                                                        )}  
                                  =$choiceres;  
                       } @possibilities;  
                   }                    }
       } else {        } else {
 # -------------------------------------------------------------- No place to go  # -------------------------------------------------------------- No place to go
Line 284  sub handler { Line 413  sub handler {
 # ----------------- The program must come past this point to untie the big hash  # ----------------- The program must come past this point to untie the big hash
       untie(%hash);        untie(%hash);
 # --------------------------------------------------------- Store position info  # --------------------------------------------------------- Store position info
               $cachehash{$startoutmap}{'last_direction'}=$direction;                $cachehash{$startoutmap}{'last_direction'}=[$direction,'notasymb'];
               foreach my $thismap (keys %cachehash) {                foreach my $thismap (keys(%cachehash)) {
                  &Apache::lonnet::symblist($thismap,%{$cachehash{$thismap}});    my $mapnum=$cachehash{$thismap}->{'mapnum'};
     delete($cachehash{$thismap}->{'mapnum'});
     &Apache::lonnet::symblist($thismap,
       %{$cachehash{$thismap}});
       }        }
 # ============================================== Do not return before this line  # ============================================== Do not return before this line
               if ($redirecturl) {                if ($redirecturl) {
 # ----------------------------------------------------- There is a URL to go to  # ----------------------------------------------------- There is a URL to go to
 # ------------------------------------------------- Check for critical messages    if ($direction eq 'forward') {
   if ((time-$ENV{'user.criticalcheck.time'})>300) {                       &Apache::lonnet::linklog($currenturl,$redirecturl);
                      my @what=&Apache::lonnet::dump  
                                   ('critical',$ENV{'user.domain'},  
                                               $ENV{'user.name'});  
                      if ($what[0]) {  
                 if (($what[0] ne 'con_lost') &&   
                             ($what[0]!~/^error\:/)) {  
                    $redirecturl='/adm/email?critical=display';  
                         }  
                      }  
                      &Apache::lonnet::appenv('user.criticalcheck.time'=>time);  
   }    }
     if ($direction eq 'back') {
   $r->content_type('text/html');                       &Apache::lonnet::linklog($redirecturl,$currenturl);
                   $r->header_out(Location =>     }
                                 'http://'.$ENV{'HTTP_HOST'}.$redirecturl);  # ------------------------------------- Check for and display critical messages
                     my ($redirect, $url) = &Apache::loncommon::critical_redirect(300);
                     unless ($redirect) { 
                         $url=&Apache::lonnet::absolute_url().$redirecturl;
         $url = &add_get_param($url, { 'symb' => $redirectsymb});
                     }
     &Apache::loncommon::content_type($r,'text/html');
                     $r->header_out(Location => $url);
                   return REDIRECT;                    return REDIRECT;
       } else {        } else {
 # --------------------------------------------------------- There was a problem  # --------------------------------------------------------- There was a problem
                   $r->content_type('text/html');                    &Apache::loncommon::content_type($r,'text/html');
                   $r->send_http_header;                    $r->send_http_header;
     my %lt=&Apache::lonlocal::texthash('title' => 'End of Sequence',
        'explain' =>
        'You have reached the end of the sequence of materials.',
        'back' => 'Go Back',
        'nav' => 'Course Contents',
        'wherenext' =>
        'There are several possibilities of where to go next',
        'pick' =>
        'Please click on the the resource you intend to access',
        'titleheader' => 'Title',
        'type' => 'Type');
                     if (&Apache::loncommon::course_type() eq 'Community') {
                         $lt{'nav'} = &mt('Community Contents');
                     }
                   if ($#possibilities>0) {                    if ($#possibilities>0) {
         my $start_page=
     &Apache::loncommon::start_page('Multiple Resources');
                      $r->print(<<ENDSTART);                       $r->print(<<ENDSTART);
 <head><title>Choose Next Location</title></head>  $start_page
 <body bgcolor="#FFFFFF">  <h3>$lt{'wherenext'}</h3>
 <h1>LON-CAPA</h1>  
 There are several possibilities of where to go next.  
 <p>  <p>
 Please click on the the resource you intend to access:  $lt{'pick'}:
 <p>  <p>
 <table border=2>  <table border="2">
 <tr><th>Title</th><th>Type</th></tr>  <tr><th>$lt{'titleheader'}</th><th>$lt{'type'}</th></tr>
 ENDSTART  ENDSTART
                      foreach (@possibilities) {                       foreach my $id (@possibilities) {
                         $r->print(                          $r->print(
                               '<tr><td><a href="'.                                '<tr><td><a href="'.
                               $multichoicehash{'src_'.$_}.'?symb=' .    &add_get_param($multichoicehash{'src_'.$id},
                                   Apache::lonnet::escape($multichoicehash{'symb_'.$_}).'">'.   {'symb' =>
                               $multichoicehash{'title_'.$_}.        $multichoicehash{'symb_'.$id},
                               '</a></td><td>'.$multichoicehash{'type_'.$_}.    }).'">'.
                                 $multichoicehash{'title_'.$id}.
                                 '</a></td><td>'.$multichoicehash{'type_'.$id}.
       '</td></tr>');        '</td></tr>');
                      }                       }
                      $r->print('</table></body></html>');                       $r->print('</table>');
      return OK;  
                   } else {                    } else {
                      $r->print(<<ENDNONE);                        $r->print(
 <head><title>Choose Next Location</title></head>                            &Apache::loncommon::start_page('No Resource')
 <body bgcolor="#FFFFFF">                           .'<h2>'.$lt{'title'}.'</h2>'
 <img src="/adm/lonIcons/lonlogos.gif" align=right>                           .'<p>'.$lt{'explain'}.'</p>');
 <h1>Sorry!</h1>                    }
 <h2>Next resource could not be identified.</h2>                    $r->print(
 <h3>You probably are at the beginning or the end of the course.</h3>                        &Apache::lonhtmlcommon::actionbox(
 </body>                            ['<a href="/adm/flip?postdata=return:">'.$lt{'back'}.'</a></li>',
 </html>                             '<a href="/adm/navmaps">'.$lt{'nav'}.'</a></li>'
 ENDNONE                            ])
                      return OK;                       .&Apache::loncommon::end_page());
          }                    return OK;
      }        }
   } else {    } else {
 # ------------------------------------------------- Problem, could not tie hash  # ------------------------------------------------- Problem, could not tie hash
               $ENV{'user.error.msg'}="/adm/flip:bre:0:1:Course Data Missing";                $env{'user.error.msg'}="/adm/flip:bre:0:1:Course Data Missing";
               return HTTP_NOT_ACCEPTABLE;                 return HTTP_NOT_ACCEPTABLE; 
           }            }
       } else {        } else {
 # ---------------------------------------- No, could not determine where we are  # ---------------------------------------- No, could not determine where we are
          $r->internal_redirect('/adm/ambiguous');    $r->internal_redirect('/adm/ambiguous');
             return OK;
       }        }
   } else {    } else {
 # -------------------------- Class was not initialized or page fliped strangely  # -------------------------- Class was not initialized or page fliped strangely
       $ENV{'user.error.msg'}="/adm/flip:bre:0:0:Choose Course";        $env{'user.error.msg'}="/adm/flip:bre:0:0:Choose Course";
       return HTTP_NOT_ACCEPTABLE;         return HTTP_NOT_ACCEPTABLE; 
   }     } 
 }  }
Line 369  ENDNONE Line 514  ENDNONE
 1;  1;
 __END__  __END__
   
   =pod
   
   =head1 NAME
   
   Apache::lonpageflip
   
   =head1 SYNOPSIS
   
   Deals with forward, backward, and other page flips.
   
   This is part of the LearningOnline Network with CAPA project
   described at http://www.lon-capa.org.
   
   =head1 OVERVIEW
   
   (empty)
   
   =head1 SUBROUTINES
   
   =over cleanup()
   
   =item addrid()
   
   =item fullmove()
   
   =item hash_src()
   
   =item move()
   
   =item get_next_possible_move()
   
   =item first_accessible_resource()
   
   =item handler()
   
   =back
   
   =cut
   
   
   
Removed from v.1.32  
changed lines
  Added in v.1.87

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
500 Internal Server Error

Internal Server Error

The server encountered an internal error or misconfiguration and was unable to complete your request.

Please contact the server administrator at root@localhost to inform them of the time this error occurred, and the actions you performed just before this error.

More information about this error may be available in the server error log.